anchor.diff:  valfun_4({make_fun2,_,_,_,Live}, Vst) ->
       call(make_fun, Live, Vst);
   %% Other BIFs
  -valfun_4({bif,tuple_size,{f,Fail},[Tuple],Dst}, Vst0) ->
  +valfun_4({bif,tuple_size,{f,Fail},[Tuple],Dst}=I, Vst0) ->
       TupleType0 = get_term_type(Tuple, Vst0),
       Vst1 = branch_state(Fail, Vst0),
       TupleType = upgrade_tuple_type({tuple,[0]}, TupleType0),
       Vst = set_type(TupleType, Tuple, Vst1),
  -    set_type_reg({integer,[]}, Dst, Vst);
  +    set_type_reg_expr({integer,[]}, I, Dst, Vst);
   valfun_4({bif,element,{f,Fail},[Pos,Tuple],Dst}, Vst0) ->
       TupleType0 = get_term_type(Tuple, Vst0),
       PosType = get_term_type(Pos, Vst0),
  
positive.code:              {value,_} ->
                   gb_trees:update(X, Type, Xs0)
           end,
      Vst#vst{current=St#st{x=Xs}};
  set_type_x(Type, Reg, #vst{}) ->
      error({invalid_store,Reg,Type}).
  
  set_type_y(Type, {y,Y}=Reg, #vst{current=#st{y=Ys0}=St}=Vst)
    when is_integer(Y), 0 =< Y ->
      check_limit(Reg),
      Ys = case gb_trees:lookup(Y, Ys0) of
  
negative.code:     heap_alloc_2(T, St);
  heap_alloc_2([], St) -> St.
      
  prune_x_regs(Live, #vst{current=#st{x=Xs0,defs=Defs0}=St0}=Vst)
    when is_integer(Live) ->
      Xs1 = gb_trees:to_list(Xs0),
      Xs = [P || {R,_}=P <- Xs1, R < Live],
      Defs = maps:filter(fun({x,X}, _) -> X < Live;
                            ({y,_}, _) -> true
                         end, Defs0),
      St = St0#st{x=gb_trees:from_orddict(Xs),defs=Defs},
      Vst#vst{current=St}.
  
  %%%
  