kube::golang::outfile_for_binary() {
  local binary=$1
  local platform=$2
  local output_path="${KUBE_GOPATH}/bin"
  local bin
  bin=$(basename "${binary}")
  if [[ "${platform}" != "${host_platform}" ]]; then
    output_path="${output_path}/${platform//\//_}"
  fi
  if [[ ${GOOS} == "windows" ]]; then
    bin="${bin}.exe"
  fi
  echo "${output_path}/${bin}"
}

# Argument: the name of a Kubernetes package.

  uint64 hash() const { return op_.hash(index_); }

 private:
  Operation op_ = Operation(nullptr);
  int32 index_ = 0;
};

/// Hash class that can be used for e.g. storing Outputs in an unordered_map
struct OutputHash {
  std::size_t operator()(const Output& output) const {
    return Hash64Combine(std::hash<Node*>()(output.node()),
                         std::hash<int32>()(output.index()));
  }
};

		}
	}
	// End previous result parsing

	return &conf, nil
}

func GetLoggingOptions(cfg *Config) *log.Options {
	loggingOptions := log.DefaultOptions()
	loggingOptions.OutputPaths = []string{"stderr"}
	loggingOptions.JSONEncoding = true
	if cfg != nil {
		// Tee all logs to UDS. Stdout will go to kubelet (hard to access, UDS will be read by the CNI DaemonSet and exposed
		// by normal `kubectl logs`

	defaultScope.Error("TestBadWriter")
}

func BenchmarkLog(b *testing.B) {
	run := func(name string, f func()) {
		b.Run(name, func(b *testing.B) {
			o := testOptions()
			o.OutputPaths = []string{"/dev/null"}
			if err := Configure(o); err != nil {
				b.Fatalf("Got err '%v', expecting success", err)
			}
			for n := 0; n < b.N; n++ {
				f()
			}
		})
	}
	run("default", func() {

	mkdirOrExit(logDir)
	f, err := os.Create(logDir)
	if err != nil {
		return err
	}
	f.Close()
	op := []string{logDir}
	opt2 := *opt
	opt2.OutputPaths = op
	opt2.ErrorOutputPaths = op
	opt2.SetDefaultOutputLevel("default", log.InfoLevel)

	return log.Configure(&opt2)
}

func logRuntime(start time.Time, format string, args ...any) {