if (!input_type || !output_type ||
        get_num_elements(input_type) <= get_num_elements(output_type)) {
      return failure();
    }
    Type input_element_type = getElementTypeOrSelf(dequantize_op.getInput());
    // Most passthrough ops do not support F16.
    if (input_element_type.isF16()) {
      return failure();
    }

    // Set the output type of the dequantize op and push it down.

  LogicalResult match(stablehlo::UniformQuantizeOp op) const override {
    const Type input_element_type = GetElementType(op.getOperand());
    if (!(input_element_type.isa<FloatType>() ||
          IsI32F32UniformQuantizedType(input_element_type) ||
          IsI32F32UniformQuantizedPerAxisType(input_element_type))) {
      LLVM_DEBUG(llvm::dbgs() << "Uniform quantize op's input should be a "

      return failure();
    }

    if (Type input_element_type = input_value_type.getElementType();
        !mlir::isa<FloatType>(input_element_type)) {
      LLVM_DEBUG(llvm::dbgs()
                 << "Failed to match @uniform_quantize function call pattern. "
                    "Input value's element type must be a float. Got: "
                 << input_element_type << ".\n");
      return failure();
    }

    // Convert if we need to enlarge the element type's bitwidth to avoid
    // precision loss.
    Type input_element_type = input_type.getElementType();

    // TODO(hinsu): Handle complex element types.
    if (!input_element_type.isIntOrFloat()) return failure();

    Type sum_element_type = GetSumAccumulationType(input_element_type);
    input = rewriter.create<ConvertOp>(op.getLoc(), input, sum_element_type);

    for (const auto &dim : dense_elem_attr.getValues<APInt>()) {
      output_shape.push_back(dim.getSExtValue());
    }

    // First unpack the input tensor along the first dimension.
    Type input_element_type = getElementTypeOrSelf(input);
    int64_t num_unpacked = 0;
    if (auto type = input.getType().dyn_cast<RankedTensorType>()) {
      if (type.getDimSize(0) > 0) {
        num_unpacked = type.getDimSize(0);

  // int and float in the verifier
  if (input_type.hasStaticShape() && output_type.hasStaticShape() &&
      input_element_type.isIntOrFloat() && output_element_type.isIntOrFloat()) {
    const auto input_element_type_bitwidth =
        input_element_type.getIntOrFloatBitWidth();
    const auto output_element_type_bitwidth =
        output_element_type.getIntOrFloatBitWidth();

  auto output_type = op.getOutput().getType().cast<ShapedType>();

  auto input_element_type = input_type.getElementType();
  auto output_element_type = output_type.getElementType();

  if (input_type.hasStaticShape()) {
    const int input_element_type_bitwidth = GetTypeBitWidth(input_element_type);
    const int output_element_type_bitwidth =
        GetTypeBitWidth(output_element_type);

    auto loc = op.getLoc();
    auto result_ty = mlir::cast<ShapedType>(op.getType());

    auto input = op.getImages();
    auto input_ty = mlir::cast<ShapedType>(input.getType());
    auto input_element_ty = input_ty.getElementType();
    auto out_size = op.getSize();
    auto out_size_ty = mlir::cast<ShapedType>(out_size.getType());
    auto out_size_element_ty = out_size_ty.getElementType();