anchor.diff:  	    Vst;
   	_ ->
   	    kill_state(Vst)
  +    end;
  +valfun_4({test,is_eq_exact,{f,Lbl},[Src,Val]=Ss}, Vst0) ->
  +    validate_src(Ss, Vst0),
  +    Infer = infer_types(Src, Vst0),
  +    Vst1 = Infer(Val, Vst0),
  +    Vst = branch_state(Lbl, Vst1),
  +    case Val of
  +        {literal,Tuple} when is_tuple(Tuple) ->
  +            Type0 = get_term_type(Val, Vst),
  +            Type = upgrade_tuple_type({tuple,tuple_size(Tuple)},
  +                                      Type0),
  +            set_type(Type, Src, Vst);
  +        _ ->
  +            Vst
       end;
   valfun_4({test,_Op,{f,Lbl},Src}, Vst) ->
       validate_src(Src, Vst),
  
positive.code: 	 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.
  	}).
  
  -type label()        :: integer().
  
negative.code: 	_ -> error({illegal_restore,SavePoint,range})
      end.
  
  select_val_branches(Src, Choices, Vst) ->
      Infer = infer_types(Src, Vst),
      select_val_branches_1(Choices, Infer, Vst).
  
  select_val_branches_1([Val,{f,L}|T], Infer, Vst0) ->
      Vst = branch_state(L, Infer(Val, Vst0)),
      select_val_branches_1(T, Infer, Vst);
  select_val_branches_1([], _, Vst) -> Vst.
  
  infer_types(Src, Vst) ->
      case get_def(Src, Vst) of
          {bif,is_map,{f,_},[Map],_} ->
              fun({atom,true}, S) -> set_type_reg(map, Map, S);
                 (_, S) -> S
              end;
          {bif,tuple_size,{f,_},[Tuple],_} ->
              fun({integer,Arity}, S) ->
                      Type0 = get_term_type(Tuple, S),
                      Type = upgrade_tuple_type({tuple,Arity}, Type0),
                      set_type(Type, Tuple, S);
                 (_, S) -> S
              end;
          {bif,'=:=',{f,_},[ArityReg,{integer,_}=Val],_} when ArityReg =/= Src ->
              fun({atom,true}, S) ->
                      Infer = infer_types(ArityReg, S),
                      Infer(Val, S);
                 (_, S) -> S
              end;
          _ ->
              fun(_, S) -> S end
      end.
  
  %%%
  %%% Keeping track of types.
  %%%
  