anchor.diff:      {Lf,Vt1,St1} = from_expr(F, Vt0, St0),
       {Las,Vt2,St2} = from_expr_list(As, Vt1, St1),
       {[funcall,Lf|Las],Vt2,St2};
  -from_expr({'try',_,Es,Scs,Ccs,As}, Vt, St0) ->
  -    %% Currently erl_lint does not allow any exports!
  -    {Les,_,St1} = from_body(Es, Vt, St0),
  -    %% These maybe empty.
  -    {Lscs,_,St2} = if Scs =:= [] -> {[],[],St1};
  -                      true -> from_icrt_cls(Scs, Vt, St1)
  -                   end,
  -    {Lccs,_,St3} = if Ccs =:= [] -> {[],[],St2};
  -                      true -> from_icrt_cls(Ccs, Vt, St2)
  -                   end,
  -    {Las,_,St4} = from_body(As, Vt, St3),
  -    {['try',[progn|Les]|
  -      from_maybe('case', Lscs) ++
  -          from_maybe('catch', Lccs) ++
  -          from_maybe('after', Las)],Vt,St4};
  -from_expr({'catch',_,E}, Vt0, St0) ->
  -    {Le,Vt1,St1} = from_expr(E, Vt0, St0),
  -    {['catch',Le],Vt1,St1};
  -from_expr({match,L,P,E}, Vt0, St0) ->
  -    {Alias,St1} = new_from_var(St0),            %Alias variable value
  -    MP = {match,L,{var,L,Alias},P},
  -    {Lp,Eqt,Vt1,St2} = from_pat(MP, Vt0, St1),  %The alias pattern
  -    {Le,Vt2,St3} = from_expr(E, Vt1, St2),      %The expression
  -    Leg = from_eq_tests(Eqt),                   %Implicit guard tests
  -    {['let',[[Lp,['when'|Leg],Le]],Alias],Vt2,St3};
   from_expr({op,_,Op,A}, Vt0, St0) ->
       {La,Vt1,St1} = from_expr(A, Vt0, St0),
       {[Op,La],Vt1,St1};
  
positive.code:     {Lt,Vt2,St2} = from_expr(Timeout, Vt1, St1),
      {Lb,Vt3,St3} = from_body(Body, Vt2, St2),
      {['receive'|Lcls ++ [['after',Lt|Lb]]],Vt3,St3};
  %% More complex special forms. These become LFE macros.
  from_expr({lc,_,E,Qs}, Vt0, St0) ->
      {Lqs,Vt1,St1} = from_lc_quals(Qs, Vt0, St0),
  
negative.code:     {Ee,St2} = to_expr(E, L, Vt1, St1),
      {Eqs,Vt2,St3} = to_lc_quals(Qs, L, Vt1, St2),
      {[{generate,L,Ep,Ee}|Eqs],Vt2,St3};
  to_lc_quals([['<-',P,['when'],E]|Qs], L, Vt, St) ->
      to_lc_quals([['<-',P,E]|Qs], L, Vt, St);         %Skip empty guard
  to_lc_quals([['<-',P,['when'|G],E]|Qs], L, Vt, St) ->
      to_lc_quals([['<-',P,E]|G ++ Qs], L, Vt, St);    %Move guards to tests
  to_lc_quals([T|Qs], L, Vt0, St0) ->
  