if offset < 0 || length < 0 {
		return -1, errInvalidArgument
	}
	if offset+length > totalLength {
		return -1, errInvalidArgument
	}

	if length == 0 {
		return 0, nil
	}

	reader := newParallelReader(readers, e, offset, totalLength)
	if len(prefer) == len(readers) {

        byte[] dst = new byte[200];

        int offset = 50;
        int length = name.writeWireFormat(dst, offset);

        // Check first byte at offset
        assertEquals(0x20, dst[offset]);

        // Check type encoding at correct offset
        assertEquals('C', dst[offset + 31]);
        assertEquals('A', dst[offset + 32]);

        assertTrue(length > 33);
    }

    @Test

    @Test
    @DisplayName("Test decode with buffer offset")
    void testDecodeWithBufferOffset() throws SMBProtocolDecodingException {
        // Prepare test data with offset
        byte[] buffer = new byte[20]; // Extra space to test offset
        int bufferIndex = 7; // Start at offset 7
        long expectedIndexNumber = 0xFEDCBA9876543210L;

        // Encode test data at offset

        <match value="0x4" type="big32" offset="4"/>
        <match value="0x5" type="big32" offset="4"/>
        <match value="0x6" type="big32" offset="4"/>
        <match value="0x7" type="big32" offset="4"/>
        <match value="0x8" type="big32" offset="4"/>
        <match value="0x9" type="big32" offset="4"/>
        <match value="0xA" type="big32" offset="4"/>
        <match value="0xB" type="big32" offset="4"/>

    void testSignWithValidParameters() {
        // Arrange
        int offset = 0;
        int length = testData.length;

        // Act
        signingDigest.sign(testData, offset, length, request, response);

        // Assert
        verify(signingDigest, times(1)).sign(testData, offset, length, request, response);
    }

    @Test
    @DisplayName("Test sign method with different offsets")

            assertEquals(expected[i], dst[offset + i], () -> "byte index " + idx);
        }
        // The region before offset and after the payload must remain untouched.
        for (int i = 0; i < offset; i++) {
            final int idx = i;
            assertEquals(0, dst[i], () -> "pre-offset byte " + idx + " modified");
        }
        for (int i = offset + 8; i < dst.length; i++) {
            final int idx = i;

        int offset = 64; // Start at offset to test proper indexing

        int written = request.writeBytesWireFormat(buffer, offset);

        // Verify bytes written
        assertEquals(24, written);

        // Verify structure size (should be 24)
        assertEquals(24, SMBUtil.readInt2(buffer, offset));

        // Verify Reserved1 (2 bytes at offset+2, should be 0)

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

        // Set header start position for the response
        setHeaderStart(response, 64);

        // Write structure header (9 bytes)
        SMBUtil.writeInt2(9, buffer, offset); // Structure size
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2); // Buffer offset (relative to header)
        SMBUtil.writeInt4(50, buffer, offset + 4); // Total length of notification data

    public int encode(byte[] buffer, int offset) {
        int start = offset;

        // Write context header
        SMBUtil.writeInt4(0, buffer, offset); // Next (offset to next context, 0 for last)
        offset += 4;

        SMBUtil.writeInt2(16, buffer, offset); // NameOffset (from start of context)
        offset += 2;

        SMBUtil.writeInt2(4, buffer, offset); // NameLength
        offset += 2;

    return new SubList(fromIndex, toIndex - fromIndex);
  }

  private final class SubList extends ImmutableList<E> {
    final transient int offset;
    final transient int length;

    SubList(int offset, int length) {
      this.offset = offset;
      this.length = length;
    }

    @Override
    public int size() {
      return length;
    }

    @Override