}
    };
  }

  @LazyInit private transient @Nullable ImmutableList<E> asList;

  @Override
  public ImmutableList<E> asList() {
    ImmutableList<E> result = asList;
    return (result == null) ? asList = super.asList() : result;
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return count(object) > 0;
  }

  /**

    return (prefix & ~mask) | (suffix & mask);
  }

  static int remove(
      @Nullable Object key,
      @Nullable Object value,
      int mask,
      Object table,
      int[] entries,
      @Nullable Object[] keys,
      @Nullable Object @Nullable [] values) {
    int hash = smearedHash(key);
    int tableIndex = hash & mask;
    int next = tableGet(table, tableIndex);

    this.forward = forward;
  }

  @Override
  public int count(@Nullable Object element) {
    return forward.count(element);
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return forward.firstEntry();
  }

  @Override
  public int size() {

   * garbage collected.
   */
  private static final class State {
    final int fileThreshold;
    final boolean resetWhenGarbageCollected;

    @GuardedBy("this")
    @Nullable MemoryOutput memory;

    @GuardedBy("this")
    @Nullable File file;

    @GuardedBy("this")
    OutputStream out;

    State(int fileThreshold, boolean resetWhenGarbageCollected) {
      this.fileThreshold = fileThreshold;

   */

  @LazyInit private @Nullable ListenableFuture<V> delegateRef;
  @LazyInit private @Nullable ScheduledFuture<?> timer;

  private TimeoutFuture(ListenableFuture<V> delegate) {
    this.delegateRef = Preconditions.checkNotNull(delegate);
  }

  /** A runnable that is called when the delegate or the timer completes. */
  private static final class Fire<V extends @Nullable Object> implements Runnable {

import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.EnumSet;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link ImmutableSet} backed by a non-empty {@link java.util.EnumSet}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@SuppressWarnings("serial") // we're overriding default serialization

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Future} which forwards all its method calls to another future. Subclasses should
 * override one or more methods to modify the behavior of the backing future as desired per the <a

import java.util.SortedSet;
import org.jspecify.annotations.Nullable;

/**
 * Superinterface of {@link SortedMultiset} to introduce a bridge method for {@code elementSet()},
 * to ensure binary compatibility with older Guava versions that specified {@code elementSet()} to
 * return {@code SortedSet}.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
interface SortedMultisetBridge<E extends @Nullable Object> extends Multiset<E> {
  @Override

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.jspecify.annotations.Nullable;

/** Emulation of Uninterruptibles in GWT. */
public final class Uninterruptibles {

  private Uninterruptibles() {}

  @CanIgnoreReturnValue
  public static <V extends @Nullable Object> V getUninterruptibly(Future<V> future)
      throws ExecutionException {
    try {
      return future.get();

  }

  private static boolean matchesType(
      @Nullable PublicSuffixType desiredType, @Nullable PublicSuffixType actualType) {
    return actualType != null && (desiredType == null || desiredType.equals(actualType));
  }

  private static boolean isExcludedMatch(int metadata) {
    return ((metadata >> EXCLUSION_SHIFT) & EXCLUSION_MASK) != 0;
  }

  private @Nullable PublicSuffixType getExactMatchType(int metadata) {