defer h.workers.Add(-1)

	h.wg.Add(1)
	defer h.wg.Done()

	entries := make([]any, 0)
	name := h.Name()

	defer func() {
		// re-load the global buffer pointer
		// in case it was modified by a new target.
		logChLock.Lock()
		currentGlobalBuffer, ok := logChBuffers[name]
		logChLock.Unlock()
		if !ok {
			return
		}

		for _, v := range entries {
			select {

 * limitations under the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.truth.Truth.assertThat;
import static java.lang.Math.max;
import static java.lang.reflect.Modifier.isStatic;
import static java.util.concurrent.TimeUnit.MICROSECONDS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;

         * type resolution are unclear and have changed across Java versions. Until there's
         * a clear specification for what annotations should mean on resolved TypeVariables
         * with modified bounds, annotation methods will throw
         * UnsupportedOperationException. Frameworks requiring annotation preservation
         * should use the original TypeVariable when bounds haven't changed.
         */

  public int size() {
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      return count;
    } finally {
      monitor.leave();
    }
  }

  // this doc comment is a modified copy of the inherited doc comment,
  // without the reference to unlimited queues.
  /**
   * Returns the number of additional elements that this queue can ideally (in the absence of memory

 * limitations under the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.truth.Truth.assertThat;
import static java.lang.Math.max;
import static java.lang.reflect.Modifier.isStatic;
import static java.util.concurrent.TimeUnit.MICROSECONDS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;

                // resolveDfs() and tree.send() modify the request packet.
                // I want to restore it before retrying. request.reset()
                // restores almost everything that was modified, except the path.
                rpath.setPath(savedPath);
                rpath.setFullUNCPath(rpath.getDomain(), rpath.getServer(), savedFullPath);
            }
            if (response != null) {

    /** The key of the message: by Last Modified (asc) */
    public static final String LABELS_search_result_sort_last_modified_asc = "{labels.search_result_sort_last_modified_asc}";

    /** The key of the message: by Last Modified (desc) */
    public static final String LABELS_search_result_sort_last_modified_desc = "{labels.search_result_sort_last_modified_desc}";

Everyone is permitted to copy and distribute copies of this Agreement, but
in order to avoid inconsistency the Agreement is copyrighted and may only
be modified in the following manner. The Agreement Steward reserves the right
to publish new versions (including revisions) of this Agreement from time
to time. No one other than the Agreement Steward has the right to modify this

              "Annotation methods are not supported on synthetic TypeVariables created during type"
                  + " resolution. The semantics of annotations on resolved types with modified"
                  + " bounds are undefined. Use the original TypeVariable for annotation access."
                  + " See b/147144588.");
        }

          /*
           * We first initialized toJoin to the size of the input collection. However, that size can
           * go out of date (for a collection like CopyOnWriteArrayList, which may have been safely
           * modified concurrently), or it might have been only an estimate to begin with (for a
           * collection like ConcurrentHashMap, which sums up several counters that may not be in