anchor.diff:  		unsafe ->{bif,ln(Anno),Mod,Func,As}
   	    end
       end;
  -expr({call,Anno,{remote,_,Mod0,Func0},As0}, Lc) ->
  +expr({call,Anno,{remote,_,Mod0,Func0},As0}, Lc, St) ->
       %% New R8 format (abstract_v2).
  -    Mod = expr(Mod0, false),
  -    Func = expr(Func0, false),
  -    As = consify(expr_list(As0)),
  +    Mod = expr(Mod0, false, St),
  +    Func = expr(Func0, false, St),
  +    As = consify(expr_list(As0, St)),
       {apply,ln(Anno),[Mod,Func,As],Lc};
  -expr({call,Anno,{atom,_,Func},As0}, Lc) ->
  -    As = expr_list(As0),
  +expr({call,Anno,{atom,_,Func},As0}, Lc, St) ->
  +    As = expr_list(As0, St),
       {local_call,ln(Anno),Func,As,Lc};
  -expr({call,Anno,Fun0,As0}, Lc) ->
  -    Fun = expr(Fun0, false),
  -    As = expr_list(As0),
  +expr({call,Anno,Fun0,As0}, Lc, St) ->
  +    Fun = expr(Fun0, false, St),
  +    As = expr_list(As0, St),
       {apply_fun,ln(Anno),Fun,As,Lc};
  -expr({'catch',Anno,E0}, _Lc) ->
  +expr({'catch',Anno,E0}, _Lc, St) ->
       %% No new variables added.
  -    E1 = expr(E0, false),
  +    E1 = expr(E0, false, St),
       {'catch',ln(Anno),E1};
  -expr({'try',Anno,Es0,CaseCs0,CatchCs0,As0}, Lc) ->
  +expr({'try',Anno,Es0,CaseCs0,CatchCs0,As0}, Lc, St) ->
       %% No new variables added.
  -    Es = expr_list(Es0),
  -    CaseCs = icr_clauses(CaseCs0, Lc),
  -    CatchCs = icr_clauses(CatchCs0, Lc),
  -    As = expr_list(As0),
  +    Es = expr_list(Es0, St),
  +    CaseCs = icr_clauses(CaseCs0, Lc, St),
  +    CatchCs = icr_clauses(CatchCs0, Lc, St),
  +    As = expr_list(As0, St),
       {'try',ln(Anno),Es,CaseCs,CatchCs,As};
  -expr({lc,_,_,_}=Compr, _Lc) ->
  -    expr_lc_bc(Compr);
  -expr({bc,_,_,_}=Compr, _Lc) ->
  -    expr_lc_bc(Compr);
  -expr({match,Anno,P0,E0}, _Lc) ->
  -    E1 = expr(E0, false),
  -    P1 = pattern(P0),
  +expr({lc,_,_,_}=Compr, _Lc, St) ->
  +    expr_lc_bc(Compr, St);
  +expr({bc,_,_,_}=Compr, _Lc, St) ->
  +    expr_lc_bc(Compr, St);
  +expr({match,Anno,P0,E0}, _Lc, St) ->
  +    E1 = expr(E0, false, St),
  +    P1 = pattern(P0, St),
       {match,ln(Anno),P1,E1};
  -expr({op,Anno,Op,A0}, _Lc) ->
  -    A1 = expr(A0, false),
  +expr({op,Anno,Op,A0}, _Lc, St) ->
  +    A1 = expr(A0, false, St),
       {op,ln(Anno),Op,[A1]};
  -expr({op,Anno,'++',L0,R0}, _Lc) ->
  -    L1 = expr(L0, false),
  -    R1 = expr(R0, false),		  %They see the same variables
  +expr({op,Anno,'++',L0,R0}, _Lc, St) ->
  +    L1 = expr(L0, false, St),
  +    R1 = expr(R0, false, St),		  %They see the same variables
       {op,ln(Anno),append,[L1,R1]};
  -expr({op,Anno,'--',L0,R0}, _Lc) ->
  -    L1 = expr(L0, false),
  -    R1 = expr(R0, false),		  %They see the same variables
  +expr({op,Anno,'--',L0,R0}, _Lc, St) ->
  +    L1 = expr(L0, false, St),
  +    R1 = expr(R0, false, St),		  %They see the same variables
       {op,ln(Anno),subtract,[L1,R1]};
  -expr({op,Anno,'!',L0,R0}, _Lc) ->
  -    L1 = expr(L0, false),
  -    R1 = expr(R0, false),		  %They see the same variables
  +expr({op,Anno,'!',L0,R0}, _Lc, St) ->
  +    L1 = expr(L0, false, St),
  +    R1 = expr(R0, false, St),		  %They see the same variables
       {send,ln(Anno),L1,R1};
  -expr({op,Anno,Op,L0,R0}, _Lc) when Op =:= 'andalso'; Op =:= 'orelse' ->
  -    L1 = expr(L0, false),
  -    R1 = expr(R0, false),		  %They see the same variables
  +expr({op,Anno,Op,L0,R0}, _Lc, St) when Op =:= 'andalso'; Op =:= 'orelse' ->
  +    L1 = expr(L0, false, St),
  +    R1 = expr(R0, false, St),		  %They see the same variables
       {Op,ln(Anno),L1,R1};
  -expr({op,Anno,Op,L0,R0}, _Lc) ->
  -    L1 = expr(L0, false),
  -    R1 = expr(R0, false),		  %They see the same variables
  +expr({op,Anno,Op,L0,R0}, _Lc, St) ->
  +    L1 = expr(L0, false, St),
  +    R1 = expr(R0, false, St),		  %They see the same variables
       {op,ln(Anno),Op,[L1,R1]};
  -expr({bin,Anno,Grp}, _Lc) ->
  -    Grp1 = expr_list(bin_expand_strings(Grp)),
  +expr({bin,Anno,Grp}, _Lc, St) ->
  +    Grp1 = expr_list(bin_expand_strings(Grp), St),
       {bin,ln(Anno),Grp1};
  -expr({bin_element,Anno,Expr0,Size0,Type0}, _Lc) ->
  +expr({bin_element,Anno,Expr0,Size0,Type0}, _Lc, St) ->
       {Size1,Type} = make_bit_type(Anno, Size0, Type0),
  -    Expr = expr(Expr0, false),
  -    Size = expr(Size1, false),
  +    Expr = expr(Expr0, false, St),
  +    Size = expr(Size1, false, St),
       {bin_element,ln(Anno),Expr,Size,Type}.
   
   consify([A|As]) -> 
  
positive.code: 
  store_module(Mod, File, Binary, Db) ->
      {interpreter_module, Exp, Abst, Src, MD5} = binary_to_term(Binary),
      Forms = case abstr(Abst) of
  		{abstract_v1,_} ->
  		    exit({Mod,too_old_beam_file});
  		{abstract_v2,_} ->
  		    exit({Mod,too_old_beam_file});
  		{raw_abstract_v1,Code0} ->
                      Code = interpret_file_attribute(Code0),
  		    standard_transforms(Code)
  	    end,
      dbg_idb:insert(Db, mod_file, File),
      dbg_idb:insert(Db, defs, []),
  
  
negative.code: %%  These expressions are processed "in parallel" for purposes of variable
  %%  definition etc.
  
  expr_list([E0|Es], St) ->
      E1 = expr(E0, false, St),
      [E1|expr_list(Es, St)];
  expr_list([], _St) -> [].
  
  icr_clauses([C0|Cs], Lc, St) ->
      C1 = clause(C0, Lc, St),
      [C1|icr_clauses(Cs, Lc, St)];
  icr_clauses([], _, _St) -> [].
  
  fun_clauses([{clause,A,H,G,B}|Cs], St) ->
      [{clause,ln(A),head(H, St),guard(G, St),exprs(B, true, St)}|fun_clauses(Cs, St)];
  fun_clauses([], _St) -> [].
  
  new_map(Fs0, Anno, St, F) ->
      Line = ln(Anno),
      Fs1 = map_fields(Fs0, St, F),
      Fs2 = [{L,K,V} || {map_field_assoc,L,K,V} <- Fs1],
      try
  	{value,Line,map_literal(Fs2, #{})}
  