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

        "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)));
    attributes.emplace_back(builder.getNamedAttr(
        "kernel_output_feature_dimension",
        BuildVhloIntV1Attr(op->kernel_output_feature_dimension, builder)));

            input_feature_dimension: 3
            input_spatial_dimensions: 1
            input_spatial_dimensions: 2
            kernel_output_feature_dimension: 3
            kernel_input_feature_dimension: 2
            kernel_spatial_dimensions: 0
            kernel_spatial_dimensions: 1
            output_batch_dimension: 0
            output_feature_dimension: 3
            output_spatial_dimensions: 1

    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,
      output_feature_dimension = 3,
      output_spatial_dimensions = [1, 2]

            .getDimSize(input_feature_dimension);
    const int kernel_input_feature_dimension =
        dnums.getKernelInputFeatureDimension();
    const int kernel_input_channels =
        mlir::cast<ShapedType>(conv_op.getRhs().getType())
            .getDimSize(kernel_input_feature_dimension);
    const int64_t feature_group_count = conv_op.getFeatureGroupCount();

  for (auto value : dnums_input.input_spatial_dimensions()) {
    dnums.add_input_spatial_dimensions(value);
  }
  dnums.set_kernel_input_feature_dimension(
      dnums_input.kernel_input_feature_dimension());
  dnums.set_kernel_output_feature_dimension(
      dnums_input.kernel_output_feature_dimension());
  for (auto value : dnums_input.kernel_spatial_dimensions()) {
    dnums.add_kernel_spatial_dimensions(value);

  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;
  output_feature_dimension : long;
  output_spatial_dimensions	: [long];

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

  }
  void add_kernel_input_feature_dimension(int64_t kernel_input_feature_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_KERNEL_INPUT_FEATURE_DIMENSION, kernel_input_feature_dimension, 0);
  }
  void add_kernel_output_feature_dimension(int64_t kernel_output_feature_dimension) {

  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 =
      kernel_tensor_shape[dnums.kernel_output_feature_dimension()];

  if (feature_group_count_val <= 0) {
    return op.emitOpError()