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:     {append_c_seq(Ce, Cb, L),St2};        %Flatten nested sequences
  comp_body([], _, _, St) -> {c_nil(),St}.  %Empty body returns []
  
  append_c_seq(#c_seq{body=B}=Cseq, Cb, L) ->
      Cseq#c_seq{body=append_c_seq(B, Cb, L)};
  append_c_seq(H, Cb, L) ->
      c_seq([L], H, Cb).
  
  %% comp_expr(Expr, Env, Line, State) -> {CoreExpr,State}.
  %% Compile an expression.
  
negative.code:     Ffun = fun ([Name,Def], St) -> comp_func(Name, Def, Env1, L, St) end,
      {Cfs,St1} = mapfoldl(Ffun, St0, Fbs),
      {Cb,St2} = comp_body(B, Env1, L, St1),
      {ann_c_letrec([L], Cfs, Cb),St2}.
  
  %% func_arity(FuncDef) -> Arity.
  %%  Return the arity of a function definition.
  