// portion of the pipeline on just the single submodule.
absl::Status RunClusteringPipelineOnSubmodule(
    ModuleOp parent_module, bool is_in_fallback_enabled_mode) {
  int num_submodules = 0;
  absl::Status clustering_pipeline_status;
  parent_module.walk([&](ModuleOp submodule) {
    if (submodule == parent_module) return mlir::WalkResult::advance();
    num_submodules++;

using ::tensorflow::kImportModelDefaultGraphFuncName;

class MergeSaveFunctionOpsToMainPass
    : public PassWrapper<MergeSaveFunctionOpsToMainPass,
                         OperationPass<ModuleOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MergeSaveFunctionOpsToMainPass)

  explicit MergeSaveFunctionOpsToMainPass() = default;

  StringRef getArgument() const override {

}

// Testing ConvertMlirModuleToExportedModel requires parsing MLIR string to
// ModuleOp.
using ConvertMlirModuleToExportedModelTest =
    ::mlir::quant::QuantizationTestBase;

TEST_F(ConvertMlirModuleToExportedModelTest, SimpleGraphDefSet) {
  // Define a module a no-op main function.
  mlir::OwningOpRef<mlir::ModuleOp> module_op = ParseModuleOpString(R"mlir(
    module attributes {tf_saved_model.semantics} {

#include "mlir/Tools/mlir-translate/Translation.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/lite/flatbuffer_import.h"

namespace tensorflow {
namespace {
static mlir::OwningOpRef<mlir::ModuleOp> FlatBufferFileToMlirTranslation(
    llvm::SourceMgr* source_mgr, mlir::MLIRContext* context) {
  const llvm::MemoryBuffer* input =
      source_mgr->getMemoryBuffer(source_mgr->getMainFileID());
  std::string error;

  ];
}

def StripNoinlineAttributePass : Pass<"tf-strip-noinline-attribute", "ModuleOp"> {
  let summary = "Strip the tf._noinline attribute from top-level functions.";
  let constructor = "TF::CreateStripNoinlineAttributePass()";
}

def ExecutorConvertControlToDataOutputsPass : Pass<"tf-executor-convert-control-to-data-outputs", "ModuleOp"> {
  let summary = "Chain control outputs of while loop body";

  let description = [{

static constexpr char kArbitraryDeviceName[] = "XLA_CPU_JIT";

namespace {
inline absl::string_view StringRefToView(llvm::StringRef ref) {
  return {ref.data(), ref.size()};
}
}  // namespace

static OwningOpRef<mlir::ModuleOp> GraphdefToMlirTranslateFunction(
    llvm::StringRef input, MLIRContext* context) {
  tensorflow::GraphdefToMlirOptions options{
      debug_info_file,        xla_compile_device_type,

using ::tensorflow::quantization::RunPasses;

PostCalibrationComponent::PostCalibrationComponent(
    absl::Nonnull<MLIRContext*> ctx)
    : ctx_(ABSL_DIE_IF_NULL(ctx)) {}  // Crash OK

absl::StatusOr<ModuleOp> PostCalibrationComponent::Run(
    ModuleOp module_op, const QuantizationConfig& config) {
  TF_RETURN_IF_ERROR(RunPasses(
      kName, /*add_passes_func=*/
      [&config](PassManager& pm) {

    };
    return dump_attributes;
  }

  StringAttr DuplicateFunction(Operation *op,
                               const FlatSymbolRefAttr &f_attr) const {
    ModuleOp module = op->getParentOfType<ModuleOp>();
    SymbolTable symbol_table(module);

    const func::FuncOp ref_func =
        dyn_cast_or_null<func::FuncOp>(symbol_table.lookup(f_attr.getValue()));

          absl::StrCat("Failed to parse input MLIR model: ", error_message));
    }

    llvm::SourceMgr source_mgr;
    source_mgr.AddNewSourceBuffer(std::move(file), llvm::SMLoc());
    auto module = parseSourceFile<ModuleOp>(source_mgr, context);
    if (module->getOperation() == nullptr) {
      return absl::AbortedError("Failed to parse input MLIR model.");
    }

    return quant::stablehlo::ImportedMlirModuleOp(std::move(module), nullptr);

    const llvm::SmallVector<int64_t>& expected_packed_shape,
    const llvm::SmallVector<int8_t>& expected_packed_values) {
  MLIRContext context;
  OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
  OpBuilder builder(&module->getBodyRegion());
  context.loadDialect<TF::TensorFlowDialect>();

  Value value = CreateConstValue<int8_t>(builder, module->getLoc(),