// Verify each is a power of 2
            for (int cap : capabilities) {
                assertTrue(isPowerOfTwo(cap), "Capability 0x" + Integer.toHexString(cap) + " should be a power of 2");
            }

            // Verify no overlapping bits
            for (int i = 0; i < capabilities.length; i++) {
                for (int j = i + 1; j < capabilities.length; j++) {

			apiRequestsMaxPerNode = int(maxMem / uint64(maxSetDrives*blockSize+int(blockSizeV1*2+blockSizeV2*2)))
		} else {
			// ram_per_request is (1MiB+32KiB) * driveCount \
			//    + 2 * 1MiB (default erasure block size v2)
			apiRequestsMaxPerNode = int(maxMem / uint64(maxSetDrives*blockSize+int(blockSizeV2*2)))
		}
	} else {
		apiRequestsMaxPerNode = cfg.RequestsMax

            _src.align(4);
            final int _netnamep = _src.dec_ndr_long();
            this.type = _src.dec_ndr_long();
            final int _remarkp = _src.dec_ndr_long();
            this.permissions = _src.dec_ndr_long();
            this.max_uses = _src.dec_ndr_long();
            this.current_uses = _src.dec_ndr_long();
            final int _pathp = _src.dec_ndr_long();
            final int _passwordp = _src.dec_ndr_long();

  @Benchmark
  int factorial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += BigIntegerMath.factorial(factorials[j]).intValue();
    }
    return tmp;
  }

  @Benchmark
  int binomial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & 0xffff;
      tmp += BigIntegerMath.binomial(factorials[j], binomials[j]).intValue();

    }
  }

  @Benchmark
  int arrayIndexed(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (int index = 0; index < size; index++) {
        sum += array[index].hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int arrayIndexedLength(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (int index = 0; index < array.length; index++) {

    // SMB uses little-endian byte order
    private static void writeLong(byte[] buf, int offset, long val) {
        for (int i = 0; i < 8; i++) {
            buf[offset + i] = (byte) ((val >>> (8 * i)) & 0xFF);
        }
    }

    private static void writeShort(byte[] buf, int offset, int val) {
        buf[offset] = (byte) (val & 0xFF);
        buf[offset + 1] = (byte) ((val >>> 8) & 0xFF);
    }

  static void checkAvalanche(HashFunction function, int trials, double epsilon) {
    Random rand = new Random(0);
    int keyBits = 32;
    int hashBits = function.bits();
    for (int i = 0; i < keyBits; i++) {
      int[] same = new int[hashBits];
      int[] diff = new int[hashBits];
      // go through trials to compute probability
      for (int j = 0; j < trials; j++) {
        int key1 = rand.nextInt();

        // Prepare test data with maximum int values
        byte[] buffer = new byte[22];
        int idFileSystem = Integer.MAX_VALUE;
        int sectPerAlloc = 100;
        int alloc = Integer.MAX_VALUE / 200;
        int free = Integer.MAX_VALUE / 200;
        int bytesPerSect = 512;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset);

    // information levels

    static final int SMB_INFO_STANDARD = 1;
    static final int SMB_INFO_QUERY_EA_SIZE = 2;
    static final int SMB_INFO_QUERY_EAS_FROM_LIST = 3;
    static final int SMB_FIND_FILE_DIRECTORY_INFO = 0x101;
    static final int SMB_FIND_FILE_FULL_DIRECTORY_INFO = 0x102;
    static final int SMB_FILE_NAMES_INFO = 0x103;
    static final int SMB_FILE_BOTH_DIRECTORY_INFO = 0x104;

        void testEncodeWithDifferentHashAlgoCounts(int count) {
            int[] hashAlgos = new int[count];
            for (int i = 0; i < count; i++) {
                hashAlgos[i] = i + 1;
            }
            byte[] salt = new byte[16];

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);
            int encoded = context.encode(buffer, 0);