anchor.diff:  -spec type_anno(term()) -> term().
   type_anno(atom) -> {atom,[]};
   type_anno(bool) -> bool;
  -type_anno({binary,_}) -> term;
  +type_anno({binary,_}) -> binary;
   type_anno(cons) -> cons;
   type_anno(float) -> {float,[]};
   type_anno(integer) -> {integer,[]};
  
positive.code: bif_return_type(float, _, _) -> {float,[]};
  bif_return_type('/', _, _) -> {float,[]};
  %% Binary operations
  bif_return_type('byte_size', _, _) -> {integer,[]};
  bif_return_type('bit_size', _, _) -> {integer,[]};
  %% Integer operations.
  bif_return_type(ceil, [_], _) -> {integer,[]};
  bif_return_type('div', [_,_], _) -> {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).
  