SmallVector<int64_t, 4> permutation_array;
      for (int64_t i = 0; i < scatter_dims_to_operand_dims.size(); ++i) {
        permutation_array.push_back(scatter_dims_to_operand_dims[i]);
      }
      for (int64_t i = 0; i < operand_type.getRank(); ++i) {
        if (!llvm::is_contained(scatter_dims_to_operand_dims, i)) {
          permutation_array.push_back(i);
        }
      }

      stablehlo.return %arg6 : tensor<f32>
    }) {indices_are_sorted = false, scatter_dimension_numbers = #stablehlo.scatter<update_window_dims = [0, 2, 3], inserted_window_dims = [1], scatter_dims_to_operand_dims = [1], index_vector_dim = 1>, unique_indices = false} : (tensor<1x500x4x4xf32>, tensor<100x1xi64>, tensor<1x100x4x4xf32>) -> tensor<1x500x4x4xf32>
    %7 = "stablehlo.scatter"(%arg1, %5, %arg4) ({

            op->inserted_window_dims, builder)));
    attributes.emplace_back(builder.getNamedAttr(
        "scatter_dims_to_operand_dims",
        BuildVhloTensorV1Attr(
            {static_cast<int64_t>(op->scatter_dims_to_operand_dims.size())},
            op->scatter_dims_to_operand_dims, builder)));
    attributes.emplace_back(builder.getNamedAttr(

  %0 = "vhlo.scatter_v1" (%input_tensor, %scatter_indices, %updates) <{
    update_window_dims = #vhlo.tensor_v1<dense<1> : tensor<1xi64>>,
    inserted_window_dims = #vhlo.tensor_v1<dense<[0, 1]> : tensor<2xi64>>,
    scatter_dims_to_operand_dims = #vhlo.tensor_v1<dense<[0, 1]> : tensor<2xi64>>,
    index_vector_dim = #vhlo.integer_v1<1 : i64>,
    indices_are_sorted = #vhlo.bool_v1<true>,
    unique_indices = #vhlo.bool_v1<true>}> ({

// CHECK-SAME:          indices_are_sorted = false, scatter_dimension_numbers = #mhlo.scatter<update_window_dims = [1], inserted_window_dims = [0], scatter_dims_to_operand_dims = [0], index_vector_dim = 1>, unique_indices = false
// CHECK-SAME:      }> ({
// CHECK:           ^bb0(%[[VAL_4:.*]]: tensor<f32>, %[[VAL_5:.*]]: tensor<f32>):

  auto inserted_window_dims = builder_.CreateVector(inserted_window_dims_vec);
  auto scatter_dims_to_operand_dims =
      builder_.CreateVector(scatter_dims_to_operand_dims_vec);

  auto options = tflite::CreateStablehloScatterOptions(
      builder_, indices_are_sorted, update_window_dims, inserted_window_dims,
      scatter_dims_to_operand_dims, index_vector_dim, unique_indices,
      subgraph_index);

  precision_config : [StablehloPrecisionConfig];
}

table StablehloScatterOptions {
  indices_are_sorted: bool;
  update_window_dims: [long];
  inserted_window_dims: [long];
  scatter_dims_to_operand_dims: [long];
  index_vector_dim: long;
  unique_indices: bool;
  update_computation_subgraph_index: int;
}

enum RngAlgorithm : byte {

  // CHECK-SAME: indices_are_sorted = false
  // CHECK-SAME: scatter_dimension_numbers
  // CHECK-SAME:   inserted_window_dims = [0, 1]
  // CHECK-SAME:   scatter_dims_to_operand_dims = [0, 1]
  // CHECK-SAME:   index_vector_dim = 1
  // CHECK-SAME: unique_indices = false
  // CHECK-NEXT: ^bb0(%[[ARG3:.*]]: tensor<f32>, %[[ARG4:.*]]: tensor<f32>):

  // CHECK-SAME: indices_are_sorted = false,
  // CHECK-SAME: scatter_dimension_numbers =
  // CHECK-SAME:   update_window_dims = [2]
  // CHECK-SAME:   inserted_window_dims = [0]
  // CHECK-SAME:   scatter_dims_to_operand_dims = [0]
  // CHECK-SAME:   index_vector_dim = 2
  // CHECK-SAME: unique_indices = false
  // CHECK: ^{{.*}}([[LHS:%.*]]: tensor<f32>, [[RHS:%.*]]: tensor<f32>):

  { auto _e = scatter_dims_to_operand_dims(); if (_e) { _o->scatter_dims_to_operand_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scatter_dims_to_operand_dims[_i] = _e->Get(_i); } } else { _o->scatter_dims_to_operand_dims.resize(0); } }
  { auto _e = index_vector_dim(); _o->index_vector_dim = _e; }