// Copyright 2023 @Author:LiuBin(LineOfSight) 1440383523@qq.com. All rights reserved.
// Licensed under the MulanPSL-2.0 License.

package resob

import (
	"encoding/binary"
	"math"
	"os"
	"strings"
	"sync/atomic"
)

func (c *BsTr) bskeyEntryLastLeaf(spr *SpireReturn, f *os.File) *BsTr {
	if c == nil || !c.isEntry() {
		return nil
	}
	flag := spr.flag
	if flag&UNIQUE != UNIQUE {
		for ; c.isNode(); _, c, _ = c.bskeyGetChildIAndKeyI(spr, c.bsks[len(c.bsks)-1], c.tms[len(c.tms)-1], len(c.chunk)-1, f) {
		}
	} else {
		for ; c.isNode(); _, c, _ = c.bskeyGetChildIAndKeyI(spr, c.bsks[len(c.bsks)-1], 0, len(c.chunk)-1, f) {
		}
	}
	return c
}
func (c *BsTr) bskeyEntryFirstLeaf(spr *SpireReturn, f *os.File) *BsTr {
	if c == nil || !c.isEntry() {
		return nil
	}
	flag := spr.flag
	if flag&UNIQUE != UNIQUE {
		for ; c.isNode(); _, c, _ = c.bskeyGetChildIAndKeyI(spr, c.bsks[0], c.tms[0], CHUNKINDEXIGNORE, f) {
		}
	} else {
		for ; c.isNode(); _, c, _ = c.bskeyGetChildIAndKeyI(spr, c.bsks[0], 0, CHUNKINDEXIGNORE, f) {
		}
	}
	return c
}
func (cs *BsTr) bskeySe(tn string, key []byte, f *os.File) ([]bool, []int64, [][]byte, uint32) {
	if !cs.isSpire() {
		return nil, nil, nil, 0
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil, nil, nil, 0
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(tn)
	}
	if spr == nil || spr.c == nil {
		return nil, nil, nil, 0
	}
	chunki := spr.c
	flag := spr.flag
	var chunko *BsTr
	var ki, kicount int
	var found bool
	var bss [][]byte
	var tms []int64
	var bools []bool
	//search entry
	bcwp := new(keyCsWrParams)
	for {
		if len(chunki.bs) == 0 {
			break
		}
		chunko = chunki
		if !found {
			ki = GEKeySearch(chunki.bsks, key)
			if ki == len(chunki.offs)-CHUNKINDEXIGNORE {
				//entry
				chunki = chunko.chunk[RIGHT]
				if chunki == nil {
					return nil, nil, nil, flag
				}
			} else {
				//entry child
				if chunko.isNode() {
					bcwp.f = f
					bcwp.cs = chunko
					bcwp.ci = ki + CHUNKINDEXIGNORE
					bcwp.spr = spr
					bcwp.wr = I
					__global_bskeyCsWr_chan__ <- bcwp
					chunki = <-__global_bskeyCsWr_LRIre_chan__
					if chunki == nil {
						return nil, nil, nil, flag
					}
				} else {
					found = true
					break
				}
			}
		}
	}
	if found {
		for {
			if !chunki.bools[ki+kicount] {
				tms = append(tms, chunki.tms[ki+kicount])
				bools = append(bools, chunki.bools[ki+kicount])
				bss = chunki.GetBs(flag, ki+kicount, bss, f)
			}
			if flag&UNIQUE != UNIQUE {
				kicount++
				if ki+kicount == len(chunki.offs)-CHUNKINDEXIGNORE {
					//bcwp := new(keyCsWrParams)
					bcwp.f = f
					bcwp.wr = R
					bcwp.cs = chunki
					bcwp.spr = spr
					bcwp.pa = chunki.chunk[PARENT]
					__global_bskeyCsWr_chan__ <- bcwp
					chunki = <-__global_bskeyCsWr_LRIre_chan__
					if chunki == nil {
						break
					}
					kicount = 0
					ki = 0
				}
				if ki+kicount < len(chunki.offs)-CHUNKINDEXIGNORE && KeyCmp(chunki.bsks[ki+kicount], key) != 0 {
					break
				}
			} else {
				break
			}
		}
	}
	return bools, tms, bss, flag
}
func bskeyscGoFunc(key []byte, spr *SpireReturn, fl, ll *BsTr, f *os.File, resc chan tmsBss) {
	var tb tmsBss
	if fl == nil || ll == nil {
		resc <- tb
		return
	}
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	flag := spr.flag
	rb0 := int(-2)
	bcwp := new(keyCsWrParams)
	bcwp.f = f
	bcwp.wr = R
	bcwp.cs = ll
	bcwp.spr = spr
	bcwp.pa = ll.chunk[PARENT]
	__global_bskeyCsWr_chan__ <- bcwp
	llr := <-__global_bskeyCsWr_LRIre_chan__
	for fl != llr {
		for i := 0; i < len(fl.offs)-CHUNKINDEXIGNORE; i++ {
			rb0 = KeyContain(fl.bsks[i], key)
			if rb0 >= 0 && !fl.bools[i] {
				keys = append(keys, fl.bsks[i])
				tms = append(tms, fl.tms[i])
				bools = append(bools, fl.bools[i])
				bss = fl.GetBs(flag, i, bss, f)
			}
		}
		bcwp = new(keyCsWrParams)
		bcwp.f = f
		bcwp.wr = R
		bcwp.spr = spr
		bcwp.cs = fl
		bcwp.pa = fl.chunk[PARENT]
		__global_bskeyCsWr_chan__ <- bcwp
		fl = <-__global_bskeyCsWr_LRIre_chan__
	}
	tb.keys = keys
	tb.tms = tms
	tb.bools = bools
	tb.bss = bss
	resc <- tb
	close(resc)
}

// return sorted results
func (cs *BsTr) bskeySc(tn string, key []byte, f *os.File) ([]any, []bool, []int64, [][]byte, uint32) {
	if !cs.isSpire() {
		return nil, nil, nil, nil, 0
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil, nil, nil, nil, 0
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(tn)
	}
	if spr == nil {
		return nil, nil, nil, nil, 0
	}
	entry := spr.c
	if entry == nil {
		return nil, nil, nil, nil, 0
	}
	flag := spr.flag
	if flag&BSKEY != BSKEY {
		return nil, nil, nil, nil, flag
	}
	var fl, ll *BsTr
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	var rescs []chan tmsBss
	for i := 0; entry != nil; entry = entry.chunk[RIGHT] {
		fl = entry.bskeyEntryFirstLeaf(spr, f)
		ll = entry.bskeyEntryLastLeaf(spr, f)
		resc := make(chan tmsBss)
		rescs = append(rescs, resc)
		go bskeyscGoFunc(key, spr, fl, ll, f, resc)
		i++
	}
	for i := 0; i < len(rescs); i++ {
		tb, ok := <-rescs[i]
		if ok {
			keys = append(keys, tb.keys...)
			tms = append(tms, tb.tms...)
			bss = append(bss, tb.bss...)
			bools = append(bools, tb.bools...)
		}
	}
	return keys, bools, tms, bss, flag
}

// the global variant for bskeySc1
var __global_bskeySc1_get1_counter int64

func (cs *BsTr) bskeySc1(tn string, key []byte, f *os.File) (*BsTr, int, []any, []bool, []int64, [][]byte, uint32) {
	if !cs.isSpire() {
		return nil, -1, nil, nil, nil, nil, 0
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil, -1, nil, nil, nil, nil, 0
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(tn)
	}
	if spr == nil || spr.c == nil {
		return nil, -1, nil, nil, nil, nil, 0
	}
	chunki := spr.c
	flag := spr.flag
	var chunko *BsTr
	var ki, kicount int
	var found bool
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	kicount = int(atomic.LoadInt64(&__global_bskeySc1_get1_counter))
	//search entry
	bcwp := new(keyCsWrParams)
	for {
		chunki.wait4Writing()
		if len(chunki.bs) == 0 {
			break
		}
		chunko = chunki
		if !found {
			ki = GCKeySearch(chunki.bs, key)
			if ki == len(chunki.offs)-CHUNKINDEXIGNORE {
				//entry
				chunki = chunko.chunk[RIGHT]
				if chunki == nil {
					return nil, -1, nil, nil, nil, nil, flag
				}
			} else {
				//entry child
				if chunko.isNode() {
					bcwp.f = f
					bcwp.cs = chunko
					bcwp.ci = ki + CHUNKINDEXIGNORE
					bcwp.spr = spr
					bcwp.wr = I
					__global_bskeyCsWr_chan__ <- bcwp
					chunki = <-__global_bskeyCsWr_LRIre_chan__
					if chunki == nil {
						return nil, -1, nil, nil, nil, nil, flag
					}
				} else {
					found = true
					break
				}
			}
		}
	}
	if found {
		for {
			chunki.wait4Writing()
			if len(keys) > 0 {
				atomic.AddInt64(&__global_bskeySc1_get1_counter, 1)
				return chunki, ki + kicount, keys, bools, tms, bss, flag
			}
			if int64(kicount) < __global_bskeySc1_get1_counter {
				kicount++
				continue
			}
			if ki+kicount == len(chunki.offs)-CHUNKINDEXIGNORE {
				//bcwp := new(keyCsWrParams)
				bcwp.f = f
				bcwp.wr = R
				bcwp.cs = chunki
				bcwp.spr = spr
				bcwp.pa = chunki.chunk[PARENT]
				__global_bskeyCsWr_chan__ <- bcwp
				chunki = <-__global_bskeyCsWr_LRIre_chan__
				if chunki == nil {
					return nil, -1, nil, nil, nil, nil, flag
				}
				kicount = 0
				ki = 0
				atomic.StoreInt64(&__global_bskeySc1_get1_counter, 0)
			}
			if !chunki.bools[ki+kicount] {
				keys = append(keys, chunki.bsks[ki+kicount])
				tms = append(tms, chunki.tms[ki+kicount])
				bools = append(bools, chunki.bools[ki+kicount])
				bss = chunki.GetBs(flag, ki+kicount, bss, f)
			} else {
				kicount++
			}
		}
	}
	return nil, -1, nil, nil, nil, nil, flag
}
func bskeyspGoFunc(key []byte, spr *SpireReturn, fl, ll *BsTr, f *os.File, resc chan tmsBss) {
	var tb tmsBss
	if fl == nil || ll == nil {
		resc <- tb
		return
	}
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	flag := spr.flag
	rb0 := int(-2)
	bcwp := new(keyCsWrParams)
	bcwp.f = f
	bcwp.wr = R
	bcwp.spr = spr
	bcwp.cs = ll
	bcwp.pa = ll.chunk[PARENT]
	__global_bskeyCsWr_chan__ <- bcwp
	llr := <-__global_bskeyCsWr_LRIre_chan__
	for fl != llr {
		for i := 0; i < len(fl.offs)-CHUNKINDEXIGNORE; i++ {
			rb0 = KeyPrefix(fl, fl.bsks[i], key)
			if rb0 > 0 && !fl.bools[i] {
				keys = append(keys, fl.bsks[i])
				tms = append(tms, fl.tms[i])
				bools = append(bools, fl.bools[i])
				bss = fl.GetBs(flag, i, bss, f)
			}
		}
		bcwp = new(keyCsWrParams)
		bcwp.f = f
		bcwp.wr = R
		bcwp.cs = fl
		bcwp.spr = spr
		bcwp.pa = fl.chunk[PARENT]
		__global_bskeyCsWr_chan__ <- bcwp
		fl = <-__global_bskeyCsWr_LRIre_chan__
	}
	tb.keys = keys
	tb.tms = tms
	tb.bss = bss
	tb.bools = bools
	resc <- tb
	close(resc)
}
func (cs *BsTr) bskeySp(tn string, key []byte, f *os.File) ([]any, []bool, []int64, [][]byte, uint32) {
	if !cs.isSpire() {
		return nil, nil, nil, nil, 0
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil, nil, nil, nil, 0
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(tn)
	}
	if spr == nil {
		return nil, nil, nil, nil, 0
	}
	entry := spr.c
	if entry == nil {
		return nil, nil, nil, nil, 0
	}
	flag := spr.flag
	if flag&BSKEY != BSKEY {
		return nil, nil, nil, nil, flag
	}
	var fl, ll *BsTr
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	var rescs []chan tmsBss
	for i := 0; entry != nil; entry = entry.chunk[RIGHT] {
		fl = entry.bskeyEntryFirstLeaf(spr, f)
		ll = entry.bskeyEntryLastLeaf(spr, f)
		resc := make(chan tmsBss)
		rescs = append(rescs, resc)
		go bskeyspGoFunc(key, spr, fl, ll, f, resc)
		i++
	}
	for i := 0; i < len(rescs); i++ {
		tb, ok := <-rescs[i]
		if ok {
			keys = append(keys, tb.keys...)
			tms = append(tms, tb.tms...)
			bss = append(bss, tb.bss...)
			bools = append(bools, tb.bools...)
		}
	}
	return keys, bools, tms, bss, flag
}
func bskeyssGoFunc(key any, spr *SpireReturn, fl, ll *BsTr, f *os.File, resc chan tmsBss) {
	var tb tmsBss
	if fl == nil || ll == nil {
		resc <- tb
		return
	}
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	flag := spr.flag
	rb0 := int(-2)
	bcwp := new(keyCsWrParams)
	bcwp.f = f
	bcwp.wr = R
	bcwp.cs = ll
	bcwp.spr = spr
	bcwp.pa = ll.chunk[PARENT]
	__global_bskeyCsWr_chan__ <- bcwp
	llr := <-__global_bskeyCsWr_LRIre_chan__
	for fl != llr {
		for i := 0; i < len(fl.offs)-CHUNKINDEXIGNORE; i++ {
			rb0 = KeySuffix(fl, fl.bsks[i], key)
			if rb0 > 0 && !fl.bools[i] {
				keys = append(keys, fl.bsks[i])
				tms = append(tms, fl.tms[i])
				bools = append(bools, fl.bools[i])
				bss = fl.GetBs(flag, i, bss, f)
			}
		}
		bcwp = new(keyCsWrParams)
		bcwp.f = f
		bcwp.wr = R
		bcwp.cs = fl
		bcwp.spr = spr
		bcwp.pa = fl.chunk[PARENT]
		__global_bskeyCsWr_chan__ <- bcwp
		fl = <-__global_bskeyCsWr_LRIre_chan__
	}
	tb.keys = keys
	tb.tms = tms
	tb.bss = bss
	tb.bools = bools
	resc <- tb
	close(resc)
}
func (cs *BsTr) bskeySs(tn string, key []byte, f *os.File) ([]any, []bool, []int64, [][]byte, uint32) {
	if !cs.isSpire() {
		return nil, nil, nil, nil, 0
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil, nil, nil, nil, 0
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(tn)
	}
	if spr == nil {
		return nil, nil, nil, nil, 0
	}
	entry := spr.c
	if entry == nil {
		return nil, nil, nil, nil, 0
	}
	flag := spr.flag
	if flag&BSKEY != BSKEY {
		return nil, nil, nil, nil, flag
	}
	var fl, ll *BsTr
	var keys []any
	var bss [][]byte
	var tms []int64
	var bools []bool
	var rescs []chan tmsBss
	for i := 0; entry != nil; entry = entry.chunk[RIGHT] {
		fl = entry.bskeyEntryFirstLeaf(spr, f)
		ll = entry.bskeyEntryLastLeaf(spr, f)
		resc := make(chan tmsBss)
		rescs = append(rescs, resc)
		go bskeyssGoFunc(key, spr, fl, ll, f, resc)
		i++
	}
	for i := 0; i < len(rescs); i++ {
		tb, ok := <-rescs[i]
		if ok {
			keys = append(keys, tb.keys...)
			tms = append(tms, tb.tms...)
			bss = append(bss, tb.bss...)
			bools = append(bools, tb.bools...)
		}
	}
	return keys, bools, tms, bss, flag
}

func bskeySLGeSomeStart(fps *FindParams, f *os.File) *FindParams {
	cs := fps.spire
	if !cs.isSpire() {
		return nil
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, fps.tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(fps.tn)
	}
	if spr == nil || spr.c == nil {
		return nil
	}
	chunki := spr.c
	var chunko *BsTr
	var ki int
	var found0, found1 bool
	bcwp := new(keyCsWrParams)
	bcwp.f = fps.f
	bcwp.spr = spr
	bcwp.wr = I
	key0, k0ok := fps.key0.([]byte)
	if !k0ok {
		return nil
	}
	key1, k1ok := fps.key1.([]byte)
	if !k1ok {
		return nil
	}
	if fps.findType != FindLE|FindNE && fps.findType != FindLE|FindLike && fps.findType != FindL|FindNE && fps.findType != FindL|FindLike {
		//search entry
		for {
			chunki.wait4Writing()
			if len(chunki.bsks) == 0 {
				return nil
			}
			chunko = chunki
			if !found0 {
				ki = GEKeySearch(chunki.bsks, key0)
				if ki == len(chunki.offs)-CHUNKINDEXIGNORE {
					//entry
					chunki = chunko.chunk[RIGHT]
					if chunki == nil {
						return nil
					}
				} else {
					//entry child
					if chunko.isNode() {
						bcwp.cs = chunko
						bcwp.ci = ki + CHUNKINDEXIGNORE
						__global_bskeyCsWr_chan__ <- bcwp
						chunki = <-__global_bskeyCsWr_LRIre_chan__
						if chunki == nil {
							return nil
						}
					} else {
						found0 = true
						break
					}
				}
			}
		}
		if found0 {
			fps.startbstr = chunki
			fps.startki = ki
			fps.curbstr = chunki
			fps.curki = ki
		} else {
			return nil
		}
	} else {
		fps.startbstr = spr.c.bskeyEntryFirstLeaf(spr, fps.f)
		fps.startki = 0
		fps.curbstr = fps.startbstr
		fps.curki = 0
	}
	chunki = spr.c
	if fps.findType != FindGE|FindNE && fps.findType != FindGE|FindLike && fps.findType != FindG|FindNE && fps.findType != FindG|FindLike {
		for {
			chunki.wait4Writing()
			if len(chunki.bsks) == 0 {
				break
			}
			chunko = chunki
			if !found1 {
				ki = GEKeySearch(chunki.bsks, key1)
				if ki == len(chunki.bsks) {
					//entry
					chunki = chunko.chunk[RIGHT]
					if chunki == nil {
						break
					}
				} else {
					//entry child
					if chunko.isNode() {
						bcwp.cs = chunko
						bcwp.ci = ki + CHUNKINDEXIGNORE
						__global_bskeyCsWr_chan__ <- bcwp
						chunki = <-__global_bskeyCsWr_LRIre_chan__
						if chunki == nil {
							return nil
						}
					} else {
						found1 = true
						break
					}
				}
			}
		}
		if found1 {
			fps.endbstr = chunki
			fps.endki = ki
		} else {
			fps.endbstr = bskeyLastLeaf(cs, spr, fps.f)
			fps.endki = len(fps.endbstr.bsks) - 1
		}
	} else {
		fps.endbstr = bskeyLastLeaf(cs, spr, fps.f)
		fps.endki = len(fps.endbstr.bsks) - 1
	}
	fps.spire = cs
	fps.spr = spr
	chunki = fps.startbstr
	ki = fps.startki
	kicount := 0
	pagehas := 0
	pageNO := 0
	bcwp.wr = R
__break__:
	for {
		if pagehas == fps.page_should_has {
			pagehas = 0
			pageNO++
		}
		if pagehas == 0 {
			if ki+kicount == len(chunki.bsks) {
				if chunki == fps.endbstr {
					break
				}
				bcwp.cs = chunki
				bcwp.pa = chunki.chunk[PARENT]
				__global_bskeyCsWr_chan__ <- bcwp
				chunki = <-__global_bskeyCsWr_LRIre_chan__
				if chunki == nil {
					break
				}
				kicount = 0
				ki = 0
			}
			pagestart := new(PageStartBsTrKi)
			pagestart.start = chunki
			pagestart.ki = ki + kicount
			fps.page_starts[pageNO] = pagestart
		}
		chunki.wait4Writing()
		if ki+kicount == len(chunki.bsks) {
			if chunki == fps.endbstr {
				break
			}
			bcwp.cs = chunki
			bcwp.pa = chunki.chunk[PARENT]
			__global_bskeyCsWr_chan__ <- bcwp
			chunki = <-__global_bskeyCsWr_LRIre_chan__
			if chunki == nil {
				break
			}
			kicount = 0
			ki = 0
		}
		switch fps.findType {
		//'>=,<='
		case FindGE | FindLE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
					break __break__
				}
				pagehas++
			}
			//'>,<='
		case FindG | FindLE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
					break __break__
				}
				pagehas++
			}
			//'>,<'
		case FindG | FindL:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
					break __break__
				}
				pagehas++
			}
			//'>=,<'
		case FindGE | FindL:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
					break __break__
				}
				pagehas++
			}
		case FindGE | FindNE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) == 0 {
					kicount++
					continue
				}
				pagehas++
			}
		case FindG | FindNE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) == 0 {
					kicount++
					continue
				}
				pagehas++
			}
		case FindGE | FindLike:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0 {
				if chunki == fps.endbstr && Like(chunki.bsks[ki+kicount], key1) < 0 {
					kicount++
					continue
				}
				pagehas++
			}
		case FindG | FindLike:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0 {
				if chunki == fps.endbstr && Like(chunki.bsks[ki+kicount], key1) < 0 {
					kicount++
					continue
				}
				pagehas++
			}
		case FindLike | FindLE:
			if !chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
					break __break__
				}
				pagehas++
			}
		case FindLike | FindL:
			if !chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
					break __break__
				}
				pagehas++
			}
		case FindNE | FindL:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
					break __break__
				}
				pagehas++
			}
		case FindNE | FindLE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0 {
				if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
					break __break__
				}
				pagehas++
			}
		}
		kicount++
	}
	fps.total = pageNO*fps.page_should_has + pagehas
	return fps
}

func bskeySLGeSome(fps *FindParams) (*FindParams, *BsTr) {
	var kicount, ki int
	var fr BsTr
	fr.InitWithNonids("", fps.tn, true)
	chunki := fps.page_starts[fps.wanted_pageNo].start
	ki = fps.page_starts[fps.wanted_pageNo].ki
	fps.curpage_has = 0
	bcwp := new(keyCsWrParams)
	bcwp.f = fps.f
	bcwp.wr = R
	bcwp.spr = fps.spr
	key0, k0ok := fps.key0.([]byte)
	if !k0ok {
		return nil, nil
	}
	key1, k1ok := fps.key1.([]byte)
	if !k1ok {
		return nil, nil
	}
__break__:
	for {
		//REVISE:add 202311062043
		chunki.wait4Writing()
		if len(chunki.bsks) == 0 {
			fps.curpage_has = -1
			break
		}
		if fps.curpage_has == fps.page_should_has {
			fps.curbstr = chunki
			fps.curki = ki + kicount
			break
		}
		if ki+kicount == len(chunki.bsks) {
			if chunki == fps.endbstr {
				break
			}
			bcwp.cs = chunki
			bcwp.pa = chunki.chunk[PARENT]
			__global_bskeyCsWr_chan__ <- bcwp
			chunki = <-__global_bskeyCsWr_LRIre_chan__
			if chunki == nil {
				fps.curki = ki + kicount - 1
				break
			}
			kicount = 0
			ki = 0
		}
		switch fps.findType {
		//'>=,<='
		case FindGE | FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
			//'>,<='
		case FindG | FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
			//'>,<'
		case FindG | FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
			//'>=,<'
		case FindGE | FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
		case FindGE | FindNE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) == 0 {
				kicount++
				continue
			}
		case FindG | FindNE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) == 0 {
				kicount++
				continue
			}
		case FindGE | FindLike:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && Like(chunki.bsks[ki+kicount], key1) < 0 {
				kicount++
				continue
			}
		case FindG | FindLike:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && Like(chunki.bsks[ki+kicount], key1) < 0 {
				kicount++
				continue
			}
		case FindLike | FindLE:
			if !(!chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
		case FindLike | FindL:
			if !(!chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
		case FindNE | FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
		case FindNE | FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
		}
		fps.curpage_has++
		fr.PutBsk(chunki.bsks[ki+kicount], "", "", "")
		fr.PutTm(chunki.tms[ki+kicount])
		fr.PutBool(chunki.bools[ki+kicount], "", "", "")
		var bss [][]byte
		bss = chunki.GetBs(fps.spr.flag, ki+kicount, bss, fps.f)
		fr.PutBytes(bss[0], "", "", "")
		kicount++
	}
	return fps, &fr
}

func bskeySLorGeSomeStart(fps *FindParams, f *os.File) *FindParams {
	cs := fps.spire
	if !cs.isSpire() {
		return nil
	}
	var spr *SpireReturn
	if cs.c4wr != nil {
		__global_spireParams_chan__ <- &spireParams{cs, 0, 0, 0, fps.tn, false, f}
		var ok bool
		spr, ok = <-__global_spireRe_chan
		if !ok {
			__global_sync_spire__ <- struct{}{}
			return nil
		}
		__global_sync_spire__ <- struct{}{}
	} else {
		spr = cs.spireRd(fps.tn)
	}
	if spr == nil || spr.c == nil {
		return nil
	}
	chunki := spr.c
	var chunko *BsTr
	var ki int
	var found0 bool
	bcwp := new(keyCsWrParams)
	bcwp.f = fps.f
	bcwp.spr = spr
	bcwp.wr = I
	key0, k0ok := fps.key0.([]byte)
	if !(fps.findType == FindAny || fps.findType == FindNull) && !k0ok {
		return nil
	} else if fps.findType == FindNull {
		key0 = []byte(nil)
	}
	if fps.findType != FindNE && fps.findType != FindLike && fps.findType != FindNull && fps.findType != FindAny {
		//search entry
		for {
			chunki.wait4Writing()
			if len(chunki.bsks) == 0 {
				return nil
			}
			chunko = chunki
			if !found0 {
				ki = GEKeySearch(chunki.bsks, key0)
				if ki == len(chunki.offs)-CHUNKINDEXIGNORE {
					//entry
					chunki = chunko.chunk[RIGHT]
					if chunki == nil {
						break
					}
				} else {
					//entry child
					if chunko.isNode() {
						bcwp.cs = chunko
						bcwp.ci = ki + CHUNKINDEXIGNORE
						__global_bskeyCsWr_chan__ <- bcwp
						chunki = <-__global_bskeyCsWr_LRIre_chan__
						if chunki == nil {
							return nil
						}
					} else {
						found0 = true
						break
					}
				}
			}
		}
		if found0 {
			switch fps.findType {
			case FindE, FindG, FindGE:
				fps.startbstr = chunki
				fps.startki = ki
				fps.endbstr = bskeyLastLeaf(cs, spr, fps.f)
				fps.endki = len(fps.endbstr.bsks) - 1
			case FindL, FindLE:
				fps.endbstr = chunki
				fps.endki = ki
				fps.startbstr = spr.c.bskeyEntryFirstLeaf(spr, fps.f)
				fps.startki = 0
			}
		} else {
			switch fps.findType {
			case FindL, FindLE:
				fps.startbstr = spr.c.bskeyEntryFirstLeaf(spr, fps.f)
				fps.startki = 0
				fps.endbstr = bskeyLastLeaf(cs, spr, fps.f)
				fps.endki = len(fps.endbstr.bsks) - 1
			default:
				return nil
			}
		}
	} else {
		fps.startbstr = spr.c.bskeyEntryFirstLeaf(spr, fps.f)
		fps.startki = 0
		fps.endbstr = bskeyLastLeaf(cs, spr, fps.f)
		fps.endki = len(fps.endbstr.bsks) - 1
	}
	fps.curbstr = fps.startbstr
	fps.curki = fps.startki
	fps.spire = cs
	fps.spr = spr
	chunki = fps.startbstr
	ki = fps.startki
	kicount := 0
	pagehas := 0
	pageNO := 0
	bcwp.wr = R
	for {
		if pagehas == fps.page_should_has {
			pagehas = 0
			pageNO++
		}
		if pagehas == 0 {
			if ki+kicount == len(chunki.bsks) {
				if chunki == fps.endbstr {
					break
				}
				bcwp.cs = chunki
				bcwp.pa = chunki.chunk[PARENT]
				__global_bskeyCsWr_chan__ <- bcwp
				chunki = <-__global_bskeyCsWr_LRIre_chan__
				if chunki == nil {
					break
				}
				kicount = 0
				ki = 0
			}
			pagestart := new(PageStartBsTrKi)
			pagestart.start = chunki
			pagestart.ki = ki + kicount
			fps.page_starts[pageNO] = pagestart
		}
		chunki.wait4Writing()
		if ki+kicount == len(chunki.bsks) {
			if chunki == fps.endbstr {
				break
			}
			bcwp.cs = chunki
			bcwp.pa = chunki.chunk[PARENT]
			__global_bskeyCsWr_chan__ <- bcwp
			chunki = <-__global_bskeyCsWr_LRIre_chan__
			if chunki == nil {
				break
			}
			kicount = 0
			ki = 0
		}
		switch fps.findType {
		case FindE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) == 0 {
				pagehas++
			}
		case FindGE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0 {
				pagehas++
			}
		case FindG:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0 {
				pagehas++
			}
		case FindL:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) < 0 {
				pagehas++
			}
		case FindLE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) <= 0 {
				pagehas++
			}
		case FindNE:
			if !chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0 {
				pagehas++
			}
		case FindLike:
			if !chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0 {
				pagehas++
			}
		case FindNull:
			if !chunki.bools[ki+kicount] && chunki.bsks[ki+kicount] == nil {
				pagehas++
			} else if chunki.bsks[ki+kicount] != nil {
				break
			}
		case FindAny:
			if !chunki.bools[ki+kicount] {
				pagehas++
			}
		}
		kicount++
	}
	fps.total = pageNO*fps.page_should_has + pagehas
	return fps
}

func bskeySLorGeSome(fps *FindParams) (*FindParams, *BsTr) {
	var kicount, ki int
	var fr BsTr
	fr.InitWithNonids("", fps.tn, true)
	chunki := fps.page_starts[fps.wanted_pageNo].start
	ki = fps.page_starts[fps.wanted_pageNo].ki
	fps.curpage_has = 0
	bcwp := new(keyCsWrParams)
	bcwp.f = fps.f
	bcwp.wr = R
	bcwp.spr = fps.spr
	key0, k0ok := fps.key0.([]byte)
	if !(fps.findType == FindAny || fps.findType == FindNull) && !k0ok {
		return nil, nil
	} else if fps.findType == FindNull {
		key0 = []byte(nil)
	}
__break__:
	for {
		chunki.wait4Writing()
		if len(chunki.bsks) == 0 {
			fps.curpage_has = -1
			break
		}
		if fps.curpage_has == fps.page_should_has {
			fps.curbstr = chunki
			fps.curki = ki + kicount
			break
		}
		if ki+kicount == len(chunki.bsks) {
			if chunki == fps.endbstr {
				break
			}
			bcwp.cs = chunki
			bcwp.pa = chunki.chunk[PARENT]
			__global_bskeyCsWr_chan__ <- bcwp
			chunki = <-__global_bskeyCsWr_LRIre_chan__
			if chunki == nil {
				fps.curki = ki + kicount - 1
				break
			}
			kicount = 0
			ki = 0
		}
		switch fps.findType {
		case FindE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) == 0) {
				break __break__
			}
		case FindGE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
		case FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) <= 0) {
				kicount++
				continue
			}
		case FindG:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
		case FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) < 0) {
				kicount++
				continue
			}
		case FindNE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0) {
				kicount++
				continue
			}
		case FindLike:
			if !(!chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
		case FindNull:
			if !(!chunki.bools[ki+kicount] && chunki.bsks[ki+kicount] == nil) {
				kicount++
				continue
			}
		case FindAny:
			if chunki.bools[ki+kicount] {
				kicount++
				continue
			}
		}
		fps.curpage_has++
		fr.PutBsk(chunki.bsks[ki+kicount], "", "", "")
		fr.PutTm(chunki.tms[ki+kicount])
		fr.PutBool(chunki.bools[ki+kicount], "", "", "")
		var bss [][]byte
		bss = chunki.GetBs(fps.spr.flag, ki+kicount, bss, fps.f)
		fr.PutBytes(bss[0], "", "", "")
		kicount++
	}
	return fps, &fr
}

func bskeySLGeSomeKeys(fps *FindParams) (*FindParams, []any) {
	var kicount, ki int
	var keys []any
	chunki := fps.page_starts[fps.wanted_pageNo].start
	ki = fps.page_starts[fps.wanted_pageNo].ki
	fps.curpage_has = 0
	bcwp := new(keyCsWrParams)
	bcwp.f = fps.f
	bcwp.wr = R
	bcwp.spr = fps.spr
	key0, k0ok := fps.key0.([]byte)
	if !k0ok {
		return nil, nil
	}
	key1, k1ok := fps.key1.([]byte)
	if !k1ok {
		return nil, nil
	}
__break__:
	for {
		chunki.wait4Writing()
		if len(chunki.bsks) == 0 {
			fps.curpage_has = -1
			break
		}
		if fps.curpage_has == fps.page_should_has {
			fps.curbstr = chunki
			fps.curki = ki + kicount
			break
		}
		if ki+kicount == len(chunki.bsks) {
			if chunki == fps.endbstr {
				break
			}
			bcwp.cs = chunki
			bcwp.pa = chunki.chunk[PARENT]
			__global_bskeyCsWr_chan__ <- bcwp
			chunki = <-__global_bskeyCsWr_LRIre_chan__
			if chunki == nil {
				fps.curki = ki + kicount - 1
				break
			}
			kicount = 0
			ki = 0
		}
		switch fps.findType {
		//'>=,<='
		case FindGE | FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
			//'>,<='
		case FindG | FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
			//'>,<'
		case FindG | FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
			//'>=,<'
		case FindGE | FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
		case FindGE | FindNE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) == 0 {
				kicount++
				continue
			}
		case FindG | FindNE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) == 0 {
				kicount++
				continue
			}
		case FindGE | FindLike:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && Like(chunki.bsks[ki+kicount], key1) < 0 {
				kicount++
				continue
			}
		case FindG | FindLike:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && Like(chunki.bsks[ki+kicount], key1) < 0 {
				kicount++
				continue
			}
		case FindLike | FindLE:
			if !(!chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
		case FindLike | FindL:
			if !(!chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
		case FindNE | FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) >= 0 {
				break __break__
			}
		case FindNE | FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0) {
				kicount++
				continue
			}
			if chunki == fps.endbstr && KeyCmp(chunki.bsks[ki+kicount], key1) > 0 {
				break __break__
			}
		}
		fps.curpage_has++
		// related with json
		// bs not BIG
		var akey any
		if strings.Contains(fps.spr.tn, EMBEDTNCOLON) {
			switch {
			case fps.spr.flag&STRDATA == STRDATA:
				akey = string(chunki.bs[ki+kicount])
			case fps.spr.flag&I64DATA == I64DATA:
				akey = int64(binary.LittleEndian.Uint64(chunki.bs[ki+kicount]))
			case fps.spr.flag&F64DATA == F64DATA:
				akey = math.Float64frombits(binary.LittleEndian.Uint64(chunki.bs[ki+kicount]))
			}
			inserti := AnyGEKeySearch(keys, akey)
			keys = append(keys[:inserti], append([]any{akey}, keys[inserti:]...)...)
		} else {
			keys = append(keys, chunki.bs[ki+kicount])
		}
		kicount++
	}
	return fps, keys
}

func bskeySLorGeSomeKeys(fps *FindParams) (*FindParams, []any) {
	var kicount, ki int
	var keys []any
	chunki := fps.page_starts[fps.wanted_pageNo].start
	ki = fps.page_starts[fps.wanted_pageNo].ki
	fps.curpage_has = 0
	bcwp := new(keyCsWrParams)
	bcwp.f = fps.f
	bcwp.wr = R
	bcwp.spr = fps.spr
	key0, k0ok := fps.key0.([]byte)
	if !(fps.findType == FindAny || fps.findType == FindNull) && !k0ok {
		return nil, nil
	} else if fps.findType == FindNull {
		key0 = []byte(nil)
	}
__break__:
	for {
		//REVISE:add 202311062043
		chunki.wait4Writing()
		if len(chunki.bsks) == 0 {
			fps.curpage_has = -1
			break
		}
		if fps.curpage_has == fps.page_should_has {
			fps.curbstr = chunki
			fps.curki = ki + kicount
			break
		}
		if ki+kicount == len(chunki.bsks) {
			if chunki == fps.endbstr {
				break
			}
			bcwp.cs = chunki
			bcwp.pa = chunki.chunk[PARENT]
			__global_bskeyCsWr_chan__ <- bcwp
			chunki = <-__global_bskeyCsWr_LRIre_chan__
			if chunki == nil {
				fps.curki = ki + kicount - 1
				break
			}
			kicount = 0
			ki = 0
		}
		switch fps.findType {
		case FindE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) == 0) {
				break __break__
			}
		case FindGE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
		case FindLE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) <= 0) {
				kicount++
				continue
			}
		case FindG:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) > 0) {
				kicount++
				continue
			}
		case FindL:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) < 0) {
				kicount++
				continue
			}
		case FindNE:
			if !(!chunki.bools[ki+kicount] && KeyCmp(chunki.bsks[ki+kicount], key0) != 0) {
				kicount++
				continue
			}
		case FindLike:
			if !(!chunki.bools[ki+kicount] && Like(chunki.bsks[ki+kicount], key0) >= 0) {
				kicount++
				continue
			}
		case FindNull:
			if !(!chunki.bools[ki+kicount] && chunki.bsks[ki+kicount] == nil) {
				kicount++
				continue
			}
		case FindAny:
			if chunki.bools[ki+kicount] {
				kicount++
				continue
			}
		}
		fps.curpage_has++
		// related with json
		// bs not BIG
		var akey any
		if strings.Contains(fps.spr.tn, EMBEDTNCOLON) {
			switch {
			case fps.spr.flag&STRDATA == STRDATA:
				akey = string(chunki.bs[ki+kicount])
			case fps.spr.flag&I64DATA == I64DATA:
				akey = int64(binary.LittleEndian.Uint64(chunki.bs[ki+kicount]))
			case fps.spr.flag&F64DATA == F64DATA:
				akey = math.Float64frombits(binary.LittleEndian.Uint64(chunki.bs[ki+kicount]))
			}
			inserti := AnyGEKeySearch(keys, akey)
			keys = append(keys[:inserti], append([]any{akey}, keys[inserti:]...)...)
		} else {
			keys = append(keys, chunki.bs[ki+kicount])
		}
		kicount++
	}
	return fps, keys
}