anchor.diff:  exp_bif(B, As) -> [call,?Q(erlang),?Q(B)|As].
   
   %% exp_args(Args, State) -> {LetBinds,State}.
  -%% Expand Args into a list of let bindings suitable for a let* or
  -%% nested lets to force sequential left-to-right evaluation.
  +%%  Expand Args into a list of let bindings suitable for a let* or
  +%%  nested lets to force sequential left-to-right evaluation.
   
   exp_args(As, St) ->
       mapfoldl(fun (A, St0) -> {V,St1} = new_symb(St0), {[V,A],St1} end, St, As).
   
   %% exp_arith(Args, Op, State) -> {Exp,State}.
  -%% Expand arithmetic call strictly forcing evaluation of all
  -%% arguments.  Note that single argument version may need special
  -%% casing.
  +%%  Expand arithmetic call strictly forcing evaluation of all
  +%%  arguments.  Note that single argument version may need special
  +%%  casing.
   
   exp_arith([A], Op, St) -> {exp_bif(Op, [A]),St};
   exp_arith([A,B], Op, St) -> {exp_bif(Op, [A,B]),St};
  
positive.code: %% This was not a call to a predefined macro.
  exp_predef(_, _, _) -> no.
  
  %% exp_comp_macro(Module, Name, Args, Env, State) ->
  %%     {yes,From,State} | {no,State}.
  %%  Expand macro in Module if it exists. Try to be smart and avoid
  %%  loading a module, and trying to load a module, unneccessarily.
  
  exp_comp_macro(M, F, As, Env, St) ->
      case erlang:function_exported(M, 'LFE-EXPAND-USER-MACRO', 2) of
  	true ->
  	    case M:'LFE-EXPAND-USER-MACRO'([F|As], Env) of
  		{yes,Exp} -> {yes,Exp,St};
  		no -> {no,St}
  	    end;
  	false ->
  	    %% Slightly faster code:ensure_loaded/1.
  	    case erlang:module_loaded(M) of
  		true -> {no,St};	        %Module loaded but no macros
  		false ->
  		    Unl = St#mac.unloadable,
  		    case lists:member(M, Unl) of
  			true -> {no,St};	%Can't load this module
  			false ->
  			    %% Try loading file and try again.
  			    case code:load_file(M) of
  				{module,_} -> exp_comp_macro(M, F, As, Env, St);
  				{error,_} ->
  				    %% Echo modules we couldn't load
  				    lfe_io:format("ecp: ~p\n", [{M,Unl}]),
  				    St1 = St#mac{unloadable=[M|Unl]},
  				    {no,St1}
  			    end
  		    end
  	    end
      end.
  
  %% exp_qlc(LC, Opts, Env, State) -> {yes,Expansion,State}.
  
negative.code:     {['let*',Ls,B],St1}.
  
  %% exp_comp(Args, Op, State) -> {Exp,State}.
  %%  Expand comparison test strictly forcing evaluation of all
  %%  arguments. Note that single argument version may need special
  %%  casing.
  
  exp_comp([A], _, St) ->            %Force evaluation
      {[progn,A,?Q(true)],St};
  exp_comp([A,B], Op, St) -> {exp_bif(Op, [A,B]),St};
  exp_comp(As, Op, St0) ->
      {Ls,St1} = exp_args(As, St0),
      Ts = op_pairs(Ls, Op),
      {['let*',Ls,['andalso'|Ts]],St1}.
  
  op_pairs([[V,_]|Ls], Op) ->
      element(1, mapfoldl(fun ([V,_], Acc) -> {exp_bif(Op, [Acc,V]),V} end,
  			V, Ls)).
  
  %% exp_nequal(Args, Op, State) -> {Exp,State}.
  %%  Expand not equal test strictly forcing evaluation of all
  %%  arguments. We need to compare all the arguments with each other.
  
  exp_nequal([A], _, St) ->            %Force evaluation
      {[progn,A,?Q(true)],St};
  exp_nequal([A,B], Op, St) -> {exp_bif(Op, [A,B]),St};
  exp_nequal(As, Op, St0) ->
      {Ls,St1} = exp_args(As, St0),
      Ts = op_all_pairs(Ls, Op),
      {['let*',Ls,['andalso'|Ts]],St1}.
  
  op_all_pairs([], _) -> [];
  op_all_pairs([[V,_]|Ls], Op) ->
      [ exp_bif(Op, [V,V1]) || [V1,_] <- Ls] ++ op_all_pairs(Ls, Op).
  
  %% exp_append(Args) -> Expansion.
  %%  Expand ++ in such a way as to allow its use in patterns. There are
  