contents.add(checkNotNull(element), occurrences);
      return this;
    }

    /**
     * Adds or removes the necessary occurrences of an element such that the element attains the
     * desired count.
     *
     * @param element the element to add or remove occurrences of
     * @param count the desired count of the element in this multiset
     * @return this {@code Builder} object

        // Store and retrieve data
        TestAccessResultData<Object> accessData = new TestAccessResultData<>();
        accessData.setData(resultData.getData());
        // URL handling removed as ResultData doesn't have getUrl()

        Object retrievedData = transformer.getData(accessData);
        assertEquals(" Test Content ", retrievedData);
    }

  }

  /**
   * Marks this step as the last step in the {@code ClosingFuture} pipeline. When this step is done,
   * {@code receiver} will be called with an object that contains the result of the operation. The
   * receiver can store the {@link ValueAndCloser} outside the receiver for later synchronous use.
   *
   * <p>After calling this method, you may not call {@link #finishToFuture()}, this method again, or

    waiter2.start();
    waiter2.awaitWaiting();
    // The waiter queue should be waiter2->waiter1

    // This should wake up waiter1 and cause the waiter1 node to be removed.
    waiter1.interrupt();

    waiter1.join();
    waiter2.awaitWaiting(); // should still be blocked

    LockSupport.unpark(waiter2); // spurious wakeup

pkg debug/plan9obj, type FileHeader struct, HdrSize uint64
pkg debug/plan9obj, type FileHeader struct, LoadAddress uint64

# CL 122960043 encoding/xml: add InputOffset method to Decoder, Russ Cox <******@****.***>
pkg encoding/xml, method (*Decoder) InputOffset() int64

# CL 124940043 cmd/go, go/build: implement import comment checking, Russ Cox <******@****.***>
pkg go/build, const ImportComment = 4

      putNext(this, next);
    }

    void unpark() {
      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call
      // unpark even though the thread has already removed itself from the list. But even if we did
      // use a CAS, that race would still exist (it would just be ever so slightly smaller).
      Thread w = thread;
      if (w != null) {
        thread = null;

        });
    }

    /**
     * Deletes all crawling sessions and their parameters except for the specified active sessions.
     * This is a cleanup operation that removes inactive session data while preserving active ones.
     *
     * @param activeSessionId a set of session IDs to preserve during the cleanup operation
     */

      return connection.client == streamIsClient
    }

  val isSourceComplete: Boolean
    get() = withLock { source.finished && source.readBuffer.exhausted() }

  /**
   * Removes and returns the stream's received response headers, blocking if necessary until headers
   * have been received. If the returned list contains multiple blocks of headers the blocks will be
   * delimited by 'null'.
   *

 *
 * <h4>Guarantees</h4>
 *
 * <p>Each makes the following guarantees:
 *
 * <ul>
 *   <li><b>Shallow immutability.</b> Elements can never be added, removed or replaced in this
 *       collection. This is a stronger guarantee than that of {@link
 *       Collections#unmodifiableCollection}, whose contents change whenever the wrapped collection
 *       is modified.

   * TypeVariableImpl} today. (We could probably then make {@code TypeVariableImpl} implement {@code
   * AnnotatedElement} so that we get partial compile-time checking.)
   *
   * <p>This workaround should be removed at a distant future time when <a
   * href="https://issuetracker.google.com/issues/115932459">Android supports {@code
   * AnnotatedType}</a>.
   */
  @SuppressWarnings("removal") // b/318391980