anchor.diff:      {[Et|Eqs],Vt1,St2};
   to_lc_quals([], _, Vt, St) -> {[],Vt,St}.
   
  -%% to_bitsegs(Segs, LineNumber, VarTable, State) -> {Segs,State}.
  -%% This gives a verbose value, but it is correct.
  -
  -to_bitsegs(Ss, L, Vt, St) ->
  -    Fun = fun (S, St0) -> to_bitseg(S, L, Vt, St0) end,
  -    mapfoldl(Fun, St, Ss).
  -
  -to_bitseg([Val|Specs]=F, L, Vt, St) ->
  -    case is_integer_list(F) of
  -        true ->
  -            {Size,Type} = to_bitspecs([]),
  -            to_bin_element(F, Size, Type, L, Vt, St);
  -        false ->
  -            {Size,Type} = to_bitspecs(Specs),
  -            to_bin_element(Val, Size, Type, L, Vt, St)
  -    end;
  -to_bitseg(Val, L, Vt, St) ->
  -    {Size,Type} = to_bitspecs([]),
  -    to_bin_element(Val, Size, Type, L, Vt, St).
  -
  -to_bin_element(Val, Size, {Type,Unit,Sign,End}, L, Vt, St0) ->
  -    {Eval,St1} = to_expr(Val, L, Vt, St0),
  -    {Esiz,St2} = to_bin_size(Size, L, Vt, St1),
  -    {{bin_element,L,Eval,Esiz,[Type,to_bin_unit(Unit),Sign,End]},St2}.
  -
  -to_bin_size(default, _, _, St) -> {default,St};
  -to_bin_size(undefined, _, _, St) -> {default,St};
  -to_bin_size(Size, L, Vt, St) -> to_expr(Size, L, Vt, St).
  -
  -to_bin_unit(default) -> default;
  -to_bin_unit(Unit) -> {unit,Unit}.
  -
  -%% to_bitspec(Specs) -> {Size,Type}.
  -%%  Get the error handling as we want it.
  -
  -to_bitspecs(Ss) ->
  -    case lfe_bits:get_bitspecs(Ss) of
  -        {ok,Sz,Ty} -> {Sz,Ty};
  -        {error,Error} -> erlang:error(Error)
  -    end.
  -
  -%% to_map_pairs(Pairs, LineNumber, VarTable, State) -> {Fields,State}.
  -
  -to_map_pairs([K,V|Ps], Field, L, Vt, St0) ->
  -    {Ek,St1} = to_expr(K, L, Vt, St0),
  -    {Ev,St2} = to_expr(V, L, Vt, St1),
  -    {Eps,St3} = to_map_pairs(Ps, Field, L, Vt, St2),
  -    {[{Field,L,Ek,Ev}|Eps],St3};
  -to_map_pairs([], _, _, _, St) -> {[],St}.
  -
  +%% new_to_var(State) -> {VarName, State}.
   new_to_var(#to{vc=C}=St) ->
       V = list_to_atom(lists:concat(["___",C,"___"])),
       {V,St#to{vc=C+1}}.
  
positive.code:     {V,St1} = new_from_var(St0),
      new_from_vars(N-1, St1, [V|Vs]);
  new_from_vars(0, St, Vs) -> {Vs,St}.
  
  from_pat({var,_,'_'}, Vt, St) -> {'_',[],Vt,St};    %Special case _
  from_pat({var,_,V}, Vt, St0) ->                     %Unquoted atom
  
negative.code: 
  to_lit_list(Ps, L) -> [ to_lit(P, L) || P <- Ps ].
  
  
  is_posint_list([I|Is]) when is_integer(I), I >= 0 ->
      is_posint_list(Is);
  is_posint_list([]) -> true;
  is_posint_list(_) -> false.
  
  %% mapfoldl2(Fun, Acc1, Acc2, List) -> {List,Acc1,Acc2}.
  %%  Like normal mapfoldl but with 2 accumulators.
  