}

def UniformQuantizedStableHloToTflPass
    : Pass<"uniform-quantized-stablehlo-to-tfl", "mlir::func::FuncOp"> {
  let summary = "Converts StableHLO ops using uniform quantized types to equivalent TFL ops.";
  let constructor = "mlir::odml::CreateUniformQuantizedStableHloToTflPass()";
  let description = [{
    Converts StableHLO ops that accept or return uniform quantized types to
    equivalent ops in the TFLite dialect.
  }];

    def factory = new OriginMetadataFactory(
        buildInvocationId,
        { it.gradleVersion = "3.0" }
    )
    def buildCacheKey = TestHashCodes.hashCodeFrom(1234)

    def "converts to origin metadata"() {
        def origin = new Properties()
        def writer = factory.createWriter("identity", CacheableEntity, buildCacheKey, Duration.ofMillis(10))
        def baos = new ByteArrayOutputStream()

func PathTemplateMatcher(path string) *uri_template.UriTemplateMatchConfig {
	return &uri_template.UriTemplateMatchConfig{
		PathTemplate: sanitizePathTemplate(path),
	}
}

// sanitizePathTemplate converts the path template into a valid envoy uri template.
// https://www.envoyproxy.io/docs/envoy/latest/api-v3/extensions/path/match/uri_template/v3/uri_template_match.proto
// If path contains "{*}", it will be replaced with "*".

// Declare bridge passes that perform legalization and/or lowering.

include "mlir/Pass/PassBase.td"

def ConvertTFQuantOpsToMHLO : Pass<"quant-convert-tf-quant-ops-to-mhlo", "mlir::func::FuncOp"> {
  let summary = "Convert TF Quant ops to MHLO quantizated ops.";

  let description = [{
    Convert TF Quant ops to MHLO quant ops.
  }];

  let constructor = "mlir::quant::stablehlo::CreateConvertTFQuantOpsToMHLOPass()";

import org.gradle.exemplar.test.normalizer.OutputNormalizer
import org.gradle.internal.os.OperatingSystem
import org.gradle.platform.internal.DefaultBuildPlatform

/**
 * This normalizer converts toolchain error message so it doesn't contain platform-specific information.
 */
class PlatformInOutputNormalizer implements OutputNormalizer {
    def static internalOs = OperatingSystem.current()

}

// MustToGVR converts a GVK to a GVR, and panics if it cannot be converted
// Warning: this is only safe for known types; do not call on arbitrary GVKs
func MustToGVR(g config.GroupVersionKind) schema.GroupVersionResource {
	r, ok := ToGVR(g)
	if !ok {
		panic("unknown kind: " + g.String())
	}
	return r
}

// FromGVR converts a GVR to a GVK.

  [(HasRankOf<1> $add_rhs_value),
   (HasEqualElementSize<[-1], [0]> $conv_out, $add_rhs)], [], (addBenefit -1)>;

// Convert conv+sub+mul pattern to conv+mul+add.
// (conv - sub) * mul -> conv * mul + (-sub) * mul
//
// This is needed to support Conv+BatchNorm pattern from Jax models converted
// using jax2tf w/o native serialization. Note that Jax2tf patterns always
// extend bias shapes to a rank of 4, e.g. 1x1x1x5.

        // Add a newline at the start of each question
        output.println();
        output.text(getPrompt());
    }

    /**
     * Converts the given text into the response object, or returns a new prompt to display to the user.
     */
    public abstract PromptResult<?> convert(String text);

    public static class PromptResult<T> {
        public final T response;
        public final String newPrompt;

namespace mlir {

// Converts a TensorFlow model (either from a SavedModel or an MLIR module) to a
// StableHLO MLIR module.
//
// Args:
//  input_path: The path to the input TensorFlow SavedModel or MLIR module.
//  context: The MLIR context to use for parsing or creating the MLIR module.
//  exported_model_signatures: List of exported model signatures (strings) to
//    convert.

void DLManagedTensorDeleter(DLManagedTensor* arg) {
  TfDlManagedTensorCtx* owner =
      static_cast<TfDlManagedTensorCtx*>(arg->manager_ctx);
  owner->reference.Unref();
  delete owner;
}

// Converts TF_DATAType to DLPack data type.
DLDataType GetDlDataType(TF_DataType data_type, TF_Status* status) {
  DLDataType dtype;
  dtype.lanes = 1;
  dtype.bits = TF_DataTypeSize(data_type) * 8;
  switch (data_type) {