docs: public List writeAckPrefix(long stamp)
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(this, tc, "writeAckPrefix", Long.valueOf(stamp));
  
      // Holds TickRanges of all Value ticks between AckPrefix
      // and completedPrefix
      // This is returned to the caller
      List<TickRange> indexList = new ArrayList<TickRange>();
         
      synchronized (this)
      {
        // SIB0105
        // Update controllable health state if poss
        if (stamp >= lastAckExpTick)
        {
          getControlAdapter().getHealthState().updateHealth(HealthStateListener.ACK_EXPECTED_STATE, 
                                                            HealthState.GREEN);
          // Disable the checking until another ackExpected is sent
          lastAckExpTick = Long.MAX_VALUE;
        }
        if (stamp >= lastNackReceivedTick)
        {
          getControlAdapter().getHealthState().updateHealth(HealthStateListener.NACK_RECEIVED_STATE, 
                                          HealthState.GREEN);
          // Disable the checking until another ackExpected is sent
          lastNackReceivedTick = Long.MAX_VALUE;
        }
        
        inboundFlow = true;
        long completedPrefix = oststream.getCompletedPrefix();
        if (stamp > completedPrefix)
        {
          // Retrieve all Value ticks between completedPrefix and stamp
          oststream.setCursor(completedPrefix + 1);
  
          // Get the first TickRange
          TickRange tr = oststream.getNext();
  
          TickRange tr2 = null;
          while ((tr.startstamp <= stamp) && (tr != tr2))
          {
            if (tr.type == TickRange.Value)
            {
              indexList.add(tr);
              totalMessagesSent++;
              timeLastMsgSent = System.currentTimeMillis();
            }
            else if (tr.type != TickRange.Completed)
            {
              //See defect 278043:
              //The remote ME is trying to ACK a tick that we do not understand.
              //Perhaps we went down just after the message was sent and the
              //message was lost from our message store, so that it is now UNKNOWN.
              //We do not want to stop processing this ACK however, as that
              //would mean that there will always be a hole and we will eventually
              //hit the sendMsgWindow.
              //We should log the event in trace & FFDC and then continue
              //to process the ack.
              if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              {
                SibTr.debug(tc, 
                            "Invalid message found processing ack stamp " 
                            + stamp + ": completed prefix " + completedPrefix, 
                            tr);
              }
              
              //ffdc incase trace is not enabled, but we do not go on to
              //throw this exception
              InvalidMessageException invalidMessageException = 
                new InvalidMessageException(); 
              FFDCFilter.processException(
                invalidMessageException,
                "com.ibm.ws.sib.processor.gd.SourceStream.writeAckPrefix",
                "1:981:1.138",
                this,
                new Object[]{Long.valueOf(stamp), Long.valueOf(completedPrefix), tr});
                
              // We only want to force any unknown ranges to 'completed' up to
              // the ack'd tick, beyond that should stay 'unknown' so we crop the
              // current TickRange to be up to the ack'd tick.
              long endstamp = tr.endstamp;
              if(endstamp > stamp)
                endstamp = stamp;
                
              TickRange completedTr =
                new TickRange(
                  TickRange.Completed,
                  tr.startstamp,
                  endstamp );              
                
              oststream.writeCompletedRangeForced(completedTr);
              
            }
            tr2 = tr;
            tr = oststream.getNext(); // get next TickRange
          } // end while
          
          // 513948
          // If we acked more messages than the sendWindow then we need to grow the sendwindow
          // to be bigger than the definedSendWindow. This will reduce back down to the correct value
          // when the msgs are removed. We also set the correct firstMsgOutsideWindow at this point.
          if (indexList.size() > sendWindow)
          {
            sendWindow = indexList.size(); // Dont need to persist - this will be done when msg removed
            // Find the firstMsgOutsideWindow if it exists
            while( tr.type == TickRange.Completed && tr.endstamp != RangeList.INFINITY)
              tr = oststream.getNext();
            
            firstMsgOutsideWindow = tr.valuestamp;
  
            if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              SibTr.debug(tc, "firstMsgOutsideWindow: " + firstMsgOutsideWindow + ", sendWindow: " + sendWindow);
          }
  
          oststream.setCompletedPrefix(stamp);
  
          // May have moved beyond stamp if there were adjacent
          // Completed ticks
          oack = oststream.getCompletedPrefix();
        }
      } // end sync
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "writeAckPrefix", Boolean.FALSE);
  
      return indexList;
  
    }