// ConstOp path.
    auto type = mlir::cast<ShapedType>(const_op.getType()).getElementType();
    if (!type.isInteger(32) && !type.isInteger(64)) return false;
  } else {
    // QConstOp path.
    auto qconst_op = dyn_cast<TFL::QConstOp>(op);
    auto type =
        quant::QuantizedType::getQuantizedElementType(qconst_op.getType());
    if (type.getStorageTypeIntegralWidth() != 32) {
      return false;
    }
  }

  }

  void rewrite(stablehlo::AddOp op, PatternRewriter& rewriter) const override {
    TFL::QConstOp lhs_qconst_op;
    TFL::QConstOp rhs_qconst_op;

    auto GetBroadcastedConstOp = [&](Value operand) -> TFL::QConstOp {
      if (auto broadcast_op = dyn_cast_or_null<stablehlo::BroadcastInDimOp>(
              operand.getDefiningOp())) {

  func.walk([&](Operation* op) {
    // TODO(renjieliu): Find a generic way to deal with const ops.
    if (op->hasTrait<OpTrait::IsTerminator>() ||
        llvm::isa<TFL::QConstOp, TFL::ConstOp>(op) ||
        llvm::isa<TFL::QConstOp, TFL::ConstOp, TF::ConstOp, ConstOp>(op))
      return;

    bool int8_type_observed = false;
    bool uint8_type_observed = false;
    for (auto& input : op->getOpOperands()) {

        supported_block_size = sparse_op.GetFloatBlockSize();
        type = mlir::cast<ShapedType>(dyn_cast<ConstOp>(inst).getType());
      } else if (isa<QConstOp>(inst)) {
        supported_block_size = sparse_op.GetQuantizedBlockSize();
        type = mlir::cast<ShapedType>(dyn_cast<QConstOp>(inst).getType());
        ratio_threshold = kBlockOverRandomSparsityRatioQuant;
      } else {
        continue;
      }

  LogicalResult matchAndRewrite(TransposeOp op,
                                PatternRewriter& rewriter) const override {
    Operation* def_op = op.getInput().getDefiningOp();
    auto qconst_op = llvm::dyn_cast_or_null<QConstOp>(def_op);
    if (qconst_op == nullptr) return failure();

    DenseIntElementsAttr perm_tensor;
    if (!matchPattern(op.getPerm(), m_Constant(&perm_tensor))) return failure();

  if (!op) return false;
  if (llvm::isa<arith::ConstantOp, mlir::func::ConstantOp>(op)) return false;
  if (op->hasTrait<OpTrait::ConstantLike>()) return false;
  if (llvm::isa<TFL::ConstOp, TFL::QConstOp>(op)) return false;
  return true;
}

// Returns true if 'op' is a terminator op, otherwise false.
bool IsTerminatorOp(Operation* op);

// Returns true if 'op' is not TFL Quant / Dequant op. Returns False otherwise

    // We can only clone the constant op or const->dequantize combo. The latter
    // case is useful for float16 quantization. Since all ops have been
    // legalized to tflite ops, so we only care about ConstOp or QConstOp or
    // mlir constant op.
    Operation* input_op = operand.getDefiningOp();
    if (input_op == nullptr) return failure();

    Attribute attr;
    if (matchPattern(input_op, m_Constant(&attr))) {

namespace TFL {
namespace common {

bool IsConstantOrNone(Operation* op) {
  return (op->getNumResults() == 1 &&
          mlir::isa<NoneType>(op->getResult(0).getType())) ||
         matchPattern(op, m_Constant()) || isa<QConstOp>(op);
}

// Pre-order traverse, adding results and BlockArgs to `been_defined` and
// collecting operands not contained within `been_defined`. If we encounter an

namespace tflite {
namespace {

bool IsConst(mlir::Operation* op) {
  return llvm::isa<mlir::arith::ConstantOp, mlir::TF::ConstOp,
                   mlir::TFL::ConstOp, mlir::TFL::QConstOp>(op);
}

bool IsOpSupported(mlir::Operation* op, const std::string& hardware) {
  auto* devce_hardware = mlir::TFL::tac::GetTargetHardware(hardware);
  if (devce_hardware == nullptr) return {};

inline bool IsNonArithmeticOp(mlir::Operation* op) {
  if (llvm::isa<func::ReturnOp, func::FuncOp>(op)) return true;
  if (op->hasTrait<OpTrait::ConstantLike>()) return true;
  if (llvm::isa<QConstOp, SparseQConstOp>(op)) return true;
  if (!NotTFLQuantDequantizeOp(op)) return true;
  return false;
}

}  // namespace

bool TargetHardware::Init() {