anchor.diff:  
   infer_types_br(#b_var{}=V, Ts, #d{ds=Ds}) ->
       #{V:=#b_set{op=Op,args=Args}} = Ds,
  -    {PosTypes0, NegTypes0} = infer_type(Op, Args, Ts, Ds),
  -
  -    %% 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'.
  -
  -    EqTypes = infer_eq_type(Op, Args, Ts, Ds),
  -    NegTypes1 = [P || {_,T}=P <- EqTypes, beam_types:is_singleton_type(T)],
  -
  -    PosTypes = EqTypes ++ PosTypes0,
  +
  +    {PosTypes, NegTypes} = infer_type(Op, Args, Ts, Ds),
  +
       SuccTs1 = meet_types(PosTypes, Ts),
  -
  -    NegTypes = NegTypes0 ++ NegTypes1,
       FailTs1 = subtract_types(NegTypes, Ts),
   
       SuccTs = infer_br_value(V, Ts, true, SuccTs1),
  
positive.code:     {[T], [T]};
  infer_success_type(_Op, _Args, _Ts, _Ds) ->
      {[], []}.
  
  join_types(Ts0, Ts1) ->
      if
  
negative.code:     end.
  
  infer_types_switch(V, Lit, Ts, #d{ds=Ds}) ->
      {PosTypes, _} = infer_type({bif,'=:='}, [V, Lit], Ts, Ds),
      meet_types(PosTypes, Ts).
  
  infer_type(succeeded, [#b_var{}=Src], Ts, Ds) ->
      #b_set{op=Op,args=Args} = maps:get(Src, Ds),
  