/// loaded into an executable in-memory representation).
class SavedModelV2Bundle {
 public:
  using RestoreObjectsCallback =
      std::function<Status(int, const TrackableObjectGraph::TrackableObject&)>;

  /// Loads persistent representations for a SavedModelV2 from the specified
  /// export directory.
  static Status Load(const std::string& export_dir, SavedModelV2Bundle* bundle);

  /// MetaGraphDef from the loaded SavedModel.

  /var/run/secrets/istiod/tls/tls.key
  /var/run/secrets/istiod/ca/root-cert.pem
  ```
  The CA path will alternatively be loaded from: `/var/run/secrets/tls/ca.crt`
  It also automatically loads any secret called istiod-tls and the istio-root-ca-configmap into those paths.
  This method is preferred to use those well known paths than to set the tls args.

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

// This test makes sure that we don't split a single
// load up into two separate loads.

package main

import "testing"

//go:noinline
func read1(b []byte) (uint16, uint16) {
	// There is only a single read of b[0].  The two
	// returned values must have the same low byte.
	v := b[0]

func addXor(dst, src []byte, a, b uint32) {
	_, _ = src[3], dst[3] // bounds check elimination hint
	if unaligned {
		// The compiler should optimize this code into
		// 32-bit unaligned little endian loads and stores.
		// TODO: delete once the compiler does a reliably
		// good job with the generic code below.
		// See issue #25111 for more details.
		v := uint32(src[0])
		v |= uint32(src[1]) << 8

        workGraphStoredAndLoaded()
        def loadOp = operations.only(ConfigurationCacheLoadBuildOperationType)
        def storeOp = operations.only(ConfigurationCacheStoreBuildOperationType)
        with(storeOp.result) {
            cacheEntrySize > 0
        }
        with(loadOp.result) {
            cacheEntrySize == storeOp.result.cacheEntrySize
        }
        def buildInvocationId = loadOp.result.originBuildInvocationId

        when:

Status LoadMetagraphIntoSession(const SessionOptions& session_options,
                                const MetaGraphDef& meta_graph,
                                std::unique_ptr<Session>* session);

/// Loads a SavedModel from the specified export directory. The MetaGraphDef
/// to be loaded is identified by the supplied tags, corresponding exactly to
/// the set of tags used at SavedModel build time. Stores a SavedModel bundle in

        if (!classesWithJavaSource.isEmpty()) {
            // We need to collect just accessible dependents, since it seems
            // private references to classes are not problematic when Groovy compiler loads a class
            sourceFileChangeProcessor.processOnlyAccessibleChangeOfClasses(classesWithJavaSource, recompilationSpec);
        }
    }

    private boolean supportsGroovyJavaJointCompilation(JavaCompileSpec spec) {

import static org.apache.commons.lang.StringUtils.substringBeforeLast;
import static org.gradle.internal.hash.Hashing.hashString;

/**
 * A {@link ScriptSource} which loads the script from a URI.
 */
public class TextResourceScriptSource implements ScriptSource {
    private final TextResource resource;
    private String className;

//go:noescape
func Load(ptr *uint32) uint32

//go:noescape
func Load8(ptr *uint8) uint8

//go:noescape
func Load64(ptr *uint64) uint64

// NO go:noescape annotation; *ptr escapes if result escapes (#31525)
func Loadp(ptr unsafe.Pointer) unsafe.Pointer

//go:noescape
func LoadAcq(addr *uint32) uint32

//go:noescape
func LoadAcq64(ptr *uint64) uint64

//go:noescape
func LoadAcquintptr(ptr *uintptr) uintptr

  // returns it.
  virtual absl::StatusOr<std::string> BuildSerializedExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result) = 0;

  // Loads `serialized_executable` into an `ExecutableType` using `ClientType`.
  virtual StatusOr<std::unique_ptr<ExecutableType>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,