@Override
              public Collection apply(Collection delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Collection<T> wrap(final Collection<T> delegate) {
    return new ForwardingCollection<T>() {
      @Override
      protected Collection<T> delegate() {
        return delegate;
      }
    };
  }

              @Override
              public Queue apply(Queue delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Queue<T> wrap(final Queue<T> delegate) {
    return new ForwardingQueue<T>() {
      @Override
      protected Queue<T> delegate() {
        return delegate;
      }
    };
  }

    return delegate().remove(element, occurrences);
  }

  @Override
  public Set<E> elementSet() {
    return delegate().elementSet();
  }

  @Override
  public Set<Entry<E>> entrySet() {
    return delegate().entrySet();
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    return object == this || delegate().equals(object);
  }

  @Override

  protected ForwardingSortedSetMultimap() {}

  @Override
  protected abstract SortedSetMultimap<K, V> delegate();

  @Override
  public SortedSet<V> get(@ParametricNullness K key) {
    return delegate().get(key);
  }

  @Override
  public SortedSet<V> removeAll(@CheckForNull Object key) {
    return delegate().removeAll(key);
  }

  @Override

  }

  @J2ktIncompatible
  @GwtIncompatible
  static Reader ignoringReader(Reader delegate, String toIgnore) {
    checkNotNull(delegate);
    checkNotNull(toIgnore);
    return new Reader() {
      @Override
      public int read() throws IOException {
        int readChar;
        do {
          readChar = delegate.read();
        } while (readChar != -1 && toIgnore.indexOf((char) readChar) >= 0);

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedMultiset<T> wrap(final SortedMultiset<T> delegate) {
    return new ForwardingSortedMultiset<T>() {
      @Override
      protected SortedMultiset<T> delegate() {
        return delegate;
      }
    };
  }

  @Override
  protected abstract ConcurrentMap<K, V> delegate();

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V putIfAbsent(K key, V value) {
    return delegate().putIfAbsent(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedSet<T> wrap(final SortedSet<T> delegate) {
    return new ForwardingSortedSet<T>() {
      @Override
      protected SortedSet<T> delegate() {
        return delegate;
      }
    };
  }

    implements TestSetGenerator<E> {

  ReserializingTestSetGenerator(TestSetGenerator<E> delegate) {
    super(delegate);
  }

  public static <E> TestSetGenerator<E> newInstance(TestSetGenerator<E> delegate) {
    return new ReserializingTestSetGenerator<>(delegate);
  }

  @Override
  public Set<E> create(Object... elements) {
    return (Set<E>) super.create(elements);
  }

  @Override
  protected abstract ListeningExecutorService delegate();

  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(Callable<T> task) {
    return delegate().submit(task);
  }

  @Override
  public ListenableFuture<?> submit(Runnable task) {
    return delegate().submit(task);
  }

  @Override