* compare} methods unconditionally, the {@code ComparisonChain} implementation stops calling its
 * inputs' {@link Comparable#compareTo compareTo} and {@link Comparator#compare compare} methods as
 * soon as one of them returns a nonzero result. This optimization is typically important only in
 * the presence of expensive {@code compareTo} and {@code compare} implementations.
 *

 * compare} methods unconditionally, the {@code ComparisonChain} implementation stops calling its
 * inputs' {@link Comparable#compareTo compareTo} and {@link Comparator#compare compare} methods as
 * soon as one of them returns a nonzero result. This optimization is typically important only in
 * the presence of expensive {@code compareTo} and {@code compare} implementations.
 *

   * instead (but note that it does not guarantee which tied minimum element is returned).
   *
   * @param a value to compare, returned if less than or equal to the rest.
   * @param b value to compare
   * @param c value to compare
   * @param rest values to compare
   * @throws ClassCastException if the parameters are not <i>mutually comparable</i> under this
   *     ordering.
   */
  @ParametricNullness

   * Comparators}</a>.
   *
   * @param a first value to compare, returned if less than or equal to b.
   * @param b second value to compare.
   * @throws ClassCastException if the parameters are not <i>mutually comparable</i>.
   * @since 30.0
   */
  public static <T extends Comparable<? super T>> T min(T a, T b) {
    return (a.compareTo(b) <= 0) ? a : b;
  }

  /**

   * instead (but note that it does not guarantee which tied minimum element is returned).
   *
   * @param a value to compare, returned if less than or equal to the rest.
   * @param b value to compare
   * @param c value to compare
   * @param rest values to compare
   * @throws ClassCastException if the parameters are not <i>mutually comparable</i> under this
   *     ordering.
   */
  @ParametricNullness

   * Comparators}</a>.
   *
   * @param a first value to compare, returned if less than or equal to b.
   * @param b second value to compare.
   * @throws ClassCastException if the parameters are not <i>mutually comparable</i>.
   * @since 30.0
   */
  public static <T extends Comparable<? super T>> T min(T a, T b) {
    return (a.compareTo(b) <= 0) ? a : b;
  }

  /**

   * @return a negative value if {@code a} is less than {@code b}; a positive value if {@code a} is
   *     greater than {@code b}; or zero if they are equal
   */
  @SuppressWarnings("InlineMeInliner") // Integer.compare unavailable under GWT+J2CL
  public static int compare(long a, long b) {
    return Longs.compare(flip(a), flip(b));
  }

  /**
   * Returns the least value present in {@code array}, treating values as unsigned.
   *

  }

  /**
   * Compares the two specified {@code byte} values, treating them as unsigned values between 0 and
   * 255 inclusive. For example, {@code (byte) -127} is considered greater than {@code (byte) 127}
   * because it is seen as having the value of positive {@code 129}.
   *
   * @param a the first {@code byte} to compare
   * @param b the second {@code byte} to compare

      assertThat(comparator1.compare(left, right)).isEqualTo(0);
      assertThat(comparator2.compare(left, right)).isEqualTo(0);
      int i = rnd.nextInt(left.length);
      left[i] ^= (byte) (1 + rnd.nextInt(255));
      assertThat(signum(comparator1.compare(left, right)))
          .isEqualTo(signum(UnsignedBytes.compare(left[i], right[i])));
      assertThat(signum(comparator2.compare(left, right)))

  /**
   * A specification for which index to return if the list contains at least one element that
   * compares as equal to the key.
   */
  enum KeyPresentBehavior {
    /**
     * Return the index of any list element that compares as equal to the key. No guarantees are
     * made as to which index is returned, if more than one element compares as equal to the key.
     */
    ANY_PRESENT {
      @Override