auto module = getOperation();
  const auto& resource_alias_analysis =
      getAnalysis<TF::ResourceAliasAnalysis>();

  llvm::SmallDenseMap<func::FuncOp, PerFunctionResult, 4> per_function_results;
  llvm::SetVector<func::FuncOp> worklist;
  for (auto func_op : module.getOps<func::FuncOp>()) {
    worklist.insert(func_op);
    per_function_results.try_emplace(
        func_op, func_op, resource_alias_analysis.GetAnalysisForFunc(func_op));

  MLIRContext* ctx = &getContext();
  func::FuncOp func = getOperation();

  if (failed(
          ConvertFakeQuantOps(func, ctx, /*use_fake_quant_num_bits=*/false))) {
    func.emitError() << "quant-convert-fake-quant-to-qdq pass failed.";
    signalPassFailure();
  }

  // For removing dead FakeQuant* ops
  RewritePatternSet patterns(ctx);
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {

  func::FuncOp init_function =
      SymbolTable::lookupNearestSymbolFrom<func::FuncOp>(
          generator_op, generator_op.getInitFunc());
  func::FuncOp next_function =
      SymbolTable::lookupNearestSymbolFrom<func::FuncOp>(
          generator_op, generator_op.getNextFunc());
  func::FuncOp finalize_function =
      SymbolTable::lookupNearestSymbolFrom<func::FuncOp>(

    for (Operation* op : filtered_ops) {
      auto func = cast<func::FuncOp>(op);
      func.emitRemark() << llvm::formatv("filtered by tac filter ({0})", count);
    }
    return;
  }

  DenseMap<func::FuncOp, SmallVector<Operation*>> func_to_filtered_ops_map;
  for (Operation* op : filtered_ops) {
    auto func = op->getParentOfType<func::FuncOp>();
    func_to_filtered_ops_map[func].push_back(op);
  }

    runOnOperation() {
  ModuleOp module_op = getOperation();

  func::FuncOp main_func = FindMainFuncOp(module_op);
  if (!main_func) return;

  // In case the model has tf.StatefulPartitionedCallOp or tf.PartitionedCallOp,
  // we recursively find called functions and process StableHLO ops in them.
  SmallVector<func::FuncOp> func_ops;
  func_ops.push_back(main_func);
  int stablehlo_func_id = -1;

    for (StringRef name : llvm::reverse(exported_names)) {
      // Create a "trampoline" function with the given name. So given
      //   func bar(...) {exported_names = ["foo"]}
      // we create
      //   func foo(...) {
      //     return bar(...)
      //   }
      func::FuncOp other = f.cloneWithoutRegions();
      other.setName(name);
      SetExportedName(other, name);
      module_body.push_front(other);

      }
    });
  }
};
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateSimpleTFDeviceAssignmentPass(
    llvm::StringRef default_device) {
  return std::make_unique<SimpleTFDeviceAssignmentPass>(default_device);
}

std::unique_ptr<OperationPass<func::FuncOp>>
CreateTFDeviceAssignmentByFuncAttrPass() {
  return std::make_unique<TFDeviceAssignmentByFuncAttrPass>();
}

// is "restore_op". Creates and returns a new initializer function iff such
// `FuncOp` is not found. The newly created initializer function's
// initializer_type is "restore_op" and its symbol will be added to the symbol
// table and session_initializer op's "intializer" attribute.
func::FuncOp GetOrCreateInitializerFunc(ModuleOp module_op) {
  if (auto init_func_op = GetInitializerFunction(

# CHECK-DAG: func private @custom_embedding_matmul{{[0-9]*}}(){{.+}}tf._implements = #tf_type.func<@tensorflow.embedding_matmul, {key1 = 2 : i64, key2 = false}>, tf._original_func_name = "custom_embedding_matmul"}...

namespace mlir {
namespace TFL {
namespace {

template <int NInput, int NOutput>
func::FuncOp createMaxUnpoolingFunc(
    mlir::Builder* builder, const SmallVector<mlir::Type, NInput>& input_types,
    const SmallVector<mlir::Type, NOutput>& output_types) {
  auto func_type = builder->getFunctionType(input_types, output_types);
  auto func = func::FuncOp::create(
      mlir::NameLoc::get(builder->getStringAttr("fused_func")), "fused_func",