func (t *PrimaryTree) Close() {
	t.Clear()
	*t = zt1
	btTPool1.Put(t)
}
Close performs Clear and recycles t to a pool for possible later reuse. No
references to t should exist or such references must not be used afterwards.
package route
import (
	"fmt"
	"io"
	"sync"
	"sync/atomic"
)
const (
	kx1 = 64  
	kd1 = 64  
)
func init() {
	if kd1 < 1 {
		panic(fmt.Errorf("kd1 %d: out of range", kd1))
	}
	if kx1 < 2 {
		panic(fmt.Errorf("kx1 %d: out of range", kx1))
	}
}
var (
	btDPool1 = sync.Pool{New: func() interface{} { return &d1{} }}
	btEPool1 = btEpool1{sync.Pool{New: func() interface{} { return &PrimaryEnumerator{} }}}
	btTPool1 = btTpool1{sync.Pool{New: func() interface{} { return &PrimaryTree{} }}}
	btXPool1 = sync.Pool{New: func() interface{} { return &x1{} }}
)
type btTpool1 struct{ sync.Pool }
func (p *btTpool1) get(cmp PrimaryCmpFunc) *PrimaryTree {
	x := p.Get().(*PrimaryTree)
	x.cmp = cmp
	return x
}
type btEpool1 struct{ sync.Pool }
func (p *btEpool1) get(err error, hit bool, i int, k uint64, q *d1, t *PrimaryTree, ver uint64) *PrimaryEnumerator {
	x := p.Get().(*PrimaryEnumerator)
	x.err, x.hit, x.i, x.k, x.q, x.t, x.ver = err, hit, i, k, q, t, ver
	return x
}
type (
	d1 struct {  
		c int
		d [2*kd1 + 1]de1
		n *d1
		p *d1
	}
	de1 struct {  
		k uint64
		v SecondaryLayer
	}
	PrimaryEnumerator struct {
		err error
		hit bool
		i   int
		k   uint64
		q   *d1
		t   *PrimaryTree
		ver uint64
	}
	PrimaryTree struct {
		c     int
		cmp   PrimaryCmpFunc
		first *d1
		last  *d1
		r     interface{}
		ver   uint64
	}
	xe1 struct {  
		ch interface{}
		k  uint64
	}
	x1 struct {  
		c int
		x [2*kx1 + 2]xe1
	}
)
var (  
	zd1  d1
	zde1 de1
	ze1  PrimaryEnumerator
	zk1  uint64
	zt1  PrimaryTree
	zx1  x1
	zxe1 xe1
)
func clr1(q interface{}) {
	switch x := q.(type) {
	case *x1:
		for i := 0; i <= x.c; i++ {  
			clr1(x.x[i].ch)
		}
		*x = zx1
		btXPool1.Put(x)
	case *d1:
		*x = zd1
		btDPool1.Put(x)
	}
}
func newX1(ch0 interface{}) *x1 {
	r := btXPool1.Get().(*x1)
	r.x[0].ch = ch0
	return r
}
func (q *x1) extract(i int) {
	q.c--
	if i < q.c {
		copy(q.x[i:], q.x[i+1:q.c+1])
		q.x[q.c].ch = q.x[q.c+1].ch
		q.x[q.c].k = zk1   
		q.x[q.c+1] = zxe1  
	}
}
func (q *x1) insert(i int, k uint64, ch interface{}) *x1 {
	c := q.c
	if i < c {
		q.x[c+1].ch = q.x[c].ch
		copy(q.x[i+2:], q.x[i+1:c])
		q.x[i+1].k = q.x[i].k
	}
	c++
	q.c = c
	q.x[i].k = k
	q.x[i+1].ch = ch
	return q
}
func (q *x1) siblings(i int) (l, r *d1) {
	if i >= 0 {
		if i > 0 {
			l = q.x[i-1].ch.(*d1)
		}
		if i < q.c {
			r = q.x[i+1].ch.(*d1)
		}
	}
	return
}
func (l *d1) mvL(r *d1, c int) {
	copy(l.d[l.c:], r.d[:c])
	copy(r.d[:], r.d[c:r.c])
	l.c += c
	r.c -= c
}
func (l *d1) mvR(r *d1, c int) {
	copy(r.d[c:], r.d[:r.c])
	copy(r.d[:c], l.d[l.c-c:])
	r.c += c
	l.c -= c
}
func NewPrimaryTree(cmp PrimaryCmpFunc) *PrimaryTree {
	return btTPool1.get(cmp)
}
func (t *PrimaryTree) Clear() {
	if t.r == nil {
		return
	}
	clr1(t.r)
	t.c, t.first, t.last, t.r = 0, nil, nil, nil
	atomic.AddUint64(&t.ver, 1)
}