break;
            } catch (CancellationException e) {
              finalResults.add(CancellationException.class);
              break;
            } catch (TimeoutException e) {
              // loop
            }
          }
          awaitUnchecked(barrier);
        };
    List<Callable<?>> allTasks = new ArrayList<>();
    allTasks.add(completeSuccessfullyRunnable);

      annotatedTypeExists()
          ? NullnessAnnotationReader.FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS
          : NullnessAnnotationReader.FROM_DECLARATION_ANNOTATIONS_ONLY;

  /**
   * Looks for declaration nullness annotations and, if supported, type-use nullness annotations.
   *
   * <p>Under Android VMs, the methods for retrieving type-use annotations don't exist. This means

  public static final String AD_AUCTION_ALLOWED = "Ad-Auction-Allowed";

  /**
   * The HTTP <a href="https://datatracker.ietf.org/doc/html/rfc8586">{@code CDN-Loop}</a> header
   * field name.
   *
   * @since 28.0
   */
  public static final String CDN_LOOP = "CDN-Loop";

  /**
   * The HTTP <a href="https://datatracker.ietf.org/doc/html/rfc7838#page-8">{@code Alt-Svc}</a>
   * header field name.
   *

    /**
     * Returns true if this reference contains an active value, meaning one that is still considered
     * present in the cache. Active values consist of live values, which are returned by cache
     * lookups, and dead values, which have been evicted but awaiting removal. Non-active values
     * consist strictly of loading values, though during refresh a value may be both active and
     * loading.
     */
    boolean isActive();

		zw.CreateHeader(&FileHeader{
			Name:   name,
			Method: Store,
		})
	}

	if err := zw.Close(); err != nil {
		b.Fatal(err)
	}
	data := buf.Bytes()

	for b.Loop() {
		zr, err := NewReader(bytes.NewReader(data), int64(len(data)))
		if err != nil {
			b.Fatal(err)
		}
		zr.Open("does-not-exist")
	}
}

func BenchmarkReaderManyDeepDirs(b *testing.B) {

  @Deprecated
  @Override
  public final ImmutableList<E> asList() {
    return this;
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    // this loop is faster for RandomAccess instances, which ImmutableLists are
    int size = size();
    for (int i = 0; i < size; i++) {
      dst[offset + i] = get(i);
    }
    return offset + size;
  }

  /**

---

"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"

          /*
           * This occurs when some pattern has an empty match, even if it doesn't match the empty
           * string -- for example, if it requires lookahead or the like. The offset must be
           * increased to look for separators beyond this point, without changing the start position
           * of the next returned substring -- so nextStart stays the same.
           */
          offset++;
          if (offset > toSplit.length()) {

public abstract class ImmutableSet<E> extends ImmutableCollection<E> implements Set<E> {
  // @IgnoreJRERequirement is not necessary because this compiles down to a constant.
  // (which is fortunate because Animal Sniffer doesn't look for @IgnoreJRERequirement on fields)

  /**
   * Returns a {@code Collector} that accumulates the input elements into a new {@code
   * ImmutableSet}. Elements appear in the resulting set in the encounter order of the stream; if

# WARNING: THESE OPTIONS WONT WORK IF YOU DO NOT HAVE PROPER AUTHENTICATION AND PERMISSIONS

# Use --config=tf_public_cache to try and use the TensorFlow public build cache
# to build TensorFlow. Look at ci/official/envs to find which types of jobs
# push to the cache.  For macOS, use --config=tf_public_macos_cache