import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Microbenchmark for {@link UnsignedBytes}.
 *
 * @author Hiroshi Yamauchi
 */
@NullUnmarked
public class UnsignedBytesBenchmark {

  private byte[] ba1;
  private byte[] ba2;
  private byte[] ba3;
  private byte[] ba4;
  private Comparator<byte[]> javaImpl;

            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();

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

    @SuppressWarnings("unchecked")
    @Override
    public Comparator<? super K> comparator() {
      Comparator<? super K> result = comparator;
      if (result == null) {
        Comparator<? super K> forwardCmp = forward().comparator();
        if (forwardCmp == null) {
          forwardCmp = (Comparator) Ordering.natural();
        }

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

    @SuppressWarnings("unchecked")
    @Override
    public Comparator<? super K> comparator() {
      Comparator<? super K> result = comparator;
      if (result == null) {
        Comparator<? super K> forwardCmp = forward().comparator();
        if (forwardCmp == null) {
          forwardCmp = (Comparator) Ordering.natural();
        }

    }

    SortedMultiset<E> emptyMultiset = (SortedMultiset<E>) delegate.create();
    Comparator<? super E> comparator = emptyMultiset.comparator();
    SampleElements<E> samples = delegate.samples();
    List<E> samplesList =
        asList(samples.e0(), samples.e1(), samples.e2(), samples.e3(), samples.e4());

    sort(samplesList, comparator);
    E firstInclusive = samplesList.get(0);

      map.put(entry.getKey(), entry.getValue());
    }
    return map;
  }

  static <T> Comparator<T> arbitraryNullFriendlyComparator() {
    return new NullFriendlyComparator<>();
  }

  private static final class NullFriendlyComparator<T> implements Comparator<T>, Serializable {
    @Override
    public int compare(T left, T right) {

    final E lastInclusive;
    private final Comparator<? super E> comparator;
    private final TestSortedSetGenerator<E> delegate;

    public SortedSetSubsetTestSetGenerator(
        TestSortedSetGenerator<E> delegate, Bound to, Bound from) {
      this.to = to;
      this.from = from;
      this.delegate = delegate;

      SortedSet<E> emptySet = delegate.create();
      this.comparator = emptySet.comparator();

   * {@code ImmutableList}, use {@code stream.sorted(comparator).collect(toImmutableList())}.
   *
   * @throws NullPointerException if any element in the input is null
   * @since 21.0
   */
  public static <E> ImmutableList<E> sortedCopyOf(
      Comparator<? super E> comparator, Iterable<? extends E> elements) {
    checkNotNull(comparator);
    @SuppressWarnings("unchecked") // all supported methods are covariant

 * @author Louis Wasserman
 * @since 11.0
 */
public interface SortedMultiset<E extends @Nullable Object> extends Multiset<E>, SortedIterable<E> {
  Comparator<? super E> comparator();

  @Nullable Entry<E> firstEntry();

  @Nullable Entry<E> lastEntry();

  @Nullable Entry<E> pollFirstEntry();

  @Nullable Entry<E> pollLastEntry();

  /**

    }

    @Override
    public SortedMap<K, V> tailMap(K fromKey) {
      return tailMap(fromKey, true);
    }

    @Override
    public Comparator<? super K> comparator() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate().comparator();
    }

    @Override
    public K firstKey() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate().firstKey();
    }