/**
 * An immutable sorted multiset with one or more distinct elements.
 *
 * @author Louis Wasserman
 */
@SuppressWarnings("serial") // uses writeReplace, not default serialization
@GwtIncompatible
@ElementTypesAreNonnullByDefault
final class RegularImmutableSortedMultiset<E> extends ImmutableSortedMultiset<E> {
  private static final long[] ZERO_CUMULATIVE_COUNTS = {0};

  static final ImmutableSortedMultiset<?> NATURAL_EMPTY_MULTISET =

   * this range map are guaranteed to read through to the returned {@code Map}.
   *
   * <p>The returned {@code Map} iterates over entries in ascending order of the bounds of the
   * {@code Range} entries.
   *
   * <p>It is guaranteed that no empty ranges will be in the returned {@code Map}.
   */
  Map<Range<K>, V> asMapOfRanges();

  /**

         */
        return bounds.equals(other.bounds);
      }

      return false;
    }

    @Override
    public int hashCode() {
      return bounds.hashCode();
    }

    @Override
    public String toString() {
      return (bounds.equals(ImmutableList.of(Object.class)))
          ? name
          : name + " extends " + getTypesString(bounds);
    }
  }

         */
        return bounds.equals(other.bounds);
      }

      return false;
    }

    @Override
    public int hashCode() {
      return bounds.hashCode();
    }

    @Override
    public String toString() {
      return (bounds.equals(ImmutableList.of(Object.class)))
          ? name
          : name + " extends " + getTypesString(bounds);
    }
  }

import java.util.SortedMap;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An object representing the differences between two sorted maps.
 *
 * @author Louis Wasserman
 * @since 8.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface SortedMapDifference<K extends @Nullable Object, V extends @Nullable Object>
    extends MapDifference<K, V> {

import com.google.common.annotations.GwtIncompatible;
import java.util.List;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a
 * ConcurrentNavigableMap implementation.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
public class ConcurrentNavigableMapTestSuiteBuilder<K, V>
    extends NavigableMapTestSuiteBuilder<K, V> {

  public static <K, V> ConcurrentNavigableMapTestSuiteBuilder<K, V> using(

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An {@code Iterable} whose elements are sorted relative to a {@code Comparator}, typically
 * provided at creation time.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
interface SortedIterable<T extends @Nullable Object> extends Iterable<T> {
  /**

import java.util.List;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of {@link Multimaps#filterKeys(ListMultimap, Predicate)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class FilteredKeyListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends FilteredKeyMultimap<K, V> implements ListMultimap<K, V> {

import java.util.Arrays;
import java.util.List;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentMap
 * implementation.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
public class ConcurrentMapTestSuiteBuilder<K, V> extends MapTestSuiteBuilder<K, V> {
  public static <K, V> ConcurrentMapTestSuiteBuilder<K, V> using(TestMapGenerator<K, V> generator) {

 *
 * <p>This superclass allows {@code TreeMultimap} to override methods to return navigable set and
 * map types in non-GWT only, while GWT code will inherit the SortedMap/SortedSet overrides.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class AbstractSortedKeySortedSetMultimap<
        K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractSortedSetMultimap<K, V> {