path := util.PathFromString(inPath)
		node, found, err := tpath.Find(inTree, path)
		if err != nil {
			return "", err
		}
		if !found {
			continue
		}

		if err := tpath.MergeNode(outTree, util.PathFromString(translation), node); err != nil {
			return "", err
		}
	}

	outYAML, err := yaml.Marshal(outTree)
	if err != nil {
		return "", err
	}
	return string(outYAML), nil

	if err != nil {
		return err
	}
	return WritePathContext(pc, value, false)
}

// MergeNode merges value to the tree in root at the given path, creating any required missing internal nodes in path.
func MergeNode(root any, path util.Path, value any) error {
	pc, _, err := getPathContext(&PathContext{Node: root}, path, path, true)
	if err != nil {
		return err
	}

					t.Fatal(err)
				}
			}
			p := util.PathFromString(tt.path)
			iv := make(map[string]any)
			err := yaml.Unmarshal([]byte(tt.value), &iv)
			if err != nil {
				t.Fatal(err)
			}
			err = MergeNode(root, p, iv)
			if gotErr, wantErr := errToString(err), tt.wantErr; gotErr != wantErr {
				t.Errorf("%s: gotErr:%s, wantErr:%s", tt.desc, gotErr, wantErr)
				return
			}

			keys = append(keys, k)
		}
		sort.Strings(keys)
		for _, k := range keys {
			outEnv := make(map[string]any)
			outEnv["name"] = k
			outEnv["value"] = fmt.Sprintf("%v", envMap[k])
			if err := tpath.MergeNode(cpSpecTree, util.ToYAMLPath(outPath), outEnv); err != nil {
				return err
			}
		}
	}
	return nil
}

// translateK8sTree is internal method for translating K8s configurations from value.yaml tree.

	Exit(2)
}

type covOperation interface {
	cov.CovDataVisitor
	Setup()
	Usage(string)
}

// Modes of operation.
const (
	funcMode      = "func"
	mergeMode     = "merge"
	intersectMode = "intersect"
	subtractMode  = "subtract"
	percentMode   = "percent"
	pkglistMode   = "pkglist"
	textfmtMode   = "textfmt"
	debugDumpMode = "debugdump"
)

func main() {

}

// ----------------------------------------------------------------------------
// Merging of package files

// The MergeMode flags control the behavior of [MergePackageFiles].
type MergeMode uint

const (
	// If set, duplicate function declarations are excluded.
	FilterFuncDuplicates MergeMode = 1 << iota
	// If set, comments that are not associated with a specific
	// AST node (as Doc or Comment) are excluded.

}

func (m *mstate) EndPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
}

func (m *mstate) VisitFunc(pkgIdx uint32, fnIdx uint32, fd *coverage.FuncDesc) {
	m.mm.visitFunc(pkgIdx, fnIdx, fd, mergeMode, *pcombineflag)
}

func (m *mstate) Finish() {
	if *pcombineflag {
		finalHash := m.mm.emitMeta(*outdirflag, true)
		m.mm.emitCounters(*outdirflag, finalHash)
	}

pkg fmt, type Stringer interface, String() string
pkg go/ast, const Bad ObjKind
pkg go/ast, const Con ObjKind
pkg go/ast, const FilterFuncDuplicates MergeMode
pkg go/ast, const FilterImportDuplicates MergeMode
pkg go/ast, const FilterUnassociatedComments MergeMode
pkg go/ast, const Fun ObjKind
pkg go/ast, const Lbl ObjKind
pkg go/ast, const Pkg ObjKind
pkg go/ast, const RECV ChanDir
pkg go/ast, const SEND ChanDir

		{"LabeledStmt.Stmt", Field, 0},
		{"Lbl", Const, 0},
		{"MapType", Type, 0},
		{"MapType.Key", Field, 0},
		{"MapType.Map", Field, 0},
		{"MapType.Value", Field, 0},
		{"MergeMode", Type, 0},
		{"MergePackageFiles", Func, 0},
		{"NewCommentMap", Func, 1},
		{"NewIdent", Func, 0},
		{"NewObj", Func, 0},
		{"NewPackage", Func, 0},
		{"NewScope", Func, 0},
		{"Node", Type, 0},