if internalcfg == nil {
		extinitcfg := &kubeadmapiv1.UpgradeConfiguration{}
		kubeadmscheme.Scheme.Default(extinitcfg)
		// Set upgradeCfg to an empty struct value the deserializer will populate
		internalcfg = &kubeadmapi.UpgradeConfiguration{}
		if err := kubeadmscheme.Scheme.Convert(extinitcfg, internalcfg, nil); err != nil {
			return nil, err
		}

  Message& operator <<(wchar_t* wide_c_str);

#if GTEST_HAS_STD_WSTRING
  // Converts the given wide string to a narrow string using the UTF-8
  // encoding, and streams the result to this Message object.
  Message& operator <<(const ::std::wstring& wstr);
#endif  // GTEST_HAS_STD_WSTRING

#if GTEST_HAS_GLOBAL_WSTRING
  // Converts the given wide string to a narrow string using the UTF-8

	_CLD_STOPPED         = 5
	_CLD_CONTINUED       = 6

	// These are the same as in syscall/syscall_linux.go.
	core      = 0x80
	stopped   = 0x7f
	continued = 0xffff
)

// WaitStatus converts SiginfoChild, as filled in by the waitid syscall,
// to syscall.WaitStatus.
func (s *SiginfoChild) WaitStatus() (ws syscall.WaitStatus) {
	switch s.Code {
	case _CLD_EXITED:
		ws = syscall.WaitStatus(s.Status << 8)

	}

	return &policyInfo, nil
}

// BucketAccessPolicyToPolicy - converts minio-go/policy.BucketAccessPolicy to policy.BucketPolicy.
func BucketAccessPolicyToPolicy(policyInfo *miniogopolicy.BucketAccessPolicy) (*policy.BucketPolicy, error) {
	data, err := json.Marshal(policyInfo)
	if err != nil {
		// This should not happen because policyInfo is valid to convert to JSON data.
		return nil, err
	}

		return nil
	}

	parsed, err := time.Parse(RFC3339Micro, *s)
	if err != nil {
		return err
	}

	t.Time = parsed.Local()
	return nil
}

// UnmarshalQueryParameter converts from a URL query parameter value to an object
func (t *MicroTime) UnmarshalQueryParameter(str string) error {
	if len(str) == 0 {
		t.Time = time.Time{}
		return nil
	}

#define GEN_PASS_DEF_CONVERTREADONLYREFERENCEVARIABLESTORESOURCEVARIABLESPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

// A pass that converts readonly reference variables to the corresponding
// resource variables.
//
// It converts (VariableV2 -> Identity) to (VarHandle -> ReadVariable).
//
// For the background, this pass is a part of hoisting VariableV2 ops by

	ftyp *funcType
	fn   func([]Value) []Value
}

// MakeFunc returns a new function of the given [Type]
// that wraps the function fn. When called, that new function
// does the following:
//
//   - converts its arguments to a slice of Values.
//   - runs results := fn(args).
//   - returns the results as a slice of Values, one per formal result.
//
// The implementation fn can assume that the argument [Value] slice

	if t == nil {
		return nil
	}
	return []T{*t}
}

// TypeName returns the name of the type
func TypeName[T any]() string {
	var empty T
	return fmt.Sprintf("%T", empty)
}

// Flatten converts a double pointer to a single pointer by referencing if its non-nil
func Flatten[T any](t **T) *T {
	if t == nil {
		return nil
	}
	return *t

std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizeWeightPass(
    const ::stablehlo::quantization::QuantizationComponentSpec&
        quantization_component_spec = {});

// Converts a serialized StableHLO module to bfloat16 and output serialized
// module.
absl::StatusOr<std::string> ConvertSerializedStableHloModuleToBfloat16(
    StringRef serialized_stablehlo_module);

namespace tensorflow {

// Extracts the attributes of a MLIR operation and populates the converted
// attributes in a proto map<string, AttrValue>.
Status GetAttrValuesFromOperation(
    mlir::Operation* inst, llvm::StringRef name,
    const tensorflow::OpRegistrationData* op_reg_data,
    bool ignore_unregistered_attrs, AttrValueMap* attributes);

// Converts a MLIR operation to TensorFlow NodeDef with given node name. This