}

func findBinaries() ([]string, error) {
	binPaths := make([]string, 0)
	err := filepath.Walk(env.LocalOut, func(path string, f os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !f.IsDir() && envoyFileNamePattern.MatchString(f.Name()) {
			binPaths = append(binPaths, path)
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return binPaths, nil
}

		content, err := Evaluate(t, data)
		if err != nil {
			return nil, err
		}
		out = append(out, content)
	}
	return out, nil
}

func EvaluateAllFiles(data any, filePaths ...string) ([]string, error) {
	templates, err := file.AsStringArray(filePaths...)
	if err != nil {
		return nil, err
	}
	return EvaluateAll(data, templates...)
}

func MustEvaluateAll(data any, templates ...string) []string {

    }

    private class LegacyPlatformWindowsSdk implements WindowsSdk {
        private final String[] binPaths;
        private final String[] libPaths;

        LegacyPlatformWindowsSdk(String[] binPaths, String[] libPaths) {
            this.binPaths = binPaths;
            this.libPaths = libPaths;
        }

        @Override
        public VersionNumber getImplementationVersion() {

	paths = append(paths, inst.LibPaths...)

	return
}

// Return an importer that searches incpaths followed by the gcc installation's
// built-in search paths and the current directory.
func (inst *GccgoInstallation) GetImporter(incpaths []string, initmap map[*types.Package]InitData) Importer {
	return GetImporter(append(append(incpaths, inst.SearchPaths()...), "."), initmap)

	return c.New().Eval(ns, args, yamlTemplates...)
}

func (c *configFactory) File(ns string, filePaths ...string) config.Plan {
	return c.New().File(ns, filePaths...)
}

func (c *configFactory) EvalFile(ns string, args any, filePaths ...string) config.Plan {
	return c.New().EvalFile(ns, args, filePaths...)
}

func (c *configFactory) applyYAML(cleanupStrategy cleanup.Strategy, ns string, yamlText ...string) error {

			convertScale = true
		}
		if utilfeature.DefaultFeatureGate.Enabled(apiextensionsfeatures.CustomResourceFieldSelectors) {
			fieldPaths := sets.New[string]()
			for _, sf := range version.SelectableFields {
				fieldPaths.Insert(strings.TrimPrefix(sf.JSONPath, "."))
			}
			selectableFields[gv] = fieldPaths
		}
	}

	unsafe = &crConverter{
		convertScale:     convertScale,
		validVersions:    validVersions,

				queue = append(queue, r)
				enqueued[r] = true
			}
		}
	}
}

// FindPath reports a shortest requirement path starting at one of the roots of
// the graph and ending at a module version m for which f(m) returns true, or
// nil if no such path exists.
func (g *Graph) FindPath(f func(module.Version) bool) []module.Version {
	// firstRequires[a] = b means that in a breadth-first traversal of the

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

package config

// KubeletConfigurationPathRefs returns pointers to all of the KubeletConfiguration fields that contain filepaths.
// You might use this, for example, to resolve all relative paths against some common root before
// passing the configuration to the application. This method must be kept up to date as new fields are added.

		}
		p.setBootstrap(bootstrap)
	}
	if bootstrap := p.getBootstrap(); bootstrap != nil {
		if fwp := bootstrap.FileWatcherProvider(); fwp != nil {
			for _, path := range fwp.FilePaths() {
				if !file.Exists(path) {
					return fmt.Errorf("%s does not exist", path)
				}
			}
		}
	}
	return nil
}

func (p *probe) getBootstrap() *grpcxds.Bootstrap {
	p.RLock()
	defer p.RUnlock()

		t.Fatal(dump.Pretty(test.Infos))
	}
}

func TestExpandPathsToFileVisitors(t *testing.T) {
	// Define a directory structure that will be used for testing and create empty files
	testDir := t.TempDir()
	filePaths := []string{
		filepath.Join(testDir, "0", "10.yaml"),
		filepath.Join(testDir, "0", "a", "10.yaml"),
		filepath.Join(testDir, "02.yaml"),
		filepath.Join(testDir, "10.yaml"),
		filepath.Join(testDir, "2.yaml"),