func (s *Int64Map) findNodeDelete(key int64, preds *[maxLevel]*int64Node, succs *[maxLevel]*int64Node) int {
	lFound, x := -1, s.header
	for i := int(atomic.LoadInt64(&s.highestLevel)) - 1; i >= 0; i-- {
		succ := x.atomicLoadNext(i)
		for succ != nil && succ.lessthan(key) {
			x = succ
			succ = x.atomicLoadNext(i)
		}
		preds[i] = x
		succs[i] = succ
		if lFound == -1 && succ != nil && succ.equal(key) {
			lFound = i
		}
	}
	return lFound
}
findNodeDelete takes a key and two maximal-height arrays then searches exactly as in a sequential skip-list.
The returned preds and succs always satisfy preds[i] > key >= succs[i].
package skipmap
import (
	"sync"
	"sync/atomic"
	"unsafe"
)
type Int64Map struct {
	header       *int64Node
	length       int64
	highestLevel int64  
}
type int64Node struct {
	key   int64
	value unsafe.Pointer  
	next  optionalArray   
	mu    sync.Mutex
	flags bitflag
	level uint32
}
func newInt64Node(key int64, value interface{}, level int) *int64Node {
	node := &int64Node{
		key:   key,
		level: uint32(level),
	}
	node.storeVal(value)
	if level > op1 {
		node.next.extra = new([op2]unsafe.Pointer)
	}
	return node
}
func (n *int64Node) storeVal(value interface{}) {
	atomic.StorePointer(&n.value, unsafe.Pointer(&value))
}
func (n *int64Node) loadVal() interface{} {
	return *(*interface{})(atomic.LoadPointer(&n.value))
}
func (n *int64Node) loadNext(i int) *int64Node {
	return (*int64Node)(n.next.load(i))
}
func (n *int64Node) storeNext(i int, node *int64Node) {
	n.next.store(i, unsafe.Pointer(node))
}
func (n *int64Node) atomicLoadNext(i int) *int64Node {
	return (*int64Node)(n.next.atomicLoad(i))
}
func (n *int64Node) atomicStoreNext(i int, node *int64Node) {
	n.next.atomicStore(i, unsafe.Pointer(node))
}
func (n *int64Node) lessthan(key int64) bool {
	return n.key < key
}
func (n *int64Node) equal(key int64) bool {
	return n.key == key
}
func NewInt64() *Int64Map {
	h := newInt64Node(0, "", maxLevel)
	h.flags.SetTrue(fullyLinked)
	return &Int64Map{
		header:       h,
		highestLevel: defaultHighestLevel,
	}
}
func (s *Int64Map) findNode(key int64, preds *[maxLevel]*int64Node, succs *[maxLevel]*int64Node) *int64Node {
	x := s.header
	for i := int(atomic.LoadInt64(&s.highestLevel)) - 1; i >= 0; i-- {
		succ := x.atomicLoadNext(i)
		for succ != nil && succ.lessthan(key) {
			x = succ
			succ = x.atomicLoadNext(i)
		}
		preds[i] = x
		succs[i] = succ
		if succ != nil && succ.equal(key) {
			return succ
		}
	}
	return nil
}