anchor.diff:      assert_type({tuple_element,I+1}, Tuple, Vst),
       Vst;
   %% Match instructions.
  -valfun_4({select_val,Src,{f,Fail},{list,Choices}}, Vst) ->
  -    assert_term(Src, Vst),
  -    Lbls = [L || {f,L} <- Choices]++[Fail],
  -    kill_state(foldl(fun(L, S) -> branch_state(L, S) end, Vst, Lbls));
  +valfun_4({select_val,Src,{f,Fail},{list,Choices}}, Vst0) ->
  +    assert_term(Src, Vst0),
  +    Vst = branch_state(Fail, Vst0),
  +    kill_state(select_val_branches(Src, Choices, Vst));
   valfun_4({select_tuple_arity,Tuple,{f,Fail},{list,Choices}}, Vst) ->
       assert_type(tuple, Tuple, Vst),
       kill_state(branch_arities(Choices, Tuple, branch_state(Fail, Vst)));
  
positive.code: 		 gb_trees:update(Y, Type, Ys0)
  	 end,
      check_try_catch_tags(Type, Y, Ys0),
      Vst#vst{current=St#st{y=Ys}};
  set_type_y(Type, Reg, #vst{}) -> error({invalid_store,Reg,Type}).
  
  make_fragile({fragile,_}=Type) -> Type;
  make_fragile(Type) -> {fragile,Type}.
  
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}.
  
  %%%
  