#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ __finitel(long double);
scalar_t__ __fpclassifyl(long double);
scalar_t__ __isinfl(long double);
scalar_t__ __isnanl(long double);
scalar_t__ __signbitl(long double);
scalar_t__ acoshl(long double);
scalar_t__ acosl(long double);
scalar_t__ asinhl(long double);
scalar_t__ asinl(long double);
scalar_t__ atan2l(long double, long double);
scalar_t__ atanhl(long double);
scalar_t__ atanl(long double);
scalar_t__ cbrtl(long double);
scalar_t__ ceill(long double);
scalar_t__ copysignl(long double, long double);
scalar_t__ coshl(long double);
scalar_t__ cosl(long double);
scalar_t__ erfcl(long double);
scalar_t__ erfl(long double);
scalar_t__ exp2l(long double);
scalar_t__ expl(long double);
scalar_t__ expm1l(long double);
scalar_t__ fabsl(long double);
scalar_t__ fdiml(long double, long double);
scalar_t__ floorl(long double);
scalar_t__ fmal(long double, long double, long double);
scalar_t__ fmaxl(long double, long double);
scalar_t__ fminl(long double, long double);
scalar_t__ fmodl(long double, long double);
scalar_t__ frexpl(long double, int *);
scalar_t__ hypotl(long double, long double);
scalar_t__ ilogbl(long double);
scalar_t__ ldexpl(long double, int);
scalar_t__ lgammal(long double);
scalar_t__ llrintl(long double);
scalar_t__ llroundl(long double);
scalar_t__ log10l(long double);
scalar_t__ log1pl(long double);
scalar_t__ log2l(long double);
scalar_t__ logbl(long double);
scalar_t__ logl(long double);
scalar_t__ lrintl(long double);
scalar_t__ lroundl(long double);
scalar_t__ modfl(long double, long double *);
scalar_t__ nearbyintl(long double);
scalar_t__ nextafterl(long double, long double);
scalar_t__ powl(long double, long double);
scalar_t__ remainderl(long double, long double);
scalar_t__ remquol(long double, long double, int *);
scalar_t__ rintl(long double);
scalar_t__ roundl(long double);
scalar_t__ scalblnl(long double, long);
scalar_t__ scalbnl(long double, int);
scalar_t__ sinhl(long double);
scalar_t__ sinl(long double);
scalar_t__ sqrtl(long double);
scalar_t__ tanhl(long double);
scalar_t__ tanl(long double);
scalar_t__ tgammal(long double);
scalar_t__ truncl(long double);
int testl(long double long_double_x, int int_x, long long_x) {
  int r = 0;
  r += __finitel(long_double_x);
  r += __fpclassifyl(long_double_x);
  r += __isinfl(long_double_x);
  r += __isnanl(long_double_x);
  r += __signbitl(long_double_x);
  r += acoshl(long_double_x);
  r += acosl(long_double_x);
  r += asinhl(long_double_x);
  r += asinl(long_double_x);
  r += atan2l(long_double_x, long_double_x);
  r += atanhl(long_double_x);
  r += atanl(long_double_x);
  r += cbrtl(long_double_x);
  r += ceill(long_double_x);
  r += copysignl(long_double_x, long_double_x);
  r += coshl(long_double_x);
  r += cosl(long_double_x);
  r += erfcl(long_double_x);
  r += erfl(long_double_x);
  r += exp2l(long_double_x);
  r += expl(long_double_x);
  r += expm1l(long_double_x);
  r += fabsl(long_double_x);
  r += fdiml(long_double_x, long_double_x);
  r += floorl(long_double_x);
  r += fmal(long_double_x, long_double_x, long_double_x);
  r += fmaxl(long_double_x, long_double_x);
  r += fminl(long_double_x, long_double_x);
  r += fmodl(long_double_x, long_double_x);
  r += frexpl(long_double_x, &int_x);
  r += hypotl(long_double_x, long_double_x);
  r += ilogbl(long_double_x);
  r += ldexpl(long_double_x, int_x);
  r += lgammal(long_double_x);
  r += llrintl(long_double_x);
  r += llroundl(long_double_x);
  r += log10l(long_double_x);
  r += log1pl(long_double_x);
  r += log2l(long_double_x);
  r += logbl(long_double_x);
  r += logl(long_double_x);
  r += lrintl(long_double_x);
  r += lroundl(long_double_x);
  r += modfl(long_double_x, &long_double_x);
  r += nearbyintl(long_double_x);
  r += nextafterl(long_double_x, long_double_x);
  r += powl(long_double_x, long_double_x);
  r += remainderl(long_double_x, long_double_x);
  r += remquol(long_double_x, long_double_x, &int_x);
  r += rintl(long_double_x);
  r += roundl(long_double_x);
  r += scalblnl(long_double_x, long_x);
  r += scalbnl(long_double_x, int_x);
  r += sinhl(long_double_x);
  r += sinl(long_double_x);
  r += sqrtl(long_double_x);
  r += tanhl(long_double_x);
  r += tanl(long_double_x);
  r += tgammal(long_double_x);
  r += truncl(long_double_x);
  return r;
}


x86 assembly (clang, -O0):
<testl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
fldt   0x10(%rbp)
fstpt  -0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   23b0 <__finitel@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   20d0 <__fpclassifyl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   21e0 <__isinfl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   21f0 <__isnanl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2190 <__signbitl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2350 <acoshl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2150 <acosl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2340 <asinhl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2380 <asinl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   23d0 <atan2l@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   22b0 <atanhl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2110 <atanl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   21d0 <cbrtl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   22c0 <ceill@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   22d0 <copysignl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   20c0 <coshl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2130 <cosl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   20a0 <erfcl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   21c0 <erfl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2170 <exp2l@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   21a0 <expl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2300 <expm1l@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2060 <fabsl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   20b0 <fdiml@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   23c0 <floorl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x20(%rax)
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2330 <fmal@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   22a0 <fmaxl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2180 <fminl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2140 <fmodl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    -0x14(%rbp),%rdi
mov    %rdi,-0x30(%rbp)
call   2260 <frexpl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   20f0 <hypotl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2080 <ilogbl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    -0x14(%rbp),%edi
mov    %rsp,%rax
fstpt  (%rax)
call   2290 <ldexpl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   22e0 <lgammal@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   22f0 <llrintl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2220 <llroundl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   23a0 <log10l@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2100 <log1pl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2230 <log2l@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2210 <logbl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   20e0 <logl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2070 <lrintl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2240 <lroundl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    -0x10(%rbp),%rdi
call   21b0 <modfl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2200 <nearbyintl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2030 <nextafterl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2090 <powl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2310 <remainderl@plt>
mov    -0x30(%rbp),%rdi
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fld    %st(0)
fstpt  0x10(%rax)
fstpt  (%rax)
call   2320 <remquol@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2270 <rintl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2370 <roundl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    -0x20(%rbp),%rdi
mov    %rsp,%rax
fstpt  (%rax)
call   2360 <scalblnl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    -0x14(%rbp),%edi
mov    %rsp,%rax
fstpt  (%rax)
call   23e0 <scalbnl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2160 <sinhl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2050 <sinl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2280 <sqrtl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2040 <tanhl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2120 <tanl@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2250 <tgammal@plt>
mov    %rax,%rcx
mov    -0x24(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
fldt   -0x10(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   2390 <truncl@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testl>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    %rsi,%r14
fldt   0x80(%rsp)
fld    %st(0)
fstpt  0x30(%rsp)
fld    %st(0)
fstpt  0x40(%rsp)
mov    %edi,0x3c(%rsp)
fstpt  (%rsp)
call   23b0 <__finitel@plt>
mov    %rax,%r15
fldt   0x30(%rsp)
fstpt  (%rsp)
call   20d0 <__fpclassifyl@plt>
mov    %rax,%r12
add    %r15d,%r12d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   21e0 <__isinfl@plt>
mov    %rax,%rbx
add    %r12d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   21f0 <__isnanl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2190 <__signbitl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2350 <acoshl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2150 <acosl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2340 <asinhl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2380 <asinl@plt>
mov    %rax,%r12
add    %r15d,%r12d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   23d0 <atan2l@plt>
mov    %rax,%rbx
add    %r12d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   22b0 <atanhl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2110 <atanl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   21d0 <cbrtl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   22c0 <ceill@plt>
mov    %rax,%r12
add    %r15d,%r12d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   22d0 <copysignl@plt>
mov    %rax,%rbx
add    %r12d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   20c0 <coshl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2130 <cosl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   20a0 <erfcl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   21c0 <erfl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2170 <exp2l@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   21a0 <expl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2300 <expm1l@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2060 <fabsl@plt>
mov    %rax,%r12
add    %r15d,%r12d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   20b0 <fdiml@plt>
mov    %rax,%rbx
add    %r12d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   23c0 <floorl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x20(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   2330 <fmal@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   22a0 <fmaxl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   2180 <fminl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   2140 <fmodl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
lea    0x3c(%rsp),%r12
mov    %r12,%rdi
call   2260 <frexpl@plt>
mov    %rax,%r13
add    %r15d,%r13d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   20f0 <hypotl@plt>
mov    %rax,%rbx
add    %r13d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2080 <ilogbl@plt>
mov    %rax,%r15
add    %ebx,%r15d
mov    0x3c(%rsp),%edi
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2290 <ldexpl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   22e0 <lgammal@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   22f0 <llrintl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2220 <llroundl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   23a0 <log10l@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2100 <log1pl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2230 <log2l@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2210 <logbl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   20e0 <logl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2070 <lrintl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2240 <lroundl@plt>
mov    %rax,%r13
add    %r15d,%r13d
fldt   0x30(%rsp)
fstpt  (%rsp)
lea    0x40(%rsp),%rdi
call   21b0 <modfl@plt>
mov    %rax,%rbx
add    %r13d,%ebx
fldt   0x40(%rsp)
fld    %st(0)
fstpt  0x30(%rsp)
fstpt  (%rsp)
call   2200 <nearbyintl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   2030 <nextafterl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   2090 <powl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   2310 <remainderl@plt>
mov    %rax,%r13
add    %r15d,%r13d
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r12,%rdi
call   2320 <remquol@plt>
mov    %rax,%rbx
add    %r13d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2270 <rintl@plt>
mov    %rax,%r15
add    %ebx,%r15d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2370 <roundl@plt>
mov    %rax,%rbx
add    %r15d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
mov    %r14,%rdi
call   2360 <scalblnl@plt>
mov    %rax,%r14
add    %ebx,%r14d
mov    0x3c(%rsp),%edi
fldt   0x30(%rsp)
fstpt  (%rsp)
call   23e0 <scalbnl@plt>
mov    %rax,%rbx
add    %r14d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2160 <sinhl@plt>
mov    %rax,%r14
add    %ebx,%r14d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2050 <sinl@plt>
mov    %rax,%rbx
add    %r14d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2280 <sqrtl@plt>
mov    %rax,%r14
add    %ebx,%r14d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2040 <tanhl@plt>
mov    %rax,%rbx
add    %r14d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2120 <tanl@plt>
mov    %rax,%r14
add    %ebx,%r14d
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2250 <tgammal@plt>
mov    %rax,%rbx
add    %r14d,%ebx
fldt   0x30(%rsp)
fstpt  (%rsp)
call   2390 <truncl@plt>
add    %ebx,%eax
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i32 @testl(x86_fp80 %0, i32 %1, i64 %2) {
%4 = alloca x86_fp80
%5 = alloca i32
%6 = alloca i64
%7 = alloca i32
store x86_fp80 %0, x86_fp80* %4
store i32 %1, i32* %5
store i64 %2, i64* %6
store i32 0, i32* %7
%8 = load x86_fp80, x86_fp80* %4
%9 = call i64 @__finitel(x86_fp80 %8)
%10 = load i32, i32* %7
%11 = sext i32 %10 to i64
%12 = add nsw i64 %11, %9
%13 = trunc i64 %12 to i32
store i32 %13, i32* %7
%14 = load x86_fp80, x86_fp80* %4
%15 = call i64 @__fpclassifyl(x86_fp80 %14)
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = add nsw i64 %17, %15
%19 = trunc i64 %18 to i32
store i32 %19, i32* %7
%20 = load x86_fp80, x86_fp80* %4
%21 = call i64 @__isinfl(x86_fp80 %20)
%22 = load i32, i32* %7
%23 = sext i32 %22 to i64
%24 = add nsw i64 %23, %21
%25 = trunc i64 %24 to i32
store i32 %25, i32* %7
%26 = load x86_fp80, x86_fp80* %4
%27 = call i64 @__isnanl(x86_fp80 %26)
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = add nsw i64 %29, %27
%31 = trunc i64 %30 to i32
store i32 %31, i32* %7
%32 = load x86_fp80, x86_fp80* %4
%33 = call i64 @__signbitl(x86_fp80 %32)
%34 = load i32, i32* %7
%35 = sext i32 %34 to i64
%36 = add nsw i64 %35, %33
%37 = trunc i64 %36 to i32
store i32 %37, i32* %7
%38 = load x86_fp80, x86_fp80* %4
%39 = call i64 @acoshl(x86_fp80 %38)
%40 = load i32, i32* %7
%41 = sext i32 %40 to i64
%42 = add nsw i64 %41, %39
%43 = trunc i64 %42 to i32
store i32 %43, i32* %7
%44 = load x86_fp80, x86_fp80* %4
%45 = call i64 @acosl(x86_fp80 %44)
%46 = load i32, i32* %7
%47 = sext i32 %46 to i64
%48 = add nsw i64 %47, %45
%49 = trunc i64 %48 to i32
store i32 %49, i32* %7
%50 = load x86_fp80, x86_fp80* %4
%51 = call i64 @asinhl(x86_fp80 %50)
%52 = load i32, i32* %7
%53 = sext i32 %52 to i64
%54 = add nsw i64 %53, %51
%55 = trunc i64 %54 to i32
store i32 %55, i32* %7
%56 = load x86_fp80, x86_fp80* %4
%57 = call i64 @asinl(x86_fp80 %56)
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = add nsw i64 %59, %57
%61 = trunc i64 %60 to i32
store i32 %61, i32* %7
%62 = load x86_fp80, x86_fp80* %4
%63 = load x86_fp80, x86_fp80* %4
%64 = call i64 @atan2l(x86_fp80 %62, x86_fp80 %63)
%65 = load i32, i32* %7
%66 = sext i32 %65 to i64
%67 = add nsw i64 %66, %64
%68 = trunc i64 %67 to i32
store i32 %68, i32* %7
%69 = load x86_fp80, x86_fp80* %4
%70 = call i64 @atanhl(x86_fp80 %69)
%71 = load i32, i32* %7
%72 = sext i32 %71 to i64
%73 = add nsw i64 %72, %70
%74 = trunc i64 %73 to i32
store i32 %74, i32* %7
%75 = load x86_fp80, x86_fp80* %4
%76 = call i64 @atanl(x86_fp80 %75)
%77 = load i32, i32* %7
%78 = sext i32 %77 to i64
%79 = add nsw i64 %78, %76
%80 = trunc i64 %79 to i32
store i32 %80, i32* %7
%81 = load x86_fp80, x86_fp80* %4
%82 = call i64 @cbrtl(x86_fp80 %81)
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = add nsw i64 %84, %82
%86 = trunc i64 %85 to i32
store i32 %86, i32* %7
%87 = load x86_fp80, x86_fp80* %4
%88 = call i64 @ceill(x86_fp80 %87)
%89 = load i32, i32* %7
%90 = sext i32 %89 to i64
%91 = add nsw i64 %90, %88
%92 = trunc i64 %91 to i32
store i32 %92, i32* %7
%93 = load x86_fp80, x86_fp80* %4
%94 = load x86_fp80, x86_fp80* %4
%95 = call i64 @copysignl(x86_fp80 %93, x86_fp80 %94)
%96 = load i32, i32* %7
%97 = sext i32 %96 to i64
%98 = add nsw i64 %97, %95
%99 = trunc i64 %98 to i32
store i32 %99, i32* %7
%100 = load x86_fp80, x86_fp80* %4
%101 = call i64 @coshl(x86_fp80 %100)
%102 = load i32, i32* %7
%103 = sext i32 %102 to i64
%104 = add nsw i64 %103, %101
%105 = trunc i64 %104 to i32
store i32 %105, i32* %7
%106 = load x86_fp80, x86_fp80* %4
%107 = call i64 @cosl(x86_fp80 %106)
%108 = load i32, i32* %7
%109 = sext i32 %108 to i64
%110 = add nsw i64 %109, %107
%111 = trunc i64 %110 to i32
store i32 %111, i32* %7
%112 = load x86_fp80, x86_fp80* %4
%113 = call i64 @erfcl(x86_fp80 %112)
%114 = load i32, i32* %7
%115 = sext i32 %114 to i64
%116 = add nsw i64 %115, %113
%117 = trunc i64 %116 to i32
store i32 %117, i32* %7
%118 = load x86_fp80, x86_fp80* %4
%119 = call i64 @erfl(x86_fp80 %118)
%120 = load i32, i32* %7
%121 = sext i32 %120 to i64
%122 = add nsw i64 %121, %119
%123 = trunc i64 %122 to i32
store i32 %123, i32* %7
%124 = load x86_fp80, x86_fp80* %4
%125 = call i64 @exp2l(x86_fp80 %124)
%126 = load i32, i32* %7
%127 = sext i32 %126 to i64
%128 = add nsw i64 %127, %125
%129 = trunc i64 %128 to i32
store i32 %129, i32* %7
%130 = load x86_fp80, x86_fp80* %4
%131 = call i64 @expl(x86_fp80 %130)
%132 = load i32, i32* %7
%133 = sext i32 %132 to i64
%134 = add nsw i64 %133, %131
%135 = trunc i64 %134 to i32
store i32 %135, i32* %7
%136 = load x86_fp80, x86_fp80* %4
%137 = call i64 @expm1l(x86_fp80 %136)
%138 = load i32, i32* %7
%139 = sext i32 %138 to i64
%140 = add nsw i64 %139, %137
%141 = trunc i64 %140 to i32
store i32 %141, i32* %7
%142 = load x86_fp80, x86_fp80* %4
%143 = call i64 @fabsl(x86_fp80 %142)
%144 = load i32, i32* %7
%145 = sext i32 %144 to i64
%146 = add nsw i64 %145, %143
%147 = trunc i64 %146 to i32
store i32 %147, i32* %7
%148 = load x86_fp80, x86_fp80* %4
%149 = load x86_fp80, x86_fp80* %4
%150 = call i64 @fdiml(x86_fp80 %148, x86_fp80 %149)
%151 = load i32, i32* %7
%152 = sext i32 %151 to i64
%153 = add nsw i64 %152, %150
%154 = trunc i64 %153 to i32
store i32 %154, i32* %7
%155 = load x86_fp80, x86_fp80* %4
%156 = call i64 @floorl(x86_fp80 %155)
%157 = load i32, i32* %7
%158 = sext i32 %157 to i64
%159 = add nsw i64 %158, %156
%160 = trunc i64 %159 to i32
store i32 %160, i32* %7
%161 = load x86_fp80, x86_fp80* %4
%162 = load x86_fp80, x86_fp80* %4
%163 = load x86_fp80, x86_fp80* %4
%164 = call i64 @fmal(x86_fp80 %161, x86_fp80 %162, x86_fp80 %163)
%165 = load i32, i32* %7
%166 = sext i32 %165 to i64
%167 = add nsw i64 %166, %164
%168 = trunc i64 %167 to i32
store i32 %168, i32* %7
%169 = load x86_fp80, x86_fp80* %4
%170 = load x86_fp80, x86_fp80* %4
%171 = call i64 @fmaxl(x86_fp80 %169, x86_fp80 %170)
%172 = load i32, i32* %7
%173 = sext i32 %172 to i64
%174 = add nsw i64 %173, %171
%175 = trunc i64 %174 to i32
store i32 %175, i32* %7
%176 = load x86_fp80, x86_fp80* %4
%177 = load x86_fp80, x86_fp80* %4
%178 = call i64 @fminl(x86_fp80 %176, x86_fp80 %177)
%179 = load i32, i32* %7
%180 = sext i32 %179 to i64
%181 = add nsw i64 %180, %178
%182 = trunc i64 %181 to i32
store i32 %182, i32* %7
%183 = load x86_fp80, x86_fp80* %4
%184 = load x86_fp80, x86_fp80* %4
%185 = call i64 @fmodl(x86_fp80 %183, x86_fp80 %184)
%186 = load i32, i32* %7
%187 = sext i32 %186 to i64
%188 = add nsw i64 %187, %185
%189 = trunc i64 %188 to i32
store i32 %189, i32* %7
%190 = load x86_fp80, x86_fp80* %4
%191 = call i64 @frexpl(x86_fp80 %190, i32* %5)
%192 = load i32, i32* %7
%193 = sext i32 %192 to i64
%194 = add nsw i64 %193, %191
%195 = trunc i64 %194 to i32
store i32 %195, i32* %7
%196 = load x86_fp80, x86_fp80* %4
%197 = load x86_fp80, x86_fp80* %4
%198 = call i64 @hypotl(x86_fp80 %196, x86_fp80 %197)
%199 = load i32, i32* %7
%200 = sext i32 %199 to i64
%201 = add nsw i64 %200, %198
%202 = trunc i64 %201 to i32
store i32 %202, i32* %7
%203 = load x86_fp80, x86_fp80* %4
%204 = call i64 @ilogbl(x86_fp80 %203)
%205 = load i32, i32* %7
%206 = sext i32 %205 to i64
%207 = add nsw i64 %206, %204
%208 = trunc i64 %207 to i32
store i32 %208, i32* %7
%209 = load x86_fp80, x86_fp80* %4
%210 = load i32, i32* %5
%211 = call i64 @ldexpl(x86_fp80 %209, i32 %210)
%212 = load i32, i32* %7
%213 = sext i32 %212 to i64
%214 = add nsw i64 %213, %211
%215 = trunc i64 %214 to i32
store i32 %215, i32* %7
%216 = load x86_fp80, x86_fp80* %4
%217 = call i64 @lgammal(x86_fp80 %216)
%218 = load i32, i32* %7
%219 = sext i32 %218 to i64
%220 = add nsw i64 %219, %217
%221 = trunc i64 %220 to i32
store i32 %221, i32* %7
%222 = load x86_fp80, x86_fp80* %4
%223 = call i64 @llrintl(x86_fp80 %222)
%224 = load i32, i32* %7
%225 = sext i32 %224 to i64
%226 = add nsw i64 %225, %223
%227 = trunc i64 %226 to i32
store i32 %227, i32* %7
%228 = load x86_fp80, x86_fp80* %4
%229 = call i64 @llroundl(x86_fp80 %228)
%230 = load i32, i32* %7
%231 = sext i32 %230 to i64
%232 = add nsw i64 %231, %229
%233 = trunc i64 %232 to i32
store i32 %233, i32* %7
%234 = load x86_fp80, x86_fp80* %4
%235 = call i64 @log10l(x86_fp80 %234)
%236 = load i32, i32* %7
%237 = sext i32 %236 to i64
%238 = add nsw i64 %237, %235
%239 = trunc i64 %238 to i32
store i32 %239, i32* %7
%240 = load x86_fp80, x86_fp80* %4
%241 = call i64 @log1pl(x86_fp80 %240)
%242 = load i32, i32* %7
%243 = sext i32 %242 to i64
%244 = add nsw i64 %243, %241
%245 = trunc i64 %244 to i32
store i32 %245, i32* %7
%246 = load x86_fp80, x86_fp80* %4
%247 = call i64 @log2l(x86_fp80 %246)
%248 = load i32, i32* %7
%249 = sext i32 %248 to i64
%250 = add nsw i64 %249, %247
%251 = trunc i64 %250 to i32
store i32 %251, i32* %7
%252 = load x86_fp80, x86_fp80* %4
%253 = call i64 @logbl(x86_fp80 %252)
%254 = load i32, i32* %7
%255 = sext i32 %254 to i64
%256 = add nsw i64 %255, %253
%257 = trunc i64 %256 to i32
store i32 %257, i32* %7
%258 = load x86_fp80, x86_fp80* %4
%259 = call i64 @logl(x86_fp80 %258)
%260 = load i32, i32* %7
%261 = sext i32 %260 to i64
%262 = add nsw i64 %261, %259
%263 = trunc i64 %262 to i32
store i32 %263, i32* %7
%264 = load x86_fp80, x86_fp80* %4
%265 = call i64 @lrintl(x86_fp80 %264)
%266 = load i32, i32* %7
%267 = sext i32 %266 to i64
%268 = add nsw i64 %267, %265
%269 = trunc i64 %268 to i32
store i32 %269, i32* %7
%270 = load x86_fp80, x86_fp80* %4
%271 = call i64 @lroundl(x86_fp80 %270)
%272 = load i32, i32* %7
%273 = sext i32 %272 to i64
%274 = add nsw i64 %273, %271
%275 = trunc i64 %274 to i32
store i32 %275, i32* %7
%276 = load x86_fp80, x86_fp80* %4
%277 = call i64 @modfl(x86_fp80 %276, x86_fp80* %4)
%278 = load i32, i32* %7
%279 = sext i32 %278 to i64
%280 = add nsw i64 %279, %277
%281 = trunc i64 %280 to i32
store i32 %281, i32* %7
%282 = load x86_fp80, x86_fp80* %4
%283 = call i64 @nearbyintl(x86_fp80 %282)
%284 = load i32, i32* %7
%285 = sext i32 %284 to i64
%286 = add nsw i64 %285, %283
%287 = trunc i64 %286 to i32
store i32 %287, i32* %7
%288 = load x86_fp80, x86_fp80* %4
%289 = load x86_fp80, x86_fp80* %4
%290 = call i64 @nextafterl(x86_fp80 %288, x86_fp80 %289)
%291 = load i32, i32* %7
%292 = sext i32 %291 to i64
%293 = add nsw i64 %292, %290
%294 = trunc i64 %293 to i32
store i32 %294, i32* %7
%295 = load x86_fp80, x86_fp80* %4
%296 = load x86_fp80, x86_fp80* %4
%297 = call i64 @powl(x86_fp80 %295, x86_fp80 %296)
%298 = load i32, i32* %7
%299 = sext i32 %298 to i64
%300 = add nsw i64 %299, %297
%301 = trunc i64 %300 to i32
store i32 %301, i32* %7
%302 = load x86_fp80, x86_fp80* %4
%303 = load x86_fp80, x86_fp80* %4
%304 = call i64 @remainderl(x86_fp80 %302, x86_fp80 %303)
%305 = load i32, i32* %7
%306 = sext i32 %305 to i64
%307 = add nsw i64 %306, %304
%308 = trunc i64 %307 to i32
store i32 %308, i32* %7
%309 = load x86_fp80, x86_fp80* %4
%310 = load x86_fp80, x86_fp80* %4
%311 = call i64 @remquol(x86_fp80 %309, x86_fp80 %310, i32* %5)
%312 = load i32, i32* %7
%313 = sext i32 %312 to i64
%314 = add nsw i64 %313, %311
%315 = trunc i64 %314 to i32
store i32 %315, i32* %7
%316 = load x86_fp80, x86_fp80* %4
%317 = call i64 @rintl(x86_fp80 %316)
%318 = load i32, i32* %7
%319 = sext i32 %318 to i64
%320 = add nsw i64 %319, %317
%321 = trunc i64 %320 to i32
store i32 %321, i32* %7
%322 = load x86_fp80, x86_fp80* %4
%323 = call i64 @roundl(x86_fp80 %322)
%324 = load i32, i32* %7
%325 = sext i32 %324 to i64
%326 = add nsw i64 %325, %323
%327 = trunc i64 %326 to i32
store i32 %327, i32* %7
%328 = load x86_fp80, x86_fp80* %4
%329 = load i64, i64* %6
%330 = call i64 @scalblnl(x86_fp80 %328, i64 %329)
%331 = load i32, i32* %7
%332 = sext i32 %331 to i64
%333 = add nsw i64 %332, %330
%334 = trunc i64 %333 to i32
store i32 %334, i32* %7
%335 = load x86_fp80, x86_fp80* %4
%336 = load i32, i32* %5
%337 = call i64 @scalbnl(x86_fp80 %335, i32 %336)
%338 = load i32, i32* %7
%339 = sext i32 %338 to i64
%340 = add nsw i64 %339, %337
%341 = trunc i64 %340 to i32
store i32 %341, i32* %7
%342 = load x86_fp80, x86_fp80* %4
%343 = call i64 @sinhl(x86_fp80 %342)
%344 = load i32, i32* %7
%345 = sext i32 %344 to i64
%346 = add nsw i64 %345, %343
%347 = trunc i64 %346 to i32
store i32 %347, i32* %7
%348 = load x86_fp80, x86_fp80* %4
%349 = call i64 @sinl(x86_fp80 %348)
%350 = load i32, i32* %7
%351 = sext i32 %350 to i64
%352 = add nsw i64 %351, %349
%353 = trunc i64 %352 to i32
store i32 %353, i32* %7
%354 = load x86_fp80, x86_fp80* %4
%355 = call i64 @sqrtl(x86_fp80 %354)
%356 = load i32, i32* %7
%357 = sext i32 %356 to i64
%358 = add nsw i64 %357, %355
%359 = trunc i64 %358 to i32
store i32 %359, i32* %7
%360 = load x86_fp80, x86_fp80* %4
%361 = call i64 @tanhl(x86_fp80 %360)
%362 = load i32, i32* %7
%363 = sext i32 %362 to i64
%364 = add nsw i64 %363, %361
%365 = trunc i64 %364 to i32
store i32 %365, i32* %7
%366 = load x86_fp80, x86_fp80* %4
%367 = call i64 @tanl(x86_fp80 %366)
%368 = load i32, i32* %7
%369 = sext i32 %368 to i64
%370 = add nsw i64 %369, %367
%371 = trunc i64 %370 to i32
store i32 %371, i32* %7
%372 = load x86_fp80, x86_fp80* %4
%373 = call i64 @tgammal(x86_fp80 %372)
%374 = load i32, i32* %7
%375 = sext i32 %374 to i64
%376 = add nsw i64 %375, %373
%377 = trunc i64 %376 to i32
store i32 %377, i32* %7
%378 = load x86_fp80, x86_fp80* %4
%379 = call i64 @truncl(x86_fp80 %378)
%380 = load i32, i32* %7
%381 = sext i32 %380 to i64
%382 = add nsw i64 %381, %379
%383 = trunc i64 %382 to i32
store i32 %383, i32* %7
%384 = load i32, i32* %7
ret i32 %384
}

LLVM IR (-O2):
define i32 @testl(x86_fp80 %0, i32 %1, i64 %2) {
%4 = alloca x86_fp80
%5 = alloca i32
store x86_fp80 %0, x86_fp80* %4
store i32 %1, i32* %5
%6 = tail call i64 @__finitel(x86_fp80 %0)
%7 = tail call i64 @__fpclassifyl(x86_fp80 %0)
%8 = add i64 %7, %6
%9 = tail call i64 @__isinfl(x86_fp80 %0)
%10 = add i64 %8, %9
%11 = tail call i64 @__isnanl(x86_fp80 %0)
%12 = add i64 %10, %11
%13 = tail call i64 @__signbitl(x86_fp80 %0)
%14 = add i64 %12, %13
%15 = tail call i64 @acoshl(x86_fp80 %0)
%16 = add i64 %14, %15
%17 = tail call i64 @acosl(x86_fp80 %0)
%18 = add i64 %16, %17
%19 = tail call i64 @asinhl(x86_fp80 %0)
%20 = add i64 %18, %19
%21 = tail call i64 @asinl(x86_fp80 %0)
%22 = add i64 %20, %21
%23 = tail call i64 @atan2l(x86_fp80 %0, x86_fp80 %0)
%24 = add i64 %22, %23
%25 = tail call i64 @atanhl(x86_fp80 %0)
%26 = add i64 %24, %25
%27 = tail call i64 @atanl(x86_fp80 %0)
%28 = add i64 %26, %27
%29 = tail call i64 @cbrtl(x86_fp80 %0)
%30 = add i64 %28, %29
%31 = tail call i64 @ceill(x86_fp80 %0)
%32 = add i64 %30, %31
%33 = tail call i64 @copysignl(x86_fp80 %0, x86_fp80 %0)
%34 = add i64 %32, %33
%35 = tail call i64 @coshl(x86_fp80 %0)
%36 = add i64 %34, %35
%37 = tail call i64 @cosl(x86_fp80 %0)
%38 = add i64 %36, %37
%39 = tail call i64 @erfcl(x86_fp80 %0)
%40 = add i64 %38, %39
%41 = tail call i64 @erfl(x86_fp80 %0)
%42 = add i64 %40, %41
%43 = tail call i64 @exp2l(x86_fp80 %0)
%44 = add i64 %42, %43
%45 = tail call i64 @expl(x86_fp80 %0)
%46 = add i64 %44, %45
%47 = tail call i64 @expm1l(x86_fp80 %0)
%48 = add i64 %46, %47
%49 = tail call i64 @fabsl(x86_fp80 %0)
%50 = add i64 %48, %49
%51 = tail call i64 @fdiml(x86_fp80 %0, x86_fp80 %0)
%52 = add i64 %50, %51
%53 = tail call i64 @floorl(x86_fp80 %0)
%54 = add i64 %52, %53
%55 = tail call i64 @fmal(x86_fp80 %0, x86_fp80 %0, x86_fp80 %0)
%56 = add i64 %54, %55
%57 = tail call i64 @fmaxl(x86_fp80 %0, x86_fp80 %0)
%58 = add i64 %56, %57
%59 = tail call i64 @fminl(x86_fp80 %0, x86_fp80 %0)
%60 = add i64 %58, %59
%61 = tail call i64 @fmodl(x86_fp80 %0, x86_fp80 %0)
%62 = add i64 %60, %61
%63 = call i64 @frexpl(x86_fp80 %0, i32* %5)
%64 = add i64 %62, %63
%65 = tail call i64 @hypotl(x86_fp80 %0, x86_fp80 %0)
%66 = add i64 %64, %65
%67 = tail call i64 @ilogbl(x86_fp80 %0)
%68 = add i64 %66, %67
%69 = load i32, i32* %5
%70 = tail call i64 @ldexpl(x86_fp80 %0, i32 %69)
%71 = add i64 %68, %70
%72 = tail call i64 @lgammal(x86_fp80 %0)
%73 = add i64 %71, %72
%74 = tail call i64 @llrintl(x86_fp80 %0)
%75 = add i64 %73, %74
%76 = tail call i64 @llroundl(x86_fp80 %0)
%77 = add i64 %75, %76
%78 = tail call i64 @log10l(x86_fp80 %0)
%79 = add i64 %77, %78
%80 = tail call i64 @log1pl(x86_fp80 %0)
%81 = add i64 %79, %80
%82 = tail call i64 @log2l(x86_fp80 %0)
%83 = add i64 %81, %82
%84 = tail call i64 @logbl(x86_fp80 %0)
%85 = add i64 %83, %84
%86 = tail call i64 @logl(x86_fp80 %0)
%87 = add i64 %85, %86
%88 = tail call i64 @lrintl(x86_fp80 %0)
%89 = add i64 %87, %88
%90 = tail call i64 @lroundl(x86_fp80 %0)
%91 = add i64 %89, %90
%92 = call i64 @modfl(x86_fp80 %0, x86_fp80* %4)
%93 = add i64 %91, %92
%94 = load x86_fp80, x86_fp80* %4
%95 = tail call i64 @nearbyintl(x86_fp80 %94)
%96 = add i64 %93, %95
%97 = tail call i64 @nextafterl(x86_fp80 %94, x86_fp80 %94)
%98 = add i64 %96, %97
%99 = tail call i64 @powl(x86_fp80 %94, x86_fp80 %94)
%100 = add i64 %98, %99
%101 = tail call i64 @remainderl(x86_fp80 %94, x86_fp80 %94)
%102 = add i64 %100, %101
%103 = call i64 @remquol(x86_fp80 %94, x86_fp80 %94, i32* %5)
%104 = add i64 %102, %103
%105 = call i64 @rintl(x86_fp80 %94)
%106 = add i64 %104, %105
%107 = call i64 @roundl(x86_fp80 %94)
%108 = add i64 %106, %107
%109 = call i64 @scalblnl(x86_fp80 %94, i64 %2)
%110 = add i64 %108, %109
%111 = load i32, i32* %5
%112 = call i64 @scalbnl(x86_fp80 %94, i32 %111)
%113 = add i64 %110, %112
%114 = call i64 @sinhl(x86_fp80 %94)
%115 = add i64 %113, %114
%116 = call i64 @sinl(x86_fp80 %94)
%117 = add i64 %115, %116
%118 = call i64 @sqrtl(x86_fp80 %94)
%119 = add i64 %117, %118
%120 = call i64 @tanhl(x86_fp80 %94)
%121 = add i64 %119, %120
%122 = call i64 @tanl(x86_fp80 %94)
%123 = add i64 %121, %122
%124 = call i64 @tgammal(x86_fp80 %94)
%125 = add i64 %123, %124
%126 = call i64 @truncl(x86_fp80 %94)
%127 = add i64 %125, %126
%128 = trunc i64 %127 to i32
ret i32 %128
}