anchor.diff:  	{false,false} -> 1
       end.
   
  -map_gen(MapMod, Pairs, Size) ->
  +map_gen(Pairs, Size) ->
       {_,L} = lists:foldl(fun(_, {Keys, Acc}) ->
   				KI = random:uniform(size(Keys)),
   				K = element(KI,Keys),
  
positive.code:     Seed = erlang:now(),
      io:format("seed = ~p\n", [Seed]),
      random:seed(Seed),
      repeat(100, fun(_) -> float_int_compare(maps) end, []),
      repeat(100, fun(_) -> float_int_compare(hashmap) end, []),
      repeat(100, fun(_) -> recursive_compare() end, []),
      ok.
  
  float_int_compare(MapMod) ->
      Terms = numeric_keys(3),
      %%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(MapMod, list_to_tuple(Pairs), Size) end,
  			  repeat(100, fun do_compare/1, [MapMod, MapGen, MapGen])
  		  end,
  		  lists:seq(1,length(Terms))),
      ok.
  
negative.code:     P ! T,
      receive R -> R end.
  
  do_compare([Gen1, Gen2]) ->
      M1 = Gen1(),
      M2 = Gen2(),
      %%io:format("Maps to compare: ~p AND ~p\n", [M1, M2]),
      C = (M1 < M2),
      Erlang = maps_lessthan(M1, M2),
      C = Erlang,
      ?CHECK(M1==M1, M1),
  
      %% Change one key from int to float (or vice versa) and check compare
      ML1 = maps:to_list(M1),
      {K1,V1} = lists:nth(random:uniform(length(ML1)), ML1),
      case K1 of
  	I when is_integer(I) ->
  	    case maps:find(float(I),M1) of
  		error ->
  		    M1f = maps:remove(I, maps:put(float(I), V1, M1)),
  		    ?CHECK(M1f > M1, [M1f, M1]);
  		_ -> ok
  	    end;
  
  	F when is_float(F), round(F) == F ->
  	    case maps:find(round(F),M1) of
  		error ->
  		    M1i = maps:remove(F, maps:put(round(F), V1, M1)),
  		    ?CHECK(M1i < M1, [M1i, M1]);
  		_ -> ok
  	    end;
  