return
}

// Offset specify the number of records to skip before starting to return the records
//
// Offset conditions can be cancelled by using `Offset(-1)`.
//
//	// select the third user
//	db.Offset(2).First(&user)
//	// select the first user by cancelling an earlier chained offset
//	db.Offset(5).Offset(-1).First(&user)
func (db *DB) Offset(offset int) (tx *DB) {
	tx = db.getInstance()

       * to start looking for a separator.
       */
      int nextStart = offset;
      while (offset != -1) {
        int start = nextStart;
        int end;

        int separatorPosition = separatorStart(offset);
        if (separatorPosition == -1) {
          end = toSplit.length();
          offset = -1;
        } else {

									offset++
									continue
								}
								for shardIdx, ok := range shardConfig {
									if ok != 0 {
										shards[shardIdx] = append(shards[shardIdx], splitData[shardIdx][offset])
									}
								}
								offset++
							}
							if offset > startOffset && reconstructAbleConfig {
								reconPartial(shards, k, parityOK, splitData, startOffset, offset, rs, shardConfig, splitFilled)

        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved (4 bytes at offset+4, should be 0)
        assertEquals(0, SMBUtil.readInt4(buffer, offset + 4));

        // Verify file ID is copied correctly (16 bytes starting at offset+8)
        byte[] copiedFileId = new byte[16];
        System.arraycopy(buffer, offset + 8, copiedFileId, 0, 16);
        assertArrayEquals(testFileId, copiedFileId);
    }

   * @param offset the first argument to {@link ByteSource#slice}
   * @param length the second argument to {@link ByteSource#slice}
   * @param expectRead the number of bytes we expect to read
   */
  private static void assertCorrectSlice(int input, int offset, long length, int expectRead)
      throws IOException {
    checkArgument(expectRead == (int) max(0, min(input, offset + length) - offset));

        assertEquals(9, SMBUtil.readInt2(buffer, offset));

        // Verify tree flags (0)
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify path length
        assertEquals(pathBytes.length, SMBUtil.readInt2(buffer, offset + 6));

        // Verify path content
        byte[] actualPath = new byte[pathBytes.length];
        System.arraycopy(buffer, offset + 8, actualPath, 0, pathBytes.length);

			obj.Close()
		}
	}()

	_, err = obj.Seek(offset, io.SeekStart)
	if err != nil {
		return 0, nil, err
	}

	info, err := obj.Stat()
	if err != nil {
		return 0, nil, err
	}
	n = info.Size - offset
	return n, obj, nil
}

// PutFile implements ftpDriver
func (driver *ftpDriver) PutFile(ctx *ftp.Context, objPath string, data io.Reader, offset int64) (n int64, err error) {

        byte[] buffer = new byte[2048];
        int bytesWritten = request.writeBytesWireFormat(buffer, 0);

        assertTrue(bytesWritten > 0);

        // Verify name length field at offset 46 (after 44 bytes of fixed fields + 2 for name offset)
        byte[] nameBytes = longPath.getBytes(StandardCharsets.UTF_16LE);
        int nameLenInBuffer = (buffer[46] & 0xFF) | ((buffer[47] & 0xFF) << 8);

        // Execute the method with offset
        int bytesWritten = transaction.writeParameterWordsWireFormat(dst, startOffset);

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // Verify data is written at correct offset
        assertEquals(3, dst[startOffset]);

        // Verify total parameter count at correct offset

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

        // Set structure size to 9 (valid)
        SMBUtil.writeInt2(9, buffer, bufferIndex);
        // Set buffer offset (relative to header start)
        SMBUtil.writeInt2(80, buffer, bufferIndex + 2);
        // Set buffer length (empty directory)
        SMBUtil.writeInt4(0, buffer, bufferIndex + 4);

        // Mock getHeaderStart