"Conv2D op doesn't have valid padding");
  }
  // Make sure dilations are all ones if set.
  const ArrayAttr& dilations =
      op->template getAttrOfType<ArrayAttr>("dilations");
  if (dilations && !TFIntListIsAllOnes(dilations)) {
    return rewriter.notifyMatchFailure(op, "dilations should be all 1");
  }

  if (!TFL::TFTypeIsFloat32Tensor(op.getInput()) &&

    // Constructs dilation array.
    SmallVector<int64_t, 4> dilation;
    if (auto rhs_dilation = conv_op.getRhsDilation()) {
      // For example, [2, 3] -> [1, 2, 3, 1].
      dilation.emplace_back(1);
      dilation.append(rhs_dilation.value().getValues<int64_t>().begin(),
                      rhs_dilation.value().getValues<int64_t>().end());
      dilation.emplace_back(1);
    } else {

      const int64_t dim = GetTensorSpatialDimIndex(num_dims, data_format, i);
      spatial_dim_indices.push_back(dim);

      const int64_t dilation = get_int(dilations[dim]);
      rhs_dilations.push_back(dilation);
      const int64_t stride = get_int(strides[dim]);
      window_strides.push_back(stride);

      Value pad_low, pad_high;

  IntegerAttr dilation_depth_factor, dilation_height_factor,
      dilation_width_factor;
  if (!TFIntListIs1XYZ1(op, "dilations", &dilation_depth_factor,
                        &dilation_height_factor, &dilation_width_factor)) {
    // If the 'dilations' attribute is missing, we use the default value (1)
    // for all dilation depth, height and width factor.
    dilation_depth_factor = rewriter.getI32IntegerAttr(1);

    // Only 2d pooling is supported in TFLite.
    if (op.getWindowDimensions().size() != 4) {
      return failure();
    }

    // reduce_window op with dilations or padding will supported later.
    // TODO: b/321099943 - Support reduce_window op with dilations and padding.
    if (op.getBaseDilations().has_value() ||
        op.getWindowDilations().has_value() || op.getPadding().has_value()) {
      return failure();
    }

    state.stride_height = height;
    state.stride_width = width;

    if (TFIntListIs1XY1(op, "dilations", &height, &width)) {
      state.dilation_height_factor = height;
      state.dilation_width_factor = width;
    } else {
      // If the 'dilations' attribute is missing, we use the default value (1)
      // for both dilation height and width factor.
      state.dilation_height_factor = intAttrOne;

        verify_size(window_strides.size(), "window strides") &&
        verify_size(padding.size(), "padding entries") &&
        verify_size(lhs_dilation.size(), "lhs dilation factors") &&
        verify_size(rhs_dilation.size(), "rhs dilation factors")))
    return std::nullopt;

  xla::Window window;
  for (size_t i = 0; i < window_dimensions.size(); i++) {
    auto dim = window.add_dimensions();

      },
      {
          'testcase_name': 'dilation',
          'activation_fn': None,
          'has_bias': False,
          'has_batch_norm': False,
          'target_opset': quant_opts_pb2.TF,
          'input_shape_dynamic': False,
          'enable_per_channel_quantization': False,
          'dilations': [1, 2, 2, 1],
      },
      {
          'testcase_name': 'relu',

                              llvm::StringMap<Attribute>& identifier_to_attr) {
  ArrayAttr dilations =
      mlir::dyn_cast<ArrayAttr>(identifier_to_attr["dilations"]);
  const int dilation_h = mlir::cast<IntegerAttr>(dilations[1]).getInt();
  const int dilation_w = mlir::cast<IntegerAttr>(dilations[2]).getInt();
  return rewriter.getI64ArrayAttr({dilation_h, dilation_w});
}

Attribute GetPaddingValue(PatternRewriter& rewriter,

      int dilation_i = mlir::cast<IntegerAttr>(dilations[i]).getInt();
      int out_size = tflite::ComputeOutSize(kTfLitePaddingSame, input_size,
                                            filter_size, stride_i, dilation_i);

      int offset = 0;
      int padding_before = tflite::ComputePaddingWithOffset(
          stride_i, dilation_i, input_size, filter_size, out_size, &offset);