import com.google.common.annotations.GwtCompatible;
import java.io.Serializable;
import java.util.Arrays;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A class that implements {@code Comparable} without generics, such as those found in libraries
 * that support Java 1.4 and before. Our library needs to do the bare minimum to accommodate such

import java.io.Serializable;
import java.math.BigInteger;
import java.util.NoSuchElementException;
import javax.annotation.CheckForNull;

/**
 * A descriptor for a <i>discrete</i> {@code Comparable} domain such as all {@link Integer}
 * instances. A discrete domain is one that supports the three basic operations: {@link #next},
 * {@link #previous} and {@link #distance}, according to their specifications. The methods {@link

 *
 * @author Gregory Kick
 * @since 10.0
 */
@GwtCompatible(emulated = true)
@SuppressWarnings("rawtypes") // allow ungenerified Comparable types
@ElementTypesAreNonnullByDefault
public abstract class ContiguousSet<C extends Comparable> extends ImmutableSortedSet<C> {
  /**
   * Returns a {@code ContiguousSet} containing the same values in the given domain {@linkplain
   * Range#contains contained} by the range.

   *
   * <p>The type specification is {@code <E extends Comparable>}, instead of the more specific
   * {@code <E extends Comparable<? super E>>}, to support classes defined without generics.
   */
  @SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
  public static <E extends Comparable> TreeMultiset<E> create() {
    return new TreeMultiset<>(Ordering.natural());
  }

  /**

      extends TestStringSetGenerator {

    private static final Comparator<Comparable<?>> COMPARABLE_REVERSED = Collections.reverseOrder();

    @Override
    protected SortedSet<String> create(String[] elements) {
      return new ImmutableSortedSet.Builder<String>(COMPARABLE_REVERSED).add(elements).build();
    }

    @Override
    public List<String> order(List<String> insertionOrder) {

import java.io.Serializable;
import java.math.BigInteger;
import java.util.NoSuchElementException;
import javax.annotation.CheckForNull;

/**
 * A descriptor for a <i>discrete</i> {@code Comparable} domain such as all {@link Integer}
 * instances. A discrete domain is one that supports the three basic operations: {@link #next},
 * {@link #previous} and {@link #distance}, according to their specifications. The methods {@link

        for (projection in typeArguments) {
            // E.g., Test : Comparable<Test>
            val type = (projection as? ConeKotlinTypeProjection)?.type ?: continue
            // E.g., Comparable<Test>
            val newType = substituteOrNull(type) ?: continue
            // Visit new type: e.g., Test, as a type argument, is substituted with Comparable<Test>, again.
            if (newType.hasRecursiveTypeArgument(visited)) return true

    }
  }

  // J2kt cannot translate the Comparable rawtype in a usable way (it becomes Comparable<Object>
  // but types are typically only Comparable to themselves).
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static MinMaxPriorityQueue.Builder<Comparable<?>> rawtypeToWildcard(
      MinMaxPriorityQueue.Builder<Comparable> builder) {
    return (MinMaxPriorityQueue.Builder) builder;
  }

      extends TestStringSetGenerator {

    private static final Comparator<Comparable<?>> COMPARABLE_REVERSED = Collections.reverseOrder();

    @Override
    protected SortedSet<String> create(String[] elements) {
      return new ImmutableSortedSet.Builder<String>(COMPARABLE_REVERSED).add(elements).build();
    }

    @Override
    public List<String> order(List<String> insertionOrder) {

          ImmutableSet.Builder::add,
          ImmutableSet.Builder::combine,
          ImmutableSet.Builder::build);

  @GwtIncompatible
  private static final Collector<Range<Comparable<?>>, ?, ImmutableRangeSet<Comparable<?>>>
      TO_IMMUTABLE_RANGE_SET =
          Collector.of(
              ImmutableRangeSet::builder,
              ImmutableRangeSet.Builder::add,
              ImmutableRangeSet.Builder::combine,