*/
  public final int size() {
    return Iterables.size(getDelegate());
  }

  /**
   * Returns {@code true} if this fluent iterable contains any object for which {@code
   * equals(target)} is true.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.anyMatch(Predicate.isEqual(target))}.
   */
  public final boolean contains(@Nullable Object target) {

     */
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws IOException {
        final int start = bufferIndex;

        bufferIndex++; // revision
        bufferIndex++;
        type = ServerMessageBlock.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        final int ownerUOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to owner sid

      extends InterruptibleTask<T> {
    private final Executor listenerExecutor;

    CombinedFutureInterruptibleTask(Executor listenerExecutor) {
      this.listenerExecutor = checkNotNull(listenerExecutor);
    }

    @Override
    final boolean isDone() {
      return CombinedFuture.this.isDone();
    }

    final void execute() {
      try {
        listenerExecutor.execute(this);

  }

  protected final K k0() {
    return e0().getKey();
  }

  protected final V v0() {
    return e0().getValue();
  }

  protected final K k1() {
    return e1().getKey();
  }

  protected final V v1() {
    return e1().getValue();
  }

  protected final K k2() {
    return e2().getKey();
  }

  protected final V v2() {
    return e2().getValue();

   * An immutable key-value pair with mutable links to other pairs in its hash buckets and in
   * iteration order.
   */
  static final class Node<K extends @Nullable Object, V extends @Nullable Object> {
    @ParametricNullness final K key;
    @ParametricNullness final V value;

    final int keyHash;
    final int valueHash;

    // All Node instances are strongly reachable from owning HashBiMap through

  }

  private static final class ComplementRanges<C extends Comparable>
      extends ImmutableList<Range<C>> {

    private final ImmutableList<Range<C>> ranges;

    // True if the "positive" range set is empty or bounded below.
    private final boolean positiveBoundedBelow;

    // True if the "positive" range set is empty or bounded above.
    private final boolean positiveBoundedAbove;

        super();
    }

    private static final Logger logger = LogManager.getLogger(BoostQueryCommand.class);

    @Override
    protected String getQueryClassName() {
        return BoostQuery.class.getSimpleName();
    }

    @Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final BoostQuery boostQuery) {

    }
  }

  public static void main(String... args) throws Exception {
    new PreemptiveAuth().run();
  }

  static final class BasicAuthInterceptor implements Interceptor {
    private final String credentials;
    private final String host;

    BasicAuthInterceptor(String host, String username, String password) {
      this.credentials = Credentials.basic(username, password);

  }

  @GwtIncompatible
  @J2ktIncompatible
  private static final class KeySetSerializedForm<K> implements Serializable {
    final ImmutableMap<K, ?> map;

    KeySetSerializedForm(ImmutableMap<K, ?> map) {
      this.map = map;
    }

    Object readResolve() {
      return map.keySet();
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

 */
public record ActivationSettings(boolean active, boolean optional, boolean recurse) {

    static ActivationSettings of(final boolean active, final boolean optional) {
        return of(active, optional, true);
    }

    static ActivationSettings of(final boolean active, final boolean optional, final boolean recursive) {
        return new ActivationSettings(active, optional, recursive);
    }