anchor.diff:  
   %Parse the function body
   
  -parseFunctionBody(return,Params,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Parameters})->
  -    estree:return_statement(parseFunctionBody(noreturn,Params,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Parameters}));
  +
  +parseNode(ReturnAtom,Params,N)->
  +    case tuple_getVar_1(N) of
  +        c_call ->parseCall(ReturnAtom,Params,N);
  +        c_values ->parseValues(ReturnAtom,Params,N);
  +        c_var ->parseVar(ReturnAtom,Params,N);
  +        c_seq ->parseSeq(ReturnAtom,Params,N);
  +        c_let ->parseLet(ReturnAtom,Params,N);
  +        c_apply ->parseApply(ReturnAtom,Params,N);
  +        c_literal ->parseLiteral(ReturnAtom,Params,N);
  +        c_tuple ->parseTuple(ReturnAtom,Params,N);
  +        c_cons ->parseCons(ReturnAtom,Params,N);
  +        c_try ->parseTry(ReturnAtom,Params,N);
  +        c_primop ->parsePrimop(ReturnAtom,Params,N);
  +        c_letrec ->parseLetrec(ReturnAtom,Params,N);
  +        c_case ->parseCase(ReturnAtom,Params,N)
  +    end.
  +
  +
  +parseCall(return,Params,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Parameters})->
  +    estree:return_statement(parseCall(noreturn,Params,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Parameters}));
   
   
   
  
positive.code:         %     estree:block_statement(
          %         encapsulateExpressions(
          %             listCheck(
          %                 parseFunctionBody(return,tupleList_getVars_3(ParamNames),Body)
          %             )
          %         )
          %     ),
          %     true
          % ),
          parseFunctionBody(ReturnAtom,Params,Apply)
      );
  
  
  parseFunctionBody(ReturnAtom,Params,{c_case, _, {c_var,_,Var}, Clauses})->
      parseFunctionBody(ReturnAtom,Params,{c_case, a, {c_values,a,[{c_var,a,Var}]}, Clauses});
  
  parseFunctionBody(ReturnAtom,Params,{c_case, _, {c_values,_,Vars}, Clauses})->
      {UnboundVars,CaseClauses} = parseCaseClauses(ReturnAtom,Params, Vars, Clauses),
      case UnboundVars of
          [] -> CaseClauses;
  
negative.code:     parseFunctionCase(ReturnAtom,Params,
          estree:call_expression(
              estree:identifier(atom_to_binary(Fun_Actual,utf8)),
              lists:map(fun(T)->parseNode(noreturn,Params,T) end,Args)
          ),
          Clauses
      );
  
  parseCase(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)->parseNode(noreturn,Params,T) end,Args)
          ),
          Clauses
      ).
  
  
  parseFunctionCase(ReturnAtom,Params,FuncCall, Clauses)->
  