*       href="https://github.com/google/guava/wiki/GraphsExplained#elements-must-be-useable-as-map-keys">
   *       notes on element objects</a> for more information.)
   *   <li>While traversing, the traverser will use <i>O(n)</i> space (where <i>n</i> is the number
   *       of nodes that have thus far been visited), plus <i>O(H)</i> space (where <i>H</i> is the

        queue = new PriorityQueue<>(100, new MyTokensComparator());
        this.synonyms = new ArrayList<>();
    }

    @Override
    public boolean incrementToken() throws IOException {
        while (true) {
            final MyToken nextToken = getNextUniqueToken(queue, prevToken);
            if (nextToken == null) {
                getNextBlock();
                if (block.length() == 0) {

        final int maxSize = getContext().getConfig().getMaximumBufferSize();

        while (curHead != null) {
            CommonServerMessageBlockRequest nextHead = null;
            int totalSize = 0;
            int n = 0;
            CommonServerMessageBlockRequest last = null;
            CommonServerMessageBlockRequest chain = curHead;
            while (chain != null) {
                n++;
                final int size = chain.size();

    }

    static void checkFile(BiConsumer<Integer, String> log, int max, String... lineArray) {
        LineItr lines = new LineItr(Arrays.asList(lineArray).iterator());
        while (lines.hasNext()) {
            Matcher m = START.matcher(lines.next());
            if (m.matches()) {
                checkSnippet(log, max, lines, m.group(1), m.group(2));
            }
        }
    }

import java.util.logging.Logger;
import org.jspecify.annotations.Nullable;

/**
 * Thread that finalizes referents. All references should implement {@code
 * com.google.common.base.FinalizableReference}.
 *
 * <p>While this class is public, we consider it to be *internal* and not part of our published API.
 * It is public so we can access it reflectively across class loaders in secure environments.
 *

    assertFullyRead(reader);

    // read in chunks to fixed array
    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {
      builder.append(buf, 0, read);
    }
    assertThat(builder.toString()).isEqualTo(expected);
    assertFullyRead(reader);

    // read all to one CharBuffer

     *
     * @param address the NetBIOS address to connect to
     * @param port the port number, or 0 for the default NetBIOS session service port
     * @throws IOException if an I/O error occurs while creating the socket
     */
    public NbtSocket(final NbtAddress address, final int port) throws IOException {
        this(address, port, null, 0);
    }

    /**

     * @return {@link List} $lt; {@link ArtifactVersion} >
     * @throws ArtifactMetadataRetrievalException
     *          in case of error while retrieving repository metadata from the repository.
     */
    List<ArtifactVersion> retrieveAvailableVersions(
            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories)

    Runnable state = get();
    Blocker blocker = null;
    while (state instanceof Blocker || state == PARKED) {
      if (state instanceof Blocker) {
        blocker = (Blocker) state;
      }
      spinCount++;
      if (spinCount > MAX_BUSY_WAIT_SPINS) {
        /*
         * If we have spun a lot, just park ourselves. This will save CPU while we wait for a slow

 *
 * Typical use loops over the parts in sequence:
 *
 * ```kotlin
 * val response: Response = call.execute()
 * val multipartReader = MultipartReader(response.body!!)
 *
 * multipartReader.use {
 *   while (true) {
 *     val part = multipartReader.nextPart() ?: break
 *     process(part.headers, part.body)
 *   }
 * }
 * ```
 *