(LiftAsTFXlaCallModule<"composite_gather_fn">
    (ArgumentList $operand, $start_indices),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"dimension_numbers"> $dimension_numbers),
      (NamedAttr<"slice_sizes"> $slice_sizes),
      (NamedAttr<"indices_are_sorted"> (DefaultOrNullAttr $indices_are_sorted)))),

    %5 = stablehlo.reshape %4 : (tensor<100xi64>) -> tensor<100x1xi64>
    %6 = "stablehlo.scatter"(%arg0, %5, %arg3) ({
    ^bb0(%arg5: tensor<f32>, %arg6: tensor<f32>):
      stablehlo.return %arg6 : tensor<f32>

                                                         op->unique_indices)));
    attributes.emplace_back(builder.getNamedAttr(
        "indices_are_sorted",
        mlir::vhlo::BooleanV1Attr::get(builder.getContext(),
                                       op->indices_are_sorted)));
    attributes.emplace_back(builder.getNamedAttr(
        "index_vector_dim", BuildVhloIntV1Attr(op->index_vector_dim, builder)));
    return;
  }

    start_index_map = #vhlo.tensor_v1<dense<[1, 0]> : tensor<2xi64>>,
    index_vector_dim = #vhlo.integer_v1<2 : i64>,
    slice_sizes = #vhlo.tensor_v1<dense<[1, 2, 2]> : tensor<3xi64>>,
    indices_are_sorted = #vhlo.bool_v1<false>
  }> : (tensor<3x4x2xi32>, tensor<2x3x2xi64>) -> tensor<2x3x2x2xi32>
  return %result : tensor<2x3x2x2xi32>
}

                          $dimension_numbers, $indices_are_sorted),
          (MHLO_GatherOp $operand, $start_indices,
                        (ToGatherDimNumsAttr $dimension_numbers),
                        (CastElementsToI64Elements $slice_sizes),
                        $indices_are_sorted),
          [(HasValidGatherDims $dimension_numbers)]>;

            offset_dims = [2, 3],
            collapsed_slice_dims = [0],
            start_index_map = [1, 0],
            index_vector_dim = 2>,
          slice_sizes = array<i64: 1, 2, 2>,
          indices_are_sorted = false
        } : (tensor<3x4x2xf32>, tensor<2x3x2xi64>) -> tensor<2x3x2x2xf32>
        func.return %2 : tensor<2x3x2x2xf32>
      }
    }
  )mlir";

  %0 = "mhlo.gather"(%arg0, %arg1) {
    dimension_numbers = #mhlo.gather<
      collapsed_slice_dims = [0],
      index_vector_dim = 2,
			start_index_map = [0],
    >,
    indices_are_sorted = false,
    slice_sizes = dense<1> : tensor<1xi64>
  } : (tensor<147456xf16>, tensor<192x256x1xi32>) -> tensor<192x256xf16>
  func.return %0 : tensor<192x256xf16>
}

}

table StablehloGatherOptions{
  offset_dims : [long];
  collapsed_slice_dims : [long];
  start_index_map : [long];
  index_vector_dim : long;
  slice_sizes : [long];
  indices_are_sorted : bool;
}

table StablehloTransposeOptions{
  permutation : [long];
}

enum StablehloPrecisionConfig : uint {
  DEFAULT,
  HIGH,
  HIGHEST,
}

  // CHECK-SAME:   start_index_map = [0, 1]
  // CHECK-SAME:   index_vector_dim = 1
  // CHECK-SAME: indices_are_sorted = true
  // CHECK-SAME: slice_sizes = dense<[1, 1, 300]> : tensor<3xi64>

  %0 = "tf.XlaGather"(%arg0, %arg1, %cst) {dimension_numbers = "\0A\02\00\01\12\01\00\1A\02\00\01\20\01", indices_are_sorted = true} : (tensor<200x100x300xf32>, tensor<10x2xi32>, tensor<3xi64>) -> tensor<1x300x10xf32>

      offset_dims = [2, 3],
      collapsed_slice_dims = [0, 1],
      start_index_map = [0, 1],
      index_vector_dim = 2>,
    slice_sizes = array<i64: 1, 1, 2, 2>,
    indices_are_sorted = false
  } : (
    tensor<3x4x2x2x!quant.uniform<i8:f32, 3.000000e-01:-5>>,
    tensor<2x3x2xi64>
  ) -> tensor<2x3x2x2x!quant.uniform<i8:f32, 3.000000e-01:-5>>