anchor.diff:  module(#c_module{anno=A,name=M,exports=Es,attrs=As,defs=Fs}, _Options) ->
       Kas = attributes(As),
       Kes = map(fun (#c_var{name={_,_}=Fname}) -> Fname end, Es),
  -    St0 = #kern{lit=dict:new()},
  +    St0 = #kern{},
       {Kfs,St} = mapfoldl(fun function/2, St0, Fs),
       {ok,#k_mdef{anno=A,name=M#c_literal.val,exports=Kes,attributes=Kas,
   		body=Kfs ++ St#kern.funs},lists:sort(St#kern.ws)}.
  
positive.code: 		  {union(Used0, Used),union(New0, New)} end,
  	  {[],[]}, Ps).
  
  %% handle_literal(Literal, Anno) -> Kernel
  %%  Examine the literal. Complex (heap-based) literals such as lists,
  %%  tuples, and binaries should be kept as literals and put into the constant pool.
  %%
  %%  (If necessary, this function could be extended to go through the literal
  %%  and convert huge binary literals to bit syntax expressions. We don't do that
  %%  because v3_core does not produce huge binary literals, and the optimizations in
  %%  sys_core_fold don't do much optimizations of binaries. IF THAT CHANGE IS MADE,
  %%  ALSO CHANGE sys_core_dsetel.)
  
  handle_literal(#c_literal{anno=A,val=V}) ->
      case V of
  	[_|_] ->
  	    #k_literal{anno=A,val=V};
  	[] ->
  	    #k_nil{anno=A};
  	V when is_tuple(V) ->
  	    #k_literal{anno=A,val=V};
  	V when is_bitstring(V) ->
  	    #k_literal{anno=A,val=V};
  	V when is_integer(V) ->
  	    #k_int{anno=A,val=V};
  	V when is_float(V) ->
  	    #k_float{anno=A,val=V};
  	V when is_atom(V) ->
  	    #k_atom{anno=A,val=V}
      end.
  
  make_list(Es) ->
      foldr(fun(E, Acc) ->
   		  #c_cons{hd=E,tl=Acc}
  
negative.code:     expr(Fun, Sub, St);
  expr(#c_var{anno=A,name=V}, Sub, St) ->
      {#k_var{anno=A,name=get_vsub(V, Sub)},[],St};
  expr(#c_literal{anno=A,val=V}, _Sub, St) ->
      Klit = case V of
  	       [] ->
  		   #k_nil{anno=A};
  	       V when is_integer(V) ->
  		   #k_int{anno=A,val=V};
  	       V when is_float(V) ->
  		   #k_float{anno=A,val=V};
  	       V when is_atom(V) ->
  		   #k_atom{anno=A,val=V};
  	       _ ->
  		   #k_literal{anno=A,val=V}
  	   end,
      {Klit,[],St};
  expr(#c_cons{anno=A,hd=Ch,tl=Ct}, Sub, St0) ->
      %% Do cons in two steps, first the expressions left to right, then
      %% any remaining literals right to left.
  