};

  /** The notion of equality used by AtomicDoubleArray */
  static boolean bitEquals(double x, double y) {
    return Double.doubleToRawLongBits(x) == Double.doubleToRawLongBits(y);
  }

  static void assertBitEquals(double x, double y) {
    assertEquals(Double.doubleToRawLongBits(x), Double.doubleToRawLongBits(y));
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNulls() {

  public final Hasher putBoolean(boolean b) {
    return putByte(b ? (byte) 1 : (byte) 0);
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putDouble(double d) {
    return putLong(Double.doubleToRawLongBits(d));
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putFloat(float f) {
    return putInt(Float.floatToRawIntBits(f));
  }

  @Override
  @CanIgnoreReturnValue

            case HALF_EVEN:
              // roundFloorAsDouble and roundCeilingAsDouble are neighbors, so precisely
              // one of them should have an even long representation
              return ((Double.doubleToRawLongBits(roundFloorAsDouble) & 1L) == 0)
                  ? roundFloorAsDouble
                  : roundCeilingAsDouble;
            case HALF_DOWN:

    assertThrows(IllegalArgumentException.class, () -> DoubleUtils.ensureNonNegative(Double.NaN));
  }

  public void testOneBits() {
    assertEquals(DoubleUtils.ONE_BITS, Double.doubleToRawLongBits(1.0));
  }

  @FormatMethod
  private static void failFormat(String template, Object... args) {
    fail(String.format(template, args));
  }

    }
    return tmp;
  }

  @Benchmark
  long roundToDouble(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(BigIntegerMath.roundToDouble(nonzero1[j], mode));
    }
    return tmp;
  }

  Hasher putLong(long l);

  /** Equivalent to {@code putInt(Float.floatToRawIntBits(f))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putFloat(float f);

  /** Equivalent to {@code putLong(Double.doubleToRawLongBits(d))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putDouble(double d);

  /** Equivalent to {@code putByte(b ? (byte) 1 : (byte) 0)}. */
  @CanIgnoreReturnValue
  @Override

    }
  }

  @Benchmark
  long factorialDouble(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(impl.factorialDouble(factorials[j]));
    }
    return tmp;
  }

  @Benchmark
  int intGCD(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;

    }
  }

  @Benchmark
  long factorialDouble(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(impl.factorialDouble(factorials[j]));
    }
    return tmp;
  }

  @Benchmark
  int intGCD(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;