anchor.diff:        cerl:c_let([Tmp], CerlFun, cerl:c_apply(Tmp, CerlActuals));
       N when N =< 10 ->
         cerl:c_call(cerl:c_atom('es_apply'), cerl:c_atom('apply'),
  -		  [CerlFun | CerlActuals]);
  +                  [CerlFun | CerlActuals]);
       _ ->
         ListOfActuals = make_list(CerlActuals),
         cerl:c_call(cerl:c_atom('es_apply'), cerl:c_atom('applyN'),
  -		  [CerlFun, ListOfActuals])
  +                  [CerlFun, ListOfActuals])
     end.
   
   make_list([]) -> cerl:c_nil();
   make_list([H | T]) -> cerl:c_cons(H, make_list(T)).
   
   translate_define(Var, Expr) ->
  -  %% Synthesize `es_gloenv:enter_var(Var, Expr)'.
  +  %% Synthesize "es_gloenv:enter_var(Var, Expr)".
     cerl:c_call(cerl:c_atom('es_gloenv'), cerl:c_atom('enter_var'),
  -	      [cerl:c_atom(Var), translate_expr(Expr)]).
  +              [cerl:c_atom(Var), translate_expr(Expr)]).
   
   translate_glovar(Var) ->
  -  %% Synthesize `es_gloenv:get_var(Var)'.
  +  %% Synthesize "es_gloenv:get_var(Var)".
     cerl:c_call(cerl:c_atom('es_gloenv'), cerl:c_atom('get_var'), [cerl:c_atom(Var)]).
   
   translate_if(Pred, Then, Else) ->
  -  %% Synthesize `case Pred of false -> Else; _ -> Then end'.
  +  %% Synthesize "case Pred of false -> Else; _ -> Then end".
     cerl:c_case(translate_expr(Pred),
  -	      [cerl:c_clause([cerl:c_atom('false')], translate_expr(Else)),
  -	       cerl:c_clause([wildpat()], translate_expr(Then))]).
  +              [cerl:c_clause([cerl:c_atom('false')], translate_expr(Else)),
  +               cerl:c_clause([wildpat()], translate_expr(Then))]).
   
   translate_lambda(Formals, Body) ->
     assemble_lambda(translate_formals(Formals), translate_expr(Body)).
  
positive.code: assemble_letrec(Bindings, Body) ->
    FVars = [FVar || {FVar, _Formals, _Body} <- Bindings],
    cerl:c_letrec([assemble_letrec_binding(FVars, Binding) || Binding <- Bindings],
  		assemble_subst(FVars, Body)).
  
  assemble_letrec_binding(FVars, {FVar, Formals, Body}) ->
    {FVar, assemble_lambda(Formals, assemble_subst(FVars, Body))}.
  
negative.code:   Var1 = cerl:c_var(1), % '_1'
    Var2 = cerl:c_var(2), % '_2'
    cerl:c_fun([Var1],
               cerl:c_case(cerl:c_case(Var1,
                                       [cerl:c_clause([cerl:c_tuple_skel([cerl:c_atom('$argv'), Var2])], Var2),
                                        cerl:c_clause([wildpat()], cerl:c_cons(Var1, cerl:c_nil()))]),
                           [cerl:c_clause([ListPattern], Body),
                            cerl:c_clause([wildpat()],
                                          cerl:c_call(cerl:c_atom('erlang'), cerl:c_atom('error'), [cerl:c_atom('badarity')]))])).
  
  assemble_lambda_1(Var, Body) -> % an arity-1 lambda must reject a varargs parameter
    %% Synthesize:
    %% fun (Var) -> case Var of {'$argv', _} -> erlang:error(badarity); _ -> Body end
    cerl:c_fun([Var],
               cerl:c_case(Var,
                           [cerl:c_clause([cerl:c_tuple_skel([cerl:c_atom('$argv'), wildpat()])],
                                          cerl:c_call(cerl:c_atom('erlang'), cerl:c_atom('error'), [cerl:c_atom('badarity')])),
                            cerl:c_clause([wildpat()], Body)])).
  
  assemble_lambda_N(Vars, Body) -> % any fixed arity except 1
    cerl:c_fun(Vars, Body).
  