}

  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

      return Iterators.transform(original.cellSet().iterator(), Tables::transposeCell);
    }

    @Override
    @GwtIncompatible // Spliterator
    Spliterator<Cell<C, R, V>> cellSpliterator() {
      return CollectSpliterators.map(
          original.cellSet().spliterator(),
          Spliterator.DISTINCT | Spliterator.NONNULL,
          Tables::transposeCell);
    }
  }

  @Override
  final UnmodifiableIterator<Cell<R, C, V>> cellIterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  final Spliterator<Cell<R, C, V>> cellSpliterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  public ImmutableCollection<V> values() {
    return (ImmutableCollection<V>) super.values();
  }

  @Override

      @Override
      protected Cell<R, C, @Nullable V> get(int index) {
        return getCell(index);
      }
    };
  }

  @Override
  Spliterator<Cell<R, C, @Nullable V>> cellSpliterator() {
    return CollectSpliterators.indexed(
        size(), Spliterator.ORDERED | Spliterator.NONNULL | Spliterator.DISTINCT, this::getCell);
  }

  private Cell<R, C, @Nullable V> getCell(int index) {

        rowIterator.remove();
        rowEntry = null;
      }
    }
  }

  @Override
  @GwtIncompatible // Spliterator
  Spliterator<Cell<R, C, V>> cellSpliterator() {
    return CollectSpliterators.flatMap(
        backingMap.entrySet().spliterator(),
        (Entry<R, Map<C, V>> rowEntry) ->
            CollectSpliterators.map(