%indices = "tf.Const"() {value = dense<[1, 2]> : tensor<2xi32>} : () -> tensor<2xi32>
  %gather = "tf.TensorArrayGatherV3"(%ta#0, %indices, %ta#1) : (tensor<!tf_type.resource>, tensor<2xi32>, tensor<f32>) -> tensor<2x3xf32>
  func.return %gather : tensor<2x3xf32>
}

// -----

// Test inferring shape from the element_shape attribute of gather.

// CHECK-LABEL: func @main
func.func @main() -> tensor<*xf32> {

      : quant_options_(quant_options), test_mode_(false) {}

  LiftQuantizableSpotsAsFunctionsPass(
      const LiftQuantizableSpotsAsFunctionsPass& other) {
    quant_options_ = other.quant_options_;
    test_mode_ = other.test_mode_;
    op_set_ = other.op_set_;
    initializeForTest();
  }

  StringRef getArgument() const final {
    // This is the argument used to refer to the pass in

// CHECK: stablehlo.gather
// CHECK-NOT: tfl.gather_nd
// CHECK-NOT: tfl.gather

// -----

// Tests that a float `stablehlo.gather` is not converted to `tfl.gather_nd`.

func.func @gather_float(%arg0: tensor<3x4x2x2xf32>, %arg1: tensor<2x3x2xi64>) -> tensor<2x3x2x2xf32> {
  %0 = "stablehlo.gather"(%arg0, %arg1) {
    dimension_numbers = #stablehlo.gather<
      offset_dims = [2, 3],

  ) -> Tuple[core.Tensor, core.Tensor]:
    """Creates a basic gather model.

    This is intended to be used for TF1 (graph mode) tests.

    Args:
      input_type: type of the input index tensor for gather operation.
      use_variable_for_filter: Setting this to `True` makes the filter for the
        gather operation a `tf.Variable`.

    Returns:
      in_placeholder: Input tensor placeholder.

        if self.same_scale_op == 'concatenate':
          ones = array_ops.ones_like(out)
          out = array_ops.concat([out, ones], 0)
        elif self.same_scale_op == 'gather':
          out = array_ops.gather(out, indices=[0], axis=0)
        elif self.same_scale_op == 'max_pool':
          out = nn_ops.max_pool(out, ksize=3, strides=1, padding='SAME')
        elif self.same_scale_op == 'pad':

  }

  LiftQuantizableSpotsAsFunctionsDRQPass(
      const LiftQuantizableSpotsAsFunctionsDRQPass& other) {
    quantization_method_ = other.quantization_method_;
    target_opset_ = other.target_opset_;
    min_num_elements_for_weights_ = other.min_num_elements_for_weights_;
  }

  StringRef getArgument() const final {
    // This is the argument used to refer to the pass in

  if [[ ${attempt} -gt 0 ]]; then
    sleep 15
  fi
  attempt=$((attempt+1))

  # The "kubectl get nodes -o template" exports node information.
  #
  # Echo the output and gather 2 counts:
  #  - Total number of nodes.
  #  - Number of "ready" nodes.
  #
  # Suppress errors from kubectl output because during cluster bootstrapping

      // Other edges might have `dst` as dst node. Update those edges with
      // `replace_node`.
      for (int j = i + 1, end = data_edges.size(); j < end; j++) {
        if (data_edges[j].dst == dst) {
          data_edges[j].dst = replace_node;
        }
      }

      // Other placeholder node might have `dst` as original node. Update

    "FakeQuantWithMinMaxVars",
    "FakeQuantWithMinMaxVarsGradient",
    "FakeQuantWithMinMaxVarsPerChannel",
    "FakeQuantWithMinMaxVarsPerChannelGradient",
    "Fill",
    "Fingerprint",
    "Gather",
    "GuaranteeConst",
    "Identity",
    "IdentityN",
    "InplaceAdd",
    "InplaceSub",
    "InplaceUpdate",
    "InvertPermutation",
    "ListDiff",
    "MatrixBandPart",
    "MatrixDiag",

#
# Package c imports package a, and uses cgo itself.
# The generation of the _cgo_import.go for package c will fail,
# because it won't know that it has to link against a/libb.a
# (because we don't gather the #cgo LDFLAGS from all transitively
# imported packages).
#
# The _cgo_import.go file is only needed for internal linking.
# When generating _cgo_import.go for package c fails, an ordinary