anchor.diff:  %% # handle_call/3
   %% ---------------------------------------------------------------------------
   
  -handle_call(T, From, #listener{pending = L} = S)
  -  when is_list(L) ->
  -    handle_call(T, From, upgrade(S));
  -
   handle_call({{accept, Ref}, Pid}, _, #listener{ref = Ref,
                                                  pending = {N,Q},
                                                  count = K}
                                        = S) ->
       TPid = accept(Ref, Pid, S),
  -    {reply, {ok, TPid}, downgrade(S#listener{pending = {N-1,Q},
  -                                             count = K+1})};
  +    {reply, {ok, TPid}, S#listener{pending = {N-1,Q},
  +                                   count = K+1}};
   
   handle_call(_, _, State) ->
       {reply, nok, State}.
  
positive.code: handle_info(T, #transport{} = S) ->
      {noreply, #transport{} = t(T,S)};
  
  handle_info(T, #listener{pending = L} = S)
    when is_list(L) ->
      handle_info(T, upgrade(S));
  
  handle_info(T, #listener{} = S) ->
      {noreply, downgrade(#listener{} = l(T,S))}.
  
  %% upgrade/1
  
  upgrade(#listener{pending = [TPid | {0,Q}]} = S) ->
      ets:insert(Q, {TPid, now()}),
      S#listener{pending = {-1,Q}}.
  %% Prior to the possiblity of setting pool_size on in transport
  %% configuration, a new accepting transport was only started following
  %% the death of a predecessor, so that there was only at most one
  
negative.code: %% several accepting transports are started concurrently. Deal with
  %% this by placing the started transports in a new queue of transport
  %% processes waiting for an association.
  
  %% ---------------------------------------------------------------------------
  %% # code_change/3
  