docs: private void processIncludeList() {
  
          byte[] result = getWriterBytes();
          if (!hasIncludeList()) {
              // no include list, so no includes and we just use the bytes as they are in one block
              m_cachedEntry.add(result);
          } else {
              // process the include list
              int max = result.length;
              int pos = 0;
              int last = 0;
              int size = 0;
              int count = 0;
  
              // work through result and split this with include list calls
              int i = 0;
              while ((i < m_includeList.size()) && (pos < max)) {
                  // look for the first FLEX_CACHE_DELIMITER char
                  while ((pos < max) && (result[pos] != FLEX_CACHE_DELIMITER)) {
                      pos++;
                  }
                  if ((pos < max) && (result[pos] == FLEX_CACHE_DELIMITER)) {
                      count++;
                      // a byte value of C_FLEX_CACHE_DELIMITER in our (String) output list indicates
                      // that the next include call must be placed here
                      size = pos - last;
                      if (size > 0) {
                          // if not (it might be 0) there would be 2 include calls back 2 back
                          byte[] piece = new byte[size];
                          System.arraycopy(result, last, piece, 0, size);
                          // add the byte array to the cache entry
                          m_cachedEntry.add(piece);
                          piece = null;
                      }
                      last = ++pos;
                      // add an include call to the cache entry
                      m_cachedEntry.add(
                          m_includeList.get(i),
                          m_includeListParameters.get(i),
                          m_includeListAttributes.get(i));
                      i++;
                  }
              }
              if (pos < max) {
                  // there is content behind the last include call
                  size = max - pos;
                  byte[] piece = new byte[size];
                  System.arraycopy(result, pos, piece, 0, size);
                  m_cachedEntry.add(piece);
                  piece = null;
              }
              if (i >= m_includeList.size()) {
                  // clear the include list if all include calls are handled
                  m_includeList = null;
                  m_includeListParameters = null;
                  m_includeListAttributes = null;
              } else {
                  // if something is left, remove the processed entries
                  m_includeList = m_includeList.subList(count, m_includeList.size());
                  m_includeListParameters = m_includeListParameters.subList(count, m_includeListParameters.size());
                  m_includeListAttributes = m_includeListAttributes.subList(count, m_includeListAttributes.size());
              }
          }
      }