void foo(float f) {
  __builtin_cabs(f);
  __builtin_cabsf(f);
  __builtin_cabsl(f);
  __builtin_cacos(f);
  __builtin_cacosf(f);
  __builtin_cacosl(f);
  __builtin_cacosh(f);
  __builtin_cacoshf(f);
  __builtin_cacoshl(f);
  __builtin_carg(f);
  __builtin_cargf(f);
  __builtin_cargl(f);
  __builtin_casin(f);
  __builtin_casinf(f);
  __builtin_casinl(f);
  __builtin_casinh(f);
  __builtin_casinhf(f);
  __builtin_casinhl(f);
  __builtin_catan(f);
  __builtin_catanf(f);
  __builtin_catanl(f);
  __builtin_catanh(f);
  __builtin_catanhf(f);
  __builtin_catanhl(f);
  __builtin_ccos(f);
  __builtin_ccosf(f);
  __builtin_ccosl(f);
  __builtin_ccosh(f);
  __builtin_ccoshf(f);
  __builtin_ccoshl(f);
  __builtin_cexp(f);
  __builtin_cexpf(f);
  __builtin_cexpl(f);
  __builtin_cimag(f);
  __builtin_cimagf(f);
  __builtin_cimagl(f);
  __builtin_conj(f);
  __builtin_conjf(f);
  __builtin_conjl(f);
  __builtin_clog(f);
  __builtin_clogf(f);
  __builtin_clogl(f);
  __builtin_cproj(f);
  __builtin_cprojf(f);
  __builtin_cprojl(f);
  __builtin_cpow(f, f);
  __builtin_cpowf(f, f);
  __builtin_cpowl(f, f);
  __builtin_creal(f);
  __builtin_crealf(f);
  __builtin_creall(f);
  __builtin_csin(f);
  __builtin_csinf(f);
  __builtin_csinl(f);
  __builtin_csinh(f);
  __builtin_csinhf(f);
  __builtin_csinhl(f);
  __builtin_csqrt(f);
  __builtin_csqrtf(f);
  __builtin_csqrtl(f);
  __builtin_ctan(f);
  __builtin_ctanf(f);
  __builtin_ctanl(f);
  __builtin_ctanh(f);
  __builtin_ctanhf(f);
  __builtin_ctanhl(f);
}


x86 assembly (clang, -O0):
<foo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x550,%rsp
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movq   $0x0,-0x10(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
call   20d0 <cabs@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
movsd  -0x20(%rbp),%xmm0
call   21c0 <cabsf@plt>
flds   -0x4(%rbp)
fstpt  -0x40(%rbp)
fldz
fld    %st(0)
fstpt  -0x50c(%rbp)
fstpt  -0x30(%rbp)
movaps -0x40(%rbp),%xmm0
movaps -0x30(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2180 <cabsl@plt>
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movq   $0x0,-0x48(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
call   2030 <cacos@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x54(%rbp)
movsd  -0x58(%rbp),%xmm0
call   23b0 <cacosf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x60(%rbp)
flds   -0x4(%rbp)
fstpt  -0x80(%rbp)
fstpt  -0x70(%rbp)
movaps -0x80(%rbp),%xmm0
movaps -0x70(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2380 <cacosl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movq   $0x0,-0x88(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
call   2360 <cacosh@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x94(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
call   22e0 <cacoshf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0xa0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0xc0(%rbp)
fstpt  -0xb0(%rbp)
movaps -0xc0(%rbp),%xmm0
movaps -0xb0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2300 <cacoshl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movq   $0x0,-0xc8(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
call   20e0 <carg@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0xd4(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
call   2060 <cargf@plt>
fldt   -0x50c(%rbp)
flds   -0x4(%rbp)
fstpt  -0x100(%rbp)
fstpt  -0xf0(%rbp)
movaps -0x100(%rbp),%xmm0
movaps -0xf0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   21e0 <cargl@plt>
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movq   $0x0,-0x108(%rbp)
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm1
ff
call   2200 <casin@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movl   $0x0,-0x114(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
call   2230 <casinf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x120(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x140(%rbp)
fstpt  -0x130(%rbp)
movaps -0x140(%rbp),%xmm0
movaps -0x130(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2090 <casinl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movq   $0x0,-0x148(%rbp)
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm1
ff
call   2080 <casinh@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0x154(%rbp)
movsd  -0x158(%rbp),%xmm0
ff
call   2140 <casinhf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x160(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x180(%rbp)
fstpt  -0x170(%rbp)
movaps -0x180(%rbp),%xmm0
movaps -0x170(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2160 <casinhl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movq   $0x0,-0x188(%rbp)
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm1
ff
call   21f0 <catan@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x198(%rbp)
ff
movl   $0x0,-0x194(%rbp)
movsd  -0x198(%rbp),%xmm0
ff
call   20b0 <catanf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x1a0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x1c0(%rbp)
fstpt  -0x1b0(%rbp)
movaps -0x1c0(%rbp),%xmm0
movaps -0x1b0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   20f0 <catanl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movq   $0x0,-0x1c8(%rbp)
movsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm1
ff
call   21b0 <catanh@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x1d8(%rbp)
ff
movl   $0x0,-0x1d4(%rbp)
movsd  -0x1d8(%rbp),%xmm0
ff
call   2260 <catanhf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x1e0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x200(%rbp)
fstpt  -0x1f0(%rbp)
movaps -0x200(%rbp),%xmm0
movaps -0x1f0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2270 <catanhl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movq   $0x0,-0x208(%rbp)
movsd  -0x210(%rbp),%xmm0
ff
movsd  -0x208(%rbp),%xmm1
ff
call   21d0 <ccos@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x218(%rbp)
ff
movl   $0x0,-0x214(%rbp)
movsd  -0x218(%rbp),%xmm0
ff
call   2130 <ccosf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x220(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x240(%rbp)
fstpt  -0x230(%rbp)
movaps -0x240(%rbp),%xmm0
movaps -0x230(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2120 <ccosl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movq   $0x0,-0x248(%rbp)
movsd  -0x250(%rbp),%xmm0
ff
movsd  -0x248(%rbp),%xmm1
ff
call   2110 <ccosh@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x258(%rbp)
ff
movl   $0x0,-0x254(%rbp)
movsd  -0x258(%rbp),%xmm0
ff
call   2190 <ccoshf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x260(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x280(%rbp)
fstpt  -0x270(%rbp)
movaps -0x280(%rbp),%xmm0
movaps -0x270(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   21a0 <ccoshl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movq   $0x0,-0x288(%rbp)
movsd  -0x290(%rbp),%xmm0
ff
movsd  -0x288(%rbp),%xmm1
ff
call   2220 <cexp@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x298(%rbp)
ff
movl   $0x0,-0x294(%rbp)
movsd  -0x298(%rbp),%xmm0
ff
call   2250 <cexpf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x2a0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x2c0(%rbp)
fstpt  -0x2b0(%rbp)
movaps -0x2c0(%rbp),%xmm0
movaps -0x2b0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2240 <cexpl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movq   $0x0,-0x2c8(%rbp)
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm1
ff
call   2340 <clog@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x2d8(%rbp)
ff
movl   $0x0,-0x2d4(%rbp)
movsd  -0x2d8(%rbp),%xmm0
ff
call   2070 <clogf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x2e0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x300(%rbp)
fstpt  -0x2f0(%rbp)
movaps -0x300(%rbp),%xmm0
movaps -0x2f0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   20a0 <clogl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movq   $0x0,-0x308(%rbp)
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x308(%rbp),%xmm1
ff
call   2320 <cproj@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x318(%rbp)
ff
movl   $0x0,-0x314(%rbp)
movsd  -0x318(%rbp),%xmm0
ff
call   2170 <cprojf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x320(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x340(%rbp)
fstpt  -0x330(%rbp)
movaps -0x340(%rbp),%xmm0
movaps -0x330(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2150 <cprojl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  %xmm2,-0x350(%rbp)
ff
movq   $0x0,-0x348(%rbp)
movsd  -0x350(%rbp),%xmm0
ff
movsd  -0x348(%rbp),%xmm1
ff
movsd  %xmm2,-0x360(%rbp)
ff
movq   $0x0,-0x358(%rbp)
movsd  -0x360(%rbp),%xmm2
ff
movsd  -0x358(%rbp),%xmm3
ff
call   2040 <cpow@plt>
movss  -0x4(%rbp),%xmm1
movss  %xmm1,-0x368(%rbp)
ff
movl   $0x0,-0x364(%rbp)
movsd  -0x368(%rbp),%xmm0
ff
movss  %xmm1,-0x370(%rbp)
ff
movl   $0x0,-0x36c(%rbp)
movsd  -0x370(%rbp),%xmm1
ff
call   22f0 <cpowf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x378(%rbp)
ff
flds   -0x4(%rbp)
fld    %st(0)
fstpt  -0x3a0(%rbp)
fld    %st(1)
fstpt  -0x390(%rbp)
fstpt  -0x3c0(%rbp)
fstpt  -0x3b0(%rbp)
movaps -0x3c0(%rbp),%xmm0
movaps -0x3b0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x3a0(%rbp),%xmm0
movaps -0x390(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2310 <cpowl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x3d0(%rbp)
ff
movq   $0x0,-0x3c8(%rbp)
movsd  -0x3d0(%rbp),%xmm0
ff
movsd  -0x3c8(%rbp),%xmm1
ff
call   2100 <csin@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x3d8(%rbp)
ff
movl   $0x0,-0x3d4(%rbp)
movsd  -0x3d8(%rbp),%xmm0
ff
call   2290 <csinf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x3e0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x400(%rbp)
fstpt  -0x3f0(%rbp)
movaps -0x400(%rbp),%xmm0
movaps -0x3f0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2280 <csinl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x410(%rbp)
ff
movq   $0x0,-0x408(%rbp)
movsd  -0x410(%rbp),%xmm0
ff
movsd  -0x408(%rbp),%xmm1
ff
call   22d0 <csinh@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x418(%rbp)
ff
movl   $0x0,-0x414(%rbp)
movsd  -0x418(%rbp),%xmm0
ff
call   2050 <csinhf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x420(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x440(%rbp)
fstpt  -0x430(%rbp)
movaps -0x440(%rbp),%xmm0
movaps -0x430(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   20c0 <csinhl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
movq   $0x0,-0x448(%rbp)
movsd  -0x450(%rbp),%xmm0
ff
movsd  -0x448(%rbp),%xmm1
ff
call   23a0 <csqrt@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x458(%rbp)
ff
movl   $0x0,-0x454(%rbp)
movsd  -0x458(%rbp),%xmm0
ff
call   2390 <csqrtf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x460(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x480(%rbp)
fstpt  -0x470(%rbp)
movaps -0x480(%rbp),%xmm0
movaps -0x470(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   2330 <csqrtl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
movq   $0x0,-0x488(%rbp)
movsd  -0x490(%rbp),%xmm0
ff
movsd  -0x488(%rbp),%xmm1
ff
call   2210 <ctan@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x498(%rbp)
ff
movl   $0x0,-0x494(%rbp)
movsd  -0x498(%rbp),%xmm0
ff
call   22b0 <ctanf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x4a0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x4c0(%rbp)
fstpt  -0x4b0(%rbp)
movaps -0x4c0(%rbp),%xmm0
movaps -0x4b0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   22c0 <ctanl@plt>
fstp   %st(0)
fstp   %st(0)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x4d0(%rbp)
ff
movq   $0x0,-0x4c8(%rbp)
movsd  -0x4d0(%rbp),%xmm0
ff
movsd  -0x4c8(%rbp),%xmm1
ff
call   22a0 <ctanh@plt>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x4d8(%rbp)
ff
movl   $0x0,-0x4d4(%rbp)
movsd  -0x4d8(%rbp),%xmm0
ff
call   2370 <ctanhf@plt>
fldt   -0x50c(%rbp)
movlpd %xmm0,-0x4e0(%rbp)
ff
flds   -0x4(%rbp)
fstpt  -0x500(%rbp)
fstpt  -0x4f0(%rbp)
lea    -0x500(%rbp),%rax
mov    (%rax),%rcx
mov    %rcx,(%rsp)
mov    0x8(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    0x10(%rax),%rcx
mov    %rcx,0x10(%rsp)
mov    0x18(%rax),%rax
mov    %rax,0x18(%rsp)
call   2350 <ctanhl@plt>
fstp   %st(0)
fstp   %st(0)
add    $0x550,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
sub    $0x318,%rsp
movaps %xmm0,0x60(%rsp)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x48(%rsp)
xorps  %xmm1,%xmm1
call   20d0 <cabs@plt>
xorps  %xmm0,%xmm0
movaps 0x60(%rsp),%xmm1
movss  %xmm1,%xmm0
movaps %xmm0,0x70(%rsp)
call   21b0 <cabsf@plt>
movaps 0x60(%rsp),%xmm0
movss  %xmm0,0x8c(%rsp)
flds   0x8c(%rsp)
fld    %st(0)
fstpt  0x60(%rsp)
fstpt  0x2f0(%rsp)
fldz
fld    %st(0)
fstpt  0x54(%rsp)
fstpt  0x300(%rsp)
movaps 0x2f0(%rsp),%xmm0
movaps 0x300(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2170 <cabsl@plt>
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2030 <cacos@plt>
movaps 0x70(%rsp),%xmm0
call   2390 <cacosf@plt>
fldt   0x60(%rsp)
fstpt  0x2d0(%rsp)
fldt   0x54(%rsp)
fstpt  0x2e0(%rsp)
movaps 0x2d0(%rsp),%xmm0
movaps 0x2e0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2360 <cacosl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2340 <cacosh@plt>
movaps 0x70(%rsp),%xmm0
call   22d0 <cacoshf@plt>
fldt   0x60(%rsp)
fstpt  0x2b0(%rsp)
fldt   0x54(%rsp)
fstpt  0x2c0(%rsp)
movaps 0x2b0(%rsp),%xmm0
movaps 0x2c0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   22f0 <cacoshl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   20e0 <carg@plt>
movaps 0x70(%rsp),%xmm0
call   2060 <cargf@plt>
fldt   0x60(%rsp)
fstpt  0x290(%rsp)
fldt   0x54(%rsp)
fstpt  0x2a0(%rsp)
movaps 0x290(%rsp),%xmm0
movaps 0x2a0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   21d0 <cargl@plt>
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   21f0 <casin@plt>
movaps 0x70(%rsp),%xmm0
call   2220 <casinf@plt>
fldt   0x60(%rsp)
fstpt  0x270(%rsp)
fldt   0x54(%rsp)
fstpt  0x280(%rsp)
movaps 0x270(%rsp),%xmm0
movaps 0x280(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2090 <casinl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2080 <casinh@plt>
movaps 0x70(%rsp),%xmm0
call   2140 <casinhf@plt>
fldt   0x60(%rsp)
fstpt  0x250(%rsp)
fldt   0x54(%rsp)
fstpt  0x260(%rsp)
movaps 0x250(%rsp),%xmm0
movaps 0x260(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2160 <casinhl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   21e0 <catan@plt>
movaps 0x70(%rsp),%xmm0
call   20b0 <catanf@plt>
fldt   0x60(%rsp)
fstpt  0x230(%rsp)
fldt   0x54(%rsp)
fstpt  0x240(%rsp)
movaps 0x230(%rsp),%xmm0
movaps 0x240(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   20f0 <catanl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   21a0 <catanh@plt>
movaps 0x70(%rsp),%xmm0
call   2250 <catanhf@plt>
fldt   0x60(%rsp)
fstpt  0x210(%rsp)
fldt   0x54(%rsp)
fstpt  0x220(%rsp)
movaps 0x210(%rsp),%xmm0
movaps 0x220(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2260 <catanhl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   21c0 <ccos@plt>
movaps 0x70(%rsp),%xmm0
call   2130 <ccosf@plt>
fldt   0x60(%rsp)
fstpt  0x1f0(%rsp)
fldt   0x54(%rsp)
fstpt  0x200(%rsp)
movaps 0x1f0(%rsp),%xmm0
movaps 0x200(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2120 <ccosl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2110 <ccosh@plt>
movaps 0x70(%rsp),%xmm0
call   2180 <ccoshf@plt>
fldt   0x60(%rsp)
fstpt  0x1d0(%rsp)
fldt   0x54(%rsp)
fstpt  0x1e0(%rsp)
movaps 0x1d0(%rsp),%xmm0
movaps 0x1e0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2190 <ccoshl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2210 <cexp@plt>
movaps 0x70(%rsp),%xmm0
call   2240 <cexpf@plt>
fldt   0x60(%rsp)
fstpt  0x1b0(%rsp)
fldt   0x54(%rsp)
fstpt  0x1c0(%rsp)
movaps 0x1b0(%rsp),%xmm0
movaps 0x1c0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2230 <cexpl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2320 <clog@plt>
movaps 0x70(%rsp),%xmm0
call   2070 <clogf@plt>
fldt   0x60(%rsp)
fstpt  0x190(%rsp)
fldt   0x54(%rsp)
fstpt  0x1a0(%rsp)
movaps 0x190(%rsp),%xmm0
movaps 0x1a0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   20a0 <clogl@plt>
fstp   %st(0)
fstp   %st(0)
fldt   0x60(%rsp)
fstpt  0x170(%rsp)
fldt   0x54(%rsp)
fstpt  0x180(%rsp)
movaps 0x170(%rsp),%xmm0
movaps 0x180(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2150 <cprojl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x48(%rsp),%xmm0
movaps %xmm0,%xmm2
call   2040 <cpow@plt>
movaps 0x70(%rsp),%xmm0
movaps %xmm0,%xmm1
call   22e0 <cpowf@plt>
fldt   0x60(%rsp)
fld    %st(0)
fstpt  0x150(%rsp)
fldt   0x54(%rsp)
fld    %st(0)
fstpt  0x160(%rsp)
fxch   %st(1)
fstpt  0x130(%rsp)
fstpt  0x140(%rsp)
movaps 0x130(%rsp),%xmm0
movaps 0x140(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x150(%rsp),%xmm0
movaps 0x160(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2300 <cpowl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2100 <csin@plt>
movaps 0x70(%rsp),%xmm0
call   2280 <csinf@plt>
fldt   0x60(%rsp)
fstpt  0x110(%rsp)
fldt   0x54(%rsp)
fstpt  0x120(%rsp)
movaps 0x110(%rsp),%xmm0
movaps 0x120(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2270 <csinl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   22c0 <csinh@plt>
movaps 0x70(%rsp),%xmm0
call   2050 <csinhf@plt>
fldt   0x60(%rsp)
fstpt  0xf0(%rsp)
fldt   0x54(%rsp)
fstpt  0x100(%rsp)
movaps 0xf0(%rsp),%xmm0
movaps 0x100(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   20c0 <csinhl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2380 <csqrt@plt>
movaps 0x70(%rsp),%xmm0
call   2370 <csqrtf@plt>
fldt   0x60(%rsp)
fstpt  0xd0(%rsp)
fldt   0x54(%rsp)
fstpt  0xe0(%rsp)
movaps 0xd0(%rsp),%xmm0
movaps 0xe0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2310 <csqrtl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2200 <ctan@plt>
movaps 0x70(%rsp),%xmm0
call   22a0 <ctanf@plt>
fldt   0x60(%rsp)
fstpt  0xb0(%rsp)
fldt   0x54(%rsp)
fstpt  0xc0(%rsp)
movaps 0xb0(%rsp),%xmm0
movaps 0xc0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   22b0 <ctanl@plt>
fstp   %st(0)
fstp   %st(0)
xorps  %xmm1,%xmm1
movsd  0x48(%rsp),%xmm0
call   2290 <ctanh@plt>
movaps 0x70(%rsp),%xmm0
call   2350 <ctanhf@plt>
fldt   0x60(%rsp)
fstpt  0x90(%rsp)
fldt   0x54(%rsp)
fstpt  0xa0(%rsp)
movaps 0x90(%rsp),%xmm0
movaps 0xa0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   2330 <ctanhl@plt>
fstp   %st(0)
fstp   %st(0)
add    $0x318,%rsp
ret

LLVM IR (-O0):
define void @foo(float %0) {
%2 = alloca float
%3 = alloca { double, double }
%4 = alloca { float, float }
%5 = alloca { x86_fp80, x86_fp80 }
%6 = alloca { double, double }
%7 = alloca { float, float }
%8 = alloca { float, float }
%9 = alloca { x86_fp80, x86_fp80 }
%10 = alloca { double, double }
%11 = alloca { float, float }
%12 = alloca { float, float }
%13 = alloca { x86_fp80, x86_fp80 }
%14 = alloca { double, double }
%15 = alloca { float, float }
%16 = alloca { x86_fp80, x86_fp80 }
%17 = alloca { double, double }
%18 = alloca { float, float }
%19 = alloca { float, float }
%20 = alloca { x86_fp80, x86_fp80 }
%21 = alloca { double, double }
%22 = alloca { float, float }
%23 = alloca { float, float }
%24 = alloca { x86_fp80, x86_fp80 }
%25 = alloca { double, double }
%26 = alloca { float, float }
%27 = alloca { float, float }
%28 = alloca { x86_fp80, x86_fp80 }
%29 = alloca { double, double }
%30 = alloca { float, float }
%31 = alloca { float, float }
%32 = alloca { x86_fp80, x86_fp80 }
%33 = alloca { double, double }
%34 = alloca { float, float }
%35 = alloca { float, float }
%36 = alloca { x86_fp80, x86_fp80 }
%37 = alloca { double, double }
%38 = alloca { float, float }
%39 = alloca { float, float }
%40 = alloca { x86_fp80, x86_fp80 }
%41 = alloca { double, double }
%42 = alloca { float, float }
%43 = alloca { float, float }
%44 = alloca { x86_fp80, x86_fp80 }
%45 = alloca { double, double }
%46 = alloca { float, float }
%47 = alloca { float, float }
%48 = alloca { x86_fp80, x86_fp80 }
%49 = alloca { double, double }
%50 = alloca { float, float }
%51 = alloca { float, float }
%52 = alloca { x86_fp80, x86_fp80 }
%53 = alloca { double, double }
%54 = alloca { double, double }
%55 = alloca { float, float }
%56 = alloca { float, float }
%57 = alloca { float, float }
%58 = alloca { x86_fp80, x86_fp80 }
%59 = alloca { x86_fp80, x86_fp80 }
%60 = alloca { double, double }
%61 = alloca { float, float }
%62 = alloca { float, float }
%63 = alloca { x86_fp80, x86_fp80 }
%64 = alloca { double, double }
%65 = alloca { float, float }
%66 = alloca { float, float }
%67 = alloca { x86_fp80, x86_fp80 }
%68 = alloca { double, double }
%69 = alloca { float, float }
%70 = alloca { float, float }
%71 = alloca { x86_fp80, x86_fp80 }
%72 = alloca { double, double }
%73 = alloca { float, float }
%74 = alloca { float, float }
%75 = alloca { x86_fp80, x86_fp80 }
%76 = alloca { double, double }
%77 = alloca { float, float }
%78 = alloca { float, float }
%79 = alloca { x86_fp80, x86_fp80 }
store float %0, float* %2
%80 = load float, float* %2
%81 = fpext float %80 to double
%82 = getelementptr inbounds { double, double }, { double, double }* %3, i32 0, i32 0
%83 = getelementptr inbounds { double, double }, { double, double }* %3, i32 0, i32 1
store double %81, double* %82
store double 0.000000e+00, double* %83
%84 = getelementptr inbounds { double, double }, { double, double }* %3, i32 0, i32 0
%85 = load double, double* %84
%86 = getelementptr inbounds { double, double }, { double, double }* %3, i32 0, i32 1
%87 = load double, double* %86
%88 = call double @cabs(double %85, double %87)
%89 = load float, float* %2
%90 = getelementptr inbounds { float, float }, { float, float }* %4, i32 0, i32 0
%91 = getelementptr inbounds { float, float }, { float, float }* %4, i32 0, i32 1
store float %89, float* %90
store float 0.000000e+00, float* %91
%92 = bitcast { float, float }* %4 to <2 x float>*
%93 = load <2 x float>, <2 x float>* %92
%94 = call float @cabsf(<2 x float> %93)
%95 = load float, float* %2
%96 = fpext float %95 to x86_fp80
%97 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %5, i32 0, i32 0
%98 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %5, i32 0, i32 1
store x86_fp80 %96, x86_fp80* %97
store x86_fp80 0xK00000000000000000000, x86_fp80* %98
%99 = call x86_fp80 @cabsl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %5)
%100 = load float, float* %2
%101 = fpext float %100 to double
%102 = getelementptr inbounds { double, double }, { double, double }* %6, i32 0, i32 0
%103 = getelementptr inbounds { double, double }, { double, double }* %6, i32 0, i32 1
store double %101, double* %102
store double 0.000000e+00, double* %103
%104 = getelementptr inbounds { double, double }, { double, double }* %6, i32 0, i32 0
%105 = load double, double* %104
%106 = getelementptr inbounds { double, double }, { double, double }* %6, i32 0, i32 1
%107 = load double, double* %106
%108 = call { double, double } @cacos(double %105, double %107)
%109 = extractvalue { double, double } %108, 0
%110 = extractvalue { double, double } %108, 1
%111 = load float, float* %2
%112 = getelementptr inbounds { float, float }, { float, float }* %7, i32 0, i32 0
%113 = getelementptr inbounds { float, float }, { float, float }* %7, i32 0, i32 1
store float %111, float* %112
store float 0.000000e+00, float* %113
%114 = bitcast { float, float }* %7 to <2 x float>*
%115 = load <2 x float>, <2 x float>* %114
%116 = call <2 x float> @cacosf(<2 x float> %115)
%117 = bitcast { float, float }* %8 to <2 x float>*
store <2 x float> %116, <2 x float>* %117
%118 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%119 = load float, float* %118
%120 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
%121 = load float, float* %120
%122 = load float, float* %2
%123 = fpext float %122 to x86_fp80
%124 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %9, i32 0, i32 0
%125 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %9, i32 0, i32 1
store x86_fp80 %123, x86_fp80* %124
store x86_fp80 0xK00000000000000000000, x86_fp80* %125
%126 = call { x86_fp80, x86_fp80 } @cacosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %9)
%127 = extractvalue { x86_fp80, x86_fp80 } %126, 0
%128 = extractvalue { x86_fp80, x86_fp80 } %126, 1
%129 = load float, float* %2
%130 = fpext float %129 to double
%131 = getelementptr inbounds { double, double }, { double, double }* %10, i32 0, i32 0
%132 = getelementptr inbounds { double, double }, { double, double }* %10, i32 0, i32 1
store double %130, double* %131
store double 0.000000e+00, double* %132
%133 = getelementptr inbounds { double, double }, { double, double }* %10, i32 0, i32 0
%134 = load double, double* %133
%135 = getelementptr inbounds { double, double }, { double, double }* %10, i32 0, i32 1
%136 = load double, double* %135
%137 = call { double, double } @cacosh(double %134, double %136)
%138 = extractvalue { double, double } %137, 0
%139 = extractvalue { double, double } %137, 1
%140 = load float, float* %2
%141 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 0
%142 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 1
store float %140, float* %141
store float 0.000000e+00, float* %142
%143 = bitcast { float, float }* %11 to <2 x float>*
%144 = load <2 x float>, <2 x float>* %143
%145 = call <2 x float> @cacoshf(<2 x float> %144)
%146 = bitcast { float, float }* %12 to <2 x float>*
store <2 x float> %145, <2 x float>* %146
%147 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 0
%148 = load float, float* %147
%149 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 1
%150 = load float, float* %149
%151 = load float, float* %2
%152 = fpext float %151 to x86_fp80
%153 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i32 0, i32 0
%154 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i32 0, i32 1
store x86_fp80 %152, x86_fp80* %153
store x86_fp80 0xK00000000000000000000, x86_fp80* %154
%155 = call { x86_fp80, x86_fp80 } @cacoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %13)
%156 = extractvalue { x86_fp80, x86_fp80 } %155, 0
%157 = extractvalue { x86_fp80, x86_fp80 } %155, 1
%158 = load float, float* %2
%159 = fpext float %158 to double
%160 = getelementptr inbounds { double, double }, { double, double }* %14, i32 0, i32 0
%161 = getelementptr inbounds { double, double }, { double, double }* %14, i32 0, i32 1
store double %159, double* %160
store double 0.000000e+00, double* %161
%162 = getelementptr inbounds { double, double }, { double, double }* %14, i32 0, i32 0
%163 = load double, double* %162
%164 = getelementptr inbounds { double, double }, { double, double }* %14, i32 0, i32 1
%165 = load double, double* %164
%166 = call double @carg(double %163, double %165)
%167 = load float, float* %2
%168 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%169 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
store float %167, float* %168
store float 0.000000e+00, float* %169
%170 = bitcast { float, float }* %15 to <2 x float>*
%171 = load <2 x float>, <2 x float>* %170
%172 = call float @cargf(<2 x float> %171)
%173 = load float, float* %2
%174 = fpext float %173 to x86_fp80
%175 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %16, i32 0, i32 0
%176 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %16, i32 0, i32 1
store x86_fp80 %174, x86_fp80* %175
store x86_fp80 0xK00000000000000000000, x86_fp80* %176
%177 = call x86_fp80 @cargl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %16)
%178 = load float, float* %2
%179 = fpext float %178 to double
%180 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 0
%181 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 1
store double %179, double* %180
store double 0.000000e+00, double* %181
%182 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 0
%183 = load double, double* %182
%184 = getelementptr inbounds { double, double }, { double, double }* %17, i32 0, i32 1
%185 = load double, double* %184
%186 = call { double, double } @casin(double %183, double %185)
%187 = extractvalue { double, double } %186, 0
%188 = extractvalue { double, double } %186, 1
%189 = load float, float* %2
%190 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 0
%191 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 1
store float %189, float* %190
store float 0.000000e+00, float* %191
%192 = bitcast { float, float }* %18 to <2 x float>*
%193 = load <2 x float>, <2 x float>* %192
%194 = call <2 x float> @casinf(<2 x float> %193)
%195 = bitcast { float, float }* %19 to <2 x float>*
store <2 x float> %194, <2 x float>* %195
%196 = getelementptr inbounds { float, float }, { float, float }* %19, i32 0, i32 0
%197 = load float, float* %196
%198 = getelementptr inbounds { float, float }, { float, float }* %19, i32 0, i32 1
%199 = load float, float* %198
%200 = load float, float* %2
%201 = fpext float %200 to x86_fp80
%202 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i32 0, i32 0
%203 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i32 0, i32 1
store x86_fp80 %201, x86_fp80* %202
store x86_fp80 0xK00000000000000000000, x86_fp80* %203
%204 = call { x86_fp80, x86_fp80 } @casinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %20)
%205 = extractvalue { x86_fp80, x86_fp80 } %204, 0
%206 = extractvalue { x86_fp80, x86_fp80 } %204, 1
%207 = load float, float* %2
%208 = fpext float %207 to double
%209 = getelementptr inbounds { double, double }, { double, double }* %21, i32 0, i32 0
%210 = getelementptr inbounds { double, double }, { double, double }* %21, i32 0, i32 1
store double %208, double* %209
store double 0.000000e+00, double* %210
%211 = getelementptr inbounds { double, double }, { double, double }* %21, i32 0, i32 0
%212 = load double, double* %211
%213 = getelementptr inbounds { double, double }, { double, double }* %21, i32 0, i32 1
%214 = load double, double* %213
%215 = call { double, double } @casinh(double %212, double %214)
%216 = extractvalue { double, double } %215, 0
%217 = extractvalue { double, double } %215, 1
%218 = load float, float* %2
%219 = getelementptr inbounds { float, float }, { float, float }* %22, i32 0, i32 0
%220 = getelementptr inbounds { float, float }, { float, float }* %22, i32 0, i32 1
store float %218, float* %219
store float 0.000000e+00, float* %220
%221 = bitcast { float, float }* %22 to <2 x float>*
%222 = load <2 x float>, <2 x float>* %221
%223 = call <2 x float> @casinhf(<2 x float> %222)
%224 = bitcast { float, float }* %23 to <2 x float>*
store <2 x float> %223, <2 x float>* %224
%225 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%226 = load float, float* %225
%227 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
%228 = load float, float* %227
%229 = load float, float* %2
%230 = fpext float %229 to x86_fp80
%231 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %24, i32 0, i32 0
%232 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %24, i32 0, i32 1
store x86_fp80 %230, x86_fp80* %231
store x86_fp80 0xK00000000000000000000, x86_fp80* %232
%233 = call { x86_fp80, x86_fp80 } @casinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %24)
%234 = extractvalue { x86_fp80, x86_fp80 } %233, 0
%235 = extractvalue { x86_fp80, x86_fp80 } %233, 1
%236 = load float, float* %2
%237 = fpext float %236 to double
%238 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 0
%239 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 1
store double %237, double* %238
store double 0.000000e+00, double* %239
%240 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 0
%241 = load double, double* %240
%242 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 1
%243 = load double, double* %242
%244 = call { double, double } @catan(double %241, double %243)
%245 = extractvalue { double, double } %244, 0
%246 = extractvalue { double, double } %244, 1
%247 = load float, float* %2
%248 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 0
%249 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 1
store float %247, float* %248
store float 0.000000e+00, float* %249
%250 = bitcast { float, float }* %26 to <2 x float>*
%251 = load <2 x float>, <2 x float>* %250
%252 = call <2 x float> @catanf(<2 x float> %251)
%253 = bitcast { float, float }* %27 to <2 x float>*
store <2 x float> %252, <2 x float>* %253
%254 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 0
%255 = load float, float* %254
%256 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 1
%257 = load float, float* %256
%258 = load float, float* %2
%259 = fpext float %258 to x86_fp80
%260 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %28, i32 0, i32 0
%261 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %28, i32 0, i32 1
store x86_fp80 %259, x86_fp80* %260
store x86_fp80 0xK00000000000000000000, x86_fp80* %261
%262 = call { x86_fp80, x86_fp80 } @catanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %28)
%263 = extractvalue { x86_fp80, x86_fp80 } %262, 0
%264 = extractvalue { x86_fp80, x86_fp80 } %262, 1
%265 = load float, float* %2
%266 = fpext float %265 to double
%267 = getelementptr inbounds { double, double }, { double, double }* %29, i32 0, i32 0
%268 = getelementptr inbounds { double, double }, { double, double }* %29, i32 0, i32 1
store double %266, double* %267
store double 0.000000e+00, double* %268
%269 = getelementptr inbounds { double, double }, { double, double }* %29, i32 0, i32 0
%270 = load double, double* %269
%271 = getelementptr inbounds { double, double }, { double, double }* %29, i32 0, i32 1
%272 = load double, double* %271
%273 = call { double, double } @catanh(double %270, double %272)
%274 = extractvalue { double, double } %273, 0
%275 = extractvalue { double, double } %273, 1
%276 = load float, float* %2
%277 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 0
%278 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 1
store float %276, float* %277
store float 0.000000e+00, float* %278
%279 = bitcast { float, float }* %30 to <2 x float>*
%280 = load <2 x float>, <2 x float>* %279
%281 = call <2 x float> @catanhf(<2 x float> %280)
%282 = bitcast { float, float }* %31 to <2 x float>*
store <2 x float> %281, <2 x float>* %282
%283 = getelementptr inbounds { float, float }, { float, float }* %31, i32 0, i32 0
%284 = load float, float* %283
%285 = getelementptr inbounds { float, float }, { float, float }* %31, i32 0, i32 1
%286 = load float, float* %285
%287 = load float, float* %2
%288 = fpext float %287 to x86_fp80
%289 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %32, i32 0, i32 0
%290 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %32, i32 0, i32 1
store x86_fp80 %288, x86_fp80* %289
store x86_fp80 0xK00000000000000000000, x86_fp80* %290
%291 = call { x86_fp80, x86_fp80 } @catanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %32)
%292 = extractvalue { x86_fp80, x86_fp80 } %291, 0
%293 = extractvalue { x86_fp80, x86_fp80 } %291, 1
%294 = load float, float* %2
%295 = fpext float %294 to double
%296 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 0
%297 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 1
store double %295, double* %296
store double 0.000000e+00, double* %297
%298 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 0
%299 = load double, double* %298
%300 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 1
%301 = load double, double* %300
%302 = call { double, double } @ccos(double %299, double %301)
%303 = extractvalue { double, double } %302, 0
%304 = extractvalue { double, double } %302, 1
%305 = load float, float* %2
%306 = getelementptr inbounds { float, float }, { float, float }* %34, i32 0, i32 0
%307 = getelementptr inbounds { float, float }, { float, float }* %34, i32 0, i32 1
store float %305, float* %306
store float 0.000000e+00, float* %307
%308 = bitcast { float, float }* %34 to <2 x float>*
%309 = load <2 x float>, <2 x float>* %308
%310 = call <2 x float> @ccosf(<2 x float> %309)
%311 = bitcast { float, float }* %35 to <2 x float>*
store <2 x float> %310, <2 x float>* %311
%312 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 0
%313 = load float, float* %312
%314 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 1
%315 = load float, float* %314
%316 = load float, float* %2
%317 = fpext float %316 to x86_fp80
%318 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %36, i32 0, i32 0
%319 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %36, i32 0, i32 1
store x86_fp80 %317, x86_fp80* %318
store x86_fp80 0xK00000000000000000000, x86_fp80* %319
%320 = call { x86_fp80, x86_fp80 } @ccosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %36)
%321 = extractvalue { x86_fp80, x86_fp80 } %320, 0
%322 = extractvalue { x86_fp80, x86_fp80 } %320, 1
%323 = load float, float* %2
%324 = fpext float %323 to double
%325 = getelementptr inbounds { double, double }, { double, double }* %37, i32 0, i32 0
%326 = getelementptr inbounds { double, double }, { double, double }* %37, i32 0, i32 1
store double %324, double* %325
store double 0.000000e+00, double* %326
%327 = getelementptr inbounds { double, double }, { double, double }* %37, i32 0, i32 0
%328 = load double, double* %327
%329 = getelementptr inbounds { double, double }, { double, double }* %37, i32 0, i32 1
%330 = load double, double* %329
%331 = call { double, double } @ccosh(double %328, double %330)
%332 = extractvalue { double, double } %331, 0
%333 = extractvalue { double, double } %331, 1
%334 = load float, float* %2
%335 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%336 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
store float %334, float* %335
store float 0.000000e+00, float* %336
%337 = bitcast { float, float }* %38 to <2 x float>*
%338 = load <2 x float>, <2 x float>* %337
%339 = call <2 x float> @ccoshf(<2 x float> %338)
%340 = bitcast { float, float }* %39 to <2 x float>*
store <2 x float> %339, <2 x float>* %340
%341 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 0
%342 = load float, float* %341
%343 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 1
%344 = load float, float* %343
%345 = load float, float* %2
%346 = fpext float %345 to x86_fp80
%347 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %40, i32 0, i32 0
%348 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %40, i32 0, i32 1
store x86_fp80 %346, x86_fp80* %347
store x86_fp80 0xK00000000000000000000, x86_fp80* %348
%349 = call { x86_fp80, x86_fp80 } @ccoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %40)
%350 = extractvalue { x86_fp80, x86_fp80 } %349, 0
%351 = extractvalue { x86_fp80, x86_fp80 } %349, 1
%352 = load float, float* %2
%353 = fpext float %352 to double
%354 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 0
%355 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 1
store double %353, double* %354
store double 0.000000e+00, double* %355
%356 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 0
%357 = load double, double* %356
%358 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 1
%359 = load double, double* %358
%360 = call { double, double } @cexp(double %357, double %359)
%361 = extractvalue { double, double } %360, 0
%362 = extractvalue { double, double } %360, 1
%363 = load float, float* %2
%364 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 0
%365 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 1
store float %363, float* %364
store float 0.000000e+00, float* %365
%366 = bitcast { float, float }* %42 to <2 x float>*
%367 = load <2 x float>, <2 x float>* %366
%368 = call <2 x float> @cexpf(<2 x float> %367)
%369 = bitcast { float, float }* %43 to <2 x float>*
store <2 x float> %368, <2 x float>* %369
%370 = getelementptr inbounds { float, float }, { float, float }* %43, i32 0, i32 0
%371 = load float, float* %370
%372 = getelementptr inbounds { float, float }, { float, float }* %43, i32 0, i32 1
%373 = load float, float* %372
%374 = load float, float* %2
%375 = fpext float %374 to x86_fp80
%376 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %44, i32 0, i32 0
%377 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %44, i32 0, i32 1
store x86_fp80 %375, x86_fp80* %376
store x86_fp80 0xK00000000000000000000, x86_fp80* %377
%378 = call { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %44)
%379 = extractvalue { x86_fp80, x86_fp80 } %378, 0
%380 = extractvalue { x86_fp80, x86_fp80 } %378, 1
%381 = load float, float* %2
%382 = fpext float %381 to double
%383 = load float, float* %2
%384 = load float, float* %2
%385 = fpext float %384 to x86_fp80
%386 = load float, float* %2
%387 = fpext float %386 to double
%388 = load float, float* %2
%389 = load float, float* %2
%390 = fpext float %389 to x86_fp80
%391 = load float, float* %2
%392 = fpext float %391 to double
%393 = getelementptr inbounds { double, double }, { double, double }* %45, i32 0, i32 0
%394 = getelementptr inbounds { double, double }, { double, double }* %45, i32 0, i32 1
store double %392, double* %393
store double 0.000000e+00, double* %394
%395 = getelementptr inbounds { double, double }, { double, double }* %45, i32 0, i32 0
%396 = load double, double* %395
%397 = getelementptr inbounds { double, double }, { double, double }* %45, i32 0, i32 1
%398 = load double, double* %397
%399 = call { double, double } @clog(double %396, double %398)
%400 = extractvalue { double, double } %399, 0
%401 = extractvalue { double, double } %399, 1
%402 = load float, float* %2
%403 = getelementptr inbounds { float, float }, { float, float }* %46, i32 0, i32 0
%404 = getelementptr inbounds { float, float }, { float, float }* %46, i32 0, i32 1
store float %402, float* %403
store float 0.000000e+00, float* %404
%405 = bitcast { float, float }* %46 to <2 x float>*
%406 = load <2 x float>, <2 x float>* %405
%407 = call <2 x float> @clogf(<2 x float> %406)
%408 = bitcast { float, float }* %47 to <2 x float>*
store <2 x float> %407, <2 x float>* %408
%409 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 0
%410 = load float, float* %409
%411 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 1
%412 = load float, float* %411
%413 = load float, float* %2
%414 = fpext float %413 to x86_fp80
%415 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %48, i32 0, i32 0
%416 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %48, i32 0, i32 1
store x86_fp80 %414, x86_fp80* %415
store x86_fp80 0xK00000000000000000000, x86_fp80* %416
%417 = call { x86_fp80, x86_fp80 } @clogl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %48)
%418 = extractvalue { x86_fp80, x86_fp80 } %417, 0
%419 = extractvalue { x86_fp80, x86_fp80 } %417, 1
%420 = load float, float* %2
%421 = fpext float %420 to double
%422 = getelementptr inbounds { double, double }, { double, double }* %49, i32 0, i32 0
%423 = getelementptr inbounds { double, double }, { double, double }* %49, i32 0, i32 1
store double %421, double* %422
store double 0.000000e+00, double* %423
%424 = getelementptr inbounds { double, double }, { double, double }* %49, i32 0, i32 0
%425 = load double, double* %424
%426 = getelementptr inbounds { double, double }, { double, double }* %49, i32 0, i32 1
%427 = load double, double* %426
%428 = call { double, double } @cproj(double %425, double %427)
%429 = extractvalue { double, double } %428, 0
%430 = extractvalue { double, double } %428, 1
%431 = load float, float* %2
%432 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 0
%433 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 1
store float %431, float* %432
store float 0.000000e+00, float* %433
%434 = bitcast { float, float }* %50 to <2 x float>*
%435 = load <2 x float>, <2 x float>* %434
%436 = call <2 x float> @cprojf(<2 x float> %435)
%437 = bitcast { float, float }* %51 to <2 x float>*
store <2 x float> %436, <2 x float>* %437
%438 = getelementptr inbounds { float, float }, { float, float }* %51, i32 0, i32 0
%439 = load float, float* %438
%440 = getelementptr inbounds { float, float }, { float, float }* %51, i32 0, i32 1
%441 = load float, float* %440
%442 = load float, float* %2
%443 = fpext float %442 to x86_fp80
%444 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %52, i32 0, i32 0
%445 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %52, i32 0, i32 1
store x86_fp80 %443, x86_fp80* %444
store x86_fp80 0xK00000000000000000000, x86_fp80* %445
%446 = call { x86_fp80, x86_fp80 } @cprojl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %52)
%447 = extractvalue { x86_fp80, x86_fp80 } %446, 0
%448 = extractvalue { x86_fp80, x86_fp80 } %446, 1
%449 = load float, float* %2
%450 = fpext float %449 to double
%451 = load float, float* %2
%452 = fpext float %451 to double
%453 = getelementptr inbounds { double, double }, { double, double }* %53, i32 0, i32 0
%454 = getelementptr inbounds { double, double }, { double, double }* %53, i32 0, i32 1
store double %450, double* %453
store double 0.000000e+00, double* %454
%455 = getelementptr inbounds { double, double }, { double, double }* %53, i32 0, i32 0
%456 = load double, double* %455
%457 = getelementptr inbounds { double, double }, { double, double }* %53, i32 0, i32 1
%458 = load double, double* %457
%459 = getelementptr inbounds { double, double }, { double, double }* %54, i32 0, i32 0
%460 = getelementptr inbounds { double, double }, { double, double }* %54, i32 0, i32 1
store double %452, double* %459
store double 0.000000e+00, double* %460
%461 = getelementptr inbounds { double, double }, { double, double }* %54, i32 0, i32 0
%462 = load double, double* %461
%463 = getelementptr inbounds { double, double }, { double, double }* %54, i32 0, i32 1
%464 = load double, double* %463
%465 = call { double, double } @cpow(double %456, double %458, double %462, double %464)
%466 = extractvalue { double, double } %465, 0
%467 = extractvalue { double, double } %465, 1
%468 = load float, float* %2
%469 = load float, float* %2
%470 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 0
%471 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 1
store float %468, float* %470
store float 0.000000e+00, float* %471
%472 = bitcast { float, float }* %55 to <2 x float>*
%473 = load <2 x float>, <2 x float>* %472
%474 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 0
%475 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 1
store float %469, float* %474
store float 0.000000e+00, float* %475
%476 = bitcast { float, float }* %56 to <2 x float>*
%477 = load <2 x float>, <2 x float>* %476
%478 = call <2 x float> @cpowf(<2 x float> %473, <2 x float> %477)
%479 = bitcast { float, float }* %57 to <2 x float>*
store <2 x float> %478, <2 x float>* %479
%480 = getelementptr inbounds { float, float }, { float, float }* %57, i32 0, i32 0
%481 = load float, float* %480
%482 = getelementptr inbounds { float, float }, { float, float }* %57, i32 0, i32 1
%483 = load float, float* %482
%484 = load float, float* %2
%485 = fpext float %484 to x86_fp80
%486 = load float, float* %2
%487 = fpext float %486 to x86_fp80
%488 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %58, i32 0, i32 0
%489 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %58, i32 0, i32 1
store x86_fp80 %485, x86_fp80* %488
store x86_fp80 0xK00000000000000000000, x86_fp80* %489
%490 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %59, i32 0, i32 0
%491 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %59, i32 0, i32 1
store x86_fp80 %487, x86_fp80* %490
store x86_fp80 0xK00000000000000000000, x86_fp80* %491
%492 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %58, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %59)
%493 = extractvalue { x86_fp80, x86_fp80 } %492, 0
%494 = extractvalue { x86_fp80, x86_fp80 } %492, 1
%495 = load float, float* %2
%496 = fpext float %495 to double
%497 = load float, float* %2
%498 = load float, float* %2
%499 = fpext float %498 to x86_fp80
%500 = load float, float* %2
%501 = fpext float %500 to double
%502 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 0
%503 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 1
store double %501, double* %502
store double 0.000000e+00, double* %503
%504 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 0
%505 = load double, double* %504
%506 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 1
%507 = load double, double* %506
%508 = call { double, double } @csin(double %505, double %507)
%509 = extractvalue { double, double } %508, 0
%510 = extractvalue { double, double } %508, 1
%511 = load float, float* %2
%512 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 0
%513 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 1
store float %511, float* %512
store float 0.000000e+00, float* %513
%514 = bitcast { float, float }* %61 to <2 x float>*
%515 = load <2 x float>, <2 x float>* %514
%516 = call <2 x float> @csinf(<2 x float> %515)
%517 = bitcast { float, float }* %62 to <2 x float>*
store <2 x float> %516, <2 x float>* %517
%518 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 0
%519 = load float, float* %518
%520 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 1
%521 = load float, float* %520
%522 = load float, float* %2
%523 = fpext float %522 to x86_fp80
%524 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %63, i32 0, i32 0
%525 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %63, i32 0, i32 1
store x86_fp80 %523, x86_fp80* %524
store x86_fp80 0xK00000000000000000000, x86_fp80* %525
%526 = call { x86_fp80, x86_fp80 } @csinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %63)
%527 = extractvalue { x86_fp80, x86_fp80 } %526, 0
%528 = extractvalue { x86_fp80, x86_fp80 } %526, 1
%529 = load float, float* %2
%530 = fpext float %529 to double
%531 = getelementptr inbounds { double, double }, { double, double }* %64, i32 0, i32 0
%532 = getelementptr inbounds { double, double }, { double, double }* %64, i32 0, i32 1
store double %530, double* %531
store double 0.000000e+00, double* %532
%533 = getelementptr inbounds { double, double }, { double, double }* %64, i32 0, i32 0
%534 = load double, double* %533
%535 = getelementptr inbounds { double, double }, { double, double }* %64, i32 0, i32 1
%536 = load double, double* %535
%537 = call { double, double } @csinh(double %534, double %536)
%538 = extractvalue { double, double } %537, 0
%539 = extractvalue { double, double } %537, 1
%540 = load float, float* %2
%541 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 0
%542 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 1
store float %540, float* %541
store float 0.000000e+00, float* %542
%543 = bitcast { float, float }* %65 to <2 x float>*
%544 = load <2 x float>, <2 x float>* %543
%545 = call <2 x float> @csinhf(<2 x float> %544)
%546 = bitcast { float, float }* %66 to <2 x float>*
store <2 x float> %545, <2 x float>* %546
%547 = getelementptr inbounds { float, float }, { float, float }* %66, i32 0, i32 0
%548 = load float, float* %547
%549 = getelementptr inbounds { float, float }, { float, float }* %66, i32 0, i32 1
%550 = load float, float* %549
%551 = load float, float* %2
%552 = fpext float %551 to x86_fp80
%553 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %67, i32 0, i32 0
%554 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %67, i32 0, i32 1
store x86_fp80 %552, x86_fp80* %553
store x86_fp80 0xK00000000000000000000, x86_fp80* %554
%555 = call { x86_fp80, x86_fp80 } @csinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %67)
%556 = extractvalue { x86_fp80, x86_fp80 } %555, 0
%557 = extractvalue { x86_fp80, x86_fp80 } %555, 1
%558 = load float, float* %2
%559 = fpext float %558 to double
%560 = getelementptr inbounds { double, double }, { double, double }* %68, i32 0, i32 0
%561 = getelementptr inbounds { double, double }, { double, double }* %68, i32 0, i32 1
store double %559, double* %560
store double 0.000000e+00, double* %561
%562 = getelementptr inbounds { double, double }, { double, double }* %68, i32 0, i32 0
%563 = load double, double* %562
%564 = getelementptr inbounds { double, double }, { double, double }* %68, i32 0, i32 1
%565 = load double, double* %564
%566 = call { double, double } @csqrt(double %563, double %565)
%567 = extractvalue { double, double } %566, 0
%568 = extractvalue { double, double } %566, 1
%569 = load float, float* %2
%570 = getelementptr inbounds { float, float }, { float, float }* %69, i32 0, i32 0
%571 = getelementptr inbounds { float, float }, { float, float }* %69, i32 0, i32 1
store float %569, float* %570
store float 0.000000e+00, float* %571
%572 = bitcast { float, float }* %69 to <2 x float>*
%573 = load <2 x float>, <2 x float>* %572
%574 = call <2 x float> @csqrtf(<2 x float> %573)
%575 = bitcast { float, float }* %70 to <2 x float>*
store <2 x float> %574, <2 x float>* %575
%576 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 0
%577 = load float, float* %576
%578 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 1
%579 = load float, float* %578
%580 = load float, float* %2
%581 = fpext float %580 to x86_fp80
%582 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %71, i32 0, i32 0
%583 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %71, i32 0, i32 1
store x86_fp80 %581, x86_fp80* %582
store x86_fp80 0xK00000000000000000000, x86_fp80* %583
%584 = call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %71)
%585 = extractvalue { x86_fp80, x86_fp80 } %584, 0
%586 = extractvalue { x86_fp80, x86_fp80 } %584, 1
%587 = load float, float* %2
%588 = fpext float %587 to double
%589 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 0
%590 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 1
store double %588, double* %589
store double 0.000000e+00, double* %590
%591 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 0
%592 = load double, double* %591
%593 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 1
%594 = load double, double* %593
%595 = call { double, double } @ctan(double %592, double %594)
%596 = extractvalue { double, double } %595, 0
%597 = extractvalue { double, double } %595, 1
%598 = load float, float* %2
%599 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%600 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
store float %598, float* %599
store float 0.000000e+00, float* %600
%601 = bitcast { float, float }* %73 to <2 x float>*
%602 = load <2 x float>, <2 x float>* %601
%603 = call <2 x float> @ctanf(<2 x float> %602)
%604 = bitcast { float, float }* %74 to <2 x float>*
store <2 x float> %603, <2 x float>* %604
%605 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 0
%606 = load float, float* %605
%607 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 1
%608 = load float, float* %607
%609 = load float, float* %2
%610 = fpext float %609 to x86_fp80
%611 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %75, i32 0, i32 0
%612 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %75, i32 0, i32 1
store x86_fp80 %610, x86_fp80* %611
store x86_fp80 0xK00000000000000000000, x86_fp80* %612
%613 = call { x86_fp80, x86_fp80 } @ctanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %75)
%614 = extractvalue { x86_fp80, x86_fp80 } %613, 0
%615 = extractvalue { x86_fp80, x86_fp80 } %613, 1
%616 = load float, float* %2
%617 = fpext float %616 to double
%618 = getelementptr inbounds { double, double }, { double, double }* %76, i32 0, i32 0
%619 = getelementptr inbounds { double, double }, { double, double }* %76, i32 0, i32 1
store double %617, double* %618
store double 0.000000e+00, double* %619
%620 = getelementptr inbounds { double, double }, { double, double }* %76, i32 0, i32 0
%621 = load double, double* %620
%622 = getelementptr inbounds { double, double }, { double, double }* %76, i32 0, i32 1
%623 = load double, double* %622
%624 = call { double, double } @ctanh(double %621, double %623)
%625 = extractvalue { double, double } %624, 0
%626 = extractvalue { double, double } %624, 1
%627 = load float, float* %2
%628 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 0
%629 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 1
store float %627, float* %628
store float 0.000000e+00, float* %629
%630 = bitcast { float, float }* %77 to <2 x float>*
%631 = load <2 x float>, <2 x float>* %630
%632 = call <2 x float> @ctanhf(<2 x float> %631)
%633 = bitcast { float, float }* %78 to <2 x float>*
store <2 x float> %632, <2 x float>* %633
%634 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 0
%635 = load float, float* %634
%636 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 1
%637 = load float, float* %636
%638 = load float, float* %2
%639 = fpext float %638 to x86_fp80
%640 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %79, i32 0, i32 0
%641 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %79, i32 0, i32 1
store x86_fp80 %639, x86_fp80* %640
store x86_fp80 0xK00000000000000000000, x86_fp80* %641
%642 = call { x86_fp80, x86_fp80 } @ctanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %79)
%643 = extractvalue { x86_fp80, x86_fp80 } %642, 0
%644 = extractvalue { x86_fp80, x86_fp80 } %642, 1
ret void
}

LLVM IR (-O2):
define void @foo(float %0) {
%2 = alloca { x86_fp80, x86_fp80 }
%3 = alloca { x86_fp80, x86_fp80 }
%4 = alloca { x86_fp80, x86_fp80 }
%5 = alloca { x86_fp80, x86_fp80 }
%6 = alloca { x86_fp80, x86_fp80 }
%7 = alloca { x86_fp80, x86_fp80 }
%8 = alloca { x86_fp80, x86_fp80 }
%9 = alloca { x86_fp80, x86_fp80 }
%10 = alloca { x86_fp80, x86_fp80 }
%11 = alloca { x86_fp80, x86_fp80 }
%12 = alloca { x86_fp80, x86_fp80 }
%13 = alloca { x86_fp80, x86_fp80 }
%14 = alloca { x86_fp80, x86_fp80 }
%15 = alloca { x86_fp80, x86_fp80 }
%16 = alloca { x86_fp80, x86_fp80 }
%17 = alloca { x86_fp80, x86_fp80 }
%18 = alloca { x86_fp80, x86_fp80 }
%19 = alloca { x86_fp80, x86_fp80 }
%20 = alloca { x86_fp80, x86_fp80 }
%21 = alloca { x86_fp80, x86_fp80 }
%22 = fpext float %0 to double
%23 = tail call double @cabs(double %22, double 0.000000e+00)
%24 = insertelement <2 x float> <float poison, float 0.000000e+00>, float %0, i64 0
%25 = tail call float @cabsf(<2 x float> %24)
%26 = fpext float %0 to x86_fp80
%27 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %2, i64 0, i32 0
%28 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %2, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %27
store x86_fp80 0xK00000000000000000000, x86_fp80* %28
%29 = tail call x86_fp80 @cabsl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %2)
%30 = tail call { double, double } @cacos(double %22, double 0.000000e+00)
%31 = tail call <2 x float> @cacosf(<2 x float> %24)
%32 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %3, i64 0, i32 0
%33 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %3, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %32
store x86_fp80 0xK00000000000000000000, x86_fp80* %33
%34 = tail call { x86_fp80, x86_fp80 } @cacosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %3)
%35 = tail call { double, double } @cacosh(double %22, double 0.000000e+00)
%36 = tail call <2 x float> @cacoshf(<2 x float> %24)
%37 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %4, i64 0, i32 0
%38 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %4, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %37
store x86_fp80 0xK00000000000000000000, x86_fp80* %38
%39 = tail call { x86_fp80, x86_fp80 } @cacoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %4)
%40 = tail call double @carg(double %22, double 0.000000e+00)
%41 = tail call float @cargf(<2 x float> %24)
%42 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %5, i64 0, i32 0
%43 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %5, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %42
store x86_fp80 0xK00000000000000000000, x86_fp80* %43
%44 = tail call x86_fp80 @cargl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %5)
%45 = tail call { double, double } @casin(double %22, double 0.000000e+00)
%46 = tail call <2 x float> @casinf(<2 x float> %24)
%47 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %6, i64 0, i32 0
%48 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %6, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %47
store x86_fp80 0xK00000000000000000000, x86_fp80* %48
%49 = tail call { x86_fp80, x86_fp80 } @casinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %6)
%50 = tail call { double, double } @casinh(double %22, double 0.000000e+00)
%51 = tail call <2 x float> @casinhf(<2 x float> %24)
%52 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %7, i64 0, i32 0
%53 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %7, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %52
store x86_fp80 0xK00000000000000000000, x86_fp80* %53
%54 = tail call { x86_fp80, x86_fp80 } @casinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %7)
%55 = tail call { double, double } @catan(double %22, double 0.000000e+00)
%56 = tail call <2 x float> @catanf(<2 x float> %24)
%57 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %8, i64 0, i32 0
%58 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %8, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %57
store x86_fp80 0xK00000000000000000000, x86_fp80* %58
%59 = tail call { x86_fp80, x86_fp80 } @catanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %8)
%60 = tail call { double, double } @catanh(double %22, double 0.000000e+00)
%61 = tail call <2 x float> @catanhf(<2 x float> %24)
%62 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %9, i64 0, i32 0
%63 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %9, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %62
store x86_fp80 0xK00000000000000000000, x86_fp80* %63
%64 = tail call { x86_fp80, x86_fp80 } @catanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %9)
%65 = tail call { double, double } @ccos(double %22, double 0.000000e+00)
%66 = tail call <2 x float> @ccosf(<2 x float> %24)
%67 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %10, i64 0, i32 0
%68 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %10, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %67
store x86_fp80 0xK00000000000000000000, x86_fp80* %68
%69 = tail call { x86_fp80, x86_fp80 } @ccosl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %10)
%70 = tail call { double, double } @ccosh(double %22, double 0.000000e+00)
%71 = tail call <2 x float> @ccoshf(<2 x float> %24)
%72 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %11, i64 0, i32 0
%73 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %11, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %72
store x86_fp80 0xK00000000000000000000, x86_fp80* %73
%74 = tail call { x86_fp80, x86_fp80 } @ccoshl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %11)
%75 = tail call { double, double } @cexp(double %22, double 0.000000e+00)
%76 = tail call <2 x float> @cexpf(<2 x float> %24)
%77 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %12, i64 0, i32 0
%78 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %12, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %77
store x86_fp80 0xK00000000000000000000, x86_fp80* %78
%79 = tail call { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %12)
%80 = tail call { double, double } @clog(double %22, double 0.000000e+00)
%81 = tail call <2 x float> @clogf(<2 x float> %24)
%82 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i64 0, i32 0
%83 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %82
store x86_fp80 0xK00000000000000000000, x86_fp80* %83
%84 = tail call { x86_fp80, x86_fp80 } @clogl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %13)
%85 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %14, i64 0, i32 0
%86 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %14, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %85
store x86_fp80 0xK00000000000000000000, x86_fp80* %86
%87 = tail call { x86_fp80, x86_fp80 } @cprojl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %14)
%88 = tail call { double, double } @cpow(double %22, double 0.000000e+00, double %22, double 0.000000e+00)
%89 = tail call <2 x float> @cpowf(<2 x float> %24, <2 x float> %24)
%90 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %15, i64 0, i32 0
%91 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %15, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %90
store x86_fp80 0xK00000000000000000000, x86_fp80* %91
%92 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %16, i64 0, i32 0
%93 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %16, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %92
store x86_fp80 0xK00000000000000000000, x86_fp80* %93
%94 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %15, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %16)
%95 = tail call { double, double } @csin(double %22, double 0.000000e+00)
%96 = tail call <2 x float> @csinf(<2 x float> %24)
%97 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %17, i64 0, i32 0
%98 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %17, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %97
store x86_fp80 0xK00000000000000000000, x86_fp80* %98
%99 = tail call { x86_fp80, x86_fp80 } @csinl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %17)
%100 = tail call { double, double } @csinh(double %22, double 0.000000e+00)
%101 = tail call <2 x float> @csinhf(<2 x float> %24)
%102 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %18, i64 0, i32 0
%103 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %18, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %102
store x86_fp80 0xK00000000000000000000, x86_fp80* %103
%104 = tail call { x86_fp80, x86_fp80 } @csinhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %18)
%105 = tail call { double, double } @csqrt(double %22, double 0.000000e+00)
%106 = tail call <2 x float> @csqrtf(<2 x float> %24)
%107 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %19, i64 0, i32 0
%108 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %19, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %107
store x86_fp80 0xK00000000000000000000, x86_fp80* %108
%109 = tail call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %19)
%110 = tail call { double, double } @ctan(double %22, double 0.000000e+00)
%111 = tail call <2 x float> @ctanf(<2 x float> %24)
%112 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i64 0, i32 0
%113 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %112
store x86_fp80 0xK00000000000000000000, x86_fp80* %113
%114 = tail call { x86_fp80, x86_fp80 } @ctanl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %20)
%115 = tail call { double, double } @ctanh(double %22, double 0.000000e+00)
%116 = tail call <2 x float> @ctanhf(<2 x float> %24)
%117 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %21, i64 0, i32 0
%118 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %21, i64 0, i32 1
store x86_fp80 %26, x86_fp80* %117
store x86_fp80 0xK00000000000000000000, x86_fp80* %118
%119 = tail call { x86_fp80, x86_fp80 } @ctanhl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %21)
ret void
}