var newOffset int64
	switch whence {
	case io.SeekStart:
		newOffset = offset
	case io.SeekCurrent:
		newOffset = r.offset + offset
	case io.SeekEnd:
		newOffset = r.size + offset
	default:
		return 0, os.ErrInvalid
	}

	switch {
	case newOffset == r.offset:
		return newOffset, nil

	case newOffset < 0, newOffset > r.size:
		return 0, os.ErrInvalid

//sys	utimes(path string, times *[2]Timeval) (err error)

func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
	_, _, e1 := Syscall6(SYS_FADVISE64_64, uintptr(fd), uintptr(advice), uintptr(offset>>32), uintptr(offset), uintptr(length>>32), uintptr(length))
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
	var newoffset int64

	if offset < 0 || offset >= r.max {
		return false, fmt.Errorf("offset %d out of range [0,%d]", offset, r.max)
	}
	if r.allocated.Bit(offset) == 1 {
		return false, nil
	}
	r.allocated = r.allocated.SetBit(r.allocated, offset, 1)
	r.count++
	return true, nil
}

// AllocateNext reserves one of the items from the pool.
// (0, false, nil) may be returned if there are no items left.

	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.

        private int startPosition;

        private int pageSize;

        private int offset;

        TestSearchRequestParams(int startPosition, int pageSize, int offset) {
            this.startPosition = startPosition;
            this.pageSize = pageSize;
            this.offset = offset;
        }

        @Override
        public String getQuery() {
            return null;
        }

		return 0, &fs.PathError{Op: "read", Path: f.f.name, Err: fs.ErrInvalid}
	}
	n := copy(b, f.f.data[f.offset:])
	f.offset += int64(n)
	return n, nil
}

func (f *openFile) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case 0:
		// offset += 0
	case 1:
		offset += f.offset
	case 2:
		offset += int64(len(f.f.data))
	}
	if offset < 0 || offset > int64(len(f.f.data)) {

	// Block 0x38, offset 0xe00
	0xe00: 0x000a,
	// Block 0x39, offset 0xe40
	0xe40: 0x0009,
	0xe5b: 0x007a, 0xe5c: 0x006a,
	// Block 0x3a, offset 0xe80
	0xe92: 0x000c, 0xe93: 0x000c, 0xe94: 0x000c,
	0xeb2: 0x000c, 0xeb3: 0x000c, 0xeb4: 0x000c,
	// Block 0x3b, offset 0xec0
	0xed2: 0x000c, 0xed3: 0x000c,
	0xef2: 0x000c, 0xef3: 0x000c,
	// Block 0x3c, offset 0xf00
	0xf34: 0x000c, 0xf35: 0x000c,

	nn := len(p)
	if h.offset > 0 {
		n := copy(h.buffer[h.offset:], p)
		if h.offset+n < TagSize {
			h.offset += n
			return nn, nil
		}
		p = p[n:]
		h.offset = 0
		update(&h.macState, h.buffer[:])
	}
	if n := len(p) - (len(p) % TagSize); n > 0 {
		update(&h.macState, p[:n])
		p = p[n:]
	}
	if len(p) > 0 {
		h.offset += copy(h.buffer[h.offset:], p)
	}
	return nn, nil
}

	// Block 0x90, offset 0x39f
	{value: 0x0010, lo: 0x80, hi: 0xb1},
	{value: 0x0004, lo: 0xb2, hi: 0xbf},
	// Block 0x91, offset 0x3a1
	{value: 0x0004, lo: 0x80, hi: 0x82},
	{value: 0x0010, lo: 0x93, hi: 0xbf},
	// Block 0x92, offset 0x3a3
	{value: 0x0010, lo: 0x80, hi: 0xbd},
	// Block 0x93, offset 0x3a4
	{value: 0x0010, lo: 0x90, hi: 0xbf},
	// Block 0x94, offset 0x3a5
	{value: 0x0010, lo: 0x80, hi: 0x8f},

	// Block 0x90, offset 0x393
	{value: 0x0010, lo: 0x80, hi: 0xb1},
	{value: 0x0004, lo: 0xb2, hi: 0xbf},
	// Block 0x91, offset 0x395
	{value: 0x0004, lo: 0x80, hi: 0x81},
	{value: 0x0010, lo: 0x93, hi: 0xbf},
	// Block 0x92, offset 0x397
	{value: 0x0010, lo: 0x80, hi: 0xbd},
	// Block 0x93, offset 0x398
	{value: 0x0010, lo: 0x90, hi: 0xbf},
	// Block 0x94, offset 0x399
	{value: 0x0010, lo: 0x80, hi: 0x8f},