for (int bits = 10; bits < 63; bits++) {
      for (int i = 0; i < 100; i++) {
        long p = BigInteger.probablePrime(bits, rand).longValue();
        assertTrue(LongMath.isPrime(p));
      }
    }
  }

  @GwtIncompatible // isPrime is GWT-incompatible
  public void testIsPrimeOnRandomComposites() {
    Random rand = new Random(1);
    for (int bits = 5; bits < 32; bits++) {

// not nil. Values of string type are immutable.
type string string

// int is a signed integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, int32.
type int int

// uint is an unsigned integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, uint32.
type uint uint

 *       byte sequences under the covers.
 *   <li><b>hash code:</b> each hash function always yields hash codes of the same fixed bit length
 *       (given by {@link #bits}). For example, {@link Hashing#sha1} produces a 160-bit number,
 *       while {@link Hashing#murmur3_32()} yields only 32 bits. Because a {@code long} value is
 *       clearly insufficient to hold all hash code values, this API represents a hash code as an
 *       instance of {@link HashCode}.

	v := BucketReplicationStat{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

func BenchmarkUnmarshalBucketReplicationStat(b *testing.B) {
	v := BucketReplicationStat{}
	bts, _ := v.MarshalMsg(nil)
	b.ReportAllocs()

 * done by determining whether the domain ended with a {@linkplain #isPublicSuffix() public suffix}
 * but was not itself a public suffix. However, this test is no longer accurate. There are many
 * domains which are both public suffixes and addressable as hosts; {@code "uk.com"} is one example.
 * Using the subset of public suffixes that are {@linkplain #isRegistrySuffix() registry suffixes},

func BenchmarkAppendMsgrebalanceInfo(b *testing.B) {
	v := rebalanceInfo{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

func BenchmarkUnmarshalrebalanceInfo(b *testing.B) {
	v := rebalanceInfo{}
	bts, _ := v.MarshalMsg(nil)
	b.ReportAllocs()
	b.SetBytes(int64(len(bts)))

   * enclosed} by both this range and {@code other}.
   *
   * <p>For example,
   *
   * <ul>
   *   <li>{@code [2, 4)} and {@code [5, 7)} are not connected
   *   <li>{@code [2, 4)} and {@code [3, 5)} are connected, because both enclose {@code [3, 4)}
   *   <li>{@code [2, 4)} and {@code [4, 6)} are connected, because both enclose the empty range
   *       {@code [4, 4)}
   * </ul>

		case "Total":
			z.Total, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "Size":
			z.Size, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "N":
			z.N, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "N")

     * deal with the cases where rounding towards 0 is wrong, which typically depends on the sign of
     * p / q.
     *
     * signum is 1 if p and q are both nonnegative or both negative, and -1 otherwise.
     */
    int signum = 1 | (int) ((p ^ q) >> (Long.SIZE - 1));
    boolean increment;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(rem == 0);

			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.KeyRotate = nil
			} else {
				if z.KeyRotate == nil {
					z.KeyRotate = new(BatchJobKeyRotateV1)
				}
				bts, err = z.KeyRotate.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "KeyRotate")
					return
				}
			}
		case "Expire":
			if msgp.IsNil(bts) {