anchor.diff:      erl_internal:arith_op(Op, 2) andalso all(fun is_pattern_expr/1, [A1,A2]);
   is_pattern_expr_1(_Other) -> false.
   
  -pattern_map(Ps, Vt, Old, Bvt, St) ->
  +pattern_map(Ps, Vt, Old, St) ->
       foldl(fun({map_field_assoc,L,_,_}, {Psvt,Bvt0,St0}) ->
                     {Psvt,Bvt0,add_error(L, illegal_pattern, St0)};
                ({map_field_exact,_L,K,V}, {Psvt,Bvt0,St0}) ->
                     St1 = St0#lint{gexpr_context=map_key},
                     {Kvt,St2} = gexpr(K, Vt, St1),
  -                  {Vvt,Bvt2,St3} = pattern(V, Vt, Old, Bvt, St2),
  +                  {Vvt,Bvt2,St3} = pattern(V, Vt, Old, St2),
                     {vtmerge_pat(vtmerge_pat(Kvt, Vvt), Psvt),
                      vtmerge_pat(Bvt0, Bvt2),
                      St3}
             end, {[],[],St}, Ps).
   
  -%% pattern_bin([Element], VarTable, Old, BinVarTable, State) ->
  +%% pattern_bin([Element], VarTable, Old, State) ->
   %%           {UpdVarTable,UpdBinVarTable,State}.
   %%  Check a pattern group. BinVarTable are used binsize variables.
   
  -pattern_bin(Es, Vt, Old, Bvt0, St0) ->
  +pattern_bin(Es, Vt, Old, St0) ->
       {_Sz,Esvt,Bvt,St1} = foldl(fun (E, Acc) ->
   				       pattern_element(E, Vt, Old, Acc)
   			       end,
  -			       {0,[],Bvt0,St0}, Es),
  +			       {0,[],[],St0}, Es),
       {Esvt,Bvt,St1}.
   
   pattern_element({bin_element,Line,{string,_,_},Size,Ts}=Be, Vt,
  
positive.code:     head(Ps, Vt, Vt, St0).    % Old = Vt
  
  head([P|Ps], Vt, Old, St0) ->
      {Pvt,Bvt1,St1} = pattern(P, Vt, Old, [], St0),
      {Psvt,Bvt2,St2} = head(Ps, Vt, Old, St1),
      {vtmerge_pat(Pvt, Psvt),vtmerge_pat(Bvt1,Bvt2),St2};
  head([], _Vt, _Env, St) -> {[],[],St}.
  
  %% pattern(Pattern, VarTable, Old, BinVarTable, State) ->
  %%                  {UpdVarTable,BinVarTable,State}.
  %%  Check pattern return variables. Old is the set of variables used for
  %%  deciding whether an occurrence is a binding occurrence or a use, and
  
negative.code:     %% Forget variables local to E immediately.
      Vt1 = vtupdate(vtold(Evt, Vt), Vt),
      {_, St2} = check_unused_vars(Evt, Vt, St1),
      {Pvt,Binvt,St3} = pattern(P, Vt1, [], St2),
      %% Have to keep fresh variables separated from used variables somehow
      %% in order to handle for example X = foo(), [X || <<X:X>> <- bar()].
      %%                                1           2      2 1
  