return new RowSortedMap();
  }

  @WeakOuter
  private final class RowSortedMap extends RowMap implements SortedMap<R, Map<C, V>> {
    @Override
    public SortedSet<R> keySet() {
      return (SortedSet<R>) super.keySet();
    }

    @Override
    SortedSet<R> createKeySet() {
      return new Maps.SortedKeySet<>(this);
    }

    @Override

      toRemove = null;
    }

    abstract T output(Node<K, V> node);
  }

  @Override
  public Set<K> keySet() {
    return new KeySet();
  }

  private final class KeySet extends Maps.KeySet<K, V> {
    KeySet() {
      super(HashBiMap.this);
    }

    @Override
    public Iterator<K> iterator() {
      return new BiIterator<K, V, K>(HashBiMap.this) {

      synchronized (mutex) {
        delegate().clear();
      }
    }

    @Override
    public Set<K> keySet() {
      synchronized (mutex) {
        if (keySet == null) {
          keySet = typePreservingSet(delegate().keySet(), mutex);
        }
        return keySet;
      }
    }

    @Override
    public Collection<V> values() {
      synchronized (mutex) {

    assertEmpty(multimap());
    assertEquals(multimap(), getSubjectGenerator().create());
    assertEmpty(multimap().entries());
    assertEmpty(multimap().asMap());
    assertEmpty(multimap().keySet());
    assertEmpty(multimap().keys());
    assertEmpty(multimap().values());
    for (K key : sampleKeys()) {
      assertGet(key);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)

    cache.put(20, 22);
    cache.put(5, 10);

    fakeTicker.advance(501, MILLISECONDS);

    assertThat(cache.asMap().keySet().contains(20)).isTrue();
    assertThat(cache.asMap().keySet().contains(5)).isTrue();
    assertThat(cache.asMap().keySet().contains(10)).isFalse();
  }

  @Test
  @J2ktIncompatible
  public void asMapEntrySet() {
    Cache<Integer, Integer> cache =

      biMap.clear();
    }
  }

  @LazyInit private transient Set<K> keySet;

  @Override
  public Set<K> keySet() {
    Set<K> result = keySet;
    return (result == null) ? keySet = new KeySet() : result;
  }

  private final class KeySet extends View<K, V, K> {
    KeySet() {
      super(HashBiMap.this);
    }

    @Override
    @ParametricNullness

  }

  @Override
  SortedMap<K, Collection<V>> backingMap() {
    return (SortedMap<K, Collection<V>>) super.backingMap();
  }

  @Override
  public SortedSet<K> keySet() {
    return (SortedSet<K>) super.keySet();
  }

  @Override
  Set<K> createKeySet() {
    return createMaybeNavigableKeySet();
  }

    }
  }

  public void testAsMapGetImplementsSet() {
    for (K key : multimap().keySet()) {
      assertTrue(multimap().asMap().get(key) instanceof Set);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testAsMapRemoveImplementsSet() {
    List<K> keys = new ArrayList<>(multimap().keySet());
    for (K key : keys) {
      resetCollection();

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

/**
 * {@code keySet()} implementation for {@link ImmutableMap}.
 *
 * @author Jesse Wilson
 * @author Kevin Bourrillion
 */
@GwtCompatible
final class ImmutableMapKeySet<K, V> extends IndexedImmutableSet<K> {

    }
  }

  public void testAsMapGetImplementsSet() {
    for (K key : multimap().keySet()) {
      assertTrue(multimap().asMap().get(key) instanceof Set);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testAsMapRemoveImplementsSet() {
    List<K> keys = new ArrayList<>(multimap().keySet());
    for (K key : keys) {
      resetCollection();