anchor.diff:  opt_remove_1(Ts, Rs) ->
       [opt_remove_2(T, Rs) || T <- Ts].
   
  -opt_remove_2({op,L,'and'=Op,A1,A2}, Rs) ->
  -    {op,L,Op,opt_remove_2(A1, Rs),opt_remove_2(A2, Rs)};
  -opt_remove_2({op,L,'andalso'=Op,A1,A2}, Rs) ->
  -    {op,L,Op,opt_remove_2(A1, Rs),opt_remove_2(A2, Rs)};
  -opt_remove_2({op,L,'orelse',A1,A2}, Rs) ->
  -    {op,L,'orelse',opt_remove_2(A1, Rs),A2};
  -opt_remove_2({call,Line,{remote,_,{atom,_,erlang},{atom,_,is_record}},
  +opt_remove_2({op,Anno,'and'=Op,A1,A2}, Rs) ->
  +    {op,Anno,Op,opt_remove_2(A1, Rs),opt_remove_2(A2, Rs)};
  +opt_remove_2({op,Anno,'andalso'=Op,A1,A2}, Rs) ->
  +    {op,Anno,Op,opt_remove_2(A1, Rs),opt_remove_2(A2, Rs)};
  +opt_remove_2({op,Anno,'orelse',A1,A2}, Rs) ->
  +    {op,Anno,'orelse',opt_remove_2(A1, Rs),A2};
  +opt_remove_2({call,Anno,{remote,_,{atom,_,erlang},{atom,_,is_record}},
   	      [{var,_,V},{atom,_,Tag},{integer,_,Sz}]}=A, Rs) ->
       case orddict:find(V, Rs) of
   	{ok,{remove,Tag,Sz}} ->
  -	    {atom,Line,true};
  +	    {atom,Anno,true};
   	_ ->
   	    A
       end;
  -opt_remove_2({call,Line,{atom,_,is_record},
  +opt_remove_2({call,Anno,{atom,_,is_record},
   	      [{var,_,V},{atom,_,Tag},{integer,_,Sz}]}=A, Rs) ->
       case orddict:find(V, Rs) of
   	{ok,{remove,Tag,Sz}} ->
  -	    {atom,Line,true};
  +	    {atom,Anno,true};
   	_ ->
   	    A
       end;
  
positive.code: find_field(F, [_ | Fs]) -> find_field(F, Fs);
  find_field(_, []) -> error.
  
  %% copy_expr(Expr, Line) -> Expr.
  %%  Make a copy of Expr converting all line numbers to Line.
  
  copy_expr(Expr, Anno) ->
      erl_parse:map_anno(fun(_A) -> Anno end, Expr).
  
negative.code:     St = St0#exprec{records=maps:put(Name, NDefs, St0#exprec.records)},
      {Fs1, St1} = forms(Fs, St),
      {[Attr | Fs1], St1};
  forms([{function,Anno,N,A,Cs0} | Fs0], St0) ->
      {Cs,St1} = clauses(Cs0, St0),
      {Fs,St2} = forms(Fs0, St1),
      {[{function,Anno,N,A,Cs} | Fs],St2};
  forms([F | Fs0], St0) ->
      {Fs,St} = forms(Fs0, St0),
      {[F | Fs], St};
  forms([], St) -> {[],St}.
  
  clauses([{clause,Anno,H0,G0,B0} | Cs0], St0) ->
      {H1,St1} = head(H0, St0),
      {G1,St2} = guard(G0, St1),
      {H,G} = optimize_is_record(H1, G1, St2),
      {B,St3} = exprs(B0, St2),
      {Cs,St4} = clauses(Cs0, St3),
      {[{clause,Anno,H,G,B} | Cs],St4};
  clauses([], St) -> {[],St}.
  
  head(As, St) -> pattern_list(As, St).
  