anchor.diff:        Block :: beam_ssa:b_blk().
   
   opt(Linear, Args) ->
  +    UsedOnce = used_once(Linear, Args),
       Ts = maps:from_list([{V,any} || #b_var{}=V <- Args]),
       FakeCall = #b_set{op=call,args=[#b_remote{mod=#b_literal{val=unknown},
                                                 name=#b_literal{val=unknown},
                                                 arity=0}]},
       Defs = maps:from_list([{Var,FakeCall#b_set{dst=Var}} ||
                                 #b_var{}=Var <- Args]),
  -    D = #d{ds=Defs,ls=#{0=>Ts},sub=#{}},
  +    D = #d{ds=Defs,ls=#{0=>Ts,?BADARG_BLOCK=>#{}},
  +           once=UsedOnce,sub=#{}},
       opt_1(Linear, D).
   
   opt_1([{L,Blk}|Bs], #d{ls=Ls}=D) ->
  
positive.code: 
  update_successors(#b_br{bool=#b_literal{val=true},succ=S}, Ts, D) ->
      update_successor(S, Ts, D);
  update_successors(#b_br{bool=#b_var{}=Bool,succ=Succ,fail=Fail}, Ts, D0) ->
      D = update_successor_bool(Bool, false, Fail, Ts, D0),
      SuccTs = infer_types(Bool, Ts, D0),
      update_successor_bool(Bool, true, Succ, SuccTs, D);
  update_successors(#b_switch{arg=#b_var{}=V,fail=Fail,list=List}, Ts, D0) ->
      D = update_successor(Fail, Ts, D0),
      foldl(fun({Val,S}, A) ->
                    T = get_type(Val, Ts),
                    update_successor(S, Ts#{V=>T}, A)
            end, D, List);
  update_successors(#b_ret{}, _Ts, D) -> D.
  
  update_successor_bool(#b_var{}=Var, BoolValue, S, Ts, D) ->
  
negative.code:             update_successor(S, Ts, D)
      end.
  
  update_successor(?BADARG_BLOCK, _Ts, #d{}=D) ->
      %% We KNOW that no variables are used in the ?BADARG_BLOCK,
      %% so there is no need to update the type information. That
      %% can be a huge timesaver for huge functions.
      D;
  update_successor(S, Ts0, #d{ls=Ls}=D) ->
      case Ls of
          #{S:=Ts1} ->
  