docs: static void rcvSendChunkedToExceptionDest(CommsServerByteBuffer request,
                                               Conversation conversation,
                                               int requestNumber,
                                               boolean allocatedFromBufferPool,
                                               boolean partOfExchange)
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "rcvSendChunkedToExceptionDest",
                                             new Object[]
                                             {
                                                request,
                                                conversation,
                                                ""+requestNumber,
                                                ""+allocatedFromBufferPool,
                                                ""+partOfExchange
                                             });
  
        ServerLinkLevelState linkState = (ServerLinkLevelState) conversation.getLinkLevelAttachment();
        ConversationState convState = (ConversationState) conversation.getAttachment();
  
        final boolean txOptimized = CommsUtils.requiresOptimizedTransaction(conversation);
  
        ChunkedMessageWrapper wrapper = null;
  
        /**************************************************************/
        /* Connection object id                                       */
        /**************************************************************/
        short connectionObjectId = request.getShort();  // BIT16 ConnectionObjectId
  
        /**************************************************************/
        /* Transaction id                                             */
        /**************************************************************/
        int transactionId = request.getSITransactionId(connectionObjectId, linkState, txOptimized);
  
        /**************************************************************/
        /* Chunk flags                                                */
        /**************************************************************/
        byte flags = request.get();
        boolean first = ((flags & CommsConstants.CHUNKED_MESSAGE_FIRST) == CommsConstants.CHUNKED_MESSAGE_FIRST);
        boolean last = ((flags & CommsConstants.CHUNKED_MESSAGE_LAST) == CommsConstants.CHUNKED_MESSAGE_LAST);
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
           SibTr.debug(tc, "connectionObjectId", connectionObjectId);
           SibTr.debug(tc, "transactionId", transactionId);
           SibTr.debug(tc, "flags", flags);
        }
  
        long wrapperId = StaticCATProducer.getWrapperId(connectionObjectId, (short) 0, transactionId);
  
        // If this is the first chunk of data, create a wrapper to save it in. Otherwise retrieve the
        // wrapper to append to.
        if (first)
        {
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "This is the first chunk of data");
  
           /**************************************************************/
           /* Destination address                                        */
           /**************************************************************/
           SIDestinationAddress destAddr = request.getSIDestinationAddress(conversation.getHandshakeProperties().getFapLevel());
  
           /**************************************************************/
           /* Reason code                                                */
           /**************************************************************/
           int reason = request.getInt();
  
           /**************************************************************/
           /* Alternate user                                             */
           /**************************************************************/
           String alternateUser = request.getString();
  
           /**************************************************************/
           /* Message Inserts                                            */
           /**************************************************************/
           String[] inserts = null;
           int numberOfInserts = request.getShort();
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Number of inserts", ""+numberOfInserts);
  
           if (numberOfInserts != 0)
           {
              inserts = new String[numberOfInserts];
  
              for (int x = 0; x < numberOfInserts; x++)
              {
                 inserts[x] = request.getString();
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Insert[" + x + "] = " + inserts[x]);
              }
           }
  
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
           {
              SibTr.debug(tc, "DestinationAddress", destAddr);
              SibTr.debug(tc, "Reason", ""+reason);
              SibTr.debug(tc, "AlternateUser", alternateUser);
              SibTr.debug(tc, "Message Inserts", Arrays.toString(inserts));
           }
  
           SICoreConnection connection =
              ((CATConnection) convState.getObject(connectionObjectId)).getSICoreConnection();
  
           // Get the transaction
           SITransaction siTran = linkState.getTransactionTable().get(transactionId);
  
           // Create a wrapper for this data to stash in the conversation state
           wrapper = new ChunkedMessageWrapper(siTran, connection, destAddr, reason, alternateUser, inserts);
           convState.putChunkedMessageWrapper(wrapperId, wrapper);
        }
        else
        {
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Appending to chunks already collected");
           wrapper = convState.getChunkedMessageWrapper(wrapperId);
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Appending to wrapper: ", wrapper);
        }
  
        // If the wrapper is null at this point, this is messed up
        if (wrapper == null)
        {
           SIErrorException e = new SIErrorException(
              TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE, "CHUNK_WRAPPER_NULL_SICO2165", null, null)
           );
           FFDCFilter.processException(e, CLASS_NAME + ".rcvSendChunkedToExceptionDest",
                                       CommsConstants.STATICCATDESTINATION_SENDCHUNKEDTOEXCEP_01,
                                       ""+wrapperId);
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Chunked message wrapper is null!");
           throw e;
        }
  
        // Now get the chunk from the message and add it to the wrapper
        wrapper.addDataSlice(request.getDataSlice());
  
  
        // If this was the last slice we have received all the data we need and we must now send the
        // message into the bus and (possibly) send back a reply to the client.
        if (last)
        {
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "This is the last chunk - sending message");
  
           // Remove the chunks from the conversation state
           convState.removeChunkedMessageWrapper(wrapperId);
  
           try
           {
              // Recreate the message
              SIBusMessage sibMessage = JsMessageFactory.getInstance().createInboundJsMessage(wrapper.getMessageData());
  
         
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              {
                 SibTr.debug(tc, "Sending exception message - " + sibMessage);
                 SibTr.debug(tc, "Destination: " + wrapper.getDestinationAddress());
                 SibTr.debug(tc, "Discriminator: " + sibMessage.getDiscriminator());
                 SibTr.debug(tc, "Reliability: " + sibMessage.getReliability());
              }
  
              if (wrapper.getTransaction() != IdToTransactionTable.INVALID_TRANSACTION)
              {
                 wrapper.getConnection().sendToExceptionDestination(wrapper.getDestinationAddress(),
                                                                    sibMessage,
                                                                    wrapper.getReason(),
                                                                    wrapper.getMessageInserts(),
                                                                    wrapper.getTransaction(),
                                                                    wrapper.getAlternateUser());
              }
  
              try
              {
                 conversation.send(poolManager.allocate(),
                                   JFapChannelConstants.SEG_SEND_CHUNKED_TO_EXCEPTION_DESTINATION_R,
                                   requestNumber,
                                   JFapChannelConstants.PRIORITY_MEDIUM,
                                   true,
                                   ThrottlingPolicy.BLOCK_THREAD,
                                   null);
              }
              catch (SIException e)
              {
                 FFDCFilter.processException(e,
                                             CLASS_NAME + ".rcvSendChunkedToExceptionDest",
                                             CommsConstants.STATICCATDESTINATION_SENDCHUNKEDTOEXCEP_02);
  
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
                 SibTr.error(tc, "COMMUNICATION_ERROR_SICO2022", e);
              }
           }
           catch (SINotAuthorizedException e)
           {
              // No FFDC Code Needed
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    null,
                                                    conversation, requestNumber);
           }
           catch (SIException e)
           {
              //No FFDC code needed
              //Only FFDC if we haven't received a meTerminated event.
              if(!convState.hasMETerminated())
              {
                 FFDCFilter.processException(e,
                                             CLASS_NAME + ".rcvSendChunkedToExceptionDest",
                                             CommsConstants.STATICCATDESTINATION_SENDCHUNKEDTOEXCEP_03);
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATDESTINATION_SENDCHUNKEDTOEXCEP_03,
                                                    conversation, requestNumber);
           }
           catch (Exception e)
           {
              FFDCFilter.processException(e,
                                          CLASS_NAME + ".rcvSendChunkedToExceptionDest",
                                          CommsConstants.STATICCATDESTINATION_SENDCHUNKEDTOEXCEP_04);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATDESTINATION_SENDCHUNKEDTOEXCEP_04,
                                                    conversation, requestNumber);
           }
        }
  
        if (allocatedFromBufferPool) request.release();
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "rcvSendChunkedToExceptionDest");
     }