anchor.diff:      {['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.
  +%%  Expand comparison test strictly forcing evaluation of all
  +%%  arguments. Note that single argument version may need special
  +%%  casing.
   
   exp_comp([A], _, St) ->            %Force evaluation
  -    {['let',[['_',A]],?Q(true)],St};
  +    {[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,_} = mapfoldl(fun ([V,_], Acc) -> {exp_bif(Op, [Acc,V]),V} end,
  -                      hd(hd(Ls)), tl(Ls)),
  +    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
  
positive.code:     {['progn'|Pfs1],Env1,St1};
  pass_form(['eval-when-compile'|Ewcs0], Env0, St0) ->
      {Env1,St1} = pass_ewc(Ewcs0, Env0, St0),
      {['progn'],Env1,St1};			%Must return a valid form
  pass_form(['define-macro'|Def], Env0, St0) ->
      case pass_define_macro(Def, Env0, St0) of
          {yes,Env1,St1} ->
              {['progn'],Env1,St1};               %Must return a valid form
          no ->
  	    St1 = add_error({bad_form,macro}, St0),
              {['progn'],Env0,St1}		%Must return a valid form
      end;
  pass_form(F, Env, St0) ->
      %% First expand enough to test top form, if so process again.
  
negative.code:     end;
  function_arity(_) -> no.
  
  %% pass_eval_set(Args, Env, State) -> {Env,State}.
  %%  Evaluate the set form.
  
  pass_eval_set(Args, Env, St) ->
      try
          pass_eval_set_1(Args, Env, St)
      catch
          _:_ ->                                  %Catch everything
              {Env,add_error({bad_env_form,'set'}, St)}
      end.
  
  pass_eval_set_1(Args, Env, St0) ->
      case exp_form(['let'|Args], Env, St0) of
          {['let',Pat,G,Exp],St1} ->
              pass_eval_set_1(Pat, [G], Exp, Env, St1);
          {['let',Pat,Exp],St1} ->
              pass_eval_set_1(Pat, [], Exp, Env, St1)
      end.                                        %Just crash here
  
  pass_eval_set_1(Pat, Guard, Exp, Env0, St) ->
      Val = lfe_eval:expr(Exp, Env0),
      {ok,_,Bs} = lfe_eval:match_when(Pat, Val, Guard, Env0),
      Env1 = foldl(fun ({N,V}, E) -> add_vbinding(N, V, E) end, Env0, Bs),
      {Env1,St}.
  
  %% pass_expand_expr(Expr, Env, State, ExpandFlag) ->
  %%     {yes,Exp,State} | {no,State}.
  