From b08d4d0c463fc5d19be75ef4636a6eff3efceed5 Mon Sep 17 00:00:00 2001 From: Pearu Peterson Date: Sun, 18 Aug 2024 01:25:21 +0300 Subject: [PATCH] Update chlo_legalize_to_stablehlo.mlir --- .../chlo/chlo_legalize_to_stablehlo.mlir | 1214 +++++++++-------- 1 file changed, 616 insertions(+), 598 deletions(-) diff --git a/stablehlo/tests/chlo/chlo_legalize_to_stablehlo.mlir b/stablehlo/tests/chlo/chlo_legalize_to_stablehlo.mlir index ae30600c405..4cec20f508f 100644 --- a/stablehlo/tests/chlo/chlo_legalize_to_stablehlo.mlir +++ b/stablehlo/tests/chlo/chlo_legalize_to_stablehlo.mlir @@ -1,17 +1,17 @@ // RUN: stablehlo-opt --chlo-legalize-to-stablehlo --split-input-file --verify-diagnostics %s | FileCheck %s -// CHECK-LABEL: func.func @asin_bf16( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor -// CHECK-NEXT: %[[TMP_0:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_2:.*]] = stablehlo.subtract %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_3:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_4:.*]] = stablehlo.multiply %[[TMP_2]], %[[TMP_3]] : tensor -// CHECK-NEXT: %[[TMP_5:.*]] = stablehlo.sqrt %[[TMP_4]] : tensor -// CHECK-NEXT: %[[TMP_6:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_5]] : tensor -// CHECK-NEXT: %[[TMP_7:.*]] = stablehlo.atan2 %[[TMP_arg0]], %[[TMP_6]] : tensor -// CHECK-NEXT: %[[TMP_8:.*]] = stablehlo.multiply %[[TMP_0]], %[[TMP_7]] : tensor -// CHECK-NEXT: return %[[TMP_8]] : tensor +// CHECK-LABEL: func.func @asin_bf16( +// CHECK-SAME: %[[VAL_0:.*]]: tensor) -> tensor { +// CHECK: %[[VAL_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.subtract %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.multiply %[[VAL_2]], %[[VAL_3]] : tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.sqrt %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.atan2 %[[VAL_0]], %[[VAL_6]] : tensor +// CHECK: %[[VAL_8:.*]] = stablehlo.add %[[VAL_7]], %[[VAL_7]] : tensor +// CHECK: return %[[VAL_8]] : tensor +// CHECK: } func.func @asin_bf16(%arg : tensor) -> tensor { %result = "chlo.asin"(%arg) : (tensor) -> tensor func.return %result : tensor @@ -19,18 +19,18 @@ func.func @asin_bf16(%arg : tensor) -> tensor { // ----- -// CHECK-LABEL: func.func @asin_f16( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor -// CHECK-NEXT: %[[TMP_0:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_2:.*]] = stablehlo.subtract %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_3:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_4:.*]] = stablehlo.multiply %[[TMP_2]], %[[TMP_3]] : tensor -// CHECK-NEXT: %[[TMP_5:.*]] = stablehlo.sqrt %[[TMP_4]] : tensor -// CHECK-NEXT: %[[TMP_6:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_5]] : tensor -// CHECK-NEXT: %[[TMP_7:.*]] = stablehlo.atan2 %[[TMP_arg0]], %[[TMP_6]] : tensor -// CHECK-NEXT: %[[TMP_8:.*]] = stablehlo.multiply %[[TMP_0]], %[[TMP_7]] : tensor -// CHECK-NEXT: return %[[TMP_8]] : tensor +// CHECK-LABEL: func.func @asin_f16( +// CHECK-SAME: %[[VAL_0:.*]]: tensor) -> tensor { +// CHECK: %[[VAL_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.subtract %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.multiply %[[VAL_2]], %[[VAL_3]] : tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.sqrt %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.atan2 %[[VAL_0]], %[[VAL_6]] : tensor +// CHECK: %[[VAL_8:.*]] = stablehlo.add %[[VAL_7]], %[[VAL_7]] : tensor +// CHECK: return %[[VAL_8]] : tensor +// CHECK: } func.func @asin_f16(%arg : tensor) -> tensor { %result = "chlo.asin"(%arg) : (tensor) -> tensor func.return %result : tensor @@ -38,18 +38,18 @@ func.func @asin_f16(%arg : tensor) -> tensor { // ----- -// CHECK-LABEL: func.func @asin_f32( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor) -> tensor -// CHECK-NEXT: %[[TMP_0:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_2:.*]] = stablehlo.subtract %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_3:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_4:.*]] = stablehlo.multiply %[[TMP_2]], %[[TMP_3]] : tensor -// CHECK-NEXT: %[[TMP_5:.*]] = stablehlo.sqrt %[[TMP_4]] : tensor -// CHECK-NEXT: %[[TMP_6:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_5]] : tensor -// CHECK-NEXT: %[[TMP_7:.*]] = stablehlo.atan2 %[[TMP_arg0]], %[[TMP_6]] : tensor -// CHECK-NEXT: %[[TMP_8:.*]] = stablehlo.multiply %[[TMP_0]], %[[TMP_7]] : tensor -// CHECK-NEXT: return %[[TMP_8]] : tensor +// CHECK-LABEL: func.func @asin_f32( +// CHECK-SAME: %[[VAL_0:.*]]: tensor) -> tensor { +// CHECK: %[[VAL_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.subtract %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.multiply %[[VAL_2]], %[[VAL_3]] : tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.sqrt %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.atan2 %[[VAL_0]], %[[VAL_6]] : tensor +// CHECK: %[[VAL_8:.*]] = stablehlo.add %[[VAL_7]], %[[VAL_7]] : tensor +// CHECK: return %[[VAL_8]] : tensor +// CHECK: } func.func @asin_f32(%arg : tensor) -> tensor { %result = "chlo.asin"(%arg) : (tensor) -> tensor func.return %result : tensor @@ -57,18 +57,18 @@ func.func @asin_f32(%arg : tensor) -> tensor { // ----- -// CHECK-LABEL: func.func @asin_f64( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor) -> tensor -// CHECK-NEXT: %[[TMP_0:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK-NEXT: %[[TMP_2:.*]] = stablehlo.subtract %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_3:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_arg0]] : tensor -// CHECK-NEXT: %[[TMP_4:.*]] = stablehlo.multiply %[[TMP_2]], %[[TMP_3]] : tensor -// CHECK-NEXT: %[[TMP_5:.*]] = stablehlo.sqrt %[[TMP_4]] : tensor -// CHECK-NEXT: %[[TMP_6:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_5]] : tensor -// CHECK-NEXT: %[[TMP_7:.*]] = stablehlo.atan2 %[[TMP_arg0]], %[[TMP_6]] : tensor -// CHECK-NEXT: %[[TMP_8:.*]] = stablehlo.multiply %[[TMP_0]], %[[TMP_7]] : tensor -// CHECK-NEXT: return %[[TMP_8]] : tensor +// CHECK-LABEL: func.func @asin_f64( +// CHECK-SAME: %[[VAL_0:.*]]: tensor) -> tensor { +// CHECK: %[[VAL_1:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.subtract %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_0]] : tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.multiply %[[VAL_2]], %[[VAL_3]] : tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.sqrt %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.add %[[VAL_1]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.atan2 %[[VAL_0]], %[[VAL_6]] : tensor +// CHECK: %[[VAL_8:.*]] = stablehlo.add %[[VAL_7]], %[[VAL_7]] : tensor +// CHECK: return %[[VAL_8]] : tensor +// CHECK: } func.func @asin_f64(%arg : tensor) -> tensor { %result = "chlo.asin"(%arg) : (tensor) -> tensor func.return %result : tensor @@ -76,143 +76,150 @@ func.func @asin_f64(%arg : tensor) -> tensor { // ----- -// CHECK-LABEL: func.func @asin_complex_f32( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor>) -> tensor> -// CHECK: %[[TMP_0:.*]] = stablehlo.real %[[TMP_arg0]] : (tensor>) -> tensor -// CHECK: %[[TMP_1:.*]] = stablehlo.abs %[[TMP_0]] : tensor -// CHECK: %[[TMP_2:.*]] = stablehlo.imag %[[TMP_arg0]] : (tensor>) -> tensor -// CHECK: %[[TMP_3:.*]] = stablehlo.abs %[[TMP_2]] : tensor -// CHECK: %[[TMP_4:.*]] = stablehlo.maximum %[[TMP_1]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_5:.*]] = stablehlo.constant dense<3.40282347E+38> : tensor -// CHECK: %[[TMP_6:.*]] = stablehlo.sqrt %[[TMP_5]] : tensor -// CHECK: %[[TMP_7:.*]] = stablehlo.constant dense<8.000000e+00> : tensor -// CHECK: %[[TMP_8:.*]] = stablehlo.divide %[[TMP_6]], %[[TMP_7]] : tensor -// CHECK: %[[TMP_9:.*]] = stablehlo.compare GE, %[[TMP_4]], %[[TMP_8]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_10:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK: %[[TMP_11:.*]] = stablehlo.compare LE, %[[TMP_1]], %[[TMP_10]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_12:.*]] = stablehlo.constant dense<5.000000e-01> : tensor -// CHECK: %[[TMP_13:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_10]] : tensor -// CHECK: %[[TMP_14:.*]] = stablehlo.abs %[[TMP_13]] : tensor -// CHECK: %[[TMP_15:.*]] = stablehlo.maximum %[[TMP_14]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_16:.*]] = stablehlo.minimum %[[TMP_14]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_17:.*]] = stablehlo.compare EQ, %[[TMP_15]], %[[TMP_16]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_18:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK: %[[TMP_19:.*]] = stablehlo.sqrt %[[TMP_18]] : tensor -// CHECK: %[[TMP_20:.*]] = stablehlo.multiply %[[TMP_19]], %[[TMP_15]] : tensor -// CHECK: %[[TMP_21:.*]] = stablehlo.divide %[[TMP_16]], %[[TMP_15]] : tensor -// CHECK: %[[TMP_22:.*]] = stablehlo.multiply %[[TMP_21]], %[[TMP_21]] : tensor -// CHECK: %[[TMP_23:.*]] = stablehlo.add %[[TMP_10]], %[[TMP_22]] : tensor -// CHECK: %[[TMP_24:.*]] = stablehlo.sqrt %[[TMP_23]] : tensor -// CHECK: %[[TMP_25:.*]] = stablehlo.compare EQ, %[[TMP_24]], %[[TMP_10]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_26:.*]] = stablehlo.constant dense<0.000000e+00> : tensor -// CHECK: %[[TMP_27:.*]] = stablehlo.compare GT, %[[TMP_22]], %[[TMP_26]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_28:.*]] = stablehlo.and %[[TMP_25]], %[[TMP_27]] : tensor -// CHECK: %[[TMP_29:.*]] = stablehlo.multiply %[[TMP_15]], %[[TMP_22]] : tensor -// CHECK: %[[TMP_30:.*]] = stablehlo.divide %[[TMP_29]], %[[TMP_18]] : tensor -// CHECK: %[[TMP_31:.*]] = stablehlo.add %[[TMP_15]], %[[TMP_30]] : tensor -// CHECK: %[[TMP_32:.*]] = stablehlo.multiply %[[TMP_15]], %[[TMP_24]] : tensor -// CHECK: %[[TMP_33:.*]] = stablehlo.select %[[TMP_28]], %[[TMP_31]], %[[TMP_32]] : tensor, tensor -// CHECK: %[[TMP_34:.*]] = stablehlo.select %[[TMP_17]], %[[TMP_20]], %[[TMP_33]] : tensor, tensor -// CHECK: %[[TMP_35:.*]] = stablehlo.subtract %[[TMP_1]], %[[TMP_10]] : tensor -// CHECK: %[[TMP_36:.*]] = stablehlo.abs %[[TMP_35]] : tensor -// CHECK: %[[TMP_37:.*]] = stablehlo.maximum %[[TMP_36]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_38:.*]] = stablehlo.minimum %[[TMP_36]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_39:.*]] = stablehlo.compare EQ, %[[TMP_37]], %[[TMP_38]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_40:.*]] = stablehlo.multiply %[[TMP_19]], %[[TMP_37]] : tensor -// CHECK: %[[TMP_41:.*]] = stablehlo.divide %[[TMP_38]], %[[TMP_37]] : tensor -// CHECK: %[[TMP_42:.*]] = stablehlo.multiply %[[TMP_41]], %[[TMP_41]] : tensor -// CHECK: %[[TMP_43:.*]] = stablehlo.add %[[TMP_10]], %[[TMP_42]] : tensor -// CHECK: %[[TMP_44:.*]] = stablehlo.sqrt %[[TMP_43]] : tensor -// CHECK: %[[TMP_45:.*]] = stablehlo.compare EQ, %[[TMP_44]], %[[TMP_10]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_46:.*]] = stablehlo.compare GT, %[[TMP_42]], %[[TMP_26]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_47:.*]] = stablehlo.and %[[TMP_45]], %[[TMP_46]] : tensor -// CHECK: %[[TMP_48:.*]] = stablehlo.multiply %[[TMP_37]], %[[TMP_42]] : tensor -// CHECK: %[[TMP_49:.*]] = stablehlo.divide %[[TMP_48]], %[[TMP_18]] : tensor -// CHECK: %[[TMP_50:.*]] = stablehlo.add %[[TMP_37]], %[[TMP_49]] : tensor -// CHECK: %[[TMP_51:.*]] = stablehlo.multiply %[[TMP_37]], %[[TMP_44]] : tensor -// CHECK: %[[TMP_52:.*]] = stablehlo.select %[[TMP_47]], %[[TMP_50]], %[[TMP_51]] : tensor, tensor -// CHECK: %[[TMP_53:.*]] = stablehlo.select %[[TMP_39]], %[[TMP_40]], %[[TMP_52]] : tensor, tensor -// CHECK: %[[TMP_54:.*]] = stablehlo.add %[[TMP_34]], %[[TMP_53]] : tensor -// CHECK: %[[TMP_55:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_54]] : tensor -// CHECK: %[[TMP_56:.*]] = stablehlo.add %[[TMP_55]], %[[TMP_1]] : tensor -// CHECK: %[[TMP_57:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_56]] : tensor -// CHECK: %[[TMP_58:.*]] = stablehlo.multiply %[[TMP_3]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_59:.*]] = stablehlo.add %[[TMP_34]], %[[TMP_13]] : tensor -// CHECK: %[[TMP_60:.*]] = stablehlo.divide %[[TMP_58]], %[[TMP_59]] : tensor -// CHECK: %[[TMP_61:.*]] = stablehlo.subtract %[[TMP_53]], %[[TMP_35]] : tensor -// CHECK: %[[TMP_62:.*]] = stablehlo.add %[[TMP_60]], %[[TMP_61]] : tensor -// CHECK: %[[TMP_63:.*]] = stablehlo.multiply %[[TMP_57]], %[[TMP_62]] : tensor -// CHECK: %[[TMP_64:.*]] = stablehlo.sqrt %[[TMP_63]] : tensor -// CHECK: %[[TMP_65:.*]] = stablehlo.divide %[[TMP_57]], %[[TMP_59]] : tensor -// CHECK: %[[TMP_66:.*]] = stablehlo.add %[[TMP_53]], %[[TMP_35]] : tensor -// CHECK: %[[TMP_67:.*]] = stablehlo.divide %[[TMP_57]], %[[TMP_66]] : tensor -// CHECK: %[[TMP_68:.*]] = stablehlo.add %[[TMP_65]], %[[TMP_67]] : tensor -// CHECK: %[[TMP_69:.*]] = stablehlo.sqrt %[[TMP_68]] : tensor -// CHECK: %[[TMP_70:.*]] = stablehlo.multiply %[[TMP_3]], %[[TMP_69]] : tensor -// CHECK: %[[TMP_71:.*]] = stablehlo.select %[[TMP_11]], %[[TMP_64]], %[[TMP_70]] : tensor, tensor -// CHECK: %[[TMP_72:.*]] = stablehlo.select %[[TMP_9]], %[[TMP_3]], %[[TMP_71]] : tensor, tensor -// CHECK: %[[TMP_73:.*]] = stablehlo.atan2 %[[TMP_0]], %[[TMP_72]] : tensor -// CHECK: %[[TMP_74:.*]] = stablehlo.compare LT, %[[TMP_2]], %[[TMP_26]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_75:.*]] = stablehlo.constant dense<9.99999995E+11> : tensor -// CHECK: %[[TMP_76:.*]] = stablehlo.multiply %[[TMP_8]], %[[TMP_75]] : tensor -// CHECK: %[[TMP_77:.*]] = stablehlo.compare LT, %[[TMP_1]], %[[TMP_76]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_78:.*]] = stablehlo.constant dense<9.99999997E-7> : tensor -// CHECK: %[[TMP_79:.*]] = stablehlo.multiply %[[TMP_8]], %[[TMP_78]] : tensor -// CHECK: %[[TMP_80:.*]] = stablehlo.constant dense<1.000000e+02> : tensor -// CHECK: %[[TMP_81:.*]] = stablehlo.multiply %[[TMP_8]], %[[TMP_80]] : tensor -// CHECK: %[[TMP_82:.*]] = stablehlo.select %[[TMP_77]], %[[TMP_79]], %[[TMP_81]] : tensor, tensor -// CHECK: %[[TMP_83:.*]] = stablehlo.compare GE, %[[TMP_3]], %[[TMP_82]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_84:.*]] = stablehlo.select %[[TMP_83]], %[[TMP_3]], %[[TMP_1]] : tensor, tensor -// CHECK: %[[TMP_85:.*]] = stablehlo.select %[[TMP_83]], %[[TMP_82]], %[[TMP_8]] : tensor, tensor -// CHECK: %[[TMP_86:.*]] = stablehlo.compare GE, %[[TMP_84]], %[[TMP_85]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_87:.*]] = stablehlo.log %[[TMP_18]] : tensor -// CHECK: %[[TMP_88:.*]] = stablehlo.log %[[TMP_84]] : tensor -// CHECK: %[[TMP_89:.*]] = stablehlo.add %[[TMP_87]], %[[TMP_88]] : tensor -// CHECK: %[[TMP_90:.*]] = stablehlo.constant dense<0x7F800000> : tensor -// CHECK: %[[TMP_91:.*]] = stablehlo.compare EQ, %[[TMP_3]], %[[TMP_90]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_92:.*]] = stablehlo.not %[[TMP_91]] : tensor -// CHECK: %[[TMP_93:.*]] = stablehlo.and %[[TMP_83]], %[[TMP_92]] : tensor -// CHECK: %[[TMP_94:.*]] = stablehlo.divide %[[TMP_1]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_95:.*]] = stablehlo.select %[[TMP_93]], %[[TMP_94]], %[[TMP_26]] : tensor, tensor -// CHECK: %[[TMP_96:.*]] = stablehlo.multiply %[[TMP_95]], %[[TMP_95]] : tensor -// CHECK: %[[TMP_97:.*]] = stablehlo.log_plus_one %[[TMP_96]] : tensor -// CHECK: %[[TMP_98:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_97]] : tensor -// CHECK: %[[TMP_99:.*]] = stablehlo.add %[[TMP_89]], %[[TMP_98]] : tensor -// CHECK: %[[TMP_100:.*]] = stablehlo.constant dense<1.17549435E-38> : tensor -// CHECK: %[[TMP_101:.*]] = stablehlo.sqrt %[[TMP_100]] : tensor -// CHECK: %[[TMP_102:.*]] = stablehlo.constant dense<4.000000e+00> : tensor -// CHECK: %[[TMP_103:.*]] = stablehlo.multiply %[[TMP_101]], %[[TMP_102]] : tensor -// CHECK: %[[TMP_104:.*]] = stablehlo.compare LT, %[[TMP_3]], %[[TMP_103]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_105:.*]] = stablehlo.compare LT, %[[TMP_1]], %[[TMP_10]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_106:.*]] = stablehlo.and %[[TMP_104]], %[[TMP_105]] : tensor -// CHECK: %[[TMP_107:.*]] = stablehlo.multiply %[[TMP_13]], %[[TMP_35]] : tensor -// CHECK: %[[TMP_108:.*]] = stablehlo.add %[[TMP_55]], %[[TMP_10]] : tensor -// CHECK: %[[TMP_109:.*]] = stablehlo.divide %[[TMP_107]], %[[TMP_108]] : tensor -// CHECK: %[[TMP_110:.*]] = stablehlo.negate %[[TMP_109]] : tensor -// CHECK: %[[TMP_111:.*]] = stablehlo.compare GE, %[[TMP_1]], %[[TMP_10]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_112:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_58]] : tensor -// CHECK: %[[TMP_113:.*]] = stablehlo.divide %[[TMP_112]], %[[TMP_59]] : tensor -// CHECK: %[[TMP_114:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_66]] : tensor -// CHECK: %[[TMP_115:.*]] = stablehlo.add %[[TMP_113]], %[[TMP_114]] : tensor -// CHECK: %[[TMP_116:.*]] = stablehlo.constant dense<1.500000e+00> : tensor -// CHECK: %[[TMP_117:.*]] = stablehlo.compare LE, %[[TMP_55]], %[[TMP_116]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_118:.*]] = stablehlo.divide %[[TMP_112]], %[[TMP_61]] : tensor -// CHECK: %[[TMP_119:.*]] = stablehlo.add %[[TMP_113]], %[[TMP_118]] : tensor -// CHECK: %[[TMP_120:.*]] = stablehlo.subtract %[[TMP_55]], %[[TMP_10]] : tensor -// CHECK: %[[TMP_121:.*]] = stablehlo.select %[[TMP_117]], %[[TMP_119]], %[[TMP_120]] : tensor, tensor -// CHECK: %[[TMP_122:.*]] = stablehlo.select %[[TMP_111]], %[[TMP_115]], %[[TMP_121]] : tensor, tensor -// CHECK: %[[TMP_123:.*]] = stablehlo.select %[[TMP_106]], %[[TMP_110]], %[[TMP_122]] : tensor, tensor -// CHECK: %[[TMP_124:.*]] = stablehlo.multiply %[[TMP_123]], %[[TMP_108]] : tensor -// CHECK: %[[TMP_125:.*]] = stablehlo.sqrt %[[TMP_124]] : tensor -// CHECK: %[[TMP_126:.*]] = stablehlo.divide %[[TMP_3]], %[[TMP_125]] : tensor -// CHECK: %[[TMP_127:.*]] = stablehlo.add %[[TMP_123]], %[[TMP_125]] : tensor -// CHECK: %[[TMP_128:.*]] = stablehlo.log_plus_one %[[TMP_127]] : tensor -// CHECK: %[[TMP_129:.*]] = stablehlo.select %[[TMP_106]], %[[TMP_126]], %[[TMP_128]] : tensor, tensor -// CHECK: %[[TMP_130:.*]] = stablehlo.select %[[TMP_86]], %[[TMP_99]], %[[TMP_129]] : tensor, tensor -// CHECK: %[[TMP_131:.*]] = stablehlo.negate %[[TMP_130]] : tensor -// CHECK: %[[TMP_132:.*]] = stablehlo.select %[[TMP_74]], %[[TMP_131]], %[[TMP_130]] : tensor, tensor -// CHECK: %[[TMP_133:.*]] = stablehlo.complex %[[TMP_73]], %[[TMP_132]] : tensor> -// CHECK: return %[[TMP_133]] : tensor> +// CHECK-LABEL: func.func @asin_complex_f32( +// CHECK-SAME: %[[VAL_0:.*]]: tensor>) -> tensor> { +// CHECK: %[[VAL_1:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.abs %[[VAL_2]] : tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.abs %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.maximum %[[VAL_3]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.constant dense<3.40282347E+38> : tensor +// CHECK: %[[VAL_8:.*]] = stablehlo.sqrt %[[VAL_7]] : tensor +// CHECK: %[[VAL_9:.*]] = stablehlo.constant dense<8.000000e+00> : tensor +// CHECK: %[[VAL_10:.*]] = stablehlo.divide %[[VAL_8]], %[[VAL_9]] : tensor +// CHECK: %[[VAL_11:.*]] = stablehlo.compare GE, %[[VAL_6]], %[[VAL_10]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_12:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_13:.*]] = stablehlo.compare LE, %[[VAL_3]], %[[VAL_12]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_14:.*]] = stablehlo.constant dense<5.000000e-01> : tensor +// CHECK: %[[VAL_15:.*]] = stablehlo.add %[[VAL_3]], %[[VAL_12]] : tensor +// CHECK: %[[VAL_16:.*]] = stablehlo.abs %[[VAL_15]] : tensor +// CHECK: %[[VAL_17:.*]] = stablehlo.maximum %[[VAL_16]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_18:.*]] = stablehlo.minimum %[[VAL_16]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_19:.*]] = stablehlo.compare EQ, %[[VAL_17]], %[[VAL_18]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_20:.*]] = stablehlo.constant dense<2.000000e+00> : tensor +// CHECK: %[[VAL_21:.*]] = stablehlo.sqrt %[[VAL_20]] : tensor +// CHECK: %[[VAL_22:.*]] = stablehlo.multiply %[[VAL_21]], %[[VAL_17]] : tensor +// CHECK: %[[VAL_23:.*]] = stablehlo.divide %[[VAL_18]], %[[VAL_17]] : tensor +// CHECK: %[[VAL_24:.*]] = stablehlo.multiply %[[VAL_23]], %[[VAL_23]] : tensor +// CHECK: %[[VAL_25:.*]] = stablehlo.add %[[VAL_12]], %[[VAL_24]] : tensor +// CHECK: %[[VAL_26:.*]] = stablehlo.sqrt %[[VAL_25]] : tensor +// CHECK: %[[VAL_27:.*]] = stablehlo.compare EQ, %[[VAL_26]], %[[VAL_12]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_28:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_29:.*]] = stablehlo.compare GT, %[[VAL_24]], %[[VAL_28]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_30:.*]] = stablehlo.and %[[VAL_27]], %[[VAL_29]] : tensor +// CHECK: %[[VAL_31:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_24]] : tensor +// CHECK: %[[VAL_32:.*]] = stablehlo.divide %[[VAL_31]], %[[VAL_20]] : tensor +// CHECK: %[[VAL_33:.*]] = stablehlo.add %[[VAL_17]], %[[VAL_32]] : tensor +// CHECK: %[[VAL_34:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_26]] : tensor +// CHECK: %[[VAL_35:.*]] = stablehlo.select %[[VAL_30]], %[[VAL_33]], %[[VAL_34]] : tensor, tensor +// CHECK: %[[VAL_36:.*]] = stablehlo.select %[[VAL_19]], %[[VAL_22]], %[[VAL_35]] : tensor, tensor +// CHECK: %[[VAL_37:.*]] = stablehlo.subtract %[[VAL_3]], %[[VAL_12]] : tensor +// CHECK: %[[VAL_38:.*]] = stablehlo.abs %[[VAL_37]] : tensor +// CHECK: %[[VAL_39:.*]] = stablehlo.maximum %[[VAL_38]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_40:.*]] = stablehlo.minimum %[[VAL_38]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_41:.*]] = stablehlo.compare EQ, %[[VAL_39]], %[[VAL_40]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_42:.*]] = stablehlo.multiply %[[VAL_21]], %[[VAL_39]] : tensor +// CHECK: %[[VAL_43:.*]] = stablehlo.divide %[[VAL_40]], %[[VAL_39]] : tensor +// CHECK: %[[VAL_44:.*]] = stablehlo.multiply %[[VAL_43]], %[[VAL_43]] : tensor +// CHECK: %[[VAL_45:.*]] = stablehlo.add %[[VAL_12]], %[[VAL_44]] : tensor +// CHECK: %[[VAL_46:.*]] = stablehlo.sqrt %[[VAL_45]] : tensor +// CHECK: %[[VAL_47:.*]] = stablehlo.compare EQ, %[[VAL_46]], %[[VAL_12]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_48:.*]] = stablehlo.compare GT, %[[VAL_44]], %[[VAL_28]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_49:.*]] = stablehlo.and %[[VAL_47]], %[[VAL_48]] : tensor +// CHECK: %[[VAL_50:.*]] = stablehlo.multiply %[[VAL_39]], %[[VAL_44]] : tensor +// CHECK: %[[VAL_51:.*]] = stablehlo.divide %[[VAL_50]], %[[VAL_20]] : tensor +// CHECK: %[[VAL_52:.*]] = stablehlo.add %[[VAL_39]], %[[VAL_51]] : tensor +// CHECK: %[[VAL_53:.*]] = stablehlo.multiply %[[VAL_39]], %[[VAL_46]] : tensor +// CHECK: %[[VAL_54:.*]] = stablehlo.select %[[VAL_49]], %[[VAL_52]], %[[VAL_53]] : tensor, tensor +// CHECK: %[[VAL_55:.*]] = stablehlo.select %[[VAL_41]], %[[VAL_42]], %[[VAL_54]] : tensor, tensor +// CHECK: %[[VAL_56:.*]] = stablehlo.add %[[VAL_36]], %[[VAL_55]] : tensor +// CHECK: %[[VAL_57:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_56]] : tensor +// CHECK: %[[VAL_58:.*]] = stablehlo.add %[[VAL_57]], %[[VAL_3]] : tensor +// CHECK: %[[VAL_59:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_58]] : tensor +// CHECK: %[[VAL_60:.*]] = stablehlo.multiply %[[VAL_5]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_61:.*]] = stablehlo.add %[[VAL_36]], %[[VAL_15]] : tensor +// CHECK: %[[VAL_62:.*]] = stablehlo.divide %[[VAL_60]], %[[VAL_61]] : tensor +// CHECK: %[[VAL_63:.*]] = stablehlo.subtract %[[VAL_55]], %[[VAL_37]] : tensor +// CHECK: %[[VAL_64:.*]] = stablehlo.add %[[VAL_62]], %[[VAL_63]] : tensor +// CHECK: %[[VAL_65:.*]] = stablehlo.multiply %[[VAL_59]], %[[VAL_64]] : tensor +// CHECK: %[[VAL_66:.*]] = stablehlo.sqrt %[[VAL_65]] : tensor +// CHECK: %[[VAL_67:.*]] = stablehlo.divide %[[VAL_59]], %[[VAL_61]] : tensor +// CHECK: %[[VAL_68:.*]] = stablehlo.add %[[VAL_55]], %[[VAL_37]] : tensor +// CHECK: %[[VAL_69:.*]] = stablehlo.divide %[[VAL_59]], %[[VAL_68]] : tensor +// CHECK: %[[VAL_70:.*]] = stablehlo.add %[[VAL_67]], %[[VAL_69]] : tensor +// CHECK: %[[VAL_71:.*]] = stablehlo.sqrt %[[VAL_70]] : tensor +// CHECK: %[[VAL_72:.*]] = stablehlo.multiply %[[VAL_5]], %[[VAL_71]] : tensor +// CHECK: %[[VAL_73:.*]] = stablehlo.select %[[VAL_13]], %[[VAL_66]], %[[VAL_72]] : tensor, tensor +// CHECK: %[[VAL_74:.*]] = stablehlo.select %[[VAL_11]], %[[VAL_5]], %[[VAL_73]] : tensor, tensor +// CHECK: %[[VAL_75:.*]] = stablehlo.constant dense<9.99999995E+11> : tensor +// CHECK: %[[VAL_76:.*]] = stablehlo.multiply %[[VAL_10]], %[[VAL_75]] : tensor +// CHECK: %[[VAL_77:.*]] = stablehlo.compare LT, %[[VAL_3]], %[[VAL_76]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_78:.*]] = stablehlo.constant dense<9.99999997E-7> : tensor +// CHECK: %[[VAL_79:.*]] = stablehlo.multiply %[[VAL_10]], %[[VAL_78]] : tensor +// CHECK: %[[VAL_80:.*]] = stablehlo.constant dense<1.000000e+02> : tensor +// CHECK: %[[VAL_81:.*]] = stablehlo.multiply %[[VAL_10]], %[[VAL_80]] : tensor +// CHECK: %[[VAL_82:.*]] = stablehlo.select %[[VAL_77]], %[[VAL_79]], %[[VAL_81]] : tensor, tensor +// CHECK: %[[VAL_83:.*]] = stablehlo.compare GE, %[[VAL_5]], %[[VAL_82]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_84:.*]] = stablehlo.select %[[VAL_83]], %[[VAL_5]], %[[VAL_3]] : tensor, tensor +// CHECK: %[[VAL_85:.*]] = stablehlo.select %[[VAL_83]], %[[VAL_82]], %[[VAL_10]] : tensor, tensor +// CHECK: %[[VAL_86:.*]] = stablehlo.compare GE, %[[VAL_84]], %[[VAL_85]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_87:.*]] = stablehlo.log %[[VAL_20]] : tensor +// CHECK: %[[VAL_88:.*]] = stablehlo.log %[[VAL_84]] : tensor +// CHECK: %[[VAL_89:.*]] = stablehlo.add %[[VAL_87]], %[[VAL_88]] : tensor +// CHECK: %[[VAL_90:.*]] = stablehlo.constant dense<0x7F800000> : tensor +// CHECK: %[[VAL_91:.*]] = stablehlo.compare EQ, %[[VAL_5]], %[[VAL_90]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_92:.*]] = stablehlo.not %[[VAL_91]] : tensor +// CHECK: %[[VAL_93:.*]] = stablehlo.and %[[VAL_83]], %[[VAL_92]] : tensor +// CHECK: %[[VAL_94:.*]] = stablehlo.divide %[[VAL_3]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_95:.*]] = stablehlo.select %[[VAL_93]], %[[VAL_94]], %[[VAL_28]] : tensor, tensor +// CHECK: %[[VAL_96:.*]] = stablehlo.multiply %[[VAL_95]], %[[VAL_95]] : tensor +// CHECK: %[[VAL_97:.*]] = stablehlo.log_plus_one %[[VAL_96]] : tensor +// CHECK: %[[VAL_98:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_97]] : tensor +// CHECK: %[[VAL_99:.*]] = stablehlo.add %[[VAL_89]], %[[VAL_98]] : tensor +// CHECK: %[[VAL_100:.*]] = stablehlo.constant dense<1.17549435E-38> : tensor +// CHECK: %[[VAL_101:.*]] = stablehlo.sqrt %[[VAL_100]] : tensor +// CHECK: %[[VAL_102:.*]] = stablehlo.constant dense<4.000000e+00> : tensor +// CHECK: %[[VAL_103:.*]] = stablehlo.multiply %[[VAL_101]], %[[VAL_102]] : tensor +// CHECK: %[[VAL_104:.*]] = stablehlo.compare LT, %[[VAL_5]], %[[VAL_103]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_105:.*]] = stablehlo.compare LT, %[[VAL_3]], %[[VAL_12]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_106:.*]] = stablehlo.and %[[VAL_104]], %[[VAL_105]] : tensor +// CHECK: %[[VAL_107:.*]] = stablehlo.multiply %[[VAL_15]], %[[VAL_37]] : tensor +// CHECK: %[[VAL_108:.*]] = stablehlo.add %[[VAL_57]], %[[VAL_12]] : tensor +// CHECK: %[[VAL_109:.*]] = stablehlo.divide %[[VAL_107]], %[[VAL_108]] : tensor +// CHECK: %[[VAL_110:.*]] = stablehlo.negate %[[VAL_109]] : tensor +// CHECK: %[[VAL_111:.*]] = stablehlo.compare GE, %[[VAL_3]], %[[VAL_12]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_112:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_60]] : tensor +// CHECK: %[[VAL_113:.*]] = stablehlo.divide %[[VAL_112]], %[[VAL_61]] : tensor +// CHECK: %[[VAL_114:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_68]] : tensor +// CHECK: %[[VAL_115:.*]] = stablehlo.add %[[VAL_113]], %[[VAL_114]] : tensor +// CHECK: %[[VAL_116:.*]] = stablehlo.constant dense<1.500000e+00> : tensor +// CHECK: %[[VAL_117:.*]] = stablehlo.compare LE, %[[VAL_57]], %[[VAL_116]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_118:.*]] = stablehlo.divide %[[VAL_112]], %[[VAL_63]] : tensor +// CHECK: %[[VAL_119:.*]] = stablehlo.add %[[VAL_113]], %[[VAL_118]] : tensor +// CHECK: %[[VAL_120:.*]] = stablehlo.subtract %[[VAL_57]], %[[VAL_12]] : tensor +// CHECK: %[[VAL_121:.*]] = stablehlo.select %[[VAL_117]], %[[VAL_119]], %[[VAL_120]] : tensor, tensor +// CHECK: %[[VAL_122:.*]] = stablehlo.select %[[VAL_111]], %[[VAL_115]], %[[VAL_121]] : tensor, tensor +// CHECK: %[[VAL_123:.*]] = stablehlo.select %[[VAL_106]], %[[VAL_110]], %[[VAL_122]] : tensor, tensor +// CHECK: %[[VAL_124:.*]] = stablehlo.multiply %[[VAL_123]], %[[VAL_108]] : tensor +// CHECK: %[[VAL_125:.*]] = stablehlo.sqrt %[[VAL_124]] : tensor +// CHECK: %[[VAL_126:.*]] = stablehlo.divide %[[VAL_5]], %[[VAL_125]] : tensor +// CHECK: %[[VAL_127:.*]] = stablehlo.add %[[VAL_123]], %[[VAL_125]] : tensor +// CHECK: %[[VAL_128:.*]] = stablehlo.log_plus_one %[[VAL_127]] : tensor +// CHECK: %[[VAL_129:.*]] = stablehlo.select %[[VAL_106]], %[[VAL_126]], %[[VAL_128]] : tensor, tensor +// CHECK: %[[VAL_130:.*]] = stablehlo.select %[[VAL_86]], %[[VAL_99]], %[[VAL_129]] : tensor, tensor +// CHECK: %[[VAL_131:.*]] = stablehlo.complex %[[VAL_74]], %[[VAL_130]] : tensor> +// CHECK: %[[VAL_132:.*]] = stablehlo.real %[[VAL_131]] : (tensor>) -> tensor +// CHECK: %[[VAL_133:.*]] = stablehlo.atan2 %[[VAL_1]], %[[VAL_132]] : tensor +// CHECK: %[[VAL_134:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_135:.*]] = stablehlo.imag %[[VAL_131]] : (tensor>) -> tensor +// CHECK: %[[VAL_136:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_137:.*]] = stablehlo.compare LT, %[[VAL_134]], %[[VAL_136]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_138:.*]] = stablehlo.negate %[[VAL_135]] : tensor +// CHECK: %[[VAL_139:.*]] = stablehlo.select %[[VAL_137]], %[[VAL_138]], %[[VAL_135]] : tensor, tensor +// CHECK: %[[VAL_140:.*]] = stablehlo.complex %[[VAL_133]], %[[VAL_139]] : tensor> +// CHECK: return %[[VAL_140]] : tensor> +// CHECK: } func.func @asin_complex_f32(%arg : tensor>) -> tensor> { %result = "chlo.asin"(%arg) : (tensor>) -> tensor> func.return %result : tensor> @@ -220,169 +227,178 @@ func.func @asin_complex_f32(%arg : tensor>) -> tensor> // ----- -// CHECK-LABEL: func.func @asin_complex_f64_dynamic( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor>) -> tensor> -// CHECK: %[[TMP_0:.*]] = stablehlo.real %[[TMP_arg0]] : (tensor>) -> tensor -// CHECK: %[[TMP_1:.*]] = stablehlo.abs %[[TMP_0]] : tensor -// CHECK: %[[TMP_2:.*]] = stablehlo.imag %[[TMP_arg0]] : (tensor>) -> tensor -// CHECK: %[[TMP_3:.*]] = stablehlo.abs %[[TMP_2]] : tensor -// CHECK: %[[TMP_4:.*]] = stablehlo.maximum %[[TMP_1]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_5:.*]] = stablehlo.constant dense<1.7976931348623157E+308> : tensor -// CHECK: %[[TMP_6:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_7:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_5]], %[[TMP_6]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_8:.*]] = stablehlo.sqrt %[[TMP_7]] : tensor -// CHECK: %[[TMP_9:.*]] = stablehlo.constant dense<8.000000e+00> : tensor -// CHECK: %[[TMP_10:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_11:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_9]], %[[TMP_10]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_12:.*]] = stablehlo.divide %[[TMP_8]], %[[TMP_11]] : tensor -// CHECK: %[[TMP_13:.*]] = stablehlo.compare GE, %[[TMP_4]], %[[TMP_12]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_14:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK: %[[TMP_15:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_16:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_14]], %[[TMP_15]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_17:.*]] = stablehlo.compare LE, %[[TMP_1]], %[[TMP_16]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_18:.*]] = stablehlo.constant dense<5.000000e-01> : tensor -// CHECK: %[[TMP_19:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_20:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_18]], %[[TMP_19]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_21:.*]] = stablehlo.add %[[TMP_1]], %[[TMP_16]] : tensor -// CHECK: %[[TMP_22:.*]] = stablehlo.abs %[[TMP_21]] : tensor -// CHECK: %[[TMP_23:.*]] = stablehlo.maximum %[[TMP_22]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_24:.*]] = stablehlo.minimum %[[TMP_22]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_25:.*]] = stablehlo.compare EQ, %[[TMP_23]], %[[TMP_24]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_26:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK: %[[TMP_27:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_28:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_26]], %[[TMP_27]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_29:.*]] = stablehlo.sqrt %[[TMP_28]] : tensor -// CHECK: %[[TMP_30:.*]] = stablehlo.multiply %[[TMP_29]], %[[TMP_23]] : tensor -// CHECK: %[[TMP_31:.*]] = stablehlo.divide %[[TMP_24]], %[[TMP_23]] : tensor -// CHECK: %[[TMP_32:.*]] = stablehlo.multiply %[[TMP_31]], %[[TMP_31]] : tensor -// CHECK: %[[TMP_33:.*]] = stablehlo.add %[[TMP_16]], %[[TMP_32]] : tensor -// CHECK: %[[TMP_34:.*]] = stablehlo.sqrt %[[TMP_33]] : tensor -// CHECK: %[[TMP_35:.*]] = stablehlo.compare EQ, %[[TMP_34]], %[[TMP_16]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_36:.*]] = stablehlo.constant dense<0.000000e+00> : tensor -// CHECK: %[[TMP_37:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_38:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_36]], %[[TMP_37]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_39:.*]] = stablehlo.compare GT, %[[TMP_32]], %[[TMP_38]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_40:.*]] = stablehlo.and %[[TMP_35]], %[[TMP_39]] : tensor -// CHECK: %[[TMP_41:.*]] = stablehlo.multiply %[[TMP_23]], %[[TMP_32]] : tensor -// CHECK: %[[TMP_42:.*]] = stablehlo.divide %[[TMP_41]], %[[TMP_28]] : tensor -// CHECK: %[[TMP_43:.*]] = stablehlo.add %[[TMP_23]], %[[TMP_42]] : tensor -// CHECK: %[[TMP_44:.*]] = stablehlo.multiply %[[TMP_23]], %[[TMP_34]] : tensor -// CHECK: %[[TMP_45:.*]] = stablehlo.select %[[TMP_40]], %[[TMP_43]], %[[TMP_44]] : tensor, tensor -// CHECK: %[[TMP_46:.*]] = stablehlo.select %[[TMP_25]], %[[TMP_30]], %[[TMP_45]] : tensor, tensor -// CHECK: %[[TMP_47:.*]] = stablehlo.subtract %[[TMP_1]], %[[TMP_16]] : tensor -// CHECK: %[[TMP_48:.*]] = stablehlo.abs %[[TMP_47]] : tensor -// CHECK: %[[TMP_49:.*]] = stablehlo.maximum %[[TMP_48]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_50:.*]] = stablehlo.minimum %[[TMP_48]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_51:.*]] = stablehlo.compare EQ, %[[TMP_49]], %[[TMP_50]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_52:.*]] = stablehlo.multiply %[[TMP_29]], %[[TMP_49]] : tensor -// CHECK: %[[TMP_53:.*]] = stablehlo.divide %[[TMP_50]], %[[TMP_49]] : tensor -// CHECK: %[[TMP_54:.*]] = stablehlo.multiply %[[TMP_53]], %[[TMP_53]] : tensor -// CHECK: %[[TMP_55:.*]] = stablehlo.add %[[TMP_16]], %[[TMP_54]] : tensor -// CHECK: %[[TMP_56:.*]] = stablehlo.sqrt %[[TMP_55]] : tensor -// CHECK: %[[TMP_57:.*]] = stablehlo.compare EQ, %[[TMP_56]], %[[TMP_16]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_58:.*]] = stablehlo.compare GT, %[[TMP_54]], %[[TMP_38]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_59:.*]] = stablehlo.and %[[TMP_57]], %[[TMP_58]] : tensor -// CHECK: %[[TMP_60:.*]] = stablehlo.multiply %[[TMP_49]], %[[TMP_54]] : tensor -// CHECK: %[[TMP_61:.*]] = stablehlo.divide %[[TMP_60]], %[[TMP_28]] : tensor -// CHECK: %[[TMP_62:.*]] = stablehlo.add %[[TMP_49]], %[[TMP_61]] : tensor -// CHECK: %[[TMP_63:.*]] = stablehlo.multiply %[[TMP_49]], %[[TMP_56]] : tensor -// CHECK: %[[TMP_64:.*]] = stablehlo.select %[[TMP_59]], %[[TMP_62]], %[[TMP_63]] : tensor, tensor -// CHECK: %[[TMP_65:.*]] = stablehlo.select %[[TMP_51]], %[[TMP_52]], %[[TMP_64]] : tensor, tensor -// CHECK: %[[TMP_66:.*]] = stablehlo.add %[[TMP_46]], %[[TMP_65]] : tensor -// CHECK: %[[TMP_67:.*]] = stablehlo.multiply %[[TMP_20]], %[[TMP_66]] : tensor -// CHECK: %[[TMP_68:.*]] = stablehlo.add %[[TMP_67]], %[[TMP_1]] : tensor -// CHECK: %[[TMP_69:.*]] = stablehlo.multiply %[[TMP_20]], %[[TMP_68]] : tensor -// CHECK: %[[TMP_70:.*]] = stablehlo.multiply %[[TMP_3]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_71:.*]] = stablehlo.add %[[TMP_46]], %[[TMP_21]] : tensor -// CHECK: %[[TMP_72:.*]] = stablehlo.divide %[[TMP_70]], %[[TMP_71]] : tensor -// CHECK: %[[TMP_73:.*]] = stablehlo.subtract %[[TMP_65]], %[[TMP_47]] : tensor -// CHECK: %[[TMP_74:.*]] = stablehlo.add %[[TMP_72]], %[[TMP_73]] : tensor -// CHECK: %[[TMP_75:.*]] = stablehlo.multiply %[[TMP_69]], %[[TMP_74]] : tensor -// CHECK: %[[TMP_76:.*]] = stablehlo.sqrt %[[TMP_75]] : tensor -// CHECK: %[[TMP_77:.*]] = stablehlo.divide %[[TMP_69]], %[[TMP_71]] : tensor -// CHECK: %[[TMP_78:.*]] = stablehlo.add %[[TMP_65]], %[[TMP_47]] : tensor -// CHECK: %[[TMP_79:.*]] = stablehlo.divide %[[TMP_69]], %[[TMP_78]] : tensor -// CHECK: %[[TMP_80:.*]] = stablehlo.add %[[TMP_77]], %[[TMP_79]] : tensor -// CHECK: %[[TMP_81:.*]] = stablehlo.sqrt %[[TMP_80]] : tensor -// CHECK: %[[TMP_82:.*]] = stablehlo.multiply %[[TMP_3]], %[[TMP_81]] : tensor -// CHECK: %[[TMP_83:.*]] = stablehlo.select %[[TMP_17]], %[[TMP_76]], %[[TMP_82]] : tensor, tensor -// CHECK: %[[TMP_84:.*]] = stablehlo.select %[[TMP_13]], %[[TMP_3]], %[[TMP_83]] : tensor, tensor -// CHECK: %[[TMP_85:.*]] = stablehlo.atan2 %[[TMP_0]], %[[TMP_84]] : tensor -// CHECK: %[[TMP_86:.*]] = stablehlo.compare LT, %[[TMP_2]], %[[TMP_38]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_87:.*]] = stablehlo.constant dense<1.000000e+12> : tensor -// CHECK: %[[TMP_88:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_89:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_87]], %[[TMP_88]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_90:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_89]] : tensor -// CHECK: %[[TMP_91:.*]] = stablehlo.compare LT, %[[TMP_1]], %[[TMP_90]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_92:.*]] = stablehlo.constant dense<9.9999999999999995E-7> : tensor -// CHECK: %[[TMP_93:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_94:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_92]], %[[TMP_93]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_95:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_94]] : tensor -// CHECK: %[[TMP_96:.*]] = stablehlo.constant dense<1.000000e+02> : tensor -// CHECK: %[[TMP_97:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_98:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_96]], %[[TMP_97]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_99:.*]] = stablehlo.multiply %[[TMP_12]], %[[TMP_98]] : tensor -// CHECK: %[[TMP_100:.*]] = stablehlo.select %[[TMP_91]], %[[TMP_95]], %[[TMP_99]] : tensor, tensor -// CHECK: %[[TMP_101:.*]] = stablehlo.compare GE, %[[TMP_3]], %[[TMP_100]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_102:.*]] = stablehlo.select %[[TMP_101]], %[[TMP_3]], %[[TMP_1]] : tensor, tensor -// CHECK: %[[TMP_103:.*]] = stablehlo.select %[[TMP_101]], %[[TMP_100]], %[[TMP_12]] : tensor, tensor -// CHECK: %[[TMP_104:.*]] = stablehlo.compare GE, %[[TMP_102]], %[[TMP_103]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_105:.*]] = stablehlo.log %[[TMP_28]] : tensor -// CHECK: %[[TMP_106:.*]] = stablehlo.log %[[TMP_102]] : tensor -// CHECK: %[[TMP_107:.*]] = stablehlo.add %[[TMP_105]], %[[TMP_106]] : tensor -// CHECK: %[[TMP_108:.*]] = stablehlo.constant dense<0x7FF0000000000000> : tensor -// CHECK: %[[TMP_109:.*]] = shape.shape_of %[[TMP_2]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_110:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_108]], %[[TMP_109]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_111:.*]] = stablehlo.compare EQ, %[[TMP_3]], %[[TMP_110]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_112:.*]] = stablehlo.not %[[TMP_111]] : tensor -// CHECK: %[[TMP_113:.*]] = stablehlo.and %[[TMP_101]], %[[TMP_112]] : tensor -// CHECK: %[[TMP_114:.*]] = stablehlo.divide %[[TMP_1]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_115:.*]] = stablehlo.select %[[TMP_113]], %[[TMP_114]], %[[TMP_38]] : tensor, tensor -// CHECK: %[[TMP_116:.*]] = stablehlo.multiply %[[TMP_115]], %[[TMP_115]] : tensor -// CHECK: %[[TMP_117:.*]] = stablehlo.log_plus_one %[[TMP_116]] : tensor -// CHECK: %[[TMP_118:.*]] = stablehlo.multiply %[[TMP_20]], %[[TMP_117]] : tensor -// CHECK: %[[TMP_119:.*]] = stablehlo.add %[[TMP_107]], %[[TMP_118]] : tensor -// CHECK: %[[TMP_120:.*]] = stablehlo.constant dense<2.2250738585072014E-308> : tensor -// CHECK: %[[TMP_121:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_122:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_120]], %[[TMP_121]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_123:.*]] = stablehlo.sqrt %[[TMP_122]] : tensor -// CHECK: %[[TMP_124:.*]] = stablehlo.constant dense<4.000000e+00> : tensor -// CHECK: %[[TMP_125:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_126:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_124]], %[[TMP_125]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_127:.*]] = stablehlo.multiply %[[TMP_123]], %[[TMP_126]] : tensor -// CHECK: %[[TMP_128:.*]] = stablehlo.compare LT, %[[TMP_3]], %[[TMP_127]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_129:.*]] = stablehlo.compare LT, %[[TMP_1]], %[[TMP_16]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_130:.*]] = stablehlo.and %[[TMP_128]], %[[TMP_129]] : tensor -// CHECK: %[[TMP_131:.*]] = stablehlo.multiply %[[TMP_21]], %[[TMP_47]] : tensor -// CHECK: %[[TMP_132:.*]] = stablehlo.add %[[TMP_67]], %[[TMP_16]] : tensor -// CHECK: %[[TMP_133:.*]] = stablehlo.divide %[[TMP_131]], %[[TMP_132]] : tensor -// CHECK: %[[TMP_134:.*]] = stablehlo.negate %[[TMP_133]] : tensor -// CHECK: %[[TMP_135:.*]] = stablehlo.compare GE, %[[TMP_1]], %[[TMP_16]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_136:.*]] = stablehlo.multiply %[[TMP_20]], %[[TMP_70]] : tensor -// CHECK: %[[TMP_137:.*]] = stablehlo.divide %[[TMP_136]], %[[TMP_71]] : tensor -// CHECK: %[[TMP_138:.*]] = stablehlo.multiply %[[TMP_20]], %[[TMP_78]] : tensor -// CHECK: %[[TMP_139:.*]] = stablehlo.add %[[TMP_137]], %[[TMP_138]] : tensor -// CHECK: %[[TMP_140:.*]] = stablehlo.constant dense<1.500000e+00> : tensor -// CHECK: %[[TMP_141:.*]] = shape.shape_of %[[TMP_0]] : tensor -> tensor<1xindex> -// CHECK: %[[TMP_142:.*]] = stablehlo.dynamic_broadcast_in_dim %[[TMP_140]], %[[TMP_141]], dims = [] : (tensor, tensor<1xindex>) -> tensor -// CHECK: %[[TMP_143:.*]] = stablehlo.compare LE, %[[TMP_67]], %[[TMP_142]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_144:.*]] = stablehlo.divide %[[TMP_136]], %[[TMP_73]] : tensor -// CHECK: %[[TMP_145:.*]] = stablehlo.add %[[TMP_137]], %[[TMP_144]] : tensor -// CHECK: %[[TMP_146:.*]] = stablehlo.subtract %[[TMP_67]], %[[TMP_16]] : tensor -// CHECK: %[[TMP_147:.*]] = stablehlo.select %[[TMP_143]], %[[TMP_145]], %[[TMP_146]] : tensor, tensor -// CHECK: %[[TMP_148:.*]] = stablehlo.select %[[TMP_135]], %[[TMP_139]], %[[TMP_147]] : tensor, tensor -// CHECK: %[[TMP_149:.*]] = stablehlo.select %[[TMP_130]], %[[TMP_134]], %[[TMP_148]] : tensor, tensor -// CHECK: %[[TMP_150:.*]] = stablehlo.multiply %[[TMP_149]], %[[TMP_132]] : tensor -// CHECK: %[[TMP_151:.*]] = stablehlo.sqrt %[[TMP_150]] : tensor -// CHECK: %[[TMP_152:.*]] = stablehlo.divide %[[TMP_3]], %[[TMP_151]] : tensor -// CHECK: %[[TMP_153:.*]] = stablehlo.add %[[TMP_149]], %[[TMP_151]] : tensor -// CHECK: %[[TMP_154:.*]] = stablehlo.log_plus_one %[[TMP_153]] : tensor -// CHECK: %[[TMP_155:.*]] = stablehlo.select %[[TMP_130]], %[[TMP_152]], %[[TMP_154]] : tensor, tensor -// CHECK: %[[TMP_156:.*]] = stablehlo.select %[[TMP_104]], %[[TMP_119]], %[[TMP_155]] : tensor, tensor -// CHECK: %[[TMP_157:.*]] = stablehlo.negate %[[TMP_156]] : tensor -// CHECK: %[[TMP_158:.*]] = stablehlo.select %[[TMP_86]], %[[TMP_157]], %[[TMP_156]] : tensor, tensor -// CHECK: %[[TMP_159:.*]] = stablehlo.complex %[[TMP_85]], %[[TMP_158]] : tensor> -// CHECK: return %[[TMP_159]] : tensor> +// CHECK-LABEL: func.func @asin_complex_f64_dynamic( +// CHECK-SAME: %[[VAL_0:.*]]: tensor>) -> tensor> { +// CHECK: %[[VAL_1:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.abs %[[VAL_2]] : tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.abs %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.maximum %[[VAL_3]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.constant dense<1.7976931348623157E+308> : tensor +// CHECK: %[[VAL_8:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_9:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_7]], %[[VAL_8]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_10:.*]] = stablehlo.sqrt %[[VAL_9]] : tensor +// CHECK: %[[VAL_11:.*]] = stablehlo.constant dense<8.000000e+00> : tensor +// CHECK: %[[VAL_12:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_13:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_11]], %[[VAL_12]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_14:.*]] = stablehlo.divide %[[VAL_10]], %[[VAL_13]] : tensor +// CHECK: %[[VAL_15:.*]] = stablehlo.compare GE, %[[VAL_6]], %[[VAL_14]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_16:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_17:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_18:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_16]], %[[VAL_17]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_19:.*]] = stablehlo.compare LE, %[[VAL_3]], %[[VAL_18]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_20:.*]] = stablehlo.constant dense<5.000000e-01> : tensor +// CHECK: %[[VAL_21:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_22:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_20]], %[[VAL_21]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_23:.*]] = stablehlo.add %[[VAL_3]], %[[VAL_18]] : tensor +// CHECK: %[[VAL_24:.*]] = stablehlo.abs %[[VAL_23]] : tensor +// CHECK: %[[VAL_25:.*]] = stablehlo.maximum %[[VAL_24]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_26:.*]] = stablehlo.minimum %[[VAL_24]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_27:.*]] = stablehlo.compare EQ, %[[VAL_25]], %[[VAL_26]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_28:.*]] = stablehlo.constant dense<2.000000e+00> : tensor +// CHECK: %[[VAL_29:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_30:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_28]], %[[VAL_29]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_31:.*]] = stablehlo.sqrt %[[VAL_30]] : tensor +// CHECK: %[[VAL_32:.*]] = stablehlo.multiply %[[VAL_31]], %[[VAL_25]] : tensor +// CHECK: %[[VAL_33:.*]] = stablehlo.divide %[[VAL_26]], %[[VAL_25]] : tensor +// CHECK: %[[VAL_34:.*]] = stablehlo.multiply %[[VAL_33]], %[[VAL_33]] : tensor +// CHECK: %[[VAL_35:.*]] = stablehlo.add %[[VAL_18]], %[[VAL_34]] : tensor +// CHECK: %[[VAL_36:.*]] = stablehlo.sqrt %[[VAL_35]] : tensor +// CHECK: %[[VAL_37:.*]] = stablehlo.compare EQ, %[[VAL_36]], %[[VAL_18]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_38:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_39:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_40:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_38]], %[[VAL_39]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_41:.*]] = stablehlo.compare GT, %[[VAL_34]], %[[VAL_40]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_42:.*]] = stablehlo.and %[[VAL_37]], %[[VAL_41]] : tensor +// CHECK: %[[VAL_43:.*]] = stablehlo.multiply %[[VAL_25]], %[[VAL_34]] : tensor +// CHECK: %[[VAL_44:.*]] = stablehlo.divide %[[VAL_43]], %[[VAL_30]] : tensor +// CHECK: %[[VAL_45:.*]] = stablehlo.add %[[VAL_25]], %[[VAL_44]] : tensor +// CHECK: %[[VAL_46:.*]] = stablehlo.multiply %[[VAL_25]], %[[VAL_36]] : tensor +// CHECK: %[[VAL_47:.*]] = stablehlo.select %[[VAL_42]], %[[VAL_45]], %[[VAL_46]] : tensor, tensor +// CHECK: %[[VAL_48:.*]] = stablehlo.select %[[VAL_27]], %[[VAL_32]], %[[VAL_47]] : tensor, tensor +// CHECK: %[[VAL_49:.*]] = stablehlo.subtract %[[VAL_3]], %[[VAL_18]] : tensor +// CHECK: %[[VAL_50:.*]] = stablehlo.abs %[[VAL_49]] : tensor +// CHECK: %[[VAL_51:.*]] = stablehlo.maximum %[[VAL_50]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_52:.*]] = stablehlo.minimum %[[VAL_50]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_53:.*]] = stablehlo.compare EQ, %[[VAL_51]], %[[VAL_52]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_54:.*]] = stablehlo.multiply %[[VAL_31]], %[[VAL_51]] : tensor +// CHECK: %[[VAL_55:.*]] = stablehlo.divide %[[VAL_52]], %[[VAL_51]] : tensor +// CHECK: %[[VAL_56:.*]] = stablehlo.multiply %[[VAL_55]], %[[VAL_55]] : tensor +// CHECK: %[[VAL_57:.*]] = stablehlo.add %[[VAL_18]], %[[VAL_56]] : tensor +// CHECK: %[[VAL_58:.*]] = stablehlo.sqrt %[[VAL_57]] : tensor +// CHECK: %[[VAL_59:.*]] = stablehlo.compare EQ, %[[VAL_58]], %[[VAL_18]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_60:.*]] = stablehlo.compare GT, %[[VAL_56]], %[[VAL_40]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_61:.*]] = stablehlo.and %[[VAL_59]], %[[VAL_60]] : tensor +// CHECK: %[[VAL_62:.*]] = stablehlo.multiply %[[VAL_51]], %[[VAL_56]] : tensor +// CHECK: %[[VAL_63:.*]] = stablehlo.divide %[[VAL_62]], %[[VAL_30]] : tensor +// CHECK: %[[VAL_64:.*]] = stablehlo.add %[[VAL_51]], %[[VAL_63]] : tensor +// CHECK: %[[VAL_65:.*]] = stablehlo.multiply %[[VAL_51]], %[[VAL_58]] : tensor +// CHECK: %[[VAL_66:.*]] = stablehlo.select %[[VAL_61]], %[[VAL_64]], %[[VAL_65]] : tensor, tensor +// CHECK: %[[VAL_67:.*]] = stablehlo.select %[[VAL_53]], %[[VAL_54]], %[[VAL_66]] : tensor, tensor +// CHECK: %[[VAL_68:.*]] = stablehlo.add %[[VAL_48]], %[[VAL_67]] : tensor +// CHECK: %[[VAL_69:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_68]] : tensor +// CHECK: %[[VAL_70:.*]] = stablehlo.add %[[VAL_69]], %[[VAL_3]] : tensor +// CHECK: %[[VAL_71:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_70]] : tensor +// CHECK: %[[VAL_72:.*]] = stablehlo.multiply %[[VAL_5]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_73:.*]] = stablehlo.add %[[VAL_48]], %[[VAL_23]] : tensor +// CHECK: %[[VAL_74:.*]] = stablehlo.divide %[[VAL_72]], %[[VAL_73]] : tensor +// CHECK: %[[VAL_75:.*]] = stablehlo.subtract %[[VAL_67]], %[[VAL_49]] : tensor +// CHECK: %[[VAL_76:.*]] = stablehlo.add %[[VAL_74]], %[[VAL_75]] : tensor +// CHECK: %[[VAL_77:.*]] = stablehlo.multiply %[[VAL_71]], %[[VAL_76]] : tensor +// CHECK: %[[VAL_78:.*]] = stablehlo.sqrt %[[VAL_77]] : tensor +// CHECK: %[[VAL_79:.*]] = stablehlo.divide %[[VAL_71]], %[[VAL_73]] : tensor +// CHECK: %[[VAL_80:.*]] = stablehlo.add %[[VAL_67]], %[[VAL_49]] : tensor +// CHECK: %[[VAL_81:.*]] = stablehlo.divide %[[VAL_71]], %[[VAL_80]] : tensor +// CHECK: %[[VAL_82:.*]] = stablehlo.add %[[VAL_79]], %[[VAL_81]] : tensor +// CHECK: %[[VAL_83:.*]] = stablehlo.sqrt %[[VAL_82]] : tensor +// CHECK: %[[VAL_84:.*]] = stablehlo.multiply %[[VAL_5]], %[[VAL_83]] : tensor +// CHECK: %[[VAL_85:.*]] = stablehlo.select %[[VAL_19]], %[[VAL_78]], %[[VAL_84]] : tensor, tensor +// CHECK: %[[VAL_86:.*]] = stablehlo.select %[[VAL_15]], %[[VAL_5]], %[[VAL_85]] : tensor, tensor +// CHECK: %[[VAL_87:.*]] = stablehlo.constant dense<1.000000e+12> : tensor +// CHECK: %[[VAL_88:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_89:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_87]], %[[VAL_88]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_90:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_89]] : tensor +// CHECK: %[[VAL_91:.*]] = stablehlo.compare LT, %[[VAL_3]], %[[VAL_90]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_92:.*]] = stablehlo.constant dense<9.9999999999999995E-7> : tensor +// CHECK: %[[VAL_93:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_94:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_92]], %[[VAL_93]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_95:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_94]] : tensor +// CHECK: %[[VAL_96:.*]] = stablehlo.constant dense<1.000000e+02> : tensor +// CHECK: %[[VAL_97:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_98:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_96]], %[[VAL_97]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_99:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_98]] : tensor +// CHECK: %[[VAL_100:.*]] = stablehlo.select %[[VAL_91]], %[[VAL_95]], %[[VAL_99]] : tensor, tensor +// CHECK: %[[VAL_101:.*]] = stablehlo.compare GE, %[[VAL_5]], %[[VAL_100]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_102:.*]] = stablehlo.select %[[VAL_101]], %[[VAL_5]], %[[VAL_3]] : tensor, tensor +// CHECK: %[[VAL_103:.*]] = stablehlo.select %[[VAL_101]], %[[VAL_100]], %[[VAL_14]] : tensor, tensor +// CHECK: %[[VAL_104:.*]] = stablehlo.compare GE, %[[VAL_102]], %[[VAL_103]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_105:.*]] = stablehlo.log %[[VAL_30]] : tensor +// CHECK: %[[VAL_106:.*]] = stablehlo.log %[[VAL_102]] : tensor +// CHECK: %[[VAL_107:.*]] = stablehlo.add %[[VAL_105]], %[[VAL_106]] : tensor +// CHECK: %[[VAL_108:.*]] = stablehlo.constant dense<0x7FF0000000000000> : tensor +// CHECK: %[[VAL_109:.*]] = shape.shape_of %[[VAL_4]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_110:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_108]], %[[VAL_109]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_111:.*]] = stablehlo.compare EQ, %[[VAL_5]], %[[VAL_110]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_112:.*]] = stablehlo.not %[[VAL_111]] : tensor +// CHECK: %[[VAL_113:.*]] = stablehlo.and %[[VAL_101]], %[[VAL_112]] : tensor +// CHECK: %[[VAL_114:.*]] = stablehlo.divide %[[VAL_3]], %[[VAL_5]] : tensor +// CHECK: %[[VAL_115:.*]] = stablehlo.select %[[VAL_113]], %[[VAL_114]], %[[VAL_40]] : tensor, tensor +// CHECK: %[[VAL_116:.*]] = stablehlo.multiply %[[VAL_115]], %[[VAL_115]] : tensor +// CHECK: %[[VAL_117:.*]] = stablehlo.log_plus_one %[[VAL_116]] : tensor +// CHECK: %[[VAL_118:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_117]] : tensor +// CHECK: %[[VAL_119:.*]] = stablehlo.add %[[VAL_107]], %[[VAL_118]] : tensor +// CHECK: %[[VAL_120:.*]] = stablehlo.constant dense<2.2250738585072014E-308> : tensor +// CHECK: %[[VAL_121:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_122:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_120]], %[[VAL_121]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_123:.*]] = stablehlo.sqrt %[[VAL_122]] : tensor +// CHECK: %[[VAL_124:.*]] = stablehlo.constant dense<4.000000e+00> : tensor +// CHECK: %[[VAL_125:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_126:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_124]], %[[VAL_125]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_127:.*]] = stablehlo.multiply %[[VAL_123]], %[[VAL_126]] : tensor +// CHECK: %[[VAL_128:.*]] = stablehlo.compare LT, %[[VAL_5]], %[[VAL_127]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_129:.*]] = stablehlo.compare LT, %[[VAL_3]], %[[VAL_18]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_130:.*]] = stablehlo.and %[[VAL_128]], %[[VAL_129]] : tensor +// CHECK: %[[VAL_131:.*]] = stablehlo.multiply %[[VAL_23]], %[[VAL_49]] : tensor +// CHECK: %[[VAL_132:.*]] = stablehlo.add %[[VAL_69]], %[[VAL_18]] : tensor +// CHECK: %[[VAL_133:.*]] = stablehlo.divide %[[VAL_131]], %[[VAL_132]] : tensor +// CHECK: %[[VAL_134:.*]] = stablehlo.negate %[[VAL_133]] : tensor +// CHECK: %[[VAL_135:.*]] = stablehlo.compare GE, %[[VAL_3]], %[[VAL_18]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_136:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_72]] : tensor +// CHECK: %[[VAL_137:.*]] = stablehlo.divide %[[VAL_136]], %[[VAL_73]] : tensor +// CHECK: %[[VAL_138:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_80]] : tensor +// CHECK: %[[VAL_139:.*]] = stablehlo.add %[[VAL_137]], %[[VAL_138]] : tensor +// CHECK: %[[VAL_140:.*]] = stablehlo.constant dense<1.500000e+00> : tensor +// CHECK: %[[VAL_141:.*]] = shape.shape_of %[[VAL_2]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_142:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_140]], %[[VAL_141]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_143:.*]] = stablehlo.compare LE, %[[VAL_69]], %[[VAL_142]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_144:.*]] = stablehlo.divide %[[VAL_136]], %[[VAL_75]] : tensor +// CHECK: %[[VAL_145:.*]] = stablehlo.add %[[VAL_137]], %[[VAL_144]] : tensor +// CHECK: %[[VAL_146:.*]] = stablehlo.subtract %[[VAL_69]], %[[VAL_18]] : tensor +// CHECK: %[[VAL_147:.*]] = stablehlo.select %[[VAL_143]], %[[VAL_145]], %[[VAL_146]] : tensor, tensor +// CHECK: %[[VAL_148:.*]] = stablehlo.select %[[VAL_135]], %[[VAL_139]], %[[VAL_147]] : tensor, tensor +// CHECK: %[[VAL_149:.*]] = stablehlo.select %[[VAL_130]], %[[VAL_134]], %[[VAL_148]] : tensor, tensor +// CHECK: %[[VAL_150:.*]] = stablehlo.multiply %[[VAL_149]], %[[VAL_132]] : tensor +// CHECK: %[[VAL_151:.*]] = stablehlo.sqrt %[[VAL_150]] : tensor +// CHECK: %[[VAL_152:.*]] = stablehlo.divide %[[VAL_5]], %[[VAL_151]] : tensor +// CHECK: %[[VAL_153:.*]] = stablehlo.add %[[VAL_149]], %[[VAL_151]] : tensor +// CHECK: %[[VAL_154:.*]] = stablehlo.log_plus_one %[[VAL_153]] : tensor +// CHECK: %[[VAL_155:.*]] = stablehlo.select %[[VAL_130]], %[[VAL_152]], %[[VAL_154]] : tensor, tensor +// CHECK: %[[VAL_156:.*]] = stablehlo.select %[[VAL_104]], %[[VAL_119]], %[[VAL_155]] : tensor, tensor +// CHECK: %[[VAL_157:.*]] = stablehlo.complex %[[VAL_86]], %[[VAL_156]] : tensor> +// CHECK: %[[VAL_158:.*]] = stablehlo.real %[[VAL_157]] : (tensor>) -> tensor +// CHECK: %[[VAL_159:.*]] = stablehlo.atan2 %[[VAL_1]], %[[VAL_158]] : tensor +// CHECK: %[[VAL_160:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_161:.*]] = stablehlo.imag %[[VAL_157]] : (tensor>) -> tensor +// CHECK: %[[VAL_162:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_163:.*]] = shape.shape_of %[[VAL_161]] : tensor -> tensor<1xindex> +// CHECK: %[[VAL_164:.*]] = stablehlo.dynamic_broadcast_in_dim %[[VAL_162]], %[[VAL_163]], dims = [] : (tensor, tensor<1xindex>) -> tensor +// CHECK: %[[VAL_165:.*]] = stablehlo.compare LT, %[[VAL_160]], %[[VAL_164]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_166:.*]] = stablehlo.negate %[[VAL_161]] : tensor +// CHECK: %[[VAL_167:.*]] = stablehlo.select %[[VAL_165]], %[[VAL_166]], %[[VAL_161]] : tensor, tensor +// CHECK: %[[VAL_168:.*]] = stablehlo.complex %[[VAL_159]], %[[VAL_167]] : tensor> +// CHECK: return %[[VAL_168]] : tensor> +// CHECK: } func.func @asin_complex_f64_dynamic(%arg : tensor>) -> tensor> { %result = "chlo.asin"(%arg) : (tensor>) -> tensor> func.return %result : tensor> @@ -456,147 +472,147 @@ func.func @asinh_f64(%arg : tensor) -> tensor { // CHECK-LABEL: func.func @asinh_complex_f32( // CHECK-SAME: %[[VAL_0:.*]]: tensor>) -> tensor> { -// CHECK: %[[VAL_1:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor -// CHECK: %[[VAL_2:.*]] = stablehlo.negate %[[VAL_1]] : tensor -// CHECK: %[[VAL_3:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor -// CHECK: %[[VAL_4:.*]] = stablehlo.complex %[[VAL_2]], %[[VAL_3]] : tensor> -// CHECK: %[[VAL_5:.*]] = stablehlo.real %[[VAL_4]] : (tensor>) -> tensor -// CHECK: %[[VAL_6:.*]] = stablehlo.abs %[[VAL_5]] : tensor -// CHECK: %[[VAL_7:.*]] = stablehlo.imag %[[VAL_4]] : (tensor>) -> tensor +// CHECK: %[[VAL_1:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.compare LT, %[[VAL_1]], %[[VAL_2]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.negate %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.complex %[[VAL_5]], %[[VAL_1]] : tensor> +// CHECK: %[[VAL_7:.*]] = stablehlo.real %[[VAL_6]] : (tensor>) -> tensor // CHECK: %[[VAL_8:.*]] = stablehlo.abs %[[VAL_7]] : tensor -// CHECK: %[[VAL_9:.*]] = stablehlo.maximum %[[VAL_6]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_10:.*]] = stablehlo.constant dense<3.40282347E+38> : tensor -// CHECK: %[[VAL_11:.*]] = stablehlo.sqrt %[[VAL_10]] : tensor -// CHECK: %[[VAL_12:.*]] = stablehlo.constant dense<8.000000e+00> : tensor -// CHECK: %[[VAL_13:.*]] = stablehlo.divide %[[VAL_11]], %[[VAL_12]] : tensor -// CHECK: %[[VAL_14:.*]] = stablehlo.compare GE, %[[VAL_9]], %[[VAL_13]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_15:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK: %[[VAL_16:.*]] = stablehlo.compare LE, %[[VAL_6]], %[[VAL_15]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_17:.*]] = stablehlo.constant dense<5.000000e-01> : tensor -// CHECK: %[[VAL_18:.*]] = stablehlo.add %[[VAL_6]], %[[VAL_15]] : tensor -// CHECK: %[[VAL_19:.*]] = stablehlo.abs %[[VAL_18]] : tensor -// CHECK: %[[VAL_20:.*]] = stablehlo.maximum %[[VAL_19]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_21:.*]] = stablehlo.minimum %[[VAL_19]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_22:.*]] = stablehlo.compare EQ, %[[VAL_20]], %[[VAL_21]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_23:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK: %[[VAL_24:.*]] = stablehlo.sqrt %[[VAL_23]] : tensor -// CHECK: %[[VAL_25:.*]] = stablehlo.multiply %[[VAL_24]], %[[VAL_20]] : tensor -// CHECK: %[[VAL_26:.*]] = stablehlo.divide %[[VAL_21]], %[[VAL_20]] : tensor -// CHECK: %[[VAL_27:.*]] = stablehlo.multiply %[[VAL_26]], %[[VAL_26]] : tensor -// CHECK: %[[VAL_28:.*]] = stablehlo.add %[[VAL_15]], %[[VAL_27]] : tensor -// CHECK: %[[VAL_29:.*]] = stablehlo.sqrt %[[VAL_28]] : tensor -// CHECK: %[[VAL_30:.*]] = stablehlo.compare EQ, %[[VAL_29]], %[[VAL_15]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_31:.*]] = stablehlo.constant dense<0.000000e+00> : tensor -// CHECK: %[[VAL_32:.*]] = stablehlo.compare GT, %[[VAL_27]], %[[VAL_31]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_33:.*]] = stablehlo.and %[[VAL_30]], %[[VAL_32]] : tensor -// CHECK: %[[VAL_34:.*]] = stablehlo.multiply %[[VAL_20]], %[[VAL_27]] : tensor -// CHECK: %[[VAL_35:.*]] = stablehlo.divide %[[VAL_34]], %[[VAL_23]] : tensor -// CHECK: %[[VAL_36:.*]] = stablehlo.add %[[VAL_20]], %[[VAL_35]] : tensor -// CHECK: %[[VAL_37:.*]] = stablehlo.multiply %[[VAL_20]], %[[VAL_29]] : tensor -// CHECK: %[[VAL_38:.*]] = stablehlo.select %[[VAL_33]], %[[VAL_36]], %[[VAL_37]] : tensor, tensor -// CHECK: %[[VAL_39:.*]] = stablehlo.select %[[VAL_22]], %[[VAL_25]], %[[VAL_38]] : tensor, tensor -// CHECK: %[[VAL_40:.*]] = stablehlo.subtract %[[VAL_6]], %[[VAL_15]] : tensor -// CHECK: %[[VAL_41:.*]] = stablehlo.abs %[[VAL_40]] : tensor -// CHECK: %[[VAL_42:.*]] = stablehlo.maximum %[[VAL_41]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_43:.*]] = stablehlo.minimum %[[VAL_41]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_44:.*]] = stablehlo.compare EQ, %[[VAL_42]], %[[VAL_43]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_45:.*]] = stablehlo.multiply %[[VAL_24]], %[[VAL_42]] : tensor -// CHECK: %[[VAL_46:.*]] = stablehlo.divide %[[VAL_43]], %[[VAL_42]] : tensor -// CHECK: %[[VAL_47:.*]] = stablehlo.multiply %[[VAL_46]], %[[VAL_46]] : tensor -// CHECK: %[[VAL_48:.*]] = stablehlo.add %[[VAL_15]], %[[VAL_47]] : tensor -// CHECK: %[[VAL_49:.*]] = stablehlo.sqrt %[[VAL_48]] : tensor -// CHECK: %[[VAL_50:.*]] = stablehlo.compare EQ, %[[VAL_49]], %[[VAL_15]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_51:.*]] = stablehlo.compare GT, %[[VAL_47]], %[[VAL_31]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_52:.*]] = stablehlo.and %[[VAL_50]], %[[VAL_51]] : tensor -// CHECK: %[[VAL_53:.*]] = stablehlo.multiply %[[VAL_42]], %[[VAL_47]] : tensor -// CHECK: %[[VAL_54:.*]] = stablehlo.divide %[[VAL_53]], %[[VAL_23]] : tensor -// CHECK: %[[VAL_55:.*]] = stablehlo.add %[[VAL_42]], %[[VAL_54]] : tensor -// CHECK: %[[VAL_56:.*]] = stablehlo.multiply %[[VAL_42]], %[[VAL_49]] : tensor -// CHECK: %[[VAL_57:.*]] = stablehlo.select %[[VAL_52]], %[[VAL_55]], %[[VAL_56]] : tensor, tensor -// CHECK: %[[VAL_58:.*]] = stablehlo.select %[[VAL_44]], %[[VAL_45]], %[[VAL_57]] : tensor, tensor -// CHECK: %[[VAL_59:.*]] = stablehlo.add %[[VAL_39]], %[[VAL_58]] : tensor -// CHECK: %[[VAL_60:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_59]] : tensor -// CHECK: %[[VAL_61:.*]] = stablehlo.add %[[VAL_60]], %[[VAL_6]] : tensor -// CHECK: %[[VAL_62:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_61]] : tensor -// CHECK: %[[VAL_63:.*]] = stablehlo.multiply %[[VAL_8]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_64:.*]] = stablehlo.add %[[VAL_39]], %[[VAL_18]] : tensor -// CHECK: %[[VAL_65:.*]] = stablehlo.divide %[[VAL_63]], %[[VAL_64]] : tensor -// CHECK: %[[VAL_66:.*]] = stablehlo.subtract %[[VAL_58]], %[[VAL_40]] : tensor -// CHECK: %[[VAL_67:.*]] = stablehlo.add %[[VAL_65]], %[[VAL_66]] : tensor -// CHECK: %[[VAL_68:.*]] = stablehlo.multiply %[[VAL_62]], %[[VAL_67]] : tensor -// CHECK: %[[VAL_69:.*]] = stablehlo.sqrt %[[VAL_68]] : tensor -// CHECK: %[[VAL_70:.*]] = stablehlo.divide %[[VAL_62]], %[[VAL_64]] : tensor -// CHECK: %[[VAL_71:.*]] = stablehlo.add %[[VAL_58]], %[[VAL_40]] : tensor -// CHECK: %[[VAL_72:.*]] = stablehlo.divide %[[VAL_62]], %[[VAL_71]] : tensor -// CHECK: %[[VAL_73:.*]] = stablehlo.add %[[VAL_70]], %[[VAL_72]] : tensor -// CHECK: %[[VAL_74:.*]] = stablehlo.sqrt %[[VAL_73]] : tensor -// CHECK: %[[VAL_75:.*]] = stablehlo.multiply %[[VAL_8]], %[[VAL_74]] : tensor -// CHECK: %[[VAL_76:.*]] = stablehlo.select %[[VAL_16]], %[[VAL_69]], %[[VAL_75]] : tensor, tensor -// CHECK: %[[VAL_77:.*]] = stablehlo.select %[[VAL_14]], %[[VAL_8]], %[[VAL_76]] : tensor, tensor -// CHECK: %[[VAL_78:.*]] = stablehlo.atan2 %[[VAL_5]], %[[VAL_77]] : tensor -// CHECK: %[[VAL_79:.*]] = stablehlo.compare LT, %[[VAL_7]], %[[VAL_31]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_9:.*]] = stablehlo.imag %[[VAL_6]] : (tensor>) -> tensor +// CHECK: %[[VAL_10:.*]] = stablehlo.abs %[[VAL_9]] : tensor +// CHECK: %[[VAL_11:.*]] = stablehlo.maximum %[[VAL_8]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_12:.*]] = stablehlo.constant dense<3.40282347E+38> : tensor +// CHECK: %[[VAL_13:.*]] = stablehlo.sqrt %[[VAL_12]] : tensor +// CHECK: %[[VAL_14:.*]] = stablehlo.constant dense<8.000000e+00> : tensor +// CHECK: %[[VAL_15:.*]] = stablehlo.divide %[[VAL_13]], %[[VAL_14]] : tensor +// CHECK: %[[VAL_16:.*]] = stablehlo.compare GE, %[[VAL_11]], %[[VAL_15]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_17:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_18:.*]] = stablehlo.compare LE, %[[VAL_8]], %[[VAL_17]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_19:.*]] = stablehlo.constant dense<5.000000e-01> : tensor +// CHECK: %[[VAL_20:.*]] = stablehlo.add %[[VAL_8]], %[[VAL_17]] : tensor +// CHECK: %[[VAL_21:.*]] = stablehlo.abs %[[VAL_20]] : tensor +// CHECK: %[[VAL_22:.*]] = stablehlo.maximum %[[VAL_21]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_23:.*]] = stablehlo.minimum %[[VAL_21]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_24:.*]] = stablehlo.compare EQ, %[[VAL_22]], %[[VAL_23]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_25:.*]] = stablehlo.constant dense<2.000000e+00> : tensor +// CHECK: %[[VAL_26:.*]] = stablehlo.sqrt %[[VAL_25]] : tensor +// CHECK: %[[VAL_27:.*]] = stablehlo.multiply %[[VAL_26]], %[[VAL_22]] : tensor +// CHECK: %[[VAL_28:.*]] = stablehlo.divide %[[VAL_23]], %[[VAL_22]] : tensor +// CHECK: %[[VAL_29:.*]] = stablehlo.multiply %[[VAL_28]], %[[VAL_28]] : tensor +// CHECK: %[[VAL_30:.*]] = stablehlo.add %[[VAL_17]], %[[VAL_29]] : tensor +// CHECK: %[[VAL_31:.*]] = stablehlo.sqrt %[[VAL_30]] : tensor +// CHECK: %[[VAL_32:.*]] = stablehlo.compare EQ, %[[VAL_31]], %[[VAL_17]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_33:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_34:.*]] = stablehlo.compare GT, %[[VAL_29]], %[[VAL_33]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_35:.*]] = stablehlo.and %[[VAL_32]], %[[VAL_34]] : tensor +// CHECK: %[[VAL_36:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_29]] : tensor +// CHECK: %[[VAL_37:.*]] = stablehlo.divide %[[VAL_36]], %[[VAL_25]] : tensor +// CHECK: %[[VAL_38:.*]] = stablehlo.add %[[VAL_22]], %[[VAL_37]] : tensor +// CHECK: %[[VAL_39:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_31]] : tensor +// CHECK: %[[VAL_40:.*]] = stablehlo.select %[[VAL_35]], %[[VAL_38]], %[[VAL_39]] : tensor, tensor +// CHECK: %[[VAL_41:.*]] = stablehlo.select %[[VAL_24]], %[[VAL_27]], %[[VAL_40]] : tensor, tensor +// CHECK: %[[VAL_42:.*]] = stablehlo.subtract %[[VAL_8]], %[[VAL_17]] : tensor +// CHECK: %[[VAL_43:.*]] = stablehlo.abs %[[VAL_42]] : tensor +// CHECK: %[[VAL_44:.*]] = stablehlo.maximum %[[VAL_43]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_45:.*]] = stablehlo.minimum %[[VAL_43]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_46:.*]] = stablehlo.compare EQ, %[[VAL_44]], %[[VAL_45]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_47:.*]] = stablehlo.multiply %[[VAL_26]], %[[VAL_44]] : tensor +// CHECK: %[[VAL_48:.*]] = stablehlo.divide %[[VAL_45]], %[[VAL_44]] : tensor +// CHECK: %[[VAL_49:.*]] = stablehlo.multiply %[[VAL_48]], %[[VAL_48]] : tensor +// CHECK: %[[VAL_50:.*]] = stablehlo.add %[[VAL_17]], %[[VAL_49]] : tensor +// CHECK: %[[VAL_51:.*]] = stablehlo.sqrt %[[VAL_50]] : tensor +// CHECK: %[[VAL_52:.*]] = stablehlo.compare EQ, %[[VAL_51]], %[[VAL_17]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_53:.*]] = stablehlo.compare GT, %[[VAL_49]], %[[VAL_33]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_54:.*]] = stablehlo.and %[[VAL_52]], %[[VAL_53]] : tensor +// CHECK: %[[VAL_55:.*]] = stablehlo.multiply %[[VAL_44]], %[[VAL_49]] : tensor +// CHECK: %[[VAL_56:.*]] = stablehlo.divide %[[VAL_55]], %[[VAL_25]] : tensor +// CHECK: %[[VAL_57:.*]] = stablehlo.add %[[VAL_44]], %[[VAL_56]] : tensor +// CHECK: %[[VAL_58:.*]] = stablehlo.multiply %[[VAL_44]], %[[VAL_51]] : tensor +// CHECK: %[[VAL_59:.*]] = stablehlo.select %[[VAL_54]], %[[VAL_57]], %[[VAL_58]] : tensor, tensor +// CHECK: %[[VAL_60:.*]] = stablehlo.select %[[VAL_46]], %[[VAL_47]], %[[VAL_59]] : tensor, tensor +// CHECK: %[[VAL_61:.*]] = stablehlo.add %[[VAL_41]], %[[VAL_60]] : tensor +// CHECK: %[[VAL_62:.*]] = stablehlo.multiply %[[VAL_19]], %[[VAL_61]] : tensor +// CHECK: %[[VAL_63:.*]] = stablehlo.add %[[VAL_62]], %[[VAL_8]] : tensor +// CHECK: %[[VAL_64:.*]] = stablehlo.multiply %[[VAL_19]], %[[VAL_63]] : tensor +// CHECK: %[[VAL_65:.*]] = stablehlo.multiply %[[VAL_10]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_66:.*]] = stablehlo.add %[[VAL_41]], %[[VAL_20]] : tensor +// CHECK: %[[VAL_67:.*]] = stablehlo.divide %[[VAL_65]], %[[VAL_66]] : tensor +// CHECK: %[[VAL_68:.*]] = stablehlo.subtract %[[VAL_60]], %[[VAL_42]] : tensor +// CHECK: %[[VAL_69:.*]] = stablehlo.add %[[VAL_67]], %[[VAL_68]] : tensor +// CHECK: %[[VAL_70:.*]] = stablehlo.multiply %[[VAL_64]], %[[VAL_69]] : tensor +// CHECK: %[[VAL_71:.*]] = stablehlo.sqrt %[[VAL_70]] : tensor +// CHECK: %[[VAL_72:.*]] = stablehlo.divide %[[VAL_64]], %[[VAL_66]] : tensor +// CHECK: %[[VAL_73:.*]] = stablehlo.add %[[VAL_60]], %[[VAL_42]] : tensor +// CHECK: %[[VAL_74:.*]] = stablehlo.divide %[[VAL_64]], %[[VAL_73]] : tensor +// CHECK: %[[VAL_75:.*]] = stablehlo.add %[[VAL_72]], %[[VAL_74]] : tensor +// CHECK: %[[VAL_76:.*]] = stablehlo.sqrt %[[VAL_75]] : tensor +// CHECK: %[[VAL_77:.*]] = stablehlo.multiply %[[VAL_10]], %[[VAL_76]] : tensor +// CHECK: %[[VAL_78:.*]] = stablehlo.select %[[VAL_18]], %[[VAL_71]], %[[VAL_77]] : tensor, tensor +// CHECK: %[[VAL_79:.*]] = stablehlo.select %[[VAL_16]], %[[VAL_10]], %[[VAL_78]] : tensor, tensor // CHECK: %[[VAL_80:.*]] = stablehlo.constant dense<9.99999995E+11> : tensor -// CHECK: %[[VAL_81:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_80]] : tensor -// CHECK: %[[VAL_82:.*]] = stablehlo.compare LT, %[[VAL_6]], %[[VAL_81]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_81:.*]] = stablehlo.multiply %[[VAL_15]], %[[VAL_80]] : tensor +// CHECK: %[[VAL_82:.*]] = stablehlo.compare LT, %[[VAL_8]], %[[VAL_81]] : (tensor, tensor) -> tensor // CHECK: %[[VAL_83:.*]] = stablehlo.constant dense<9.99999997E-7> : tensor -// CHECK: %[[VAL_84:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_83]] : tensor +// CHECK: %[[VAL_84:.*]] = stablehlo.multiply %[[VAL_15]], %[[VAL_83]] : tensor // CHECK: %[[VAL_85:.*]] = stablehlo.constant dense<1.000000e+02> : tensor -// CHECK: %[[VAL_86:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_85]] : tensor +// CHECK: %[[VAL_86:.*]] = stablehlo.multiply %[[VAL_15]], %[[VAL_85]] : tensor // CHECK: %[[VAL_87:.*]] = stablehlo.select %[[VAL_82]], %[[VAL_84]], %[[VAL_86]] : tensor, tensor -// CHECK: %[[VAL_88:.*]] = stablehlo.compare GE, %[[VAL_8]], %[[VAL_87]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_89:.*]] = stablehlo.select %[[VAL_88]], %[[VAL_8]], %[[VAL_6]] : tensor, tensor -// CHECK: %[[VAL_90:.*]] = stablehlo.select %[[VAL_88]], %[[VAL_87]], %[[VAL_13]] : tensor, tensor +// CHECK: %[[VAL_88:.*]] = stablehlo.compare GE, %[[VAL_10]], %[[VAL_87]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_89:.*]] = stablehlo.select %[[VAL_88]], %[[VAL_10]], %[[VAL_8]] : tensor, tensor +// CHECK: %[[VAL_90:.*]] = stablehlo.select %[[VAL_88]], %[[VAL_87]], %[[VAL_15]] : tensor, tensor // CHECK: %[[VAL_91:.*]] = stablehlo.compare GE, %[[VAL_89]], %[[VAL_90]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_92:.*]] = stablehlo.log %[[VAL_23]] : tensor +// CHECK: %[[VAL_92:.*]] = stablehlo.log %[[VAL_25]] : tensor // CHECK: %[[VAL_93:.*]] = stablehlo.log %[[VAL_89]] : tensor // CHECK: %[[VAL_94:.*]] = stablehlo.add %[[VAL_92]], %[[VAL_93]] : tensor // CHECK: %[[VAL_95:.*]] = stablehlo.constant dense<0x7F800000> : tensor -// CHECK: %[[VAL_96:.*]] = stablehlo.compare EQ, %[[VAL_8]], %[[VAL_95]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_96:.*]] = stablehlo.compare EQ, %[[VAL_10]], %[[VAL_95]] : (tensor, tensor) -> tensor // CHECK: %[[VAL_97:.*]] = stablehlo.not %[[VAL_96]] : tensor // CHECK: %[[VAL_98:.*]] = stablehlo.and %[[VAL_88]], %[[VAL_97]] : tensor -// CHECK: %[[VAL_99:.*]] = stablehlo.divide %[[VAL_6]], %[[VAL_8]] : tensor -// CHECK: %[[VAL_100:.*]] = stablehlo.select %[[VAL_98]], %[[VAL_99]], %[[VAL_31]] : tensor, tensor +// CHECK: %[[VAL_99:.*]] = stablehlo.divide %[[VAL_8]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_100:.*]] = stablehlo.select %[[VAL_98]], %[[VAL_99]], %[[VAL_33]] : tensor, tensor // CHECK: %[[VAL_101:.*]] = stablehlo.multiply %[[VAL_100]], %[[VAL_100]] : tensor // CHECK: %[[VAL_102:.*]] = stablehlo.log_plus_one %[[VAL_101]] : tensor -// CHECK: %[[VAL_103:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_102]] : tensor +// CHECK: %[[VAL_103:.*]] = stablehlo.multiply %[[VAL_19]], %[[VAL_102]] : tensor // CHECK: %[[VAL_104:.*]] = stablehlo.add %[[VAL_94]], %[[VAL_103]] : tensor // CHECK: %[[VAL_105:.*]] = stablehlo.constant dense<1.17549435E-38> : tensor // CHECK: %[[VAL_106:.*]] = stablehlo.sqrt %[[VAL_105]] : tensor // CHECK: %[[VAL_107:.*]] = stablehlo.constant dense<4.000000e+00> : tensor // CHECK: %[[VAL_108:.*]] = stablehlo.multiply %[[VAL_106]], %[[VAL_107]] : tensor -// CHECK: %[[VAL_109:.*]] = stablehlo.compare LT, %[[VAL_8]], %[[VAL_108]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_110:.*]] = stablehlo.compare LT, %[[VAL_6]], %[[VAL_15]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_109:.*]] = stablehlo.compare LT, %[[VAL_10]], %[[VAL_108]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_110:.*]] = stablehlo.compare LT, %[[VAL_8]], %[[VAL_17]] : (tensor, tensor) -> tensor // CHECK: %[[VAL_111:.*]] = stablehlo.and %[[VAL_109]], %[[VAL_110]] : tensor -// CHECK: %[[VAL_112:.*]] = stablehlo.multiply %[[VAL_18]], %[[VAL_40]] : tensor -// CHECK: %[[VAL_113:.*]] = stablehlo.add %[[VAL_60]], %[[VAL_15]] : tensor +// CHECK: %[[VAL_112:.*]] = stablehlo.multiply %[[VAL_20]], %[[VAL_42]] : tensor +// CHECK: %[[VAL_113:.*]] = stablehlo.add %[[VAL_62]], %[[VAL_17]] : tensor // CHECK: %[[VAL_114:.*]] = stablehlo.divide %[[VAL_112]], %[[VAL_113]] : tensor // CHECK: %[[VAL_115:.*]] = stablehlo.negate %[[VAL_114]] : tensor -// CHECK: %[[VAL_116:.*]] = stablehlo.compare GE, %[[VAL_6]], %[[VAL_15]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_117:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_63]] : tensor -// CHECK: %[[VAL_118:.*]] = stablehlo.divide %[[VAL_117]], %[[VAL_64]] : tensor -// CHECK: %[[VAL_119:.*]] = stablehlo.multiply %[[VAL_17]], %[[VAL_71]] : tensor +// CHECK: %[[VAL_116:.*]] = stablehlo.compare GE, %[[VAL_8]], %[[VAL_17]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_117:.*]] = stablehlo.multiply %[[VAL_19]], %[[VAL_65]] : tensor +// CHECK: %[[VAL_118:.*]] = stablehlo.divide %[[VAL_117]], %[[VAL_66]] : tensor +// CHECK: %[[VAL_119:.*]] = stablehlo.multiply %[[VAL_19]], %[[VAL_73]] : tensor // CHECK: %[[VAL_120:.*]] = stablehlo.add %[[VAL_118]], %[[VAL_119]] : tensor // CHECK: %[[VAL_121:.*]] = stablehlo.constant dense<1.500000e+00> : tensor -// CHECK: %[[VAL_122:.*]] = stablehlo.compare LE, %[[VAL_60]], %[[VAL_121]] : (tensor, tensor) -> tensor -// CHECK: %[[VAL_123:.*]] = stablehlo.divide %[[VAL_117]], %[[VAL_66]] : tensor +// CHECK: %[[VAL_122:.*]] = stablehlo.compare LE, %[[VAL_62]], %[[VAL_121]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_123:.*]] = stablehlo.divide %[[VAL_117]], %[[VAL_68]] : tensor // CHECK: %[[VAL_124:.*]] = stablehlo.add %[[VAL_118]], %[[VAL_123]] : tensor -// CHECK: %[[VAL_125:.*]] = stablehlo.subtract %[[VAL_60]], %[[VAL_15]] : tensor +// CHECK: %[[VAL_125:.*]] = stablehlo.subtract %[[VAL_62]], %[[VAL_17]] : tensor // CHECK: %[[VAL_126:.*]] = stablehlo.select %[[VAL_122]], %[[VAL_124]], %[[VAL_125]] : tensor, tensor // CHECK: %[[VAL_127:.*]] = stablehlo.select %[[VAL_116]], %[[VAL_120]], %[[VAL_126]] : tensor, tensor // CHECK: %[[VAL_128:.*]] = stablehlo.select %[[VAL_111]], %[[VAL_115]], %[[VAL_127]] : tensor, tensor // CHECK: %[[VAL_129:.*]] = stablehlo.multiply %[[VAL_128]], %[[VAL_113]] : tensor // CHECK: %[[VAL_130:.*]] = stablehlo.sqrt %[[VAL_129]] : tensor -// CHECK: %[[VAL_131:.*]] = stablehlo.divide %[[VAL_8]], %[[VAL_130]] : tensor +// CHECK: %[[VAL_131:.*]] = stablehlo.divide %[[VAL_10]], %[[VAL_130]] : tensor // CHECK: %[[VAL_132:.*]] = stablehlo.add %[[VAL_128]], %[[VAL_130]] : tensor // CHECK: %[[VAL_133:.*]] = stablehlo.log_plus_one %[[VAL_132]] : tensor // CHECK: %[[VAL_134:.*]] = stablehlo.select %[[VAL_111]], %[[VAL_131]], %[[VAL_133]] : tensor, tensor // CHECK: %[[VAL_135:.*]] = stablehlo.select %[[VAL_91]], %[[VAL_104]], %[[VAL_134]] : tensor, tensor -// CHECK: %[[VAL_136:.*]] = stablehlo.negate %[[VAL_135]] : tensor -// CHECK: %[[VAL_137:.*]] = stablehlo.select %[[VAL_79]], %[[VAL_136]], %[[VAL_135]] : tensor, tensor -// CHECK: %[[VAL_138:.*]] = stablehlo.complex %[[VAL_78]], %[[VAL_137]] : tensor> -// CHECK: %[[VAL_139:.*]] = stablehlo.imag %[[VAL_138]] : (tensor>) -> tensor -// CHECK: %[[VAL_140:.*]] = stablehlo.real %[[VAL_138]] : (tensor>) -> tensor -// CHECK: %[[VAL_141:.*]] = stablehlo.negate %[[VAL_140]] : tensor +// CHECK: %[[VAL_136:.*]] = stablehlo.complex %[[VAL_79]], %[[VAL_135]] : tensor> +// CHECK: %[[VAL_137:.*]] = stablehlo.imag %[[VAL_136]] : (tensor>) -> tensor +// CHECK: %[[VAL_138:.*]] = stablehlo.negate %[[VAL_137]] : tensor +// CHECK: %[[VAL_139:.*]] = stablehlo.select %[[VAL_3]], %[[VAL_138]], %[[VAL_137]] : tensor, tensor +// CHECK: %[[VAL_140:.*]] = stablehlo.real %[[VAL_136]] : (tensor>) -> tensor +// CHECK: %[[VAL_141:.*]] = stablehlo.atan2 %[[VAL_4]], %[[VAL_140]] : tensor // CHECK: %[[VAL_142:.*]] = stablehlo.complex %[[VAL_139]], %[[VAL_141]] : tensor> // CHECK: return %[[VAL_142]] : tensor> // CHECK: } @@ -896,149 +912,151 @@ func.func @acosh(%arg: tensor) -> tensor { // ----- -// CHECK-LABEL: func.func @acosh_complex_f32( -// CHECK-SAME: %[[TMP_arg0:.*]]: tensor>) -> tensor> +// CHECK-LABEL: func.func @acosh_complex_f32( +// CHECK-SAME: %[[VAL_0:.*]]: tensor>) -> tensor> { +// CHECK: %[[VAL_1:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_2:.*]] = stablehlo.abs %[[VAL_1]] : tensor +// CHECK: %[[VAL_3:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_4:.*]] = stablehlo.abs %[[VAL_3]] : tensor +// CHECK: %[[VAL_5:.*]] = stablehlo.maximum %[[VAL_2]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_6:.*]] = stablehlo.constant dense<3.40282347E+38> : tensor +// CHECK: %[[VAL_7:.*]] = stablehlo.sqrt %[[VAL_6]] : tensor +// CHECK: %[[VAL_8:.*]] = stablehlo.constant dense<8.000000e+00> : tensor +// CHECK: %[[VAL_9:.*]] = stablehlo.divide %[[VAL_7]], %[[VAL_8]] : tensor +// CHECK: %[[VAL_10:.*]] = stablehlo.compare GE, %[[VAL_5]], %[[VAL_9]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_11:.*]] = stablehlo.constant dense<1.000000e+00> : tensor +// CHECK: %[[VAL_12:.*]] = stablehlo.compare LE, %[[VAL_2]], %[[VAL_11]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_13:.*]] = stablehlo.constant dense<5.000000e-01> : tensor +// CHECK: %[[VAL_14:.*]] = stablehlo.add %[[VAL_2]], %[[VAL_11]] : tensor +// CHECK: %[[VAL_15:.*]] = stablehlo.abs %[[VAL_14]] : tensor +// CHECK: %[[VAL_16:.*]] = stablehlo.maximum %[[VAL_15]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_17:.*]] = stablehlo.minimum %[[VAL_15]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_18:.*]] = stablehlo.compare EQ, %[[VAL_16]], %[[VAL_17]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_19:.*]] = stablehlo.constant dense<2.000000e+00> : tensor +// CHECK: %[[VAL_20:.*]] = stablehlo.sqrt %[[VAL_19]] : tensor +// CHECK: %[[VAL_21:.*]] = stablehlo.multiply %[[VAL_20]], %[[VAL_16]] : tensor +// CHECK: %[[VAL_22:.*]] = stablehlo.divide %[[VAL_17]], %[[VAL_16]] : tensor +// CHECK: %[[VAL_23:.*]] = stablehlo.multiply %[[VAL_22]], %[[VAL_22]] : tensor +// CHECK: %[[VAL_24:.*]] = stablehlo.add %[[VAL_11]], %[[VAL_23]] : tensor +// CHECK: %[[VAL_25:.*]] = stablehlo.sqrt %[[VAL_24]] : tensor +// CHECK: %[[VAL_26:.*]] = stablehlo.compare EQ, %[[VAL_25]], %[[VAL_11]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_27:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_28:.*]] = stablehlo.compare GT, %[[VAL_23]], %[[VAL_27]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_29:.*]] = stablehlo.and %[[VAL_26]], %[[VAL_28]] : tensor +// CHECK: %[[VAL_30:.*]] = stablehlo.multiply %[[VAL_16]], %[[VAL_23]] : tensor +// CHECK: %[[VAL_31:.*]] = stablehlo.divide %[[VAL_30]], %[[VAL_19]] : tensor +// CHECK: %[[VAL_32:.*]] = stablehlo.add %[[VAL_16]], %[[VAL_31]] : tensor +// CHECK: %[[VAL_33:.*]] = stablehlo.multiply %[[VAL_16]], %[[VAL_25]] : tensor +// CHECK: %[[VAL_34:.*]] = stablehlo.select %[[VAL_29]], %[[VAL_32]], %[[VAL_33]] : tensor, tensor +// CHECK: %[[VAL_35:.*]] = stablehlo.select %[[VAL_18]], %[[VAL_21]], %[[VAL_34]] : tensor, tensor +// CHECK: %[[VAL_36:.*]] = stablehlo.subtract %[[VAL_2]], %[[VAL_11]] : tensor +// CHECK: %[[VAL_37:.*]] = stablehlo.abs %[[VAL_36]] : tensor +// CHECK: %[[VAL_38:.*]] = stablehlo.maximum %[[VAL_37]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_39:.*]] = stablehlo.minimum %[[VAL_37]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_40:.*]] = stablehlo.compare EQ, %[[VAL_38]], %[[VAL_39]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_41:.*]] = stablehlo.multiply %[[VAL_20]], %[[VAL_38]] : tensor +// CHECK: %[[VAL_42:.*]] = stablehlo.divide %[[VAL_39]], %[[VAL_38]] : tensor +// CHECK: %[[VAL_43:.*]] = stablehlo.multiply %[[VAL_42]], %[[VAL_42]] : tensor +// CHECK: %[[VAL_44:.*]] = stablehlo.add %[[VAL_11]], %[[VAL_43]] : tensor +// CHECK: %[[VAL_45:.*]] = stablehlo.sqrt %[[VAL_44]] : tensor +// CHECK: %[[VAL_46:.*]] = stablehlo.compare EQ, %[[VAL_45]], %[[VAL_11]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_47:.*]] = stablehlo.compare GT, %[[VAL_43]], %[[VAL_27]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_48:.*]] = stablehlo.and %[[VAL_46]], %[[VAL_47]] : tensor +// CHECK: %[[VAL_49:.*]] = stablehlo.multiply %[[VAL_38]], %[[VAL_43]] : tensor +// CHECK: %[[VAL_50:.*]] = stablehlo.divide %[[VAL_49]], %[[VAL_19]] : tensor +// CHECK: %[[VAL_51:.*]] = stablehlo.add %[[VAL_38]], %[[VAL_50]] : tensor +// CHECK: %[[VAL_52:.*]] = stablehlo.multiply %[[VAL_38]], %[[VAL_45]] : tensor +// CHECK: %[[VAL_53:.*]] = stablehlo.select %[[VAL_48]], %[[VAL_51]], %[[VAL_52]] : tensor, tensor +// CHECK: %[[VAL_54:.*]] = stablehlo.select %[[VAL_40]], %[[VAL_41]], %[[VAL_53]] : tensor, tensor +// CHECK: %[[VAL_55:.*]] = stablehlo.add %[[VAL_35]], %[[VAL_54]] : tensor +// CHECK: %[[VAL_56:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_55]] : tensor +// CHECK: %[[VAL_57:.*]] = stablehlo.add %[[VAL_56]], %[[VAL_2]] : tensor +// CHECK: %[[VAL_58:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_57]] : tensor +// CHECK: %[[VAL_59:.*]] = stablehlo.multiply %[[VAL_4]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_60:.*]] = stablehlo.add %[[VAL_35]], %[[VAL_14]] : tensor +// CHECK: %[[VAL_61:.*]] = stablehlo.divide %[[VAL_59]], %[[VAL_60]] : tensor +// CHECK: %[[VAL_62:.*]] = stablehlo.subtract %[[VAL_54]], %[[VAL_36]] : tensor +// CHECK: %[[VAL_63:.*]] = stablehlo.add %[[VAL_61]], %[[VAL_62]] : tensor +// CHECK: %[[VAL_64:.*]] = stablehlo.multiply %[[VAL_58]], %[[VAL_63]] : tensor +// CHECK: %[[VAL_65:.*]] = stablehlo.sqrt %[[VAL_64]] : tensor +// CHECK: %[[VAL_66:.*]] = stablehlo.divide %[[VAL_58]], %[[VAL_60]] : tensor +// CHECK: %[[VAL_67:.*]] = stablehlo.add %[[VAL_54]], %[[VAL_36]] : tensor +// CHECK: %[[VAL_68:.*]] = stablehlo.divide %[[VAL_58]], %[[VAL_67]] : tensor +// CHECK: %[[VAL_69:.*]] = stablehlo.add %[[VAL_66]], %[[VAL_68]] : tensor +// CHECK: %[[VAL_70:.*]] = stablehlo.sqrt %[[VAL_69]] : tensor +// CHECK: %[[VAL_71:.*]] = stablehlo.multiply %[[VAL_4]], %[[VAL_70]] : tensor +// CHECK: %[[VAL_72:.*]] = stablehlo.select %[[VAL_12]], %[[VAL_65]], %[[VAL_71]] : tensor, tensor +// CHECK: %[[VAL_73:.*]] = stablehlo.select %[[VAL_10]], %[[VAL_4]], %[[VAL_72]] : tensor, tensor +// CHECK: %[[VAL_74:.*]] = stablehlo.constant dense<9.99999995E+11> : tensor +// CHECK: %[[VAL_75:.*]] = stablehlo.multiply %[[VAL_9]], %[[VAL_74]] : tensor +// CHECK: %[[VAL_76:.*]] = stablehlo.compare LT, %[[VAL_2]], %[[VAL_75]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_77:.*]] = stablehlo.constant dense<9.99999997E-7> : tensor +// CHECK: %[[VAL_78:.*]] = stablehlo.multiply %[[VAL_9]], %[[VAL_77]] : tensor +// CHECK: %[[VAL_79:.*]] = stablehlo.constant dense<1.000000e+02> : tensor +// CHECK: %[[VAL_80:.*]] = stablehlo.multiply %[[VAL_9]], %[[VAL_79]] : tensor +// CHECK: %[[VAL_81:.*]] = stablehlo.select %[[VAL_76]], %[[VAL_78]], %[[VAL_80]] : tensor, tensor +// CHECK: %[[VAL_82:.*]] = stablehlo.compare GE, %[[VAL_4]], %[[VAL_81]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_83:.*]] = stablehlo.select %[[VAL_82]], %[[VAL_4]], %[[VAL_2]] : tensor, tensor +// CHECK: %[[VAL_84:.*]] = stablehlo.select %[[VAL_82]], %[[VAL_81]], %[[VAL_9]] : tensor, tensor +// CHECK: %[[VAL_85:.*]] = stablehlo.compare GE, %[[VAL_83]], %[[VAL_84]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_86:.*]] = stablehlo.log %[[VAL_19]] : tensor +// CHECK: %[[VAL_87:.*]] = stablehlo.log %[[VAL_83]] : tensor +// CHECK: %[[VAL_88:.*]] = stablehlo.add %[[VAL_86]], %[[VAL_87]] : tensor +// CHECK: %[[VAL_89:.*]] = stablehlo.constant dense<0x7F800000> : tensor +// CHECK: %[[VAL_90:.*]] = stablehlo.compare EQ, %[[VAL_4]], %[[VAL_89]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_91:.*]] = stablehlo.not %[[VAL_90]] : tensor +// CHECK: %[[VAL_92:.*]] = stablehlo.and %[[VAL_82]], %[[VAL_91]] : tensor +// CHECK: %[[VAL_93:.*]] = stablehlo.divide %[[VAL_2]], %[[VAL_4]] : tensor +// CHECK: %[[VAL_94:.*]] = stablehlo.select %[[VAL_92]], %[[VAL_93]], %[[VAL_27]] : tensor, tensor +// CHECK: %[[VAL_95:.*]] = stablehlo.multiply %[[VAL_94]], %[[VAL_94]] : tensor +// CHECK: %[[VAL_96:.*]] = stablehlo.log_plus_one %[[VAL_95]] : tensor +// CHECK: %[[VAL_97:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_96]] : tensor +// CHECK: %[[VAL_98:.*]] = stablehlo.add %[[VAL_88]], %[[VAL_97]] : tensor +// CHECK: %[[VAL_99:.*]] = stablehlo.constant dense<1.17549435E-38> : tensor +// CHECK: %[[VAL_100:.*]] = stablehlo.sqrt %[[VAL_99]] : tensor +// CHECK: %[[VAL_101:.*]] = stablehlo.constant dense<4.000000e+00> : tensor +// CHECK: %[[VAL_102:.*]] = stablehlo.multiply %[[VAL_100]], %[[VAL_101]] : tensor +// CHECK: %[[VAL_103:.*]] = stablehlo.compare LT, %[[VAL_4]], %[[VAL_102]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_104:.*]] = stablehlo.compare LT, %[[VAL_2]], %[[VAL_11]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_105:.*]] = stablehlo.and %[[VAL_103]], %[[VAL_104]] : tensor +// CHECK: %[[VAL_106:.*]] = stablehlo.multiply %[[VAL_14]], %[[VAL_36]] : tensor +// CHECK: %[[VAL_107:.*]] = stablehlo.add %[[VAL_56]], %[[VAL_11]] : tensor +// CHECK: %[[VAL_108:.*]] = stablehlo.divide %[[VAL_106]], %[[VAL_107]] : tensor +// CHECK: %[[VAL_109:.*]] = stablehlo.negate %[[VAL_108]] : tensor +// CHECK: %[[VAL_110:.*]] = stablehlo.compare GE, %[[VAL_2]], %[[VAL_11]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_111:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_59]] : tensor +// CHECK: %[[VAL_112:.*]] = stablehlo.divide %[[VAL_111]], %[[VAL_60]] : tensor +// CHECK: %[[VAL_113:.*]] = stablehlo.multiply %[[VAL_13]], %[[VAL_67]] : tensor +// CHECK: %[[VAL_114:.*]] = stablehlo.add %[[VAL_112]], %[[VAL_113]] : tensor +// CHECK: %[[VAL_115:.*]] = stablehlo.constant dense<1.500000e+00> : tensor +// CHECK: %[[VAL_116:.*]] = stablehlo.compare LE, %[[VAL_56]], %[[VAL_115]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_117:.*]] = stablehlo.divide %[[VAL_111]], %[[VAL_62]] : tensor +// CHECK: %[[VAL_118:.*]] = stablehlo.add %[[VAL_112]], %[[VAL_117]] : tensor +// CHECK: %[[VAL_119:.*]] = stablehlo.subtract %[[VAL_56]], %[[VAL_11]] : tensor +// CHECK: %[[VAL_120:.*]] = stablehlo.select %[[VAL_116]], %[[VAL_118]], %[[VAL_119]] : tensor, tensor +// CHECK: %[[VAL_121:.*]] = stablehlo.select %[[VAL_110]], %[[VAL_114]], %[[VAL_120]] : tensor, tensor +// CHECK: %[[VAL_122:.*]] = stablehlo.select %[[VAL_105]], %[[VAL_109]], %[[VAL_121]] : tensor, tensor +// CHECK: %[[VAL_123:.*]] = stablehlo.multiply %[[VAL_122]], %[[VAL_107]] : tensor +// CHECK: %[[VAL_124:.*]] = stablehlo.sqrt %[[VAL_123]] : tensor +// CHECK: %[[VAL_125:.*]] = stablehlo.divide %[[VAL_4]], %[[VAL_124]] : tensor +// CHECK: %[[VAL_126:.*]] = stablehlo.add %[[VAL_122]], %[[VAL_124]] : tensor +// CHECK: %[[VAL_127:.*]] = stablehlo.log_plus_one %[[VAL_126]] : tensor +// CHECK: %[[VAL_128:.*]] = stablehlo.select %[[VAL_105]], %[[VAL_125]], %[[VAL_127]] : tensor, tensor +// CHECK: %[[VAL_129:.*]] = stablehlo.select %[[VAL_85]], %[[VAL_98]], %[[VAL_128]] : tensor, tensor +// CHECK: %[[VAL_130:.*]] = stablehlo.complex %[[VAL_73]], %[[VAL_129]] : tensor> +// CHECK: %[[VAL_131:.*]] = stablehlo.imag %[[VAL_130]] : (tensor>) -> tensor +// CHECK: %[[VAL_132:.*]] = stablehlo.imag %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_133:.*]] = stablehlo.constant dense<0.000000e+00> : tensor +// CHECK: %[[VAL_134:.*]] = stablehlo.compare LT, %[[VAL_132]], %[[VAL_133]] : (tensor, tensor) -> tensor +// CHECK: %[[VAL_135:.*]] = stablehlo.real %[[VAL_130]] : (tensor>) -> tensor +// CHECK: %[[VAL_136:.*]] = stablehlo.real %[[VAL_0]] : (tensor>) -> tensor +// CHECK: %[[VAL_137:.*]] = stablehlo.atan2 %[[VAL_135]], %[[VAL_136]] : tensor +// CHECK: %[[VAL_138:.*]] = stablehlo.negate %[[VAL_137]] : tensor +// CHECK: %[[VAL_139:.*]] = stablehlo.select %[[VAL_134]], %[[VAL_138]], %[[VAL_137]] : tensor, tensor +// CHECK: %[[VAL_140:.*]] = stablehlo.complex %[[VAL_131]], %[[VAL_139]] : tensor> +// CHECK: return %[[VAL_140]] : tensor> +// CHECK: } func.func @acosh_complex_f32(%arg : tensor>) -> tensor> { -// CHECK: %[[TMP_0:.*]] = stablehlo.imag %[[TMP_arg0]] : (tensor>) -> tensor -// CHECK: %[[TMP_1:.*]] = stablehlo.constant dense<0.000000e+00> : tensor -// CHECK: %[[TMP_2:.*]] = stablehlo.compare LT, %[[TMP_0]], %[[TMP_1]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_3:.*]] = stablehlo.real %[[TMP_arg0]] : (tensor>) -> tensor -// CHECK: %[[TMP_4:.*]] = stablehlo.constant dense<0.000000e+00> : tensor -// CHECK: %[[TMP_5:.*]] = stablehlo.compare LT, %[[TMP_0]], %[[TMP_4]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_6:.*]] = stablehlo.abs %[[TMP_0]] : tensor -// CHECK: %[[TMP_7:.*]] = stablehlo.abs %[[TMP_3]] : tensor -// CHECK: %[[TMP_8:.*]] = stablehlo.constant dense<3.40282347E+38> : tensor -// CHECK: %[[TMP_9:.*]] = stablehlo.sqrt %[[TMP_8]] : tensor -// CHECK: %[[TMP_10:.*]] = stablehlo.constant dense<8.000000e+00> : tensor -// CHECK: %[[TMP_11:.*]] = stablehlo.divide %[[TMP_9]], %[[TMP_10]] : tensor -// CHECK: %[[TMP_12:.*]] = stablehlo.constant dense<9.99999995E+11> : tensor -// CHECK: %[[TMP_13:.*]] = stablehlo.multiply %[[TMP_11]], %[[TMP_12]] : tensor -// CHECK: %[[TMP_14:.*]] = stablehlo.compare LT, %[[TMP_7]], %[[TMP_13]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_15:.*]] = stablehlo.constant dense<9.99999997E-7> : tensor -// CHECK: %[[TMP_16:.*]] = stablehlo.multiply %[[TMP_11]], %[[TMP_15]] : tensor -// CHECK: %[[TMP_17:.*]] = stablehlo.constant dense<1.000000e+02> : tensor -// CHECK: %[[TMP_18:.*]] = stablehlo.multiply %[[TMP_11]], %[[TMP_17]] : tensor -// CHECK: %[[TMP_19:.*]] = stablehlo.select %[[TMP_14]], %[[TMP_16]], %[[TMP_18]] : tensor, tensor -// CHECK: %[[TMP_20:.*]] = stablehlo.compare GE, %[[TMP_6]], %[[TMP_19]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_21:.*]] = stablehlo.select %[[TMP_20]], %[[TMP_6]], %[[TMP_7]] : tensor, tensor -// CHECK: %[[TMP_22:.*]] = stablehlo.select %[[TMP_20]], %[[TMP_19]], %[[TMP_11]] : tensor, tensor -// CHECK: %[[TMP_23:.*]] = stablehlo.compare GE, %[[TMP_21]], %[[TMP_22]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_24:.*]] = stablehlo.constant dense<2.000000e+00> : tensor -// CHECK: %[[TMP_25:.*]] = stablehlo.log %[[TMP_24]] : tensor -// CHECK: %[[TMP_26:.*]] = stablehlo.log %[[TMP_21]] : tensor -// CHECK: %[[TMP_27:.*]] = stablehlo.add %[[TMP_25]], %[[TMP_26]] : tensor -// CHECK: %[[TMP_28:.*]] = stablehlo.constant dense<5.000000e-01> : tensor -// CHECK: %[[TMP_29:.*]] = stablehlo.constant dense<0x7F800000> : tensor -// CHECK: %[[TMP_30:.*]] = stablehlo.compare EQ, %[[TMP_6]], %[[TMP_29]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_31:.*]] = stablehlo.not %[[TMP_30]] : tensor -// CHECK: %[[TMP_32:.*]] = stablehlo.and %[[TMP_20]], %[[TMP_31]] : tensor -// CHECK: %[[TMP_33:.*]] = stablehlo.divide %[[TMP_7]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_34:.*]] = stablehlo.select %[[TMP_32]], %[[TMP_33]], %[[TMP_4]] : tensor, tensor -// CHECK: %[[TMP_35:.*]] = stablehlo.multiply %[[TMP_34]], %[[TMP_34]] : tensor -// CHECK: %[[TMP_36:.*]] = stablehlo.log_plus_one %[[TMP_35]] : tensor -// CHECK: %[[TMP_37:.*]] = stablehlo.multiply %[[TMP_28]], %[[TMP_36]] : tensor -// CHECK: %[[TMP_38:.*]] = stablehlo.add %[[TMP_27]], %[[TMP_37]] : tensor -// CHECK: %[[TMP_39:.*]] = stablehlo.constant dense<1.17549435E-38> : tensor -// CHECK: %[[TMP_40:.*]] = stablehlo.sqrt %[[TMP_39]] : tensor -// CHECK: %[[TMP_41:.*]] = stablehlo.constant dense<4.000000e+00> : tensor -// CHECK: %[[TMP_42:.*]] = stablehlo.multiply %[[TMP_40]], %[[TMP_41]] : tensor -// CHECK: %[[TMP_43:.*]] = stablehlo.compare LT, %[[TMP_6]], %[[TMP_42]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_44:.*]] = stablehlo.constant dense<1.000000e+00> : tensor -// CHECK: %[[TMP_45:.*]] = stablehlo.compare LT, %[[TMP_7]], %[[TMP_44]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_46:.*]] = stablehlo.and %[[TMP_43]], %[[TMP_45]] : tensor -// CHECK: %[[TMP_47:.*]] = stablehlo.add %[[TMP_7]], %[[TMP_44]] : tensor -// CHECK: %[[TMP_48:.*]] = stablehlo.subtract %[[TMP_7]], %[[TMP_44]] : tensor -// CHECK: %[[TMP_49:.*]] = stablehlo.multiply %[[TMP_47]], %[[TMP_48]] : tensor -// CHECK: %[[TMP_50:.*]] = stablehlo.abs %[[TMP_47]] : tensor -// CHECK: %[[TMP_51:.*]] = stablehlo.maximum %[[TMP_50]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_52:.*]] = stablehlo.minimum %[[TMP_50]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_53:.*]] = stablehlo.compare EQ, %[[TMP_51]], %[[TMP_52]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_54:.*]] = stablehlo.sqrt %[[TMP_24]] : tensor -// CHECK: %[[TMP_55:.*]] = stablehlo.multiply %[[TMP_54]], %[[TMP_51]] : tensor -// CHECK: %[[TMP_56:.*]] = stablehlo.divide %[[TMP_52]], %[[TMP_51]] : tensor -// CHECK: %[[TMP_57:.*]] = stablehlo.multiply %[[TMP_56]], %[[TMP_56]] : tensor -// CHECK: %[[TMP_58:.*]] = stablehlo.add %[[TMP_44]], %[[TMP_57]] : tensor -// CHECK: %[[TMP_59:.*]] = stablehlo.sqrt %[[TMP_58]] : tensor -// CHECK: %[[TMP_60:.*]] = stablehlo.compare EQ, %[[TMP_59]], %[[TMP_44]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_61:.*]] = stablehlo.compare GT, %[[TMP_57]], %[[TMP_4]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_62:.*]] = stablehlo.and %[[TMP_60]], %[[TMP_61]] : tensor -// CHECK: %[[TMP_63:.*]] = stablehlo.multiply %[[TMP_51]], %[[TMP_57]] : tensor -// CHECK: %[[TMP_64:.*]] = stablehlo.divide %[[TMP_63]], %[[TMP_24]] : tensor -// CHECK: %[[TMP_65:.*]] = stablehlo.add %[[TMP_51]], %[[TMP_64]] : tensor -// CHECK: %[[TMP_66:.*]] = stablehlo.multiply %[[TMP_51]], %[[TMP_59]] : tensor -// CHECK: %[[TMP_67:.*]] = stablehlo.select %[[TMP_62]], %[[TMP_65]], %[[TMP_66]] : tensor, tensor -// CHECK: %[[TMP_68:.*]] = stablehlo.select %[[TMP_53]], %[[TMP_55]], %[[TMP_67]] : tensor, tensor -// CHECK: %[[TMP_69:.*]] = stablehlo.abs %[[TMP_48]] : tensor -// CHECK: %[[TMP_70:.*]] = stablehlo.maximum %[[TMP_69]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_71:.*]] = stablehlo.minimum %[[TMP_69]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_72:.*]] = stablehlo.compare EQ, %[[TMP_70]], %[[TMP_71]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_73:.*]] = stablehlo.multiply %[[TMP_54]], %[[TMP_70]] : tensor -// CHECK: %[[TMP_74:.*]] = stablehlo.divide %[[TMP_71]], %[[TMP_70]] : tensor -// CHECK: %[[TMP_75:.*]] = stablehlo.multiply %[[TMP_74]], %[[TMP_74]] : tensor -// CHECK: %[[TMP_76:.*]] = stablehlo.add %[[TMP_44]], %[[TMP_75]] : tensor -// CHECK: %[[TMP_77:.*]] = stablehlo.sqrt %[[TMP_76]] : tensor -// CHECK: %[[TMP_78:.*]] = stablehlo.compare EQ, %[[TMP_77]], %[[TMP_44]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_79:.*]] = stablehlo.compare GT, %[[TMP_75]], %[[TMP_4]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_80:.*]] = stablehlo.and %[[TMP_78]], %[[TMP_79]] : tensor -// CHECK: %[[TMP_81:.*]] = stablehlo.multiply %[[TMP_70]], %[[TMP_75]] : tensor -// CHECK: %[[TMP_82:.*]] = stablehlo.divide %[[TMP_81]], %[[TMP_24]] : tensor -// CHECK: %[[TMP_83:.*]] = stablehlo.add %[[TMP_70]], %[[TMP_82]] : tensor -// CHECK: %[[TMP_84:.*]] = stablehlo.multiply %[[TMP_70]], %[[TMP_77]] : tensor -// CHECK: %[[TMP_85:.*]] = stablehlo.select %[[TMP_80]], %[[TMP_83]], %[[TMP_84]] : tensor, tensor -// CHECK: %[[TMP_86:.*]] = stablehlo.select %[[TMP_72]], %[[TMP_73]], %[[TMP_85]] : tensor, tensor -// CHECK: %[[TMP_87:.*]] = stablehlo.add %[[TMP_68]], %[[TMP_86]] : tensor -// CHECK: %[[TMP_88:.*]] = stablehlo.multiply %[[TMP_28]], %[[TMP_87]] : tensor -// CHECK: %[[TMP_89:.*]] = stablehlo.add %[[TMP_88]], %[[TMP_44]] : tensor -// CHECK: %[[TMP_90:.*]] = stablehlo.divide %[[TMP_49]], %[[TMP_89]] : tensor -// CHECK: %[[TMP_91:.*]] = stablehlo.negate %[[TMP_90]] : tensor -// CHECK: %[[TMP_92:.*]] = stablehlo.compare GE, %[[TMP_7]], %[[TMP_44]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_93:.*]] = stablehlo.multiply %[[TMP_6]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_94:.*]] = stablehlo.multiply %[[TMP_28]], %[[TMP_93]] : tensor -// CHECK: %[[TMP_95:.*]] = stablehlo.add %[[TMP_68]], %[[TMP_47]] : tensor -// CHECK: %[[TMP_96:.*]] = stablehlo.divide %[[TMP_94]], %[[TMP_95]] : tensor -// CHECK: %[[TMP_97:.*]] = stablehlo.add %[[TMP_86]], %[[TMP_48]] : tensor -// CHECK: %[[TMP_98:.*]] = stablehlo.multiply %[[TMP_28]], %[[TMP_97]] : tensor -// CHECK: %[[TMP_99:.*]] = stablehlo.add %[[TMP_96]], %[[TMP_98]] : tensor -// CHECK: %[[TMP_100:.*]] = stablehlo.constant dense<1.500000e+00> : tensor -// CHECK: %[[TMP_101:.*]] = stablehlo.compare LE, %[[TMP_88]], %[[TMP_100]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_102:.*]] = stablehlo.subtract %[[TMP_86]], %[[TMP_48]] : tensor -// CHECK: %[[TMP_103:.*]] = stablehlo.divide %[[TMP_94]], %[[TMP_102]] : tensor -// CHECK: %[[TMP_104:.*]] = stablehlo.add %[[TMP_96]], %[[TMP_103]] : tensor -// CHECK: %[[TMP_105:.*]] = stablehlo.subtract %[[TMP_88]], %[[TMP_44]] : tensor -// CHECK: %[[TMP_106:.*]] = stablehlo.select %[[TMP_101]], %[[TMP_104]], %[[TMP_105]] : tensor, tensor -// CHECK: %[[TMP_107:.*]] = stablehlo.select %[[TMP_92]], %[[TMP_99]], %[[TMP_106]] : tensor, tensor -// CHECK: %[[TMP_108:.*]] = stablehlo.select %[[TMP_46]], %[[TMP_91]], %[[TMP_107]] : tensor, tensor -// CHECK: %[[TMP_109:.*]] = stablehlo.multiply %[[TMP_108]], %[[TMP_89]] : tensor -// CHECK: %[[TMP_110:.*]] = stablehlo.sqrt %[[TMP_109]] : tensor -// CHECK: %[[TMP_111:.*]] = stablehlo.divide %[[TMP_6]], %[[TMP_110]] : tensor -// CHECK: %[[TMP_112:.*]] = stablehlo.add %[[TMP_108]], %[[TMP_110]] : tensor -// CHECK: %[[TMP_113:.*]] = stablehlo.log_plus_one %[[TMP_112]] : tensor -// CHECK: %[[TMP_114:.*]] = stablehlo.select %[[TMP_46]], %[[TMP_111]], %[[TMP_113]] : tensor, tensor -// CHECK: %[[TMP_115:.*]] = stablehlo.select %[[TMP_23]], %[[TMP_38]], %[[TMP_114]] : tensor, tensor -// CHECK: %[[TMP_116:.*]] = stablehlo.negate %[[TMP_115]] : tensor -// CHECK: %[[TMP_117:.*]] = stablehlo.select %[[TMP_5]], %[[TMP_115]], %[[TMP_116]] : tensor, tensor -// CHECK: %[[TMP_118:.*]] = stablehlo.negate %[[TMP_117]] : tensor -// CHECK: %[[TMP_119:.*]] = stablehlo.maximum %[[TMP_7]], %[[TMP_6]] : tensor -// CHECK: %[[TMP_120:.*]] = stablehlo.compare GE, %[[TMP_119]], %[[TMP_11]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_121:.*]] = stablehlo.compare LE, %[[TMP_7]], %[[TMP_44]] : (tensor, tensor) -> tensor -// CHECK: %[[TMP_122:.*]] = stablehlo.add %[[TMP_88]], %[[TMP_7]] : tensor -// CHECK: %[[TMP_123:.*]] = stablehlo.multiply %[[TMP_28]], %[[TMP_122]] : tensor -// CHECK: %[[TMP_124:.*]] = stablehlo.divide %[[TMP_93]], %[[TMP_95]] : tensor -// CHECK: %[[TMP_125:.*]] = stablehlo.add %[[TMP_124]], %[[TMP_102]] : tensor -// CHECK: %[[TMP_126:.*]] = stablehlo.multiply %[[TMP_123]], %[[TMP_125]] : tensor -// CHECK: %[[TMP_127:.*]] = stablehlo.sqrt %[[TMP_126]] : tensor -// CHECK: %[[TMP_128:.*]] = stablehlo.divide %[[TMP_123]], %[[TMP_95]] : tensor -// CHECK: %[[TMP_129:.*]] = stablehlo.divide %[[TMP_123]], %[[TMP_97]] : tensor -// CHECK: %[[TMP_130:.*]] = stablehlo.add %[[TMP_128]], %[[TMP_129]] : tensor -// CHECK: %[[TMP_131:.*]] = stablehlo.sqrt %[[TMP_130]] : tensor -// CHECK: %[[TMP_132:.*]] = stablehlo.multiply %[[TMP_6]], %[[TMP_131]] : tensor -// CHECK: %[[TMP_133:.*]] = stablehlo.select %[[TMP_121]], %[[TMP_127]], %[[TMP_132]] : tensor, tensor -// CHECK: %[[TMP_134:.*]] = stablehlo.select %[[TMP_120]], %[[TMP_6]], %[[TMP_133]] : tensor, tensor -// CHECK: %[[TMP_135:.*]] = stablehlo.atan2 %[[TMP_134]], %[[TMP_3]] : tensor -// CHECK: %[[TMP_136:.*]] = stablehlo.complex %[[TMP_118]], %[[TMP_135]] : tensor> -// CHECK: %[[TMP_137:.*]] = stablehlo.negate %[[TMP_136]] : tensor> -// CHECK: %[[TMP_138:.*]] = stablehlo.select %[[TMP_2]], %[[TMP_137]], %[[TMP_136]] : tensor, tensor> -// CHECK: return %[[TMP_138]] : tensor> %result = "chlo.acosh"(%arg) : (tensor>) -> tensor> func.return %result : tensor> }