anchor.diff:      [M|format_message(F, Es)];
   format_message(_, []) -> [].
   
  -parse_to_dict(L) -> parse_to_dict(L, dict:new()).
  -
  -parse_to_dict([{function,_,Name,Arity,Clauses}|T], Dict0) ->
  -    Dict = dict:store({local, Name,Arity}, Clauses, Dict0),
  -    parse_to_dict(T, Dict);
  -parse_to_dict([{attribute,_,import,{Mod,Funcs}}|T], Dict0) ->
  -    Dict = lists:foldl(fun(I, D) ->
  -                               dict:store({remote,I}, Mod, D)
  -                       end, Dict0, Funcs),
  -    parse_to_dict(T, Dict);
  -parse_to_dict([_|T], Dict) ->
  -    parse_to_dict(T, Dict);
  -parse_to_dict([], Dict) ->
  -    Dict.
  +parse_to_map(L) -> parse_to_map(L, maps:new()).
  +
  +parse_to_map([{function,_,Name,Arity,Clauses}|T], Map0) ->
  +    Map = maps:put({local, Name,Arity}, Clauses, Map0),
  +    parse_to_map(T, Map);
  +parse_to_map([{attribute,_,import,{Mod,Funcs}}|T], Map0) ->
  +    Map = lists:foldl(fun(I, D) ->
  +                              maps:put({remote,I}, Mod, D)
  +                       end, Map0, Funcs),
  +    parse_to_map(T, Map);
  +parse_to_map([_|T], Map) ->
  +    parse_to_map(T, Map);
  +parse_to_map([], Map) ->
  +    Map.
   
   code_handler(local, [file], _, File) ->
       File;
  -code_handler(Name, Args, Dict, File) ->
  +code_handler(Name, Args, Map, File) ->
       %%io:format("code handler=~p~n",[{Name, Args}]),
       Arity = length(Args),
  -    case dict:find({local,Name,Arity}, Dict) of
  +    case maps:find({local,Name,Arity}, Map) of
           {ok, Cs} ->
  -            LF = {value,fun(I, J) -> code_handler(I, J, Dict, File) end},
  +            LF = {value,fun(I, J) -> code_handler(I, J, Map, File) end},
               case erl_eval:match_clause(Cs, Args,erl_eval:new_bindings(),LF) of
                   {Body, Bs} ->
                       eval_exprs(Body, Bs, LF, none, none);
  
positive.code:                     erlang:error({function_clause,[{local,Name,Args}]})
              end;
          error ->
              case dict:find({remote,{Name,Arity}}, Dict) of
                  {ok, Mod} ->
                      %% io:format("Calling:~p~n",[{Mod,Name,Args}]),
                      apply(Mod, Name, Args);
  
negative.code: 	    false -> Forms;
  	    true  -> erl_expand_records:module(Forms, [])
  	end,
      Dict = parse_to_map(Forms2),
      ArgsA = erl_parse:abstract(Args, 0),
      Anno = a0(),
      Call = {call,Anno,{atom,Anno,main},[ArgsA]},
  