anchor.diff:  
   % Compiles a given Erlang source file to a EStree ast
   erast2esast(AST) ->
  -    toksModule(AST).
  +    parseModule(AST).
   
   %Read the module token (first token)
  -toksModule({c_module, _A, {_, _, ModuleName}, Exports, _Attributes, Functions})->
  +parseModule({c_module, _A, {_, _, ModuleName}, Exports, _Attributes, Functions})->
       io:format("module: ~s ~n", [ModuleName]),
       io:format("    exports: ~p ~n", [tupleList_getVars_3(Exports)]),
  -    FormattedFunctions = toksFunctions(Functions),
  +    FormattedFunctions = parseFunctions(Functions),
       FormattedExports = lists:map(fun({N,A})->{atom_to_list(N),A} end,tupleList_getVars_3(Exports)),
       %io:format("~p~n~n~n~n~n~n", [FormattedFunctions]),
       esast:c_module(atom_to_list(ModuleName),FormattedExports,FormattedFunctions);
       
       
  -toksModule(T)->
  +parseModule(T)->
       io:format("Unrecognised Token in module section: ~p", [T]).
   
   
   
   %Split functions apart
  -toksFunctions(Functions)->
  -    lists:map(fun(X)->toksFunc(X) end,Functions).
  +parseFunctions(Functions)->
  +    lists:map(fun(X)->parseFunction(X) end,Functions).
   
   %Read a function
  -toksFunc({{_, _, {FunctionName, Arity}}, {_, [compiler_generated], _, _}})->
  +parseFunction({{_, _, {FunctionName, Arity}}, {_, [compiler_generated], _, _}})->
       {atom_to_list(FunctionName)++"/"++integer_to_list(Arity),esast:functionExpression(null,[],esast:blockStatement([esast:emptyStatement()]),false)};
  -toksFunc({{_, _, {FunctionName, Arity}}, {_, _, ParamNames, Body}})->
  +parseFunction({{_, _, {FunctionName, Arity}}, {_, _, ParamNames, Body}})->
       {atom_to_list(FunctionName)++"/"++integer_to_list(Arity),esast:functionExpression(
           null,
           tupleListToIdentifierList(ParamNames),
           esast:blockStatement(
               encapsulateExpressions(
                   listCheck(
  -                    toksFuncBody(return,Body)
  +                    parseFunctionBody(return,Body)
                   )
               )
           ),
  
positive.code: 
  %Parse the function body
  
  toksFuncBody(return,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Params})->
      %io:format("        call function ~s:~s(", [Module, FunctionName]),
      %io:format("~p)~n", [tupleList_getVars_3(Params)]);
      esast:returnStatement(toksFuncBody(noreturn,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Params}));
  
  
  
  
negative.code: 
  
  tupleListToIdentifierList(List)->
      lists:map(fun({c_var,[],A})->parseFunctionBody(noreturn,{c_var,[],A}) end,List).
  
  
  
  