// First add all the integer candidate values.
    longValues.addAll(Iterables.transform(POSITIVE_INTEGER_CANDIDATES, TO_LONG));
    // Add boundary values manually to avoid over/under flow (this covers 2^N for 31 and 63).
    longValues.add(Integer.MAX_VALUE + 1L, Long.MAX_VALUE - 1L, Long.MAX_VALUE);

    // Now add values near 2^N for lots of values of N.
    for (int exponent : asList(32, 33, 39, 40, 41, 47, 48, 49, 55, 56, 57)) {

    assertThat(multimap.values()).containsExactly(6, 3, 2, 5, 2, 4).inOrder();
    assertThat(multimap.get("a")).containsExactly(5, 2).inOrder();
    assertThat(multimap.get("b")).containsExactly(6, 3).inOrder();
    assertTrue(multimap.get("a") instanceof ImmutableSortedSet);
    assertEquals(
        Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator());

    BigDecimal bigMean = new BigDecimal(bigX.add(bigY)).divide(two, RoundingMode.FLOOR);
    return bigMean.longValueExact();
  }

  private static boolean fitsInLong(BigInteger big) {
    return big.bitLength() <= 63;
  }

  private static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
  private static final BigInteger MIN_LONG = BigInteger.valueOf(Long.MIN_VALUE);

//	}
	SLL	$19, R21	// 0015acc0
	SLLV	$19, R21	// 0015acf8
	SRL	$31, R17	// 00118fc2
	SRLV	$31, R17	// 00118ffa
	SRA	$3, R12		// 000c60c3
	SRAV	$12, R3		// 00031b3b
	ROTR	$12, R8		// 00284302
	ROTRV	$63, R22	// 0036b7fe


//	LAND/LXOR/LNOR/LOR rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	AND	R14, R8		// 010e4024
	XOR	R15, R9		// 012f4826
	NOR	R16, R10	// 01505027

    assertThat(formEncode(59)).isEqualTo("%3B")
    assertThat(formEncode(60)).isEqualTo("%3C")
    assertThat(formEncode(61)).isEqualTo("%3D")
    assertThat(formEncode(62)).isEqualTo("%3E")
    assertThat(formEncode(63)).isEqualTo("%3F")
    assertThat(formEncode(64)).isEqualTo("%40")
    assertThat(formEncode(65)).isEqualTo("A")
    assertThat(formEncode(90)).isEqualTo("Z")
    assertThat(formEncode(91)).isEqualTo("%5B")

    bytesIn.writeUtf8("custom-key")
    bytesIn.writeByte(0x0d) // Literal value (len = 13)
    bytesIn.writeUtf8("custom-header")
    bytesIn.writeByte(0xbe) // Indexed name and value (idx = 63)
    hpackWriter!!.writeHeaders(headerBlock)
    assertThat(bytesOut).isEqualTo(bytesIn)
    assertThat(hpackWriter!!.headerCount).isEqualTo(1)
    val entry = hpackWriter!!.dynamicTable[hpackWriter!!.dynamicTable.size - 1]!!

	github.com/miekg/dns v1.1.65
	github.com/minio/cli v1.24.2
	github.com/minio/console v1.7.7-0.20250905210349-2017f33b26e1
	github.com/minio/csvparser v1.0.0
	github.com/minio/dnscache v0.1.1
	github.com/minio/dperf v0.6.3
	github.com/minio/highwayhash v1.0.3
	github.com/minio/kms-go/kes v0.3.1
	github.com/minio/kms-go/kms v0.5.1-0.20250225090116-4e64ce8d0f35
	github.com/minio/madmin-go/v3 v3.0.109
	github.com/minio/minio-go/v7 v7.0.91

fun String.canParseAsIpAddress(): Boolean = VERIFY_AS_IP_ADDRESS.matches(this)

/**
 * Returns true if the length is not valid for DNS (empty or greater than 253 characters), or if any
 * label is longer than 63 characters. Trailing dots are okay.
 */
internal fun String.containsInvalidLabelLengths(): Boolean {
  if (length !in 1..253) return true

  var labelStart = 0
  while (true) {

   * prefix, or when one array is a prefix of the other, treats the shorter array as the lesser. For
   * example, {@code [] < [1L] < [1L, 2L] < [2L] < [1L << 63]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(long[],
   * long[])}.
   *

	_ = x[ErrRemoteTargetDenyAddError-59]
	_ = x[ErrReplicationNoExistingObjects-60]
	_ = x[ErrReplicationValidationError-61]
	_ = x[ErrReplicationPermissionCheckError-62]
	_ = x[ErrObjectRestoreAlreadyInProgress-63]
	_ = x[ErrNoSuchKey-64]
	_ = x[ErrNoSuchUpload-65]
	_ = x[ErrInvalidVersionID-66]
	_ = x[ErrNoSuchVersion-67]
	_ = x[ErrNotImplemented-68]
	_ = x[ErrPreconditionFailed-69]
	_ = x[ErrRequestTimeTooSkewed-70]