anchor.diff:      {Em,St1} = to_expr(Map, L, Vt, St0),
       {Eks,St2} = to_exprs(Keys, L, Vt, St1),
       Fun = fun (K, {F,St}) ->
  -		  to_remote_call({atom,L,maps}, {atom,L,remove}, [K,F], L, St)
  -	  end,
  +                  to_remote_call({atom,L,maps}, {atom,L,remove}, [K,F], L, St)
  +          end,
       lists:foldl(Fun, {Em,St2}, Eks).
   
   %% to_map_pairs(Pairs, LineNumber, VarTable, State) -> {Fields,State}.
  
positive.code: to_pat_map_pairs([], _, Pvs, Vt, St) -> {[],Pvs,Vt,St}.
  
  %% to_pat_bitsegs(Segs, LineNumber, VarTable, State) -> {Segs,State}.
  %% This gives a verbose value, but it is correct.
  
  to_pat_bitsegs(Ss, L, Pvs, Vt, St) ->
      Fun = fun (S, Pvs0, Vt0, St0) -> to_pat_bitseg(S, L, Pvs0, Vt0, St0) end,
      mapfoldl3(Fun, Pvs, Vt, St, Ss).
  
  to_pat_bitseg([Val|Specs]=F, L, Pvs, Vt, St) ->
      case is_posint_list(F) of
          true ->
              {Size,Type} = to_bitspecs([], L),
              to_pat_bin_element(F, Size, Type, L, Pvs, Vt, St);
          false ->
              {Size,Type} = to_bitspecs(Specs, L),
              to_pat_bin_element(Val, Size, Type, L, Pvs, Vt, St)
      end;
  to_pat_bitseg(Val, L, Pvs, Vt, St) ->
      {Size,Type} = to_bitspecs([], L),
      to_pat_bin_element(Val, Size, Type, L, Pvs, Vt, St).
  
  to_pat_bin_element(Val, Size, {Type,Unit,Sign,End}, L, Pvs0, Vt0, St0) ->
      {Eval,Pvs1,Vt1,St1} = to_pat(Val, L, Pvs0, Vt0, St0),
      {Esiz,Pvs2,Vt2,St2} = to_pat_bin_size(Size, L, Pvs1, Vt1, St1),
      {{bin_element,L,Eval,Esiz,[Type,to_bin_unit(Unit),Sign,End]},Pvs2,Vt2,St2}.
  
  to_pat_bin_size(all, _, Pvs, Vt, St) -> {default,Pvs,Vt,St};
  to_pat_bin_size(default, _, Pvs, Vt, St) -> {default,Pvs,Vt,St};
  
negative.code:     %% This does all the work for us.
      erl_parse:abstract(Lit, L).
  
  %% mapfoldl2(Fun, Acc1, Acc2, List) -> {List,Acc1,Acc2}.
  %%  Like normal mapfoldl but with 2 accumulators.
  
  