// `stablehlo.maximum`, representing max pooling.
class DeferActivationTransposeForMaxPoolReduceWindowOp
    : public OpRewritePattern<mlir::stablehlo::ReduceWindowOp> {
 public:
  using OpRewritePattern<mlir::stablehlo::ReduceWindowOp>::OpRewritePattern;

  LogicalResult match(mlir::stablehlo::ReduceWindowOp op) const override {
    if (failed(MatchMaxPoolReduceWindowOp(op))) return failure();

// Transform reduce_window(transpose(x)) to transpose(reduce_window(x))
struct TransposeCommuteWithReduceWindow
    : public OpRewritePattern<stablehlo::ReduceWindowOp> {
  using OpRewritePattern<stablehlo::ReduceWindowOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(stablehlo::ReduceWindowOp reduce_op,
                                PatternRewriter& rewriter) const override {
    MLIRContext* ctx = reduce_op.getContext();

                mlir::stablehlo::DynamicReshapeOp,
                mlir::stablehlo::DynamicSliceOp, mlir::stablehlo::GatherOp,
                mlir::stablehlo::PadOp, mlir::stablehlo::ReduceWindowOp,
                mlir::stablehlo::ReshapeOp, mlir::stablehlo::SelectOp,
                mlir::stablehlo::SliceOp, mlir::stablehlo::TransposeOp>(op)) {
    scale_spec->has_same_scale_requirement = true;
  }

          !IsConnectedWithQuantizedCompsiteFunction(candidate_op)) {
        return failure();
      }

      // Ops with regions will be quantized in a separate pattern.
      if (isa<mlir::stablehlo::ReduceWindowOp>(candidate_op)) {
        return failure();
      }

      const bool weight_only_quantizable =
          IsWeightOnlyQuantizableOp(*candidate_op);

  }
};

// A helper function for ConvertMaxPoolOp and ConvertAvgPoolOp. Returns true
// if the given ReduceWindowOp is a spatial pooling without dilation. If returns
// true, also outputs the window strides and the TF padding mode ("VALID" or
// "SAME").
bool IsSpatialPoolingWithoutDilation(
    mhlo::ReduceWindowOp rw, llvm::SmallVectorImpl<int64_t>* window_strides,
    std::string* padding_mode, std::string* data_format) {

      // computations, compared to the `xla::AvgPoolGrad` implementation, by
      // subtracting the original exterior padding before `ReduceWindowOp`
      // instead of trimming the result of `ReduceWindowOp` (the final result is
      // the same because all strides are 1).
      low_padding[dim] =
          conv_grad_spatial_dim.pad_before - orig_padding[dim].first;

  }
};

// Rewrites quantized stablehlo.reduce_window with max to tfl.max_pool_2d.
class RewriteQuantizedReduceWindowOpWithMax
    : public OpRewritePattern<stablehlo::ReduceWindowOp> {
 public:
  using OpRewritePattern<stablehlo::ReduceWindowOp>::OpRewritePattern;

  LogicalResult MatchBinaryReduceFunction(Region& function) const {
    Block& body = function.front();
    if (body.getNumArguments() != 2) return failure();

      return failure();
    }

    for (Operation* op_with_region : op.getResult().getUsers()) {
      // Among the ops with regions, only reduce_window op is supported for now.
      if (!isa<mlir::stablehlo::ReduceWindowOp>(op_with_region)) {
        return failure();
      }

      if (!IsNestedRegionQuantizable(op_with_region)) {
        return failure();
      }

      const std::vector<int32_t>& operands,
      const std::vector<int32_t>& results);

  std::optional<BufferOffset<tflite::Operator>> BuildStablehloReduceWindowOp(
      mlir::stablehlo::ReduceWindowOp reduce_window_op,
      const std::vector<int32_t>& operands,
      const std::vector<int32_t>& results);

  std::optional<BufferOffset<tflite::Operator>> BuildStablehloRngBitGeneratorOp(