docs: private void _deregisterAsynchConsumerCallback(boolean stoppable)
        throws SISessionUnavailableException, SISessionDroppedException,
               SIConnectionUnavailableException, SIConnectionDroppedException,
               SIErrorException,
               SIIncorrectCallException
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "_deregisterAsynchConsumerCallback","stoppable="+stoppable);
  
        if (executingOnCallbackThread())
        {
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "called from within asynch consumer callback, callbackThreadState="+callbackThreadState);
  
           if (callbackThreadState == CallbackThreadState.CLOSED ||
               state == StateEnum.CLOSED || state == StateEnum.CLOSING)
           {
              throw new SISessionUnavailableException(nls.getFormattedMessage("SESSION_CLOSED_SICO1013", null, null));
           }
           else if (callbackThreadState == CallbackThreadState.STARTED_DEREGISTERED ||
                    callbackThreadState == CallbackThreadState.STARTED_REGISTERED)
           {
              throw new SIIncorrectCallException(nls.getFormattedMessage("CALLBACK_CHANGE_WHILE_STARTED_SICO1015", null, null));
           }
           else
           {
              callbackThreadCallback = null;
              if (callbackThreadState == CallbackThreadState.STOPPED_REGISTERED)
              {
                 callbackThreadState = CallbackThreadState.STOPPED_DEREGISTERED;
              }
           }
        }
        else
        {
          if (state == StateEnum.STARTED) {
            throw new SIIncorrectCallException(nls.getFormattedMessage("CALLBACK_CHANGE_WHILE_STARTED_SICO1015", null, null));
          }
  
           synchronized (callbackLock) {
             synchronized(synchLock)
             {
                if (asynchConsumerRegistered)
                {
                   asynchConsumerRegistered = false;
  
                   proxyQueue.setAsynchCallback(null, 0, 0, 0, null, 0, 0, stoppable);                           //SIB0115d.comms,472879
  
                   // If we are not read ahead get the queue cleaned up by GC
                   if (!isReadAhead) proxyQueue = null;
  
                   if (currentOrderingContext != null)
                   {
                      currentOrderingContext.decrementUseCount();
                      currentOrderingContext = null;
                   }
                }
  
             }
           }
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "_deregisterAsynchConsumerCallback");
      }