anchor.diff:  
   -define(UNICODE_INT, #t_integer{elements={0,16#10FFFF}}).
   
  --record(d, {ds :: #{beam_ssa:var_name():=beam_ssa:b_set()},
  +-record(d, {ds :: #{beam_ssa:b_var():=beam_ssa:b_set()},
               ls :: #{beam_ssa:label():=type_db()},
  -            sub :: #{beam_ssa:var_name():=beam_ssa:value()}
  +            once :: cerl_sets:set(beam_ssa:b_var()),
  +            sub :: #{beam_ssa:b_var():=beam_ssa:value()}
              }).
   
   -define(ATOM_SET_SIZE, 5).
  
positive.code:             update_successor(S, Ts, D)
      end.
  
  update_successor(S, Ts0, #d{ls=Ls}=D) ->
      case Ls of
          #{S:=Ts1} ->
  
negative.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}, Ts0, D0) ->
      case cerl_sets:is_element(Bool, D0#d.once) of
          true ->
              %% This variable is defined in this block and is only
              %% referenced by this br terminator. Therefore, there is
              %% no need to include the type database passed on to the
              %% successors of this block.
              Ts = maps:remove(Bool, Ts0),
              D = update_successor(Fail, Ts, D0),
              SuccTs = infer_types(Bool, Ts, D0),
              update_successor(Succ, SuccTs, D);
          false ->
              D = update_successor_bool(Bool, false, Fail, Ts0, D0),
              SuccTs = infer_types(Bool, Ts0, D0),
              update_successor_bool(Bool, true, Succ, SuccTs, D)
      end;
  update_successors(#b_switch{arg=#b_var{}=V,fail=Fail,list=List}, Ts0, D0) ->
      case cerl_sets:is_element(V, D0#d.once) of
          true ->
              %% This variable is defined in this block and is only
              %% referenced by this switch terminator. Therefore, there is
              %% no need to include the type database passed on to the
              %% successors of this block.
              Ts = maps:remove(V, Ts0),
              D = update_successor(Fail, Ts, D0),
              F = fun({_Val,S}, A) ->
                          update_successor(S, Ts, A)
                  end,
              foldl(F, D, List);
          false ->
              D = update_successor(Fail, Ts0, D0),
              F = fun({Val,S}, A) ->
                          T = get_type(Val, Ts0),
                          update_successor(S, Ts0#{V=>T}, A)
                  end,
              foldl(F, D, List)
          end;
  update_successors(#b_ret{}, _Ts, D) -> D.
  
  update_successor_bool(#b_var{}=Var, BoolValue, S, Ts, D) ->
  