*/
    ToolchainPrivate[] getToolchainsForType(String type, MavenSession context) throws MisconfiguredToolchainException;

    /**
     * Stores the toolchain into build context for later use by toolchain-aware plugins.
     *
     * @param toolchain the toolchain to store, must not be {@code null}
     * @param context the Maven session, must not be {@code null}
     * @since 2.0.9

                cacheAction == STORE && !hasProblems -> log("Configuration cache entry stored.")
                cacheAction == STORE -> log("Configuration cache entry stored with {}.", problemCountString)
                cacheAction == UPDATE && !hasProblems -> log("Configuration cache entry updated for {}, {} up-to-date.", updatedProjectsString, reusedProjectsString)

    accessKeyId: 'YOUR-ACCESSKEYID' ,
    secretAccessKey: 'YOUR-SECRETACCESSKEY' ,
    endpoint: 'http://127.0.0.1:9000' ,
    s3ForcePathStyle: true,
    signatureVersion: 'v4'
});

// List all contents stored in the zip archive
s3.listObjectsV2({Bucket : 'your-bucket', Prefix: 'path/to/file.zip/'}).
    on('build', function(req) { req.httpRequest.headers['X-Minio-Extract'] = 'true'; }).
    send(function(err, data) {

	vlp.typ = typ
	vlp.data = data
	return
}

var firstStoreInProgress byte

// Store sets the value of the [Value] v to val.
// All calls to Store for a given Value must use values of the same concrete type.
// Store of an inconsistent type panics, as does Store(nil).
func (v *Value) Store(val any) {
	if val == nil {
		panic("sync/atomic: store of nil value into Value")
	}
	vp := (*efaceWords)(unsafe.Pointer(v))

// those objects this container provides a map from node id to the revived
// objects.
//
// For objects that have to be revived but are not part of the object graph,
// this container provides a place where the objects can be stored so they are
// available to the runtime.
template <typename T>
class RevivedObjectContainer {
 public:
  // Insert an object that is not related to a node id. This usually means the

    public interface Details {
    }

    public interface Result {
        /**
         * The number of bytes of the stored configuration cache entry.
         *
         * @since 8.6
         */
        long getCacheEntrySize();

        /**
         * The ID of the build that store the configuration cache entry.
         *
         * `null` when unknown, e.g. when loading models and not a task graph.
         *

#include "absl/strings/string_view.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/lite/tools/optimize/reduced_precision_support.h"

namespace mlir {
namespace quant {

// Stores information about how to quantize a user-specified custom operation.
struct CustomOpInfo {
  std::vector<std::int32_t> quantizable_input_indices;
  bool is_weight_only = false;
  bool no_side_effect = true;
};

        def file = tmpDir.file("thing.zip")

        when:
        builder.jar(file) {
            it.put("store.txt", "bytes".bytes, ClasspathEntryVisitor.Entry.CompressionMethod.STORED)
            it.put("undefined.txt", "bytes".bytes, ClasspathEntryVisitor.Entry.CompressionMethod.UNDEFINED)

	maxEndpointsPerSlice int32

	// lock protects changes to numEndpoints and cache.
	lock sync.Mutex
	// numEndpoints represents the total number of endpoints stored in
	// EndpointSlices.
	numEndpoints int
	// cache stores a EndpointPortCache grouped by NamespacedNames representing
	// Services.
	cache map[types.NamespacedName]*EndpointPortCache
}

				continue
			}
			if v.Type.IsMemory() {
				stores = append(stores, v)
				for _, a := range v.Args {
					if a.Block == b && a.Type.IsMemory() {
						storeUse.add(a.ID)
					}
				}
			}
		}
		if len(stores) == 0 {
			lastMems[b.ID] = memPhi
			continue
		}

		// find last store in the block
		var last *Value
		for _, v := range stores {
			if storeUse.contains(v.ID) {
				continue