anchor.diff:              Br0
       end.
   
  +%%%
  +%%% Calculate the set of variables that are only used once in the
  +%%% block that they are defined in. That will allow us to discard type
  +%%% information for variables that will never be referenced by the
  +%%% successor blocks, potentially improving compilation times.
  +%%%
  +
  +used_once(Linear, Args) ->
  +    Map0 = used_once_1(reverse(Linear), #{}),
  +    Map = maps:without(Args, Map0),
  +    cerl_sets:from_list(maps:keys(Map)).
  +
  +used_once_1([{L,#b_blk{is=Is,last=Last}}|Bs], Uses0) ->
  +    Uses = used_once_2([Last|reverse(Is)], L, Uses0),
  +    used_once_1(Bs, Uses);
  +used_once_1([], Uses) -> Uses.
  +
  +used_once_2([I|Is], L, Uses0) ->
  +    Uses = used_once_uses(beam_ssa:used(I), L, Uses0),
  +    case I of
  +        #b_set{dst=Dst} ->
  +            case Uses of
  +                #{Dst:=[L]} ->
  +                    used_once_2(Is, L, Uses);
  +                #{} ->
  +                    used_once_2(Is, L, maps:remove(Dst, Uses))
  +            end;
  +        _ ->
  +            used_once_2(Is, L, Uses)
  +    end;
  +used_once_2([], _, Uses) -> Uses.
  +
  +used_once_uses([V|Vs], L, Uses) ->
  +    case Uses of
  +        #{V:=Us} ->
  +            used_once_uses(Vs, L, Uses#{V:=[L|Us]});
  +        #{} ->
  +            used_once_uses(Vs, L, Uses#{V=>[L]})
  +    end;
  +used_once_uses([], _, Uses) -> Uses.
  +
  +
   get_types(Values, Ts) ->
       [get_type(Val, Ts) || Val <- Values].
   -spec get_type(beam_ssa:value(), type_db()) -> type().
  
positive.code: 
  -define(UNICODE_INT, #t_integer{elements={0,16#10FFFF}}).
  
  -record(d, {ds :: #{beam_ssa:var_name():=beam_ssa:b_set()},
              ls :: #{beam_ssa:label():=type_db()},
              sub :: #{beam_ssa:var_name():=beam_ssa:value()}
             }).
  
  -define(ATOM_SET_SIZE, 5).
  
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} ->
  