anchor.diff:  
   comp_guard([], _, _, St) -> {c_atom(true),St};  %The empty guard
   comp_guard(Gts, Env, L, St0) ->
  -    {Ce,St1} = comp_gtest(Gts, Env, L, St0),    %Guard expression
  +    {Ce,St1} = comp_guard_tests(Gts, Env, L, St0),    %Guard expression
       %% Can hard code the rest!
       Cv = c_var('Try'),
       Evs = [c_var('T'),c_var('R')],              %Why only two?
       False = c_atom(false),                      %Exception returns false
       {ann_c_try([L], Ce, [Cv], Cv, Evs, False),St1}.
   
  -%% comp_gtest(GuardTests, Env, Line, State) -> {CoreTest,State}.
  +%% comp_guard_tests(GuardTests, Env, Line, State) -> {CoreTest,State}.
   %%  Compile a guard test, making sure it returns a boolean value. We
   %%  do this in a naive way by always explicitly comparing the result
   %%  to 'true' and letting the optimiser clean this up. Ignore errors.
   
  -%% comp_gtest([[quote,Bool]=Test], _, _, St) when is_boolean(Bool) ->
  -%%     io:format("We hit it: ~p\n", [Test]),
  -%%     {c_atom(Bool),St};
  -%% comp_gtest([[Op|As]=Test], Env, L, St0) ->
  -%%     Ar = length(As),
  -%%     case erl_internal:bool_op(Op, Ar) orelse
  -%%     erl_internal:comp_op(Op, Ar) orelse
  -%%     erl_internal:type_test(Op, Ar) of
  -%%     true ->
  -%%         io:format("We hit it: ~p\n", [Test]),
  -%%         comp_gexpr(Test, Env, L, St0);
  -%%     false ->
  -%%         Call = fun (Cas, _, L, St) ->
  -%%                Ann = line_file_anno(L, St),
  -%%                {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), Cas),St}
  -%%            end,
  -%%         comp_gargs([Test,?Q(true)], Call, Env, L, St0)
  -%%     end;
  -comp_gtest(Ts, Env, L, St0) ->            %Not a bool test or boolean
  -    %% Generate an explicit comparison with 'true' to give boolean.
  -    {Cg,St1} = comp_gbody(Ts, Env, L, St0),
  -    True = comp_lit(true),
  -    Call = fun (Cas, _, Li, St) ->
  -                   Ann = line_file_anno(Li, St),
  -                   {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), Cas),St}
  -           end,
  -    simple_seq([Cg,True], Call, Env, L, St1).
  -
  -%% comp_gbody(Body, Env, Line, State) -> {CoreBody,State}.
  -%% Compile a guard body into a sequence of logical and tests.
  -
  -comp_gbody([], _, _, St) -> {c_atom(true),St};
  -comp_gbody([T], Env, L, St) -> comp_gexpr(T, Env, L, St);
  -comp_gbody([T|Ts], Env, L, St) ->
  -    comp_gif(T, [progn|Ts], ?Q(false), Env, L, St).
  +comp_guard_tests(Gts, Env, Line, St0) ->
  +    {Gas,St1} = mapfoldl(fun (Gt, St) -> comp_guard_test(Gt, Env, Line, St) end,
  +                         St0, Gts),
  +    Ands = fun guard_ands/4,
  +    simple_seq(Gas, Ands, Env, Line, St1).
  +
  +guard_ands([Ga], _, _, St) -> {Ga,St};
  +guard_ands([G1,G2], _, Line, St) ->
  +    {ann_c_call([Line], c_atom(erlang), c_atom('and') , [G1,G2]), St};
  +guard_ands([G1,G2|Gas], Env, Line, St0) ->
  +    {Cv,St1} = new_c_var(Line, St0),
  +    {Gr,St2} = guard_ands([Cv|Gas], Env, Line, St1),
  +    And = ann_c_call([Line], c_atom(erlang), c_atom('and'), [G1,G2]),
  +    {ann_c_let([Line], [Cv], And, Gr),St2}.
  +
  +%% comp_guard_test(Test, Env, Line, State) -> {CoreTest,State}.
  +%%  Compile one test. We try to avoid generating an unnecessary true
  +%%  test by checking the test and only adding one when we know the
  +%%  test won't automatically return a boolean value.
  +
  +comp_guard_test([call,[quote,erlang],[quote,Op]|Args]=Test, Env, L, St) ->
  +    comp_guard_test_1(Test, Op, Args, Env, L, St);
  +comp_guard_test([Op|Args]=Test, Env, L, St) ->
  +    comp_guard_test_1(Test, Op, Args, Env, L, St).
  +
  +comp_guard_test_1(Test, Op, Args, Env, L, St0) ->
  +    Ar = length(Args),
  +    %% Check if this is a boolean test, else add a boolean test.
  +    case erl_internal:bool_op(Op, Ar) orelse
  +        erl_internal:comp_op(Op, Ar) orelse
  +        erl_internal:type_test(Op, Ar) of
  +        true ->                                 %It's already boolean
  +            comp_gexpr(Test, Env, L, St0);
  +        false ->                                %No it's not, then make it one
  +            Call = fun (Cas, _, Li, St) ->
  +                           Ann = [Li,compiler_generated],
  +                           {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), Cas),
  +                            St}
  +                   end,
  +            comp_gargs([Test,?Q(true)], Call, Env, L, St0)
  +    end.
   
   %% comp_gexpr(Expr, Env, Line, State) -> {CoreExpr,State}.
   
  
positive.code: forms(Forms, St0, Core0) ->
      %% Collect the module definition and functions definitions.
      {Fbs0,St1} = lfe_lib:proc_forms(fun collect_form/3, Forms, St0),
      %% Add predefined functions and definitions.
      Predefs = [{module_info,0},{module_info,1}],
      Mibs = [{module_info,
               [lambda,[],
                [call,?Q(erlang),?Q(get_module_info),?Q(St1#cg.mod)]],1},
              {module_info,
               [lambda,[x],
                [call,?Q(erlang),?Q(get_module_info),?Q(St1#cg.mod),x]],1}],
      %% The sum of all functions.
      Fbs1 = Fbs0 ++ Mibs,
      %% Make initial environment and set state.
  
negative.code:     {Ccs,St2} = comp_match_clauses(Cls, Env, L, St1),
      {Fvs,St3} = new_c_vars(Ar, L, St2),
      Cf = func_fail(Fvs, L, St3),
      Ann = line_file_anno(L, St3),
      Cb = ann_c_case(Ann, c_values(Cvs), Ccs ++ [Cf]),
      {ann_c_fun(Ann, Cvs, Cb),St3}.
  
  func_fail(Fvs, L, #cg{func=F}=St) ->
  