anchor.diff:      Vst;
   
   %% Other test instructions.
  +valfun_4({test,has_map_fields,{f,Lbl},Src,{list,List}}, Vst) ->
  +    assert_type(map, Src, Vst),
  +    assert_unique_map_keys(List),
  +    branch(Lbl, Vst, fun(V) -> V end);
   valfun_4({test,is_atom,{f,Lbl},[Src]}, Vst) ->
       type_test(Lbl, {atom,[]}, Src, Vst);
   valfun_4({test,is_binary,{f,Lbl},[Src]}, Vst) ->
  
positive.code: 	_ -> error({illegal_restore,SavePoint,range})
      end.
  
  select_val_branches(Fail, Src, Choices, Vst0) ->
      Vst = svb_1(Choices, Src, Vst0),
      kill_state(branch_state(Fail, Vst)).
  
  svb_1([Val,{f,L}|T], Src, Vst0) ->
      Vst = complex_test(L,
                         fun(BranchVst) ->
                                 update_eq_types(Src, Val, BranchVst)
                         end,
                         fun(FailVst) ->
                                 update_ne_types(Src, Val, FailVst)
                         end, Vst0),
      svb_1(T, Src, Vst);
  svb_1([], _, Vst) ->
      Vst.
  
  select_arity_branches(Fail, List, Tuple, Vst0) ->
      Type = get_term_type(Tuple, Vst0),
      Vst = sab_1(List, Tuple, Type, Vst0),
      kill_state(branch_state(Fail, Vst)).
  
  sab_1([Sz,{f,L}|T], Tuple, {tuple,[_],Es}=Type0, Vst0) ->
      #vst{current=St0} = Vst0,
      Vst1 = update_type(fun meet/2, {tuple,Sz,Es}, Tuple, Vst0),
      Vst2 = branch_state(L, Vst1),
      Vst = Vst2#vst{current=St0},
  
      sab_1(T, Tuple, Type0, Vst);
  sab_1([Sz,{f,L}|T], Tuple, {tuple,Sz,_Es}=Type, Vst0) ->
      %% The type is already correct. (This test is redundant.)
      Vst = branch_state(L, Vst0),
      sab_1(T, Tuple, Type, Vst);
  sab_1([_,{f,_}|T], Tuple, Type, Vst) ->
      %% We already have an established different exact size for the tuple.
      %% This label can't possibly be reached.
      sab_1(T, Tuple, Type, Vst);
  sab_1([], _, _, #vst{}=Vst) ->
      Vst.
  
  infer_types({Kind,_}=Reg, Vst) when Kind =:= x; Kind =:= y ->
  
negative.code:             assert_term(Src, Vst),
              kill_state(Vst)
      end;
  valfun_4({test,test_arity,{f,Lbl},[Tuple,Sz]}, Vst) when is_integer(Sz) ->
      assert_type(tuple, Tuple, Vst),
      branch(Lbl, Vst,
             fun(SuccVst) ->
                     Type = {tuple, Sz, #{}},
                     update_type(fun meet/2, Type, Tuple, SuccVst)
             end);
  valfun_4({test,is_tagged_tuple,{f,Lbl},[Src,Sz,Atom]}, Vst) ->
      assert_term(Src, Vst),
      branch(Lbl, Vst,
             fun(SuccVst) ->
                     Type = {tuple, Sz, #{ {integer,1} => Atom }},
                     update_type(fun meet/2, Type, Src, SuccVst)
             end);
  valfun_4({test,is_eq_exact,{f,Lbl},[Src,Val]=Ss}, Vst) ->
      validate_src(Ss, Vst),
      branch(Lbl, Vst,
             fun(FailVst) ->
                     update_ne_types(Src, Val, FailVst)
             end,
             fun(SuccVst) ->
                     update_eq_types(Src, Val, SuccVst)
             end);
  valfun_4({test,is_ne_exact,{f,Lbl},[Src,Val]=Ss}, Vst) ->
      validate_src(Ss, Vst),
      branch(Lbl, Vst,
             fun(FailVst) ->
                     update_eq_types(Src, Val, FailVst)
             end,
             fun(SuccVst) ->
                     update_ne_types(Src, Val, SuccVst)
             end);
  valfun_4({test,_Op,{f,Lbl},Src}, Vst) ->
      %% is_pid, is_reference, et cetera.
      validate_src(Src, Vst),
      branch(Lbl, Vst, fun(V) -> V end);
  valfun_4({bs_add,{f,Fail},[A,B,_],Dst}, Vst) ->
      assert_term(A, Vst),
      assert_term(B, Vst),
      branch(Fail, Vst,
             fun(SuccVst) ->
                     create_term({integer,[]}, bs_add, [A, B], Dst, SuccVst)
             end);
  valfun_4({bs_utf8_size,{f,Fail},A,Dst}, Vst) ->
      assert_term(A, Vst),
      branch(Fail, Vst,
             fun(SuccVst) ->
                     create_term({integer,[]}, bs_utf8_size, [A], Dst, SuccVst)
             end);
  valfun_4({bs_utf16_size,{f,Fail},A,Dst}, Vst) ->
      assert_term(A, Vst),
      branch(Fail, Vst,
             fun(SuccVst) ->
                     create_term({integer,[]}, bs_utf16_size, [A], Dst, SuccVst)
             end);
  valfun_4({bs_init2,{f,Fail},Sz,Heap,Live,_,Dst}, Vst0) ->
      verify_live(Live, Vst0),
      verify_y_init(Vst0),
  