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

        if (offset >= mappingItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<CharMappingItem> emptyList(), offset, size, mappingItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > mappingItemList.size()) {
            toIndex = mappingItemList.size();
        }

        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);

    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        if (offset < 0 || length < 0 || offset + length > data.length) {
            throw new CIFSException("Invalid offset or length");
        }
        if (!isAlgorithmSupported(algorithm)) {

    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;

        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) {

            SMBUtil.writeInt4(0, buffer, offset + 4); // sin6_flowinfo
            System.arraycopy(address.getAddress(), 0, buffer, offset + 8, 16); // sin6_addr
            SMBUtil.writeInt4(0, buffer, offset + 24); // sin6_scope_id
        } else {
            // IPv4 sockaddr_in structure (Windows AF_INET = 2)
            SMBUtil.writeInt2(2, buffer, offset); // sa_family: AF_INET