anchor.diff:  infer_type({bif,is_tuple}, [Arg], _Ts, _Ds) ->
       T = {Arg, #t_tuple{}},
       {[T], [T]};
  +infer_type({bif,'=:='}, [#b_var{}=LHS,#b_var{}=RHS], Ts, _Ds) ->
  +    %% As an example, assume that L1 is known to be 'list', and L2 is
  +    %% known to be 'cons'. Then if 'L1 =:= L2' evaluates to 'true', it can
  +    %% be inferred that L1 is 'cons' (the meet of 'cons' and 'list').
  +    LType = raw_type(LHS, Ts),
  +    RType = raw_type(RHS, Ts),
  +    Type = beam_types:meet(LType, RType),
  +
  +    PosTypes = [{V,Type} || {V, OrigType} <- [{LHS, LType}, {RHS, RType}],
  +                            OrigType =/= Type],
  +
  +    %% We must be careful with types inferred from '=:='.
  +    %%
  +    %% If we have seen L =:= [a], we know that L is 'cons' if the
  +    %% comparison succeeds. However, if the comparison fails, L could
  +    %% still be 'cons'. Therefore, we must not subtract 'cons' from the
  +    %% previous type of L.
  +    %%
  +    %% However, it is safe to subtract a type inferred from '=:=' if
  +    %% it is single-valued, e.g. if it is [] or the atom 'true'.
  +    NegTypes = case beam_types:is_singleton_type(Type) of
  +                   true -> PosTypes;
  +                   false -> []
  +               end,
  +
  +    {PosTypes, NegTypes};
  +infer_type({bif,'=:='}, [#b_var{}=Src,#b_literal{}=Lit], Ts, Ds) ->
  +    Def = maps:get(Src, Ds),
  +    Type = raw_type(Lit, Ts),
  +    EqLitTypes = infer_eq_lit(Def, Lit),
  +    PosTypes = [{Src,Type} | EqLitTypes],
  +    {PosTypes, EqLitTypes};
   infer_type(_Op, _Args, _Ts, _Ds) ->
       {[], []}.
   
  
positive.code:     {[T], [T]};
  infer_success_type(_Op, _Args, _Ts, _Ds) ->
      {[], []}.
  
  join_types(Ts0, Ts1) ->
      if
  
negative.code: 
  infer_types_br(#b_var{}=V, Ts, #d{ds=Ds}) ->
      #{V:=#b_set{op=Op,args=Args}} = Ds,
  
      {PosTypes, NegTypes} = infer_type(Op, Args, Ts, Ds),
  
      SuccTs1 = meet_types(PosTypes, Ts),
      FailTs1 = subtract_types(NegTypes, Ts),
  
      SuccTs = infer_br_value(V, Ts, true, SuccTs1),
  