anchor.diff:  update({bs_restore2,_,_}, Ts) ->
       Ts;
   update({bs_context_to_binary,Dst}, Ts) ->
  -    tdb_update([{Dst,kill}], Ts);
  -update({test,bs_start_match2,_,_,[Src,_],Dst}, Ts) ->
  -    Type = case tdb_find(Src, Ts) of
  -               {binary,_}=Type0 -> Type0;
  -               _ -> {binary,1}
  -           end,
  -    tdb_update([{Dst,Type}], Ts);
  +    tdb_store(Dst, {binary,1}, Ts);
  +update({test,bs_start_match2,_,_,[Src,_],Dst}, Ts0) ->
  +    Ts = tdb_meet(Src, {binary,1}, Ts0),
  +    tdb_copy(Src, Dst, Ts);
   update({test,bs_get_binary2,_,_,[_,_,Unit,_],Dst}, Ts) ->
       true = is_integer(Unit),                    %Assertion.
  -    tdb_update([{Dst,{binary,Unit}}], Ts);
  +    tdb_store(Dst, {binary,Unit}, Ts);
   update({test,bs_get_float2,_,_,_,Dst}, Ts) ->
  -    tdb_update([{Dst,float}], Ts);
  +    tdb_store(Dst, float, Ts);
   update({test,bs_test_unit,_,[Src,Unit]}, Ts) ->
  -    tdb_update([{Src,{binary,Unit}}], Ts);
  -
  +    tdb_meet(Src, {binary,Unit}, Ts);
  +
  +%% Other test instructions
  +update({test,Test,_Fail,[Src]}, Ts) ->
  +    Type = case Test of
  +               is_binary -> {binary,8};
  +               is_bitstr -> {binary,1};
  +               is_boolean -> boolean;
  +               is_float -> float;
  +               is_integer -> integer;
  +               is_map -> map;
  +               is_nonempty_list -> nonempty_list;
  +               _ -> any
  +           end,
  +    tdb_meet(Src, Type, Ts);
   update({test,_Test,_Fail,_Other}, Ts) ->
       Ts;
   
  
positive.code:     Ts;
  update({set,[D],[S],move}, Ts) ->
      tdb_copy(S, D, Ts);
  update({set,[D],[{integer,I},Reg],{bif,element,_}}, Ts0) ->
      tdb_update([{Reg,{tuple,min_size,I,[]}},{D,kill}], Ts0);
  update({set,[D],[_Index,Reg],{bif,element,_}}, Ts0) ->
      tdb_update([{Reg,{tuple,min_size,0,[]}},{D,kill}], Ts0);
  update({set,[D],Args,{bif,N,_}}, Ts0) ->
      Ar = length(Args),
      BoolOp = erl_internal:new_type_test(N, Ar) orelse
  	erl_internal:comp_op(N, Ar) orelse
  	erl_internal:bool_op(N, Ar),
      case BoolOp of
  	true ->
  	    tdb_update([{D,boolean}], Ts0);
  	false ->
  	    tdb_update([{D,kill}], Ts0)
      end;
  update({set,[D],[S],{get_tuple_element,0}}, Ts) ->
      tdb_update([{D,{tuple_element,S,0}}], Ts);
  update({set,[D],[S],{alloc,_,{gc_bif,float,{f,0}}}}, Ts0) ->
      %% Make sure we reject non-numeric literal argument.
      case possibly_numeric(S) of
  	true ->  tdb_update([{D,float}], Ts0);
  	false -> Ts0
      end;
  update({set,[D],[S1,S2],{alloc,_,{gc_bif,'band',{f,0}}}}, Ts) ->
      case keyfind(integer, 1, [S1,S2]) of
  	{integer,N} ->
  	    update_band(N, D, Ts);
  	false ->
  	    tdb_update([{D,integer}], Ts)
      end;
  update({set,[D],[S1,S2],{alloc,_,{gc_bif,'/',{f,0}}}}, Ts0) ->
      %% Make sure we reject non-numeric literals.
      case possibly_numeric(S1) andalso possibly_numeric(S2) of
  	true ->  tdb_update([{D,float}], Ts0);
  	false -> Ts0
      end;
  update({set,[D],[S1,S2],{alloc,_,{gc_bif,Op,{f,0}}}}, Ts0) ->
      case op_type(Op) of
  	integer ->
  	    tdb_update([{D,integer}], Ts0);
  	{float,_} ->
  	    case {tdb_find(S1, Ts0),tdb_find(S2, Ts0)} of
  		{float,_} -> tdb_update([{D,float}], Ts0);
  		{_,float} -> tdb_update([{D,float}], Ts0);
  		{_,_} -> tdb_update([{D,kill}], Ts0)
  	    end;
  	unknown ->
  	    tdb_update([{D,kill}], Ts0)
      end;
  update({set,[],_Src,_Op}, Ts0) -> Ts0;
  update({set,[D],_Src,_Op}, Ts0) ->
      tdb_update([{D,kill}], Ts0);
  update({kill,D}, Ts) ->
      tdb_update([{D,kill}], Ts);
  
  %% Instructions outside of blocks.
  update({test,is_float,_Fail,[Src]}, Ts0) ->
      tdb_update([{Src,float}], Ts0);
  update({test,test_arity,_Fail,[Src,Arity]}, Ts0) ->
      tdb_update([{Src,{tuple,exact_size,Arity,[]}}], Ts0);
  update({test,is_map,_Fail,[Src]}, Ts0) ->
      tdb_update([{Src,map}], Ts0);
  update({get_map_elements,_,Src,{list,Elems0}}, Ts0) ->
      {_Ss,Ds} = beam_utils:split_even(Elems0),
      Elems = [{Dst,kill} || Dst <- Ds],
      tdb_update([{Src,map}|Elems], Ts0);
  update({test,is_nonempty_list,_Fail,[Src]}, Ts0) ->
      tdb_update([{Src,nonempty_list}], Ts0);
  update({test,is_eq_exact,_,[Reg,{atom,_}=Atom]}, Ts) ->
      case tdb_find(Reg, Ts) of
  	error ->
  	    Ts;
  	{tuple_element,TupleReg,0} ->
  	    tdb_update([{TupleReg,{tuple,min_size,1,[Atom]}}], Ts);
  	_ ->
  	    Ts
      end;
  update({test,is_record,_Fail,[Src,Tag,{integer,Arity}]}, Ts) ->
      tdb_update([{Src,{tuple,exact_size,Arity,[Tag]}}], Ts);
  
  %% Binaries and binary matching.
  
  update({test,is_binary,_Fail,[Src]}, Ts0) ->
      tdb_update([{Src,{binary,8}}], Ts0);
  update({test,is_bitstr,_Fail,[Src]}, Ts0) ->
      tdb_update([{Src,{binary,1}}], Ts0);
  update({test,bs_get_integer2,_,_,Args,Dst}, Ts) ->
      tdb_update([{Dst,get_bs_integer_type(Args)}], Ts);
  update({test,bs_get_utf8,_,_,_,Dst}, Ts) ->
      tdb_update([{Dst,?UNICODE_INT}], Ts);
  update({test,bs_get_utf16,_,_,_,Dst}, Ts) ->
      tdb_update([{Dst,?UNICODE_INT}], Ts);
  update({test,bs_get_utf32,_,_,_,Dst}, Ts) ->
      tdb_update([{Dst,?UNICODE_INT}], Ts);
  update({bs_init,_,{bs_init2,_,_},_,_,Dst}, Ts) ->
      tdb_update([{Dst,{binary,8}}], Ts);
  update({bs_init,_,_,_,_,Dst}, Ts) ->
      tdb_update([{Dst,{binary,1}}], Ts);
  update({bs_put,_,_,_}, Ts) ->
      Ts;
  update({bs_save2,_,_}, Ts) ->
  
negative.code: 	    {D,Rs} = find_dest(D0, Rs1),
  	    Areg = fetch_reg(A, Rs),
  	    Acc = [{set,[D],[Areg],{bif,fnegate,{f,0}}}|clearerror(Acc1)],
  	    Ts = tdb_store(D0, float, Ts0),
  	    simplify_float_1(Is, Ts, Rs, Acc);
  	_Other ->
  	    Ts = update(I, Ts0),
  