anchor.diff:      %%io:format("Recursive term A = ~p\n", [A]),
       %%io:format("Recursive term B = ~p\n", [B]),
   
  -    ?CHECK({true,false} =:=  case do_cmp(A, B, false) of
  +    do_cmp(A, B),
  +
  +    A2 = copy_term(A),
  +    ?CHECK(A == A2, {A,A2}),
  +    ?CHECK(0 =:= cmp(A, A2, false), {A,A2}),
  +
  +    B2 = copy_term(B),
  +    ?CHECK(B == B2, {B,B2}),
  +    ?CHECK(0 =:= cmp(B, B2, false), {B,B2}),
  +    ok.
  +
  +do_cmp(A, B) ->
  +    ?CHECK({true,false} =:=  case cmp(A, B, false) of
   				 -1 -> {A<B, A>=B};
   				 0 -> {A==B, A/=B};
   				 1 -> {A>B, A=<B}
   			     end,
  -	   {A,B}),
  -    A2 = copy_term(A),
  -    ?CHECK(A == A2, {A,A2}),
  -    ?CHECK(0 =:= cmp(A, A2, false), {A,A2}),
  -
  -    B2 = copy_term(B),
  -    ?CHECK(B == B2, {B,B2}),
  -    ?CHECK(0 =:= cmp(B, B2, false), {B,B2}),
  -    ok.
  -
  -do_cmp(A, B, Exact) ->
  -    C = cmp(A, B, Exact),
  -    C.
  +	   {A,B}).
   
   %% Generate two terms {A,B} that may only differ
   %% at float vs integer types.
  
positive.code:     -1;
  cmp_others(F, I, true) when is_float(F), is_integer(I) ->
      1;
  cmp_others(T1, T2, _) ->
      case {T1<T2, T1==T2} of
  	{true,false} -> -1;
  
negative.code:     %%io:format("Keys to use: ~p\n", [Terms]),
      Pairs = lists:map(fun(K) -> list_to_tuple([{K,V} || V <- Terms]) end, Terms),
      lists:foreach(fun(Size) ->
  			  MapGen = fun() -> map_gen(Pairs, Size) end,
  			  repeat(100, fun do_compare/1, [MapGen, MapGen])
  		  end,
  		  lists:seq(1,length(Terms))),
      ok.
  
  atoms_compare() ->
      Atoms = [true, false, ok, '', ?MODULE, list_to_atom(id("a new atom"))],
      Pairs = lists:map(fun(K) -> list_to_tuple([{K,V} || V <- Atoms]) end,
                        Atoms),
      lists:foreach(
        fun(Size) ->
                M1 = map_gen(Pairs, Size),
                M2 = map_gen(Pairs, Size),
                %%io:format("Atom maps to compare: ~p AND ~p\n", [M1, M2]),
                do_cmp(M1, M2)
        end,
        lists:seq(1,length(Atoms))),
      ok.
  
  numeric_keys(N) ->
  