anchor.diff:  simplify(#b_set{dst=Dst,args=Args0}=I0, Ts0, Ds0, _Ls, Sub) ->
       Args = simplify_args(Args0, Ts0, Sub),
       I1 = beam_ssa:normalize(I0#b_set{args=Args}),
  -    case simplify(I1, Ts0) of
  +    case simplify(I1, Ts0, Ds0) of
           #b_set{}=I ->
               Ts = update_types(I, Ts0, Ds0),
               Ds = Ds0#{ Dst => I },
  
positive.code:             %% If the bitstring is a binary (the size in bits is
              %% evenly divisibly by 8), byte_size/1 gives
              %% the same result as size/1.
              simplify(I#b_set{op={bif,byte_size}}, Ts);
          _ ->
              eval_bif(I, Ts)
      end;
  simplify(#b_set{op={bif,tuple_size},args=[Term]}=I, Ts) ->
      case normalized_type(Term, Ts) of
          #t_tuple{size=Size,exact=true} ->
              #b_literal{val=Size};
          _ ->
              I
      end;
  simplify(#b_set{op={bif,is_map_key},args=[Key,Map]}=I, Ts) ->
      case normalized_type(Map, Ts) of
          #t_map{} ->
              I#b_set{op=has_map_field,args=[Map,Key]};
          _ ->
              I
      end;
  simplify(#b_set{op={bif,Op0},args=Args}=I, Ts) when Op0 =:= '==';
                                                      Op0 =:= '/=' ->
      Types = normalized_types(Args, Ts),
      EqEq0 = case {beam_types:meet(Types),beam_types:join(Types)} of
                  {none,any} -> true;
  
negative.code:                      '==' -> '=:=';
                       '/=' -> '=/='
                   end,
              simplify(I#b_set{op={bif,Op}}, Ts, Ds);
          false ->
              eval_bif(I, Ts, Ds)
      end;
  simplify(#b_set{op={bif,'=:='},args=[Same,Same]}, _Ts, _Ds) ->
      #b_literal{val=true};
  simplify(#b_set{op={bif,'=:='},args=[LHS,RHS]}=I, Ts, Ds) ->
      LType = concrete_type(LHS, Ts),
      RType = concrete_type(RHS, Ts),
      case beam_types:meet(LType, RType) of
  