}
  }

  private static <E extends @Nullable Object> E getElementOrThrow(@Nullable Entry<E> entry) {
    if (entry == null) {
      throw new NoSuchElementException();
    }
    return entry.getElement();
  }

  private static <E extends @Nullable Object> @Nullable E getElementOrNull(
      @Nullable Entry<E> entry) {
    return (entry == null) ? null : entry.getElement();
  }

import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

@GwtCompatible
final class PairwiseEquivalence<E, T extends @Nullable E> extends Equivalence<Iterable<T>>
    implements Serializable {
  final Equivalence<E> elementEquivalence;

  PairwiseEquivalence(Equivalence<E> elementEquivalence) {

    @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
    Future<?> possiblyIgnoredError =
        threadPool.submit(
            new Callable<@Nullable Void>() {
              @Override
              public @Nullable Void call() throws InterruptedException {
                new Producer(q, 50).call();
                new Interrupter(mainThread).run();
                new Producer(q, 50).call();

 */

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.concurrent.Executor;
import org.jspecify.annotations.Nullable;

/**
 * A {@link ListenableFuture} 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

   */
  public static <T extends @Nullable Object> Predicate<T> notNull() {
    return ObjectPredicate.NOT_NULL.withNarrowedType();
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the given predicate evaluates to {@code
   * false}.
   *
   * <p><b>Discouraged:</b> Prefer using {@code predicate.negate()}.
   */
  public static <T extends @Nullable Object> Predicate<T> not(Predicate<T> predicate) {

 *
 * @author Jared Levy
 * @since 2.0
 */
@DoNotMock("Use ImmutableMultimap, HashMultimap, or another implementation")
@GwtCompatible
public interface Multimap<K extends @Nullable Object, V extends @Nullable Object> {
  // Query Operations

  /**
   * Returns the number of key-value pairs in this multimap.
   *

   * @return the replacement string, or {@code null} if no escaping was needed
   */
  public static @Nullable String computeReplacement(UnicodeEscaper escaper, int cp) {
    return stringOrNull(escaper.escape(cp));
  }

  private static @Nullable String stringOrNull(char @Nullable [] in) {
    return (in == null) ? null : new String(in);
  }

    return forwardMultiset();
  }

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

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

  abstract Iterator<Entry<E>> entryIterator();

  @Nullable private transient Set<Entry<E>> entrySet;

  @Override

  public E last() {
    return delegate.last();
  }

  @Override
  public @Nullable E lower(E e) {
    return delegate.lower(checkValid(e));
  }

  @Override
  public @Nullable E pollFirst() {
    return delegate.pollFirst();
  }

  @Override
  public @Nullable E pollLast() {
    return delegate.pollLast();
  }

  @Override
  public boolean remove(Object object) {

    return (Collector) TO_OPTIONAL;
  }

  private static final Object NULL_PLACEHOLDER = new Object();

  private static final Collector<@Nullable Object, ?, @Nullable Object> ONLY_ELEMENT =
      Collector.<@Nullable Object, ToOptionalState, @Nullable Object>of(
          ToOptionalState::new,
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {