mlir::ModuleOp module_op = getOperation();
    mlir::PassManager pm(ctx);

    pm.addPass(CreateNoOpPass());

    EnableIrPrinting(pm, "dump2");

    if (failed(pm.run(module_op))) {
      signalPassFailure();
    }
  }
};

std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> CreateParentPass() {
  return std::make_unique<ParentPass>();
}

}  // namespace mlir_dump_test

namespace {

  auto *ctx = func.getContext();
  patterns.add<ConstFakeQuantRewrite, ConstFakeQuantPerAxisRewrite>(
      ctx, &hadFailure);
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
  if (hadFailure) signalPassFailure();
}

std::unique_ptr<OperationPass<func::FuncOp>> createConvertSimulatedQuantPass() {
  return std::make_unique<ConvertSimulatedQuantPass>();
}

    if (failed(GetReads(func, replicate, reads)))
      return WalkResult::interrupt();
    MoveReads(replicate, reads);
    return WalkResult::advance();
  });

  if (result.wasInterrupted()) return signalPassFailure();
}

}  // namespace

std::unique_ptr<OperationPass<FuncOp>> CreateHoistBroadcastReadPass() {
  return std::make_unique<HoistBroadcastRead>();
}

}  // namespace internal

  ModuleOp module_op = getOperation();

  if (failed(RenameExistingMainFunction(module_op))) {
    module_op->emitError("Failed to rename existing function `@main`.");
    signalPassFailure();
  }

  if (!CreateMainFunction(module_op)) {
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateInsertMainFunctionPass() {
  return std::make_unique<InsertMainFunctionPass>();
}

  // module level.
  for (auto func : module_op.getOps<func::FuncOp>()) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-propagate-quantize-type failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

// Creates an instance of the TensorFlow dialect PropagateQuantizeType pass.
std::unique_ptr<OperationPass<ModuleOp>> CreatePropagateQuantizeTypePass() {

    for (auto& op : bb) {
      if (failed(DuplicateValueIfNeeded(&op, &stateful_values, &builder))) {
        func.emitError() << "Failed to duplicate values for the stateful op\n";
        return signalPassFailure();
      }
    }
  }
}

}  // namespace

/// Creates an instance of the TensorFlow Lite dialect SplitMergedOperands
/// pass.

};

void PartitionedTopologicalSortPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!PartitionedTopologicalSort(func, &func.getBody().front(), partition_)) {
    return signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreatePartitionedTopologicalSortPass() {
  return std::make_unique<PartitionedTopologicalSortPass>();
}

    solver.load<dataflow::DeadCodeAnalysis>();
    solver.load<dataflow::SparseConstantPropagation>();
    TF::LoadResourceDataflowAnalysis(solver);
    if (failed(solver.initializeAndRun(module))) return signalPassFailure();

    SymbolTable symbol_table(module);

    OpBuilder globalBuilder(module.getBodyRegion());

    module.walk([&](TF::ReadVariableOp op) {
      Operation* source = GetHandleSource(op, solver);

  patterns.add<RewriteNchwConvolutionToNhwc>(&ctx);

  if (failed(applyPatternsAndFoldGreedily(func_op, std::move(patterns)))) {
    func_op.emitError() << "Failed to run NchwConvolutionToNhwcPass.";
    signalPassFailure();
  }
}

  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    func.emitError() << "quant-add-quantization-unit-loc pattern "
                        "conversion did not converge.";
    signalPassFailure();
  }
}

}  // namespace

// Creates an instance of `AddQuantizationUnitLocPass`.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateAddQuantizationUnitLocPass() {