}`
	// Type-check the package.
	// We create an empty map for each kind of input
	// we're interested in, and Check populates them.
	info := types2.Info{
		Types: make(map[syntax.Expr]types2.TypeAndValue),
		Defs:  make(map[*syntax.Name]types2.Object),
		Uses:  make(map[*syntax.Name]types2.Object),
	}
	pkg := mustTypecheck(input, nil, &info)

	// Print package-level variables in initialization order.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build ignore

/*
 * Input to cgo -cdefs

GOARCH=386 go tool cgo -cdefs defs2_linux.go >defs_linux_386.h

The asm header tricks we have to use for Linux on amd64
(see defs.c and defs1.c) don't work here, so this is yet another
file.  Sigh.
*/

package runtime

/*

			defs := GetOpenAPIDefinitionsWithoutDisabledFeatures(getOpenAPIDefs)(func(path string) spec.Ref {
				return spec.Ref{}
			})
			def := defs["k8s.io/api/apps/v1.DeploymentCondition"]
			enumAppeared := false
			for _, prop := range def.Schema.Properties {
				if strings.Contains(prop.Description, "enum") {
					enumAppeared = true

python_register_toolchains(
    name = "python",
    ignore_root_user_error = True,
    python_version = TF_PYTHON_VERSION,
)

load("@python//:defs.bzl", "interpreter")
load("@rules_python//python:pip.bzl", "pip_parse")

pip_parse(
    name = "pypi",
    python_interpreter_target = interpreter,

            "quantization_interface.h.inc",
        ),
        (
            ["-gen-op-interface-defs"],
            "quantization_interface.cc.inc",
        ),
    ],
    tblgen = "@llvm-project//mlir:mlir-tblgen",
    td_file = "quantization.td",
    deps = [
        ":quantization_td_files",
    ],
)

exports_files([
    "quantization_traits.h",

# Make output from the dockerized build go someplace else
ENV KUBE_OUTPUT_SUBPATH=_output/dockerized

# Pick up version stuff here as we don't copy our .git over.
ENV KUBE_GIT_VERSION_FILE=${HOME}/.dockerized-kube-version-defs

# Add system-wide git user information
RUN git config --system user.email "******@****.***" \
  && git config --system user.name "kube-build-image"

# Fix permissions on gopath
RUN chmod -R a+rwx $GOPATH

/default.etcd

# Also ignore protoc installed by hack/install-protoc.sh
/third_party/protoc*

# User cluster configs
.kubeconfig

.tags*

# Version file for dockerized build
.dockerized-kube-version-defs

# Web UI
/www/master/node_modules/
/www/master/npm-debug.log
/www/master/shared/config/development.json

# Karma output
/www/test_out

    tbl_outs = [
        (
            ["-gen-op-decls"],
            "tfrt_ops.h.inc",
        ),
        (
            ["-gen-op-defs"],
            "tfrt_ops.cc.inc",
        ),
    ],
    tblgen = "@llvm-project//mlir:mlir-tblgen",
    td_file = "tfrt_ops.td",
    deps = [
        ":tensorflow_tfrt_ops_td_files",
    ],
)

cc_library(
    name = "tensorflow_tfrt_ops",
    srcs = [

  for (Node* node : graph->nodes()) {
    if (CanCreateXlaKernel(node->def())) {
      const FunctionBody* fbody = nullptr;
      std::vector<int> constant_arg_indices;
      std::vector<int> resource_arg_indices;

      NameAttrList function;
      TF_RETURN_IF_ERROR(NameAndAttrsFromFunctionCall(node->def(), &function));

      // Force all constants to be on the host memory.

	// Type-check the package.
	// We create an empty map for each kind of input
	// we're interested in, and Check populates them.
	info := types.Info{
		Types: make(map[ast.Expr]types.TypeAndValue),
		Defs:  make(map[*ast.Ident]types.Object),
		Uses:  make(map[*ast.Ident]types.Object),
	}
	var conf types.Config
	pkg, err := conf.Check("fib", fset, []*ast.File{f}, &info)
	if err != nil {
		log.Fatal(err)
	}