anchor.diff:              estree:block_statement(
                   encapsulateExpressions(
                       listCheck(
  -                        parseFunctionBody(return,Params,Elem)
  +                        parseNode(return,Params,Elem)
                       )
                   )
               ),
           false),
  -    []);
  -    % parseFunctionBody(ReturnAtom,Params,Elem);
  -
  -parseFunctionBody(return,Params,{c_primop,_,{_,_,Type},_Details})->
  +    []).
  +    % parseNode(ReturnAtom,Params,Elem);
  +
  +parsePrimop(return,Params,{c_primop,_,{_,_,Type},_Details})->
       % io:format("        Error? ~p~n~p~n", [Type,Details]),
  -    estree:error(atom_to_list(Type),"TODO Errors dont parse nicely\\n",estree:literal(<<"Message">>));
  +    estree:error(atom_to_list(Type),"TODO Errors dont parse nicely\\n",estree:literal(<<"Message">>)).
       % io:format("",[]);
   
   
   %c_letrec appears to represent list comprehension.
  -parseFunctionBody(ReturnAtom,Params,{c_letrec,_,[Func],Apply})->
  -% parseFunctionBody(ReturnAtom,Params,{c_letrec,_,[{{_, _, {FunctionName, Arity}}, {_c_fun, _, ParamNames, Body}}],Apply})->
  +parseLetrec(ReturnAtom,Params,{c_letrec,_,[Func],Apply})->
  +% parseNode(ReturnAtom,Params,{c_letrec,_,[{{_, _, {FunctionName, Arity}}, {_c_fun, _, ParamNames, Body}}],Apply})->
   %     {Id,F} = parseFunction({{a, [], {'listComp', Arity}}, {c_fun, [], ParamNames, Body}}),
       {Id,F} = parseFunction(Func),
       assembleSequence(
  
positive.code:     parseFunctionCase(ReturnAtom,Params,
          estree:call_expression(
              estree:identifier(atom_to_binary(Fun_Actual,utf8)),
              lists:map(fun(T)->parseFunctionBody(noreturn,Params,T) end,Args)
          ),
          Clauses
      );
  
  parseFunctionBody(ReturnAtom,Params,{c_case, _, {c_call,_,{c_literal,_,Module},{c_literal,_,FunctionName},Args}, Clauses})->
      parseFunctionCase(ReturnAtom,Params,
          estree:call_expression(
              estree:member_expression(estree:identifier(atom_to_binary(Module,utf8)),estree:identifier(atom_to_binary(FunctionName,utf8)),false),
              lists:map(fun(T)->parseFunctionBody(noreturn,Params,T) end,Args)
          ),
          Clauses
      );
  
  parseFunctionBody(_,Params,T)->
      io:format("Unrecognised Token in function body: ~p~n", [T]).
  
  
  parseFunctionCase(ReturnAtom,Params,FuncCall, Clauses)->
  
negative.code:     [Val | tupleList_getVars_2(Body)];
  tupleList_getVars_2([{_, Val, _} | Body])->
      [Val | tupleList_getVars_2(Body)].
  
  
  tuple_getVar_1({V})->V;
  tuple_getVar_1({V,_})->V;
  tuple_getVar_1({V,_,_})->V;
  tuple_getVar_1({V,_,_,_})->V;
  tuple_getVar_1({V,_,_,_,_})->V;
  tuple_getVar_1({V,_,_,_,_,_})->V;
  tuple_getVar_1({V,_,_,_,_,_,_})->V.
  
  
  declaratorsFromList(List)->
  