anchor.diff:  %% (unclear if this test case will actually prove anything on
   %% a modern computer with lots of memory).
   spawn_with_binaries(Config) when is_list(Config) ->
  -    ?line L = lists:duplicate(2048, 42),
  -    ?line TwoMeg = lists:duplicate(1024, L),
  -    ?line Fun = fun() -> spawn(?MODULE, binary_owner, [list_to_binary(TwoMeg)]),
  +    L = lists:duplicate(2048, 42),
  +    TwoMeg = lists:duplicate(1024, L),
  +    Fun = fun() -> spawn(?MODULE, binary_owner, [list_to_binary(TwoMeg)]),
   			 receive after 1 -> ok end end,
  -    ?line Iter = case test_server:purify_is_running() of
  +    Iter = case test_server:purify_is_running() of
   		     true -> 10;
   		     false -> 150
   		 end,
  -    ?line test_server:do_times(Iter, Fun),
  +    test_server:do_times(Iter, Fun),
       ok.
   
   binary_owner(Bin) when is_binary(Bin) ->
  
positive.code: 							 ok
  						 end
  					 end),
  	    ?line receive {suspend_me, Suspendee} -> ok end,
  	    ?line erlang:suspend_process(Suspendee),
  	    ?line erlang:system_flag(multi_scheduling, unblock),
  	    
  	    ?line [{status,suspended},
  		   {current_function,{erlang,processes_trap,2}}]
  		= process_info(Suspendee, [status, current_function]),
  
  	    ?line ok = do_processes_bif_test(WantReds, WillTrap, Processes),
  	    
  	    ?line erlang:resume_process(Suspendee),
  	    ?line receive {Suspendee, done, _} -> ok end,
  	    ?line unlink(Suspendee),
  	    ?line exit(Suspendee, bang)
      end,
      case get(processes_bif_testcase_comment) of
  	undefined -> ?line ok;
  	Comment -> ?line {comment, Comment}
      end.
      
  do_processes_bif_test(WantReds, DieTest, Processes) ->
      ?line Tester = self(),
      ?line SpawnProcesses = fun (Prio) ->
  				   spawn_opt(?MODULE,
  					     do_processes,
  					     [WantReds],
  					     [link, {priority, Prio}])
  			   end,
      ?line Cleaner = spawn_link(fun () ->
  				       process_flag(trap_exit, true),
  				       Tester ! {cleaner_alive, self()},
  				       processes_bif_cleaner()
  			       end),
      ?line receive {cleaner_alive, Cleaner} -> ok end,
      try
  	?line DoIt = make_ref(),
  	?line GetGoing = make_ref(),
  	?line {NoTestProcs, TestProcs} = spawn_initial_hangarounds(Cleaner),
  	?line ?t:format("Testing with ~p processes~n", [NoTestProcs]),
  	?line SpawnHangAround = fun () ->
  					spawn(?MODULE,
  					      hangaround,
  					      [Cleaner, new_hangaround])
  				end,
  	?line Killer = spawn_opt(fun () ->
  					 Splt = NoTestProcs div 10,
  					 {TP1, TP23} = lists:split(Splt,
  								   TestProcs),
  					 {TP2, TP3} = lists:split(Splt, TP23),
  					 erlang:system_flag(multi_scheduling,
  							    block),
  					 Tester ! DoIt,
  					 receive GetGoing -> ok end,
  					 erlang:system_flag(multi_scheduling,
  							    unblock),
  					 SpawnProcesses(high),
  					 lists:foreach(
  					   fun (P) ->
  						   SpawnHangAround(),
  						   exit(P, bang)
  					   end,
  					   TP1),
  					 SpawnProcesses(high),
  					 erlang:yield(),
  					 lists:foreach(
  					   fun (P) ->
  						   SpawnHangAround(),
  						   exit(P, bang)
  					   end,
  					   TP2),
  					 SpawnProcesses(high),
  					 lists:foreach(
  					   fun (P) ->
  						   SpawnHangAround(),
  						   exit(P, bang)
  					   end,
  					   TP3)
  				 end,
  				 [{priority, high}, link]),
  	?line receive DoIt -> ok end,
  	?line process_flag(priority, low),
  	?line SpawnProcesses(low),
  	?line erlang:yield(),
  	?line process_flag(priority, normal),
  	?line CorrectProcs0 = erts_debug:get_internal_state(processes),
  	?line Killer ! GetGoing,
  	?line erts_debug:set_internal_state(reds_left, WantReds),
  	?line Procs0 = processes(),
  	?line Procs = lists:sort(Procs0),
  	?line CorrectProcs = lists:sort(CorrectProcs0),
  	?line LengthCorrectProcs = length(CorrectProcs),
  	?line ?t:format("~p = length(CorrectProcs)~n", [LengthCorrectProcs]),
  	?line true = LengthCorrectProcs > NoTestProcs,
  	?line case CorrectProcs =:= Procs of
  		  true ->
  		      ?line ok;
  		  false ->
  		      ?line processes_unexpected_result(CorrectProcs, Procs)
  	      end,
  	?line unlink(Killer),
  	?line exit(Killer, bang)
      after
  	unlink(Cleaner),
          exit(Cleaner, kill),
          %% Wait for the system to recover to a normal state...
  	wait_until_system_recover()
      end,
      ?line do_processes_bif_die_test(DieTest, Processes),
      ?line ok.
  
  
  do_processes_bif_die_test(false, _Processes) ->
      ?line ?t:format("Skipping test killing process executing processes/0~n",[]),
      ?line ok;
  do_processes_bif_die_test(true, Processes) ->
      ?line do_processes_bif_die_test(5, Processes);
  do_processes_bif_die_test(N, Processes) ->
      ?line ?t:format("Doing test killing process executing processes/0~n",[]),
      try
  	?line Tester = self(),
  	?line Oooh_Nooooooo = make_ref(),
  	?line {_, DieWhileDoingMon} = erlang:spawn_monitor(
  					fun () ->
  						Victim = self(),
  						spawn_opt(
  						  fun () ->
  							  exit(Victim, got_him)
  						  end,
  						  [link,
  						   {priority, max}]),
  						Tester ! {Oooh_Nooooooo,
  							  hd(Processes())},
  						exit(ohhhh_nooooo)
  					end),
  	?line receive
  		  {'DOWN', DieWhileDoingMon, _, _, Reason} ->
  		      case Reason of
  			  got_him -> ok;
  			  _ -> throw({kill_in_trap, Reason})
  		      end
  	      end,
  	?line receive
  		  {Oooh_Nooooooo, _} ->
  		      ?line throw({kill_in_trap, 'Oooh_Nooooooo'})
  	      after 0 ->
  		      ?line ok
  	      end,
  	?line PrcsCllrsSeqLen = 2*erlang:system_info(schedulers_online),
  	?line PrcsCllrsSeq = lists:seq(1, PrcsCllrsSeqLen),
  	?line ProcsCallers = lists:map(
  			       fun (_) ->
  				       spawn_link(
  					 fun () ->
  						 Tester ! hd(Processes())
  					 end)
  			       end,
  			       PrcsCllrsSeq),
  	?line erlang:yield(),
  	{ProcsCallers1, ProcsCallers2} = lists:split(PrcsCllrsSeqLen div 2,
  						     ProcsCallers),
  	?line process_flag(priority, high),
  	?line lists:foreach(
  		fun (P) ->
  			unlink(P),
  			exit(P, bang)
  		end,
  		lists:reverse(ProcsCallers2) ++ ProcsCallers1),
  	?line process_flag(priority, normal),
  	?line ok
      catch
  	throw:{kill_in_trap, R} when N > 0 ->
  	    ?t:format("Failed to kill in trap: ~p~n", [R]),
  
negative.code:     bump_big(R2, 16#08000000).
  
  bump_big(Prev, Limit) ->
      true = erlang:bump_reductions(100000), %Limited to CONTEXT_REDUCTIONS.
      case process_info(self(), reductions) of
  	      {reductions,Big} when is_integer(Big), Big > Limit ->
  		  erlang:garbage_collect(),
  		  io:format("~p\n", [Big]);
  	      {reductions,R} when is_integer(R), R > Prev ->
  		  bump_big(R, Limit)
  	  end,
  