*    @param    offset    starting position of sub-array.
     */
    private void transform(final byte[] block, int offset) {

        // encodes 64 bytes from input block into an array of 16 32-bit
        // entities. Use A as a temp var.
        for (int i = 0; i < 16; i++) {
            X[i] = block[offset++] & 0xFF | (block[offset++] & 0xFF) << 8 | (block[offset++] & 0xFF) << 16 | (block[offset++] & 0xFF) << 24;

        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);

	for _, block := range enBlocks[:dataBlocks] {
		// Skip blocks until we have reached our offset.
		if offset >= int64(len(block)) {
			// Decrement offset.
			offset -= int64(len(block))
			continue
		}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.

          imports = ["okhttp3.RequestBody.Companion.toRequestBody"],
        ),
      level = DeprecationLevel.WARNING,
    )
    fun create(
      contentType: MediaType?,
      content: ByteArray,
      offset: Int = 0,
      byteCount: Int = content.size,
    ): RequestBody = content.toRequestBody(contentType, offset, byteCount)

    @JvmStatic

        byte[] data = response.getOutputBuffer();
        int offset = 0;
        
        while (offset < data.length) {
            int nextEntryOffset = readInt4(data, offset);
            int action = readInt4(data, offset + 4);
            int fileNameLength = readInt4(data, offset + 8);
            
            // Extract filename

        byte[] buffer = new byte[512];
        int offset = 0;

        // Write setup
        offset += trans2QueryFSInfo.writeSetupWireFormat(buffer, offset);
        assertEquals(2, offset);

        // Write parameters
        offset += trans2QueryFSInfo.writeParametersWireFormat(buffer, offset);
        assertEquals(4, offset);

        // Write data
        offset += trans2QueryFSInfo.writeDataWireFormat(buffer, offset);

        return this;
    }

    /**
     * Gets the fragment offset.
     *
     * @return the fragment offset value
     */
    public int getFragmentOffset() {
        return fragmentOffset;
    }

    /**
     * Sets the fragment offset with fluent interface.
     *
     * @param fragmentOffset the fragment offset value
     * @return this HighlightInfo instance for method chaining
     */

        int offset = 0;
        if (domainLength > 0) {
            writeUShort(targetInfo, offset, 2);
            offset += 2;
            writeUShort(targetInfo, offset, domainLength);
            offset += 2;
            System.arraycopy(domain, 0, targetInfo, offset, domainLength);
            offset += domainLength;
        }
        if (serverLength > 0) {

    private int fid, count, offset, remaining, off;
    private byte[] b;

    SmbComWrite() {
        command = SMB_COM_WRITE;
    }

    SmbComWrite(final int fid, final int offset, final int remaining, final byte[] b, final int off, final int len) {
        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;

        }
    }

    /**
     * Validate offset and length for file operations
     *
     * @param offset file offset
     * @param length operation length
     * @param fileSize total file size
     * @throws SmbException if parameters are invalid
     */
    public void validateFileOperation(long offset, long length, long fileSize) throws SmbException {