libs = append(libs, authzLibraryDecls, listsLibraryDecls, regexLibraryDecls, urlLibraryDecls, quantityLibraryDecls, ipLibraryDecls, cidrLibraryDecls)
	functionNames := sets.New[string]()
	for _, lib := range libs {
		for name := range lib {
			functionNames[name] = struct{}{}
		}
	}

	// WARN: All library changes must follow

  llvm::SmallDenseSet<func::FuncOp> added;
  for (const llvm::StringRef function_name : function_names) {
    auto func =
        llvm::dyn_cast_or_null<func::FuncOp>(symbol_table.lookupSymbolIn(
            module, builder.getStringAttr(function_name)));
    if (func == nullptr) {
      return module.emitError()
             << "Cannot find function '" << function_name << "'";
    }

    const WalkResult result = WalkReachableFunctions(

    # Add op names to the function name.
    function_name = 'quantized_{}'.format(
        _format_snake_case_op_name(quantized_ops[0]))
    if len(quantized_ops) > 1:
      function_name += '_with_{}'.format(
          _format_snake_case_op_name(quantized_ops[1]))
    if len(quantized_ops) > 1:
      for quantized_op in quantized_ops[2:]:
        function_name += '_and_{}'.format(

                                         StringRef function_name) const {
    // Disable quantization for the DepthwiseConv since it has no benefits in
    // the XLA opset.
    if (function_name.contains("depthwise_conv2d")) {
      return absl::InternalError(
          "DepthwiseConv2D doesn't get any benefit of quantization in XLA.");
    } else if (function_name.contains("conv2d")) {

    if (!op->hasAttr(kQuantTraitAttrName)) return failure();
    StringRef function_name = f_attr.getValue();
    // TODO(b/228928859): Improve the getter function to match attributes rather
    // than function name.
    if (!function_name.starts_with("composite_")) {
      return failure();
    }

    if (function_name.contains("depthwise_conv2d")) {

    R"pb(specs
         [ {
           matcher { function_name { regex: "composite_dot_general_.*" } }
           method { no_quantization {} }
         }])pb";

// Configure `QuantizationSpecs` to apply `StaticRangePtq` to all quantizable
// units.
constexpr absl::string_view kSpecsStaticRangePtqToAll =
    R"pb(specs
         [ {
           matcher { function_name { regex: ".*" } }
           method { static_range_ptq {} }

  EXPECT_EQ("", stacktrace_first_node_info.function_name);

  const auto& stacktrace_second_node_info = node_stack.at(1);
  EXPECT_EQ(kUncompilableFunctionNodeName, stacktrace_second_node_info.name);
  EXPECT_EQ(kUncompilableFunctionName,
            stacktrace_second_node_info.function_name);

  EXPECT_EQ(kUncompilableFunctionNodeName, node_info.name);
  EXPECT_TRUE(

    llvm::StringRef name = pass_registration.pass->name();

    if (DEBUG_DATA_DUMPER()->ShouldDump(function_name, kDebugGroupMain) ||
        VLOG_IS_ON(1)) {
      ::tensorflow::DumpMlirOpToFile(
          DEBUG_DATA_DUMPER()->GetDumpFilename(
              function_name, kDebugGroupMain,
              llvm::formatv("mlir_{0}_before", name)),
          *module_ref, llvm::StringRef(), nullptr);
    }

      }
    }

    StringRef function_name =
        mlir::cast<FlatSymbolRefAttr>(call_op.getFAttr()).getValue();
    if ((quantization_method_ == tensorflow::quantization::QuantizationMethod::
                                     METHOD_DYNAMIC_RANGE_INT8) &&
        (function_name.contains("batch_matmul") ||
         function_name.contains("conv3d"))) {
      call_op->removeAttr(kQuantTraitAttrName);

    llvm::StringRef function_name, llvm::ArrayRef<Tensor> arguments) {
  // Get the kernel entrypoint function.
  const Function* compute = bef_file_->GetFunction(function_name);
  CHECK(compute) << "Entrypoint function not found";
  CHECK_EQ(arguments.size() + 1, compute->num_arguments())
      << "Wrong number of arguments for function " << function_name.str();