// end, which would not be thread safe.

  static auto* ops = [] {
    llvm::SmallDenseSet<mlir::TypeID, 512>* ops_set = new llvm::SmallDenseSet<
        mlir::TypeID, 512>{
        TypeID::get<TF::AcoshOp>(),
        TypeID::get<TF::AcosOp>(),
        TypeID::get<TF::AddNOp>(),
        TypeID::get<TF::AddV2Op>(),
        TypeID::get<TF::AngleOp>(),
        TypeID::get<TF::AdjustContrastv2Op>(),

                 std::vector<Output>* grad_outputs) {
  // y = acosh(x)
  // dy/dx = 1 / sinh(y)
  auto dydx = Reciprocal(scope, Sinh(scope, op.output(0)));
  // grad(x) = grad(y) * conj(dy/dx)
  grad_outputs->push_back(
      Mul(scope, grad_inputs[0], ConjugateHelper(scope, dydx)));
  return scope.status();
}
REGISTER_GRADIENT_OP("Acosh", AcoshGrad);

Status AtanhGrad(const Scope& scope, const Operation& op,

  static absl::flat_hash_map<string, std::vector<string>>* result =
      new absl::flat_hash_map<string, std::vector<string>>{
          // Unary
          {"PW",
           {"ComplexAbs", "Angle", "Conj", "Abs", "Acos", "Acosh", "Asin",
            "Atan", "Atanh", "Ceil", "Cos", "Cosh", "Sin", "Exp", "Expm1",
            "Floor", "IsFinite", "IsInf", "IsNan", "Inv", "Reciprocal", "Log",

}  // namespace

INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AbsOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AcosOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AcoshOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AsinOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AsinhOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AtanOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(AtanhOp);

  %0, %1, %2 = "tf.IfRegion"(%arg0) ({
     %t0 = "tf.Abs"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
     %t1 = "tf.Acos"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
     %t2 = "tf.Acosh"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
    "tf.Yield"(%t0, %t1, %t2) : (tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> ()
    }, {
     %e0 = "tf.Neg"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>

*   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`

		{"Clone", Func, 21},
		{"Copy", Func, 21},
		{"DeleteFunc", Func, 21},
		{"Equal", Func, 21},
		{"EqualFunc", Func, 21},
	},
	"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},

  let extraClassDeclaration = [{
    static bool isCompatibleReturnTypes(TypeRange inferred, TypeRange actual) {
      return ArraysAreCastCompatible(inferred, actual);
    }
  }];
}

def TF_AcoshOp : TF_Op<"Acosh", [Pure, TF_SameOperandsAndResultTypeResolveRef]> {
  let summary = "Computes inverse hyperbolic cosine of x element-wise.";

  let description = [{

pkg math, const SqrtE ideal-float
pkg math, const SqrtPhi ideal-float
pkg math, const SqrtPi ideal-float
pkg math, func Abs(float64) float64
pkg math, func Acos(float64) float64
pkg math, func Acosh(float64) float64
pkg math, func Asin(float64) float64
pkg math, func Asinh(float64) float64
pkg math, func Atan(float64) float64
pkg math, func Atan2(float64, float64) float64
pkg math, func Atanh(float64) float64