docs: public final void satisfiedRequest(long tick, SIMPMessage msg)
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(tc, "satisfiedRequest", new Object[] { Long.valueOf(tick), msg });
  
      boolean sendMsg = false;
      // used to send a message outside the synchronized block
      long startstamp = tick;
      AOValue value = null;
      boolean transitionToFlushed = false;
  
      synchronized (this)
      {
        try
        {
          if (startedFlush || closed)
          { // unlock the message
            msg.unlockMsg(msg.getLockID(),null,true);
            // change this tick to final
            TickRange r = new TickRange(TickRange.Completed, tick, tick);
            stream.writeCompleted(r);
            transitionToFlushed = tryTransitionToFlushed();
          }
          else
          {
  
            stream.setCursor(tick);
            TickRange r = stream.getNext();
            if (r.type != TickRange.Requested)
            {
              // this tick is no longer requested
              // unlock the message
              msg.unlockMsg(msg.getLockID(),null,true);
            }
            else
            {
              AORequested requested = (AORequested) r.value;
              long waitTime = System.currentTimeMillis() - requested.startTime;
              if (msg
                .getReliability()
                .compareTo(Reliability.RELIABLE_NONPERSISTENT)
                <= 0)
              {
                // Note that this means that the message storage strategy in the MS is either
                // STORE_NEVER or STORE_MAYBE. In either case, we create an AOValue tick with
                // storage strategy equal to STORE_NEVER. In fact, we don't even add this AOValue
                // tick to an ItemStream. Also, we do not persistently lock the message
  
                int reliability = msg.getReliability().getIndex();
                int priority = msg.getMessage().getPriority().intValue();
                // message is already locked. change tick to value state
  
                value =
                  new AOValue(
                    tick,
                    msg,
                    msg.getID(),
                    AbstractItem.STORE_NEVER,
                    0L,
                    waitTime,
                    latestTick[reliability][priority]);
                latestTick[reliability][priority] = tick; // update latestTick
  
                TickRange r2 = TickRange.newValueTick(tick, value, 0L);
  
                stream.writeCombinedRange(r2);
                r2 = stream.findCompletedRange(r2);
                // now start the DecisionExpected timer
                dem.addTimeoutEntry(value);
                // send message if active
                if (active)
                {
                  sendMsg = true;
                  startstamp = r2.startstamp;
                }
              }
              else
              {
                int storagePolicy;
                if (msg
                  .getReliability()
                  .compareTo(Reliability.ASSURED_PERSISTENT)
                  < 0)
                  storagePolicy = AbstractItem.STORE_EVENTUALLY;
                else
                  storagePolicy = AbstractItem.STORE_ALWAYS;
  
                // change the AORequested tick to INSERTING state
                 ((AORequested) r.value).inserting = true;
  
                // message needs to be persistently locked, and tick persisted
                int reliability = msg.getReliability().getIndex();
                int priority = msg.getMessage().getPriority().intValue();
                PersistLockAndTick update =
                  new PersistLockAndTick(
                    tick,
                    msg,
                    storagePolicy,
                    waitTime,
                    latestTick[reliability][priority]);
                latestTick[reliability][priority] = tick; // update latestTick
  
                parent.getPersistLockThread().enqueueWork(update);
                countAsyncUpdatesOutstanding++;
              }
            }
          }
        }
        catch (MessageStoreException e)
        {
          // MessageStoreException shouldn't occur so FFDC.
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.impl.AOStream.satisfiedRequest",
            "1:1058:1.80.3.24",
            this);
  
          SibTr.exception(tc, e);
        }
        catch (Exception e)
        {
          // probably a bug - log error
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.impl.AOStream.satisfiedRequest",
            "1:1069:1.80.3.24",
            this);
          SIErrorException e2 =
            new SIErrorException(
              nls.getFormattedMessage(
                "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                new Object[] {
                  "com.ibm.ws.sib.processor.impl.AOStream",
                  "1:1077:1.80.3.24",
                  e },
                null));
          SibTr.exception(tc, e2);
          SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
            new Object[] {
              "com.ibm.ws.sib.processor.impl.AOStream",
              "1:1084:1.80.3.24",
              e });
        }
      } // end synchronized (this)
  
      if (sendMsg)
      {
        long prevTick = value.getPrevTick();
        parent.sendRemoteGetData(
          msg,
          remoteMEUuid,
          gatheringTargetDestUuid,
          streamId,
          prevTick,
          startstamp,
          tick,
          value.getWaitTime());
  
        msg.releaseJsMessage();
      }
      if (transitionToFlushed)
      {
        parent.sendFlushed(remoteMEUuid, gatheringTargetDestUuid, streamId);
      }
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "satisfiedRequest");
  
    }