};
    DenseI64ArrayAttr new_window_dimensions =
        getInvertPermutedAttr(reduce_op.getWindowDimensions());
    DenseI64ArrayAttr new_window_strides =
        getInvertPermutedAttr(reduce_op.getWindowStrides());
    DenseI64ArrayAttr new_base_dilations =
        getInvertPermutedAttr(reduce_op.getBaseDilations());
    DenseI64ArrayAttr new_win_dilations =
        getInvertPermutedAttr(reduce_op.getWindowDilations());

  const uint64_t rank = rw.getWindowDimensions().size();
  if (rank <= 3 || rank > 5) return false;

  if (rw.getWindowStrides().has_value()) {
    window_strides->insert(window_strides->end(),
                           rw.getWindowStrides()->getValues<int64_t>().begin(),
                           rw.getWindowStrides()->getValues<int64_t>().end());
  } else {
    window_strides->resize(rank, 1);
  }

            PermuteI64ArrayAttr(rewriter, op.getWindowDimensions(),
                                kNchwToNhwcPermutation),
            /*window_strides=*/
            PermuteI64ArrayAttr(rewriter, op.getWindowStrides(),
                                kNchwToNhwcPermutation),
            /*base_dilations=*/
            PermuteI64ArrayAttr(rewriter, op.getBaseDilations(),
                                kNchwToNhwcPermutation),

  // Returns the stride amount for the height and width, respectively.
  std::pair<int64_t, int64_t> GetStrides(stablehlo::ConvolutionOp op) const {
    std::optional<ArrayRef<int64_t>> window_strides_attr =
        op.getWindowStrides();
    if (!window_strides_attr.has_value()) {
      return {1, 1};  // Default values.
    }

    auto window_strides_attr_value = window_strides_attr.value();

    SmallVector<Type> result_types{op.getResult().getType()};
    ReplaceTfOpWithNewOp<TF::XlaConvV2Op>(
        rewriter, op, op.getResult().getType(), op.getLhs(), op.getRhs(),
        op.getWindowStrides(), op.getPadding(), op.getLhsDilation(),
        op.getRhsDilation(), op.getFeatureGroupCount(),
        op.getDimensionNumbers(), op.getPrecisionConfig(), 1);
    return ::mlir::success();
  };
};

      window_dilations, padding;
  if (input_ty.hasStaticShape() &&
      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)) &&

  auto window_dimensions =
      builder_.CreateVector(std::vector<int64_t>(wd.begin(), wd.end()));
  auto window_strides = builder_.CreateVector(
      mlir::GetOptionalVector<int64_t>(reduce_window_op.getWindowStrides()));
  auto base_dilations = builder_.CreateVector(
      mlir::GetOptionalVector<int64_t>(reduce_window_op.getBaseDilations()));
  auto window_dilations = builder_.CreateVector(

        window_dilations, padding;
    if (!(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)) &&