const int input_feature_dimension = dnums.getInputFeatureDimension();
    const int kernel_input_feature_dimension =
        dnums.getKernelInputFeatureDimension();
    const int input_channels =
        mlir::cast<ShapedType>(conv_op.getLhs().getType())
            .getDimSize(input_feature_dimension);
    const int kernel_input_channels =

                                             input_batch_dimension = #vhlo.integer_v1<0 : i64>, 
                                             input_feature_dimension = #vhlo.integer_v1<3 : i64>,
                                             input_spatial_dimensions = #vhlo.tensor_v1<dense<[1, 2]> : tensor<2xi64>>,

        "input_batch_dimension",
        BuildVhloIntV1Attr(op->input_batch_dimension, builder)));
    attributes.emplace_back(builder.getNamedAttr(
        "input_feature_dimension",
        BuildVhloIntV1Attr(op->input_feature_dimension, builder)));
    attributes.emplace_back(builder.getNamedAttr(
        "kernel_input_feature_dimension",
        BuildVhloIntV1Attr(op->kernel_input_feature_dimension, builder)));

  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
            kernel_input_feature_dimension: 2

  %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],
      output_batch_dimension = 0,

        &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);
  }
  dnums.set_kernel_input_feature_dimension(

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];
  output_batch_dimension : long;

                                         vhlo_op.getInputBatchDimension())
                                         .getValue()
                                         .getSExtValue();
        auto input_feature_dimension = mlir::cast<mlir::vhlo::IntegerV1Attr>(
                                           vhlo_op.getInputFeatureDimension())
                                           .getValue()

    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_INPUT_BATCH_DIMENSION, input_batch_dimension, 0);
  }
  void add_input_feature_dimension(int64_t input_feature_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_INPUT_FEATURE_DIMENSION, input_feature_dimension, 0);
  }
  void add_input_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> input_spatial_dimensions) {

    return success();
  }

  auto feature_group_count_val =
      feature_group_count_attr.getValues<IntegerAttr>()[0].getInt();
  auto input_features = input_tensor_shape[dnums.input_feature_dimension()];
  auto input_batch = input_tensor_shape[dnums.input_batch_dimension()];
  auto kernel_input_features =
      kernel_tensor_shape[dnums.kernel_input_feature_dimension()];
  auto kernel_output_features =