};

void DenseToSparsePass::runOnOperation() {
  func::FuncOp func = getOperation();
  OpBuilder builder(func);

  func.walk([&](SparseOpInterface sparse_op) {
    const auto& sparse_operands = sparse_op.GetSparseOperands();
    std::vector<std::vector<int>> supported_block_size;
    for (int operand : sparse_operands) {
      auto* op = sparse_op.getOperation();
      auto value = op->getOperand(operand);

    StringRef attr_name = attr.getName().getValue();
    if (attr_name.starts_with("tf_saved_model.")) {
      func->removeAttr(attr_name);
    }
  }

  auto iface = cast<FunctionOpInterface>(func.getOperation());
  for (int i = 0; i < func.getNumArguments(); ++i) {
    for (auto& attr : iface.getArgAttrs(i)) {
      const StringAttr& attr_name = attr.getName();
      if (attr_name.getValue().starts_with("tf_saved_model.")) {

        args_to_erase.set(i);
      }
    }
    func.eraseArguments(args_to_erase);
  }
}

void OptimizeGlobalTensorsPass::runOnOperation() {
  auto module = getOperation();
  if (!tf_saved_model::HasTfSavedModelSemantics(module)) {
    return;
  }

  EraseUnusedBoundInputs(module);

  TF::ResourceAnalyzer resource_analyzer(module);

        q_op, q_op.getResult().getType(), q_op.getArg());
    return success();
  }
};

void PostQuantizePass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  func::FuncOp func = getOperation();
  MLIRContext* ctx = func.getContext();
  // TODO: b/307463853 - Consider splitting passes for each pattern set.
  patterns.add<FoldTrivalRequantizeOp<quantfork::QuantizeCastOp>,

      InsertCalibrationStatisticsSaverPassBase;

 private:
  void runOnOperation() override;
};

void InsertCalibrationStatisticsSaverPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext& ctx = getContext();

  std::unordered_set<std::string> aggregator_ops_to_ignore(
      aggregator_ops_to_ignore_.begin(), aggregator_ops_to_ignore_.end());

  ParentPass() = default;

  llvm::StringRef getArgument() const final { return "parent-pass"; }

  void runOnOperation() override {
    mlir::MLIRContext* ctx = &getContext();
    mlir::ModuleOp module_op = getOperation();
    mlir::PassManager pm(ctx);

    pm.addPass(CreateNoOpPass());

    EnableIrPrinting(pm, "dump2");

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

          LegalizeCompositeToCustomOpPass> {
  using LegalizeCompositeToCustomOpPassBase::
      LegalizeCompositeToCustomOpPassBase;

  void runOnOperation() override {
    func::FuncOp fn = getOperation();

    int num_layers = 0, current_layer_index = 0;
    // First walk the function to count number of KV Caches.
    fn.walk([&](Operation* op) {
      auto composite = llvm::dyn_cast<stablehlo::CompositeOp>(op);

      return failure();
    }
  }
  return success();
}

void SplitMergedOperandsPass::runOnOperation() {
  llvm::DenseSet<Value> stateful_values;
  auto func = getOperation();
  OpBuilder builder(func);
  for (auto& bb : func.getBody()) {
    for (auto& op : bb) {
      if (failed(DuplicateValueIfNeeded(&op, &stateful_values, &builder))) {

  AssetSinkingPass() = default;

  explicit AssetSinkingPass(llvm::StringRef saved_model_dir) {
    saved_model_dir_ = saved_model_dir.str();
  }

  void runOnOperation() override {
    ModuleOp module = getOperation();
    if (!HasTfSavedModelSemantics(module)) {
      return;
    }

    auto init_op = GetSessionInitializerOp(module);
    if (init_op == nullptr || init_op.getInitializers().empty()) {
      return;
    }

      }
      changed = true;
    }
    return changed ? success() : failure();
  }
};

void PropagateQuantizeType::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto module_op = getOperation();
  MLIRContext* ctx = &getContext();

  patterns.add<PropagateDequantizeOpIfAllowed>(ctx);
  FrozenRewritePatternSet frozen_patterns(std::move(patterns));