anchor.diff:  valfun_4({loop_rec_end,_}, Vst) ->
       verify_y_init(Vst),
       kill_state(Vst);
  -valfun_4(timeout, #vst{current=St}=Vst) ->
  -    Vst#vst{current=St#st{x=init_regs(0, term)}};
  +valfun_4(timeout, Vst) ->
  +    prune_x_regs(0, Vst);
   valfun_4(send, Vst) ->
       call(send, 2, Vst);
   valfun_4({set_tuple_element,Src,Tuple,N}, Vst) ->
  
positive.code:     {reverse(R),Is}.
  
  init_vst(Arity, Ls1, Ls2, Ft) ->
      Xs = init_regs(Arity, term),
      Ys = init_regs(0, initialized),
      St = #st{x=Xs,y=Ys},
      Branches = gb_trees_from_list([{L,St} || L <- Ls1]),
      Labels = gb_sets:from_list(Ls1++Ls2),
      #vst{branched=Branches,
           current=St,
           labels=Labels,
           ft=Ft}.
  
  kill_heap_allocation(St) ->
      St#st{h=0,hf=0}.
  
  init_regs(0, _) ->
      gb_trees:empty();
  init_regs(N, Type) ->
      gb_trees_from_list([{R,Type} || R <- seq(0, N-1)]).
  
  valfun([], MFA, _Offset, #vst{branched=Targets0,labels=Labels0}=Vst) ->
      Targets = gb_trees:keys(Targets0),
  
negative.code: -type reg_tab() :: gb_trees:tree(index(), 'none' | {'value', _}).
  
  -record(st,				%Emulation state
  	{x=gb_trees:empty() :: reg_tab(), %x register info.
  	 y=gb_trees:empty() :: reg_tab(), %y register info.
  	 f=init_fregs(),                  %
  	 numy=none,			  %Number of y registers.
  	 h=0,				  %Available heap size.
  	 hf=0,				  %Available heap size for floats.
  	 fls=undefined,			  %Floating point state.
  	 ct=[],				  %List of hot catch/try labels
           setelem=false,                   %Previous instruction was setelement/3.
           puts_left=none,                  %put/1 instructions left.
           defs=#{},                        %Defining expression for each register.
           aliases=#{}
  	}).
  
  