// array. The top bits of this value are the remaining bits of the hash value that were not used
  // in the short hash. We saw that a mask of 0x7f would keep the 7-bit value 0x6f from a full
  // hashcode of 0x89abcdef. The imaginary `hash` value would then be the remaining top 25 bits,
  // 0x89abcd80. To this is added (or'd) the `next` value, which is an index within `entries`

  // The number of compression rounds.
  private final int c;
  // The number of finalization rounds.
  private final int d;
  // Two 64-bit keys (represent a single 128-bit key).
  private final long k0;
  private final long k1;

  /**
   * @param c the number of compression rounds (must be positive)
   * @param d the number of finalization rounds (must be positive)

        value: Int,
        prefixMask: Int,
        bits: Int,
      ) {
        var value = value
        // Write the raw value for a single byte value.
        if (value < prefixMask) {
          out.writeByte(bits or value)
          return
        }

        // Write the mask to start a multibyte value.
        out.writeByte(bits or prefixMask)
        value -= prefixMask

)

// uint8 is the set of all unsigned 8-bit integers.
// Range: 0 through 255.
type uint8 uint8

// uint16 is the set of all unsigned 16-bit integers.
// Range: 0 through 65535.
type uint16 uint16

// uint32 is the set of all unsigned 32-bit integers.
// Range: 0 through 4294967295.
type uint32 uint32

// uint64 is the set of all unsigned 64-bit integers.
// Range: 0 through 18446744073709551615.

first (rounds + 1) × (128 ÷ 32) words are used. enc [60]uint32 dec [60]uint32 } const ( // AES-128 has 128-bit keys, 10 rounds, and uses 11 128-bit round keys // (11×128÷32 = 44 32-bit words). // AES-192 has 192-bit keys, 12 rounds, and uses 13 128-bit round keys // (13×128÷32 = 52 32-bit words). // AES-256 has 256-bit keys, 14 rounds, and uses 15 128-bit round keys // (15×128÷32 = 60 32-bit words). aes128KeySize = 16 aes192KeySize = 24 aes256KeySize = 32 aes128Rounds = 10 aes192Rounds = 12 aes256Rounds...

first (rounds + 1) × (128 ÷ 32) words are used. enc [60]uint32 dec [60]uint32 } const ( // AES-128 has 128-bit keys, 10 rounds, and uses 11 128-bit round keys // (11×128÷32 = 44 32-bit words). // AES-192 has 192-bit keys, 12 rounds, and uses 13 128-bit round keys // (13×128÷32 = 52 32-bit words). // AES-256 has 256-bit keys, 14 rounds, and uses 15 128-bit round keys // (15×128÷32 = 60 32-bit words). aes128KeySize = 16 aes192KeySize = 24 aes256KeySize = 32 aes128Rounds = 10 aes192Rounds = 12 aes256Rounds...

            }

            // Verify no overlapping bits
            for (int i = 0; i < capabilities.length; i++) {
                for (int j = i + 1; j < capabilities.length; j++) {
                    assertEquals(0, capabilities[i] & capabilities[j], "Capabilities should not have overlapping bits");
                }
            }
        }

        @Test

  // array. The top bits of this value are the remaining bits of the hash value that were not used
  // in the short hash. We saw that a mask of 0x7f would keep the 7-bit value 0x6f from a full
  // hashcode of 0x89abcdef. The imaginary `hash` value would then be the remaining top 25 bits,
  // 0x89abcd80. To this is added (or'd) the `next` value, which is an index within `entries`

   * This method does so by hashing 64 bits of the IPv6 address into {@code 224.0.0.0/3} (64 bits
   * into 29 bits):
   *
   * <ul>
   *   <li>If the IPv6 address contains an embedded IPv4 address, the function hashes that.
   *   <li>Otherwise, it hashes the upper 64 bits of the IPv6 address.
   * </ul>
   *
   * <p>A "coerced" IPv4 address is equivalent to itself.

| xlVersionMinor | uint16         | Minor xl-meta version.
| xlMetaV2       | msgp bin array | Bin array with serialized metadata
| crc            | msgp uint      | Lower 32 bits of 64 bit xxhash of previous array contents (v1.2+ only)
| inline data    | binary         | Inline data if any, see Inline Data section for encoding.  
| [EOF] | |

## v1.0-v1.2 Versions