@Override
    public void encode(byte[] buffer, int offset) {
        // Context header
        int nameLen = getName().length();
        writeInt4(buffer, offset, 16);  // Next
        writeInt2(buffer, offset + 4, nameLen);  // NameOffset
        writeInt2(buffer, offset + 6, nameLen);  // NameLength
        writeInt2(buffer, offset + 8, 0);  // Reserved
        writeInt2(buffer, offset + 10, STRUCTURE_SIZE);  // DataOffset

    }

    @Test
    @DisplayName("readParameterWordsWireFormat with offset beyond buffer - throws exception")
    void testReadParameterWordsWithOffsetBeyondBuffer() {
        byte[] buffer = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04 };
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readParameterWordsWireFormat(buffer, 2) // Only 3 bytes available from offset 2
        );
    }

    @Test

        buffer[offset + 24] = 0x12;
        buffer[offset + 25] = 0x34;
        buffer[offset + 26] = 0x56;
        buffer[offset + 27] = 0x78;

        // Decode
        int bytesConsumed = response.decode(buffer, offset, 28);

        // Verify
        assertEquals(28, bytesConsumed, "Should consume exactly 28 bytes");

        byte[] resumeKey = response.getResumeKey();

        assertArrayEquals(testKey.getKey(), encodedKey);

        // Verify lease state at offset 40 (24 + 16 for key)
        assertEquals(testState, SMBUtil.readInt4(buffer, 40));

        // Verify lease flags at offset 44 (40 + 4 for state)
        assertEquals(0, SMBUtil.readInt4(buffer, 44));

        // Verify lease duration at offset 48 (44 + 4 for flags) - should be 0 (reserved)
        assertEquals(0, SMBUtil.readInt8(buffer, 48));

     *    @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;

	// Check offset overflow. Must fit in int32.
	MOVQ 2147483647+1(AX), AX       // ERROR "offset too large"
	MOVQ 3395469782(R10), R8        // ERROR "offset too large"
	LEAQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDL 3395469782(AX), AX         // ERROR "offset too large"

        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.

    session.commit()
    session.refresh(hero)
    return hero


@app.get("/heroes/")
def read_heroes(
    session: SessionDep,
    offset: int = 0,
    limit: Annotated[int, Query(le=100)] = 100,
) -> list[Hero]:
    heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()
    return heroes


@app.get("/heroes/{hero_id}")
def read_hero(hero_id: int, session: SessionDep) -> Hero:

        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
     */