// Get the tensors.
  DenseElementsAttr input_tensor, weights_tensor, bias_tensor;
  if (!matchPattern(getInput(), m_Constant(&input_tensor)) ||
      !matchPattern(getFilter(), m_Constant(&weights_tensor)) ||
      (has_bias && !matchPattern(getBias(), m_Constant(&bias_tensor)))) {
    return failure();
  }

  // Get the tensor types.

      matchPattern(op.getWindowDimensions(), m_Constant(&window_dimensions)) &&
      matchPattern(op.getWindowStrides(), m_Constant(&window_strides)) &&
      matchPattern(op.getBaseDilations(), m_Constant(&base_dilations)) &&
      matchPattern(op.getWindowDilations(), m_Constant(&window_dilations)) &&
      matchPattern(op.getPadding(), m_Constant(&padding))) {

LogicalResult QuantizedConstRewrite::matchAndRewrite(
    QuantizeCastOp qbarrier, PatternRewriter &rewriter) const {
  Attribute value;

  // Is the operand a constant?
  if (!matchPattern(qbarrier.getArg(), m_Constant(&value))) {
    return failure();
  }

  // Does the qbarrier convert to a quantized type. This will not be true
  // if a quantized type has not yet been chosen or if the cast to an equivalent

                            SmallVectorImpl<int64_t>& s0_shape,
                            SmallVectorImpl<int64_t>& s1_shape) {
  if (!matchPattern(op.getS0(), m_Constant(&s0))) return false;
  if (!matchPattern(op.getS1(), m_Constant(&s1))) return false;

  for (auto s : s0.getValues<APInt>()) s0_shape.push_back(s.getSExtValue());
  for (auto s : s1.getValues<APInt>()) s1_shape.push_back(s.getSExtValue());

    if (!begin_attr_type ||
        !matchPattern(begin_attr, m_Constant(&begin_elem_attr))) {
      return failure();
    }
    if (!end_attr_type || !matchPattern(end_attr, m_Constant(&end_elem_attr))) {
      return failure();
    }
    if (!strides_attr_type ||
        !matchPattern(strides_attr, m_Constant(&strides_elem_attr))) {
      return failure();
    }

  LogicalResult matchAndRewrite(mlir::stablehlo::UniformQuantizeOp op,
                                PatternRewriter& rewriter) const override {
    DenseFPElementsAttr attr;
    if (matchPattern(op.getOperand(), m_Constant(&attr))) {
      const Type qtype = op.getResult().getType();
      ElementsAttr quantized_attr = Quantize(attr, qtype);
      if (quantized_attr) {
        rewriter.replaceOpWithNewOp<mlir::stablehlo::ConstantOp>(

    ElementsAttr paddings;
    llvm::SmallVector<int64_t, 4> block_shape_ints;
    auto padded_shape = llvm::to_vector<4>(input_shape);
    if (matchPattern(op.getBlockShape(), m_Constant(&block_shape)) &&
        matchPattern(op.getPaddings(), m_Constant(&paddings))) {
      for (uint64_t i = 0; i < block_rank; i++) {
        int64_t paddings_sum =
            paddings.getValues<APInt>()[{i, 0}].getSExtValue() +

// data so that the iota dimension does not need to be the (inner) z-dimension.
bool MatchIotaConst(DenseIntElementsAttr dimensions, Value iota) {
  DenseIntElementsAttr iota_const_attr;
  if (!matchPattern(iota, m_Constant(&iota_const_attr))) return false;

  auto iota_type = iota_const_attr.getType();
  auto iota_shape = iota_type.getShape();
  auto reduce_dim = (*dimensions.value_begin<APInt>()).getSExtValue();

            op->getOperand(qi).getDefiningOp());
        if (!const_op) {
          continue;
        }

        DenseFPElementsAttr attr;
        if (!matchPattern(const_op->getResult(0), m_Constant(&attr))) {
          continue;
        }

        if (mlir::dyn_cast<DenseFPElementsAttr>(attr).size() >=
            quant_specs_.minimum_elements_for_weights) {
          continue;
        }

  DenseFPElementsAttr scales;
  if (!matchPattern(scales_value, m_Constant(&scales))) {
    return rewriter.notifyMatchFailure(op, "scales must be constant");
  }

  // Check whether the zero_points operand has constant op.
  DenseIntElementsAttr zero_points;
  if (!matchPattern(zero_points_value, m_Constant(&zero_points))) {
    return rewriter.notifyMatchFailure(op, "zero_points must be constant");
  }