anchor.diff:  from_pat({var,_,'_'}, Vt, St) -> {'_',[],Vt,St};    %Special case _
   from_pat({var,_,V}, Vt, St0) ->                     %Unquoted atom
       case ordsets:is_element(V, Vt) of               %Is variable bound?
  -    true ->
  -        {V1,St1} = new_from_var(St0),               %New var for pattern
  -        {V1,[{V,V1}],Vt,St1};                       %Add to guard tests
  -    false ->
  -        {V,[],ordsets:add_element(V, Vt),St0}
  +        true ->
  +            {V1,St1} = new_from_var(St0),       %New var for pattern
  +            {V1,[{V,V1}],Vt,St1};               %Add to guard tests
  +        false ->
  +            {V,[],ordsets:add_element(V, Vt),St0}
       end;
   from_pat({nil,_}, Vt, St) -> {[],[],Vt,St};
   from_pat({integer,_,I}, Vt, St) -> {I,[],Vt,St};
  
positive.code: to_expr([F|As], L, Vt, St0) when is_atom(F) ->  %General function call
      {Eas,St1} = to_expr_list(As, L, Vt, St0),
      case is_erl_op(F, length(As)) of
      true -> {list_to_tuple([op,L,F|Eas]),St1};
      false -> {{call,L,{atom,L,F},Eas},St1}
      end;
  to_expr(List, L, _, St) ->
      case is_integer_list(List) of
      true -> {{string,L,List},St};
      false ->
          io:format("BOOM:~p\n", [List]),
          {integer,L,4711}                        %Not right!
      end.
  
  to_expr_var(V, L, Vt, St) ->
      Var = case orddict:find(V, Vt) of
            {ok,V1} -> V1;
            error -> V
        end,
      {{var,L,Var},St}.
  
  %% is_erl_op(Op, Arity) -> bool().
  
negative.code: 
  to_block(Es, L, Vt, St0) ->
      case to_expr_list(Es, L, Vt, St0) of
          {[Ee],St1} -> {Ee,St1};                 %No need to wrap
          {Ees,St1} -> {{block,L,Ees},St1}        %Must wrap
      end.
  
  %% to_let_bindings(Bindings, LineNumber, VarTable, State) ->
  %%     {Block,VarTable,State}.
  %%  When we have a guard translate into a case but special case where
  %%  we have an empty guard.
  
  to_let_bindings(Lbs, L, Vt, St) ->
      Fun = fun ([P,E], Vt0, St0) ->
                    {Ep,Vt1,St1} = to_pat(P, L, Vt0, St0),
                    {Ee,St2} = to_expr(E, L, Vt0, St1),
                    {{match,L,Ep,Ee},Vt1,St2};
                ([P,['when'],E], Vt0, St0) ->     %Just to keep it short
                    {Ep,Vt1,St1} = to_pat(P, L, Vt0, St0),
                    {Ee,St2} = to_expr(E, L, Vt0, St1),
                    {{match,L,Ep,Ee},Vt1,St2};
                ([P,['when'|G],E], Vt0, St0) ->
                    {Ee,St1} = to_expr(E, L, Vt0, St0),
                    {Ep,Vt1,St2} = to_pat(P, L, Vt0, St1),
                    {Eg,St3} = to_body(G, L, Vt1, St2),
                    {{'case',L,Ee,[{clause,L,[Ep],Eg,[Ep]}]},Vt1,St3}
        end,
      mapfoldl2(Fun, Vt, St, Lbs).
  
  