];
}

def IdentifyDilatedConvPass : Pass<"tfl-identify-dilated-conv", "mlir::func::FuncOp"> {
  let summary = "Convert dense tensor to sparse format.";
  let constructor = "CreateIdentifyDilatedConvPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
}

def GetArithmeticCountPass : Pass<"tfl-get-arithmetic-count", "mlir::func::FuncOp"> {
  let summary = "Calculate arithmetic count for tfl operations.";

// input and output types by unwrapping quantization parameters.
std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizePass();

// Overloading of CreateQuantizePass which takes QuantizationSpecs.
std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizePass(
    QuantizationSpecs quant_specs,
    tensorflow::quantization::OpSet target_opset);

// 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;

  for (func::FuncOp init_func_op : GetInitializerFunctions(module_op)) {
    if (failed(ValidateInitFunc(init_func_op))) {
      return failure();
    }

  constexpr StringRef kModuleOpStr =
      R"mlir(module attributes {tf_saved_model.semantics} {})mlir";

  Block block;
  ModuleOp module_op = ParseModuleOp(kModuleOpStr, block, ctx_);

  func::FuncOp init_func_op = GetInitializerFunction(
      module_op, /*initializer_type=*/kTfSavedModelInitializerInitType);

  EXPECT_THAT(init_func_op, IsNull());
}

TEST_F(TfSavedModelTest,

// back to the original representation using `ConvertBackward` function during
// deconstruction.
template <void (*ConvertForward)(func::FuncOp),
          void (*ConvertBackward)(func::FuncOp)>
class ScopedOpsConverter {
 public:
  explicit ScopedOpsConverter(func::FuncOp func) : func_(func) {
    ConvertForward(func_);
  }

  ScopedOpsConverter(const ScopedOpsConverter&) = delete;

      /*prefix=*/filename_arg, tensor_names_const, shape_and_slices_const,
      /*tensors=*/tensor_values);
}

// Creates and returns a new `FuncOp` named "tf_quant__save". The resulting
// `FuncOp`'s body has no ops.
func::FuncOp CreateEmptySaveFunc(ModuleOp module_op) {
  OpBuilder builder(module_op);
  builder.setInsertionPointToEnd(&module_op.getBodyRegion().front());

class ConvertMaxUnpoolingFunc {
 public:
  explicit ConvertMaxUnpoolingFunc(func::FuncOp func, mlir::TF::FuncAttr attr)
      : func_(func), attr_(attr) {}

  LogicalResult RewriteFunc();

  LogicalResult VerifySignature();

 private:
  LogicalResult CreateCustomOptions(std::string& custom_option_buffer);

  func::FuncOp func_;
  mlir::TF::FuncAttr attr_;
};

};

// Returns true iff func_op has either no Region or the body has no Blocks.
bool IsFuncOpEmpty(func::FuncOp func_op) {
  return func_op->getNumRegions() == 0 || func_op.getBody().empty();
}

// Gets the GraphOp from the function op. Returns an empty op iff it doesn't
// exist.
GraphOp GetGraphOpFromFuncOp(func::FuncOp func_op) {
  if (IsFuncOpEmpty(func_op)) return {};

  auto graph_op_range = func_op.front().without_terminator();

void EliminateUnusedResultsForIfCase(Operation *op,
                                     ArrayRef<func::FuncOp> branches) {
  // Clone branch functions if needed since we will be mutating them.
  SmallVector<func::FuncOp, 2> cloned_branches;
  cloned_branches.reserve(branches.size());
  for (func::FuncOp func : branches) {
    func::FuncOp cloned = CloneFunctionIfNeeded(func);
    cloned_branches.push_back(cloned);

// A subgraph may associate with 1...n FuncOp, and each FuncOp may correspond
// with different hardwares.
struct Subgraph {
  // The call can be thought as an "API".
  func::CallOp call;

  // available_choces can be viewed as "real implementation" assosicated with
  // the hardware.
  std::unordered_map<InferenceDeviceType, func::FuncOp,
                     InferenceDeviceType::inference_device_type_hash>