From 9c9e825412e99a12d52acb88cd7ee5826eb21513 Mon Sep 17 00:00:00 2001
From: Vincent Bernat <vincent@bernat.ch>
Date: Sat, 21 Oct 2023 10:21:54 +0200
Subject: [PATCH] Fix comment about FindDeepestTagsWithFilter* functions (#29)

---
 bool_tree/tree_v4.go                 | 4 ++--
 bool_tree/tree_v6_generated.go       | 4 ++--
 byte_tree/tree_v4.go                 | 4 ++--
 byte_tree/tree_v6_generated.go       | 4 ++--
 complex128_tree/tree_v4.go           | 4 ++--
 complex128_tree/tree_v6_generated.go | 4 ++--
 complex64_tree/tree_v4.go            | 4 ++--
 complex64_tree/tree_v6_generated.go  | 4 ++--
 float32_tree/tree_v4.go              | 4 ++--
 float32_tree/tree_v6_generated.go    | 4 ++--
 float64_tree/tree_v4.go              | 4 ++--
 float64_tree/tree_v6_generated.go    | 4 ++--
 generics_tree/tree_v4.go             | 4 ++--
 generics_tree/tree_v6_generated.go   | 4 ++--
 int16_tree/tree_v4.go                | 4 ++--
 int16_tree/tree_v6_generated.go      | 4 ++--
 int32_tree/tree_v4.go                | 4 ++--
 int32_tree/tree_v6_generated.go      | 4 ++--
 int64_tree/tree_v4.go                | 4 ++--
 int64_tree/tree_v6_generated.go      | 4 ++--
 int8_tree/tree_v4.go                 | 4 ++--
 int8_tree/tree_v6_generated.go       | 4 ++--
 int_tree/tree_v4.go                  | 4 ++--
 int_tree/tree_v6_generated.go        | 4 ++--
 rune_tree/tree_v4.go                 | 4 ++--
 rune_tree/tree_v6_generated.go       | 4 ++--
 string_tree/tree_v4.go               | 4 ++--
 string_tree/tree_v6_generated.go     | 4 ++--
 template/tree_v4.go                  | 4 ++--
 template/tree_v6_generated.go        | 4 ++--
 uint16_tree/tree_v4.go               | 4 ++--
 uint16_tree/tree_v6_generated.go     | 4 ++--
 uint32_tree/tree_v4.go               | 4 ++--
 uint32_tree/tree_v6_generated.go     | 4 ++--
 uint64_tree/tree_v4.go               | 4 ++--
 uint64_tree/tree_v6_generated.go     | 4 ++--
 uint8_tree/tree_v4.go                | 4 ++--
 uint8_tree/tree_v6_generated.go      | 4 ++--
 uint_tree/tree_v4.go                 | 4 ++--
 uint_tree/tree_v6_generated.go       | 4 ++--
 40 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/bool_tree/tree_v4.go b/bool_tree/tree_v4.go
index 8b06b6b..54e9b7c 100644
--- a/bool_tree/tree_v4.go
+++ b/bool_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []bool) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []bool) {
 	ret := make([]bool, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []bool, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []bool, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []bool) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/bool_tree/tree_v6_generated.go b/bool_tree/tree_v6_generated.go
index 85eac32..3874671 100644
--- a/bool_tree/tree_v6_generated.go
+++ b/bool_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []bool) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []bool) {
 	ret := make([]bool, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []bool, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []bool, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []bool) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/byte_tree/tree_v4.go b/byte_tree/tree_v4.go
index 714c463..0602f9f 100644
--- a/byte_tree/tree_v4.go
+++ b/byte_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []byte) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []byte) {
 	ret := make([]byte, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []byte, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []byte, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []byte) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/byte_tree/tree_v6_generated.go b/byte_tree/tree_v6_generated.go
index 2b06029..6d75843 100644
--- a/byte_tree/tree_v6_generated.go
+++ b/byte_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []byte) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []byte) {
 	ret := make([]byte, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []byte, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []byte, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []byte) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/complex128_tree/tree_v4.go b/complex128_tree/tree_v4.go
index 21b7089..038a7ba 100644
--- a/complex128_tree/tree_v4.go
+++ b/complex128_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []complex1
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []complex128) {
 	ret := make([]complex128, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []complex128, address patricia.IPv4Ad
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []complex128, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []complex128) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/complex128_tree/tree_v6_generated.go b/complex128_tree/tree_v6_generated.go
index a541366..4a91fdf 100644
--- a/complex128_tree/tree_v6_generated.go
+++ b/complex128_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []complex1
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []complex128) {
 	ret := make([]complex128, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []complex128, address patricia.IPv6Ad
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []complex128, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []complex128) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/complex64_tree/tree_v4.go b/complex64_tree/tree_v4.go
index 88f9602..8fadc64 100644
--- a/complex64_tree/tree_v4.go
+++ b/complex64_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []complex6
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []complex64) {
 	ret := make([]complex64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []complex64, address patricia.IPv4Add
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []complex64, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []complex64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/complex64_tree/tree_v6_generated.go b/complex64_tree/tree_v6_generated.go
index 8dd9e42..0b7ca21 100644
--- a/complex64_tree/tree_v6_generated.go
+++ b/complex64_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []complex6
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []complex64) {
 	ret := make([]complex64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []complex64, address patricia.IPv6Add
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []complex64, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []complex64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/float32_tree/tree_v4.go b/float32_tree/tree_v4.go
index f4f83e6..2e54ee6 100644
--- a/float32_tree/tree_v4.go
+++ b/float32_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []float32)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []float32) {
 	ret := make([]float32, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []float32, address patricia.IPv4Addre
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []float32, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []float32) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/float32_tree/tree_v6_generated.go b/float32_tree/tree_v6_generated.go
index e8c0075..8dbe42b 100644
--- a/float32_tree/tree_v6_generated.go
+++ b/float32_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []float32)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []float32) {
 	ret := make([]float32, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []float32, address patricia.IPv6Addre
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []float32, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []float32) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/float64_tree/tree_v4.go b/float64_tree/tree_v4.go
index dee1af3..f5c09f3 100644
--- a/float64_tree/tree_v4.go
+++ b/float64_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []float64)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []float64) {
 	ret := make([]float64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []float64, address patricia.IPv4Addre
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []float64, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []float64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/float64_tree/tree_v6_generated.go b/float64_tree/tree_v6_generated.go
index 50097f7..7dca415 100644
--- a/float64_tree/tree_v6_generated.go
+++ b/float64_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []float64)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []float64) {
 	ret := make([]float64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []float64, address patricia.IPv6Addre
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []float64, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []float64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/generics_tree/tree_v4.go b/generics_tree/tree_v4.go
index a0c82e1..070528c 100644
--- a/generics_tree/tree_v4.go
+++ b/generics_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4[T]) FindDeepestTags(address patricia.IPv4Address) (bool, []T) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4[T]) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc[T]) (bool, []T) {
 	ret := make([]T, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4[T]) FindDeepestTagsAppend(ret []T, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4[T]) FindDeepestTagsWithFilterAppend(ret []T, address patricia.IPv4Address, filterFunc FilterFunc[T]) (bool, []T) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/generics_tree/tree_v6_generated.go b/generics_tree/tree_v6_generated.go
index b2fb61c..f66345d 100644
--- a/generics_tree/tree_v6_generated.go
+++ b/generics_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6[T]) FindDeepestTags(address patricia.IPv6Address) (bool, []T) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6[T]) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc[T]) (bool, []T) {
 	ret := make([]T, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6[T]) FindDeepestTagsAppend(ret []T, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6[T]) FindDeepestTagsWithFilterAppend(ret []T, address patricia.IPv6Address, filterFunc FilterFunc[T]) (bool, []T) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int16_tree/tree_v4.go b/int16_tree/tree_v4.go
index a205c9d..162358b 100644
--- a/int16_tree/tree_v4.go
+++ b/int16_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []int16) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int16) {
 	ret := make([]int16, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []int16, address patricia.IPv4Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []int16, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int16) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int16_tree/tree_v6_generated.go b/int16_tree/tree_v6_generated.go
index 7ab4dd3..3720ba4 100644
--- a/int16_tree/tree_v6_generated.go
+++ b/int16_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []int16) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int16) {
 	ret := make([]int16, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []int16, address patricia.IPv6Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []int16, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int16) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int32_tree/tree_v4.go b/int32_tree/tree_v4.go
index b51c2e5..9a6257f 100644
--- a/int32_tree/tree_v4.go
+++ b/int32_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []int32) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int32) {
 	ret := make([]int32, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []int32, address patricia.IPv4Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []int32, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int32) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int32_tree/tree_v6_generated.go b/int32_tree/tree_v6_generated.go
index 65b35b4..74d891a 100644
--- a/int32_tree/tree_v6_generated.go
+++ b/int32_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []int32) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int32) {
 	ret := make([]int32, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []int32, address patricia.IPv6Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []int32, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int32) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int64_tree/tree_v4.go b/int64_tree/tree_v4.go
index b827ee6..02d4199 100644
--- a/int64_tree/tree_v4.go
+++ b/int64_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []int64) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int64) {
 	ret := make([]int64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []int64, address patricia.IPv4Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []int64, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int64_tree/tree_v6_generated.go b/int64_tree/tree_v6_generated.go
index 8a4eb5d..62f4e3c 100644
--- a/int64_tree/tree_v6_generated.go
+++ b/int64_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []int64) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int64) {
 	ret := make([]int64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []int64, address patricia.IPv6Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []int64, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int8_tree/tree_v4.go b/int8_tree/tree_v4.go
index c0ae715..35f93a6 100644
--- a/int8_tree/tree_v4.go
+++ b/int8_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []int8) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int8) {
 	ret := make([]int8, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []int8, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []int8, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int8) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int8_tree/tree_v6_generated.go b/int8_tree/tree_v6_generated.go
index 5b431dd..a593f59 100644
--- a/int8_tree/tree_v6_generated.go
+++ b/int8_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []int8) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int8) {
 	ret := make([]int8, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []int8, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []int8, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int8) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int_tree/tree_v4.go b/int_tree/tree_v4.go
index 087529c..dfa1eb7 100644
--- a/int_tree/tree_v4.go
+++ b/int_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []int) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int) {
 	ret := make([]int, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []int, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []int, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []int) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/int_tree/tree_v6_generated.go b/int_tree/tree_v6_generated.go
index 382a3fe..d9fbb8c 100644
--- a/int_tree/tree_v6_generated.go
+++ b/int_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []int) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int) {
 	ret := make([]int, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []int, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []int, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []int) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/rune_tree/tree_v4.go b/rune_tree/tree_v4.go
index b881f12..8389d4b 100644
--- a/rune_tree/tree_v4.go
+++ b/rune_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []rune) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []rune) {
 	ret := make([]rune, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []rune, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []rune, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []rune) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/rune_tree/tree_v6_generated.go b/rune_tree/tree_v6_generated.go
index fa747b3..0f23614 100644
--- a/rune_tree/tree_v6_generated.go
+++ b/rune_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []rune) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []rune) {
 	ret := make([]rune, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []rune, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []rune, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []rune) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/string_tree/tree_v4.go b/string_tree/tree_v4.go
index e074e2e..94bd676 100644
--- a/string_tree/tree_v4.go
+++ b/string_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []string)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []string) {
 	ret := make([]string, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []string, address patricia.IPv4Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []string, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []string) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/string_tree/tree_v6_generated.go b/string_tree/tree_v6_generated.go
index 562efe1..eabbbfa 100644
--- a/string_tree/tree_v6_generated.go
+++ b/string_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []string)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []string) {
 	ret := make([]string, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []string, address patricia.IPv6Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []string, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []string) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/template/tree_v4.go b/template/tree_v4.go
index 14a9ddf..5ffe790 100644
--- a/template/tree_v4.go
+++ b/template/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []Generate
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []GeneratedType) {
 	ret := make([]GeneratedType, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []GeneratedType, address patricia.IPv
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []GeneratedType, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []GeneratedType) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/template/tree_v6_generated.go b/template/tree_v6_generated.go
index 70057a4..733d848 100644
--- a/template/tree_v6_generated.go
+++ b/template/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []Generate
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []GeneratedType) {
 	ret := make([]GeneratedType, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []GeneratedType, address patricia.IPv
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []GeneratedType, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []GeneratedType) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint16_tree/tree_v4.go b/uint16_tree/tree_v4.go
index 7e1ce11..5f0486c 100644
--- a/uint16_tree/tree_v4.go
+++ b/uint16_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []uint16)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint16) {
 	ret := make([]uint16, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []uint16, address patricia.IPv4Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []uint16, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint16) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint16_tree/tree_v6_generated.go b/uint16_tree/tree_v6_generated.go
index 1ecee21..a9b16ef 100644
--- a/uint16_tree/tree_v6_generated.go
+++ b/uint16_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []uint16)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint16) {
 	ret := make([]uint16, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []uint16, address patricia.IPv6Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []uint16, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint16) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint32_tree/tree_v4.go b/uint32_tree/tree_v4.go
index e787671..d6a1448 100644
--- a/uint32_tree/tree_v4.go
+++ b/uint32_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []uint32)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint32) {
 	ret := make([]uint32, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []uint32, address patricia.IPv4Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []uint32, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint32) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint32_tree/tree_v6_generated.go b/uint32_tree/tree_v6_generated.go
index 1b7deb6..5401dc4 100644
--- a/uint32_tree/tree_v6_generated.go
+++ b/uint32_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []uint32)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint32) {
 	ret := make([]uint32, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []uint32, address patricia.IPv6Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []uint32, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint32) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint64_tree/tree_v4.go b/uint64_tree/tree_v4.go
index 5144635..87c7692 100644
--- a/uint64_tree/tree_v4.go
+++ b/uint64_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []uint64)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint64) {
 	ret := make([]uint64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []uint64, address patricia.IPv4Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []uint64, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint64_tree/tree_v6_generated.go b/uint64_tree/tree_v6_generated.go
index d1fdec3..d4deda3 100644
--- a/uint64_tree/tree_v6_generated.go
+++ b/uint64_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []uint64)
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint64) {
 	ret := make([]uint64, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []uint64, address patricia.IPv6Addres
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []uint64, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint64) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint8_tree/tree_v4.go b/uint8_tree/tree_v4.go
index 5a0b7aa..361c207 100644
--- a/uint8_tree/tree_v4.go
+++ b/uint8_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []uint8) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint8) {
 	ret := make([]uint8, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []uint8, address patricia.IPv4Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []uint8, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint8) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint8_tree/tree_v6_generated.go b/uint8_tree/tree_v6_generated.go
index ceec2b8..488cd7c 100644
--- a/uint8_tree/tree_v6_generated.go
+++ b/uint8_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []uint8) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint8) {
 	ret := make([]uint8, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []uint8, address patricia.IPv6Address
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []uint8, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint8) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint_tree/tree_v4.go b/uint_tree/tree_v4.go
index 4be6859..f826a64 100644
--- a/uint_tree/tree_v4.go
+++ b/uint_tree/tree_v4.go
@@ -635,7 +635,7 @@ func (t *TreeV4) FindDeepestTags(address patricia.IPv4Address) (bool, []uint) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilter(address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint) {
 	ret := make([]uint, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV4) FindDeepestTagsAppend(ret []uint, address patricia.IPv4Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV4) FindDeepestTagsWithFilterAppend(ret []uint, address patricia.IPv4Address, filterFunc FilterFunc) (bool, []uint) {
 	root := &t.nodes[1]
 	var found bool
diff --git a/uint_tree/tree_v6_generated.go b/uint_tree/tree_v6_generated.go
index 3d2abaa..85e8b8d 100644
--- a/uint_tree/tree_v6_generated.go
+++ b/uint_tree/tree_v6_generated.go
@@ -635,7 +635,7 @@ func (t *TreeV6) FindDeepestTags(address patricia.IPv6Address) (bool, []uint) {
 
 // FindDeepestTagsWithFilter finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - use FindDeepestTagsWithFilterAppend if you can reuse slices, to cut down on allocations
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilter(address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint) {
 	ret := make([]uint, 0)
 	return t.FindDeepestTagsWithFilterAppend(ret, address, filterFunc)
@@ -649,7 +649,7 @@ func (t *TreeV6) FindDeepestTagsAppend(ret []uint, address patricia.IPv6Address)
 
 // FindDeepestTagsWithFilterAppend finds all tags at the deepest level in the tree, matching the provided filter, representing the closest match
 // - appends results to the input slice
-// - returns true regardless of the result of the filtering function
+// - returns true unless the tree is empty, even if the results are filtered out
 func (t *TreeV6) FindDeepestTagsWithFilterAppend(ret []uint, address patricia.IPv6Address, filterFunc FilterFunc) (bool, []uint) {
 	root := &t.nodes[1]
 	var found bool