int padding_after = padding_before + offset;
      padding_values[2 * i] = padding_before;
      padding_values[2 * i + 1] = padding_after;
    }
  }

  if (input_zp_value == 0 ||
      absl::c_all_of(padding_values, [](int v) { return v == 0; })) {
    padding = CreateConstValue<int32_t>(
        builder, loc, {num_dims - 2, 2},
        SmallVector<int32_t>(padding_values.begin() + 2,

}

ShapedType GetPadOpType(CompositeOp op) {
  const TorchAvgPoolData pool = GetTorchAvgPoolData(op);

  const auto padding_values = GetPadOpPaddingValues(pool);
  const int64_t h = pool.h_in + padding_values[0] + padding_values[1];
  const int64_t w = pool.w_in + padding_values[2] + padding_values[3];
  llvm::SmallVector<int64_t> shape = {pool.n, h, w, pool.c};

    if (!padding_attr) {
      return {0, 0, 0, 0};
    }

    auto padding_values = padding_attr.getValues<int64_t>();
    // Padding has [[h_low, h_high], [w_low, w_high]] format.
    // https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution.
    return {padding_values[0], padding_values[1], padding_values[2],
            padding_values[3]};
  }

  // Returns the input and output dimensions, respectively.

      auto get_int = [](Attribute attr) {
        return mlir::cast<IntegerAttr>(attr).getInt();
      };

      SmallVector<int32_t> padding_values(padding_attr_array.size());
      for (int i = 0; i < padding_attr_array.size(); i++) {
        padding_values[i] =
            static_cast<int32_t>(get_int(padding_attr_array[i]));
      }

      RankedTensorType padding_attr_type = tensorflow::GetTypeFromTFTensorShape(

              /*align_corners=*/true, lhs_dilation_values[0], padding_values[0],
              window_strides_values[0], input_sizes[0], output_sizes[0])) {
        align_corners = true;
        return success();
      }
      if (can_convert_to_bilinear(
              /*align_corners=*/false, lhs_dilation_values[0],
              padding_values[0], window_strides_values[0], input_sizes[0],
              output_sizes[0])) {

    Type i64 = rewriter.getI64Type();
    RankedTensorType paddings_ty = RankedTensorType::get({1, 2}, i64);
    std::vector<int64_t> paddings_values = {0, pad};
    Value paddings = rewriter.create<ConstOp>(
        loc, DenseIntElementsAttr::get(paddings_ty, paddings_values));
    Value output = rewriter.create<PadOp>(loc, op_type, state, paddings);

    rewriter.replaceOp(op, output);
    return success();
  }
};

      CompileTimeConstantOperand<TF::ListDiffOp, 0, 1>,  // $x, $y
      // $k, $padding_value
      CompileTimeConstantOperand<TF::MatrixDiagPartV3Op, 1, 2>,
      // $k, $num_rows, $num_cols, $padding_value
      CompileTimeConstantOperand<TF::MatrixDiagV2Op, 1, 2, 3, 4>,
      // $k, $num_rows, $num_cols, $padding_value
      CompileTimeConstantOperand<TF::MatrixDiagV3Op, 1, 2, 3, 4>,

  // Verify padding_value is a tensor with all 0s.
  mlir::Value padding_value = tf_matrix_diag_v2_or_v3_op.getPaddingValue();
  mlir::Type element_type =
      mlir::cast<ShapedType>(padding_value.getType()).getElementType();
  if (mlir::isa<FloatType>(element_type)) {
    DenseFPElementsAttr padding_attr;
    if (!matchPattern(padding_value, m_Constant(&padding_attr)) ||

  auto padding_type =
      RankedTensorType::get({4, 2}, builder->getIntegerType(32));
  auto paddings = DenseIntElementsAttr::get(padding_type, values);
  auto paddings_value = builder->create<TF::ConstOp>(filter.getLoc(), paddings);
  std::vector<int64_t> pad_shape = {filter_shape[0] + pad_h,
                                    filter_shape[1] + pad_w, filter_shape[2],

  }
  SetOpAttrValueScalar(ctx, op, i_list_values, "ksize", status);
  SetOpAttrValueScalar(ctx, op, i_list_values, "strides", status);

  tensorflow::AttrValue padding_value;
  *padding_value.mutable_s() = "VALID";
  tensorflow::SetOpAttrValueScalar(ctx, op, padding_value, "padding", status);

  tensorflow::AttrValue data_format_value;
  *data_format_value.mutable_s() = "NHWC";