offset: Annotated[
            int,
            Doc(
                """
                The position in bytes to seek to in the file.
                """
            ),
        ],
    ) -> None:
        """
        Move to a position in the file.

        Any next read or write will be done from that position.

        To be awaitable, compatible with async, this is run in threadpool.
        """

  @Override
  int indexOf(@Nullable Object target) {
    if (target == null) {
      return -1;
    }
    int position;
    try {
      position = Collections.binarySearch(elements, target, unsafeComparator());
    } catch (ClassCastException e) {
      return -1;
    }
    return (position >= 0) ? position : -1;
  }

  @Override
  ImmutableList<E> createAsList() {

        private String reading;

        public TestAnalyzeToken(String term, int position, int startOffset, int endOffset, int positionIncrement, String type,
                java.util.Map<String, Object> attributes) {
            super(term, position, startOffset, endOffset, positionIncrement, type, attributes);
        }

        public String getReading() {
            return reading;

  private void addToCache(K key, V value) {
    addToCache(new CacheEntry<K, V>(key, value));
  }

  private void addToCache(CacheEntry<K, V> entry) {
    // Slide new entry into first cache position. Drop previous entry in second cache position.
    cacheEntry2 = cacheEntry1;
    cacheEntry1 = entry;
  }

  private static final class CacheEntry<K, V> {
    final K key;
    final V value;

    CacheEntry(K key, V value) {

The scanner now allows retrieving the end position of a token via the new [Scanner.End] method....

      }
      return crossOverUp(index, x);
    }

    /**
     * Fills the hole at {@code index} by moving in the least of its grandchildren to this position,
     * then recursively filling the new hole created.
     *
     * @return the position of the new hole (where the lowest grandchild moved from, that had no
     *     grandchild to replace it)
     */
    int fillHoleAt(int index) {

        NdrHyper hyper = new NdrHyper(original);
        // Create buffer with extra space for alignment
        NdrBuffer buf = new NdrBuffer(new byte[16], 0);
        hyper.encode(buf);
        // Reset buffer position for decoding
        buf.reset();
        NdrHyper decoded = new NdrHyper(0);
        decoded.decode(buf);
        assertEquals(original, decoded.value, "Decoded value should match encoded value");
    }

    /**

      }
      return crossOverUp(index, x);
    }

    /**
     * Fills the hole at {@code index} by moving in the least of its grandchildren to this position,
     * then recursively filling the new hole created.
     *
     * @return the position of the new hole (where the lowest grandchild moved from, that had no
     *     grandchild to replace it)
     */
    int fillHoleAt(int index) {

	// Text returns the original string representation of the token.
	Text() string
	// File reports the source file name of the token.
	File() string
	// Base reports the position base of the token.
	Base() *src.PosBase
	// SetBase sets the position base.
	SetBase(*src.PosBase)
	// Line reports the source line number of the token.
	Line() int
	// Col reports the source column number of the token.
	Col() int

     * @param dstIndex the starting position in the buffer
     * @return number of bytes written
     */
    protected abstract int writeBytesWireFormat(byte[] dst, int dstIndex);

    /**
     * Reads the message body from the wire format.
     *
     * @param buffer the buffer to read from
     * @param bufferIndex the starting position in the buffer
     * @return number of bytes read