// and restoring the variable(s)' values.  Variable values are indexed in the
  // checkpoint files by "checkpoint keys".  These keys along with dtype and
  // shape / slice information allow RestoreV2 to look up a variable's value in
  // the SavedModel and restore it into a tensor.
  tensorflow::StatusOr<std::string> GetVariableCheckpointKey(int index);

  // Retrieves the object graph from the SavedModel.
  //

// op2 = .... {tac.device = "GPU"} {"CPU": 20, "GPU": 5.0}
// op3 = .... {tac.device = "GPU"} {"CPU": 30, "GPU": 10.0}
// op4 = .... {tac.device = "CPU"} {"CPU": 40, "GPU": -1.0}
//
// The exported runtime metadata will look like below:
// ======== Runtime Metadata ========
//
// RuntimeMetadata: {
//   hardwares: {
//    ["CPU", "GPU"]
//   }
//
//  subgraph_metadata: {
//    [
//      op1:
//       hardware: 0

    PluginRegistry createChild(ClassLoaderScope lookupScope);

    /**
     * Finds the plugin id which corresponds to the supplied class name.
     * @param clazz the class to look for
     * @return the plugin id for this class.
     */
    Optional<PluginId> findPluginForClass(Class<?> clazz);

import org.gradle.exemplar.executor.ExecutionMetadata
import org.gradle.exemplar.test.normalizer.OutputNormalizer

/**
 * This normalizer converts native component paths and environment
 * information to look like macOS because samples output currently shows
 * the output for macOS and is not yet capable of adapting dynamically
 * to different toolchains.
 */
class NativeComponentReportOutputNormalizer implements OutputNormalizer {

	// Discussion:
	//   A recursive template does not end in the same context in which it
	//   starts, and a reliable output context cannot be computed.
	//   Look for typos in the named template.
	//   If the template should not be called in the named start context,
	//   look for calls to that template in unexpected contexts.
	//   Maybe refactor recursive templates to not be recursive.
	ErrOutputContext

func (c *sigctxt) setsigpc(x uint64) { c.set_pc(x) }
func (c *sigctxt) sigsp() uintptr    { return uintptr(c.sp()) }
func (c *sigctxt) siglr() uintptr    { return uintptr(c.lr()) }

// preparePanic sets up the stack to look like a call to sigpanic.
func (c *sigctxt) preparePanic(sig uint32, gp *g) {
	// We arrange lr, and pc to pretend the panicking
	// function calls sigpanic directly.
	// Always save LR to stack so that panics in leaf

    .SetIsStateful()
    .Doc(R"(XLA Compile Op. For use by the XLA JIT only.

Compiles a TensorFlow function into an XLA LocalExecutable and returns a key
that _XlaRun can use to look up the LocalExecutable and execute it.

key: A key that can be used to look up the local executable compiled by the
   node and associated metadata.

compilation_successful: If the `must_compile` attr is false the _XlaCompile op

# Verifies golang.org/issue/37574.

# If we are already using an +incompatible version, we shouldn't look up
# a lower compatible version when upgrading.
cp go.mod go.mod.orig
go mod tidy
cmp go.mod.orig go.mod
grep '^example.com/incompatiblewithsub v2\.0\.0\+incompatible' go.sum
! grep '^example.com/incompatiblewithsub v1.0.0' go.sum

go get example.com/incompatiblewithsub/sub
cmp go.mod.orig go.mod

import (
	//Init the abac api package
	_ "k8s.io/kubernetes/pkg/apis/abac"
	_ "k8s.io/kubernetes/pkg/apis/abac/v0"
	_ "k8s.io/kubernetes/pkg/apis/abac/v1beta1"
)

// TODO: this file is totally wrong, it should look like other latest files.

	}
}

const hellogo = `
package main

func main() {
  println("hello")
}
`

// Returns a pair F,T where F is a meta-data file generated from
// "hello.go" above, and T is a token to look for that should be
// present in the coverage report from F.
func genAuxMeta(t *testing.T, dstdir string) (string, string) {
	// Do a GOCOVERDIR=<tmp> go run hello.go
	src := filepath.Join(dstdir, "hello.go")