DenseFPElementsAttr float_attr;
    if (matchPattern(value, m_Constant(&float_attr)) && float_attr.isSplat() &&
        float_attr.getSplatValue<APFloat>().isExactlyValue(raw_value))
      return true;
  } else if (mlir::isa<IntegerType>(element_type)) {
    DenseIntElementsAttr int_attr;
    if (matchPattern(value, m_Constant(&int_attr)) && int_attr.isSplat() &&
        int_attr.getSplatValue<APInt>() == raw_value)

  if (!(matchPattern(op.getWindowStrides(), m_Constant(&window_strides_attr)) &&
        matchPattern(op.getPadding(), m_Constant(&padding_attr)) &&
        matchPattern(op.getLhsDilation(), m_Constant(&lhs_dilation_attr)) &&
        matchPattern(op.getRhsDilation(), m_Constant(&rhs_dilation_attr)) &&
        matchPattern(op.getFeatureGroupCount(),
                     m_Constant(&feature_group_count_attr))))
    return success();

    if (!matchPattern(gather_nd_first.getIndices(), m_Constant(&indices)))
      return failure();
    int i = 0;
    for (const auto &axis_int : indices.getValues<APInt>()) {
      const int64_t axis = axis_int.getSExtValue();
      if (axis != i / 2) return failure();
      ++i;
    }
    if (!matchPattern(gather_nd_second.getIndices(), m_Constant(&indices)))
      return failure();
    i = 0;

  SmallVector<int32_t> initial_permutation;
  DenseElementsAttr perm1_const;

  SmallVector<int32_t> new_permutation;
  if (matchPattern(permutation1, m_Constant(&perm1_const))) {
    for (int32_t idx = 0; idx < perm1_const.getNumElements(); ++idx) {
      initial_permutation.push_back(idx);
    }
    for (auto perm : perm2_const.getValues<APInt>()) {

  LogicalResult matchAndRewrite(TFL::BatchMatMulOp bmm_op,
                                PatternRewriter& rewriter) const override {
    DenseElementsAttr constant;
    if (auto rhs = bmm_op.getY(); !matchPattern(rhs, m_Constant(&constant))) {
      // The constant may be preceded by QDQs in models with QDQ format, so we
      // should set it to the real constant.
      auto dq = dyn_cast_or_null<DequantizeOp>(rhs.getDefiningOp());

      id2.replaceAllUsesWith(id2.getInput());
      max = tf_op.getMax();
      rewriter.eraseOp(id2);
    }
    if (!matchPattern(min, m_Constant(&min_value))) return failure();
    if (!matchPattern(max, m_Constant(&max_value))) return failure();

    int quant_dim = -1;
    if (PerAxis) {
      // This is a special case that the quant_dim is the last dimensions

  // a dilated conv.
  auto stb_paddings = stb_op.getPaddings();
  auto bts_crops = bts_op.getCrops();
  ElementsAttr stb_paddings_attr, bts_crops_attr;
  if (!matchPattern(stb_paddings, m_Constant(&stb_paddings_attr)) ||
      !matchPattern(bts_crops, m_Constant(&bts_crops_attr))) {
    return rewriter.notifyMatchFailure(
        op,
        "either SpaceToBatchND or BatchToSpaceND "
        "doesn't have constant padding/crops value");
  }

    Location loc = cst_tensor_op.getLoc();
    Type out_type = cst_tensor_op.getType();
    Operation *new_cst = nullptr;

    ArrayAttr array;
    if (matchPattern(cst_tensor_op.getArg(), m_Constant(&array))) {
      llvm::DenseSet<Type> all_types;
      for (auto it : array) {
        TypedAttr typed_attr = it.dyn_cast<TypedAttr>();
        if (!typed_attr) return failure();

      min = min_id.getInput();
    }
    if (auto max_id = max.getDefiningOp<TF::IdentityOp>()) {
      max = max_id.getInput();
    }

    if (!matchPattern(min, m_Constant(&min_value))) {
      return false;
    }
    if (!matchPattern(max, m_Constant(&max_value))) {
      return false;
    }
    return true;  // Successfully matched and fetched.
  }
};

  ElementsAttr k;
  if (!matchPattern(tf_matrix_diag_v2_or_v3_op.getK(), m_Constant(&k)))
    return false;
  if (ExtractSingleElementAsInteger(k).getInt() != 0) return false;

  // Extract num_rows constant tensor and check value = -1.
  ElementsAttr num_rows;
  if (!matchPattern(tf_matrix_diag_v2_or_v3_op.getNumRows(),
                    m_Constant(&num_rows)))
    return false;