anchor.diff:                     Ar = length(Cas),
                      Ann = line_file_anno(Li, Sta),
                      case get_fbinding(Fun, Ar, En) of
  -                       {yes,M,F} ->             %Import
  +                       {yes,M,F} ->             %BIF or import
                              {ann_c_call(Ann, c_atom(M), c_atom(F), Cas),Sta};
                          {yes,Name} ->
                              %% Might have been renamed, use real function name.
  
positive.code:                 false ->
                      case lfe_internal:is_erl_bif(Name, Ar) of
                          true ->                 %Auto-imported Erlang BIF
  			    {yes,erlang,Name};
                          false -> no
                      end
              end
  
negative.code:     [['when'|Ts]|Body].
  
  %% comp_let(VarBindings, Body, Env, L, State) -> {c_let()|c_case(),State}.
  %%  Compile a let expr. First evaluate all the value expressions in
  %%  parallel so they don't inherit variables, then build nested cases
  %%  to do matching optimising case where value bound to variable. Use
  %%  nested cases so match fail only give one value. Probably not worth
  %%  the effort as optimiser would do it.
  
  comp_let(Vbs, B, Env, L, St0) ->
      {Cvs,Ces,Cms,St1} = comp_let_vbs(Vbs, Env, L, St0),
      {Cb,St2} = comp_let_body(Cms, B, add_vbindings(Cvs, Env), L, St1),
      %% Build nesting let which evaluates expressions first.
      {ann_c_let([L], Cvs, ann_c_values([L], Ces), Cb),St2}.
  
  comp_let_vbs(Vbs, Env, L, St) ->
      Fun = fun ([V,E], {Cvs,Ces,Cms,St0}) when is_atom(V) ->
                    {Ce,St1} = comp_expr(E, Env, L, St0),
                    {[c_var(V)|Cvs],[Ce|Ces],Cms,St1};
                ([P,E], {Cvs,Ces,Cms,St0}) ->
                    {V,St1} = new_var(St0),
                    {Ce,St2} = comp_expr(E, Env, L, St1),
                    {[c_var(V)|Cvs],[Ce|Ces],[{P,[],V}|Cms],St2};
                ([P,['when'|G],E], {Cvs,Ces,Cms,St0}) ->
                    {V,St1} = new_var(St0),
                    {Ce,St2} = comp_expr(E, Env, L, St1),
                    {[c_var(V)|Cvs],[Ce|Ces],[{P,G,V}|Cms],St2}
            end,
      lists:foldr(Fun, {[],[],[],St}, Vbs).
  
  comp_let_body([{P,G,V}|Cms], B, Env0, L, St0) ->
      Cv = c_var(V),
      {Cp,Pvs,Vts,St1} = pattern(P, L, St0),
      Env1 = add_vbindings(Pvs, Env0),
      {Cg,St2} = comp_guard(Vts ++ G, Env1, L, St1),
      {Cb,St3} = comp_let_body(Cms, B, Env1, L, St2),
      Cf = let_fail(Cv, L, St3),
      {ann_c_case([L], Cv, [ann_c_clause([L], [Cp], Cg, Cb),Cf]),St3};
  comp_let_body([], B, Env, L, St0) ->
      {Cb,St1} = comp_body(B, Env, L, St0),
      {Cb,St1}.
  
  let_fail(Cv, L, St) ->
      fail_clause([Cv], c_tuple([c_atom(badmatch),Cv]), [], L, St).
  
  %% comp_let_function(FuncBindngs, Body, Env, Line, State) ->
  %%      {c_letrec(),State}.
  