anchor.diff:      #b_local{name=#b_literal{val=Name}, arity=Arity}.
   
   opt_bs([{L, #b_blk{is=Is0,last=Last0}=Blk0} | Bs],
  -       Ds0, Ls0, Fdb0, Sub0, SuccTypes0, Meta, Acc) when is_map_key(L, Ls0) ->
  -
  -    #{ L := Ts0 } = Ls0,
  -    {Is, Ts, Ds, Fdb, Sub} = opt_is(Is0, Ts0, Ds0, Ls0, Fdb0, Sub0, Meta, []),
  -
  -    Last1 = simplify_terminator(Last0, Ts, Ds, Sub),
  -
  -    SuccTypes = update_success_types(Last1, Ts, Ds, Meta, SuccTypes0),
  -    {Last, Ls} = update_successors(Last1, Ts, Ds, Ls0, Meta#metadata.used_once),
  -
  -    Blk = Blk0#b_blk{is=Is,last=Last},
  -    opt_bs(Bs, Ds, Ls, Fdb, Sub, SuccTypes, Meta, [{L,Blk} | Acc]);
  -opt_bs([_Blk | Bs], Ds, Ls, Fdb, Sub, SuccTypes, Meta, Acc) ->
  -    %% This block is never reached. Discard it.
  -    opt_bs(Bs, Ds, Ls, Fdb, Sub, SuccTypes, Meta, Acc);
  +       Ds0, Ls0, Fdb0, Sub0, SuccTypes0, Meta, Acc) ->
  +    case Ls0 of
  +        #{ L := Incoming } ->
  +            {incoming, Ts0} = Incoming,         %Assertion.
  +
  +            {Is, Ts, Ds, Fdb, Sub} =
  +            opt_is(Is0, Ts0, Ds0, Ls0, Fdb0, Sub0, Meta, []),
  +
  +            Last1 = simplify_terminator(Last0, Ts, Ds, Sub),
  +            SuccTypes = update_success_types(Last1, Ts, Ds, Meta, SuccTypes0),
  +
  +            UsedOnce = Meta#metadata.used_once,
  +            {Last, Ls1} = update_successors(Last1, Ts, Ds, Ls0, UsedOnce),
  +
  +            Ls = Ls1#{ L := {outgoing, Ts} },           %Assertion.
  +
  +            Blk = Blk0#b_blk{is=Is,last=Last},
  +            opt_bs(Bs, Ds, Ls, Fdb, Sub, SuccTypes, Meta, [{L,Blk} | Acc]);
  +        #{} ->
  +            %% This block is never reached. Discard it.
  +            opt_bs(Bs, Ds0, Ls0, Fdb0, Sub0, SuccTypes0, Meta, Acc)
  +    end;
   opt_bs([], _Ds, _Ls, Fdb, _Sub, SuccTypes, _Meta, Acc) ->
       {reverse(Acc), Fdb, SuccTypes}.
   
  
positive.code:     end.
  
  sig_bs([{L, #b_blk{is=Is,last=Last0}} | Bs],
         Ds0, Ls0, Fdb, Sub0, SuccTypes0, Meta, State0) when is_map_key(L, Ls0) ->
  
      #{ L := Ts0 } = Ls0,
  
      {Ts, Ds, Sub, State} = sig_is(Is, Ts0, Ds0, Ls0, Fdb, Sub0, State0),
  
      Last = simplify_terminator(Last0, Ts, Ds, Sub),
      SuccTypes = update_success_types(Last, Ts, Ds, Meta, SuccTypes0),
      {_, Ls} = update_successors(Last, Ts, Ds, Ls0, Meta#metadata.used_once),
  
      sig_bs(Bs, Ds, Ls, Fdb, Sub, SuccTypes, Meta, State);
  sig_bs([_Blk | Bs], Ds, Ls, Fdb, Sub, SuccTypes, Meta, State) ->
      %% This block is never reached. Ignore it.
      sig_bs(Bs, Ds, Ls, Fdb, Sub, SuccTypes, Meta, State);
  sig_bs([], _Ds, _Ls, _Fdb, _Sub, SuccTypes, _Meta, State) ->
      {State, SuccTypes}.
  
  
negative.code: 
  join_types(Ts, Ts) ->
      Ts;
  join_types(LHS, RHS) ->
      if
          map_size(LHS) < map_size(RHS) ->
              join_types_1(maps:keys(LHS), RHS, LHS);
          true ->
              join_types_1(maps:keys(RHS), LHS, RHS)
      end.
  
  %% Joins two type maps, keeping the variables that are common to both maps.
  join_types_1([V | Vs], Bigger, Smaller) ->
      case {Bigger, Smaller} of
          {#{ V := Same }, #{ V := Same }} ->
              join_types_1(Vs, Bigger, Smaller);
          {#{ V := LHS }, #{ V := RHS }} ->
              T = beam_types:join(LHS, RHS),
              join_types_1(Vs, Bigger, Smaller#{ V := T });
          {#{}, #{ V := _ }} ->
              join_types_1(Vs, Bigger, maps:remove(V, Smaller))
      end;
  join_types_1([], _Bigger, Smaller) ->
      Smaller.
  
  meet_types([{V,T0}|Vs], Ts) ->
      #{V:=T1} = Ts,
  