Spliterator<A> splitrA = streamA.spliterator();
    Spliterator<B> splitrB = streamB.spliterator();
    int characteristics =
        splitrA.characteristics()
            & splitrB.characteristics()
            & (Spliterator.SIZED | Spliterator.ORDERED);
    Iterator<A> itrA = Spliterators.iterator(splitrA);
    Iterator<B> itrB = Spliterators.iterator(splitrB);
    return StreamSupport.stream(

  }

  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 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) {

          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

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