"""
        ),
    ] = _Unset,
    decimal_places: Annotated[
        Union[int, None],
        Doc(
            """
            Maximum number of decimal places allowed for numbers.
            """
        ),
    ] = _Unset,
    examples: Annotated[
        Optional[list[Any]],
        Doc(
            """
            Example values for this field.

    int decimal = 0;
    int max = Integer.MAX_VALUE / 10; // for int overflow detection
    for (int i = start; i < end; i++) {
      if (decimal > max) {
        return -1;
      }
      decimal *= 10;
      int digit = Character.digit(string.charAt(i), 10);
      if (digit < 0) {
        return -1;
      }
      decimal += digit;
    }
    return decimal;
  }

		}
		expectedSql := []string{
			`ALTER TABLE "migrate_decimal_columns" ALTER COLUMN "recid1" decimal(8) NOT NULL`,
			`ALTER TABLE "migrate_decimal_columns" ALTER COLUMN "recid2" decimal(9,1) NOT NULL`,
			`ALTER TABLE "migrate_decimal_columns" ALTER COLUMN "recid3" decimal(9,2) NOT NULL`,
		}
		decimalColumnsTest[MigrateDecimalColumn, MigrateDecimalColumn2](t, expectedSql)

    long rem = dividend - quotient * divisor;
    return rem - (compare(rem, divisor) >= 0 ? divisor : 0);
  }

  /**
   * Returns the unsigned {@code long} value represented by the given decimal string.
   *
   * <p><b>Java 8+ users:</b> use {@link Long#parseUnsignedLong(String)} instead.
   *
   * @throws NumberFormatException if the string does not contain a valid unsigned {@code long}
   *     value

@NullUnmarked
public class HashStringBenchmark {
  static class MaxCodePoint {
    final int value;

    /**
     * Convert the input string to a code point. Accepts regular decimal numerals, hex strings, and
     * some symbolic names meaningful to humans.
     */
    private static int decode(String userFriendly) {
      try {
        return Integer.decode(userFriendly);

        assertThrows(PACDecodingException.class, () -> pdis.readString());
    }

    @Test
    public void testReadId() throws IOException, PACDecodingException {
        // RID = 0x12345678 (305419896 in decimal, little-endian)
        byte[] data = new byte[] { 0x78, 0x56, 0x34, 0x12 };
        PacDataInputStream pdis = createInputStream(data);
        SID sid = pdis.readId();

- **Type Safe** - Comprehensive use of generics and modern Java type system features

### Additional Components
- **Text Processing** (`org.codelibs.core.text`) - JSON utilities, tokenization, decimal formatting, and text manipulation
- **Logging Abstraction** (`org.codelibs.core.log`) - Flexible logging system supporting JCL (Jakarta Commons Logging) and JUL (Java Util Logging)

 *
 * This matches IPv6 addresses as a hex string containing at least one colon, and possibly
 * including dots after the first colon. It matches IPv4 addresses as strings containing only
 * decimal digits and dots. This pattern matches strings like "a:.23" and "54" that are neither IP
 * addresses nor hostnames; they will be verified as IP addresses (which is a more strict
 * verification).
 */

        }

        @Test
        @DisplayName("Textual constructor with hex identifier authority")
        void testTextualConstructorHexAuthority() throws Exception {
            // Arrange: 0x5 == decimal 5 results in decimal authority in toString
            SID sid = new SID("S-1-0x000000000005-21-99");

            // Act
            String s = sid.toString();

            // Assert
            assertEquals("S-1-5-21-99", s);

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

  /**
   * Returns the unsigned {@code int} value represented by the given string.
   *
   * <p>Accepts a decimal, hexadecimal, or octal number given by specifying the following prefix:
   *
   * <ul>
   *   <li>{@code 0x}<i>HexDigits</i>
   *   <li>{@code 0X}<i>HexDigits</i>
   *   <li>{@code #}<i>HexDigits</i>