dir        string // file system directory
	inModule   bool
}

// Dirs is a structure for scanning the directory tree.
// Its Next method returns the next Go source directory it finds.
// Although it can be used to scan the tree multiple times, it
// only walks the tree once, caching the data it finds.
type Dirs struct {
	scan   chan Dir // Directories generated by walk.
	hist   []Dir    // History of reported Dirs.

    }


    /**
     * @return the treeId
     */
    public final int getTreeId () {
        return this.treeId;
    }


    /**
     * @param treeId
     *            the treeId to set
     */
    public final void setTreeId ( int treeId ) {
        this.treeId = treeId;
        if ( this.next != null ) {
            this.next.setTreeId(treeId);
        }
    }


    /**

    }

    @Override
    public void finished(TaskEvent e) {
        if (e.getKind() == Kind.ANALYZE) {
            Trees trees = Trees.instance(task);
            ConstantsTreeVisitor visitor = new ConstantsTreeVisitor(task.getElements(), trees, constantDependentsConsumer);
            TreePath path = trees.getPath(e.getCompilationUnit(), e.getCompilationUnit());
            visitor.scan(path, null);
        }
    }

// See the License for the specific language governing permissions and
// limitations under the License.

/*
struct.go contains functions for traversing and modifying trees of Go structs.
*/
package tpath

import (
	"fmt"
	"reflect"
	"strconv"

	"google.golang.org/protobuf/types/known/structpb"

	"istio.io/istio/operator/pkg/util"
)

NOTE: Although `FileTree` extends `FileCollection` (an is-a relationship), their behaviors differ.
In other words, you can use a file tree wherever a file collection is required, but remember that a file collection is a flat list/set of files, while a file tree is a file and directory hierarchy.
To convert a file tree to a flat collection, use the link:{javadocPath}/org/gradle/api/file/FileTree.html#getFiles--[FileTree.getFiles()] property.

        set.exclude 'excludes'
        def trees = set.srcDirTrees as List

        then:
        trees.size() == 2
        trees[0].dir == testDir.file('dir1')
        trees[0].patterns.includes as List == ['includes']
        trees[0].patterns.excludes as List == ['excludes']
        trees[1].dir == testDir.file('dir2')
        trees[1].patterns.includes as List == ['includes']
        trees[1].patterns.excludes as List == ['excludes']

	}

	out := make(map[string]any)
	err = yaml.Unmarshal([]byte(by), &out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// OverlayYAML patches the overlay tree over the base tree and returns the result. All trees are expressed as YAML
// strings.
func OverlayYAML(base, overlay string) (string, error) {
	if strings.TrimSpace(base) == "" {
		return overlay, nil
	}
	if strings.TrimSpace(overlay) == "" {

		children: [4]*node{
			makeTree(depth - 1),
			makeTree(depth - 1),
			makeTree(depth - 1),
			makeTree(depth - 1),
		},
	}
}

var trees [16]*node
var ballast *[16]*[1024]*node
var sink [][]byte

func main() {
	for i := range trees {
		trees[i] = makeTree(6)
	}
	ballast = new([16]*[1024]*node)
	for i := range ballast {
		ballast[i] = new([1024]*node)
		for j := range ballast[i] {

			pt = &t.prev
		} else {
			pt = &t.next
		}
	}

	// Add s as new leaf in tree of unique addrs.
	// The balanced tree is a treap using ticket as the random heap priority.
	// That is, it is a binary tree ordered according to the elem addresses,
	// but then among the space of possible binary trees respecting those
	// addresses, it is kept balanced on average by maintaining a heap ordering

        val tree = CachingLightTree(originalTree)
        val packageNode = packageNode(tree)
        val importNodes = importNodes(tree)
        val scriptNodes = scriptNodes(tree)

        val packages = packageHeader(tree, packageNode)
        val imports = importNodes.map { import(tree, it) }
        val statements = scriptNodes.map { statement(tree, it) }