}

    @Override
    public Iterator<Entry<K, V>> iterator() {
      return entryIterator();
    }

    @Override
    public Spliterator<Entry<K, V>> spliterator() {
      return entrySpliterator();
    }
  }

  @WeakOuter
  final class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);
    }

  UnmodifiableIterator<Entry<K, V>> entryIterator() {
    return Maps.unmodifiableEntryIterator(delegate.entrySet().iterator());
  }

  @Override
  @GwtIncompatible // Spliterator
  Spliterator<Entry<K, V>> entrySpliterator() {
    return CollectSpliterators.map(
        delegate.entrySet().spliterator(),
        Spliterator.DISTINCT | Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL,
        Maps::unmodifiableEntry);

        LinkedHashMultimap.this.remove(toRemove.getKey(), toRemove.getValue());
        toRemove = null;
      }
    };
  }

  @Override
  Spliterator<Entry<K, V>> entrySpliterator() {
    return Spliterators.spliterator(
        entries(), Spliterator.DISTINCT | Spliterator.ORDERED | Spliterator.NONNULL);
  }

  @Override
  Iterator<V> valueIterator() {

    Spliterator<Entry<E>> entrySpliterator = multiset.entrySet().spliterator();
    return CollectSpliterators.flatMap(
        entrySpliterator,
        (Entry<E> entry) -> Collections.nCopies(entry.getCount(), entry.getElement()).spliterator(),
        Spliterator.SIZED
            | (entrySpliterator.characteristics()

         */
        return immutableEntry(requireNonNull(currentKey), valueItr.next());
      }
    };
  }

  @Override
  @GwtIncompatible // Spliterator
  Spliterator<Entry<K, V>> entrySpliterator() {
    return CollectSpliterators.flatMap(
        asMap().entrySet().spliterator(),
        keyToValueCollectionEntry -> {
          K key = keyToValueCollectionEntry.getKey();

          iterator.remove();
          maintainEmptyInvariant();
        }
      };
    }

    @Override
    @GwtIncompatible // Spliterator
    Spliterator<Entry<C, V>> entrySpliterator() {
      updateBackingRowMapField();
      if (backingRowMap == null) {
        return Spliterators.emptySpliterator();
      }
      return CollectSpliterators.map(

        protected Entry<K, V> get(int index) {
          return getEntry(index);
        }
      };
    }

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

  abstract static class IteratorBasedImmutableMap<K, V> extends ImmutableMap<K, V> {
    abstract UnmodifiableIterator<Entry<K, V>> entryIterator();

    @GwtIncompatible // Spliterator
    Spliterator<Entry<K, V>> entrySpliterator() {
      return Spliterators.spliterator(
          entryIterator(),
          size(),
          Spliterator.DISTINCT | Spliterator.NONNULL | Spliterator.IMMUTABLE | Spliterator.ORDERED);
    }

    @Override
    Iterator<Entry<K, V>> entryIterator() {
      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)));
    }

      Entry<K, V> output(@ParametricNullness K key, @ParametricNullness V value) {
        return immutableEntry(key, value);
      }
    };
  }

  @Override
  Spliterator<Entry<K, V>> entrySpliterator() {
    return CollectSpliterators.flatMap(
        map.entrySet().spliterator(),
        keyToValueCollectionEntry -> {
          K key = keyToValueCollectionEntry.getKey();