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

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

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

  @Override

  public void testTransformEntrySetContains() {
    Map<@Nullable String, @Nullable Boolean> underlying = new HashMap<>();
    underlying.put("a", null);
    underlying.put("b", true);
    underlying.put(null, true);

    Map<@Nullable String, @Nullable Boolean> map =
        transformValues(
            underlying,
            new Function<@Nullable Boolean, @Nullable Boolean>() {
              @Override

     * in the value bucket (or vice versa).
     */
    private final transient @Nullable ImmutableMapEntry<K, V> nextInKeyBucket;

    NonTerminalImmutableMapEntry(
        K key, V value, @Nullable ImmutableMapEntry<K, V> nextInKeyBucket) {
      super(key, value);
      this.nextInKeyBucket = nextInKeyBucket;
    }

    @Override
    final @Nullable ImmutableMapEntry<K, V> getNextInKeyBucket() {
      return nextInKeyBucket;

    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return delegate().containsKey(key);
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    return delegate().containsValue(value);
  }

  @Override

    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return delegate().containsKey(key);
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    return delegate().containsValue(value);
  }

  @Override

   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

  private static final class SupplierComposition<
          F extends @Nullable Object, T extends @Nullable Object>
      implements Supplier<T>, Serializable {

 * @param <V> the type of the mapped values
 * @since 7.0
 */
@DoNotMock("Use ImmutableTable, HashBasedTable, or another implementation")
@GwtCompatible
public interface Table<
    R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object> {
  // TODO(jlevy): Consider adding methods similar to ConcurrentMap methods.

  // Accessors

  /**

        header);
  }

  private static final class Reference<T> {
    private @Nullable T value;

    @Nullable T get() {
      return value;
    }

    void checkAndSet(@Nullable T expected, @Nullable T newValue) {
      if (value != expected) {
        throw new ConcurrentModificationException();
      }
      value = newValue;
    }

  private static class SynchronizedMultimap<K extends @Nullable Object, V extends @Nullable Object>
      extends SynchronizedObject implements Multimap<K, V> {
    transient @Nullable Set<K> keySet;
    transient @Nullable Collection<V> valuesCollection;
    transient @Nullable Collection<Map.Entry<K, V>> entries;
    transient @Nullable Map<K, Collection<V>> asMap;
    transient @Nullable Multiset<K> keys;

    @SuppressWarnings("unchecked")