}
      auto output_shape =
          mlir::cast<RankedTensorType>(conv_op.getResult().getType())
              .getShape();
      SmallVector<int64_t, 4> transposed_output_shape = {
          output_shape[dnums.getOutputBatchDimension()],
          output_shape[dnums.getOutputSpatialDimensions().data()[0]],
          output_shape[dnums.getOutputSpatialDimensions().data()[1]],

      mlir::cast<ShapedType>(input.getType()).getShape();
  ArrayRef<int64_t> output_shape =
      mlir::cast<ShapedType>(output.getType()).getShape();

  int64_t agg_value = 1;
  for (size_t i = agg_start_idx; i < input_shape.size() - 1; ++i) {
    agg_value *= input_shape[i];
  }

  return (agg_value == output_shape[agg_start_idx]);
}

// Returns whether the given type `a` is broadcast-compatible with `b`.

                    )
                ]
            )
        )
        self.assertTrue(
            self._contains_op(
                output_graphdef,
                'Const',
                '_output_shapes',
                per_channel_size_attr,
            )
        )
    elif target_opset == quant_opts_pb2.UNIFORM_QUANTIZED:
      self.assertTrue(

                .getScale(),
            /*filter_scales=*/filter_quantized_type.getScales());
        const ArrayRef<int64_t> output_shape =
            op->getResult(0).getType().cast<TensorType>().getShape();
        const SmallVector<int64_t, 1> bias_shape = {
            output_shape[output_shape.size() - 1]};
        // `tfl.fully_connected`'s `GetChannelDimIndex` is 0.
        const auto bias_quantized_type =

  let summary = "Transpose convolution operator";

  let description = [{
    Performs transpose convolution operation on input.
  }];

  let arguments = (ins
    TFL_I32Tensor:$output_shape,
    TFL_TensorOf<[F32, QI8, QUI8, QI16]>:$weights,
    TFL_TensorOf<[F32, QI8, QUI8, QI16]>:$input,
    TFL_TensorOfOrNone<[F32, QI32, I64]>:$bias,
    TFL_PaddingAttr:$padding,

                    IsWithinInt32Range);

    if (elements_all_in_int32_range) {
      std::vector<int32_t> output_shape(output_ty.getRank());
      std::transform(output_ty.getShape().begin(), output_ty.getShape().end(),
                     output_shape.begin(),
                     [](int64_t val) { return static_cast<int32_t>(val); });
      output_int_type = tensorflow::GetTypeFromTFTensorShape(