str.pop_back();
  }
}

// Lifts quantizable units as separate functions, thereby identifying the
// boundaries of quantizable subgraphs. `QuantizationSpecs` influences how
// quantizable units are lifted.
//
// FileCheck test cases using various `QuantizationSpecs` can be seen at
// `TestLiftQuantizableSpotsAsFunctionsWithQuantizationSpecsPass`.
class LiftQuantizableSpotsAsFunctionsPass

inline constexpr StringRef kFusedFunctionAttr = "tf_quant.composite_function";
// The keyword to detect if this is a `NullAttribute`.
inline constexpr StringRef kNullAttributeValue = "N/A";

// Prefixes attached to lifted functions.
constexpr StringRef kQuantizedFuncPrefix = "quantized_";
constexpr StringRef kCompositeFuncPrefix = "composite_";

// The attribute will be used for TF::XlaCallModuleOp to restore the original

  // here will be quantized with best effort.
  map<int32, QuantizedType> input_quantized_types = 1;
}

// Represents a matching method that matches quantizable units by lifted
// functions' names.
message FunctionNameMatcherSpec {
  // Regular expression to match lifted functions' names. Underlying regex
  // engine uses re2, which accepts a subset of PCRE. See
  // https://github.com/google/re2/wiki/Syntax for details.
  string regex = 1;

namespace mlir::quant::stablehlo {
namespace {

using ::mlir::stablehlo::DotGeneralOp;
using ::stablehlo::quantization::Method;
using ::stablehlo::quantization::StaticRangePtq;

// Whether it represents a lifted function (i.e. `op` is the corresponding
// `XlaCallModuleOp`) that is explicitly marked `NoQuantization`.
bool IsDenylistedLiftedFunction(Operation* op) {
  if (auto xla_call_module_op = dyn_cast_or_null<TF::XlaCallModuleOp>(op);

func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, failed bool) {
	offset = initOffset
	var ret64 int64
	for shifted := 0; offset < len(bytes); shifted++ {
		// 5 * 7 bits per byte == 35 bits of data
		// Thus the representation is either non-minimal or too large for an int32
		if shifted == 5 {
			failed = true
			return
		}
		ret64 <<= 7
		b := bytes[offset]

        return true;
      }
    }
  }
  return false;
}

// Lifts HashTable ops in the target function as function arguments and returns
// the lifted ops. These ops  will then be added to the caller function and
// passed to the target function.
LogicalResult LiftHashTableOpsToArguments(ModuleOp module_op,
                                          func::FuncOp target_func) {

		be those functions exported using a cgo //export comment.
		Requires exactly one main package to be listed.

	-buildmode=default
		Listed main packages are built into executables and listed
		non-main packages are built into .a files (the default
		behavior).

	-buildmode=shared
		Combine all the listed non-main packages into a single shared
		library that will be used when building with the -linkshared

 * are overridden on the method level, you have to be sure to copy the lower bound down to the method level
 * when setting a new upper bound, otherwise the lower bound is lifted, as the method level annotations
 * replace the class level ones.
 */
@TargetGradleVersion('>=3.3')
class BuildActionCompositeBuildCrossVersionSpec extends ToolingApiSpecification {

        failure.assertHasCause("'$badVersion' is not a valid Gradle version string (examples: '1.0', '1.0-rc-1')")
        failure.assertHasResolution("Specify a valid Gradle release listed on https://gradle.org/releases/.")
        failure.assertHasResolution("Use one of the following dynamic version specifications: 'latest', 'release-candidate', 'release-nightly', 'nightly'.")

        where:

     * The exception that caused the problem.
     */
    @Nullable
    RuntimeException getException();

    /**
     * Additional data attached to the problem.
     * <p>
     * The supported types are listed on {@link AdditionalData}.
     */
    @Nullable
    AdditionalData getAdditionalData();

    /**
     * Returns a problem builder with fields initialized with values from this instance.
     */