anchor.diff:  	      {var,_,'_'} -> St0#core{wanted=false};
   	      _ -> St0
   	  end,
  -    {E2,Eps,St2} = novars(E1, St1),
  +    {E2,Eps1,St2} = novars(E1, St1),
       St3 = St2#core{wanted=St0#core.wanted},
  -    P2 = try
  -	     pattern(P1, St3)
  +    {P2,Eps2,St4} = try
  +	    pattern(P1, St3)
   	 catch
   	     throw:Thrown ->
  -		 Thrown
  +		{Thrown,[],St3}
   	 end,
  -    {Fpat,St4} = new_var(St3),
  -    Lanno = lineno_anno(L, St4),
  +    {Fpat,St5} = new_var(St4),
  +    Lanno = lineno_anno(L, St5),
       Fc = fail_clause([Fpat], Lanno, c_tuple([#c_literal{val=badmatch},Fpat])),
       case P2 of
   	nomatch ->
  -	    St = add_warning(L, nomatch, St4),
  +	    St = add_warning(L, nomatch, St5),
   	    {#icase{anno=#a{anno=Lanno},
  -		    args=[E2],clauses=[],fc=Fc},Eps,St};
  +		    args=[E2],clauses=[],fc=Fc},Eps1++Eps2,St};
   	Other when not is_atom(Other) ->
  -	    {#imatch{anno=#a{anno=Lanno},pat=P2,arg=E2,fc=Fc},Eps,St4}
  +	    {#imatch{anno=#a{anno=Lanno},pat=P2,arg=E2,fc=Fc},Eps1++Eps2,St5}
       end;
   expr({op,_,'++',{lc,Llc,E,Qs0},More}, St0) ->
       %% Optimise '++' here because of the list comprehension algorithm.
  
positive.code: generator(Line, {generate,Lg,P0,E}, Gs, St0) ->
      LA = lineno_anno(Line, St0),
      GA = lineno_anno(Lg, St0),
      {Head,St1} = list_gen_pattern(P0, Line, St0),
      {[Tail,Skip],St2} = new_vars(2, St1),
      {Cg,St3} = lc_guard_tests(Gs, St2),
      {AccPat,SkipPat} = case Head of
  
negative.code: force_novars(Ce, St) ->
      force_safe(Ce, St).
  
  
  %% safe_pattern_expr(Expr, State) -> {Cexpr,[PreExpr],State}.
  %%   only literals and variables are safe expressions in patterns
  safe_pattern_expr(E,St0) ->
      case safe(E,St0) of
  	{#c_var{},_,_}=Safe -> Safe;
  	{#c_literal{},_,_}=Safe -> Safe;
  	{Ce,Eps,St1} ->
  	    {V,St2} = new_var(St1),
  	    {V,Eps++[#iset{var=V,arg=Ce}],St2}
      end.
  
  %% safe(Expr, State) -> {Safe,[PreExpr],State}.
  %%  Generate an internal safe expression.  These are simples without
  %%  binaries which can fail.  At this level we do not need to do a
  