anchor.diff:  verify_packed_regs([{Term, N}| T], Term, N) ->
       verify_packed_regs(T, Term, N-1);
   verify_packed_regs(L, Term, N) ->
  -    ?line ok = io:format("Expected [{~p, ~p}|T]; got\n~p\n", [Term, N, L]),
  -    ?line test_server:fail().
  +    ok = io:format("Expected [{~p, ~p}|T]; got\n~p\n", [Term, N, L]),
  +    test_server:fail().
   
   buildo_mucho(Config) when is_list(Config) ->
  -    ?line buildo_mucho_1(),
  +    buildo_mucho_1(),
       ok.
   
   buildo_mucho_1() ->
  
positive.code:     end.
  
  fconv(Config) when is_list(Config) ->
      ?line do_fconv(atom),
      ?line do_fconv(nil),
      ?line do_fconv(tuple_literal),
      ?line 3.0 = do_fconv(1.0, 2.0),
      ok.
  
  do_fconv(Type) ->
  
negative.code: %% Test three high register numbers in a put_list instruction
  %% (to test whether packing works properly).
  packed_registers(Config) when is_list(Config) ->
      PrivDir = ?config(priv_dir, Config),
      Mod = packed_regs,
      Name = filename:join(PrivDir, atom_to_list(Mod) ++ ".erl"),
  
      %% Generate a module which generates a list of tuples.
      %% put_list(A) -> [{A, 600}, {A, 999}, ... {A, 0}].
      Code = gen_packed_regs(600, ["-module("++atom_to_list(Mod)++").\n",
  				       "-export([put_list/1]).\n",
  				       "put_list(A) ->\n["]),
      ok = file:write_file(Name, Code),
  
      %% Compile the module.
      io:format("Compiling: ~s\n", [Name]),
      CompRc = compile:file(Name, [{outdir, PrivDir}, report]),
      io:format("Result: ~p\n",[CompRc]),
      {ok, Mod} = CompRc,
  
      %% Load it.
      io:format("Loading...\n",[]),
      LoadRc = code:load_abs(filename:join(PrivDir, atom_to_list(Mod))),
      {module,_Module} = LoadRc,
  
      %% Call it and verify result.
      Term = {a, b},
      L = Mod:put_list(Term),
      verify_packed_regs(L, Term, 600),
      ok.
  
  gen_packed_regs(0, Acc) ->
  