feature_group_count = #vhlo.integer_v1<32 : i64>,
                                             input_batch_dimension = #vhlo.integer_v1<0 : i64>, 
                                             input_feature_dimension = #vhlo.integer_v1<3 : i64>,

            {static_cast<int64_t>(op->window_reversal.size())},
            op->window_reversal, builder)));
    attributes.emplace_back(builder.getNamedAttr(
        "input_batch_dimension",
        BuildVhloIntV1Attr(op->input_batch_dimension, builder)));
    attributes.emplace_back(builder.getNamedAttr(
        "input_feature_dimension",
        BuildVhloIntV1Attr(op->input_feature_dimension, builder)));

  // [b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f].

  tensorflow::UniformQuantizedConvolutionDimensionNumbersAttr dimension_numbers;
  if (!tensorflow::protobuf::TextFormat::ParseFromString(
          R"pb(
            input_batch_dimension: 0
            input_feature_dimension: 3
            input_spatial_dimensions: 1
            input_spatial_dimensions: 2
            kernel_output_feature_dimension: 3

func.func @convert_conv2d(%arg0: tensor<1x8x8x207xf32>, %arg1: tensor<3x3x207x16xf32>) -> tensor<1x8x8x16xf32> {
  %0 = "mhlo.convolution"(%arg0, %arg1) {batch_group_count = 1 : i64,
    dimension_numbers = #mhlo.conv<raw
      input_batch_dimension = 0,
      input_feature_dimension = 3,
      input_spatial_dimensions = [1, 2],
      kernel_input_feature_dimension = 2,
      kernel_output_feature_dimension = 3,
      kernel_spatial_dimensions = [0, 1],

    const ::tensorflow::UniformQuantizedConvolutionDimensionNumbersAttr
        &dnums_input) {
  xla::ConvolutionDimensionNumbers dnums;
  dnums.set_input_batch_dimension(dnums_input.input_batch_dimension());
  dnums.set_input_feature_dimension(dnums_input.input_feature_dimension());
  for (auto value : dnums_input.input_spatial_dimensions()) {
    dnums.add_input_spatial_dimensions(value);
  }

  strides : [long];
}

table StablehloConvolutionOptions{
  window_strides : [long];
  padding : [long];
  lhs_dilation : [long];
  rhs_dilation : [long];
  window_reversal : [bool];
  input_batch_dimension : long;
  input_feature_dimension : long;
  input_spatial_dimensions : [long];
  kernel_input_feature_dimension : long;
  kernel_output_feature_dimension : long;
  kernel_spatial_dimensions : [long];

  auto num_spatial_dims = input_tensor_dims.size() - 2;
  std::vector<int64_t> output_dims(input_tensor_dims.size());

  auto input_batch = input_tensor_dims[dnums.input_batch_dimension()];
  auto kernel_output_feature =
      kernel_tensor_dims[dnums.kernel_output_feature_dimension()];
  output_dims[dnums.output_batch_dimension()] = input_batch / batch_group_count;

    fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_REVERSAL, window_reversal);
  }
  void add_input_batch_dimension(int64_t input_batch_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_INPUT_BATCH_DIMENSION, input_batch_dimension, 0);
  }
  void add_input_feature_dimension(int64_t input_feature_dimension) {

        auto window_reversal = builder_.CreateVector(mlir::GetVector<bool>(
            mlir::cast<mlir::vhlo::TensorV1Attr>(vhlo_op.getWindowReversal()),
            vhlo_type_converter));
        auto input_batch_dimension = mlir::cast<mlir::vhlo::IntegerV1Attr>(
                                         vhlo_op.getInputBatchDimension())
                                         .getValue()

        rewriter.getDenseI64ArrayAttr(kOihwToHwioPermutation));

    // [b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]
    const auto new_dimension_nums = rewriter.getAttr<ConvDimensionNumbersAttr>(
        /*inputBatchDimension=*/0, /*inputFeatureDimension=*/3,
        /*inputSpatialDimensions=*/SmallVector<int64_t>{1, 2},
        /*kernelInputFeatureDimension=*/2, /*kernelOutputFeatureDimension=*/3,