* invoke methods, they invoke methods on the {@code ForwardingListMultimap}.
 *
 * @author Kurt Alfred Kluever
 * @since 3.0
 */
@GwtCompatible
public abstract class ForwardingListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingMultimap<K, V> implements ListMultimap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingListMultimap() {}

  @Override

  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

  @Override
  @Nullable Object @Nullable [] internalArray() {
    return delegateList.internalArray();
  }

  @Override
  int internalArrayStart() {

   * created multimaps.
   *
   * @since 2.0
   */
  @DoNotMock
  public static class Builder<K, V> {
    @Nullable Map<K, ImmutableCollection.Builder<V>> builderMap;
    @Nullable Comparator<? super K> keyComparator;
    @Nullable Comparator<? super V> valueComparator;
    int expectedValuesPerKey = ImmutableCollection.Builder.DEFAULT_INITIAL_CAPACITY;

    /**

   * @since 28.1
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void merge(
      Range<K> range,
      @Nullable V value,
      BiFunction<? super V, ? super @Nullable V, ? extends @Nullable V> remappingFunction) {
    throw new UnsupportedOperationException();
  }

  @Override
  public ImmutableMap<Range<K>, V> asMapOfRanges() {
    if (ranges.isEmpty()) {

   */
  <T extends @NonNull B> @Nullable T getInstance(Class<T> type);

  /**
   * Returns the value the specified type is mapped to, or {@code null} if no entry for this type is
   * present. This will only return a value that was bound to this specific type, not a value that
   * may have been bound to a subtype.
   */
  <T extends @NonNull B> @Nullable T getInstance(TypeToken<T> type);

  /**

    checkNotNull(valueComparator);
    return Comparator.<Optional<T>, @Nullable T>comparing(
        o -> orElseNull(o), Comparator.nullsLast(valueComparator));
  }

  // For discussion of why this exists, see the Android flavor.
  private static <T> @Nullable T orElseNull(Optional<T> optional) {
    return optional.orElse(null);
  }

  /**

  @Override
  public E takeLast() throws InterruptedException {
    return delegate().takeLast();
  }

  @Override
  public @Nullable E pollFirst(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().pollFirst(timeout, unit);
  }

  @Override
  public @Nullable E pollLast(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().pollLast(timeout, unit);
  }

  @Override

    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);
    SlowChannel slowChannel = new SlowChannel();
    InterruptibleTask<@Nullable Void> task =
        new InterruptibleTask<@Nullable Void>() {
          @Override
          @Nullable Void runInterruptibly() throws Exception {
            slowChannel.doBegin();
            isInterruptibleRegistered.countDown();
            try {

   *
   * @since 15.0
   */
  public static <E extends @Nullable Object> Funnel<Iterable<? extends E>> sequentialFunnel(
      Funnel<E> elementFunnel) {
    return new SequentialFunnel<>(elementFunnel);
  }

  private static final class SequentialFunnel<E extends @Nullable Object>
      implements Funnel<Iterable<? extends E>> {
    private final Funnel<E> elementFunnel;

 * "https://github.com/google/guava/wiki/NewCollectionTypesExplained#multimap">{@code Multimap}</a>.
 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public interface SortedSetMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends SetMultimap<K, V> {
  // Following Javadoc copied from Multimap.

  /**
   * Returns a collection view of all values associated with a key. If no mappings in the multimap