anchor.diff:          true ->
               case make_literal_list(Args) of
                   none ->
  -                    eval_bif_1(I, Bif, concrete_types(Args, Ts));
  +                    eval_bif_1(I, Bif, Ts, Ds);
                   LitArgs ->
                       try apply(erlang, Bif, LitArgs) of
                           Val -> #b_literal{val=Val}
  
positive.code:         #t_union{list=nil} ->
              I0#b_set{op={bif,'=:='},args=[Src,#b_literal{val=[]}]};
          _ ->
              eval_bif(I0, Ts)
      end;
  simplify(#b_set{op={bif,Op},args=Args}=I, Ts) ->
      Types = normalized_types(Args, Ts),
      case is_float_op(Op, Types) of
          false ->
              eval_bif(I, Ts);
          true ->
              AnnoArgs = [anno_float_arg(A) || A <- Types],
              eval_bif(beam_ssa:add_anno(float_op, AnnoArgs, I), Ts)
      end;
  simplify(#b_set{op=bs_extract,args=[Ctx]}=I, Ts) ->
      case concrete_type(Ctx, Ts) of
          #t_bitstring{} ->
  
negative.code:                 false ->
                      I
              end;
          [#t_integer{},#t_integer{}] ->
              reassociate(I, Ts, Ds);
          _ ->
              I
      end.
  
  reassociate(#b_set{op={bif,OpB},args=[#b_var{}=V0,#b_literal{val=B0}]}=I, _Ts, Ds)
    when OpB =:= '+'; OpB =:= '-' ->
      case map_get(V0, Ds) of
          #b_set{op={bif,OpA},args=[#b_var{}=V,#b_literal{val=A0}]}
            when OpA =:= '+'; OpA =:= '-' ->
              A = erlang:OpA(A0),
              B = erlang:OpB(B0),
              case A + B of
                  Combined when Combined < 0 ->
                      I#b_set{op={bif,'-'},args=[V,#b_literal{val=-Combined}]};
                  Combined when Combined >= 0 ->
                      I#b_set{op={bif,'+'},args=[V,#b_literal{val=Combined}]}
              end;
          #b_set{} ->
              I
      end;
  reassociate(I, _Ts, _Ds) -> I.
  
  simplify_args(Args, Ts, Sub) ->
      [simplify_arg(Arg, Ts, Sub) || Arg <- Args].
  