}

  Set<Cell<R, C, V>> createCellSet() {
    return new CellSet();
  }

  abstract Iterator<Table.Cell<R, C, V>> cellIterator();

  Spliterator<Table.Cell<R, C, V>> cellSpliterator() {
    return Spliterators.spliterator(cellSet(), Spliterator.NONNULL | Spliterator.DISTINCT);
  }

  @WeakOuter
  private final class CellSet extends AbstractSet<Cell<R, C, V>> {
    @Override

@GwtCompatible
abstract class ImmutableMapEntrySet<K, V> extends ImmutableSet.CachingAsList<Entry<K, V>> {
  private static final int SPLITERATOR_CHARACTERISTICS =
      Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.NONNULL | Spliterator.IMMUTABLE;

  static final class RegularEntrySet<K, V> extends ImmutableMapEntrySet<K, V> {
    private final transient ImmutableMap<K, V> map;
    private final transient ImmutableList<Entry<K, V>> entries;

   * accessor method (under -target 8) that would lack the Android flavor's @IgnoreJRERequirement.
   */
  Spliterator.OfInt spliterator() {
    return Spliterators.spliterator(array, start, end, Spliterator.IMMUTABLE | Spliterator.ORDERED);
  }

  /**
   * Returns an immutable <i>view</i> of this array's values as a {@code List}; note that {@code

   * accessor method (under -target 8) that would lack the Android flavor's @IgnoreJRERequirement.
   */
  Spliterator.OfLong spliterator() {
    return Spliterators.spliterator(array, start, end, Spliterator.IMMUTABLE | Spliterator.ORDERED);
  }

  /**
   * Returns an immutable <i>view</i> of this array's values as a {@code List}; note that {@code

      iterable.forEach(action);
    }

    @SuppressWarnings("unchecked") // safe upcast, assuming no one has a crazy Spliterator subclass
    @Override
    public Spliterator<T> spliterator() {
      return (Spliterator<T>) iterable.spliterator();
    }

    @Override
    public String toString() {
      return iterable.toString();
    }

        return new AsMapIterator();
      }

      @Override
      public Spliterator<Entry<K, Collection<V>>> spliterator() {
        return CollectSpliterators.map(
            submap.entrySet().spliterator(),
            Spliterator.DISTINCT | Spliterator.NONNULL,
            AsMap.this::wrapEntry);
      }

      // The following methods are included for performance.

          return getEntry(index);
        }
      };
    }

    @Override
    @GwtIncompatible("Spliterator")
    Spliterator<Entry<K, V>> entrySpliterator() {
      return CollectSpliterators.indexed(
          size(), Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.NONNULL, this::getEntry);
    }

    // TODO(lowasser): consider an optimized values() implementation

    @Override

          return CollectSpliterators.map(
              valueCollection.spliterator(),
              Spliterator.ORDERED | Spliterator.NONNULL | Spliterator.IMMUTABLE,
              (V value) -> immutableEntry(key, value));
        },
        Spliterator.SIZED | (this instanceof SetMultimap ? Spliterator.DISTINCT : 0),
        size());
  }

  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {

  @Override
  public final ImmutableList<E> asList() {
    return this;
  }

  @Override
  @GwtIncompatible("Spliterator")
  public Spliterator<E> spliterator() {
    return spliteratorWithCharacteristics(SPLITERATOR_CHARACTERISTICS);
  }

  @GwtIncompatible("Spliterator")
  Spliterator<E> spliteratorWithCharacteristics(int characteristics) {
    return CollectSpliterators.indexed(size(), characteristics, this::get);

      return asMapEntryIterator(set, function);
    }

    @Override
    @GwtIncompatible("Spliterator")
    Spliterator<Entry<K, V>> entrySpliterator() {
      return CollectSpliterators.map(
          set.spliterator(),
          Spliterator.DISTINCT | Spliterator.NONNULL,
          e -> immutableEntry(e, function.apply(e)));
    }

    @Override