anchor.diff:  	    false -> Forms;
   	    true  -> erl_expand_records:module(Forms, [])
   	end,
  -    Dict = parse_to_dict(Forms2),
  +    Dict = parse_to_map(Forms2),
       ArgsA = erl_parse:abstract(Args, 0),
       Anno = a0(),
       Call = {call,Anno,{atom,Anno,main},[ArgsA]},
  
positive.code:     [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.
  
  code_handler(local, [file], _, File) ->
      File;
  code_handler(Name, Args, Dict, File) ->
      %%io:format("code handler=~p~n",[{Name, Args}]),
      Arity = length(Args),
      case dict:find({local,Name,Arity}, Dict) of
          {ok, Cs} ->
              LF = {value,fun(I, J) -> code_handler(I, J, Dict, File) end},
              case erl_eval:match_clause(Cs, Args,erl_eval:new_bindings(),LF) of
                  {Body, Bs} ->
                      eval_exprs(Body, Bs, LF, none, none);
  
negative.code:                     erlang:error({function_clause,[{local,Name,Args}]})
              end;
          error ->
              case maps:find({remote,{Name,Arity}}, Map) of
                  {ok, Mod} ->
                      %% io:format("Calling:~p~n",[{Mod,Name,Args}]),
                      apply(Mod, Name, Args);
  