ModeTemporary  = fs.ModeTemporary  // T: temporary file; Plan 9 only
	ModeSymlink    = fs.ModeSymlink    // L: symbolic link
	ModeDevice     = fs.ModeDevice     // D: device file
	ModeNamedPipe  = fs.ModeNamedPipe  // p: named pipe (FIFO)
	ModeSocket     = fs.ModeSocket     // S: Unix domain socket
	ModeSetuid     = fs.ModeSetuid     // u: setuid
	ModeSetgid     = fs.ModeSetgid     // g: setgid

/**
 * A multi, volatile, classloader safe cache for model schemas.
 * <p>
 * Significant complexity is introduced by facilitating a volatile classloader environment.
 * That is, classes being loaded and unloaded for the life of this cache.
 * This requires ModelSchema objects to not retain strong class references (which they don't due to use of ModelType)
 * and for strong class references not to be held for the cache keys.
 * <p>

import org.apache.maven.lifecycle.internal.builder.Builder;
import org.apache.maven.lifecycle.internal.builder.BuilderNotFoundException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Starts the build life cycle
 *
 */
@Named
@Singleton
public class DefaultLifecycleStarter implements LifecycleStarter {
    private final Logger logger = LoggerFactory.getLogger(getClass());

import java.util.concurrent.TimeUnit;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on

 * Executor, and sequentially such that no two will ever be running at the same time.
 *
 * <p>Tasks submitted to {@link #execute(Runnable)} are executed in FIFO order.
 *
 * <p>The execution of tasks is done by one thread as long as there are tasks left in the queue.
 * When a task is {@linkplain Thread#interrupt interrupted}, execution of subsequent tasks

 * Executor, and sequentially such that no two will ever be running at the same time.
 *
 * <p>Tasks submitted to {@link #execute(Runnable)} are executed in FIFO order.
 *
 * <p>The execution of tasks is done by one thread as long as there are tasks left in the queue.
 * When a task is {@linkplain Thread#interrupt interrupted}, execution of subsequent tasks

    "mlir::sparse_tensor::SparseTensorDialect", "mlir::vhlo::VhloDialect",
  ];
}

def TestLiftQuantizableSpotsAsFunctionsWithQuantizationSpecsPass :
    Pass<"stablehlo-test-lift-quantizable-spots-as-functions-with-quantization-specs", "mlir::ModuleOp"> {
  let summary = "Test-only pass for testing the LiftQuantizableSpotsAsFunctionsPass with a predefined QuantizationSpecs.";
  let description = [{

public class DefaultClassLoaderFactory implements ClassLoaderFactory {
    // This uses the system classloader and will not release any loaded classes for the life of the daemon process.
    // Do not use this to load any classes which are part of the build; it will not release them when the build is complete.

// RUN: tf-opt %s -tfl-lift-tflite-flex-ops | FileCheck %s

// CHECK-LABEL: TfAdd
func.func @TfAdd(%arg0: tensor<4xf64>, %arg1: tensor<4xf64>) -> tensor<4xf64> {
  %0 = "tfl.custom"(%arg0, %arg1) {
    custom_code = "FlexAdd",
    custom_option = #tfl<const_bytes : "0x03416464001412034164641A001A002A070A015412023002320000021B171414042801">
  } : (tensor<4xf64>, tensor<4xf64>) -> tensor<4xf64>

		podObjectCountName: *(resource.NewQuantity(1, resource.DecimalSI)),
	}

	// by convention, we do not quota compute resources that have reached end-of life
	// note: the "pods" resource is considered a compute resource since it is tied to life-cycle.
	if !QuotaV1Pod(pod, clock) {
		return result, nil
	}

	opts := resourcehelper.PodResourcesOptions{