}

    @Override
    Map<R, @Nullable V> getValue(int index) {
      return new Column(index);
    }

    @Override
    Map<R, @Nullable V> setValue(int index, Map<R, @Nullable V> newValue) {
      throw new UnsupportedOperationException();
    }

    @Override
    public @Nullable Map<R, @Nullable V> put(C key, Map<R, @Nullable V> value) {
      throw new UnsupportedOperationException();

  public void assertEqualHashCode(
      Predicate<? super @Nullable Integer> expected, Predicate<? super @Nullable Integer> actual) {
    assertEquals(actual + " should hash like " + expected, expected.hashCode(), actual.hashCode());
  }

  public void testHashCodeForBooleanOperations() {
    Predicate<@Nullable Integer> p1 = Predicates.isNull();
    Predicate<@Nullable Integer> p2 = isOdd();

import java.util.Spliterator;
import java.util.Spliterators;
import org.jspecify.annotations.Nullable;

/**
 * A skeleton {@code Multimap} implementation, not necessarily in terms of a {@code Map}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
abstract class AbstractMultimap<K extends @Nullable Object, V extends @Nullable Object>
    implements Multimap<K, V> {
  @Override
  public boolean isEmpty() {

     * @param defaultReply the default reply value
     * @return the string entered by the user
     * @throws PrompterException if an exception occurs
     */
    @Nonnull
    String prompt(@Nullable String message, @Nullable List<String> possibleValues, @Nullable String defaultReply)
            throws PrompterException;

    /**
     * Prompts the user for a password.
     *
     * @param message the message to display

   */
  static <T extends @Nullable Object> T[] toArrayImpl(
      @Nullable Object[] src, int offset, int len, T[] dst) {
    checkPositionIndexes(offset, offset + len, src.length);
    if (dst.length < len) {
      dst = newArray(dst, len);
    } else if (dst.length > len) {
      @Nullable Object[] unsoundlyCovariantArray = dst;
      unsoundlyCovariantArray[len] = null;
    }

   * override {@link #toArray(Object[])}, you may wish to override {@link #toArray} to forward to
   * this implementation.
   *
   * @since 7.0
   */
  protected @Nullable Object[] standardToArray() {
    @Nullable Object[] newArray = new @Nullable Object[size()];
    return toArray(newArray);
  }

  /**
   * A sensible definition of {@link #toArray(Object[])} in terms of {@link #size} and {@link

   * override {@link #toArray(Object[])}, you may wish to override {@link #toArray} to forward to
   * this implementation.
   *
   * @since 7.0
   */
  protected @Nullable Object[] standardToArray() {
    @Nullable Object[] newArray = new @Nullable Object[size()];
    return toArray(newArray);
  }

  /**
   * A sensible definition of {@link #toArray(Object[])} in terms of {@link #size} and {@link

    return delegate().offerLast(e);
  }

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

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

  @CanIgnoreReturnValue // TODO(cpovirk): Consider removing this?
  @Override
  public @Nullable E pollFirst() {
    return delegate().pollFirst();
  }

import org.jspecify.annotations.Nullable;

/**
 * Skeletal implementation of {@link NavigableMap}.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
abstract class AbstractNavigableMap<K extends @Nullable Object, V extends @Nullable Object>
    extends IteratorBasedAbstractMap<K, V> implements NavigableMap<K, V> {

  @Override
  public abstract @Nullable V get(@Nullable Object key);

  @Override

  private final transient ImmutableEntry<E>[] entries;
  private final transient @Nullable ImmutableEntry<?>[] hashTable;
  private final transient int size;
  private final transient int hashCode;

  @LazyInit private transient @Nullable ImmutableSet<E> elementSet;

  private RegularImmutableMultiset(
      ImmutableEntry<E>[] entries,
      @Nullable ImmutableEntry<?>[] hashTable,
      int size,
      int hashCode,