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

    public static final int ACB_NORMAL = 16;
    /** Account control bit flag: MNS logon user account */
    public static final int ACB_MNS = 32;
    /** Account control bit flag: Interdomain trust account */
    public static final int ACB_DOMTRUST = 64;
    /** Account control bit flag: Workstation trust account */
    public static final int ACB_WSTRUST = 128;

    public static final int ACB_NORMAL = 16;
    /** Account control bit flag: MNS logon user account */
    public static final int ACB_MNS = 32;
    /** Account control bit flag: Interdomain trust account */
    public static final int ACB_DOMTRUST = 64;
    /** Account control bit flag: Workstation trust account */
    public static final int ACB_WSTRUST = 128;

            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_RESERVED_1), "DCERPC_RESERVED_1 should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_CONC_MPX), "DCERPC_CONC_MPX should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_DID_NOT_EXECUTE), "DCERPC_DID_NOT_EXECUTE should be a single bit");

        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) {

    mutated[0]++;
    assertTrue(Arrays.equals(original, hash.asBytes()));
  }

  private static void assertReadableBytes(HashCode hashCode) {
    assertTrue(hashCode.bits() >= 32); // sanity
    byte[] hashBytes = hashCode.asBytes();
    int totalBytes = hashCode.bits() / 8;

    for (int bytes = 0; bytes < totalBytes; bytes++) {
      byte[] bb = new byte[bytes];
      hashCode.writeBytesTo(bb, 0, bb.length);

 * limitations under the License.
 */
package okhttp3.tls.internal.der

import okio.ByteString

/**
 * Like a [ByteString], but whose bits are not necessarily a strict multiple of 8.
 */
internal data class BitString(
  val byteString: ByteString,
  /** 0-7 unused bits in the last byte. */
  val unusedBitsCount: Int,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {

   * </ul>
   */
  private transient @Nullable Object table;

  /**
   * Contains the logical entries, in the range of [0, size()). The high bits of each int are the
   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>

        assertTrue(SmbConstants.DEFAULT_SO_TIMEOUT >= SmbConstants.DEFAULT_RESPONSE_TIMEOUT);
    }

    @Test
    @DisplayName("Should have distinct bit patterns for flags")
    void testDistinctBitPatterns() {
        // Verify file attributes have distinct bit patterns
        int[] attributes = { SmbConstants.ATTR_READONLY, SmbConstants.ATTR_HIDDEN, SmbConstants.ATTR_SYSTEM, SmbConstants.ATTR_VOLUME,

![Erasure](https://github.com/minio/minio/blob/master/docs/screenshots/erasure-code.jpg?raw=true)

## What is Bit Rot protection?

Bit Rot, also known as data rot or silent data corruption is a data loss issue faced by disk drives today. Data on the drive may silently get corrupted without signaling an error has occurred, making bit rot more dangerous than a permanent hard drive failure.