int[] arr = {b};
            write(arr, 0, 1);
        }

        public void write(int[] bytes, int offset, int length) throws IOException {
            for (int i = 0; i < bytes.length; i++) {
                delegate.write(bytes[i]);
                if (bytes[i] == '\n') {
                    delegate.write(indent);
                }
            }
        }
    }

        // Nonces should have proper size
        assertEquals(16, nonce1.length, "GCM nonce should be 16 bytes");
        assertEquals(16, nonce2.length, "GCM nonce should be 16 bytes");
        assertEquals(16, nonce3.length, "GCM nonce should be 16 bytes");

        // For GCM, last 4 bytes should contain incrementing counter
        ByteBuffer buffer1 = ByteBuffer.wrap(nonce1, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);

            buffer[bufferIndex + 2] = expectedOplockLevel;

            // Write reserved field (4 bytes at offset 4)
            bufferIndex += 4;

            // Write Reserved2 (4 bytes)
            bufferIndex += 4;

            // Write file ID (16 bytes)
            byte[] expectedFileId = createTestData(16);
            System.arraycopy(expectedFileId, 0, buffer, bufferIndex, 16);

   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 4 elements
   */
  public static int fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1], bytes[2], bytes[3]);
  }

  /**
   * Returns the {@code int} value whose byte representation is the given 4 bytes, in big-endian

     * @param off
     *            offset into buffer
     * @param len
     *            read up to <code>len</code> bytes
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */
    int read(byte[] b, int off, int len) throws SmbException;

    /**
     * Current position in file
     *
     * @return current position
     */
    long getFilePointer();

    /**

    /** HTTP/2: Size in bytes of the table used to decode the sender's header blocks. */
    const val HEADER_TABLE_SIZE = 1

    /** HTTP/2: The peer must not send a PUSH_PROMISE frame when this is 0. */
    const val ENABLE_PUSH = 2

    /** Sender's maximum number of concurrent streams. */
    const val MAX_CONCURRENT_STREAMS = 3

    /** Window size in bytes. */
    const val INITIAL_WINDOW_SIZE = 4

    }

    /// Encrypt a block of eight bytes.
    private void encrypt(final byte[] clearText, final int clearOff, final byte[] cipherText, final int cipherOff) {

        squashBytesToInts(clearText, clearOff, tempInts, 0, 2);
        des(tempInts, tempInts, encryptKeys);
        spreadIntsToBytes(tempInts, 0, cipherText, cipherOff, 2);
    }

    /// Decrypt a block of eight bytes.

 * Provides standardized method for converting objects to their binary representation.
 *
 * @author mbechler
 */
public class ByteEncodable implements Encodable {

    private final byte[] bytes;
    private final int off;
    private final int len;

    /**
     * Constructs a ByteEncodable object wrapping a byte array segment.
     *
     * @param b the byte array to wrap

        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes from the file into the specified byte array.
     *
     * @param b the byte array to read data into
     * @param off the offset in the array at which to start storing bytes
     * @param len the maximum number of bytes to read
     * @return the number of bytes read, or -1 if end of file is reached
     * @throws SmbException if an I/O error occurs

     * @param usage the Kerberos key usage number for this operation
     * @param baseKey the base Kerberos key for key derivation
     * @param input the data to calculate the MAC for
     * @return the calculated MAC bytes (truncated to 12 bytes)
     * @throws GeneralSecurityException if cryptographic operations fail
     */
    public static byte[] calculateMacHMACAES(int usage, KerberosKey baseKey, byte[] input) throws GeneralSecurityException {