anchor.diff:      io:format("seed = ~p\n", [rand:export_seed()]),
       repeat(100, fun(_) -> float_int_compare() end, []),
       repeat(100, fun(_) -> recursive_compare() end, []),
  +    repeat(10, fun(_) -> atoms_compare() end, []),
       ok.
   
   float_int_compare() ->
  
positive.code:     %%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
  				 -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.
  
  %% Generate two terms {A,B} that may only differ
  %% at float vs integer types.
  
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) ->
  