// post-training quantization.
  bool disable_infer_tensor_range = false;

  // Whether to use the unfrozen variable quantization in MLIR. Typically,
  // variables are frozen for passing passes, but some variables aren't frozen.
  // If it is true, QuantizeVariables pass will be added after the
  // PrepareQuantizePass.
  bool enable_mlir_variable_quantization = false;

	for name, obj := range iom {
		isRenamed := false
		for fromPat, toPat := range rnm {
			fromRe, err := buildResourceRegexp(strings.TrimSpace(fromPat))
			if err != nil {
				return nil, fmt.Errorf("error building the regexp from "+
					"rename-from string: %v, error: %v", fromPat, err)
			}
			if fromRe.MatchString(name) {
				fromList := strings.Split(name, ":")
				if len(fromList) != 3 {

  if (is_inliner_run) {
    pm_after_freezing_variables.addPass(mlir::createInlinerPass());
  }
  if (run_tf_to_stablehlo) {
    // AddLegalizeTFToStablehloPasses expects frozen TF variables when
    // legalizing to stablehlo.constant.
    AddTFToStablehloPasses(pm_after_freezing_variables, input_arg_shapes);
  }

  if (deserialize_xla_call_module) {

		meshConfig:             env.Mesh(),
		computedMetricsFilters: map[metricsKey]any{},
		computedLoggingConfig:  map[loggingKey][]LoggingConfig{},
	}

	fromEnv := env.List(gvk.Telemetry, NamespaceAll)
	sortConfigByCreationTime(fromEnv)
	for _, config := range fromEnv {
		telemetry := Telemetry{
			Name:      config.Name,
			Namespace: config.Namespace,
			Spec:      config.Spec.(*tpb.Telemetry),
		}

// tensors with fill op.
std::unique_ptr<OperationPass<ModuleOp>> CreateUnfoldLargeSplatConstantPass();

// Creates a pass that adds control dependencies to keep the relative execution
// order of operations with side effects frozen.
std::unique_ptr<OperationPass<func::FuncOp>> CreatePinOpsWithSideEffectsPass();

// Legalize TensorList Ops iff all of them are supported.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeTensorListPass();

		files, err := zipindex.ReadDir(b[len(b)-size:], objSize, nil)
		if err == nil {
			return files, gr.ObjInfo, nil
		}
		var terr zipindex.ErrNeedMoreData
		if errors.As(err, &terr) {
			size = int(terr.FromEnd)
			if size <= 0 || size > 100<<20 {
				return nil, ObjectInfo{}, errors.New("zip directory too large")
			}
		} else {
			return nil, ObjectInfo{}, err
		}
	}
}

// It also implements the following extensions:
//
//	8BITMIME  RFC 1652
//	AUTH      RFC 2554
//	STARTTLS  RFC 3207
//
// Additional extensions may be handled by clients.
//
// The smtp package is frozen and is not accepting new features.
// Some external packages provide more functionality. See:
//
//	https://godoc.org/?q=smtp
package smtp

import (
	"crypto/tls"
	"encoding/base64"
	"errors"
	"fmt"

  // This decomposes resource ops like ResourceGather into read-variable op
  // followed by gather. This is used when the saved model import path is used
  // during which resources don't get frozen in the python layer.
  pass_manager->addNestedPass<mlir::func::FuncOp>(
      mlir::TFDevice::CreateDecomposeResourceOpsPass());

  pass_manager->addPass(mlir::TF::CreateTFRegionControlFlowToFunctional());
}

// translates tabbed columns in input into properly aligned text.
//
// The package is using the Elastic Tabstops algorithm described at
// http://nickgravgaard.com/elastictabstops/index.html.
//
// The text/tabwriter package is frozen and is not accepting new features.
package tabwriter

import (
	"fmt"
	"io"
	"unicode/utf8"
)

// ----------------------------------------------------------------------------
// Filter implementation

----
org.gradle.java.installations.fromEnv=JDK8,JRE17
----

Additionally, you can provide a comma-separated list of paths to specific installations using the `org.gradle.java.installations.paths` property.