RankedTensorType::get({static_cast<int64_t>(array_attr.size())},
                            rewriter.getIntegerType(64)),
      array);
}

template <typename UniformQuantizedConvolutionOp>
FailureOr<ElementsAttr> ConvertPaddingAttr(
    UniformQuantizedConvolutionOp op,
    const xla::ConvolutionDimensionNumbers &dnums, PatternRewriter &rewriter) {
  StringAttr conv_padding = op.getPaddingAttr();
  SmallVector<int64_t> padding_nums;

namespace mlir::quant {

std::unique_ptr<OpQuantSpec> GetUniformOpQuantSpec(Operation* op) {
  auto spec = std::make_unique<OpQuantSpec>();
  if (isa<TF::UniformQuantizedConvolutionHybridOp>(op) ||
      isa<TF::UniformQuantizedConvolutionOp>(op)) {
    spec->coeff_op_quant_dim[1] = 3;
  } else if (isa<TF::UniformQuantizedDotHybridOp>(op)) {
    spec->coeff_op_quant_dim[1] = -1;
  }

  for (auto quantizable_operand : spec->coeff_op_quant_dim) {

      TF::UniformDequantizeOp,
      TF::UniformQuantizeOp,
      TF::UniformQuantizedAddOp,
      TF::UniformQuantizedClipByValueOp,
      TF::UniformQuantizedConvolutionHybridOp,
      TF::UniformQuantizedConvolutionOp,
      TF::UniformQuantizedDotHybridOp,
      TF::UniformQuantizedDotOp,
      TF::UniformRequantizeOp
      // go/keep-sorted end
      // clang-format on
      >(op);
}

              enable_per_channel_quantization)))
        return failure();
    } else if (auto uniform_op =
                   llvm::dyn_cast<TF::UniformQuantizedConvolutionOp>(inner_op);
               uniform_op != nullptr) {
      if (failed(FillAttributesForUniformQuantizedConvolutionOp(
              rewriter, uniform_op, identifier_to_attr, quantization_method,

}

//===----------------------------------------------------------------------===//
// UniformQuantizedConvolutionOp
//===----------------------------------------------------------------------===//
//

LogicalResult UniformQuantizedConvolutionOp::verify() {
  return VerifyLhsRhsBothUniformQuantizedOp(*this);
}