// This pass has two stages:
  // a) first, we call EncapsulateSubgraphsPass to encapsulate all nodes
  //    marked with the same _xla_compile_id attribute into functions. These
  //    functions contain the computations to be passed to XlaLaunch. During
  //    encapsulation, we sort the arguments into the order expected by
  //    XlaLaunch.
  static Status Encapsulate(std::unique_ptr<Graph>* graph,

	K, err := mlkem768.Decapsulate(dk, c)
	if err != nil {
		return nil, err
	}
	return kyberSharedSecret(K, c), nil
}

// kyberEncapsulate implements encapsulation according to Kyber Round 3.
func kyberEncapsulate(ek []byte) (c, ss []byte, err error) {
	c, ss, err = mlkem768.Encapsulate(ek)
	if err != nil {
		return nil, nil, err
	}

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A service that provides the plugin service for the current build invocation.
 *
 * The plugin uses this to encapsulate its service in user facing code that may be cached.
 * This allows such cached code to use the plugin service for the current build when used from-cache.
 */
@ServiceScope(Scope.BuildTree.class)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.file;


/**
 * Encapsulates the logic for serializing and deserializing a file collection to and from the configuration cache.
 */
public interface FileCollectionExecutionTimeValue {

import org.gradle.internal.metaobject.DynamicInvokeResult;
import org.gradle.internal.metaobject.DynamicObject;

import javax.annotation.Nullable;
import java.util.Map;

/**
 * Encapsulates the implementations of the common ways to interact with a {@link DynamicObject}.
 */
public interface DynamicLookupRoutine {

 various properties files. What needs to be done is to encapsulate all of this in the POM.

 Typically users parameterize the use of plugins, or have custom values like ${user.name}
 for use in elements like the <developerConnection/>. It would be idea if we
 could encapsulate everything we need about the project in the POM including
 plugin parameters and anything else.

import org.gradle.internal.hash.Hasher;

import java.io.File;

/**
 * Classpath element transform factory. There are some differences when instrumenting classes to be loaded by the instrumenting agent, this interface encapsulates them.
 */
public interface ClasspathElementTransformFactory {
    /**
     * Updates jar/directory content hash to account for the transform produced by this factory.
     *
     * @param hasher the hasher to modify

import org.gradle.internal.service.scopes.GradleUserHomeScopeServiceRegistry;
import org.gradle.internal.service.scopes.Scope;

import java.io.Closeable;

/**
 * Encapsulates the state of a build process, such as the Gradle daemon. An instance is created for each process that runs a build.
 */
public class BuildProcessState implements Closeable {
    private final ServiceRegistry services;

import org.apache.maven.lifecycle.internal.ReactorContext;
import org.apache.maven.lifecycle.internal.TaskSegment;
import org.apache.maven.lifecycle.internal.builder.Builder;

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 */
@Named("singlethreaded")

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file encapsulates some of the odd characteristics of the
// Loong64 (LoongArch64) instruction set, to minimize its interaction
// with the core of the assembler.

package arch

import (
	"cmd/internal/obj"
	"cmd/internal/obj/loong64"
)

func jumpLoong64(word string) bool {