anchor.diff:  from_body([], Vt, St) -> {[],Vt,St}.
   
   from_expr_list(Es, Vt, St) -> mapfoldl2(fun from_expr/3, Vt, St, Es).
  +
  +%% 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_assocs(MapAssocs, VarTable, State) -> {Pairs,VarTable,State}.
  +
  +from_map_assocs([{_,_,Key,Val}|As], Vt0, St0) ->
  +    {Lk,Vt1,St1} = from_expr(Key, Vt0, St0),
  +    {Lv,Vt2,St2} = from_expr(Val, Vt1, St1),
  +    {Las,Vt3,St3} = from_map_assocs(As, Vt2, St2),
  +    {[Lk,Lv|Las],Vt3,St3};
  +from_map_assocs([], Vt, St) -> {[],Vt,St}.
  +
  +%% from_map_update(MapAssocs, CurrAssoc, CurrMap, VarTable, State) ->
  +%%     {Map,VarTable,State}.
  +%%  We need to be a bit cunning here and do everything left-to-right
  +%%  and minimize nested calls.
  +
  +from_map_update([{Assoc,_,Key,Val}|As], Curr, Map0, Vt0, St0) ->
  +    {Lk,Vt1,St1} = from_expr(Key, Vt0, St0),
  +    {Lv,Vt2,St2} = from_expr(Val, Vt1, St1),
  +    %% Check if can continue this mapping or need to start a new one.
  +    Map1 = if Assoc =:= Curr -> Map0 ++ [Lk,Lv];
  +              Assoc =:= map_field_assoc -> ['map-set',Map0,Lk,Lv];
  +              Assoc =:= map_field_exact -> ['map-update',Map0,Lk,Lv]
  +           end,
  +    from_map_update(As, Assoc, Map1, Vt2, St2);
  +%% from_map_update([{Assoc,_,Key,Val}|Fs], Assoc, Map0, Vt0, St0) ->
  +%%     {Lk,Vt1,St1} = from_expr(Key, Vt0, St0),
  +%%     {Lv,Vt2,St2} = from_expr(Val, Vt1, St1),
  +%%     from_map_update(Fs, Assoc, Map0 ++ [Lk,Lv], Vt2, St2);
  +%% from_map_update([{Assoc,_,Key,Val}|Fs], _, Map0, Vt0, St0) ->
  +%%     {Lk,Vt1,St1} = from_expr(Key, Vt0, St0),
  +%%     {Lv,Vt2,St2} = from_expr(Val, Vt1, St1),
  +%%     Op = if Assoc =:= map_field_assoc -> 'map-set';
  +%%             true -> 'map-update'
  +%%          end,
  +%%     from_map_update(Fs, Assoc, [Op,Map0,Lk,Lv], Vt2, St2);
  +from_map_update([], _, Map, Vt, St) -> {Map,Vt,St}.
   
   %% from_icrt_cls(Clauses, VarTable, State) -> {Clauses,VarTable,State}.
   %% from_icrt_cl(Clause, VarTable, State) -> {Clause,VarTable,State}.
  
positive.code: from_expr({'catch',_,E}, Vt0, St0) ->
      {Le,Vt1,St1} = from_expr(E, Vt0, St0),
      {['catch',Le],Vt1,St1};
  from_expr({match,_,P,E}, Vt0, St0) ->
      {Lp,Eqt,Vt1,St1} = from_pat(P, Vt0, St0),   %The pattern
      {Le,Vt2,St2} = from_expr(E, Vt1, St1),      %The expression
      {Lb,Vt3,St3} = from_expr(P, Vt2, St2),      %Pattern as value expression
      Leg = from_eq_tests(Eqt),                   %Implicit guard tests
      {['let',[[Lp,['when'|Leg],Le]],Lb],Vt3,St3};
  from_expr({op,_,Op,A}, Vt0, St0) ->
      {La,Vt1,St1} = from_expr(A, Vt0, St0),
      {[Op,La],Vt1,St1};
  
negative.code:     mapfoldl2(Fun, Vt, St, Ss).
  
  to_pat_bitseg([Val|Specs]=F, L, Vt, St) ->
      case is_posint_list(F) of
          true ->
              {Size,Type} = to_bitspecs([]),
              to_pat_bin_element(F, Size, Type, L, Vt, St);
  