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:             Sub#{ Dst => Var }
      end.
  
  simplify(#b_set{op={bif,'and'},args=Args}=I, Ts) ->
      case is_safe_bool_op(Args, Ts) of
          true ->
              case Args of
                  [_,#b_literal{val=false}=Res] -> Res;
                  [Res,#b_literal{val=true}] -> Res;
                  _ -> eval_bif(I, Ts)
              end;
          false ->
              I
      end;
  simplify(#b_set{op={bif,'or'},args=Args}=I, Ts) ->
      case is_safe_bool_op(Args, Ts) of
          true ->
              case Args of
                  [Res,#b_literal{val=false}] -> Res;
                  [_,#b_literal{val=true}=Res] -> Res;
                  _ -> eval_bif(I, Ts)
              end;
          false ->
              I
      end;
  simplify(#b_set{op={bif,element},args=[#b_literal{val=Index},Tuple]}=I0, Ts) ->
      case normalized_type(Tuple, Ts) of
          #t_tuple{size=Size} when is_integer(Index),
                                   1 =< Index,
                                   Index =< Size ->
              I = I0#b_set{op=get_tuple_element,
                           args=[Tuple,#b_literal{val=Index-1}]},
              simplify(I, Ts);
          _ ->
              eval_bif(I0, Ts)
      end;
  simplify(#b_set{op={bif,hd},args=[List]}=I, Ts) ->
      case normalized_type(List, Ts) of
          #t_cons{} ->
              I#b_set{op=get_hd};
          _ ->
              eval_bif(I, Ts)
      end;
  simplify(#b_set{op={bif,tl},args=[List]}=I, Ts) ->
      case normalized_type(List, Ts) of
          #t_cons{} ->
              I#b_set{op=get_tl};
          _ ->
              eval_bif(I, Ts)
      end;
  simplify(#b_set{op={bif,size},args=[Term]}=I, Ts) ->
      case normalized_type(Term, Ts) of
          #t_tuple{} ->
              simplify(I#b_set{op={bif,tuple_size}}, Ts);
  
negative.code:                     %% comparison operator (such as >=) that can be
                      %% translated to test instruction, this
                      %% optimization will eliminate one instruction.
                      simplify(I#b_set{op={bif,'not'},args=[LHS]}, Ts, Ds);
                  {_,_} ->
                      eval_bif(I, Ts, Ds)
              end
      end;
  simplify(#b_set{op={bif,is_list},args=[Src]}=I0, Ts, Ds) ->
      case concrete_type(Src, Ts) of
          #t_union{list=#t_cons{}} ->
              I = I0#b_set{op=is_nonempty_list,args=[Src]},
  