anchor.diff:  
   %Parse the function body
   
  -toksFuncBody(return,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Params})->
  +parseFunctionBody(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}));
  +    esast:returnStatement(parseFunctionBody(noreturn,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Params}));
   
   
   
  
positive.code: 
  
  
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'band'}, [L,R]})->
      esast:binaryExpression(atom_to_binary('&',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bor'}, [L,R]})->
      esast:binaryExpression(atom_to_binary('|',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bxor'}, [L,R]})->
      esast:binaryExpression(atom_to_binary('^',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bnot'}, [L]})->
      esast:unaryExpression(atom_to_binary('~',utf8),true,toksFuncBody(noreturn,L));
  
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'or'}, [L,R]})->
      esast:logicalExpression(atom_to_binary('||',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'and'}, [L,R]})->
      esast:logicalExpression(atom_to_binary('&&',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'not'}, [L]})->
      esast:unaryExpression(atom_to_binary('!',utf8),true,toksFuncBody(noreturn,L));
  
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'xor'}, [L,R]})->
      toksFuncBody(noreturn,{c_call, a, {a, a, erlang}, {a, a, 'or'}, [
              {c_call, a, {a, a, erlang}, {a, a, 'and'}, [L,{c_call, a, {a, a, erlang}, {a, a, 'not'}, [R]}]},
              {c_call, a, {a, a, erlang}, {a, a, 'and'}, [R,{c_call, a, {a, a, erlang}, {a, a, 'not'}, [L]}]}
          ]}
      );
  
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'div'}, [L,R]})->
      esast:callExpression(
           esast:memberExpression(esast:identifier(<<"Math">>),esast:identifier(<<"floor">>),false),
           [toksFuncBody(noreturn,{c_call, a, {b, c, erlang}, {d, e, '/'}, [L,R]})]
       );
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'rem'}, [L,R]})->
      esast:binaryExpression(atom_to_binary('%',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, '/='}, [L,R]})->
      esast:binaryExpression(atom_to_binary('!=',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, '=<'}, [L,R]})->
      esast:binaryExpression(atom_to_binary('<=',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  
  toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, FunctionName}, [L,R]})->
      esast:binaryExpression(atom_to_binary(FunctionName,utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  
  %Bodge job: external module calls
  %TODO: proper external module calls
  toksFuncBody(noreturn,{c_call, _, {_, _, io}, {_, _, format}, [T]})->
      esast:callExpression(
           esast:memberExpression(esast:identifier(<<"console">>),esast:identifier(<<"log">>),false),
           [toksFuncBody(noreturn,T)]
       );
  
  
  toksFuncBody(noreturn,{c_call, _, {_, _, _Module}, {_, _, _FunctionName}, _Params})->
      io:format("",[]);
  
  
  toksFuncBody(return,{c_values, _, _Values})->
      %io:format("~p~n", [tupleList_getVars_3(Values)]);
      io:format("",[]);
  
  toksFuncBody(return,{c_var, A, Var})->
      esast:returnStatement(toksFuncBody(noreturn,{c_var, A, Var}));
  toksFuncBody(noreturn,{c_var, _, Var})->
      esast:identifier(atom_to_binary(Var,utf8));
      %io:format("",[]);
  
  
  toksFuncBody(return,{c_seq, _, A, B})->
      assembleSequence(
          toksFuncBody(noreturn,A),
          toksFuncBody(return,B));
  toksFuncBody(noreturn,{c_seq, _, A, B})->
      assembleSequence(
          toksFuncBody(noreturn,A),
          toksFuncBody(noreturn,B));
  
  
  
  toksFuncBody(return,{c_let, _, [{_, _, _Variable}], _A, _B})->
      %io:format("        Let statement: ~s~n", [Variable]),
      %toksFuncBody(A),
      %toksFuncBody(B);
      io:format("",[]);
      
  % Is apply a local function call? Assignment from function? Assignment with pattern matching?
  toksFuncBody(return,{c_apply, _, {_,_,{_FName,_Arity}}, _Params})->
      %io:format("Call local function ~s(",[FName]),
      %io:format("~p)~n", [tupleList_getVars_3(Params)]);
      io:format("",[]);
  
  toksFuncBody(return,{c_apply, _, _A, _B})->
      %io:format("        Apply statement: ~n");
      io:format("",[]);
      
  toksFuncBody(return,{c_literal,_,Value})->
      esast:returnStatement(esast:literal(Value));
  toksFuncBody(_,{c_literal,_,Value})->
      esast:literal(Value);
  
  toksFuncBody(return,{c_tuple,_,_Values})->
      %io:format("        Tuple ~p~n", [tupleList_getVars_3(Values)]);
      io:format("",[]);
      
  toksFuncBody(return,{c_primop,_,{_,_,Type},_Details})->
      % io:format("        Error? ~p~n~p~n", [Type,Details]),
      esast:error(atom_to_list(Type),"TODO Errors dont parse nicely",esast:literal("Message"));
      % io:format("",[]);
      
  toksFuncBody(return,{c_case, _, _Condition, _Clauses})->
      %io:format("        case statement:"),
      %toksFuncBody(noreturn,Condition),
      %lists:map(fun({c_clause,_,MatchVals,_true,Body})->toksFuncBody(return,Body) end,Clauses).
      io:format("",[]);
      
  toksFuncBody(_,T)->
      io:format("Unrecognised Token in function body: ~p", [T]).
  
  assembleSequence(L,R) when is_list(L) and is_list(R)->
  
negative.code: 
  
  tupleListToIdentifierList(List)->
      lists:map(fun({c_var,[],A})->parseFunctionBody(noreturn,{c_var,[],A}) end,List).
  
  
  
  