}

func.func @argmax(%arg0: tensor<3xi32>, %arg1: tensor<i32>) -> tensor<i32> {
  %0 = "tf.ArgMax"(%arg0, %arg1) : (tensor<3xi32>, tensor<i32>) -> tensor<i32>
  func.return %0 : tensor<i32>

// CHECK-LABEL: argmax
// CHECK:  "tfl.arg_max"(%arg0, %arg1) : (tensor<3xi32>, tensor<i32>) -> tensor<i32>
}

    int oneBased = ~~(index + 1); // for GWT
    checkState(oneBased > 0, "negative index");
    return (oneBased & EVEN_POWERS_OF_TWO) > (oneBased & ODD_POWERS_OF_TWO);
  }

  /**
   * Returns {@code true} if the MinMax heap structure holds. This is only used in testing.
   *
   * <p>TODO(kevinb): move to the test class?
   */
  @VisibleForTesting
  boolean isIntact() {
    for (int i = 1; i < size; i++) {

	SIGIOINT    = syscall.Signal(0x10)
	SIGIOT      = syscall.Signal(0x6)
	SIGKAP      = syscall.Signal(0x3c)
	SIGKILL     = syscall.Signal(0x9)
	SIGLOST     = syscall.Signal(0x6)
	SIGMAX      = syscall.Signal(0x3f)
	SIGMAX32    = syscall.Signal(0x3f)
	SIGMIGRATE  = syscall.Signal(0x23)
	SIGMSG      = syscall.Signal(0x1b)
	SIGPIPE     = syscall.Signal(0xd)
	SIGPOLL     = syscall.Signal(0x17)

	SHADD:     "SHADD",
	SHL:       "SHL",
	SHLL:      "SHLL",
	SHLL2:     "SHLL2",
	SHRN:      "SHRN",
	SHRN2:     "SHRN2",
	SHSUB:     "SHSUB",
	SLI:       "SLI",
	SMADDL:    "SMADDL",
	SMAX:      "SMAX",
	SMAXP:     "SMAXP",
	SMAXV:     "SMAXV",
	SMC:       "SMC",
	SMIN:      "SMIN",
	SMINP:     "SMINP",
	SMINV:     "SMINV",
	SMLAL:     "SMLAL",
	SMLAL2:    "SMLAL2",
	SMLSL:     "SMLSL",

    {"RED",
     {"All", "Any", "Min", "Max", "Mean", "Prod", "Sum"}},
          // clang-format on
          {"PWRED",
           {"ArgMax", "ArgMin", "DiagPart", "Softmax",
            "SparseSoftmaxCrossEntropyWithLogits", "LogSoftmax"}},
          {"REDUCEWINDOW",
           {"ArgMax", "ArgMin", "DiagPart", "Softmax",
            "SparseSoftmaxCrossEntropyWithLogits", "LogSoftmax"}},

  %0 = "tf.Tile"(%arg0, %multiples) : (tensor<?x8xf32>, tensor<2xi32>) -> tensor<?x24xf32>
  func.return %0 : tensor<?x24xf32>
}

//===----------------------------------------------------------------------===//
// ArgMax/ArgMin op legalizations.
//===----------------------------------------------------------------------===//

// -----

// CHECK-LABEL: func @argmax_i64_input_i32_output_axis_0

  // CHECK:  %cst_5 = arith.constant dense<1> : tensor<1xi32>
  // CHECK:  %2 = "tf.Max"(%arg0, %cst_5) <{keep_dims = false}> : (tensor<1x9xi32>, tensor<1xi32>) -> tensor<1xi32>
  // CHECK:  %3 = "tf.ArgMax"(%arg0, %cst_5) : (tensor<1x9xi32>, tensor<1xi32>) -> tensor<1xi32>
  // CHECK:  return %3 : tensor<1xi32>
}

// CHECK-LABEL:   func @convert_argmax(

    (replaceWithValue $input),
    [(IsTailOfShape $input, $output),
     (IsTailOfShape $output, $input)]>;
}

// Remove (log-)softmax before arg-minmax as (log-)softmax is monotonic.
foreach ArgMinMaxOp = [TFL_ArgMinOp, TFL_ArgMaxOp] in {
  def RemoveSoftmaxOpBefore#ArgMinMaxOp : Pat<
    (ArgMinMaxOp (TFL_SoftmaxOp:$softmax $logits, TFL_FloatNonNegative:$beta),

    if (!input_type) {
      return failure();
    }

    Type input_element_type = input_type.getElementType();
    // TODO(bixia): Clarify whether tf.ArgMax supports complex data types. If
    // tf.ArgMax doesn't support complex data types, this check can be removed.
    if (!input_element_type.isSignlessIntOrFloat()) return failure();

    Location loc = op.getLoc();
    Value init_value =

  // operands from tflite op name.
  // Also, since the above code special-handles the `tfl.reshape` op and add an
  // additional input, we put these function block here.
  llvm::MinMax input_min_max = mlir::OperandNumbersMinMax(op_name);
  int input_max_num = input_min_max.Max;
  int op_input_num = op_state.operands.size();
  if (input_max_num != 0 && input_max_num > op_input_num) {