anchor.diff:  %%  literal as possible. This function will fail if the value is not
   %%  expressable as a literal (for instance, a pid).
   
  -comp_lit([H0|T0]) ->
  -    case {comp_lit(H0),comp_lit(T0)} of
  -        {#c_literal{anno=Ann,val=H},#c_literal{val=T}} ->
  -            c_lit(Ann, [H|T]);
  -        {H,T} -> c_cons(H, T)
  -    end;
  +comp_lit([H|T]) ->
  +    Ch = comp_lit(H),
  +    Ct = comp_lit(T),
  +    %% c_cons is smart and can handle head and tail both literals.
  +    c_cons(Ch, Ct);
   comp_lit([]) -> c_nil();
   comp_lit(T) when is_tuple(T) ->
       Es = comp_lit_list(tuple_to_list(T)),
  -    case is_lit_list(Es) of
  -        true -> c_lit(list_to_tuple(concrete_list(Es)));
  -        false -> c_tuple(Es)
  -    end;
  +    %% c_tuple is smart and can handle a list of literals.
  +    c_tuple(Es);
   comp_lit(A) when is_atom(A) -> c_atom(A);
   comp_lit(I) when is_integer(I) -> c_int(I);
   comp_lit(F) when is_float(F) -> c_float(F);
   comp_lit(Bin) when is_bitstring(Bin) ->
       Bits = comp_lit_bitsegs(Bin),
  -    c_binary([], Bits);
  +    ann_c_binary([], Bits);
   comp_lit(Map) when ?IS_MAP(Map) ->
       comp_lit_map(Map).
   
   comp_lit_list(Vals) -> [ comp_lit(V) || V <- Vals ].
   
  -is_lit_list(Es) -> all(fun (E) -> is_record(E, c_literal) end, Es).
  -
  -concrete_list([#c_literal{val=V}|T]) -> [V|concrete_list(T)];
  -concrete_list([]) -> [].
  +is_lit_list(Es) -> all(fun (E) -> is_literal(E) end, Es).
   
   comp_lit_bitsegs(<<B:8,Bits/bitstring>>) ->         %Next byte
       [c_byte_bitseg(B, 8)|comp_lit_bitsegs(Bits)];
  
positive.code:                    Ar = length(Cas),
                     {yes,M,F} = get_gbinding(Fun, Ar, En),
                     Ann = line_file_anno(Li, Sta),
                     {c_call(Ann, c_atom(M), c_atom(F), Cas),Sta}
             end,
      comp_gargs(As, Call, Env, L, St);
  comp_gexpr(Symb, _, _, St) when is_atom(Symb) ->
  
negative.code:         true ->
              %% Expand comp_let as we need to special case body.
              {Cf,St1} = comp_match_lambda(Cls, Env, L, St0),
              Cvs = fun_vars(Cf),
              Cb = fun_body(Cf),
              Efun = fun (E, St) -> comp_expr(E, Env, L, St) end,
              {Ces,St2} = mapfoldl(Efun, St1, As),
              {ann_c_let([L], Cvs, ann_c_values(Ces), Cb),St2};
          false ->                %Catch arg mismatch at runtime
              comp_funcall_1(F, As, Env, L, St0)
      end;
  