std::unique_ptr<RE2> match_regex_;  // NOLINT
};

// Converts `Method` to a single-line textproto representation. Returns
// `failure()` when converting to textproto failed.
FailureOr<std::string> QuantizationMethodToTextProto(const Method& method) {
  TextFormat::Printer printer;
  printer.SetSingleLineMode(true);

  std::string method_txtpb;
  if (!printer.PrintToString(method, &method_txtpb)) {

        stack.push_back(called_func);
      }

      return WalkResult::advance();
    });
    if (result.wasInterrupted()) {
      return result;
    }
  }

  return WalkResult::advance();
}

FailureOr<OwningOpRef<ModuleOp>> CreatePrunedModule(
    ModuleOp module, llvm::ArrayRef<llvm::StringRef> function_names) {
  SymbolTableCollection symbol_table;
  OpBuilder builder(module.getContext());

		</postConstruct>
		<postConstruct name="addIndexConfig">
			<arg>"fess_config.elevate_word_to_label/elevate_word_to_label"</arg>
		</postConstruct>
		<postConstruct name="addIndexConfig">
			<arg>"fess_config.failure_url/failure_url"</arg>
		</postConstruct>
		<postConstruct name="addIndexConfig">
			<arg>"fess_config.file_authentication/file_authentication"</arg>
		</postConstruct>
		<postConstruct name="addIndexConfig">

        return IntegerType::get(type.getContext(), 16,
                                IntegerType::SignednessSemantics::Unsigned);
      })
      .Default([&type](Type) { return type; });
}

FailureOr<mlir::DenseElementsAttr> GetDenseAttrFromTensorProtoAttr(
    const llvm::StringRef mangled_tensor_proto, TensorType tensor_type) {
  ::tensorflow::TensorProto tensor_proto;

using quant::tensorflow::IsTFQintType;

#define GEN_PASS_DEF_CONVERTTFQUANTOPSTOMHLO
#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/bridge/passes.h.inc"

template <typename UniformQuantizedOp>
FailureOr<TensorType> GetUniformQuantizedType(
    UniformQuantizedOp op, Type original_type,
    TypedValue<TensorType> scales_value,
    TypedValue<TensorType> zero_points_value, FloatType expressed_type,

  SmallVector<NamedAttribute> new_arg_attrs =
      ReplaceBoundInputAttrWithIndexPathAttr(arg_attrs, index_path, builder);

  main_func_op.setArgAttrs(arg_idx, new_arg_attrs);
}

}  // namespace

FailureOr<SmallVector<AssetFileDef>> ConvertAssetArgs(ModuleOp module_op) {
  func::FuncOp main_func_op = FindMainFuncOp(module_op);
  if (!main_func_op) return failure();

    }
  )mlir";

  const OwningOpRef<ModuleOp> module_op =
      ParseModuleOpString(kXlaCallModuleOpWithPerTensorQuantizedConvolution);
  ASSERT_TRUE(module_op);

  const FailureOr<TF::XlaCallModuleOp> xla_call_module_op =
      FindFirstOpFromMainFunc<TF::XlaCallModuleOp>(*module_op);
  ASSERT_TRUE(succeeded(xla_call_module_op));

  const std::unique_ptr<OpQuantSpec> op_quant_spec =

// Returns initializer_type -> init_func_op mapping from the session_init_op's
// initializers. The initializer functions are validated for whether it can be
// moved to the main function. Returns failure() iff validation fails.
FailureOr<absl::flat_hash_map<std::string, func::FuncOp>> GetInitFuncOps(
    ModuleOp module_op) {
  absl::flat_hash_map<std::string, func::FuncOp> init_func_ops;

// naming conflicts. But we need to rename the function calls inside the
// stablehlo functions as well. So we first do this renaming in the stablehlo
// module itself without inserting into the tf module.
FailureOr<StringAttr> RenameStablehloFunctions(
    MLIRContext *context, SymbolTableCollection &symbol_tables,
    ModuleOp tf_module, ModuleOp stablehlo_module) {
  SymbolTable &tf_symbol_table = symbol_tables.getSymbolTable(tf_module);

      return %0 : tensor<1x1x4xf32>
    }
  )mlir";

  const OwningOpRef<ModuleOp> module_op =
      ParseModuleOpString(kXlaCallModuleOpWithQuantizationMethodAttr);
  ASSERT_TRUE(module_op);

  FailureOr<TF::XlaCallModuleOp> xla_call_module_op =
      FindFirstOpFromMainFunc<TF::XlaCallModuleOp>(*module_op);
  ASSERT_TRUE(succeeded(xla_call_module_op));