// changes which violates the constraint for the TransposeOp that the
// input's and output's element type should be the same.
DenseIntElementsAttr TransposeFilterInConvolution(
    Location loc, PatternRewriter& rewriter,
    const DenseIntElementsAttr& filter_value_attr, const bool is_depthwise) {
  ArrayRef<int64_t> filter_shape = filter_value_attr.getShapedType().getShape();

  RankedTensorType type =
      mlir::dyn_cast_or_null<RankedTensorType>(input.getType());
  if (!type) return false;

  DenseIntElementsAttr axes_attr =
      mlir::dyn_cast_or_null<DenseIntElementsAttr>(axes);
  DenseIntElementsAttr shape_attr =
      mlir::dyn_cast_or_null<DenseIntElementsAttr>(shape);
  if (!axes_attr || !shape_attr) return false;

  if (shape_attr.getNumElements() != type.getRank()) return false;

    auto start_attr = rewriter.create<TF::ConstOp>(
        value.getLoc(),
        DenseIntElementsAttr::get(
            RankedTensorType::get({static_cast<int64_t>(start.size())},
                                  rewriter.getI64Type()),
            start));
    auto size_attr = rewriter.create<TF::ConstOp>(
        value.getLoc(),
        DenseIntElementsAttr::get(
            RankedTensorType::get({static_cast<int64_t>(size.size())},

        {}, getElementTypeOrSelf(axis_attr));
    DenseIntElementsAttr attr;
    if (axis_type.getElementType().isInteger(32)) {
      attr = DenseIntElementsAttr::get(axis_type, static_cast<int32_t>(axis));
    } else {
      assert(axis_type.getElementType().isInteger(64));
      attr = DenseIntElementsAttr::get(axis_type, axis);
    }
    auto axis_const = rewriter.create<TF::ConstOp>(loc, attr);

                    Value limit, Value delta) {
  assert(start.getType() == limit.getType());
  assert(start.getType() == delta.getType());
  DenseIntElementsAttr start_val;
  DenseIntElementsAttr limit_val;
  DenseIntElementsAttr delta_val;
  if (matchPattern(start, m_Constant(&start_val)) &&
      matchPattern(limit, m_Constant(&limit_val)) &&
      matchPattern(delta, m_Constant(&delta_val))) {

  // Begin has to be all 0s.
  DenseIntElementsAttr begin_dense_elem_attr;
  if (!matchPattern(getBegin(), m_Constant(&begin_dense_elem_attr))) {
    return {};
  }
  for (auto begin_ele : begin_dense_elem_attr) {
    if (begin_ele.getSExtValue() != 0) {
      return {};
    }
  }

  // Strides has to be all 1s.
  DenseIntElementsAttr strides_dense_elem_attr;

    return false;

  DenseIntElementsAttr slice_sizes_attr;
  if (DenseIntElementsAttr attr;
      matchPattern(op.getSliceSizes(), m_Constant(&attr))) {
    slice_sizes_attr = attr;
  } else if (const auto it = results_.find(ValuePort(op.getSliceSizes()));
             it != results_.end() &&
             llvm::isa_and_nonnull<DenseIntElementsAttr>(it->second)) {