anchor.diff:      do_exception_with_heap_frag(Bin, Sizes);
   do_exception_with_heap_frag(_, []) -> ok.
   
  +line_numbers(Config) when is_list(Config) ->
  +    {'EXIT',{{case_clause,bad_tag},
  +	     [{?MODULE,line1,2,
  +	       [{file,"fake_file.erl"},{line,3}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch line1(bad_tag, 0)),
  +    {'EXIT',{badarith,
  +	     [{?MODULE,line1,2,
  +	       [{file,"fake_file.erl"},{line,5}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch line1(a, not_an_integer)),
  +    {'EXIT',{{badmatch,{ok,1}},
  +	     [{?MODULE,line1,2,
  +	       [{file,"fake_file.erl"},{line,7}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch line1(a, 0)),
  +    {'EXIT',{crash,
  +	     [{?MODULE,crash,1,
  +	       [{file,"fake_file.erl"},{line,14}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch line1(a, 41)),
  +
  +    ModFile = ?MODULE_STRING++".erl",
  +    [{?MODULE,maybe_crash,1,[{file,"call.erl"},{line,28}]},
  +     {?MODULE,call1,0,[{file,"call.erl"},{line,14}]},
  +     {?MODULE,close_calls,1,[{file,"call.erl"},{line,5}]},
  +     {?MODULE,line_numbers,1,[{file,ModFile},{line,_}]}|_] =
  +	close_calls(call1),
  +    [{?MODULE,maybe_crash,1,[{file,"call.erl"},{line,28}]},
  +     {?MODULE,call2,0,[{file,"call.erl"},{line,18}]},
  +     {?MODULE,close_calls,1,[{file,"call.erl"},{line,6}]},
  +     {?MODULE,line_numbers,1,[{file,ModFile},{line,_}]}|_] =
  +	close_calls(call2),
  +    [{?MODULE,maybe_crash,1,[{file,"call.erl"},{line,28}]},
  +     {?MODULE,call3,0,[{file,"call.erl"},{line,22}]},
  +     {?MODULE,close_calls,1,[{file,"call.erl"},{line,7}]},
  +     {?MODULE,line_numbers,1,[{file,ModFile},{line,_}]}|_] =
  +	close_calls(call3),
  +    no_crash = close_calls(other),
  +
  +    <<0,0>> = build_binary1(16),
  +    {'EXIT',{badarg,
  +	     [{?MODULE,build_binary1,1,
  +	       [{file,"bit_syntax.erl"},{line,72503}]},
  +	      {?MODULE,line_numbers,1,
  +	       [{file,ModFile},{line,_}]}|_]}} =
  +	(catch build_binary1(bad_size)),
  +
  +    <<7,1,2,3>> = build_binary2(8, <<1,2,3>>),
  +    {'EXIT',{badarg,
  +	     [{?MODULE,build_binary2,2,
  +	       [{file,"bit_syntax.erl"},{line,72507}]},
  +	      {?MODULE,line_numbers,1,
  +	       [{file,ModFile},{line,_}]}|_]}} =
  +	(catch build_binary2(bad_size, <<>>)),
  +    {'EXIT',{badarg,
  +	     [{erlang,bit_size,[bad_binary],[]},
  +	      {?MODULE,build_binary2,2,
  +	       [{file,"bit_syntax.erl"},{line,72507}]},
  +	      {?MODULE,line_numbers,1,
  +	       [{file,ModFile},{line,_}]}|_]}} =
  +	(catch build_binary2(8, bad_binary)),
  +
  +    {'EXIT',{function_clause,
  +	     [{?MODULE,do_call_abs,[y,y],
  +	       [{file,"gc_bif.erl"},{line,18}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch do_call_abs(y, y)),
  +    {'EXIT',{badarg,
  +	     [{erlang,abs,[[]],[]},
  +	      {?MODULE,do_call_abs,2,
  +	       [{file,"gc_bif.erl"},{line,19}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch do_call_abs(x, [])),
  +
  +    {'EXIT',{{badmatch,"42"},
  +	     [{MODULE,applied_bif_1,1,[{file,"applied_bif.erl"},{line,5}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch applied_bif_1(42)),
  +
  +    {'EXIT',{{badmatch,{current_location,
  +			{?MODULE,applied_bif_2,0,
  +			 [{file,"applied_bif.erl"},{line,9}]}}},
  +	     [{MODULE,applied_bif_2,0,[{file,"applied_bif.erl"},{line,10}]},
  +	      {?MODULE,line_numbers,1,_}|_]}} =
  +	(catch applied_bif_2()),
  +
  +    ok.
  +
   id(I) -> I.
   
   -file("odd_even.erl", 1).			%Line 1
  
positive.code: 	 init_per_group/2,end_per_group/2, 
  	 badmatch/1, pending_errors/1, nil_arith/1,
           stacktrace/1, nested_stacktrace/1, raise/1, gunilla/1, per/1,
  	 exception_with_heap_frag/1]).
  
  -export([bad_guy/2]).
  
  -include_lib("test_server/include/test_server.hrl").
  -import(lists, [foreach/2]).
  
negative.code: 
  odd(N) when is_integer(N), N > 1, (N rem 2) == 1 ->
      even(N-1)++[N].				%Line 6
  
  %%
  %% If the compiler removes redundant line instructions (any
  %% line instruction with the same location as the previous),
  %% and the loader also removes line instructions before
  %% tail-recursive calls to external functions, then the
  %% badmatch exception in line 7 below will be reported as
  %% occurring in line 6.
  %%
  %% That means that any removal of redundant line instructions
  %% must all be done in the compiler OR in the loader.
  %%
  -file("fake_file.erl", 1).			%Line 1
  line1(Tag, X) ->				%Line 2
      case Tag of					%Line 3
  	a ->
  	    Y = X + 1,				%Line 5
  	    Res = id({ok,Y}),			%Line 6
  	    ?MODULE:crash({ok,42} = Res);	%Line 7
  	b ->
  	    x = id(x),				%Line 9
  	    ok					%Line 10
      end.					%Line 11
  
  crash(_) ->					%Line 13
      erlang:error(crash).			%Line 14
  
  -file("call.erl", 1).				%Line 1
  close_calls(Where) ->				%Line 2
      put(where_to_crash, Where),			%Line 3
      try
  	call1(),				%Line 5
  	call2(),				%Line 6
  	call3(),				%Line 7
  	no_crash				%Line 8
      catch error:crash ->
  	    erlang:get_stacktrace()		%Line 10
      end.					%Line 11
  
  call1() ->					%Line 13
      maybe_crash(call1),				%Line 14
      ok.						%Line 15
  
  call2() ->					%Line 17
      maybe_crash(call2),				%Line 18
      ok.						%Line 19
  
  call3() ->					%Line 21
      maybe_crash(call3),				%Line 22
      ok.						%Line 23
  
  maybe_crash(Name) ->				%Line 25
      case get(where_to_crash) of			%Line 26
  	Name ->
  	    erlang:error(crash);		%Line 28
  	_ ->
  	    ok					%Line 30
      end.
  
  -file("bit_syntax.erl", 72500).			%Line 72500
  build_binary1(Size) ->				%Line 72501
      id(42),					%Line 72502
      <<0:Size>>.					%Line 72503
  
  build_binary2(Size, Bin) ->			%Line 72505
      id(0),					%Line 72506
      <<7:Size,Bin/binary>>.			%Line 72507
  
  -file("gc_bif.erl", 17).
  do_call_abs(x, Arg) ->				%Line 18
      abs(Arg).					%Line 19
  
  %% Make sure a BIF that is applied does not leave the p->cp
  %% set (and thus generating an extra entry on the stack).
  
  -file("applied_bif.erl", 1).
  %% Explicit apply.
  applied_bif_1(I) ->				%Line 3
      L = apply(erlang, integer_to_list, [I]),	%Line 4
      fail = L,					%Line 5
      ok.						%Line 6
  %% Implicit apply.
  applied_bif_2() ->				%Line 8
      R = process_info(self(), current_location),	%Line 9
      fail = R,					%Line 10
      ok.						%Line 11
  