// CHECK: [[name:%.*]] = "tf.VarHandleOp"
    // CHECK: "tf.ReadVariableOp"([[name]])
    %a = builtin.unrealized_conversion_cast to tensor<f32>
    %b = builtin.unrealized_conversion_cast to tensor<f32>
    %0, %1, %2 = "tf.WhileRegion"(%a, %b, %arg0) ({
      ^bb0(%ca: tensor<f32>, %cb: tensor<f32>, %cc: !res):
      %cond = builtin.unrealized_conversion_cast to tensor<i1>

	// ClusterScoped is true for resource in cluster-level.
	ClusterScoped bool

	// Synthetic is true for resource that do not actually exist in a cluster
	Synthetic bool

	// Builtin is true for resources that are builtin (not CRD)
	Builtin bool

	// Identifier is the unique identifier for the resource
	Identifier string

	// Kind is the config proto type.
	Kind string

	// Plural is the type in plural.

//go:build ignore

// Generate builtin.go from builtin/runtime.go.

package main

import (
	"bytes"
	"flag"
	"fmt"
	"go/ast"
	"go/format"
	"go/parser"
	"go/token"
	"io"
	"log"
	"os"
	"path/filepath"
	"strconv"
	"strings"
)

var stdout = flag.Bool("stdout", false, "write to stdout instead of builtin.go")

func TestBuiltin(t *testing.T) {
	testenv.MustHaveGoRun(t)
	t.Parallel()

	old, err := os.ReadFile("builtin.go")
	if err != nil {
		t.Fatal(err)
	}

	new, err := testenv.Command(t, testenv.GoToolPath(t), "run", "mkbuiltin.go", "-stdout").Output()
	if err != nil {
		t.Fatal(err)
	}

	if !bytes.Equal(old, new) {
		t.Fatal("builtin.go out of date; run mkbuiltin.go")
	}

}

// Version returns the version of the builtin KMS.
func (secretKey) Version(ctx context.Context) (string, error) { return "v1", nil }

// APIs returns an error since the builtin KMS does not provide a list of APIs.
func (secretKey) APIs(ctx context.Context) ([]madmin.KMSAPI, error) {
	return nil, ErrNotSupported
}

// Status returns a set of endpoints and their KMS status. Since, the builtin KMS is not

import (
	"go/ast"
	"go/types"

	"golang.org/x/tools/go/ast/astutil"
	"golang.org/x/tools/internal/typeparams"
)

// Callee returns the named target of a function call, if any:
// a function, method, builtin, or variable.
//
// Functions and methods may potentially have type parameters.
func Callee(info *types.Info, call *ast.CallExpr) types.Object {
	fun := astutil.Unparen(call.Fun)

	MinKES                  // MinIO MinKES
	Builtin                 // Builtin single key KMS implementation
)

// Type identifies the KMS type.
type Type uint

// String returns the Type's string representation
func (t Type) String() string {
	switch t {
	case MinKMS:
		return "MinIO KMS"
	case MinKES:
		return "MinIO KES"
	case Builtin:
		return "MinIO builtin"
	default:

	}

	if uintptr(len) > -uintptr(ptr) {
		if ptr == nil {
			panicunsafestringnilptr()
		}
		panicunsafestringlen()
	}
}

// Keep this code in sync with cmd/compile/internal/walk/builtin.go:walkUnsafeString
func unsafestring64(ptr unsafe.Pointer, len64 int64) {
	len := int(len64)
	if int64(len) != len64 {
		panicunsafestringlen()
	}
	unsafestring(ptr, len)
}

  // It returns the default list of accepted dialects.
  std::vector<std::string> accepted_dialects({"stablehlo", "builtin", "func"});
  return accepted_dialects;
}

std::vector<std::string> GetAcceptedTFLiteDialects() {
  // It returns the default list of accepted dialects.
  std::vector<std::string> accepted_dialects({"tfl", "builtin", "func"});
  return accepted_dialects;
}

bool IsAcceptedDialect(llvm::StringRef dialect_name,

apiVersion: release-notes/v2
kind: feature
area: telemetry
issue: []

releaseNotes:
  - |