anchor.diff:          false -> Type
       end.
   
  +%% Generic
  +bif_arg_types(tuple_size, [_]) -> [{tuple,[0],#{}}];
  +bif_arg_types(map_size, [_]) -> [map];
  +bif_arg_types(length, [_]) -> [list];
  +bif_arg_types(hd, [_]) -> [cons];
  +bif_arg_types(tl, [_]) -> [cons];
  +%% Boolean
  +bif_arg_types('not', [_]) -> [bool];
  +bif_arg_types('and', [_,_]) -> [bool, bool];
  +bif_arg_types('or', [_,_]) -> [bool, bool];
  +bif_arg_types('xor', [_,_]) -> [bool, bool];
  +%% Binary
  +bif_arg_types('byte_size', [_]) -> [binary];
  +bif_arg_types('bit_size', [_]) -> [binary];
  +%% Numerical
  +bif_arg_types('-', [_]) -> [number];
  +bif_arg_types('+', [_]) -> [number];
  +bif_arg_types('*', [_,_]) -> [number, number];
  +bif_arg_types('/', [_,_]) -> [number, number];
  +bif_arg_types(ceil, [_]) -> [number];
  +bif_arg_types(floor, [_]) -> [number];
  +bif_arg_types(trunc, [_]) -> [number];
  +bif_arg_types(round, [_]) -> [number];
  +%% Integer-specific
  +bif_arg_types('div', [_,_]) -> [{integer,[]}, {integer,[]}];
  +bif_arg_types('rem', [_,_]) -> [{integer,[]}, {integer,[]}];
  +bif_arg_types('band', [_,_]) -> [{integer,[]}, {integer,[]}];
  +bif_arg_types('bor', [_,_]) -> [{integer,[]}, {integer,[]}];
  +bif_arg_types('bxor', [_,_]) -> [{integer,[]}, {integer,[]}];
  +bif_arg_types('bnot', [_]) -> [{integer,[]}];
  +bif_arg_types('bsl', [_,_]) -> [{integer,[]}, {integer,[]}];
  +bif_arg_types('bsr', [_,_]) -> [{integer,[]}, {integer,[]}];
  +%% Unsafe type tests that may fail if an argument doesn't have the right type.
  +bif_arg_types(is_function, [_,_]) -> [term, {integer,[]}];
  +bif_arg_types(_, Args) -> [term || _Arg <- Args].
  +
   bif_type('-', Src, Vst) ->
       arith_type(Src, Vst);
   bif_type('+', Src, Vst) ->
  
positive.code:     extract_term(Type, Ss, Dst, Vst);
  valfun_4({bif,Op,{f,Fail},Ss,Dst}, Vst0) ->
      validate_src(Ss, Vst0),
      Vst = branch_state(Fail, Vst0),
      Type = bif_type(Op, Ss, Vst),
      extract_term(Type, Ss, Dst, Vst);
  valfun_4({gc_bif,Op,{f,Fail},Live,Ss,Dst}, #vst{current=St0}=Vst0) ->
  
negative.code:     St = kill_heap_allocation(St0),
      Vst1 = Vst0#vst{current=St},
      Vst2 = branch_state(Fail, Vst1),
  
      ArgTypes = bif_arg_types(Op, Ss),
      Vst3 = foldl(fun({Arg, T}, Vsti) ->
                           update_type(fun meet/2, T, Arg, Vsti)
                   end, Vst2, zip(Ss, ArgTypes)),
  
      Type = bif_type(Op, Ss, Vst3),
      Vst = prune_x_regs(Live, Vst3),
      extract_term(Type, Ss, Dst, Vst, Vst0);
  