* the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags
 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access
 * mask of the ACE, the whole access check fails. If the ACE is an "allow"
 * ACE and <i>all</i> of the bits in the desired access bits match bits in

import org.jspecify.annotations.Nullable;

/**
 * An immutable hash code of arbitrary bit length.
 *
 * @author Dimitris Andreou
 * @author Kurt Alfred Kluever
 * @since 11.0
 */
public abstract class HashCode {
  HashCode() {}

  /** Returns the number of bits in this hash code; a positive multiple of 8. */
  public abstract int bits();

  /**

 * the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags
 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access
 * mask of the ACE, the whole access check fails. If the ACE is an "allow"
 * ACE and <i>all</i> of the bits in the desired access bits match bits in

        @Test
        @DisplayName("Should indicate search bits support")
        void testIsSupportSearchBits() throws Exception {
            // Test with search bits supported
            setPrivateField(response, "supportSearchBits", true);
            assertTrue(response.isSupportSearchBits(), "Should indicate search bits support");

            // Test without search bits support

  // 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`

        @Test
        @DisplayName("Should validate constant bit ranges")
        void shouldValidateConstantBitRanges() {
            // File access constants should fit in lower 16 bits (0x0000FFFF)
            assertTrue(ACE.FILE_READ_DATA <= 0x0000FFFF, "FILE_READ_DATA should fit in lower 16 bits");
            assertTrue(ACE.FILE_WRITE_DATA <= 0x0000FFFF, "FILE_WRITE_DATA should fit in lower 16 bits");

    val symbol: Int

    /** Number of bits represented in the terminal node. */
    val terminalBitCount: Int

    /** Construct an internal node. */
    constructor() {
      this.children = arrayOfNulls(256)
      this.symbol = 0 // Not read.
      this.terminalBitCount = 0 // Not read.
    }

    /** Construct a terminal node. */
    constructor(symbol: Int, bits: Int) {
      this.children = null

        assertEquals(123, ex.getNtStatus());
    }

    /**
     * Parameterised test covering many error codes.
     * - Error code 0 returns 0 (NT_STATUS_SUCCESS)
     * - Negative values with 0xC0000000 bits set are returned as-is
     * - Positive values not in DOS_ERROR_CODES map to NT_STATUS_UNSUCCESSFUL
     */
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 123, -7 })
    void testGetNtStatusVariousCodes(int errcode) {

    long numeratorAccum = n;
    long denominatorAccum = 1;

    int bits = LongMath.log2(n, CEILING);

    int numeratorBits = bits;

    for (int i = 1; i < k; i++) {
      int p = n - i;
      int q = i + 1;

      // log2(p) >= bits - 1, because p >= n/2

      if (numeratorBits + bits >= Long.SIZE - 1) {
        // The numerator is as big as it can get without risking overflow.

 	goto no_more_room;
diff --git a/string/bits/string2.h b/string/bits/string2.h
index c9bf593..f461fc1 100644
--- a/string/bits/string2.h
+++ b/string/bits/string2.h
@@ -47,29 +47,7 @@
 #endif
 
 #if _STRING_ARCH_unaligned
-/* If we can do unaligned memory accesses we must know the endianess.  */
-# include <endian.h>
 # include <bits/types.h>
-
-# if __BYTE_ORDER == __LITTLE_ENDIAN