tr := qp.New()

	keys := []string{"a", "b", "c", "f", "cef", "e", "cefy"}
	for _, key := range keys {
		tr.Upsert([]byte(key), 1)
	}

	size := tr.Size()
	fmt.Printf("after Upsert, trie size: %d \n", size)

	val, found := tr.Get([]byte("a"))
	fmt.Printf("Get a, val: %v, found: %t \n", val, found)

	oldVal, found := tr.Delete([]byte("b"))
	fmt.Printf("Delete b, val: %v, found: %t \n", oldVal, found)

	size = tr.Size()
	fmt.Printf("after Delete, trie size: %d \n", size)

	tr := qp.New()
	keys := []string{"a", "b", "c", "f", "cef", "e", "cefy"}
	for _, key := range keys {
		tr.Upsert([]byte(key), 1)
	}	
	it := tr.Iterator()
	for {
		k, v, ok := it.Next()
		if !ok {
			break
		}
		fmt.Printf("key: %v, val: %v\n", k,v)
	}

	tr := qp.New()
	keys := []string{"a", "b", "c", "f", "cef", "e", "cefy"}
	for _, key := range keys {
		tr.Upsert([]byte(key), 1)
	}	
	max := math.MaxInt
	result := tr.Walk(max, nil)
	fmt.Printf("result: %v \n", result)

	tr := qp.New()
	keys := []string{"a", "b", "c", "f", "cef", "e", "cefy"}
	for _, key := range keys {
		tr.Upsert([]byte(key), 1)
	}

	tx := tr.Txn()
	tx.Upsert([]byte("b"), 2)
	tx.Upsert([]byte("x"), 3)
	tx.Delete([]byte("a"))
	tr = tx.Commit() // or  tx.Abort()
	result := tr.Walk(10, nil)
	for _, d := range result {
		fmt.Printf("key: %s, value: %v \n", string(d.Key), d.Value)
	}

	onInsert := func(newVal any) (finalVal any) {
		v := newVal.(int)
		return v * 10 // return newVal * 10
	}
	tr := qp.New(qp.WithOnInsert(onInsert))	
	for i := 1; i < 10; i++ {
		key := fmt.Sprintf("%d", i)
		val := i
		tr.Upsert([]byte(string(key)), val)
	}	
	for i := 1; i < 10; i++ {
		key := fmt.Sprintf("%d", i)
		val, _ := tr.Get([]byte(string(key)))
		fmt.Printf("key: %s, value: %v \n", string(key), val)
	}

	onUpdate := func(newVal, oldVal any) (finalVal any) {
		v := newVal.(int)
		return v + oldVal.(int) // return newVal + oldVal
	}
	tr := qp.New(qp.WithOnUpdate(onUpdate))	
	for i := 1; i < 10; i++ {
		key := fmt.Sprintf("%d", i)
		val := i
		tr.Upsert([]byte(string(key)), val)
	}	
	// update
	for i := 1; i < 10; i++ {
		key := fmt.Sprintf("%d", i)
		val := i
		tr.Upsert([]byte(string(key)), val)
	}	
	for i := 1; i < 10; i++ {
		key := fmt.Sprintf("%d", i)
		val, _ := tr.Get([]byte(string(key)))
		fmt.Printf("key: %s, value: %v \n", string(key), val)
	}

	tr := qp.New()
	kvs := []qp.KVPair{
		{Key: []byte("a"), Value: 1},
		{Key: []byte("ab"), Value: 2},
		{Key: []byte("b"), Value: 2},
		{Key: []byte("c"), Value: 3},
	}
	for _, d := range kvs {
		tr.Upsert([]byte(d.Key), d.Value)
	}	
	// Return up to 10 pairs.
	max := 10
	// only reuturn key with 'a' prefix and value > 2
	f := func(key []byte, val any) bool { 
		v := val.(int)
		return bytes.HasPrefix(key, []byte("a")) && v >= 2
	}
	result := tr.Walk(max, f)
	fmt.Printf("result: %v \n", result)