"Atan", "Atanh", "Ceil", "Cos", "Cosh", "Sin", "Exp", "Expm1",
            "Floor", "IsFinite", "IsInf", "IsNan", "Inv", "Reciprocal", "Log",
            "Log1p", "Invert", "LogicalNot", "Ndtri", "Neg", "Rint", "Round",
            "Rsqrt", "Sigmoid", "Sign", "Sinh", "Softplus", "Softsign", "Sqrt",
            "Square", "Tan", "Tanh", "Real", "Imag", "Erf", "Erfc", "Erfinv",

int64_t LogisticOp::GetArithmeticCount(Operation* op) {
  int64_t count;
  // As a very rough ballpark, the cost of evaluating a math function
  // such as tanh or logistic is about 32 multiplications, and about as
  // many additions/subtractions. (Just a power-of-two order-of-magnitude
  // from looking at actual implementations that we use in runtime/code).

}

// CHECK-LABEL:   func @tanh(
// CHECK-SAME:               %[[VAL_0:.*]]: tensor<2xf32>) -> tensor<2xf32> {
// CHECK:           %[[VAL_1:.*]] = "tf.Tanh"(%[[VAL_0]]) : (tensor<2xf32>) -> tensor<2xf32>
// CHECK:           return %[[VAL_1]] : tensor<2xf32>
// CHECK:         }
func.func @tanh(%arg0: tensor<2xf32>) -> tensor<2xf32> {
  %0 = "mhlo.tanh"(%arg0) : (tensor<2xf32>) -> tensor<2xf32>

      %cst_7, %cst_7, %cst_7,
      %cst_7, %cst_7, %cst_7, %cst_7,
      %cst_3, %cst_2,
      %recurrent_stats, %cell_stats,
      %cst_2, %cst_2, %cst_2, %cst_2) {cell_clip = 1.000000e+01 : f32, fused_activation_function = "TANH", proj_clip = 0.000000e+00 : f32, time_major = false}
    : ( tensor<1x28x28xf32>,
        tensor<20x20xf32>, tensor<20x20xf32>, tensor<20x20xf32>, tensor<20x20xf32>,

  %3 = "tfl.mul"(%2, %cst) {fused_activation_function = "NONE"} : (tensor<3xf32>, tensor<f32>) -> tensor<3xf32>
  %4 = "tfl.tanh"(%3) : (tensor<3xf32>) -> tensor<3xf32>
  %5 = "tfl.add"(%4, %cst_1) {fused_activation_function = "NONE"} : (tensor<3xf32>, tensor<f32>) -> tensor<3xf32>

// -----

// CHECK-LABEL: func @tanh
func.func @tanh(%arg0: tensor<2xf32>) -> tensor<2xf32> {
  // CHECK:  mhlo.tanh %arg0 : tensor<2xf32>
  %0 = "tf.Tanh"(%arg0) : (tensor<2xf32>) -> tensor<2xf32>
  func.return %0 : tensor<2xf32>
}

// -----

// CHECK-LABEL: func @tanh_dynamic
func.func @tanh_dynamic(%arg0: tensor<?xf32>) -> tensor<?xf32> {
  // CHECK:  mhlo.tanh %arg0 : tensor<?xf32>

    }
    void $cppClass::print(OpAsmPrinter &p) {
      return printOneResultOp(getOperation(), p);
    }
  }];
}

def TFL_TanhOp: TFL_Op<"tanh", [
    Pure,
    SameOperandsAndResultShape,
    PredOpTrait<"input and output must have same element type",
      TFL_TCresVTEtIsSameAsOp<0, 0>>,
    FixedOutputRangeInterface,
    QuantizableResult,

	},
	"math": {
		{"Abs", Func, 0},
		{"Acos", Func, 0},
		{"Acosh", Func, 0},
		{"Asin", Func, 0},
		{"Asinh", Func, 0},
		{"Atan", Func, 0},
		{"Atan2", Func, 0},
		{"Atanh", Func, 0},
		{"Cbrt", Func, 0},
		{"Ceil", Func, 0},
		{"Copysign", Func, 0},
		{"Cos", Func, 0},
		{"Cosh", Func, 0},
		{"Dim", Func, 0},
		{"E", Const, 0},
		{"Erf", Func, 0},

    }
  }];
}

def TF_TanhGradOp : TF_Op<"TanhGrad", [Pure, TF_SameOperandsAndResultTypeResolveRef]> {
  let summary = "Computes the gradient for the tanh of `x` wrt its input.";

  let description = [{
Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
is the corresponding input gradient.
  }];

  let arguments = (ins
    TF_FpOrComplexTensor:$y,
    TF_FpOrComplexTensor:$dy

*   Enable JIT-compiled i64-indexed kernels on GPU for large tensors with more than 2**32 elements.
    *   Unary GPU kernels: Abs, Atanh, Acos, Acosh, Asin, Asinh, Atan, Cos, Cosh, Sin, Sinh, Tan, Tanh.
    *   Binary GPU kernels: AddV2, Sub, Div, DivNoNan, Mul, MulNoNan, FloorDiv, Equal, NotEqual, Greater, GreaterEqual, LessEqual, Less.

* `tf.lite`