anchor.diff:  %% Other test instructions.
   valfun_4({test,is_atom,{f,Lbl},[Src]}, Vst) ->
       type_test(Lbl, {atom,[]}, Src, Vst);
  +valfun_4({test,is_binary,{f,Lbl},[Src]}, Vst) ->
  +    type_test(Lbl, binary, Src, Vst);
  +valfun_4({test,is_bitstr,{f,Lbl},[Src]}, Vst) ->
  +    type_test(Lbl, binary, Src, Vst);
   valfun_4({test,is_boolean,{f,Lbl},[Src]}, Vst) ->
       type_test(Lbl, bool, Src, Vst);
   valfun_4({test,is_float,{f,Lbl},[Src]}, Vst) ->
  
positive.code: -spec type_anno(term()) -> term().
  type_anno(atom) -> {atom,[]};
  type_anno(bool) -> bool;
  type_anno({binary,_}) -> term;
  type_anno(cons) -> cons;
  type_anno(float) -> {float,[]};
  type_anno(integer) -> {integer,[]};
  
negative.code:     verify_y_init(Vst),
  
      %% #ms{} can represent either a match context or a term, so we have to mark
      %% the source as a term if it fails with a match context as an input. This
      %% hack is only needed until we get proper union types.
      complex_test(Fail,
                   fun(FailVst) ->
                           case get_raw_type(Src, FailVst) of
                               #ms{} -> override_type(term, Src, FailVst);
                               _ -> FailVst
                           end
                   end,
                   fun(SuccVst0) ->
                           SuccVst1 = update_type(fun meet/2, binary, Src, SuccVst0),
                           SuccVst = prune_x_regs(Live, SuccVst1),
                           extract_term(Type, bs_start_match, [Src], Dst,
                                        SuccVst, SuccVst0)
                   end, Vst).
  