%split_dim_0 = arith.constant dense<0> : tensor<i32>
  %0, %1 = "tfl.split"(%split_dim_0, %arg0) {num_splits = 2 : i32} : (tensor<i32>, tensor<16x4xf32>) -> (tensor<8x4xf32>, tensor<8x4xf32>)
  %split_dim_1 = arith.constant dense<1> : tensor<i32>

  // TODO(renjieliu): change to use split_dim when we raise the constants
  // as well.
  int64_t split_dim = -1;
  for (int64_t d = 0; d < input_type.getRank(); ++d) {
    if (input_type.getDimSize(d) != output_type.getDimSize(d)) split_dim = d;
  }

  const SmallVector<Value, 4>& slice_outputs = SliceOutputs(
      split_op, input, input_type, split_dim, num_splits, &rewriter);

  if (!input_type) return success();

  int64_t split_dim = split_dim_opt.value();
  const int64_t rank = input_type.getRank();
  if (split_dim < 0) split_dim += rank;
  if (split_dim < 0 || split_dim >= rank)
    return op.emitOpError("'split_dim' should be in [-rank, rank)");

  // If the 'split_dim' dimension of the 'input' tensor has a dynamic size,
  // there are no other checks.

  let description = [{
    Splits the `value` tensor along `split_dim` into a number of sub-tensors
    with same shape as the original one, except for `split_dim`. Same as
    tf.Split.
  }];

  let arguments = (ins
    TFL_TensorOf<[I32]>:$split_dim,
    TFL_TensorOf<[F32, I16, I32, I8, UI8, QI8, QUI8, QI16]>:$value,
    ConfinedAttr<I32Attr, [IntPositive]>:$num_splits

template <class Op>
LogicalResult VerifySplitInputAndSplitDim(Op op,
                                          std::optional<int64_t> *dim_index) {
  *dim_index = std::nullopt;

  Value split_dim = op.getSplitDim();
  if (auto split_dim_type = split_dim.getType().dyn_cast<RankedTensorType>())
    if (split_dim_type.getRank() != 0)
      return op.emitOpError(
          "split dimension should be an integer scalar tensor");

// -----

// CHECK-LABEL: @split_not_match_dynamic_split_dim_input
func.func @split_not_match_dynamic_split_dim_input(%input: tensor<4x4xf32>, %split_dim: tensor<i32>) -> (tensor<*xf32>, tensor<*xf32>) {
  // CHECK: tf.Split
  %0:2 = "tf.Split"(%split_dim, %input) : (tensor<i32>, tensor<4x4xf32>) -> (tensor<*xf32>, tensor<*xf32>)
  func.return %0#0, %0#1 : tensor<*xf32>, tensor<*xf32>
}

// -----

              Eq(BuiltinOperator_SPLIT));
  EXPECT_THAT(GetBuiltinCode(model_.operator_codes[add->opcode_index].get()),
              Eq(BuiltinOperator_ADD));

  // There should be 5 tensors: input, output, split, split/split_dim, split:1.
  // Tensor indices could be different between original and quantized.
  EXPECT_THAT(subgraph->tensors, SizeIs(5));
  const int input_idx = 0;
  EXPECT_THAT(subgraph->tensors[input_idx]->type, Eq(TensorType_INT8));

//
// For example, given the following IR:
//
// %split_sizes = "tf.Const"() {value = dense<[1, -1, 3]> : tensor<3xi32>}
// %split_dim = "tf.Const"() {value = dense<1> : tensor<i32>}
// %0:3 = "tf.SplitV"(%input, %split_sizes, %split_dim) :
//                   (tensor<4x6xf32>, tensor<3xi32>, tensor<i32>) ->
//                   (tensor<4x1xf32>, tensor<4x2xf32>, tensor<4x3xf32>)
//

`[-rank(value), rank(value))`.}]>:$split_dim,
    Arg<TF_Tensor, [{The tensor to split.}]>:$value
  );

  let results = (outs
    Res<Variadic<TF_Tensor>, [{They are identically shaped tensors, whose shape matches that of `value`
except along `axis`, where their sizes are
`values.shape[split_dim] / num_split`.}]>:$output
  );

`seq_dim` becomes `seq_axis` * `tf.sparse_concat`: `concat_dim` becomes `axis` *
`tf.sparse_reduce_sum`: `reduction_axes` becomes `axis` *
`tf.sparse_reduce_sum_sparse`: `reduction_axes` becomes `axis` *
`tf.sparse_split`: `split_dim` becomes `axis` * `tf.listdiff` has been renamed
to `tf.setdiff1d` to match NumPy naming. * `tf.inv` has been renamed to be
`tf.reciprocal` (component-wise reciprocal) to avoid confusion with `np.inv`