anchor.diff:          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})->
  
positive.code: 
  
  %###########################
  parseCase(ReturnAtom,Params,{c_case, _, {c_var,_,Var}, Clauses})->
      parseCase(ReturnAtom,Params,{c_case, a, {c_values,a,[{c_var,a,Var}]}, Clauses});
  
  parseCase(ReturnAtom,Params,{c_case, _, {c_values,_,Vars}, Clauses})->
      {UnboundVars,CaseClauses} = parseCaseClauses(ReturnAtom,Params, Vars, Clauses),
      case UnboundVars of
          [] -> CaseClauses;
          _  -> assembleSequence(
                  estree:variable_declaration(
                      tupleList_getVars_2(maps:to_list(maps:from_list(UnboundVars))),
                      <<"let">>),
                  CaseClauses)
      end;
  
  parseCase(ReturnAtom,Params,{c_case, _, {c_apply,_,{c_var,_,Fun},Args}, Clauses})->
      case Fun of
  
negative.code: 
  
  parseCaseClauses(ReturnAtom,Params, Vars, [])->
      [];
  parseCaseClauses(ReturnAtom,Params, Vars, [{c_clause,_,Match,Evaluate,Consequent}|Clauses])->
      % {UnboundVars,ElseClauses} = parseCaseClauses(ReturnAtom,Params, Vars, Clauses),%alternate
      ElseClauses = parseCaseClauses(ReturnAtom,Params, Vars, Clauses),%alternate
      case ElseClauses of
          [] -> ElseClausesActual = null;
          _  -> ElseClausesActual = ElseClauses
      end,
      % {lists:append(declaratorsFromList(Match),UnboundVars),
       estree:if_statement(
          assembleCaseCondition(Params,Vars,Match,Evaluate),%test
          estree:block_statement(%consequent
  