import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link Multimaps#filterKeys(SetMultimap, Predicate)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class FilteredKeySetMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends FilteredKeyMultimap<K, V> implements FilteredSetMultimap<K, V> {

          <item index="2" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNullable" />
          <item index="3" class="java.lang.String" itemvalue="com.android.annotations.Nullable" />
          <item index="4" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.Nullable" />
          <item index="5" class="java.lang.String" itemvalue="io.reactivex.annotations.Nullable" />

   * would lead to at least slighly more work at startup time.
   */
  @LazyInit private transient @Nullable Ordering<@Nullable Comparable<?>> nullsFirst;
  @LazyInit private transient @Nullable Ordering<@Nullable Comparable<?>> nullsLast;

  @Override
  @SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??

  static final RegularImmutableBiMap<Object, Object> EMPTY = new RegularImmutableBiMap<>();

  private final transient @Nullable Object keyHashTable;
  @VisibleForTesting final transient @Nullable Object[] alternatingKeysAndValues;
  private final transient int keyOffset; // 0 for K-to-V, 1 for V-to-K
  private final transient int size;
  private final transient RegularImmutableBiMap<V, K> inverse;

            DefaultToolchainsBuilderRequest(
                    @Nonnull ProtoSession session,
                    @Nullable RequestTrace trace,
                    @Nullable Source installationToolchainsSource,
                    @Nullable Source userToolchainsSource) {
                super(session, trace);
                this.installationToolchainsSource = installationToolchainsSource;

 * invoke methods, they invoke methods on the {@code ForwardingSetMultimap}.
 *
 * @author Kurt Alfred Kluever
 * @since 3.0
 */
@GwtCompatible
public abstract class ForwardingSetMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingMultimap<K, V> implements SetMultimap<K, V> {
  /** Constructor for use by subclasses. */
  public ForwardingSetMultimap() {}

  @Override

   * @since 11.0
   */
  public static <R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>
      Table<R, C, V> unmodifiableTable(Table<? extends R, ? extends C, ? extends V> table) {
    return new UnmodifiableTable<>(table);
  }

  private static class UnmodifiableTable<
          R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>

                mergeFunction),
        (s1, s2) -> s1.combine(s2, mergeFunction),
        state -> state.toTable());
  }

  static <
          T extends @Nullable Object,
          R extends @Nullable Object,
          C extends @Nullable Object,
          V,
          I extends Table<R, C, V>>
      Collector<T, ?, I> toTable(
          Function<? super T, ? extends R> rowFunction,

    }

    @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();

    READY,
    NOT_READY,
    DONE,
    FAILED,
  }

  private @Nullable T next;

  protected abstract @Nullable T computeNext();

  @CanIgnoreReturnValue
  protected final @Nullable T endOfData() {
    state = State.DONE;
    return null;
  }

  @Override
  public final boolean hasNext() {
    checkState(state != State.FAILED);
    switch (state) {
      case DONE:
        return false;