// CHECK: <{window_dimensions = array<i64: 1, 2, 2, 1>, window_strides = array<i64: 1, 2, 2, 1>}>
// CHECK: ^bb0(%[[REDUCE_ARG_0:.+]]: tensor<f32>, %[[REDUCE_ARG_1:.+]]: tensor<f32>):
// CHECK: %[[MAX:.+]] = stablehlo.maximum %[[REDUCE_ARG_0]], %[[REDUCE_ARG_1]]
// CHECK: stablehlo.return %[[MAX]]

// Check that the attributes window_dimensions & window_strides are also

    // CHECK: %[[REDUCE:.*]] = "stablehlo.reduce_window"(%[[CALL]], %[[Q0]])
    // CHECK{LITERAL}: padding = dense<[[0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<4x2xi64>
    // CHECK-SAME: window_dimensions = array<i64: 1, 3, 3, 1>
    // CHECK: %[[ARG1:.*]]: tensor<!quant.uniform<i8:f32, 3.000000e-01:1>>, %[[ARG2:.*]]: tensor<!quant.uniform<i8:f32, 3.000000e-01:1>>

    return true;
  if (op_name == "stablehlo.reduce_window" &&
      (field_name == "window_dimensions" || field_name == "window_strides" ||
       field_name == "base_dilations" || field_name == "window_dilations"))
    return true;
  if (op_name == "stablehlo.select_and_scatter" &&
      (field_name == "window_dimensions" || field_name == "window_strides"))
    return true;
  if (op_name == "stablehlo.slice" &&

    return;
  }
  if (const auto* op = op_union.AsStablehloReduceWindowOptions()) {
    if (!op->window_dimensions.empty()) {
      attributes.emplace_back(builder.getNamedAttr(
          "window_dimensions",
          BuildVhloTensorV1Attr(
              {static_cast<int64_t>(op->window_dimensions.size())},
              op->window_dimensions, builder)));
    }
    if (!op->window_strides.empty()) {

  %4 = "stablehlo.reduce_window"(%3, %5) ({  // max pool
  ^bb0(%arg1: tensor<f32>, %arg2: tensor<f32>):
      %6 = stablehlo.maximum %arg1, %arg2 : tensor<f32>
      stablehlo.return %6 : tensor<f32>
  }) {
    window_dimensions = array<i64: 1, 1, 2, 2>,
    window_strides = array<i64: 1, 1, 2, 2>
  } : (tensor<1x4x5x5xf32>, tensor<f32>) -> tensor<1x4x2x2xf32>
  return %4 : tensor<1x4x2x2xf32>
}

    mhlo.return %7 : tensor<f32>
  }) {window_dimensions = dense<[1, 1, 3, 3]> : tensor<4xi64>} : (tensor<1x3x6x6xf32>, tensor<f32>) -> tensor<1x3x4x4xf32>
  %4 = "mhlo.reduce_window"(%1, %2) ({
  ^bb0(%arg1: tensor<f32>, %arg2: tensor<f32>):
    %7 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %7 : tensor<f32>
  }) {window_dimensions = dense<3> : tensor<2xi64>} : (tensor<6x6xf32>, tensor<f32>) -> tensor<4x4xf32>

      CompileTimeConstantOperand<TF::XlaPadOp, 2, 3, 4>,
      // $window_dimensions, $window_strides, $base_dilations,
      // $window_dilations, $padding
      CompileTimeConstantOperand<TF::XlaReduceWindowOp, 2, 3, 4, 5, 6>,
      // $dim_index
      CompileTimeConstantOperand<TF::XlaRemoveDynamicDimensionSizeOp, 1>,
      // $window_dimensions, $window_strides, $padding

    auto new_reduce_window_op =
        rewriter.create<mlir::stablehlo::ReduceWindowOp>(
            op.getLoc(), new_result_type, transpose_op.getOperand(),
            /*init_value=*/op.getOperand(1),
            /*window_dimensions=*/
            PermuteI64ArrayAttr(rewriter, op.getWindowDimensions(),
                                kNchwToNhwcPermutation),
            /*window_strides=*/

        padding = #vhlo.tensor_v1<dense<[[0, 0], [159, 0], [0, 0]]> : tensor<3x2xi64>>,
        window_dilations = #vhlo.tensor_v1<dense<1> : tensor<3xi64>>,
        window_dimensions = #vhlo.tensor_v1<dense<[1, 160, 1]> : tensor<3xi64>>,
        window_strides = #vhlo.tensor_v1<dense<1> : tensor<3xi64>>}> ({
    ^bb0(%arg23: tensor<f32>, %arg24: tensor<f32>):

  rhs_batching_dimensions : [long];
  lhs_contracting_dimensions : [long];
  rhs_contracting_dimensions : [long];
  precision_config : [StablehloPrecisionConfig];
}

table StablehloReduceWindowOptions{
  window_dimensions : [long];
  window_strides : [long];
  base_dilations : [long];
  window_dilations : [long];
  padding : [long];
  body_subgraph_index : int;
}

table StablehloWhileOptions{