// to the given dividend, so that we don't have half of our divisions being
  // trivial because the divisor is bigger than the dividend.
  // Using remainder here does not give us a uniform distribution but it should
  // not have a big impact on the measurement.
  private static long randomDivisor(long dividend) {
    long r = RANDOM_SOURCE.nextLong();
    if (dividend == -1) {
      return r;
    } else {

    return (int) (toLong(dividend) / toLong(divisor));
  }

  /**
   * Returns dividend % divisor, where the dividend and divisor are treated as unsigned 32-bit
   * quantities.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#remainderUnsigned(int, int)} instead.
   *
   * @param dividend the dividend (numerator)
   * @param divisor the divisor (denominator)
   * @throws ArithmeticException if divisor is 0
   */

    for (int i = 0; i < 1000000; i++) {
      long dividend = r.nextLong();
      long divisor = r.nextLong();
      // Test that the Euclidean property is preserved:
      assertThat(
              dividend
                  - (divisor * UnsignedLongs.divide(dividend, divisor)
                      + UnsignedLongs.remainder(dividend, divisor)))
          .isEqualTo(0);
    }
  }

    Random r = new Random(0L);
    for (int i = 0; i < 1000000; i++) {
      int dividend = r.nextInt();
      int divisor = r.nextInt();
      // Test that the Euclidean property is preserved:
      assertThat(
              dividend
                  - (divisor * UnsignedInts.divide(dividend, divisor)
                      + UnsignedInts.remainder(dividend, divisor)))
          .isEqualTo(0);
    }
  }

    a >>= aTwos; // divide out all 2s
    int bTwos = Integer.numberOfTrailingZeros(b);
    b >>= bTwos; // divide out all 2s
    while (a != b) { // both a, b are odd
      // The key to the binary GCD algorithm is as follows:
      // Both a and b are odd. Assume a > b; then gcd(a - b, b) = gcd(a, b).
      // But in gcd(a - b, b), a - b is even and b is odd, so we can divide out powers of two.

   *
   * @param dividend the dividend (numerator)
   * @param divisor the divisor (denominator)
   * @throws ArithmeticException if divisor is 0
   * @since 11.0
   */
  public static long remainder(long dividend, long divisor) {
    if (divisor < 0) { // i.e., divisor >= 2^63:
      if (compare(dividend, divisor) < 0) {
        return dividend; // dividend < divisor
      } else {

    return Tables.transformValues(table, DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);
    table.put("three", 'a', 3);
    table.put("four", 'b', 4);
    return Tables.transformValues(table, DIVIDE_BY_2).column('a');
  }

    for (int i = 0; i < 1000000; i++) {
      long dividend = r.nextLong();
      long divisor = r.nextLong();
      // Test that the Euclidean property is preserved:
      assertThat(
              dividend
                  - (divisor * UnsignedLongs.divide(dividend, divisor)
                      + UnsignedLongs.remainder(dividend, divisor)))
          .isEqualTo(0);
    }
  }

          long expected =
              new BigDecimal(valueOf(p)).divide(new BigDecimal(valueOf(q)), 0, mode).longValue();
          long actual = LongMath.divide(p, q, mode);
          if (expected != actual) {
            failFormat("expected divide(%s, %s, %s) = %s; got %s", p, q, mode, expected, actual);
          }
        }
      }
    }
  }

  @GwtIncompatible // TODO

  // to the given dividend, so that we don't have half of our divisions being
  // trivial because the divisor is bigger than the dividend.
  // Using remainder here does not give us a uniform distribution but it should
  // not have a big impact on the measurement.
  private static long randomDivisor(long dividend) {
    long r = RANDOM_SOURCE.nextLong();
    if (dividend == -1) {
      return r;
    } else {