// The Unsafe implementation if it's available. Otherwise, the Java implementation.
    Comparator<byte[]> comparator = UnsignedBytes.lexicographicalComparator();
    Helpers.testComparator(comparator, ordered);
    assertThat(SerializableTester.reserialize(comparator)).isSameInstanceAs(comparator);

    // The Java implementation.
    Comparator<byte[]> javaImpl = UnsignedBytes.lexicographicalComparatorJavaImpl();

  @SuppressWarnings({"unchecked", "nullness"})
  static int unsafeCompare(
      @CheckForNull Comparator<?> comparator, @CheckForNull Object o1, @CheckForNull Object o2) {
    if (comparator == null) {
      return ((Comparable<@Nullable Object>) o1).compareTo(o2);
    } else {
      return ((Comparator<@Nullable Object>) comparator).compare(o1, o2);
    }
  }

  /**

   * may be null; use {@link Ordering#natural()} to specify natural order.
   *
   * @param keyComparator the comparator that determines the key ordering
   * @param valueComparator the comparator that determines the value ordering
   */
  public static <K extends @Nullable Object, V extends @Nullable Object> TreeMultimap<K, V> create(

  private final transient long[] cumulativeCounts;
  private final transient int offset;
  private final transient int length;

  RegularImmutableSortedMultiset(Comparator<? super E> comparator) {
    this.elementSet = ImmutableSortedSet.emptySet(comparator);
    this.cumulativeCounts = ZERO_CUMULATIVE_COUNTS;
    this.offset = 0;
    this.length = 0;
  }

  RegularImmutableSortedMultiset(

            new byte[] {GREATEST, GREATEST, GREATEST});

    Comparator<byte[]> comparator = SignedBytes.lexicographicalComparator();
    Helpers.testComparator(comparator, ordered);
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testLexicographicalComparatorSerializable() {
    Comparator<byte[]> comparator = SignedBytes.lexicographicalComparator();

import org.gradle.api.attributes.MultipleCandidatesDetails;

import java.util.Comparator;

public abstract class AttributeMatchingRules {
    public static <T> Action<? super CompatibilityCheckDetails<T>> orderedCompatibility(Comparator<? super T> comparator, boolean reverse) {
        return new DefaultOrderedCompatibilityRule<>(comparator, reverse);
    }

final class CompoundOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Comparator<? super T>[] comparators;

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

  @SuppressWarnings("unchecked") // Generic array creation

   * there is no need to use this method.
   *
   * @param comparator the comparator that defines the order
   * @return comparator itself if it is already an {@code Ordering}; otherwise an ordering that
   *     wraps that comparator
   */
  @GwtCompatible(serializable = true)
  public static <T extends @Nullable Object> Ordering<T> from(Comparator<T> comparator) {
    return (comparator instanceof Ordering)
        ? (Ordering<T>) comparator

		t.Run(tt.Name, func(t *testing.T) {
			buf.Reset()
			if err := Compact(&buf, []byte(tt.compact)); err != nil {
				t.Errorf("%s: Compact error: %v", tt.Where, err)
			} else if got := buf.String(); got != tt.compact {
				t.Errorf("%s: Compact:\n\tgot:  %s\n\twant: %s", tt.Where, indentNewlines(got), indentNewlines(tt.compact))
			}

			buf.Reset()
			if err := Compact(&buf, []byte(tt.indent)); err != nil {

        Object[] constants = requireNonNull(theClass.getEnumConstants());

        // yes, UnsafeComparator does implement Comparator<byte[]>
        @SuppressWarnings("unchecked")
        Comparator<byte[]> comparator = (Comparator<byte[]>) constants[0];
        return comparator;
      } catch (Throwable t) { // ensure we really catch *everything*
        return lexicographicalComparatorJavaImpl();
      }
    }
  }