anchor.diff:  from_lit_list(Es) -> [ from_lit(E) || E <- Es ].
   
   -record(to, {vc=0                           %Variable counter
  -        }).
  +            }).
   
   to_expr(E, L) ->
       {Le,_} = to_expr(E, L, orddict:new(), #to{}),
  
positive.code:     {[F,Le|Lfs],Vt2,St2};
  from_rec_fields([], Vt, St) -> {[],Vt,St}.
  
  %% from_bitsegs(Segs, VarTable, State) -> {Segs,VarTable,State}.
  
  from_bitsegs([{bin_element,_,Seg,Size,Type}|Segs], Vt0, St0) ->
      {S,Vt1,St1} = from_bitseg(Seg, Size, Type, Vt0, St0),
      {Ss,Vt2,St2} = from_bitsegs(Segs, Vt1, St1),
      {[S|Ss],Vt2,St2};
  from_bitsegs([], Vt, St) -> {[],Vt,St}.
  
  %% So it won't get confused with strings.
  from_bitseg({integer,_,I}, default, default, Vt, St) -> {I,Vt,St};
  from_bitseg({integer,_,I}, Size, Type, Vt0, St0) ->
      {Lsize,Vt1,St1} = from_bitseg_size(Size, Vt0, St0),
      {[I|from_bitseg_type(Type) ++ Lsize],Vt1,St1};
  from_bitseg({float,_,F}, Size, Type, Vt0, St0) ->
      {Lsize,Vt1,St1} = from_bitseg_size(Size, Vt0, St0),
      {[F|from_bitseg_type(Type) ++ Lsize],Vt1,St1};
  from_bitseg({string,_,S}, Size, Type, Vt0, St0) ->
      {Lsize,Vt1,St1} = from_bitseg_size(Size, Vt0, St0),
      {[S|from_bitseg_type(Type) ++ Lsize],Vt1,St1};
  from_bitseg(E, Size, Type, Vt0, St0) ->
      {Le,Vt1,St1} = from_expr(E, Vt0, St0),
      {Lsize,Vt2,St2} = from_bitseg_size(Size, Vt1, St1),
      {[Le|from_bitseg_type(Type) ++ Lsize],Vt2,St2}.
  
  from_bitseg_size(default, Vt, St) -> {[],Vt,St};
  from_bitseg_size(Size, Vt0, St0) ->
      {Ssize,Vt1,St1} = from_expr(Size, Vt0, St0),
      {[[size,Ssize]],Vt1,St1}.
  
  from_bitseg_type(default) -> [];
  from_bitseg_type(Ts) ->
      map(fun ({unit,U}) -> [unit,U]; (T) -> T end, Ts).
  
  %% from_map_pairs(MapFields, VarTable, State) -> {Pairs,VarTable,State}.
  
  from_map_pairs([{_,_,Key,Val}|Ps], Vt0, St0) ->
      {Lk,Vt1,St1} = from_expr(Key, Vt0, St0),
      {Lv,Vt2,St2} = from_expr(Val, Vt1, St1),
      {Lps,Vt3,St3} = from_map_pairs(Ps, Vt2, St2),
      {[Lk,Lv|Lps],Vt3,St3};
  from_map_pairs([], Vt, St) -> {[],Vt,St}.
  
  %% split_map_pairs(MapFields) -> {ExactFields,AssocFields}.
  
  split_map_pairs(Ps) ->
      Split = fun ({map_field_exact,_,_,_}=F, {Es,As}) -> {[F|Es],As};
                  ({map_field_assoc,_,_,_}=F, {Es,As}) -> {Es,[F|As]}
              end,
      lists:foldr(Split, {[],[]},Ps).
  
  new_from_var(#from{vc=C}=St) ->
      V = list_to_atom(lists:concat(["---",C,"---"])),
      {V,St#from{vc=C+1}}.
  
  new_from_vars(N, St) -> new_from_vars(N, St, []).
  
negative.code:             {{var,L,V},orddict:store(V, V, Vt),St0}
      end.
  
  to_pat_map_pairs([K,V|Ps], L, Vt0, St0) ->
      {Ek,Vt1,St1} = to_pat(K, L, Vt0, St0),
      {Ev,Vt2,St2} = to_pat(V, L, Vt1, St1),
      {Eps,Vt3,St3} = to_pat_map_pairs(Ps, L, Vt2, St2),
      {[{map_field_exact,L,Ek,Ev}|Eps],Vt3,St3};
  to_pat_map_pairs([], _, Vt, St) -> {[],Vt,St}.
  
  %% to_pat_bitsegs(Segs, LineNumber, VarTable, State) -> {Segs,State}.
  %% This gives a verbose value, but it is correct.
  
  