this.comparators = (Comparator<? super T>[]) new Comparator<?>[] {primary, secondary};
  }

  @SuppressWarnings("unchecked") // Generic array creation
  CompoundOrdering(Iterable<? extends Comparator<? super T>> comparators) {
    this.comparators =
        Iterables.toArray(comparators, (Comparator<? super T>[]) new Comparator<?>[0]);
  }

  @Override

    this.comparators = (Comparator<? super T>[]) new Comparator<?>[] {primary, secondary};
  }

  @SuppressWarnings("unchecked") // Generic array creation
  CompoundOrdering(Iterable<? extends Comparator<? super T>> comparators) {
    this.comparators =
        Iterables.toArray(comparators, (Comparator<? super T>[]) new Comparator<?>[0]);
  }

  @Override

 *   <li>{@link RangeSet}
 *   <li>{@link DiscreteDomain}
 *   <li>{@link ContiguousSet}
 * </ul>
 *
 * <h2>Classes of static utility methods</h2>
 *
 * <ul>
 *   <li>{@link Collections2}
 *   <li>{@link Comparators}
 *   <li>{@link Iterables}
 *   <li>{@link Iterators}
 *   <li>{@link Lists}
 *   <li>{@link Maps}
 *   <li>{@link MoreCollectors}
 *   <li>{@link Multimaps}
 *   <li>{@link Multisets}

   * {@code comparator}.
   */
  public static boolean hasSameComparator(Comparator<?> comparator, Iterable<?> elements) {
    checkNotNull(comparator);
    checkNotNull(elements);
    Comparator<?> comparator2;
    if (elements instanceof SortedSet) {
      comparator2 = comparator((SortedSet<?>) elements);
    } else if (elements instanceof SortedIterable) {

    MIN_MAX {
      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return MinMaxPriorityQueue.orderedBy(comparator).create();
      }
    },
    PRIORITY_QUEUE {
      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return new PriorityQueue<>(11, comparator);
      }
    },
    INVERTED_MIN_MAX {
      @Override

    MIN_MAX {
      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return MinMaxPriorityQueue.orderedBy(comparator).create();
      }
    },
    PRIORITY_QUEUE {
      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return new PriorityQueue<>(11, comparator);
      }
    },
    INVERTED_MIN_MAX {
      @Override

import java.io.Serializable;
import java.util.Comparator;
import org.jspecify.annotations.Nullable;

/** An ordering for a pre-existing comparator. */
@GwtCompatible
final class ComparatorOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Comparator<T> comparator;

  ComparatorOrdering(Comparator<T> comparator) {
    this.comparator = checkNotNull(comparator);
  }

  @Override

  public void testOrderedByComparator() {
    Comparator<? super K> comparator = navigableMap.comparator();
    if (comparator == null) {
      comparator = NATURAL_ORDER;
    }
    Iterator<Entry<K, V>> entryItr = navigableMap.entrySet().iterator();
    Entry<K, V> prevEntry = entryItr.next();
    while (entryItr.hasNext()) {
      Entry<K, V> nextEntry = entryItr.next();

  abstract SortedMultiset<E> forwardMultiset();

  @Nullable private transient Comparator<? super E> comparator;

  @Override
  public Comparator<? super E> comparator() {
    Comparator<? super E> result = comparator;
    if (result == null) {
      return comparator = Ordering.from(forwardMultiset().comparator()).reverse();
    }
    return result;
  }

  @Nullable private transient SortedSet<E> elementSet;

  abstract SortedMultiset<E> forwardMultiset();

  @LazyInit private transient @Nullable Comparator<? super E> comparator;

  @Override
  public Comparator<? super E> comparator() {
    Comparator<? super E> result = comparator;
    if (result == null) {
      result = Ordering.from(forwardMultiset().comparator()).reverse();
      comparator = result;
    }
    return result;
  }