* @param str string to measure
     * @param offset current buffer offset for alignment calculation
     * @return string length
     */
    public int stringWireLength(final String str, final int offset) {
        int len = str.length() + 1;
        if (this.useUnicode) {
            len = str.length() * 2 + 2;
            len = offset % 2 != 0 ? len + 1 : len;
        }
        return len;
    }

			if s.entry(i).offset()[0] == 0x00 {
				break // Don't return, need to process extended headers (even if empty)
			}
			offset := p.parseNumeric(s.entry(i).offset())
			length := p.parseNumeric(s.entry(i).length())
			if p.err != nil {
				return nil, p.err
			}
			spd = append(spd, sparseEntry{Offset: offset, Length: length})
		}

		if s.isExtended()[0] > 0 {

from typing import Annotated, Literal

from fastapi import FastAPI, Query
from pydantic import BaseModel, Field

app = FastAPI()


class FilterParams(BaseModel):
    limit: int = Field(100, gt=0, le=100)
    offset: int = Field(0, ge=0)
    order_by: Literal["created_at", "updated_at"] = "created_at"
    tags: list[str] = []


@app.get("/items/")
async def read_items(filter_query: Annotated[FilterParams, Query()]):

        @Test
        @DisplayName("Should decode with non-zero buffer offset")
        void testDecodeWithOffset() {
            byte[] testBuffer = new byte[20];
            int offset = 5;
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

            // Add padding before actual data
            bb.position(offset);
            bb.putShort((short) 24); // pathConsumed

     * @param token the input token bytes
     * @param offset offset into the token array
     * @param len length of token data
     * @return the output token bytes
     * @throws SmbException if an error occurs during context initialization
     */
    public byte[] initSecContext(byte[] token, final int offset, final int len) throws SmbException {
        switch (state) {
        case 1:

        return this.action;
    }

    @Override
    public String getFileName() {
        return this.fileName;
    }

    /**
     * Gets the offset to the next entry.
     *
     * @return the next entry offset in bytes
     */
    public int getNextEntryOffset() {
        return this.nextEntryOffset;
    }

    /**
     * Constructs a file notify information from the given buffer.

    /// Squash bytes down to ints.
    /**
     * Converts bytes to integers for internal DES processing
     * @param inBytes the input byte array
     * @param inOff the offset into the input array
     * @param outInts the output integer array
     * @param outOff the offset into the output array
     * @param intLen the number of integers to convert
     */

        assertEquals(0, used, "readBytesWireFormat is unimplemented and must return 0");
    }

    private static byte[] subArray(byte[] src, int offset, int length) {
        byte[] dst = new byte[length];
        System.arraycopy(src, offset, dst, 0, length);
        return dst;
    }

        data[18] = 0;
        data[19] = 0; // remark offset

        // Entry 2: IPC$, type 3 (IPC), remark "Inter-Process Communication"
        System.arraycopy("IPC$".getBytes(StandardCharsets.US_ASCII), 0, data, 20, 4);
        data[34] = 0x03;
        data[35] = 0x00; // type = 3
        data[36] = 60;
        data[37] = 0;
        data[38] = 0;
        data[39] = 0; // remark offset

        // Remarks data

    void testReadParametersWireFormatWithBufferOffset() throws Exception {
        int offset = 20;
        byte[] notificationData = createSingleNotificationBuffer("offset_test.txt", FileNotifyInformation.FILE_ACTION_MODIFIED);
        byte[] buffer = new byte[offset + notificationData.length];
        System.arraycopy(notificationData, 0, buffer, offset, notificationData.length);