void bar() {
  foof(__builtin_csqrtf(__builtin_nanf("")));
  foo(__builtin_csqrt(__builtin_nan("")));
  fool(__builtin_csqrtl(__builtin_nanl("")));
  foof(__builtin_csqrtf(__builtin_inff()));
  foo(__builtin_csqrt(__builtin_inf()));
  fool(__builtin_csqrtl(__builtin_infl()));
  foof(__builtin_csqrtf(-__builtin_inff()));
  foo(__builtin_csqrt(-__builtin_inf()));
  fool(__builtin_csqrtl(-__builtin_infl()));
  do {
    foof(__builtin_cexpf(1e20F));
    foo(__builtin_cexp(1e20));
    fool(__builtin_cexpl(1e20L));
  } while (0);
  do {
    foof(__builtin_cexpf(-1e20F));
    foo(__builtin_cexp(-1e20));
    fool(__builtin_cexpl(-1e20L));
  } while (0);
  foof(__builtin_cpowf(__builtin_nanf(""), 2.5F));
  foo(__builtin_cpow(__builtin_nan(""), 2.5));
  fool(__builtin_cpowl(__builtin_nanl(""), 2.5L));
  foof(__builtin_cpowf(2.5F, __builtin_nanf("")));
  foo(__builtin_cpow(2.5, __builtin_nan("")));
  fool(__builtin_cpowl(2.5L, __builtin_nanl("")));
  foof(__builtin_cpowf(__builtin_inff(), 2.5F));
  foo(__builtin_cpow(__builtin_inf(), 2.5));
  fool(__builtin_cpowl(__builtin_infl(), 2.5L));
  foof(__builtin_cpowf(-__builtin_inff(), 2.5F));
  foo(__builtin_cpow(-__builtin_inf(), 2.5));
  fool(__builtin_cpowl(-__builtin_infl(), 2.5L));
  foof(__builtin_cpowf(2.5F, __builtin_inff()));
  foo(__builtin_cpow(2.5, __builtin_inf()));
  fool(__builtin_cpowl(2.5L, __builtin_infl()));
  foof(__builtin_cpowf(2.5F, -__builtin_inff()));
  foo(__builtin_cpow(2.5, -__builtin_inf()));
  fool(__builtin_cpowl(2.5L, -__builtin_infl()));
  do {
    foof(__builtin_cpowf(-0.0F, -4.5F));
    foo(__builtin_cpow(-0.0, -4.5));
    fool(__builtin_cpowl(-0.0L, -4.5L));
  } while (0);
  do {
    foof(__builtin_cpowf(0.0F, -4.5F));
    foo(__builtin_cpow(0.0, -4.5));
    fool(__builtin_cpowl(0.0L, -4.5L));
  } while (0);
  foof(__builtin_cpowf(3.40282346638528859811704183484516925e+38F, 3.5F));
  foof(
      __builtin_cpowf(3.40282346638528859811704183484516925e+38F * 1.FI, 3.5F));
  foo(__builtin_cpow(((double)1.79769313486231570814527423731704357e+308L),
                     3.5));
  foo(__builtin_cpow(
      ((double)1.79769313486231570814527423731704357e+308L) * 1.I, 3.5));
  fool(__builtin_cpowl(1.18973149535723176502126385303097021e+4932L, 3.5L));
  fool(__builtin_cpowl(1.18973149535723176502126385303097021e+4932L * 1.LI,
                       3.5L));
  do {
    foof(__builtin_cpowf(2.0F, 0x1p50F));
    foo(__builtin_cpow(2.0, 0x1p50));
    fool(__builtin_cpowl(2.0L, 0x1p50L));
  } while (0);
  do {
    foof(__builtin_cpowf(2.0F, 0x1p28F));
    foo(__builtin_cpow(2.0, 0x1p28));
    fool(__builtin_cpowl(2.0L, 0x1p28L));
  } while (0);
  do {
    foof(__builtin_cpowf(2.0F, 0x1p24F));
    foo(__builtin_cpow(2.0, 0x1p24));
    fool(__builtin_cpowl(2.0L, 0x1p24L));
  } while (0);
  foof(__builtin_cpowf(3.40282346638528859811704183484516925e+38F, -3.5F));
  foof(__builtin_cpowf(3.40282346638528859811704183484516925e+38F * 1.FI,
                       -3.5F));
  foo(__builtin_cpow(((double)1.79769313486231570814527423731704357e+308L),
                     -3.5));
  foo(__builtin_cpow(
      ((double)1.79769313486231570814527423731704357e+308L) * 1.I, -3.5));
  fool(__builtin_cpowl(1.18973149535723176502126385303097021e+4932L, -3.5L));
  fool(__builtin_cpowl(1.18973149535723176502126385303097021e+4932L * 1.LI,
                       -3.5L));
  do {
    foof(__builtin_cpowf(2.0F, -0x1p50F));
    foo(__builtin_cpow(2.0, -0x1p50));
    fool(__builtin_cpowl(2.0L, -0x1p50L));
  } while (0);
  do {
    foof(__builtin_cpowf(2.0F, -0x1p28F));
    foo(__builtin_cpow(2.0, -0x1p28));
    fool(__builtin_cpowl(2.0L, -0x1p28L));
  } while (0);
  do {
    foof(__builtin_cpowf(2.0F, -0x1p24F));
    foo(__builtin_cpow(2.0, -0x1p24));
    fool(__builtin_cpowl(2.0L, -0x1p24L));
  } while (0);
}


x86 assembly (clang, -O0):
<bar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1010,%rsp
movl   $0x7fc00000,-0x8(%rbp)
movl   $0x0,-0x4(%rbp)
movsd  -0x8(%rbp),%xmm0
call   10d0 <csqrtf@plt>
movlpd %xmm0,-0x10(%rbp)
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  %xmm1,-0x18(%rbp)
movss  %xmm0,-0x14(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    $0x1,%al
mov    %al,-0xeee(%rbp)
call   1040 <foof@plt>
movabs $0x7ff8000000000000,%rax
mov    %rax,-0x28(%rbp)
movq   $0x0,-0x20(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
call   10e0 <csqrt@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
mov    $0x2,%al
mov    %al,-0xeed(%rbp)
call   1090 <foo@plt>
flds   0x2da6(%rip)
fstpt  -0x60(%rbp)
fldz
fld    %st(0)
fstpt  -0xeec(%rbp)
fstpt  -0x50(%rbp)
movaps -0x60(%rbp),%xmm0
movaps -0x50(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10c0 <csqrtl@plt>
fstpt  -0x80(%rbp)
fstpt  -0x70(%rbp)
movaps -0x80(%rbp),%xmm0
movaps -0x70(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
xor    %eax,%eax
mov    %al,-0xeef(%rbp)
call   1050 <fool@plt>
movl   $0x7f800000,-0x88(%rbp)
movl   $0x0,-0x84(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
call   10d0 <csqrtf@plt>
mov    -0xeee(%rbp),%al
movlpd %xmm0,-0x90(%rbp)
ff
movss  -0x90(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm1,-0x98(%rbp)
ff
movss  %xmm0,-0x94(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1040 <foof@plt>
movabs $0x7ff0000000000000,%rax
mov    %rax,-0xa8(%rbp)
movq   $0x0,-0xa0(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
call   10e0 <csqrt@plt>
mov    -0xeed(%rbp),%al
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  %xmm1,-0xb0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xeec(%rbp)
flds   0x2c9a(%rip)
fstpt  -0xe0(%rbp)
fstpt  -0xd0(%rbp)
movaps -0xe0(%rbp),%xmm0
movaps -0xd0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10c0 <csqrtl@plt>
mov    -0xeef(%rbp),%al
fstpt  -0x100(%rbp)
fstpt  -0xf0(%rbp)
movaps -0x100(%rbp),%xmm0
movaps -0xf0(%rbp),%xmm1
mov    %rsp,%rcx
movaps %xmm1,0x10(%rcx)
movaps %xmm0,(%rcx)
call   1050 <fool@plt>
movl   $0xff800000,-0x108(%rbp)
movl   $0x0,-0x104(%rbp)
movsd  -0x108(%rbp),%xmm0
ff
call   10d0 <csqrtf@plt>
mov    -0xeee(%rbp),%al
movlpd %xmm0,-0x110(%rbp)
ff
movss  -0x110(%rbp),%xmm1
ff
movss  -0x10c(%rbp),%xmm0
movss  %xmm1,-0x118(%rbp)
ff
movss  %xmm0,-0x114(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
call   1040 <foof@plt>
movabs $0xfff0000000000000,%rax
mov    %rax,-0x128(%rbp)
movq   $0x0,-0x120(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
call   10e0 <csqrt@plt>
mov    -0xeed(%rbp),%al
movsd  %xmm0,-0x138(%rbp)
ff
movsd  %xmm1,-0x130(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xeec(%rbp)
flds   0x2b82(%rip)
fstpt  -0x160(%rbp)
fstpt  -0x150(%rbp)
movaps -0x160(%rbp),%xmm0
movaps -0x150(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10c0 <csqrtl@plt>
fstpt  -0x180(%rbp)
fstpt  -0x170(%rbp)
lea    -0x180(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x60ad78ec,-0x188(%rbp)
78 ad 60
movl   $0x0,-0x184(%rbp)
movsd  -0x188(%rbp),%xmm0
ff
call   1080 <cexpf@plt>
movlpd %xmm0,-0x190(%rbp)
ff
movss  -0x190(%rbp),%xmm1
ff
movss  -0x18c(%rbp),%xmm0
ff
movss  %xmm1,-0x198(%rbp)
ff
movss  %xmm0,-0x194(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4415af1d78b58c40,%rax
af 15 44
mov    %rax,-0x1a8(%rbp)
movq   $0x0,-0x1a0(%rbp)
movsd  -0x1a8(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm1
ff
call   1060 <cexp@plt>
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  %xmm1,-0x1b0(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
fldl   0x2a97(%rip)
fstpt  -0x1e0(%rbp)
fldz
fstpt  -0x1d0(%rbp)
movaps -0x1e0(%rbp),%xmm0
movaps -0x1d0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   1070 <cexpl@plt>
fstpt  -0x200(%rbp)
fstpt  -0x1f0(%rbp)
lea    -0x200(%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)
mov    $0x0,%al
call   1050 <fool@plt>
jmp    160d <bar+0x44d>
movl   $0xe0ad78ec,-0x208(%rbp)
78 ad e0
movl   $0x0,-0x204(%rbp)
movsd  -0x208(%rbp),%xmm0
ff
call   1080 <cexpf@plt>
movlpd %xmm0,-0x210(%rbp)
ff
movss  -0x210(%rbp),%xmm1
ff
movss  -0x20c(%rbp),%xmm0
ff
movss  %xmm1,-0x218(%rbp)
ff
movss  %xmm0,-0x214(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0xc415af1d78b58c40,%rax
af 15 c4
mov    %rax,-0x228(%rbp)
movq   $0x0,-0x220(%rbp)
movsd  -0x228(%rbp),%xmm0
ff
movsd  -0x220(%rbp),%xmm1
ff
call   1060 <cexp@plt>
movsd  %xmm0,-0x238(%rbp)
ff
movsd  %xmm1,-0x230(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
movsd  -0x230(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
fldl   0x297d(%rip)
fstpt  -0x260(%rbp)
fldz
fstpt  -0x250(%rbp)
movaps -0x260(%rbp),%xmm0
movaps -0x250(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   1070 <cexpl@plt>
fstpt  -0x280(%rbp)
fstpt  -0x270(%rbp)
lea    -0x280(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x7fc00000,-0x288(%rbp)
movl   $0x0,-0x284(%rbp)
movsd  -0x288(%rbp),%xmm0
ff
movl   $0x40200000,-0x290(%rbp)
movl   $0x0,-0x28c(%rbp)
movsd  -0x290(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0x298(%rbp)
ff
movss  -0x298(%rbp),%xmm1
ff
movss  -0x294(%rbp),%xmm0
ff
movss  %xmm1,-0x2a0(%rbp)
ff
movss  %xmm0,-0x29c(%rbp)
ff
movsd  -0x2a0(%rbp),%xmm0
ff
mov    $0x1,%al
mov    %al,-0xf29(%rbp)
call   1040 <foof@plt>
movabs $0x7ff8000000000000,%rax
mov    %rax,-0xf58(%rbp)
mov    %rax,-0x2b0(%rbp)
movq   $0x0,-0x2a8(%rbp)
movsd  -0x2b0(%rbp),%xmm0
ff
movsd  -0x2a8(%rbp),%xmm1
ff
movabs $0x4004000000000000,%rax
mov    %rax,-0xf28(%rbp)
mov    %rax,-0x2c0(%rbp)
movq   $0x0,-0x2b8(%rbp)
movsd  -0x2c0(%rbp),%xmm2
ff
movsd  -0x2b8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  %xmm1,-0x2c8(%rbp)
ff
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm1
ff
mov    $0x2,%al
mov    %al,-0xf15(%rbp)
call   1090 <foo@plt>
flds   0x27be(%rip)
fld    %st(0)
fstpt  -0xf4c(%rbp)
fstpt  -0x2f0(%rbp)
fldz
fld    %st(0)
fstpt  -0xefc(%rbp)
fld    %st(0)
fstpt  -0x2e0(%rbp)
flds   0x27a4(%rip)
fld    %st(0)
fstpt  -0xf14(%rbp)
fstpt  -0x310(%rbp)
fstpt  -0x300(%rbp)
movaps -0x310(%rbp),%xmm0
movaps -0x300(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x2f0(%rbp),%xmm0
movaps -0x2e0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0x330(%rbp)
fstpt  -0x320(%rbp)
movaps -0x330(%rbp),%xmm0
movaps -0x320(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
xor    %eax,%eax
mov    %al,-0xf2a(%rbp)
call   1050 <fool@plt>
movl   $0x40200000,-0x338(%rbp)
movl   $0x0,-0x334(%rbp)
movsd  -0x338(%rbp),%xmm0
ff
movl   $0x7fc00000,-0x340(%rbp)
movl   $0x0,-0x33c(%rbp)
movsd  -0x340(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xf29(%rbp),%al
movlpd %xmm0,-0x348(%rbp)
ff
movss  -0x348(%rbp),%xmm1
ff
movss  -0x344(%rbp),%xmm0
ff
movss  %xmm1,-0x350(%rbp)
ff
movss  %xmm0,-0x34c(%rbp)
ff
movsd  -0x350(%rbp),%xmm0
ff
call   1040 <foof@plt>
mov    -0xf28(%rbp),%rcx
mov    -0xf58(%rbp),%rax
mov    %rcx,-0x360(%rbp)
movq   $0x0,-0x358(%rbp)
movsd  -0x360(%rbp),%xmm0
ff
movsd  -0x358(%rbp),%xmm1
ff
mov    %rax,-0x370(%rbp)
movq   $0x0,-0x368(%rbp)
movsd  -0x370(%rbp),%xmm2
ff
movsd  -0x368(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xf15(%rbp),%al
movsd  %xmm0,-0x380(%rbp)
ff
movsd  %xmm1,-0x378(%rbp)
ff
movsd  -0x380(%rbp),%xmm0
ff
movsd  -0x378(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xf4c(%rbp)
fldt   -0xf14(%rbp)
fldt   -0xefc(%rbp)
fxch   %st(1)
fstpt  -0x3a0(%rbp)
fld    %st(0)
fstpt  -0x390(%rbp)
fxch   %st(1)
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   10b0 <cpowl@plt>
mov    -0xf2a(%rbp),%al
fstpt  -0x3e0(%rbp)
fstpt  -0x3d0(%rbp)
movaps -0x3e0(%rbp),%xmm0
movaps -0x3d0(%rbp),%xmm1
mov    %rsp,%rcx
movaps %xmm1,0x10(%rcx)
movaps %xmm0,(%rcx)
call   1050 <fool@plt>
movl   $0x7f800000,-0x3e8(%rbp)
movl   $0x0,-0x3e4(%rbp)
movsd  -0x3e8(%rbp),%xmm0
ff
movl   $0x40200000,-0x3f0(%rbp)
movl   $0x0,-0x3ec(%rbp)
movsd  -0x3f0(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xf29(%rbp),%al
movlpd %xmm0,-0x3f8(%rbp)
ff
movss  -0x3f8(%rbp),%xmm1
ff
movss  -0x3f4(%rbp),%xmm0
ff
movss  %xmm1,-0x400(%rbp)
ff
movss  %xmm0,-0x3fc(%rbp)
ff
movsd  -0x400(%rbp),%xmm0
ff
call   1040 <foof@plt>
mov    -0xf28(%rbp),%rax
movabs $0x7ff0000000000000,%rcx
mov    %rcx,-0xf40(%rbp)
mov    %rcx,-0x410(%rbp)
movq   $0x0,-0x408(%rbp)
movsd  -0x410(%rbp),%xmm0
ff
movsd  -0x408(%rbp),%xmm1
ff
mov    %rax,-0x420(%rbp)
movq   $0x0,-0x418(%rbp)
movsd  -0x420(%rbp),%xmm2
ff
movsd  -0x418(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xf15(%rbp),%al
movsd  %xmm0,-0x430(%rbp)
ff
movsd  %xmm1,-0x428(%rbp)
ff
movsd  -0x430(%rbp),%xmm0
ff
movsd  -0x428(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xf14(%rbp)
fldt   -0xefc(%rbp)
flds   0x2482(%rip)
fld    %st(0)
fstpt  -0xf34(%rbp)
fstpt  -0x450(%rbp)
fld    %st(0)
fstpt  -0x440(%rbp)
fxch   %st(1)
fstpt  -0x470(%rbp)
fstpt  -0x460(%rbp)
movaps -0x470(%rbp),%xmm0
movaps -0x460(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x450(%rbp),%xmm0
movaps -0x440(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
mov    -0xf2a(%rbp),%al
fstpt  -0x490(%rbp)
fstpt  -0x480(%rbp)
movaps -0x490(%rbp),%xmm0
movaps -0x480(%rbp),%xmm1
mov    %rsp,%rcx
movaps %xmm1,0x10(%rcx)
movaps %xmm0,(%rcx)
call   1050 <fool@plt>
movl   $0xff800000,-0x498(%rbp)
movl   $0x0,-0x494(%rbp)
movsd  -0x498(%rbp),%xmm0
ff
movl   $0x40200000,-0x4a0(%rbp)
movl   $0x0,-0x49c(%rbp)
movsd  -0x4a0(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xf29(%rbp),%al
movlpd %xmm0,-0x4a8(%rbp)
ff
movss  -0x4a8(%rbp),%xmm1
ff
movss  -0x4a4(%rbp),%xmm0
ff
movss  %xmm1,-0x4b0(%rbp)
ff
movss  %xmm0,-0x4ac(%rbp)
ff
movsd  -0x4b0(%rbp),%xmm0
ff
call   1040 <foof@plt>
mov    -0xf28(%rbp),%rax
movabs $0xfff0000000000000,%rcx
mov    %rcx,-0xf20(%rbp)
mov    %rcx,-0x4c0(%rbp)
movq   $0x0,-0x4b8(%rbp)
movsd  -0x4c0(%rbp),%xmm0
ff
movsd  -0x4b8(%rbp),%xmm1
ff
mov    %rax,-0x4d0(%rbp)
movq   $0x0,-0x4c8(%rbp)
movsd  -0x4d0(%rbp),%xmm2
ff
movsd  -0x4c8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xf15(%rbp),%al
movsd  %xmm0,-0x4e0(%rbp)
ff
movsd  %xmm1,-0x4d8(%rbp)
ff
movsd  -0x4e0(%rbp),%xmm0
ff
movsd  -0x4d8(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xf14(%rbp)
fldt   -0xefc(%rbp)
flds   0x22ea(%rip)
fld    %st(0)
fstpt  -0xf08(%rbp)
fstpt  -0x500(%rbp)
fld    %st(0)
fstpt  -0x4f0(%rbp)
fxch   %st(1)
fstpt  -0x520(%rbp)
fstpt  -0x510(%rbp)
movaps -0x520(%rbp),%xmm0
movaps -0x510(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x500(%rbp),%xmm0
movaps -0x4f0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
mov    -0xf2a(%rbp),%al
fstpt  -0x540(%rbp)
fstpt  -0x530(%rbp)
movaps -0x540(%rbp),%xmm0
movaps -0x530(%rbp),%xmm1
mov    %rsp,%rcx
movaps %xmm1,0x10(%rcx)
movaps %xmm0,(%rcx)
call   1050 <fool@plt>
movl   $0x40200000,-0x548(%rbp)
movl   $0x0,-0x544(%rbp)
movsd  -0x548(%rbp),%xmm0
ff
movl   $0x7f800000,-0x550(%rbp)
movl   $0x0,-0x54c(%rbp)
movsd  -0x550(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xf29(%rbp),%al
movlpd %xmm0,-0x558(%rbp)
ff
movss  -0x558(%rbp),%xmm1
ff
movss  -0x554(%rbp),%xmm0
ff
movss  %xmm1,-0x560(%rbp)
ff
movss  %xmm0,-0x55c(%rbp)
ff
movsd  -0x560(%rbp),%xmm0
ff
call   1040 <foof@plt>
mov    -0xf28(%rbp),%rcx
mov    -0xf40(%rbp),%rax
mov    %rcx,-0x570(%rbp)
movq   $0x0,-0x568(%rbp)
movsd  -0x570(%rbp),%xmm0
ff
movsd  -0x568(%rbp),%xmm1
ff
mov    %rax,-0x580(%rbp)
movq   $0x0,-0x578(%rbp)
movsd  -0x580(%rbp),%xmm2
ff
movsd  -0x578(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xf15(%rbp),%al
movsd  %xmm0,-0x590(%rbp)
ff
movsd  %xmm1,-0x588(%rbp)
ff
movsd  -0x590(%rbp),%xmm0
ff
movsd  -0x588(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xf34(%rbp)
fldt   -0xf14(%rbp)
fldt   -0xefc(%rbp)
fxch   %st(1)
fstpt  -0x5b0(%rbp)
fld    %st(0)
fstpt  -0x5a0(%rbp)
fxch   %st(1)
fstpt  -0x5d0(%rbp)
fstpt  -0x5c0(%rbp)
movaps -0x5d0(%rbp),%xmm0
movaps -0x5c0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x5b0(%rbp),%xmm0
movaps -0x5a0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
mov    -0xf2a(%rbp),%al
fstpt  -0x5f0(%rbp)
fstpt  -0x5e0(%rbp)
movaps -0x5f0(%rbp),%xmm0
movaps -0x5e0(%rbp),%xmm1
mov    %rsp,%rcx
movaps %xmm1,0x10(%rcx)
movaps %xmm0,(%rcx)
call   1050 <fool@plt>
movl   $0x40200000,-0x5f8(%rbp)
movl   $0x0,-0x5f4(%rbp)
movsd  -0x5f8(%rbp),%xmm0
ff
movl   $0xff800000,-0x600(%rbp)
movl   $0x0,-0x5fc(%rbp)
movsd  -0x600(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xf29(%rbp),%al
movlpd %xmm0,-0x608(%rbp)
ff
movss  -0x608(%rbp),%xmm1
ff
movss  -0x604(%rbp),%xmm0
ff
movss  %xmm1,-0x610(%rbp)
ff
movss  %xmm0,-0x60c(%rbp)
ff
movsd  -0x610(%rbp),%xmm0
ff
call   1040 <foof@plt>
mov    -0xf28(%rbp),%rcx
mov    -0xf20(%rbp),%rax
mov    %rcx,-0x620(%rbp)
movq   $0x0,-0x618(%rbp)
movsd  -0x620(%rbp),%xmm0
ff
movsd  -0x618(%rbp),%xmm1
ff
mov    %rax,-0x630(%rbp)
movq   $0x0,-0x628(%rbp)
movsd  -0x630(%rbp),%xmm2
ff
movsd  -0x628(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xf15(%rbp),%al
movsd  %xmm0,-0x640(%rbp)
movsd  %xmm1,-0x638(%rbp)
ff
movsd  -0x640(%rbp),%xmm0
ff
movsd  -0x638(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   -0xf14(%rbp)
fldt   -0xf08(%rbp)
fldt   -0xefc(%rbp)
fxch   %st(2)
fstpt  -0x660(%rbp)
fld    %st(1)
fstpt  -0x650(%rbp)
fstpt  -0x680(%rbp)
fstpt  -0x670(%rbp)
movaps -0x680(%rbp),%xmm0
movaps -0x670(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x660(%rbp),%xmm0
movaps -0x650(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0x6a0(%rbp)
fstpt  -0x690(%rbp)
lea    -0x6a0(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x80000000,-0x6a8(%rbp)
movl   $0x0,-0x6a4(%rbp)
movsd  -0x6a8(%rbp),%xmm0
ff
movl   $0xc0900000,-0x6b0(%rbp)
movl   $0x0,-0x6ac(%rbp)
movsd  -0x6b0(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0x6b8(%rbp)
ff
movss  -0x6b8(%rbp),%xmm1
ff
movss  -0x6b4(%rbp),%xmm0
ff
movss  %xmm1,-0x6c0(%rbp)
ff
movss  %xmm0,-0x6bc(%rbp)
ff
movsd  -0x6c0(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x8000000000000000,%rax
mov    %rax,-0x6d0(%rbp)
movq   $0x0,-0x6c8(%rbp)
movsd  -0x6d0(%rbp),%xmm0
ff
movsd  -0x6c8(%rbp),%xmm1
ff
movabs $0xc012000000000000,%rax
mov    %rax,-0x6e0(%rbp)
movq   $0x0,-0x6d8(%rbp)
movsd  -0x6e0(%rbp),%xmm2
ff
movsd  -0x6d8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0x6f0(%rbp)
ff
movsd  %xmm1,-0x6e8(%rbp)
ff
movsd  -0x6f0(%rbp),%xmm0
ff
movsd  -0x6e8(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
fldz
fld    %st(0)
fchs
fstpt  -0x710(%rbp)
fld    %st(0)
fstpt  -0x700(%rbp)
flds   0x1e37(%rip)
fstpt  -0x730(%rbp)
fstpt  -0x720(%rbp)
movaps -0x730(%rbp),%xmm0
movaps -0x720(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x710(%rbp),%xmm0
movaps -0x700(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0x750(%rbp)
fstpt  -0x740(%rbp)
lea    -0x750(%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)
mov    $0x0,%al
call   1050 <fool@plt>
jmp    2259 <bar+0x1099>
movl   $0x0,-0x758(%rbp)
movl   $0x0,-0x754(%rbp)
movsd  -0x758(%rbp),%xmm0
ff
movl   $0xc0900000,-0x760(%rbp)
movl   $0x0,-0x75c(%rbp)
movsd  -0x760(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0x768(%rbp)
ff
movss  -0x768(%rbp),%xmm1
ff
movss  -0x764(%rbp),%xmm0
ff
movss  %xmm1,-0x770(%rbp)
ff
movss  %xmm0,-0x76c(%rbp)
ff
movsd  -0x770(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movq   $0x0,-0x780(%rbp)
movq   $0x0,-0x778(%rbp)
movsd  -0x780(%rbp),%xmm0
ff
movsd  -0x778(%rbp),%xmm1
ff
movabs $0xc012000000000000,%rax
mov    %rax,-0x790(%rbp)
movq   $0x0,-0x788(%rbp)
movsd  -0x790(%rbp),%xmm2
ff
movsd  -0x788(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0x7a0(%rbp)
ff
movsd  %xmm1,-0x798(%rbp)
ff
movsd  -0x7a0(%rbp),%xmm0
ff
movsd  -0x798(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
fldz
fld    %st(0)
fstpt  -0x7c0(%rbp)
fld    %st(0)
fstpt  -0x7b0(%rbp)
flds   0x1cad(%rip)
fstpt  -0x7e0(%rbp)
fstpt  -0x7d0(%rbp)
movaps -0x7e0(%rbp),%xmm0
movaps -0x7d0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x7c0(%rbp),%xmm0
movaps -0x7b0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0x800(%rbp)
fstpt  -0x7f0(%rbp)
lea    -0x800(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x7f7fffff,-0x808(%rbp)
ff 7f 7f
movl   $0x0,-0x804(%rbp)
movsd  -0x808(%rbp),%xmm0
ff
movl   $0x40600000,-0x810(%rbp)
movl   $0x0,-0x80c(%rbp)
movsd  -0x810(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0x818(%rbp)
ff
movss  -0x818(%rbp),%xmm1
ff
movss  -0x814(%rbp),%xmm0
ff
movss  %xmm1,-0x820(%rbp)
ff
movss  %xmm0,-0x81c(%rbp)
ff
movsd  -0x820(%rbp),%xmm0
ff
mov    $0x1,%al
mov    %al,-0xf91(%rbp)
call   1040 <foof@plt>
movl   $0x0,-0x828(%rbp)
movl   $0x7f7fffff,-0x824(%rbp)
ff 7f 7f
movsd  -0x828(%rbp),%xmm0
ff
movl   $0x40600000,-0x830(%rbp)
movl   $0x0,-0x82c(%rbp)
movsd  -0x830(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xf91(%rbp),%al
movlpd %xmm0,-0x838(%rbp)
ff
movss  -0x838(%rbp),%xmm1
ff
movss  -0x834(%rbp),%xmm0
ff
movss  %xmm1,-0x840(%rbp)
ff
movss  %xmm0,-0x83c(%rbp)
ff
movsd  -0x840(%rbp),%xmm0
ff
call   1040 <foof@plt>
movabs $0x7fefffffffffffff,%rax
ff ef 7f
mov    %rax,-0xf90(%rbp)
mov    %rax,-0x850(%rbp)
movq   $0x0,-0x848(%rbp)
movsd  -0x850(%rbp),%xmm0
ff
movsd  -0x848(%rbp),%xmm1
ff
movabs $0x400c000000000000,%rax
mov    %rax,-0xf88(%rbp)
mov    %rax,-0x860(%rbp)
movq   $0x0,-0x858(%rbp)
movsd  -0x860(%rbp),%xmm2
ff
movsd  -0x858(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0x870(%rbp)
ff
movsd  %xmm1,-0x868(%rbp)
ff
movsd  -0x870(%rbp),%xmm0
ff
movsd  -0x868(%rbp),%xmm1
ff
mov    $0x2,%al
mov    %al,-0xf7d(%rbp)
call   1090 <foo@plt>
mov    -0xf90(%rbp),%rcx
mov    -0xf88(%rbp),%rax
movq   $0x0,-0x880(%rbp)
mov    %rcx,-0x878(%rbp)
movsd  -0x880(%rbp),%xmm0
ff
movsd  -0x878(%rbp),%xmm1
ff
mov    %rax,-0x890(%rbp)
movq   $0x0,-0x888(%rbp)
movsd  -0x890(%rbp),%xmm2
ff
movsd  -0x888(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xf7d(%rbp),%al
movsd  %xmm0,-0x8a0(%rbp)
ff
movsd  %xmm1,-0x898(%rbp)
ff
movsd  -0x8a0(%rbp),%xmm0
ff
movsd  -0x898(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   0x1a60(%rip)
fld    %st(0)
fstpt  -0xf7c(%rbp)
fstpt  -0x8c0(%rbp)
fldz
fld    %st(0)
fstpt  -0xf64(%rbp)
fld    %st(0)
fstpt  -0x8b0(%rbp)
flds   0x19fe(%rip)
fld    %st(0)
fstpt  -0xf70(%rbp)
fstpt  -0x8e0(%rbp)
fstpt  -0x8d0(%rbp)
movaps -0x8e0(%rbp),%xmm0
movaps -0x8d0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x8c0(%rbp),%xmm0
movaps -0x8b0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0x900(%rbp)
fstpt  -0x8f0(%rbp)
movaps -0x900(%rbp),%xmm0
movaps -0x8f0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
xor    %eax,%eax
call   1050 <fool@plt>
fldt   -0xf7c(%rbp)
fldt   -0xf70(%rbp)
fldt   -0xf64(%rbp)
fld    %st(0)
fstpt  -0x920(%rbp)
fxch   %st(2)
fstpt  -0x910(%rbp)
fstpt  -0x940(%rbp)
fstpt  -0x930(%rbp)
movaps -0x940(%rbp),%xmm0
movaps -0x930(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x920(%rbp),%xmm0
movaps -0x910(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0x960(%rbp)
fstpt  -0x950(%rbp)
lea    -0x960(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x40000000,-0x968(%rbp)
movl   $0x0,-0x964(%rbp)
movsd  -0x968(%rbp),%xmm0
ff
movl   $0x58800000,-0x970(%rbp)
movl   $0x0,-0x96c(%rbp)
movsd  -0x970(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0x978(%rbp)
ff
movss  -0x978(%rbp),%xmm1
ff
movss  -0x974(%rbp),%xmm0
ff
movss  %xmm1,-0x980(%rbp)
ff
movss  %xmm0,-0x97c(%rbp)
ff
movsd  -0x980(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4000000000000000,%rax
mov    %rax,-0x990(%rbp)
movq   $0x0,-0x988(%rbp)
movsd  -0x990(%rbp),%xmm0
ff
movsd  -0x988(%rbp),%xmm1
ff
movabs $0x4310000000000000,%rax
mov    %rax,-0x9a0(%rbp)
movq   $0x0,-0x998(%rbp)
movsd  -0x9a0(%rbp),%xmm2
ff
movsd  -0x998(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0x9b0(%rbp)
ff
movsd  %xmm1,-0x9a8(%rbp)
ff
movsd  -0x9b0(%rbp),%xmm0
ff
movsd  -0x9a8(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x17f5(%rip)
fstpt  -0x9d0(%rbp)
fldz
fld    %st(0)
fstpt  -0x9c0(%rbp)
flds   0x17e3(%rip)
fstpt  -0x9f0(%rbp)
fstpt  -0x9e0(%rbp)
movaps -0x9f0(%rbp),%xmm0
movaps -0x9e0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0x9d0(%rbp),%xmm0
movaps -0x9c0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xa10(%rbp)
fstpt  -0xa00(%rbp)
lea    -0xa10(%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)
mov    $0x0,%al
call   1050 <fool@plt>
jmp    28b9 <bar+0x16f9>
movl   $0x40000000,-0xa18(%rbp)
movl   $0x0,-0xa14(%rbp)
movsd  -0xa18(%rbp),%xmm0
ff
movl   $0x4d800000,-0xa20(%rbp)
movl   $0x0,-0xa1c(%rbp)
movsd  -0xa20(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0xa28(%rbp)
ff
movss  -0xa28(%rbp),%xmm1
ff
movss  -0xa24(%rbp),%xmm0
ff
movss  %xmm1,-0xa30(%rbp)
ff
movss  %xmm0,-0xa2c(%rbp)
ff
movsd  -0xa30(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4000000000000000,%rax
mov    %rax,-0xa40(%rbp)
movq   $0x0,-0xa38(%rbp)
movsd  -0xa40(%rbp),%xmm0
ff
movsd  -0xa38(%rbp),%xmm1
ff
movabs $0x41b0000000000000,%rax
mov    %rax,-0xa50(%rbp)
movq   $0x0,-0xa48(%rbp)
movsd  -0xa50(%rbp),%xmm2
ff
movsd  -0xa48(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0xa60(%rbp)
ff
movsd  %xmm1,-0xa58(%rbp)
ff
movsd  -0xa60(%rbp),%xmm0
ff
movsd  -0xa58(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x1661(%rip)
fstpt  -0xa80(%rbp)
fldz
fld    %st(0)
fstpt  -0xa70(%rbp)
flds   0x1653(%rip)
fstpt  -0xaa0(%rbp)
fstpt  -0xa90(%rbp)
movaps -0xaa0(%rbp),%xmm0
movaps -0xa90(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xa80(%rbp),%xmm0
movaps -0xa70(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xac0(%rbp)
fstpt  -0xab0(%rbp)
lea    -0xac0(%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)
mov    $0x0,%al
call   1050 <fool@plt>
jmp    2a4d <bar+0x188d>
movl   $0x40000000,-0xac8(%rbp)
movl   $0x0,-0xac4(%rbp)
movsd  -0xac8(%rbp),%xmm0
ff
movl   $0x4b800000,-0xad0(%rbp)
movl   $0x0,-0xacc(%rbp)
movsd  -0xad0(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0xad8(%rbp)
ff
movss  -0xad8(%rbp),%xmm1
ff
movss  -0xad4(%rbp),%xmm0
ff
movss  %xmm1,-0xae0(%rbp)
ff
movss  %xmm0,-0xadc(%rbp)
ff
movsd  -0xae0(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4000000000000000,%rax
mov    %rax,-0xaf0(%rbp)
movq   $0x0,-0xae8(%rbp)
movsd  -0xaf0(%rbp),%xmm0
ff
movsd  -0xae8(%rbp),%xmm1
ff
movabs $0x4170000000000000,%rax
mov    %rax,-0xb00(%rbp)
movq   $0x0,-0xaf8(%rbp)
movsd  -0xb00(%rbp),%xmm2
ff
movsd  -0xaf8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0xb10(%rbp)
ff
movsd  %xmm1,-0xb08(%rbp)
ff
movsd  -0xb10(%rbp),%xmm0
ff
movsd  -0xb08(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x14cd(%rip)
fstpt  -0xb30(%rbp)
fldz
fld    %st(0)
fstpt  -0xb20(%rbp)
flds   0x14c3(%rip)
fstpt  -0xb50(%rbp)
fstpt  -0xb40(%rbp)
movaps -0xb50(%rbp),%xmm0
movaps -0xb40(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xb30(%rbp),%xmm0
movaps -0xb20(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xb70(%rbp)
fstpt  -0xb60(%rbp)
lea    -0xb70(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x7f7fffff,-0xb78(%rbp)
ff 7f 7f
movl   $0x0,-0xb74(%rbp)
movsd  -0xb78(%rbp),%xmm0
ff
movl   $0xc0600000,-0xb80(%rbp)
movl   $0x0,-0xb7c(%rbp)
movsd  -0xb80(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0xb88(%rbp)
ff
movss  -0xb88(%rbp),%xmm1
ff
movss  -0xb84(%rbp),%xmm0
ff
movss  %xmm1,-0xb90(%rbp)
ff
movss  %xmm0,-0xb8c(%rbp)
ff
movsd  -0xb90(%rbp),%xmm0
ff
mov    $0x1,%al
mov    %al,-0xfc9(%rbp)
call   1040 <foof@plt>
movl   $0x0,-0xb98(%rbp)
movl   $0x7f7fffff,-0xb94(%rbp)
ff 7f 7f
movsd  -0xb98(%rbp),%xmm0
ff
movl   $0xc0600000,-0xba0(%rbp)
movl   $0x0,-0xb9c(%rbp)
movsd  -0xba0(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
mov    -0xfc9(%rbp),%al
movlpd %xmm0,-0xba8(%rbp)
ff
movss  -0xba8(%rbp),%xmm1
ff
movss  -0xba4(%rbp),%xmm0
ff
movss  %xmm1,-0xbb0(%rbp)
ff
movss  %xmm0,-0xbac(%rbp)
ff
movsd  -0xbb0(%rbp),%xmm0
ff
call   1040 <foof@plt>
movabs $0x7fefffffffffffff,%rax
ff ef 7f
mov    %rax,-0xfc8(%rbp)
mov    %rax,-0xbc0(%rbp)
movq   $0x0,-0xbb8(%rbp)
movsd  -0xbc0(%rbp),%xmm0
ff
movsd  -0xbb8(%rbp),%xmm1
movabs $0xc00c000000000000,%rax
mov    %rax,-0xfc0(%rbp)
mov    %rax,-0xbd0(%rbp)
movq   $0x0,-0xbc8(%rbp)
movsd  -0xbd0(%rbp),%xmm2
ff
movsd  -0xbc8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0xbe0(%rbp)
ff
movsd  %xmm1,-0xbd8(%rbp)
ff
movsd  -0xbe0(%rbp),%xmm0
ff
movsd  -0xbd8(%rbp),%xmm1
ff
mov    $0x2,%al
mov    %al,-0xfb5(%rbp)
call   1090 <foo@plt>
mov    -0xfc8(%rbp),%rcx
mov    -0xfc0(%rbp),%rax
movq   $0x0,-0xbf0(%rbp)
mov    %rcx,-0xbe8(%rbp)
movsd  -0xbf0(%rbp),%xmm0
ff
movsd  -0xbe8(%rbp),%xmm1
ff
mov    %rax,-0xc00(%rbp)
movq   $0x0,-0xbf8(%rbp)
movsd  -0xc00(%rbp),%xmm2
ff
movsd  -0xbf8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
mov    -0xfb5(%rbp),%al
movsd  %xmm0,-0xc10(%rbp)
ff
movsd  %xmm1,-0xc08(%rbp)
ff
movsd  -0xc10(%rbp),%xmm0
ff
movsd  -0xc08(%rbp),%xmm1
ff
call   1090 <foo@plt>
fldt   0x1262(%rip)
fld    %st(0)
fstpt  -0xfb4(%rbp)
fstpt  -0xc30(%rbp)
fldz
fld    %st(0)
fstpt  -0xf9c(%rbp)
fld    %st(0)
fstpt  -0xc20(%rbp)
flds   0x1214(%rip)
fld    %st(0)
fstpt  -0xfa8(%rbp)
fstpt  -0xc50(%rbp)
fstpt  -0xc40(%rbp)
movaps -0xc50(%rbp),%xmm0
movaps -0xc40(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xc30(%rbp),%xmm0
movaps -0xc20(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xc70(%rbp)
fstpt  -0xc60(%rbp)
movaps -0xc70(%rbp),%xmm0
movaps -0xc60(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
xor    %eax,%eax
call   1050 <fool@plt>
fldt   -0xfb4(%rbp)
fldt   -0xfa8(%rbp)
fldt   -0xf9c(%rbp)
fld    %st(0)
fstpt  -0xc90(%rbp)
fxch   %st(2)
fstpt  -0xc80(%rbp)
fstpt  -0xcb0(%rbp)
fstpt  -0xca0(%rbp)
movaps -0xcb0(%rbp),%xmm0
movaps -0xca0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xc90(%rbp),%xmm0
movaps -0xc80(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xcd0(%rbp)
fstpt  -0xcc0(%rbp)
lea    -0xcd0(%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)
mov    $0x0,%al
call   1050 <fool@plt>
movl   $0x40000000,-0xcd8(%rbp)
movl   $0x0,-0xcd4(%rbp)
movsd  -0xcd8(%rbp),%xmm0
ff
movl   $0xd8800000,-0xce0(%rbp)
movl   $0x0,-0xcdc(%rbp)
movsd  -0xce0(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0xce8(%rbp)
ff
movss  -0xce8(%rbp),%xmm1
ff
movss  -0xce4(%rbp),%xmm0
ff
movss  %xmm1,-0xcf0(%rbp)
ff
movss  %xmm0,-0xcec(%rbp)
ff
movsd  -0xcf0(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4000000000000000,%rax
mov    %rax,-0xd00(%rbp)
movq   $0x0,-0xcf8(%rbp)
movsd  -0xd00(%rbp),%xmm0
ff
movsd  -0xcf8(%rbp),%xmm1
ff
movabs $0xc310000000000000,%rax
mov    %rax,-0xd10(%rbp)
movq   $0x0,-0xd08(%rbp)
movsd  -0xd10(%rbp),%xmm2
ff
movsd  -0xd08(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0xd20(%rbp)
ff
movsd  %xmm1,-0xd18(%rbp)
movsd  -0xd20(%rbp),%xmm0
movsd  -0xd18(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
flds   0xff7(%rip)
fstpt  -0xd40(%rbp)
fldz
fld    %st(0)
fstpt  -0xd30(%rbp)
flds   0xff5(%rip)
fstpt  -0xd60(%rbp)
fstpt  -0xd50(%rbp)
movaps -0xd60(%rbp),%xmm0
movaps -0xd50(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xd40(%rbp),%xmm0
movaps -0xd30(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xd80(%rbp)
fstpt  -0xd70(%rbp)
lea    -0xd80(%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)
mov    $0x0,%al
call   1050 <fool@plt>
jmp    30b7 <bar+0x1ef7>
movl   $0x40000000,-0xd88(%rbp)
movl   $0x0,-0xd84(%rbp)
movsd  -0xd88(%rbp),%xmm0
ff
movl   $0xcd800000,-0xd90(%rbp)
movl   $0x0,-0xd8c(%rbp)
movsd  -0xd90(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0xd98(%rbp)
ff
movss  -0xd98(%rbp),%xmm1
ff
movss  -0xd94(%rbp),%xmm0
ff
movss  %xmm1,-0xda0(%rbp)
ff
movss  %xmm0,-0xd9c(%rbp)
ff
movsd  -0xda0(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4000000000000000,%rax
mov    %rax,-0xdb0(%rbp)
movq   $0x0,-0xda8(%rbp)
movsd  -0xdb0(%rbp),%xmm0
ff
movsd  -0xda8(%rbp),%xmm1
ff
movabs $0xc1b0000000000000,%rax
mov    %rax,-0xdc0(%rbp)
movq   $0x0,-0xdb8(%rbp)
movsd  -0xdc0(%rbp),%xmm2
ff
movsd  -0xdb8(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0xdd0(%rbp)
ff
movsd  %xmm1,-0xdc8(%rbp)
ff
movsd  -0xdd0(%rbp),%xmm0
ff
movsd  -0xdc8(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
flds   0xe63(%rip)
fstpt  -0xdf0(%rbp)
fldz
fld    %st(0)
fstpt  -0xde0(%rbp)
flds   0xe65(%rip)
fstpt  -0xe10(%rbp)
fstpt  -0xe00(%rbp)
movaps -0xe10(%rbp),%xmm0
movaps -0xe00(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xdf0(%rbp),%xmm0
movaps -0xde0(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xe30(%rbp)
fstpt  -0xe20(%rbp)
lea    -0xe30(%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)
mov    $0x0,%al
call   1050 <fool@plt>
jmp    324b <bar+0x208b>
movl   $0x40000000,-0xe38(%rbp)
movl   $0x0,-0xe34(%rbp)
movsd  -0xe38(%rbp),%xmm0
ff
movl   $0xcb800000,-0xe40(%rbp)
movl   $0x0,-0xe3c(%rbp)
movsd  -0xe40(%rbp),%xmm1
ff
call   10a0 <cpowf@plt>
movlpd %xmm0,-0xe48(%rbp)
ff
movss  -0xe48(%rbp),%xmm1
ff
movss  -0xe44(%rbp),%xmm0
ff
movss  %xmm1,-0xe50(%rbp)
ff
movss  %xmm0,-0xe4c(%rbp)
ff
movsd  -0xe50(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <foof@plt>
movabs $0x4000000000000000,%rax
mov    %rax,-0xe60(%rbp)
movq   $0x0,-0xe58(%rbp)
movsd  -0xe60(%rbp),%xmm0
ff
movsd  -0xe58(%rbp),%xmm1
ff
movabs $0xc170000000000000,%rax
mov    %rax,-0xe70(%rbp)
movq   $0x0,-0xe68(%rbp)
movsd  -0xe70(%rbp),%xmm2
ff
movsd  -0xe68(%rbp),%xmm3
ff
call   1030 <cpow@plt>
movsd  %xmm0,-0xe80(%rbp)
ff
movsd  %xmm1,-0xe78(%rbp)
ff
movsd  -0xe80(%rbp),%xmm0
ff
movsd  -0xe78(%rbp),%xmm1
ff
mov    $0x2,%al
call   1090 <foo@plt>
flds   0xccf(%rip)
fstpt  -0xea0(%rbp)
fldz
fld    %st(0)
fstpt  -0xe90(%rbp)
flds   0xcd5(%rip)
fstpt  -0xec0(%rbp)
fstpt  -0xeb0(%rbp)
movaps -0xec0(%rbp),%xmm0
movaps -0xeb0(%rbp),%xmm1
mov    %rsp,%rax
movaps %xmm1,0x30(%rax)
movaps %xmm0,0x20(%rax)
movaps -0xea0(%rbp),%xmm0
movaps -0xe90(%rbp),%xmm1
movaps %xmm1,0x10(%rax)
movaps %xmm0,(%rax)
call   10b0 <cpowl@plt>
fstpt  -0xee0(%rbp)
fstpt  -0xed0(%rbp)
lea    -0xee0(%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)
mov    $0x0,%al
call   1050 <fool@plt>
add    $0x1010,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bar>:
sub    $0x888,%rsp
movss  0x1e31(%rip),%xmm0
call   10d0 <csqrtf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x1e65(%rip),%xmm0
xorps  %xmm1,%xmm1
call   10e0 <csqrt@plt>
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x1e08(%rip)
fld    %st(0)
fstpt  0x74(%rsp)
fstpt  0x860(%rsp)
fldz
fld    %st(0)
fstpt  0x44(%rsp)
fstpt  0x870(%rsp)
movaps 0x860(%rsp),%xmm0
movaps 0x870(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10c0 <csqrtl@plt>
fstpt  0x840(%rsp)
fstpt  0x850(%rsp)
movaps 0x840(%rsp),%xmm0
movaps 0x850(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1d9c(%rip),%xmm0
call   10d0 <csqrtf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x1dd4(%rip),%xmm0
xorps  %xmm1,%xmm1
call   10e0 <csqrt@plt>
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x1d73(%rip)
fld    %st(0)
fstpt  0x68(%rsp)
fstpt  0x820(%rsp)
fldt   0x44(%rsp)
fstpt  0x830(%rsp)
movaps 0x820(%rsp),%xmm0
movaps 0x830(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10c0 <csqrtl@plt>
fstpt  0x800(%rsp)
fstpt  0x810(%rsp)
movaps 0x800(%rsp),%xmm0
movaps 0x810(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1d0b(%rip),%xmm0
call   10d0 <csqrtf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x1d47(%rip),%xmm0
xorps  %xmm1,%xmm1
call   10e0 <csqrt@plt>
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x1ce2(%rip)
fld    %st(0)
fstpt  0x5c(%rsp)
fstpt  0x7e0(%rsp)
fldt   0x44(%rsp)
fstpt  0x7f0(%rsp)
movaps 0x7e0(%rsp),%xmm0
movaps 0x7f0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10c0 <csqrtl@plt>
fstpt  0x7c0(%rsp)
fstpt  0x7d0(%rsp)
movaps 0x7c0(%rsp),%xmm0
movaps 0x7d0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1c7a(%rip),%xmm0
call   1080 <cexpf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x1cba(%rip),%xmm0
xorps  %xmm1,%xmm1
call   1060 <cexp@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldl   0x1ca5(%rip)
fstpt  0x7a0(%rsp)
fldt   0x44(%rsp)
fstpt  0x7b0(%rsp)
movaps 0x7a0(%rsp),%xmm0
movaps 0x7b0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   1070 <cexpl@plt>
fstpt  0x780(%rsp)
fstpt  0x790(%rsp)
movaps 0x780(%rsp),%xmm0
movaps 0x790(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1bef(%rip),%xmm0
call   1080 <cexpf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x1c33(%rip),%xmm0
xorps  %xmm1,%xmm1
call   1060 <cexp@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldl   0x1c1e(%rip)
fstpt  0x760(%rsp)
fldt   0x44(%rsp)
fstpt  0x770(%rsp)
movaps 0x760(%rsp),%xmm0
movaps 0x770(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   1070 <cexpl@plt>
fstpt  0x740(%rsp)
fstpt  0x750(%rsp)
movaps 0x740(%rsp),%xmm0
movaps 0x750(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1b64(%rip),%xmm1
movss  0x1b48(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x1ba4(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x1b6e(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x74(%rsp)
fstpt  0x720(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x730(%rsp)
flds   0x1b10(%rip)
fld    %st(0)
fstpt  0x50(%rsp)
fstpt  0x700(%rsp)
fstpt  0x710(%rsp)
movaps 0x700(%rsp),%xmm0
movaps 0x710(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x720(%rsp),%xmm0
movaps 0x730(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x6e0(%rsp)
fstpt  0x6f0(%rsp)
movaps 0x6e0(%rsp),%xmm0
movaps 0x6f0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1a8e(%rip),%xmm0
movss  0x1a72(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x1ac8(%rip),%xmm0
movsd  0x1a98(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x6c0(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x6d0(%rsp)
fldt   0x74(%rsp)
fstpt  0x6a0(%rsp)
fstpt  0x6b0(%rsp)
movaps 0x6a0(%rsp),%xmm0
movaps 0x6b0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x6c0(%rsp),%xmm0
movaps 0x6d0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x680(%rsp)
fstpt  0x690(%rsp)
movaps 0x680(%rsp),%xmm0
movaps 0x690(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x19b0(%rip),%xmm0
movss  0x19b8(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x19da(%rip),%xmm0
movsd  0x19f2(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x68(%rsp)
fstpt  0x660(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x670(%rsp)
fldt   0x50(%rsp)
fstpt  0x640(%rsp)
fstpt  0x650(%rsp)
movaps 0x640(%rsp),%xmm0
movaps 0x650(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x660(%rsp),%xmm0
movaps 0x670(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x620(%rsp)
fstpt  0x630(%rsp)
movaps 0x620(%rsp),%xmm0
movaps 0x630(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x18e6(%rip),%xmm0
movss  0x18ea(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x1914(%rip),%xmm0
movsd  0x1924(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x5c(%rsp)
fstpt  0x600(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x610(%rsp)
fldt   0x50(%rsp)
fstpt  0x5e0(%rsp)
fstpt  0x5f0(%rsp)
movaps 0x5e0(%rsp),%xmm0
movaps 0x5f0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x600(%rsp),%xmm0
movaps 0x610(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x5c0(%rsp)
fstpt  0x5d0(%rsp)
movaps 0x5c0(%rsp),%xmm0
movaps 0x5d0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1824(%rip),%xmm0
movss  0x180c(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x185e(%rip),%xmm0
movsd  0x1836(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x5a0(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x5b0(%rsp)
fldt   0x68(%rsp)
fstpt  0x580(%rsp)
fstpt  0x590(%rsp)
movaps 0x580(%rsp),%xmm0
movaps 0x590(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x5a0(%rsp),%xmm0
movaps 0x5b0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x560(%rsp)
fstpt  0x570(%rsp)
movaps 0x560(%rsp),%xmm0
movaps 0x570(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1756(%rip),%xmm0
movss  0x1742(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x1790(%rip),%xmm0
movsd  0x1770(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x540(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x550(%rsp)
fldt   0x5c(%rsp)
fstpt  0x520(%rsp)
fstpt  0x530(%rsp)
movaps 0x520(%rsp),%xmm0
movaps 0x530(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x540(%rsp),%xmm0
movaps 0x550(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x500(%rsp)
fstpt  0x510(%rsp)
movaps 0x500(%rsp),%xmm0
movaps 0x510(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x168c(%rip),%xmm0
movss  0x1688(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x16d0(%rip),%xmm0
movsd  0x16d0(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x44(%rsp)
fld    %st(0)
fchs
fstpt  0x4e0(%rsp)
fld    %st(0)
fstpt  0x4f0(%rsp)
flds   0x163c(%rip)
fld    %st(0)
fstpt  0x50(%rsp)
fstpt  0x4c0(%rsp)
fstpt  0x4d0(%rsp)
movaps 0x4c0(%rsp),%xmm0
movaps 0x4d0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x4e0(%rsp),%xmm0
movaps 0x4f0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x4a0(%rsp)
fstpt  0x4b0(%rsp)
movaps 0x4a0(%rsp),%xmm0
movaps 0x4b0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
xorps  %xmm0,%xmm0
movss  0x15b7(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x15fe(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x480(%rsp)
fld    %st(0)
fstpt  0x490(%rsp)
fldt   0x50(%rsp)
fstpt  0x460(%rsp)
fstpt  0x470(%rsp)
movaps 0x460(%rsp),%xmm0
movaps 0x470(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x480(%rsp),%xmm0
movaps 0x490(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x440(%rsp)
fstpt  0x450(%rsp)
movaps 0x440(%rsp),%xmm0
movaps 0x450(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x14fc(%rip),%xmm0
movss  0x14f8(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movaps 0x15a1(%rip),%xmm0
movss  0x14dd(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x152d(%rip),%xmm0
movsd  0x152d(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
xorps  %xmm0,%xmm0
xorps  %xmm3,%xmm3
movsd  0x1505(%rip),%xmm1
movsd  0x1505(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x1553(%rip)
fld    %st(0)
fstpt  0x5c(%rsp)
fstpt  0x420(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x430(%rsp)
flds   0x1467(%rip)
fld    %st(0)
fstpt  0x50(%rsp)
fstpt  0x400(%rsp)
fstpt  0x410(%rsp)
movaps 0x400(%rsp),%xmm0
movaps 0x410(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x420(%rsp),%xmm0
movaps 0x430(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x3e0(%rsp)
fstpt  0x3f0(%rsp)
movaps 0x3e0(%rsp),%xmm0
movaps 0x3f0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x3c0(%rsp)
fldt   0x5c(%rsp)
fstpt  0x3d0(%rsp)
fldt   0x50(%rsp)
fstpt  0x3a0(%rsp)
fstpt  0x3b0(%rsp)
movaps 0x3a0(%rsp),%xmm0
movaps 0x3b0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x3c0(%rsp),%xmm0
movaps 0x3d0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x380(%rsp)
fstpt  0x390(%rsp)
movaps 0x380(%rsp),%xmm0
movaps 0x390(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1359(%rip),%xmm0
movss  0x1355(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x13ad(%rip),%xmm0
movsd  0x13ad(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
flds   0x131d(%rip)
fld    %st(0)
fstpt  0x50(%rsp)
fstpt  0x360(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x370(%rsp)
flds   0x1301(%rip)
fstpt  0x340(%rsp)
fstpt  0x350(%rsp)
movaps 0x340(%rsp),%xmm0
movaps 0x350(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x360(%rsp),%xmm0
movaps 0x370(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x320(%rsp)
fstpt  0x330(%rsp)
movaps 0x320(%rsp),%xmm0
movaps 0x330(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x1289(%rip),%xmm1
movss  0x1279(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x12e5(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x12c7(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x300(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x310(%rsp)
flds   0x1235(%rip)
fstpt  0x2e0(%rsp)
fstpt  0x2f0(%rsp)
movaps 0x2e0(%rsp),%xmm0
movaps 0x2f0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x300(%rsp),%xmm0
movaps 0x310(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x2c0(%rsp)
fstpt  0x2d0(%rsp)
movaps 0x2c0(%rsp),%xmm0
movaps 0x2d0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x11bd(%rip),%xmm1
movss  0x11a9(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x121d(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x11f7(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x2a0(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x2b0(%rsp)
flds   0x1169(%rip)
fstpt  0x280(%rsp)
fstpt  0x290(%rsp)
movaps 0x280(%rsp),%xmm0
movaps 0x290(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x2a0(%rsp),%xmm0
movaps 0x2b0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x260(%rsp)
fstpt  0x270(%rsp)
movaps 0x260(%rsp),%xmm0
movaps 0x270(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0x10f1(%rip),%xmm1
movss  0x10d1(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movaps 0x117e(%rip),%xmm0
movss  0x10ce(%rip),%xmm1
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0x113a(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0x10fc(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
xorps  %xmm0,%xmm0
xorps  %xmm3,%xmm3
movsd  0x10e2(%rip),%xmm1
movsd  0x110a(%rip),%xmm2
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x5c(%rsp)
fstpt  0x240(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x250(%rsp)
flds   0x1060(%rip)
fld    %st(0)
fstpt  0x68(%rsp)
fstpt  0x220(%rsp)
fstpt  0x230(%rsp)
movaps 0x220(%rsp),%xmm0
movaps 0x230(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x240(%rsp),%xmm0
movaps 0x250(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x200(%rsp)
fstpt  0x210(%rsp)
movaps 0x200(%rsp),%xmm0
movaps 0x210(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x1e0(%rsp)
fldt   0x5c(%rsp)
fstpt  0x1f0(%rsp)
fldt   0x68(%rsp)
fstpt  0x1c0(%rsp)
fstpt  0x1d0(%rsp)
movaps 0x1c0(%rsp),%xmm0
movaps 0x1d0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x1e0(%rsp),%xmm0
movaps 0x1f0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x1a0(%rsp)
fstpt  0x1b0(%rsp)
movaps 0x1a0(%rsp),%xmm0
movaps 0x1b0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0xf52(%rip),%xmm1
movss  0xf36(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0xfba(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0xf84(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x180(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x190(%rsp)
flds   0xefe(%rip)
fstpt  0x160(%rsp)
fstpt  0x170(%rsp)
movaps 0x160(%rsp),%xmm0
movaps 0x170(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x180(%rsp),%xmm0
movaps 0x190(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x140(%rsp)
fstpt  0x150(%rsp)
movaps 0x140(%rsp),%xmm0
movaps 0x150(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0xe86(%rip),%xmm1
movss  0xe66(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0xef2(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0xeb4(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0x120(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0x130(%rsp)
flds   0xe32(%rip)
fstpt  0x100(%rsp)
fstpt  0x110(%rsp)
movaps 0x100(%rsp),%xmm0
movaps 0x110(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0x120(%rsp),%xmm0
movaps 0x130(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0xe0(%rsp)
fstpt  0xf0(%rsp)
movaps 0xe0(%rsp),%xmm0
movaps 0xf0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
movss  0xdba(%rip),%xmm1
movss  0xd96(%rip),%xmm0
call   10a0 <cpowf@plt>
mov    $0x1,%al
call   1040 <foof@plt>
movsd  0xe2a(%rip),%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm3,%xmm3
movsd  0xde4(%rip),%xmm0
call   1030 <cpow@plt>
mov    $0x2,%al
call   1090 <foo@plt>
fldt   0x50(%rsp)
fstpt  0xc0(%rsp)
fldt   0x44(%rsp)
fld    %st(0)
fstpt  0xd0(%rsp)
flds   0xd66(%rip)
fstpt  0xa0(%rsp)
fstpt  0xb0(%rsp)
movaps 0xa0(%rsp),%xmm0
movaps 0xb0(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps 0xc0(%rsp),%xmm0
movaps 0xd0(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
call   10b0 <cpowl@plt>
fstpt  0x80(%rsp)
fstpt  0x90(%rsp)
movaps 0x80(%rsp),%xmm0
movaps 0x90(%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1050 <fool@plt>
add    $0x888,%rsp
ret

LLVM IR (-O0):
define void @bar() {
%1 = alloca { float, float }
%2 = alloca { float, float }
%3 = alloca { float, float }
%4 = alloca { double, double }
%5 = alloca { double, double }
%6 = alloca { x86_fp80, x86_fp80 }
%7 = alloca { x86_fp80, x86_fp80 }
%8 = alloca { float, float }
%9 = alloca { float, float }
%10 = alloca { float, float }
%11 = alloca { double, double }
%12 = alloca { double, double }
%13 = alloca { x86_fp80, x86_fp80 }
%14 = alloca { x86_fp80, x86_fp80 }
%15 = alloca { float, float }
%16 = alloca { float, float }
%17 = alloca { float, float }
%18 = alloca { double, double }
%19 = alloca { double, double }
%20 = alloca { x86_fp80, x86_fp80 }
%21 = alloca { x86_fp80, x86_fp80 }
%22 = alloca { float, float }
%23 = alloca { float, float }
%24 = alloca { float, float }
%25 = alloca { double, double }
%26 = alloca { double, double }
%27 = alloca { x86_fp80, x86_fp80 }
%28 = alloca { x86_fp80, x86_fp80 }
%29 = alloca { float, float }
%30 = alloca { float, float }
%31 = alloca { float, float }
%32 = alloca { double, double }
%33 = alloca { double, double }
%34 = alloca { x86_fp80, x86_fp80 }
%35 = alloca { x86_fp80, x86_fp80 }
%36 = alloca { float, float }
%37 = alloca { float, float }
%38 = alloca { float, float }
%39 = alloca { float, float }
%40 = alloca { double, double }
%41 = alloca { double, double }
%42 = alloca { double, double }
%43 = alloca { x86_fp80, x86_fp80 }
%44 = alloca { x86_fp80, x86_fp80 }
%45 = alloca { x86_fp80, x86_fp80 }
%46 = alloca { float, float }
%47 = alloca { float, float }
%48 = alloca { float, float }
%49 = alloca { float, float }
%50 = alloca { double, double }
%51 = alloca { double, double }
%52 = alloca { double, double }
%53 = alloca { x86_fp80, x86_fp80 }
%54 = alloca { x86_fp80, x86_fp80 }
%55 = alloca { x86_fp80, x86_fp80 }
%56 = alloca { float, float }
%57 = alloca { float, float }
%58 = alloca { float, float }
%59 = alloca { float, float }
%60 = alloca { double, double }
%61 = alloca { double, double }
%62 = alloca { double, double }
%63 = alloca { x86_fp80, x86_fp80 }
%64 = alloca { x86_fp80, x86_fp80 }
%65 = alloca { x86_fp80, x86_fp80 }
%66 = alloca { float, float }
%67 = alloca { float, float }
%68 = alloca { float, float }
%69 = alloca { float, float }
%70 = alloca { double, double }
%71 = alloca { double, double }
%72 = alloca { double, double }
%73 = alloca { x86_fp80, x86_fp80 }
%74 = alloca { x86_fp80, x86_fp80 }
%75 = alloca { x86_fp80, x86_fp80 }
%76 = alloca { float, float }
%77 = alloca { float, float }
%78 = alloca { float, float }
%79 = alloca { float, float }
%80 = alloca { double, double }
%81 = alloca { double, double }
%82 = alloca { double, double }
%83 = alloca { x86_fp80, x86_fp80 }
%84 = alloca { x86_fp80, x86_fp80 }
%85 = alloca { x86_fp80, x86_fp80 }
%86 = alloca { float, float }
%87 = alloca { float, float }
%88 = alloca { float, float }
%89 = alloca { float, float }
%90 = alloca { double, double }
%91 = alloca { double, double }
%92 = alloca { double, double }
%93 = alloca { x86_fp80, x86_fp80 }
%94 = alloca { x86_fp80, x86_fp80 }
%95 = alloca { x86_fp80, x86_fp80 }
%96 = alloca { float, float }
%97 = alloca { float, float }
%98 = alloca { float, float }
%99 = alloca { float, float }
%100 = alloca { double, double }
%101 = alloca { double, double }
%102 = alloca { double, double }
%103 = alloca { x86_fp80, x86_fp80 }
%104 = alloca { x86_fp80, x86_fp80 }
%105 = alloca { x86_fp80, x86_fp80 }
%106 = alloca { float, float }
%107 = alloca { float, float }
%108 = alloca { float, float }
%109 = alloca { float, float }
%110 = alloca { double, double }
%111 = alloca { double, double }
%112 = alloca { double, double }
%113 = alloca { x86_fp80, x86_fp80 }
%114 = alloca { x86_fp80, x86_fp80 }
%115 = alloca { x86_fp80, x86_fp80 }
%116 = alloca { float, float }
%117 = alloca { float, float }
%118 = alloca { float, float }
%119 = alloca { float, float }
%120 = alloca { float, float }
%121 = alloca { float, float }
%122 = alloca { float, float }
%123 = alloca { float, float }
%124 = alloca { double, double }
%125 = alloca { double, double }
%126 = alloca { double, double }
%127 = alloca { double, double }
%128 = alloca { double, double }
%129 = alloca { double, double }
%130 = alloca { x86_fp80, x86_fp80 }
%131 = alloca { x86_fp80, x86_fp80 }
%132 = alloca { x86_fp80, x86_fp80 }
%133 = alloca { x86_fp80, x86_fp80 }
%134 = alloca { x86_fp80, x86_fp80 }
%135 = alloca { x86_fp80, x86_fp80 }
%136 = alloca { float, float }
%137 = alloca { float, float }
%138 = alloca { float, float }
%139 = alloca { float, float }
%140 = alloca { double, double }
%141 = alloca { double, double }
%142 = alloca { double, double }
%143 = alloca { x86_fp80, x86_fp80 }
%144 = alloca { x86_fp80, x86_fp80 }
%145 = alloca { x86_fp80, x86_fp80 }
%146 = alloca { float, float }
%147 = alloca { float, float }
%148 = alloca { float, float }
%149 = alloca { float, float }
%150 = alloca { double, double }
%151 = alloca { double, double }
%152 = alloca { double, double }
%153 = alloca { x86_fp80, x86_fp80 }
%154 = alloca { x86_fp80, x86_fp80 }
%155 = alloca { x86_fp80, x86_fp80 }
%156 = alloca { float, float }
%157 = alloca { float, float }
%158 = alloca { float, float }
%159 = alloca { float, float }
%160 = alloca { double, double }
%161 = alloca { double, double }
%162 = alloca { double, double }
%163 = alloca { x86_fp80, x86_fp80 }
%164 = alloca { x86_fp80, x86_fp80 }
%165 = alloca { x86_fp80, x86_fp80 }
%166 = alloca { float, float }
%167 = alloca { float, float }
%168 = alloca { float, float }
%169 = alloca { float, float }
%170 = alloca { float, float }
%171 = alloca { float, float }
%172 = alloca { float, float }
%173 = alloca { float, float }
%174 = alloca { double, double }
%175 = alloca { double, double }
%176 = alloca { double, double }
%177 = alloca { double, double }
%178 = alloca { double, double }
%179 = alloca { double, double }
%180 = alloca { x86_fp80, x86_fp80 }
%181 = alloca { x86_fp80, x86_fp80 }
%182 = alloca { x86_fp80, x86_fp80 }
%183 = alloca { x86_fp80, x86_fp80 }
%184 = alloca { x86_fp80, x86_fp80 }
%185 = alloca { x86_fp80, x86_fp80 }
%186 = alloca { float, float }
%187 = alloca { float, float }
%188 = alloca { float, float }
%189 = alloca { float, float }
%190 = alloca { double, double }
%191 = alloca { double, double }
%192 = alloca { double, double }
%193 = alloca { x86_fp80, x86_fp80 }
%194 = alloca { x86_fp80, x86_fp80 }
%195 = alloca { x86_fp80, x86_fp80 }
%196 = alloca { float, float }
%197 = alloca { float, float }
%198 = alloca { float, float }
%199 = alloca { float, float }
%200 = alloca { double, double }
%201 = alloca { double, double }
%202 = alloca { double, double }
%203 = alloca { x86_fp80, x86_fp80 }
%204 = alloca { x86_fp80, x86_fp80 }
%205 = alloca { x86_fp80, x86_fp80 }
%206 = alloca { float, float }
%207 = alloca { float, float }
%208 = alloca { float, float }
%209 = alloca { float, float }
%210 = alloca { double, double }
%211 = alloca { double, double }
%212 = alloca { double, double }
%213 = alloca { x86_fp80, x86_fp80 }
%214 = alloca { x86_fp80, x86_fp80 }
%215 = alloca { x86_fp80, x86_fp80 }
%216 = getelementptr inbounds { float, float }, { float, float }* %1, i32 0, i32 0
%217 = getelementptr inbounds { float, float }, { float, float }* %1, i32 0, i32 1
store float 0x7FF8000000000000, float* %216
store float 0.000000e+00, float* %217
%218 = bitcast { float, float }* %1 to <2 x float>*
%219 = load <2 x float>, <2 x float>* %218
%220 = call <2 x float> @csqrtf(<2 x float> %219)
%221 = bitcast { float, float }* %2 to <2 x float>*
store <2 x float> %220, <2 x float>* %221
%222 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 0
%223 = load float, float* %222
%224 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 1
%225 = load float, float* %224
%226 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 0
%227 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 1
store float %223, float* %226
store float %225, float* %227
%228 = bitcast { float, float }* %3 to <2 x float>*
%229 = load <2 x float>, <2 x float>* %228
%230 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %229)
%231 = getelementptr inbounds { double, double }, { double, double }* %4, i32 0, i32 0
%232 = getelementptr inbounds { double, double }, { double, double }* %4, i32 0, i32 1
store double 0x7FF8000000000000, double* %231
store double 0.000000e+00, double* %232
%233 = getelementptr inbounds { double, double }, { double, double }* %4, i32 0, i32 0
%234 = load double, double* %233
%235 = getelementptr inbounds { double, double }, { double, double }* %4, i32 0, i32 1
%236 = load double, double* %235
%237 = call { double, double } @csqrt(double %234, double %236)
%238 = extractvalue { double, double } %237, 0
%239 = extractvalue { double, double } %237, 1
%240 = getelementptr inbounds { double, double }, { double, double }* %5, i32 0, i32 0
%241 = getelementptr inbounds { double, double }, { double, double }* %5, i32 0, i32 1
store double %238, double* %240
store double %239, double* %241
%242 = getelementptr inbounds { double, double }, { double, double }* %5, i32 0, i32 0
%243 = load double, double* %242
%244 = getelementptr inbounds { double, double }, { double, double }* %5, i32 0, i32 1
%245 = load double, double* %244
%246 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %243, double %245)
%247 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %6, i32 0, i32 0
%248 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %6, i32 0, i32 1
store x86_fp80 0xK7FFFC000000000000000, x86_fp80* %247
store x86_fp80 0xK00000000000000000000, x86_fp80* %248
%249 = call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %6)
%250 = extractvalue { x86_fp80, x86_fp80 } %249, 0
%251 = extractvalue { x86_fp80, x86_fp80 } %249, 1
%252 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %7, i32 0, i32 0
%253 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %7, i32 0, i32 1
store x86_fp80 %250, x86_fp80* %252
store x86_fp80 %251, x86_fp80* %253
%254 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %7)
%255 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%256 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
store float 0x7FF0000000000000, float* %255
store float 0.000000e+00, float* %256
%257 = bitcast { float, float }* %8 to <2 x float>*
%258 = load <2 x float>, <2 x float>* %257
%259 = call <2 x float> @csqrtf(<2 x float> %258)
%260 = bitcast { float, float }* %9 to <2 x float>*
store <2 x float> %259, <2 x float>* %260
%261 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 0
%262 = load float, float* %261
%263 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 1
%264 = load float, float* %263
%265 = getelementptr inbounds { float, float }, { float, float }* %10, i32 0, i32 0
%266 = getelementptr inbounds { float, float }, { float, float }* %10, i32 0, i32 1
store float %262, float* %265
store float %264, float* %266
%267 = bitcast { float, float }* %10 to <2 x float>*
%268 = load <2 x float>, <2 x float>* %267
%269 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %268)
%270 = getelementptr inbounds { double, double }, { double, double }* %11, i32 0, i32 0
%271 = getelementptr inbounds { double, double }, { double, double }* %11, i32 0, i32 1
store double 0x7FF0000000000000, double* %270
store double 0.000000e+00, double* %271
%272 = getelementptr inbounds { double, double }, { double, double }* %11, i32 0, i32 0
%273 = load double, double* %272
%274 = getelementptr inbounds { double, double }, { double, double }* %11, i32 0, i32 1
%275 = load double, double* %274
%276 = call { double, double } @csqrt(double %273, double %275)
%277 = extractvalue { double, double } %276, 0
%278 = extractvalue { double, double } %276, 1
%279 = getelementptr inbounds { double, double }, { double, double }* %12, i32 0, i32 0
%280 = getelementptr inbounds { double, double }, { double, double }* %12, i32 0, i32 1
store double %277, double* %279
store double %278, double* %280
%281 = getelementptr inbounds { double, double }, { double, double }* %12, i32 0, i32 0
%282 = load double, double* %281
%283 = getelementptr inbounds { double, double }, { double, double }* %12, i32 0, i32 1
%284 = load double, double* %283
%285 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %282, double %284)
%286 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i32 0, i32 0
%287 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i32 0, i32 1
store x86_fp80 0xK7FFF8000000000000000, x86_fp80* %286
store x86_fp80 0xK00000000000000000000, x86_fp80* %287
%288 = call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %13)
%289 = extractvalue { x86_fp80, x86_fp80 } %288, 0
%290 = extractvalue { x86_fp80, x86_fp80 } %288, 1
%291 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %14, i32 0, i32 0
%292 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %14, i32 0, i32 1
store x86_fp80 %289, x86_fp80* %291
store x86_fp80 %290, x86_fp80* %292
%293 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %14)
%294 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%295 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
store float 0xFFF0000000000000, float* %294
store float 0.000000e+00, float* %295
%296 = bitcast { float, float }* %15 to <2 x float>*
%297 = load <2 x float>, <2 x float>* %296
%298 = call <2 x float> @csqrtf(<2 x float> %297)
%299 = bitcast { float, float }* %16 to <2 x float>*
store <2 x float> %298, <2 x float>* %299
%300 = getelementptr inbounds { float, float }, { float, float }* %16, i32 0, i32 0
%301 = load float, float* %300
%302 = getelementptr inbounds { float, float }, { float, float }* %16, i32 0, i32 1
%303 = load float, float* %302
%304 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 0
%305 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 1
store float %301, float* %304
store float %303, float* %305
%306 = bitcast { float, float }* %17 to <2 x float>*
%307 = load <2 x float>, <2 x float>* %306
%308 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %307)
%309 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 0
%310 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 1
store double 0xFFF0000000000000, double* %309
store double 0.000000e+00, double* %310
%311 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 0
%312 = load double, double* %311
%313 = getelementptr inbounds { double, double }, { double, double }* %18, i32 0, i32 1
%314 = load double, double* %313
%315 = call { double, double } @csqrt(double %312, double %314)
%316 = extractvalue { double, double } %315, 0
%317 = extractvalue { double, double } %315, 1
%318 = getelementptr inbounds { double, double }, { double, double }* %19, i32 0, i32 0
%319 = getelementptr inbounds { double, double }, { double, double }* %19, i32 0, i32 1
store double %316, double* %318
store double %317, double* %319
%320 = getelementptr inbounds { double, double }, { double, double }* %19, i32 0, i32 0
%321 = load double, double* %320
%322 = getelementptr inbounds { double, double }, { double, double }* %19, i32 0, i32 1
%323 = load double, double* %322
%324 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %321, double %323)
%325 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i32 0, i32 0
%326 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i32 0, i32 1
store x86_fp80 0xKFFFF8000000000000000, x86_fp80* %325
store x86_fp80 0xK00000000000000000000, x86_fp80* %326
%327 = call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %20)
%328 = extractvalue { x86_fp80, x86_fp80 } %327, 0
%329 = extractvalue { x86_fp80, x86_fp80 } %327, 1
%330 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %21, i32 0, i32 0
%331 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %21, i32 0, i32 1
store x86_fp80 %328, x86_fp80* %330
store x86_fp80 %329, x86_fp80* %331
%332 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %21)
br label %333
333: ; preds = %0
%334 = getelementptr inbounds { float, float }, { float, float }* %22, i32 0, i32 0
%335 = getelementptr inbounds { float, float }, { float, float }* %22, i32 0, i32 1
store float 0x4415AF1D80000000, float* %334
store float 0.000000e+00, float* %335
%336 = bitcast { float, float }* %22 to <2 x float>*
%337 = load <2 x float>, <2 x float>* %336
%338 = call <2 x float> @cexpf(<2 x float> %337)
%339 = bitcast { float, float }* %23 to <2 x float>*
store <2 x float> %338, <2 x float>* %339
%340 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%341 = load float, float* %340
%342 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
%343 = load float, float* %342
%344 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 0
%345 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 1
store float %341, float* %344
store float %343, float* %345
%346 = bitcast { float, float }* %24 to <2 x float>*
%347 = load <2 x float>, <2 x float>* %346
%348 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %347)
%349 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 0
%350 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 1
store double 1.000000e+20, double* %349
store double 0.000000e+00, double* %350
%351 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 0
%352 = load double, double* %351
%353 = getelementptr inbounds { double, double }, { double, double }* %25, i32 0, i32 1
%354 = load double, double* %353
%355 = call { double, double } @cexp(double %352, double %354)
%356 = extractvalue { double, double } %355, 0
%357 = extractvalue { double, double } %355, 1
%358 = getelementptr inbounds { double, double }, { double, double }* %26, i32 0, i32 0
%359 = getelementptr inbounds { double, double }, { double, double }* %26, i32 0, i32 1
store double %356, double* %358
store double %357, double* %359
%360 = getelementptr inbounds { double, double }, { double, double }* %26, i32 0, i32 0
%361 = load double, double* %360
%362 = getelementptr inbounds { double, double }, { double, double }* %26, i32 0, i32 1
%363 = load double, double* %362
%364 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %361, double %363)
%365 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %27, i32 0, i32 0
%366 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %27, i32 0, i32 1
store x86_fp80 0xK4041AD78EBC5AC620000, x86_fp80* %365
store x86_fp80 0xK00000000000000000000, x86_fp80* %366
%367 = call { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %27)
%368 = extractvalue { x86_fp80, x86_fp80 } %367, 0
%369 = extractvalue { x86_fp80, x86_fp80 } %367, 1
%370 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %28, i32 0, i32 0
%371 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %28, i32 0, i32 1
store x86_fp80 %368, x86_fp80* %370
store x86_fp80 %369, x86_fp80* %371
%372 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %28)
br label %373
373: ; preds = %333
br label %374
374: ; preds = %373
%375 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 0
%376 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 1
store float 0xC415AF1D80000000, float* %375
store float 0.000000e+00, float* %376
%377 = bitcast { float, float }* %29 to <2 x float>*
%378 = load <2 x float>, <2 x float>* %377
%379 = call <2 x float> @cexpf(<2 x float> %378)
%380 = bitcast { float, float }* %30 to <2 x float>*
store <2 x float> %379, <2 x float>* %380
%381 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 0
%382 = load float, float* %381
%383 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 1
%384 = load float, float* %383
%385 = getelementptr inbounds { float, float }, { float, float }* %31, i32 0, i32 0
%386 = getelementptr inbounds { float, float }, { float, float }* %31, i32 0, i32 1
store float %382, float* %385
store float %384, float* %386
%387 = bitcast { float, float }* %31 to <2 x float>*
%388 = load <2 x float>, <2 x float>* %387
%389 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %388)
%390 = getelementptr inbounds { double, double }, { double, double }* %32, i32 0, i32 0
%391 = getelementptr inbounds { double, double }, { double, double }* %32, i32 0, i32 1
store double -1.000000e+20, double* %390
store double 0.000000e+00, double* %391
%392 = getelementptr inbounds { double, double }, { double, double }* %32, i32 0, i32 0
%393 = load double, double* %392
%394 = getelementptr inbounds { double, double }, { double, double }* %32, i32 0, i32 1
%395 = load double, double* %394
%396 = call { double, double } @cexp(double %393, double %395)
%397 = extractvalue { double, double } %396, 0
%398 = extractvalue { double, double } %396, 1
%399 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 0
%400 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 1
store double %397, double* %399
store double %398, double* %400
%401 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 0
%402 = load double, double* %401
%403 = getelementptr inbounds { double, double }, { double, double }* %33, i32 0, i32 1
%404 = load double, double* %403
%405 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %402, double %404)
%406 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %34, i32 0, i32 0
%407 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %34, i32 0, i32 1
store x86_fp80 0xKC041AD78EBC5AC620000, x86_fp80* %406
store x86_fp80 0xK00000000000000000000, x86_fp80* %407
%408 = call { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %34)
%409 = extractvalue { x86_fp80, x86_fp80 } %408, 0
%410 = extractvalue { x86_fp80, x86_fp80 } %408, 1
%411 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %35, i32 0, i32 0
%412 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %35, i32 0, i32 1
store x86_fp80 %409, x86_fp80* %411
store x86_fp80 %410, x86_fp80* %412
%413 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %35)
br label %414
414: ; preds = %374
%415 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 0
%416 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 1
store float 0x7FF8000000000000, float* %415
store float 0.000000e+00, float* %416
%417 = bitcast { float, float }* %36 to <2 x float>*
%418 = load <2 x float>, <2 x float>* %417
%419 = getelementptr inbounds { float, float }, { float, float }* %37, i32 0, i32 0
%420 = getelementptr inbounds { float, float }, { float, float }* %37, i32 0, i32 1
store float 2.500000e+00, float* %419
store float 0.000000e+00, float* %420
%421 = bitcast { float, float }* %37 to <2 x float>*
%422 = load <2 x float>, <2 x float>* %421
%423 = call <2 x float> @cpowf(<2 x float> %418, <2 x float> %422)
%424 = bitcast { float, float }* %38 to <2 x float>*
store <2 x float> %423, <2 x float>* %424
%425 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%426 = load float, float* %425
%427 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
%428 = load float, float* %427
%429 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 0
%430 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 1
store float %426, float* %429
store float %428, float* %430
%431 = bitcast { float, float }* %39 to <2 x float>*
%432 = load <2 x float>, <2 x float>* %431
%433 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %432)
%434 = getelementptr inbounds { double, double }, { double, double }* %40, i32 0, i32 0
%435 = getelementptr inbounds { double, double }, { double, double }* %40, i32 0, i32 1
store double 0x7FF8000000000000, double* %434
store double 0.000000e+00, double* %435
%436 = getelementptr inbounds { double, double }, { double, double }* %40, i32 0, i32 0
%437 = load double, double* %436
%438 = getelementptr inbounds { double, double }, { double, double }* %40, i32 0, i32 1
%439 = load double, double* %438
%440 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 0
%441 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 1
store double 2.500000e+00, double* %440
store double 0.000000e+00, double* %441
%442 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 0
%443 = load double, double* %442
%444 = getelementptr inbounds { double, double }, { double, double }* %41, i32 0, i32 1
%445 = load double, double* %444
%446 = call { double, double } @cpow(double %437, double %439, double %443, double %445)
%447 = extractvalue { double, double } %446, 0
%448 = extractvalue { double, double } %446, 1
%449 = getelementptr inbounds { double, double }, { double, double }* %42, i32 0, i32 0
%450 = getelementptr inbounds { double, double }, { double, double }* %42, i32 0, i32 1
store double %447, double* %449
store double %448, double* %450
%451 = getelementptr inbounds { double, double }, { double, double }* %42, i32 0, i32 0
%452 = load double, double* %451
%453 = getelementptr inbounds { double, double }, { double, double }* %42, i32 0, i32 1
%454 = load double, double* %453
%455 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %452, double %454)
%456 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %43, i32 0, i32 0
%457 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %43, i32 0, i32 1
store x86_fp80 0xK7FFFC000000000000000, x86_fp80* %456
store x86_fp80 0xK00000000000000000000, x86_fp80* %457
%458 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %44, i32 0, i32 0
%459 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %44, i32 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %458
store x86_fp80 0xK00000000000000000000, x86_fp80* %459
%460 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %43, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %44)
%461 = extractvalue { x86_fp80, x86_fp80 } %460, 0
%462 = extractvalue { x86_fp80, x86_fp80 } %460, 1
%463 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %45, i32 0, i32 0
%464 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %45, i32 0, i32 1
store x86_fp80 %461, x86_fp80* %463
store x86_fp80 %462, x86_fp80* %464
%465 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %45)
%466 = getelementptr inbounds { float, float }, { float, float }* %46, i32 0, i32 0
%467 = getelementptr inbounds { float, float }, { float, float }* %46, i32 0, i32 1
store float 2.500000e+00, float* %466
store float 0.000000e+00, float* %467
%468 = bitcast { float, float }* %46 to <2 x float>*
%469 = load <2 x float>, <2 x float>* %468
%470 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 0
%471 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 1
store float 0x7FF8000000000000, float* %470
store float 0.000000e+00, float* %471
%472 = bitcast { float, float }* %47 to <2 x float>*
%473 = load <2 x float>, <2 x float>* %472
%474 = call <2 x float> @cpowf(<2 x float> %469, <2 x float> %473)
%475 = bitcast { float, float }* %48 to <2 x float>*
store <2 x float> %474, <2 x float>* %475
%476 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 0
%477 = load float, float* %476
%478 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 1
%479 = load float, float* %478
%480 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 0
%481 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 1
store float %477, float* %480
store float %479, float* %481
%482 = bitcast { float, float }* %49 to <2 x float>*
%483 = load <2 x float>, <2 x float>* %482
%484 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %483)
%485 = getelementptr inbounds { double, double }, { double, double }* %50, i32 0, i32 0
%486 = getelementptr inbounds { double, double }, { double, double }* %50, i32 0, i32 1
store double 2.500000e+00, double* %485
store double 0.000000e+00, double* %486
%487 = getelementptr inbounds { double, double }, { double, double }* %50, i32 0, i32 0
%488 = load double, double* %487
%489 = getelementptr inbounds { double, double }, { double, double }* %50, i32 0, i32 1
%490 = load double, double* %489
%491 = getelementptr inbounds { double, double }, { double, double }* %51, i32 0, i32 0
%492 = getelementptr inbounds { double, double }, { double, double }* %51, i32 0, i32 1
store double 0x7FF8000000000000, double* %491
store double 0.000000e+00, double* %492
%493 = getelementptr inbounds { double, double }, { double, double }* %51, i32 0, i32 0
%494 = load double, double* %493
%495 = getelementptr inbounds { double, double }, { double, double }* %51, i32 0, i32 1
%496 = load double, double* %495
%497 = call { double, double } @cpow(double %488, double %490, double %494, double %496)
%498 = extractvalue { double, double } %497, 0
%499 = extractvalue { double, double } %497, 1
%500 = getelementptr inbounds { double, double }, { double, double }* %52, i32 0, i32 0
%501 = getelementptr inbounds { double, double }, { double, double }* %52, i32 0, i32 1
store double %498, double* %500
store double %499, double* %501
%502 = getelementptr inbounds { double, double }, { double, double }* %52, i32 0, i32 0
%503 = load double, double* %502
%504 = getelementptr inbounds { double, double }, { double, double }* %52, i32 0, i32 1
%505 = load double, double* %504
%506 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %503, double %505)
%507 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %53, i32 0, i32 0
%508 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %53, i32 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %507
store x86_fp80 0xK00000000000000000000, x86_fp80* %508
%509 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %54, i32 0, i32 0
%510 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %54, i32 0, i32 1
store x86_fp80 0xK7FFFC000000000000000, x86_fp80* %509
store x86_fp80 0xK00000000000000000000, x86_fp80* %510
%511 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %53, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %54)
%512 = extractvalue { x86_fp80, x86_fp80 } %511, 0
%513 = extractvalue { x86_fp80, x86_fp80 } %511, 1
%514 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %55, i32 0, i32 0
%515 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %55, i32 0, i32 1
store x86_fp80 %512, x86_fp80* %514
store x86_fp80 %513, x86_fp80* %515
%516 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %55)
%517 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 0
%518 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 1
store float 0x7FF0000000000000, float* %517
store float 0.000000e+00, float* %518
%519 = bitcast { float, float }* %56 to <2 x float>*
%520 = load <2 x float>, <2 x float>* %519
%521 = getelementptr inbounds { float, float }, { float, float }* %57, i32 0, i32 0
%522 = getelementptr inbounds { float, float }, { float, float }* %57, i32 0, i32 1
store float 2.500000e+00, float* %521
store float 0.000000e+00, float* %522
%523 = bitcast { float, float }* %57 to <2 x float>*
%524 = load <2 x float>, <2 x float>* %523
%525 = call <2 x float> @cpowf(<2 x float> %520, <2 x float> %524)
%526 = bitcast { float, float }* %58 to <2 x float>*
store <2 x float> %525, <2 x float>* %526
%527 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%528 = load float, float* %527
%529 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
%530 = load float, float* %529
%531 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 0
%532 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 1
store float %528, float* %531
store float %530, float* %532
%533 = bitcast { float, float }* %59 to <2 x float>*
%534 = load <2 x float>, <2 x float>* %533
%535 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %534)
%536 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 0
%537 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 1
store double 0x7FF0000000000000, double* %536
store double 0.000000e+00, double* %537
%538 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 0
%539 = load double, double* %538
%540 = getelementptr inbounds { double, double }, { double, double }* %60, i32 0, i32 1
%541 = load double, double* %540
%542 = getelementptr inbounds { double, double }, { double, double }* %61, i32 0, i32 0
%543 = getelementptr inbounds { double, double }, { double, double }* %61, i32 0, i32 1
store double 2.500000e+00, double* %542
store double 0.000000e+00, double* %543
%544 = getelementptr inbounds { double, double }, { double, double }* %61, i32 0, i32 0
%545 = load double, double* %544
%546 = getelementptr inbounds { double, double }, { double, double }* %61, i32 0, i32 1
%547 = load double, double* %546
%548 = call { double, double } @cpow(double %539, double %541, double %545, double %547)
%549 = extractvalue { double, double } %548, 0
%550 = extractvalue { double, double } %548, 1
%551 = getelementptr inbounds { double, double }, { double, double }* %62, i32 0, i32 0
%552 = getelementptr inbounds { double, double }, { double, double }* %62, i32 0, i32 1
store double %549, double* %551
store double %550, double* %552
%553 = getelementptr inbounds { double, double }, { double, double }* %62, i32 0, i32 0
%554 = load double, double* %553
%555 = getelementptr inbounds { double, double }, { double, double }* %62, i32 0, i32 1
%556 = load double, double* %555
%557 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %554, double %556)
%558 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %63, i32 0, i32 0
%559 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %63, i32 0, i32 1
store x86_fp80 0xK7FFF8000000000000000, x86_fp80* %558
store x86_fp80 0xK00000000000000000000, x86_fp80* %559
%560 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %64, i32 0, i32 0
%561 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %64, i32 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %560
store x86_fp80 0xK00000000000000000000, x86_fp80* %561
%562 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %63, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %64)
%563 = extractvalue { x86_fp80, x86_fp80 } %562, 0
%564 = extractvalue { x86_fp80, x86_fp80 } %562, 1
%565 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %65, i32 0, i32 0
%566 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %65, i32 0, i32 1
store x86_fp80 %563, x86_fp80* %565
store x86_fp80 %564, x86_fp80* %566
%567 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %65)
%568 = getelementptr inbounds { float, float }, { float, float }* %66, i32 0, i32 0
%569 = getelementptr inbounds { float, float }, { float, float }* %66, i32 0, i32 1
store float 0xFFF0000000000000, float* %568
store float 0.000000e+00, float* %569
%570 = bitcast { float, float }* %66 to <2 x float>*
%571 = load <2 x float>, <2 x float>* %570
%572 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 0
%573 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 1
store float 2.500000e+00, float* %572
store float 0.000000e+00, float* %573
%574 = bitcast { float, float }* %67 to <2 x float>*
%575 = load <2 x float>, <2 x float>* %574
%576 = call <2 x float> @cpowf(<2 x float> %571, <2 x float> %575)
%577 = bitcast { float, float }* %68 to <2 x float>*
store <2 x float> %576, <2 x float>* %577
%578 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 0
%579 = load float, float* %578
%580 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 1
%581 = load float, float* %580
%582 = getelementptr inbounds { float, float }, { float, float }* %69, i32 0, i32 0
%583 = getelementptr inbounds { float, float }, { float, float }* %69, i32 0, i32 1
store float %579, float* %582
store float %581, float* %583
%584 = bitcast { float, float }* %69 to <2 x float>*
%585 = load <2 x float>, <2 x float>* %584
%586 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %585)
%587 = getelementptr inbounds { double, double }, { double, double }* %70, i32 0, i32 0
%588 = getelementptr inbounds { double, double }, { double, double }* %70, i32 0, i32 1
store double 0xFFF0000000000000, double* %587
store double 0.000000e+00, double* %588
%589 = getelementptr inbounds { double, double }, { double, double }* %70, i32 0, i32 0
%590 = load double, double* %589
%591 = getelementptr inbounds { double, double }, { double, double }* %70, i32 0, i32 1
%592 = load double, double* %591
%593 = getelementptr inbounds { double, double }, { double, double }* %71, i32 0, i32 0
%594 = getelementptr inbounds { double, double }, { double, double }* %71, i32 0, i32 1
store double 2.500000e+00, double* %593
store double 0.000000e+00, double* %594
%595 = getelementptr inbounds { double, double }, { double, double }* %71, i32 0, i32 0
%596 = load double, double* %595
%597 = getelementptr inbounds { double, double }, { double, double }* %71, i32 0, i32 1
%598 = load double, double* %597
%599 = call { double, double } @cpow(double %590, double %592, double %596, double %598)
%600 = extractvalue { double, double } %599, 0
%601 = extractvalue { double, double } %599, 1
%602 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 0
%603 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 1
store double %600, double* %602
store double %601, double* %603
%604 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 0
%605 = load double, double* %604
%606 = getelementptr inbounds { double, double }, { double, double }* %72, i32 0, i32 1
%607 = load double, double* %606
%608 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %605, double %607)
%609 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %73, i32 0, i32 0
%610 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %73, i32 0, i32 1
store x86_fp80 0xKFFFF8000000000000000, x86_fp80* %609
store x86_fp80 0xK00000000000000000000, x86_fp80* %610
%611 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %74, i32 0, i32 0
%612 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %74, i32 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %611
store x86_fp80 0xK00000000000000000000, x86_fp80* %612
%613 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %73, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %74)
%614 = extractvalue { x86_fp80, x86_fp80 } %613, 0
%615 = extractvalue { x86_fp80, x86_fp80 } %613, 1
%616 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %75, i32 0, i32 0
%617 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %75, i32 0, i32 1
store x86_fp80 %614, x86_fp80* %616
store x86_fp80 %615, x86_fp80* %617
%618 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %75)
%619 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 0
%620 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 1
store float 2.500000e+00, float* %619
store float 0.000000e+00, float* %620
%621 = bitcast { float, float }* %76 to <2 x float>*
%622 = load <2 x float>, <2 x float>* %621
%623 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 0
%624 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 1
store float 0x7FF0000000000000, float* %623
store float 0.000000e+00, float* %624
%625 = bitcast { float, float }* %77 to <2 x float>*
%626 = load <2 x float>, <2 x float>* %625
%627 = call <2 x float> @cpowf(<2 x float> %622, <2 x float> %626)
%628 = bitcast { float, float }* %78 to <2 x float>*
store <2 x float> %627, <2 x float>* %628
%629 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 0
%630 = load float, float* %629
%631 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 1
%632 = load float, float* %631
%633 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 0
%634 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 1
store float %630, float* %633
store float %632, float* %634
%635 = bitcast { float, float }* %79 to <2 x float>*
%636 = load <2 x float>, <2 x float>* %635
%637 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %636)
%638 = getelementptr inbounds { double, double }, { double, double }* %80, i32 0, i32 0
%639 = getelementptr inbounds { double, double }, { double, double }* %80, i32 0, i32 1
store double 2.500000e+00, double* %638
store double 0.000000e+00, double* %639
%640 = getelementptr inbounds { double, double }, { double, double }* %80, i32 0, i32 0
%641 = load double, double* %640
%642 = getelementptr inbounds { double, double }, { double, double }* %80, i32 0, i32 1
%643 = load double, double* %642
%644 = getelementptr inbounds { double, double }, { double, double }* %81, i32 0, i32 0
%645 = getelementptr inbounds { double, double }, { double, double }* %81, i32 0, i32 1
store double 0x7FF0000000000000, double* %644
store double 0.000000e+00, double* %645
%646 = getelementptr inbounds { double, double }, { double, double }* %81, i32 0, i32 0
%647 = load double, double* %646
%648 = getelementptr inbounds { double, double }, { double, double }* %81, i32 0, i32 1
%649 = load double, double* %648
%650 = call { double, double } @cpow(double %641, double %643, double %647, double %649)
%651 = extractvalue { double, double } %650, 0
%652 = extractvalue { double, double } %650, 1
%653 = getelementptr inbounds { double, double }, { double, double }* %82, i32 0, i32 0
%654 = getelementptr inbounds { double, double }, { double, double }* %82, i32 0, i32 1
store double %651, double* %653
store double %652, double* %654
%655 = getelementptr inbounds { double, double }, { double, double }* %82, i32 0, i32 0
%656 = load double, double* %655
%657 = getelementptr inbounds { double, double }, { double, double }* %82, i32 0, i32 1
%658 = load double, double* %657
%659 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %656, double %658)
%660 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %83, i32 0, i32 0
%661 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %83, i32 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %660
store x86_fp80 0xK00000000000000000000, x86_fp80* %661
%662 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %84, i32 0, i32 0
%663 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %84, i32 0, i32 1
store x86_fp80 0xK7FFF8000000000000000, x86_fp80* %662
store x86_fp80 0xK00000000000000000000, x86_fp80* %663
%664 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %83, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %84)
%665 = extractvalue { x86_fp80, x86_fp80 } %664, 0
%666 = extractvalue { x86_fp80, x86_fp80 } %664, 1
%667 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %85, i32 0, i32 0
%668 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %85, i32 0, i32 1
store x86_fp80 %665, x86_fp80* %667
store x86_fp80 %666, x86_fp80* %668
%669 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %85)
%670 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 0
%671 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 1
store float 2.500000e+00, float* %670
store float 0.000000e+00, float* %671
%672 = bitcast { float, float }* %86 to <2 x float>*
%673 = load <2 x float>, <2 x float>* %672
%674 = getelementptr inbounds { float, float }, { float, float }* %87, i32 0, i32 0
%675 = getelementptr inbounds { float, float }, { float, float }* %87, i32 0, i32 1
store float 0xFFF0000000000000, float* %674
store float 0.000000e+00, float* %675
%676 = bitcast { float, float }* %87 to <2 x float>*
%677 = load <2 x float>, <2 x float>* %676
%678 = call <2 x float> @cpowf(<2 x float> %673, <2 x float> %677)
%679 = bitcast { float, float }* %88 to <2 x float>*
store <2 x float> %678, <2 x float>* %679
%680 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 0
%681 = load float, float* %680
%682 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 1
%683 = load float, float* %682
%684 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 0
%685 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 1
store float %681, float* %684
store float %683, float* %685
%686 = bitcast { float, float }* %89 to <2 x float>*
%687 = load <2 x float>, <2 x float>* %686
%688 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %687)
%689 = getelementptr inbounds { double, double }, { double, double }* %90, i32 0, i32 0
%690 = getelementptr inbounds { double, double }, { double, double }* %90, i32 0, i32 1
store double 2.500000e+00, double* %689
store double 0.000000e+00, double* %690
%691 = getelementptr inbounds { double, double }, { double, double }* %90, i32 0, i32 0
%692 = load double, double* %691
%693 = getelementptr inbounds { double, double }, { double, double }* %90, i32 0, i32 1
%694 = load double, double* %693
%695 = getelementptr inbounds { double, double }, { double, double }* %91, i32 0, i32 0
%696 = getelementptr inbounds { double, double }, { double, double }* %91, i32 0, i32 1
store double 0xFFF0000000000000, double* %695
store double 0.000000e+00, double* %696
%697 = getelementptr inbounds { double, double }, { double, double }* %91, i32 0, i32 0
%698 = load double, double* %697
%699 = getelementptr inbounds { double, double }, { double, double }* %91, i32 0, i32 1
%700 = load double, double* %699
%701 = call { double, double } @cpow(double %692, double %694, double %698, double %700)
%702 = extractvalue { double, double } %701, 0
%703 = extractvalue { double, double } %701, 1
%704 = getelementptr inbounds { double, double }, { double, double }* %92, i32 0, i32 0
%705 = getelementptr inbounds { double, double }, { double, double }* %92, i32 0, i32 1
store double %702, double* %704
store double %703, double* %705
%706 = getelementptr inbounds { double, double }, { double, double }* %92, i32 0, i32 0
%707 = load double, double* %706
%708 = getelementptr inbounds { double, double }, { double, double }* %92, i32 0, i32 1
%709 = load double, double* %708
%710 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %707, double %709)
%711 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %93, i32 0, i32 0
%712 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %93, i32 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %711
store x86_fp80 0xK00000000000000000000, x86_fp80* %712
%713 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %94, i32 0, i32 0
%714 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %94, i32 0, i32 1
store x86_fp80 0xKFFFF8000000000000000, x86_fp80* %713
store x86_fp80 0xK00000000000000000000, x86_fp80* %714
%715 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %93, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %94)
%716 = extractvalue { x86_fp80, x86_fp80 } %715, 0
%717 = extractvalue { x86_fp80, x86_fp80 } %715, 1
%718 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %95, i32 0, i32 0
%719 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %95, i32 0, i32 1
store x86_fp80 %716, x86_fp80* %718
store x86_fp80 %717, x86_fp80* %719
%720 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %95)
br label %721
721: ; preds = %414
%722 = getelementptr inbounds { float, float }, { float, float }* %96, i32 0, i32 0
%723 = getelementptr inbounds { float, float }, { float, float }* %96, i32 0, i32 1
store float -0.000000e+00, float* %722
store float 0.000000e+00, float* %723
%724 = bitcast { float, float }* %96 to <2 x float>*
%725 = load <2 x float>, <2 x float>* %724
%726 = getelementptr inbounds { float, float }, { float, float }* %97, i32 0, i32 0
%727 = getelementptr inbounds { float, float }, { float, float }* %97, i32 0, i32 1
store float -4.500000e+00, float* %726
store float 0.000000e+00, float* %727
%728 = bitcast { float, float }* %97 to <2 x float>*
%729 = load <2 x float>, <2 x float>* %728
%730 = call <2 x float> @cpowf(<2 x float> %725, <2 x float> %729)
%731 = bitcast { float, float }* %98 to <2 x float>*
store <2 x float> %730, <2 x float>* %731
%732 = getelementptr inbounds { float, float }, { float, float }* %98, i32 0, i32 0
%733 = load float, float* %732
%734 = getelementptr inbounds { float, float }, { float, float }* %98, i32 0, i32 1
%735 = load float, float* %734
%736 = getelementptr inbounds { float, float }, { float, float }* %99, i32 0, i32 0
%737 = getelementptr inbounds { float, float }, { float, float }* %99, i32 0, i32 1
store float %733, float* %736
store float %735, float* %737
%738 = bitcast { float, float }* %99 to <2 x float>*
%739 = load <2 x float>, <2 x float>* %738
%740 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %739)
%741 = getelementptr inbounds { double, double }, { double, double }* %100, i32 0, i32 0
%742 = getelementptr inbounds { double, double }, { double, double }* %100, i32 0, i32 1
store double -0.000000e+00, double* %741
store double 0.000000e+00, double* %742
%743 = getelementptr inbounds { double, double }, { double, double }* %100, i32 0, i32 0
%744 = load double, double* %743
%745 = getelementptr inbounds { double, double }, { double, double }* %100, i32 0, i32 1
%746 = load double, double* %745
%747 = getelementptr inbounds { double, double }, { double, double }* %101, i32 0, i32 0
%748 = getelementptr inbounds { double, double }, { double, double }* %101, i32 0, i32 1
store double -4.500000e+00, double* %747
store double 0.000000e+00, double* %748
%749 = getelementptr inbounds { double, double }, { double, double }* %101, i32 0, i32 0
%750 = load double, double* %749
%751 = getelementptr inbounds { double, double }, { double, double }* %101, i32 0, i32 1
%752 = load double, double* %751
%753 = call { double, double } @cpow(double %744, double %746, double %750, double %752)
%754 = extractvalue { double, double } %753, 0
%755 = extractvalue { double, double } %753, 1
%756 = getelementptr inbounds { double, double }, { double, double }* %102, i32 0, i32 0
%757 = getelementptr inbounds { double, double }, { double, double }* %102, i32 0, i32 1
store double %754, double* %756
store double %755, double* %757
%758 = getelementptr inbounds { double, double }, { double, double }* %102, i32 0, i32 0
%759 = load double, double* %758
%760 = getelementptr inbounds { double, double }, { double, double }* %102, i32 0, i32 1
%761 = load double, double* %760
%762 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %759, double %761)
%763 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %103, i32 0, i32 0
%764 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %103, i32 0, i32 1
store x86_fp80 0xK80000000000000000000, x86_fp80* %763
store x86_fp80 0xK00000000000000000000, x86_fp80* %764
%765 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %104, i32 0, i32 0
%766 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %104, i32 0, i32 1
store x86_fp80 0xKC0019000000000000000, x86_fp80* %765
store x86_fp80 0xK00000000000000000000, x86_fp80* %766
%767 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %103, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %104)
%768 = extractvalue { x86_fp80, x86_fp80 } %767, 0
%769 = extractvalue { x86_fp80, x86_fp80 } %767, 1
%770 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %105, i32 0, i32 0
%771 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %105, i32 0, i32 1
store x86_fp80 %768, x86_fp80* %770
store x86_fp80 %769, x86_fp80* %771
%772 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %105)
br label %773
773: ; preds = %721
br label %774
774: ; preds = %773
%775 = getelementptr inbounds { float, float }, { float, float }* %106, i32 0, i32 0
%776 = getelementptr inbounds { float, float }, { float, float }* %106, i32 0, i32 1
store float 0.000000e+00, float* %775
store float 0.000000e+00, float* %776
%777 = bitcast { float, float }* %106 to <2 x float>*
%778 = load <2 x float>, <2 x float>* %777
%779 = getelementptr inbounds { float, float }, { float, float }* %107, i32 0, i32 0
%780 = getelementptr inbounds { float, float }, { float, float }* %107, i32 0, i32 1
store float -4.500000e+00, float* %779
store float 0.000000e+00, float* %780
%781 = bitcast { float, float }* %107 to <2 x float>*
%782 = load <2 x float>, <2 x float>* %781
%783 = call <2 x float> @cpowf(<2 x float> %778, <2 x float> %782)
%784 = bitcast { float, float }* %108 to <2 x float>*
store <2 x float> %783, <2 x float>* %784
%785 = getelementptr inbounds { float, float }, { float, float }* %108, i32 0, i32 0
%786 = load float, float* %785
%787 = getelementptr inbounds { float, float }, { float, float }* %108, i32 0, i32 1
%788 = load float, float* %787
%789 = getelementptr inbounds { float, float }, { float, float }* %109, i32 0, i32 0
%790 = getelementptr inbounds { float, float }, { float, float }* %109, i32 0, i32 1
store float %786, float* %789
store float %788, float* %790
%791 = bitcast { float, float }* %109 to <2 x float>*
%792 = load <2 x float>, <2 x float>* %791
%793 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %792)
%794 = getelementptr inbounds { double, double }, { double, double }* %110, i32 0, i32 0
%795 = getelementptr inbounds { double, double }, { double, double }* %110, i32 0, i32 1
store double 0.000000e+00, double* %794
store double 0.000000e+00, double* %795
%796 = getelementptr inbounds { double, double }, { double, double }* %110, i32 0, i32 0
%797 = load double, double* %796
%798 = getelementptr inbounds { double, double }, { double, double }* %110, i32 0, i32 1
%799 = load double, double* %798
%800 = getelementptr inbounds { double, double }, { double, double }* %111, i32 0, i32 0
%801 = getelementptr inbounds { double, double }, { double, double }* %111, i32 0, i32 1
store double -4.500000e+00, double* %800
store double 0.000000e+00, double* %801
%802 = getelementptr inbounds { double, double }, { double, double }* %111, i32 0, i32 0
%803 = load double, double* %802
%804 = getelementptr inbounds { double, double }, { double, double }* %111, i32 0, i32 1
%805 = load double, double* %804
%806 = call { double, double } @cpow(double %797, double %799, double %803, double %805)
%807 = extractvalue { double, double } %806, 0
%808 = extractvalue { double, double } %806, 1
%809 = getelementptr inbounds { double, double }, { double, double }* %112, i32 0, i32 0
%810 = getelementptr inbounds { double, double }, { double, double }* %112, i32 0, i32 1
store double %807, double* %809
store double %808, double* %810
%811 = getelementptr inbounds { double, double }, { double, double }* %112, i32 0, i32 0
%812 = load double, double* %811
%813 = getelementptr inbounds { double, double }, { double, double }* %112, i32 0, i32 1
%814 = load double, double* %813
%815 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %812, double %814)
%816 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %113, i32 0, i32 0
%817 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %113, i32 0, i32 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %816
store x86_fp80 0xK00000000000000000000, x86_fp80* %817
%818 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %114, i32 0, i32 0
%819 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %114, i32 0, i32 1
store x86_fp80 0xKC0019000000000000000, x86_fp80* %818
store x86_fp80 0xK00000000000000000000, x86_fp80* %819
%820 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %113, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %114)
%821 = extractvalue { x86_fp80, x86_fp80 } %820, 0
%822 = extractvalue { x86_fp80, x86_fp80 } %820, 1
%823 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %115, i32 0, i32 0
%824 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %115, i32 0, i32 1
store x86_fp80 %821, x86_fp80* %823
store x86_fp80 %822, x86_fp80* %824
%825 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %115)
br label %826
826: ; preds = %774
%827 = getelementptr inbounds { float, float }, { float, float }* %116, i32 0, i32 0
%828 = getelementptr inbounds { float, float }, { float, float }* %116, i32 0, i32 1
store float 0x47EFFFFFE0000000, float* %827
store float 0.000000e+00, float* %828
%829 = bitcast { float, float }* %116 to <2 x float>*
%830 = load <2 x float>, <2 x float>* %829
%831 = getelementptr inbounds { float, float }, { float, float }* %117, i32 0, i32 0
%832 = getelementptr inbounds { float, float }, { float, float }* %117, i32 0, i32 1
store float 3.500000e+00, float* %831
store float 0.000000e+00, float* %832
%833 = bitcast { float, float }* %117 to <2 x float>*
%834 = load <2 x float>, <2 x float>* %833
%835 = call <2 x float> @cpowf(<2 x float> %830, <2 x float> %834)
%836 = bitcast { float, float }* %118 to <2 x float>*
store <2 x float> %835, <2 x float>* %836
%837 = getelementptr inbounds { float, float }, { float, float }* %118, i32 0, i32 0
%838 = load float, float* %837
%839 = getelementptr inbounds { float, float }, { float, float }* %118, i32 0, i32 1
%840 = load float, float* %839
%841 = getelementptr inbounds { float, float }, { float, float }* %119, i32 0, i32 0
%842 = getelementptr inbounds { float, float }, { float, float }* %119, i32 0, i32 1
store float %838, float* %841
store float %840, float* %842
%843 = bitcast { float, float }* %119 to <2 x float>*
%844 = load <2 x float>, <2 x float>* %843
%845 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %844)
%846 = getelementptr inbounds { float, float }, { float, float }* %120, i32 0, i32 0
%847 = getelementptr inbounds { float, float }, { float, float }* %120, i32 0, i32 1
store float 0.000000e+00, float* %846
store float 0x47EFFFFFE0000000, float* %847
%848 = bitcast { float, float }* %120 to <2 x float>*
%849 = load <2 x float>, <2 x float>* %848
%850 = getelementptr inbounds { float, float }, { float, float }* %121, i32 0, i32 0
%851 = getelementptr inbounds { float, float }, { float, float }* %121, i32 0, i32 1
store float 3.500000e+00, float* %850
store float 0.000000e+00, float* %851
%852 = bitcast { float, float }* %121 to <2 x float>*
%853 = load <2 x float>, <2 x float>* %852
%854 = call <2 x float> @cpowf(<2 x float> %849, <2 x float> %853)
%855 = bitcast { float, float }* %122 to <2 x float>*
store <2 x float> %854, <2 x float>* %855
%856 = getelementptr inbounds { float, float }, { float, float }* %122, i32 0, i32 0
%857 = load float, float* %856
%858 = getelementptr inbounds { float, float }, { float, float }* %122, i32 0, i32 1
%859 = load float, float* %858
%860 = getelementptr inbounds { float, float }, { float, float }* %123, i32 0, i32 0
%861 = getelementptr inbounds { float, float }, { float, float }* %123, i32 0, i32 1
store float %857, float* %860
store float %859, float* %861
%862 = bitcast { float, float }* %123 to <2 x float>*
%863 = load <2 x float>, <2 x float>* %862
%864 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %863)
%865 = getelementptr inbounds { double, double }, { double, double }* %124, i32 0, i32 0
%866 = getelementptr inbounds { double, double }, { double, double }* %124, i32 0, i32 1
store double 0x7FEFFFFFFFFFFFFF, double* %865
store double 0.000000e+00, double* %866
%867 = getelementptr inbounds { double, double }, { double, double }* %124, i32 0, i32 0
%868 = load double, double* %867
%869 = getelementptr inbounds { double, double }, { double, double }* %124, i32 0, i32 1
%870 = load double, double* %869
%871 = getelementptr inbounds { double, double }, { double, double }* %125, i32 0, i32 0
%872 = getelementptr inbounds { double, double }, { double, double }* %125, i32 0, i32 1
store double 3.500000e+00, double* %871
store double 0.000000e+00, double* %872
%873 = getelementptr inbounds { double, double }, { double, double }* %125, i32 0, i32 0
%874 = load double, double* %873
%875 = getelementptr inbounds { double, double }, { double, double }* %125, i32 0, i32 1
%876 = load double, double* %875
%877 = call { double, double } @cpow(double %868, double %870, double %874, double %876)
%878 = extractvalue { double, double } %877, 0
%879 = extractvalue { double, double } %877, 1
%880 = getelementptr inbounds { double, double }, { double, double }* %126, i32 0, i32 0
%881 = getelementptr inbounds { double, double }, { double, double }* %126, i32 0, i32 1
store double %878, double* %880
store double %879, double* %881
%882 = getelementptr inbounds { double, double }, { double, double }* %126, i32 0, i32 0
%883 = load double, double* %882
%884 = getelementptr inbounds { double, double }, { double, double }* %126, i32 0, i32 1
%885 = load double, double* %884
%886 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %883, double %885)
%887 = getelementptr inbounds { double, double }, { double, double }* %127, i32 0, i32 0
%888 = getelementptr inbounds { double, double }, { double, double }* %127, i32 0, i32 1
store double 0.000000e+00, double* %887
store double 0x7FEFFFFFFFFFFFFF, double* %888
%889 = getelementptr inbounds { double, double }, { double, double }* %127, i32 0, i32 0
%890 = load double, double* %889
%891 = getelementptr inbounds { double, double }, { double, double }* %127, i32 0, i32 1
%892 = load double, double* %891
%893 = getelementptr inbounds { double, double }, { double, double }* %128, i32 0, i32 0
%894 = getelementptr inbounds { double, double }, { double, double }* %128, i32 0, i32 1
store double 3.500000e+00, double* %893
store double 0.000000e+00, double* %894
%895 = getelementptr inbounds { double, double }, { double, double }* %128, i32 0, i32 0
%896 = load double, double* %895
%897 = getelementptr inbounds { double, double }, { double, double }* %128, i32 0, i32 1
%898 = load double, double* %897
%899 = call { double, double } @cpow(double %890, double %892, double %896, double %898)
%900 = extractvalue { double, double } %899, 0
%901 = extractvalue { double, double } %899, 1
%902 = getelementptr inbounds { double, double }, { double, double }* %129, i32 0, i32 0
%903 = getelementptr inbounds { double, double }, { double, double }* %129, i32 0, i32 1
store double %900, double* %902
store double %901, double* %903
%904 = getelementptr inbounds { double, double }, { double, double }* %129, i32 0, i32 0
%905 = load double, double* %904
%906 = getelementptr inbounds { double, double }, { double, double }* %129, i32 0, i32 1
%907 = load double, double* %906
%908 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %905, double %907)
%909 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %130, i32 0, i32 0
%910 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %130, i32 0, i32 1
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %909
store x86_fp80 0xK00000000000000000000, x86_fp80* %910
%911 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %131, i32 0, i32 0
%912 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %131, i32 0, i32 1
store x86_fp80 0xK4000E000000000000000, x86_fp80* %911
store x86_fp80 0xK00000000000000000000, x86_fp80* %912
%913 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %130, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %131)
%914 = extractvalue { x86_fp80, x86_fp80 } %913, 0
%915 = extractvalue { x86_fp80, x86_fp80 } %913, 1
%916 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %132, i32 0, i32 0
%917 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %132, i32 0, i32 1
store x86_fp80 %914, x86_fp80* %916
store x86_fp80 %915, x86_fp80* %917
%918 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %132)
%919 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %133, i32 0, i32 0
%920 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %133, i32 0, i32 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %919
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %920
%921 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %134, i32 0, i32 0
%922 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %134, i32 0, i32 1
store x86_fp80 0xK4000E000000000000000, x86_fp80* %921
store x86_fp80 0xK00000000000000000000, x86_fp80* %922
%923 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %133, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %134)
%924 = extractvalue { x86_fp80, x86_fp80 } %923, 0
%925 = extractvalue { x86_fp80, x86_fp80 } %923, 1
%926 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %135, i32 0, i32 0
%927 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %135, i32 0, i32 1
store x86_fp80 %924, x86_fp80* %926
store x86_fp80 %925, x86_fp80* %927
%928 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %135)
br label %929
929: ; preds = %826
%930 = getelementptr inbounds { float, float }, { float, float }* %136, i32 0, i32 0
%931 = getelementptr inbounds { float, float }, { float, float }* %136, i32 0, i32 1
store float 2.000000e+00, float* %930
store float 0.000000e+00, float* %931
%932 = bitcast { float, float }* %136 to <2 x float>*
%933 = load <2 x float>, <2 x float>* %932
%934 = getelementptr inbounds { float, float }, { float, float }* %137, i32 0, i32 0
%935 = getelementptr inbounds { float, float }, { float, float }* %137, i32 0, i32 1
store float 0x4310000000000000, float* %934
store float 0.000000e+00, float* %935
%936 = bitcast { float, float }* %137 to <2 x float>*
%937 = load <2 x float>, <2 x float>* %936
%938 = call <2 x float> @cpowf(<2 x float> %933, <2 x float> %937)
%939 = bitcast { float, float }* %138 to <2 x float>*
store <2 x float> %938, <2 x float>* %939
%940 = getelementptr inbounds { float, float }, { float, float }* %138, i32 0, i32 0
%941 = load float, float* %940
%942 = getelementptr inbounds { float, float }, { float, float }* %138, i32 0, i32 1
%943 = load float, float* %942
%944 = getelementptr inbounds { float, float }, { float, float }* %139, i32 0, i32 0
%945 = getelementptr inbounds { float, float }, { float, float }* %139, i32 0, i32 1
store float %941, float* %944
store float %943, float* %945
%946 = bitcast { float, float }* %139 to <2 x float>*
%947 = load <2 x float>, <2 x float>* %946
%948 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %947)
%949 = getelementptr inbounds { double, double }, { double, double }* %140, i32 0, i32 0
%950 = getelementptr inbounds { double, double }, { double, double }* %140, i32 0, i32 1
store double 2.000000e+00, double* %949
store double 0.000000e+00, double* %950
%951 = getelementptr inbounds { double, double }, { double, double }* %140, i32 0, i32 0
%952 = load double, double* %951
%953 = getelementptr inbounds { double, double }, { double, double }* %140, i32 0, i32 1
%954 = load double, double* %953
%955 = getelementptr inbounds { double, double }, { double, double }* %141, i32 0, i32 0
%956 = getelementptr inbounds { double, double }, { double, double }* %141, i32 0, i32 1
store double 0x4310000000000000, double* %955
store double 0.000000e+00, double* %956
%957 = getelementptr inbounds { double, double }, { double, double }* %141, i32 0, i32 0
%958 = load double, double* %957
%959 = getelementptr inbounds { double, double }, { double, double }* %141, i32 0, i32 1
%960 = load double, double* %959
%961 = call { double, double } @cpow(double %952, double %954, double %958, double %960)
%962 = extractvalue { double, double } %961, 0
%963 = extractvalue { double, double } %961, 1
%964 = getelementptr inbounds { double, double }, { double, double }* %142, i32 0, i32 0
%965 = getelementptr inbounds { double, double }, { double, double }* %142, i32 0, i32 1
store double %962, double* %964
store double %963, double* %965
%966 = getelementptr inbounds { double, double }, { double, double }* %142, i32 0, i32 0
%967 = load double, double* %966
%968 = getelementptr inbounds { double, double }, { double, double }* %142, i32 0, i32 1
%969 = load double, double* %968
%970 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %967, double %969)
%971 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %143, i32 0, i32 0
%972 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %143, i32 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %971
store x86_fp80 0xK00000000000000000000, x86_fp80* %972
%973 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %144, i32 0, i32 0
%974 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %144, i32 0, i32 1
store x86_fp80 0xK40318000000000000000, x86_fp80* %973
store x86_fp80 0xK00000000000000000000, x86_fp80* %974
%975 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %143, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %144)
%976 = extractvalue { x86_fp80, x86_fp80 } %975, 0
%977 = extractvalue { x86_fp80, x86_fp80 } %975, 1
%978 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %145, i32 0, i32 0
%979 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %145, i32 0, i32 1
store x86_fp80 %976, x86_fp80* %978
store x86_fp80 %977, x86_fp80* %979
%980 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %145)
br label %981
981: ; preds = %929
br label %982
982: ; preds = %981
%983 = getelementptr inbounds { float, float }, { float, float }* %146, i32 0, i32 0
%984 = getelementptr inbounds { float, float }, { float, float }* %146, i32 0, i32 1
store float 2.000000e+00, float* %983
store float 0.000000e+00, float* %984
%985 = bitcast { float, float }* %146 to <2 x float>*
%986 = load <2 x float>, <2 x float>* %985
%987 = getelementptr inbounds { float, float }, { float, float }* %147, i32 0, i32 0
%988 = getelementptr inbounds { float, float }, { float, float }* %147, i32 0, i32 1
store float 0x41B0000000000000, float* %987
store float 0.000000e+00, float* %988
%989 = bitcast { float, float }* %147 to <2 x float>*
%990 = load <2 x float>, <2 x float>* %989
%991 = call <2 x float> @cpowf(<2 x float> %986, <2 x float> %990)
%992 = bitcast { float, float }* %148 to <2 x float>*
store <2 x float> %991, <2 x float>* %992
%993 = getelementptr inbounds { float, float }, { float, float }* %148, i32 0, i32 0
%994 = load float, float* %993
%995 = getelementptr inbounds { float, float }, { float, float }* %148, i32 0, i32 1
%996 = load float, float* %995
%997 = getelementptr inbounds { float, float }, { float, float }* %149, i32 0, i32 0
%998 = getelementptr inbounds { float, float }, { float, float }* %149, i32 0, i32 1
store float %994, float* %997
store float %996, float* %998
%999 = bitcast { float, float }* %149 to <2 x float>*
%1000 = load <2 x float>, <2 x float>* %999
%1001 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1000)
%1002 = getelementptr inbounds { double, double }, { double, double }* %150, i32 0, i32 0
%1003 = getelementptr inbounds { double, double }, { double, double }* %150, i32 0, i32 1
store double 2.000000e+00, double* %1002
store double 0.000000e+00, double* %1003
%1004 = getelementptr inbounds { double, double }, { double, double }* %150, i32 0, i32 0
%1005 = load double, double* %1004
%1006 = getelementptr inbounds { double, double }, { double, double }* %150, i32 0, i32 1
%1007 = load double, double* %1006
%1008 = getelementptr inbounds { double, double }, { double, double }* %151, i32 0, i32 0
%1009 = getelementptr inbounds { double, double }, { double, double }* %151, i32 0, i32 1
store double 0x41B0000000000000, double* %1008
store double 0.000000e+00, double* %1009
%1010 = getelementptr inbounds { double, double }, { double, double }* %151, i32 0, i32 0
%1011 = load double, double* %1010
%1012 = getelementptr inbounds { double, double }, { double, double }* %151, i32 0, i32 1
%1013 = load double, double* %1012
%1014 = call { double, double } @cpow(double %1005, double %1007, double %1011, double %1013)
%1015 = extractvalue { double, double } %1014, 0
%1016 = extractvalue { double, double } %1014, 1
%1017 = getelementptr inbounds { double, double }, { double, double }* %152, i32 0, i32 0
%1018 = getelementptr inbounds { double, double }, { double, double }* %152, i32 0, i32 1
store double %1015, double* %1017
store double %1016, double* %1018
%1019 = getelementptr inbounds { double, double }, { double, double }* %152, i32 0, i32 0
%1020 = load double, double* %1019
%1021 = getelementptr inbounds { double, double }, { double, double }* %152, i32 0, i32 1
%1022 = load double, double* %1021
%1023 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1020, double %1022)
%1024 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %153, i32 0, i32 0
%1025 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %153, i32 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %1024
store x86_fp80 0xK00000000000000000000, x86_fp80* %1025
%1026 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %154, i32 0, i32 0
%1027 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %154, i32 0, i32 1
store x86_fp80 0xK401B8000000000000000, x86_fp80* %1026
store x86_fp80 0xK00000000000000000000, x86_fp80* %1027
%1028 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %153, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %154)
%1029 = extractvalue { x86_fp80, x86_fp80 } %1028, 0
%1030 = extractvalue { x86_fp80, x86_fp80 } %1028, 1
%1031 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %155, i32 0, i32 0
%1032 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %155, i32 0, i32 1
store x86_fp80 %1029, x86_fp80* %1031
store x86_fp80 %1030, x86_fp80* %1032
%1033 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %155)
br label %1034
1034: ; preds = %982
br label %1035
1035: ; preds = %1034
%1036 = getelementptr inbounds { float, float }, { float, float }* %156, i32 0, i32 0
%1037 = getelementptr inbounds { float, float }, { float, float }* %156, i32 0, i32 1
store float 2.000000e+00, float* %1036
store float 0.000000e+00, float* %1037
%1038 = bitcast { float, float }* %156 to <2 x float>*
%1039 = load <2 x float>, <2 x float>* %1038
%1040 = getelementptr inbounds { float, float }, { float, float }* %157, i32 0, i32 0
%1041 = getelementptr inbounds { float, float }, { float, float }* %157, i32 0, i32 1
store float 0x4170000000000000, float* %1040
store float 0.000000e+00, float* %1041
%1042 = bitcast { float, float }* %157 to <2 x float>*
%1043 = load <2 x float>, <2 x float>* %1042
%1044 = call <2 x float> @cpowf(<2 x float> %1039, <2 x float> %1043)
%1045 = bitcast { float, float }* %158 to <2 x float>*
store <2 x float> %1044, <2 x float>* %1045
%1046 = getelementptr inbounds { float, float }, { float, float }* %158, i32 0, i32 0
%1047 = load float, float* %1046
%1048 = getelementptr inbounds { float, float }, { float, float }* %158, i32 0, i32 1
%1049 = load float, float* %1048
%1050 = getelementptr inbounds { float, float }, { float, float }* %159, i32 0, i32 0
%1051 = getelementptr inbounds { float, float }, { float, float }* %159, i32 0, i32 1
store float %1047, float* %1050
store float %1049, float* %1051
%1052 = bitcast { float, float }* %159 to <2 x float>*
%1053 = load <2 x float>, <2 x float>* %1052
%1054 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1053)
%1055 = getelementptr inbounds { double, double }, { double, double }* %160, i32 0, i32 0
%1056 = getelementptr inbounds { double, double }, { double, double }* %160, i32 0, i32 1
store double 2.000000e+00, double* %1055
store double 0.000000e+00, double* %1056
%1057 = getelementptr inbounds { double, double }, { double, double }* %160, i32 0, i32 0
%1058 = load double, double* %1057
%1059 = getelementptr inbounds { double, double }, { double, double }* %160, i32 0, i32 1
%1060 = load double, double* %1059
%1061 = getelementptr inbounds { double, double }, { double, double }* %161, i32 0, i32 0
%1062 = getelementptr inbounds { double, double }, { double, double }* %161, i32 0, i32 1
store double 0x4170000000000000, double* %1061
store double 0.000000e+00, double* %1062
%1063 = getelementptr inbounds { double, double }, { double, double }* %161, i32 0, i32 0
%1064 = load double, double* %1063
%1065 = getelementptr inbounds { double, double }, { double, double }* %161, i32 0, i32 1
%1066 = load double, double* %1065
%1067 = call { double, double } @cpow(double %1058, double %1060, double %1064, double %1066)
%1068 = extractvalue { double, double } %1067, 0
%1069 = extractvalue { double, double } %1067, 1
%1070 = getelementptr inbounds { double, double }, { double, double }* %162, i32 0, i32 0
%1071 = getelementptr inbounds { double, double }, { double, double }* %162, i32 0, i32 1
store double %1068, double* %1070
store double %1069, double* %1071
%1072 = getelementptr inbounds { double, double }, { double, double }* %162, i32 0, i32 0
%1073 = load double, double* %1072
%1074 = getelementptr inbounds { double, double }, { double, double }* %162, i32 0, i32 1
%1075 = load double, double* %1074
%1076 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1073, double %1075)
%1077 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %163, i32 0, i32 0
%1078 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %163, i32 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %1077
store x86_fp80 0xK00000000000000000000, x86_fp80* %1078
%1079 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %164, i32 0, i32 0
%1080 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %164, i32 0, i32 1
store x86_fp80 0xK40178000000000000000, x86_fp80* %1079
store x86_fp80 0xK00000000000000000000, x86_fp80* %1080
%1081 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %163, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %164)
%1082 = extractvalue { x86_fp80, x86_fp80 } %1081, 0
%1083 = extractvalue { x86_fp80, x86_fp80 } %1081, 1
%1084 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %165, i32 0, i32 0
%1085 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %165, i32 0, i32 1
store x86_fp80 %1082, x86_fp80* %1084
store x86_fp80 %1083, x86_fp80* %1085
%1086 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %165)
br label %1087
1087: ; preds = %1035
%1088 = getelementptr inbounds { float, float }, { float, float }* %166, i32 0, i32 0
%1089 = getelementptr inbounds { float, float }, { float, float }* %166, i32 0, i32 1
store float 0x47EFFFFFE0000000, float* %1088
store float 0.000000e+00, float* %1089
%1090 = bitcast { float, float }* %166 to <2 x float>*
%1091 = load <2 x float>, <2 x float>* %1090
%1092 = getelementptr inbounds { float, float }, { float, float }* %167, i32 0, i32 0
%1093 = getelementptr inbounds { float, float }, { float, float }* %167, i32 0, i32 1
store float -3.500000e+00, float* %1092
store float 0.000000e+00, float* %1093
%1094 = bitcast { float, float }* %167 to <2 x float>*
%1095 = load <2 x float>, <2 x float>* %1094
%1096 = call <2 x float> @cpowf(<2 x float> %1091, <2 x float> %1095)
%1097 = bitcast { float, float }* %168 to <2 x float>*
store <2 x float> %1096, <2 x float>* %1097
%1098 = getelementptr inbounds { float, float }, { float, float }* %168, i32 0, i32 0
%1099 = load float, float* %1098
%1100 = getelementptr inbounds { float, float }, { float, float }* %168, i32 0, i32 1
%1101 = load float, float* %1100
%1102 = getelementptr inbounds { float, float }, { float, float }* %169, i32 0, i32 0
%1103 = getelementptr inbounds { float, float }, { float, float }* %169, i32 0, i32 1
store float %1099, float* %1102
store float %1101, float* %1103
%1104 = bitcast { float, float }* %169 to <2 x float>*
%1105 = load <2 x float>, <2 x float>* %1104
%1106 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1105)
%1107 = getelementptr inbounds { float, float }, { float, float }* %170, i32 0, i32 0
%1108 = getelementptr inbounds { float, float }, { float, float }* %170, i32 0, i32 1
store float 0.000000e+00, float* %1107
store float 0x47EFFFFFE0000000, float* %1108
%1109 = bitcast { float, float }* %170 to <2 x float>*
%1110 = load <2 x float>, <2 x float>* %1109
%1111 = getelementptr inbounds { float, float }, { float, float }* %171, i32 0, i32 0
%1112 = getelementptr inbounds { float, float }, { float, float }* %171, i32 0, i32 1
store float -3.500000e+00, float* %1111
store float 0.000000e+00, float* %1112
%1113 = bitcast { float, float }* %171 to <2 x float>*
%1114 = load <2 x float>, <2 x float>* %1113
%1115 = call <2 x float> @cpowf(<2 x float> %1110, <2 x float> %1114)
%1116 = bitcast { float, float }* %172 to <2 x float>*
store <2 x float> %1115, <2 x float>* %1116
%1117 = getelementptr inbounds { float, float }, { float, float }* %172, i32 0, i32 0
%1118 = load float, float* %1117
%1119 = getelementptr inbounds { float, float }, { float, float }* %172, i32 0, i32 1
%1120 = load float, float* %1119
%1121 = getelementptr inbounds { float, float }, { float, float }* %173, i32 0, i32 0
%1122 = getelementptr inbounds { float, float }, { float, float }* %173, i32 0, i32 1
store float %1118, float* %1121
store float %1120, float* %1122
%1123 = bitcast { float, float }* %173 to <2 x float>*
%1124 = load <2 x float>, <2 x float>* %1123
%1125 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1124)
%1126 = getelementptr inbounds { double, double }, { double, double }* %174, i32 0, i32 0
%1127 = getelementptr inbounds { double, double }, { double, double }* %174, i32 0, i32 1
store double 0x7FEFFFFFFFFFFFFF, double* %1126
store double 0.000000e+00, double* %1127
%1128 = getelementptr inbounds { double, double }, { double, double }* %174, i32 0, i32 0
%1129 = load double, double* %1128
%1130 = getelementptr inbounds { double, double }, { double, double }* %174, i32 0, i32 1
%1131 = load double, double* %1130
%1132 = getelementptr inbounds { double, double }, { double, double }* %175, i32 0, i32 0
%1133 = getelementptr inbounds { double, double }, { double, double }* %175, i32 0, i32 1
store double -3.500000e+00, double* %1132
store double 0.000000e+00, double* %1133
%1134 = getelementptr inbounds { double, double }, { double, double }* %175, i32 0, i32 0
%1135 = load double, double* %1134
%1136 = getelementptr inbounds { double, double }, { double, double }* %175, i32 0, i32 1
%1137 = load double, double* %1136
%1138 = call { double, double } @cpow(double %1129, double %1131, double %1135, double %1137)
%1139 = extractvalue { double, double } %1138, 0
%1140 = extractvalue { double, double } %1138, 1
%1141 = getelementptr inbounds { double, double }, { double, double }* %176, i32 0, i32 0
%1142 = getelementptr inbounds { double, double }, { double, double }* %176, i32 0, i32 1
store double %1139, double* %1141
store double %1140, double* %1142
%1143 = getelementptr inbounds { double, double }, { double, double }* %176, i32 0, i32 0
%1144 = load double, double* %1143
%1145 = getelementptr inbounds { double, double }, { double, double }* %176, i32 0, i32 1
%1146 = load double, double* %1145
%1147 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1144, double %1146)
%1148 = getelementptr inbounds { double, double }, { double, double }* %177, i32 0, i32 0
%1149 = getelementptr inbounds { double, double }, { double, double }* %177, i32 0, i32 1
store double 0.000000e+00, double* %1148
store double 0x7FEFFFFFFFFFFFFF, double* %1149
%1150 = getelementptr inbounds { double, double }, { double, double }* %177, i32 0, i32 0
%1151 = load double, double* %1150
%1152 = getelementptr inbounds { double, double }, { double, double }* %177, i32 0, i32 1
%1153 = load double, double* %1152
%1154 = getelementptr inbounds { double, double }, { double, double }* %178, i32 0, i32 0
%1155 = getelementptr inbounds { double, double }, { double, double }* %178, i32 0, i32 1
store double -3.500000e+00, double* %1154
store double 0.000000e+00, double* %1155
%1156 = getelementptr inbounds { double, double }, { double, double }* %178, i32 0, i32 0
%1157 = load double, double* %1156
%1158 = getelementptr inbounds { double, double }, { double, double }* %178, i32 0, i32 1
%1159 = load double, double* %1158
%1160 = call { double, double } @cpow(double %1151, double %1153, double %1157, double %1159)
%1161 = extractvalue { double, double } %1160, 0
%1162 = extractvalue { double, double } %1160, 1
%1163 = getelementptr inbounds { double, double }, { double, double }* %179, i32 0, i32 0
%1164 = getelementptr inbounds { double, double }, { double, double }* %179, i32 0, i32 1
store double %1161, double* %1163
store double %1162, double* %1164
%1165 = getelementptr inbounds { double, double }, { double, double }* %179, i32 0, i32 0
%1166 = load double, double* %1165
%1167 = getelementptr inbounds { double, double }, { double, double }* %179, i32 0, i32 1
%1168 = load double, double* %1167
%1169 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1166, double %1168)
%1170 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %180, i32 0, i32 0
%1171 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %180, i32 0, i32 1
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %1170
store x86_fp80 0xK00000000000000000000, x86_fp80* %1171
%1172 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %181, i32 0, i32 0
%1173 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %181, i32 0, i32 1
store x86_fp80 0xKC000E000000000000000, x86_fp80* %1172
store x86_fp80 0xK00000000000000000000, x86_fp80* %1173
%1174 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %180, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %181)
%1175 = extractvalue { x86_fp80, x86_fp80 } %1174, 0
%1176 = extractvalue { x86_fp80, x86_fp80 } %1174, 1
%1177 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %182, i32 0, i32 0
%1178 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %182, i32 0, i32 1
store x86_fp80 %1175, x86_fp80* %1177
store x86_fp80 %1176, x86_fp80* %1178
%1179 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %182)
%1180 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %183, i32 0, i32 0
%1181 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %183, i32 0, i32 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %1180
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %1181
%1182 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %184, i32 0, i32 0
%1183 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %184, i32 0, i32 1
store x86_fp80 0xKC000E000000000000000, x86_fp80* %1182
store x86_fp80 0xK00000000000000000000, x86_fp80* %1183
%1184 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %183, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %184)
%1185 = extractvalue { x86_fp80, x86_fp80 } %1184, 0
%1186 = extractvalue { x86_fp80, x86_fp80 } %1184, 1
%1187 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %185, i32 0, i32 0
%1188 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %185, i32 0, i32 1
store x86_fp80 %1185, x86_fp80* %1187
store x86_fp80 %1186, x86_fp80* %1188
%1189 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %185)
br label %1190
1190: ; preds = %1087
%1191 = getelementptr inbounds { float, float }, { float, float }* %186, i32 0, i32 0
%1192 = getelementptr inbounds { float, float }, { float, float }* %186, i32 0, i32 1
store float 2.000000e+00, float* %1191
store float 0.000000e+00, float* %1192
%1193 = bitcast { float, float }* %186 to <2 x float>*
%1194 = load <2 x float>, <2 x float>* %1193
%1195 = getelementptr inbounds { float, float }, { float, float }* %187, i32 0, i32 0
%1196 = getelementptr inbounds { float, float }, { float, float }* %187, i32 0, i32 1
store float 0xC310000000000000, float* %1195
store float 0.000000e+00, float* %1196
%1197 = bitcast { float, float }* %187 to <2 x float>*
%1198 = load <2 x float>, <2 x float>* %1197
%1199 = call <2 x float> @cpowf(<2 x float> %1194, <2 x float> %1198)
%1200 = bitcast { float, float }* %188 to <2 x float>*
store <2 x float> %1199, <2 x float>* %1200
%1201 = getelementptr inbounds { float, float }, { float, float }* %188, i32 0, i32 0
%1202 = load float, float* %1201
%1203 = getelementptr inbounds { float, float }, { float, float }* %188, i32 0, i32 1
%1204 = load float, float* %1203
%1205 = getelementptr inbounds { float, float }, { float, float }* %189, i32 0, i32 0
%1206 = getelementptr inbounds { float, float }, { float, float }* %189, i32 0, i32 1
store float %1202, float* %1205
store float %1204, float* %1206
%1207 = bitcast { float, float }* %189 to <2 x float>*
%1208 = load <2 x float>, <2 x float>* %1207
%1209 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1208)
%1210 = getelementptr inbounds { double, double }, { double, double }* %190, i32 0, i32 0
%1211 = getelementptr inbounds { double, double }, { double, double }* %190, i32 0, i32 1
store double 2.000000e+00, double* %1210
store double 0.000000e+00, double* %1211
%1212 = getelementptr inbounds { double, double }, { double, double }* %190, i32 0, i32 0
%1213 = load double, double* %1212
%1214 = getelementptr inbounds { double, double }, { double, double }* %190, i32 0, i32 1
%1215 = load double, double* %1214
%1216 = getelementptr inbounds { double, double }, { double, double }* %191, i32 0, i32 0
%1217 = getelementptr inbounds { double, double }, { double, double }* %191, i32 0, i32 1
store double 0xC310000000000000, double* %1216
store double 0.000000e+00, double* %1217
%1218 = getelementptr inbounds { double, double }, { double, double }* %191, i32 0, i32 0
%1219 = load double, double* %1218
%1220 = getelementptr inbounds { double, double }, { double, double }* %191, i32 0, i32 1
%1221 = load double, double* %1220
%1222 = call { double, double } @cpow(double %1213, double %1215, double %1219, double %1221)
%1223 = extractvalue { double, double } %1222, 0
%1224 = extractvalue { double, double } %1222, 1
%1225 = getelementptr inbounds { double, double }, { double, double }* %192, i32 0, i32 0
%1226 = getelementptr inbounds { double, double }, { double, double }* %192, i32 0, i32 1
store double %1223, double* %1225
store double %1224, double* %1226
%1227 = getelementptr inbounds { double, double }, { double, double }* %192, i32 0, i32 0
%1228 = load double, double* %1227
%1229 = getelementptr inbounds { double, double }, { double, double }* %192, i32 0, i32 1
%1230 = load double, double* %1229
%1231 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1228, double %1230)
%1232 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %193, i32 0, i32 0
%1233 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %193, i32 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %1232
store x86_fp80 0xK00000000000000000000, x86_fp80* %1233
%1234 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %194, i32 0, i32 0
%1235 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %194, i32 0, i32 1
store x86_fp80 0xKC0318000000000000000, x86_fp80* %1234
store x86_fp80 0xK00000000000000000000, x86_fp80* %1235
%1236 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %193, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %194)
%1237 = extractvalue { x86_fp80, x86_fp80 } %1236, 0
%1238 = extractvalue { x86_fp80, x86_fp80 } %1236, 1
%1239 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %195, i32 0, i32 0
%1240 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %195, i32 0, i32 1
store x86_fp80 %1237, x86_fp80* %1239
store x86_fp80 %1238, x86_fp80* %1240
%1241 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %195)
br label %1242
1242: ; preds = %1190
br label %1243
1243: ; preds = %1242
%1244 = getelementptr inbounds { float, float }, { float, float }* %196, i32 0, i32 0
%1245 = getelementptr inbounds { float, float }, { float, float }* %196, i32 0, i32 1
store float 2.000000e+00, float* %1244
store float 0.000000e+00, float* %1245
%1246 = bitcast { float, float }* %196 to <2 x float>*
%1247 = load <2 x float>, <2 x float>* %1246
%1248 = getelementptr inbounds { float, float }, { float, float }* %197, i32 0, i32 0
%1249 = getelementptr inbounds { float, float }, { float, float }* %197, i32 0, i32 1
store float 0xC1B0000000000000, float* %1248
store float 0.000000e+00, float* %1249
%1250 = bitcast { float, float }* %197 to <2 x float>*
%1251 = load <2 x float>, <2 x float>* %1250
%1252 = call <2 x float> @cpowf(<2 x float> %1247, <2 x float> %1251)
%1253 = bitcast { float, float }* %198 to <2 x float>*
store <2 x float> %1252, <2 x float>* %1253
%1254 = getelementptr inbounds { float, float }, { float, float }* %198, i32 0, i32 0
%1255 = load float, float* %1254
%1256 = getelementptr inbounds { float, float }, { float, float }* %198, i32 0, i32 1
%1257 = load float, float* %1256
%1258 = getelementptr inbounds { float, float }, { float, float }* %199, i32 0, i32 0
%1259 = getelementptr inbounds { float, float }, { float, float }* %199, i32 0, i32 1
store float %1255, float* %1258
store float %1257, float* %1259
%1260 = bitcast { float, float }* %199 to <2 x float>*
%1261 = load <2 x float>, <2 x float>* %1260
%1262 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1261)
%1263 = getelementptr inbounds { double, double }, { double, double }* %200, i32 0, i32 0
%1264 = getelementptr inbounds { double, double }, { double, double }* %200, i32 0, i32 1
store double 2.000000e+00, double* %1263
store double 0.000000e+00, double* %1264
%1265 = getelementptr inbounds { double, double }, { double, double }* %200, i32 0, i32 0
%1266 = load double, double* %1265
%1267 = getelementptr inbounds { double, double }, { double, double }* %200, i32 0, i32 1
%1268 = load double, double* %1267
%1269 = getelementptr inbounds { double, double }, { double, double }* %201, i32 0, i32 0
%1270 = getelementptr inbounds { double, double }, { double, double }* %201, i32 0, i32 1
store double 0xC1B0000000000000, double* %1269
store double 0.000000e+00, double* %1270
%1271 = getelementptr inbounds { double, double }, { double, double }* %201, i32 0, i32 0
%1272 = load double, double* %1271
%1273 = getelementptr inbounds { double, double }, { double, double }* %201, i32 0, i32 1
%1274 = load double, double* %1273
%1275 = call { double, double } @cpow(double %1266, double %1268, double %1272, double %1274)
%1276 = extractvalue { double, double } %1275, 0
%1277 = extractvalue { double, double } %1275, 1
%1278 = getelementptr inbounds { double, double }, { double, double }* %202, i32 0, i32 0
%1279 = getelementptr inbounds { double, double }, { double, double }* %202, i32 0, i32 1
store double %1276, double* %1278
store double %1277, double* %1279
%1280 = getelementptr inbounds { double, double }, { double, double }* %202, i32 0, i32 0
%1281 = load double, double* %1280
%1282 = getelementptr inbounds { double, double }, { double, double }* %202, i32 0, i32 1
%1283 = load double, double* %1282
%1284 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1281, double %1283)
%1285 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %203, i32 0, i32 0
%1286 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %203, i32 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %1285
store x86_fp80 0xK00000000000000000000, x86_fp80* %1286
%1287 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %204, i32 0, i32 0
%1288 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %204, i32 0, i32 1
store x86_fp80 0xKC01B8000000000000000, x86_fp80* %1287
store x86_fp80 0xK00000000000000000000, x86_fp80* %1288
%1289 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %203, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %204)
%1290 = extractvalue { x86_fp80, x86_fp80 } %1289, 0
%1291 = extractvalue { x86_fp80, x86_fp80 } %1289, 1
%1292 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %205, i32 0, i32 0
%1293 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %205, i32 0, i32 1
store x86_fp80 %1290, x86_fp80* %1292
store x86_fp80 %1291, x86_fp80* %1293
%1294 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %205)
br label %1295
1295: ; preds = %1243
br label %1296
1296: ; preds = %1295
%1297 = getelementptr inbounds { float, float }, { float, float }* %206, i32 0, i32 0
%1298 = getelementptr inbounds { float, float }, { float, float }* %206, i32 0, i32 1
store float 2.000000e+00, float* %1297
store float 0.000000e+00, float* %1298
%1299 = bitcast { float, float }* %206 to <2 x float>*
%1300 = load <2 x float>, <2 x float>* %1299
%1301 = getelementptr inbounds { float, float }, { float, float }* %207, i32 0, i32 0
%1302 = getelementptr inbounds { float, float }, { float, float }* %207, i32 0, i32 1
store float 0xC170000000000000, float* %1301
store float 0.000000e+00, float* %1302
%1303 = bitcast { float, float }* %207 to <2 x float>*
%1304 = load <2 x float>, <2 x float>* %1303
%1305 = call <2 x float> @cpowf(<2 x float> %1300, <2 x float> %1304)
%1306 = bitcast { float, float }* %208 to <2 x float>*
store <2 x float> %1305, <2 x float>* %1306
%1307 = getelementptr inbounds { float, float }, { float, float }* %208, i32 0, i32 0
%1308 = load float, float* %1307
%1309 = getelementptr inbounds { float, float }, { float, float }* %208, i32 0, i32 1
%1310 = load float, float* %1309
%1311 = getelementptr inbounds { float, float }, { float, float }* %209, i32 0, i32 0
%1312 = getelementptr inbounds { float, float }, { float, float }* %209, i32 0, i32 1
store float %1308, float* %1311
store float %1310, float* %1312
%1313 = bitcast { float, float }* %209 to <2 x float>*
%1314 = load <2 x float>, <2 x float>* %1313
%1315 = call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %1314)
%1316 = getelementptr inbounds { double, double }, { double, double }* %210, i32 0, i32 0
%1317 = getelementptr inbounds { double, double }, { double, double }* %210, i32 0, i32 1
store double 2.000000e+00, double* %1316
store double 0.000000e+00, double* %1317
%1318 = getelementptr inbounds { double, double }, { double, double }* %210, i32 0, i32 0
%1319 = load double, double* %1318
%1320 = getelementptr inbounds { double, double }, { double, double }* %210, i32 0, i32 1
%1321 = load double, double* %1320
%1322 = getelementptr inbounds { double, double }, { double, double }* %211, i32 0, i32 0
%1323 = getelementptr inbounds { double, double }, { double, double }* %211, i32 0, i32 1
store double 0xC170000000000000, double* %1322
store double 0.000000e+00, double* %1323
%1324 = getelementptr inbounds { double, double }, { double, double }* %211, i32 0, i32 0
%1325 = load double, double* %1324
%1326 = getelementptr inbounds { double, double }, { double, double }* %211, i32 0, i32 1
%1327 = load double, double* %1326
%1328 = call { double, double } @cpow(double %1319, double %1321, double %1325, double %1327)
%1329 = extractvalue { double, double } %1328, 0
%1330 = extractvalue { double, double } %1328, 1
%1331 = getelementptr inbounds { double, double }, { double, double }* %212, i32 0, i32 0
%1332 = getelementptr inbounds { double, double }, { double, double }* %212, i32 0, i32 1
store double %1329, double* %1331
store double %1330, double* %1332
%1333 = getelementptr inbounds { double, double }, { double, double }* %212, i32 0, i32 0
%1334 = load double, double* %1333
%1335 = getelementptr inbounds { double, double }, { double, double }* %212, i32 0, i32 1
%1336 = load double, double* %1335
%1337 = call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %1334, double %1336)
%1338 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %213, i32 0, i32 0
%1339 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %213, i32 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %1338
store x86_fp80 0xK00000000000000000000, x86_fp80* %1339
%1340 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %214, i32 0, i32 0
%1341 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %214, i32 0, i32 1
store x86_fp80 0xKC0178000000000000000, x86_fp80* %1340
store x86_fp80 0xK00000000000000000000, x86_fp80* %1341
%1342 = call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %213, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %214)
%1343 = extractvalue { x86_fp80, x86_fp80 } %1342, 0
%1344 = extractvalue { x86_fp80, x86_fp80 } %1342, 1
%1345 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %215, i32 0, i32 0
%1346 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %215, i32 0, i32 1
store x86_fp80 %1343, x86_fp80* %1345
store x86_fp80 %1344, x86_fp80* %1346
%1347 = call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %215)
br label %1348
1348: ; preds = %1296
ret void
}

LLVM IR (-O2):
define void @bar() {
%1 = alloca { x86_fp80, x86_fp80 }
%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 = alloca { x86_fp80, x86_fp80 }
%23 = alloca { x86_fp80, x86_fp80 }
%24 = alloca { x86_fp80, x86_fp80 }
%25 = alloca { x86_fp80, x86_fp80 }
%26 = alloca { x86_fp80, x86_fp80 }
%27 = alloca { x86_fp80, x86_fp80 }
%28 = alloca { x86_fp80, x86_fp80 }
%29 = alloca { x86_fp80, x86_fp80 }
%30 = alloca { x86_fp80, x86_fp80 }
%31 = alloca { x86_fp80, x86_fp80 }
%32 = alloca { x86_fp80, x86_fp80 }
%33 = alloca { x86_fp80, x86_fp80 }
%34 = alloca { x86_fp80, x86_fp80 }
%35 = alloca { x86_fp80, x86_fp80 }
%36 = alloca { x86_fp80, x86_fp80 }
%37 = alloca { x86_fp80, x86_fp80 }
%38 = alloca { x86_fp80, x86_fp80 }
%39 = alloca { x86_fp80, x86_fp80 }
%40 = alloca { x86_fp80, x86_fp80 }
%41 = alloca { x86_fp80, x86_fp80 }
%42 = alloca { x86_fp80, x86_fp80 }
%43 = alloca { x86_fp80, x86_fp80 }
%44 = alloca { x86_fp80, x86_fp80 }
%45 = alloca { x86_fp80, x86_fp80 }
%46 = alloca { x86_fp80, x86_fp80 }
%47 = alloca { x86_fp80, x86_fp80 }
%48 = alloca { x86_fp80, x86_fp80 }
%49 = alloca { x86_fp80, x86_fp80 }
%50 = alloca { x86_fp80, x86_fp80 }
%51 = alloca { x86_fp80, x86_fp80 }
%52 = alloca { x86_fp80, x86_fp80 }
%53 = alloca { x86_fp80, x86_fp80 }
%54 = alloca { x86_fp80, x86_fp80 }
%55 = alloca { x86_fp80, x86_fp80 }
%56 = alloca { x86_fp80, x86_fp80 }
%57 = alloca { x86_fp80, x86_fp80 }
%58 = alloca { x86_fp80, x86_fp80 }
%59 = alloca { x86_fp80, x86_fp80 }
%60 = alloca { x86_fp80, x86_fp80 }
%61 = alloca { x86_fp80, x86_fp80 }
%62 = alloca { x86_fp80, x86_fp80 }
%63 = alloca { x86_fp80, x86_fp80 }
%64 = alloca { x86_fp80, x86_fp80 }
%65 = tail call <2 x float> @csqrtf(<2 x float> <float 0x7FF8000000000000, float 0.000000e+00>)
%66 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %65)
%67 = tail call { double, double } @csqrt(double 0x7FF8000000000000, double 0.000000e+00)
%68 = extractvalue { double, double } %67, 0
%69 = extractvalue { double, double } %67, 1
%70 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %68, double %69)
%71 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %1, i64 0, i32 0
%72 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %1, i64 0, i32 1
store x86_fp80 0xK7FFFC000000000000000, x86_fp80* %71
store x86_fp80 0xK00000000000000000000, x86_fp80* %72
%73 = tail call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %1)
%74 = extractvalue { x86_fp80, x86_fp80 } %73, 0
%75 = extractvalue { x86_fp80, x86_fp80 } %73, 1
%76 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %2, i64 0, i32 0
%77 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %2, i64 0, i32 1
store x86_fp80 %74, x86_fp80* %76
store x86_fp80 %75, x86_fp80* %77
%78 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %2)
%79 = tail call <2 x float> @csqrtf(<2 x float> <float 0x7FF0000000000000, float 0.000000e+00>)
%80 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %79)
%81 = tail call { double, double } @csqrt(double 0x7FF0000000000000, double 0.000000e+00)
%82 = extractvalue { double, double } %81, 0
%83 = extractvalue { double, double } %81, 1
%84 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %82, double %83)
%85 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %3, i64 0, i32 0
%86 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %3, i64 0, i32 1
store x86_fp80 0xK7FFF8000000000000000, x86_fp80* %85
store x86_fp80 0xK00000000000000000000, x86_fp80* %86
%87 = tail call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %3)
%88 = extractvalue { x86_fp80, x86_fp80 } %87, 0
%89 = extractvalue { x86_fp80, x86_fp80 } %87, 1
%90 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %4, i64 0, i32 0
%91 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %4, i64 0, i32 1
store x86_fp80 %88, x86_fp80* %90
store x86_fp80 %89, x86_fp80* %91
%92 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %4)
%93 = tail call <2 x float> @csqrtf(<2 x float> <float 0xFFF0000000000000, float 0.000000e+00>)
%94 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %93)
%95 = tail call { double, double } @csqrt(double 0xFFF0000000000000, double 0.000000e+00)
%96 = extractvalue { double, double } %95, 0
%97 = extractvalue { double, double } %95, 1
%98 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %96, double %97)
%99 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %5, i64 0, i32 0
%100 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %5, i64 0, i32 1
store x86_fp80 0xKFFFF8000000000000000, x86_fp80* %99
store x86_fp80 0xK00000000000000000000, x86_fp80* %100
%101 = tail call { x86_fp80, x86_fp80 } @csqrtl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %5)
%102 = extractvalue { x86_fp80, x86_fp80 } %101, 0
%103 = extractvalue { x86_fp80, x86_fp80 } %101, 1
%104 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %6, i64 0, i32 0
%105 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %6, i64 0, i32 1
store x86_fp80 %102, x86_fp80* %104
store x86_fp80 %103, x86_fp80* %105
%106 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %6)
%107 = tail call <2 x float> @cexpf(<2 x float> <float 0x4415AF1D80000000, float 0.000000e+00>)
%108 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %107)
%109 = tail call { double, double } @cexp(double 1.000000e+20, double 0.000000e+00)
%110 = extractvalue { double, double } %109, 0
%111 = extractvalue { double, double } %109, 1
%112 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %110, double %111)
%113 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %7, i64 0, i32 0
%114 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %7, i64 0, i32 1
store x86_fp80 0xK4041AD78EBC5AC620000, x86_fp80* %113
store x86_fp80 0xK00000000000000000000, x86_fp80* %114
%115 = tail call { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %7)
%116 = extractvalue { x86_fp80, x86_fp80 } %115, 0
%117 = extractvalue { x86_fp80, x86_fp80 } %115, 1
%118 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %8, i64 0, i32 0
%119 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %8, i64 0, i32 1
store x86_fp80 %116, x86_fp80* %118
store x86_fp80 %117, x86_fp80* %119
%120 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %8)
%121 = tail call <2 x float> @cexpf(<2 x float> <float 0xC415AF1D80000000, float 0.000000e+00>)
%122 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %121)
%123 = tail call { double, double } @cexp(double -1.000000e+20, double 0.000000e+00)
%124 = extractvalue { double, double } %123, 0
%125 = extractvalue { double, double } %123, 1
%126 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %124, double %125)
%127 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %9, i64 0, i32 0
%128 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %9, i64 0, i32 1
store x86_fp80 0xKC041AD78EBC5AC620000, x86_fp80* %127
store x86_fp80 0xK00000000000000000000, x86_fp80* %128
%129 = tail call { x86_fp80, x86_fp80 } @cexpl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %9)
%130 = extractvalue { x86_fp80, x86_fp80 } %129, 0
%131 = extractvalue { x86_fp80, x86_fp80 } %129, 1
%132 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %10, i64 0, i32 0
%133 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %10, i64 0, i32 1
store x86_fp80 %130, x86_fp80* %132
store x86_fp80 %131, x86_fp80* %133
%134 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %10)
%135 = tail call <2 x float> @cpowf(<2 x float> <float 0x7FF8000000000000, float 0.000000e+00>, <2 x float> <float 2.500000e+00, float 0.000000e+00>)
%136 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %135)
%137 = tail call { double, double } @cpow(double 0x7FF8000000000000, double 0.000000e+00, double 2.500000e+00, double 0.000000e+00)
%138 = extractvalue { double, double } %137, 0
%139 = extractvalue { double, double } %137, 1
%140 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %138, double %139)
%141 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %11, i64 0, i32 0
%142 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %11, i64 0, i32 1
store x86_fp80 0xK7FFFC000000000000000, x86_fp80* %141
store x86_fp80 0xK00000000000000000000, x86_fp80* %142
%143 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %12, i64 0, i32 0
%144 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %12, i64 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %143
store x86_fp80 0xK00000000000000000000, x86_fp80* %144
%145 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %11, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %12)
%146 = extractvalue { x86_fp80, x86_fp80 } %145, 0
%147 = extractvalue { x86_fp80, x86_fp80 } %145, 1
%148 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i64 0, i32 0
%149 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %13, i64 0, i32 1
store x86_fp80 %146, x86_fp80* %148
store x86_fp80 %147, x86_fp80* %149
%150 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %13)
%151 = tail call <2 x float> @cpowf(<2 x float> <float 2.500000e+00, float 0.000000e+00>, <2 x float> <float 0x7FF8000000000000, float 0.000000e+00>)
%152 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %151)
%153 = tail call { double, double } @cpow(double 2.500000e+00, double 0.000000e+00, double 0x7FF8000000000000, double 0.000000e+00)
%154 = extractvalue { double, double } %153, 0
%155 = extractvalue { double, double } %153, 1
%156 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %154, double %155)
%157 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %14, i64 0, i32 0
%158 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %14, i64 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %157
store x86_fp80 0xK00000000000000000000, x86_fp80* %158
%159 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %15, i64 0, i32 0
%160 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %15, i64 0, i32 1
store x86_fp80 0xK7FFFC000000000000000, x86_fp80* %159
store x86_fp80 0xK00000000000000000000, x86_fp80* %160
%161 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %14, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %15)
%162 = extractvalue { x86_fp80, x86_fp80 } %161, 0
%163 = extractvalue { x86_fp80, x86_fp80 } %161, 1
%164 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %16, i64 0, i32 0
%165 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %16, i64 0, i32 1
store x86_fp80 %162, x86_fp80* %164
store x86_fp80 %163, x86_fp80* %165
%166 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %16)
%167 = tail call <2 x float> @cpowf(<2 x float> <float 0x7FF0000000000000, float 0.000000e+00>, <2 x float> <float 2.500000e+00, float 0.000000e+00>)
%168 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %167)
%169 = tail call { double, double } @cpow(double 0x7FF0000000000000, double 0.000000e+00, double 2.500000e+00, double 0.000000e+00)
%170 = extractvalue { double, double } %169, 0
%171 = extractvalue { double, double } %169, 1
%172 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %170, double %171)
%173 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %17, i64 0, i32 0
%174 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %17, i64 0, i32 1
store x86_fp80 0xK7FFF8000000000000000, x86_fp80* %173
store x86_fp80 0xK00000000000000000000, x86_fp80* %174
%175 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %18, i64 0, i32 0
%176 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %18, i64 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %175
store x86_fp80 0xK00000000000000000000, x86_fp80* %176
%177 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %17, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %18)
%178 = extractvalue { x86_fp80, x86_fp80 } %177, 0
%179 = extractvalue { x86_fp80, x86_fp80 } %177, 1
%180 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %19, i64 0, i32 0
%181 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %19, i64 0, i32 1
store x86_fp80 %178, x86_fp80* %180
store x86_fp80 %179, x86_fp80* %181
%182 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %19)
%183 = tail call <2 x float> @cpowf(<2 x float> <float 0xFFF0000000000000, float 0.000000e+00>, <2 x float> <float 2.500000e+00, float 0.000000e+00>)
%184 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %183)
%185 = tail call { double, double } @cpow(double 0xFFF0000000000000, double 0.000000e+00, double 2.500000e+00, double 0.000000e+00)
%186 = extractvalue { double, double } %185, 0
%187 = extractvalue { double, double } %185, 1
%188 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %186, double %187)
%189 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i64 0, i32 0
%190 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %20, i64 0, i32 1
store x86_fp80 0xKFFFF8000000000000000, x86_fp80* %189
store x86_fp80 0xK00000000000000000000, x86_fp80* %190
%191 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %21, i64 0, i32 0
%192 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %21, i64 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %191
store x86_fp80 0xK00000000000000000000, x86_fp80* %192
%193 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %20, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %21)
%194 = extractvalue { x86_fp80, x86_fp80 } %193, 0
%195 = extractvalue { x86_fp80, x86_fp80 } %193, 1
%196 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %22, i64 0, i32 0
%197 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %22, i64 0, i32 1
store x86_fp80 %194, x86_fp80* %196
store x86_fp80 %195, x86_fp80* %197
%198 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %22)
%199 = tail call <2 x float> @cpowf(<2 x float> <float 2.500000e+00, float 0.000000e+00>, <2 x float> <float 0x7FF0000000000000, float 0.000000e+00>)
%200 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %199)
%201 = tail call { double, double } @cpow(double 2.500000e+00, double 0.000000e+00, double 0x7FF0000000000000, double 0.000000e+00)
%202 = extractvalue { double, double } %201, 0
%203 = extractvalue { double, double } %201, 1
%204 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %202, double %203)
%205 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %23, i64 0, i32 0
%206 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %23, i64 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %205
store x86_fp80 0xK00000000000000000000, x86_fp80* %206
%207 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %24, i64 0, i32 0
%208 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %24, i64 0, i32 1
store x86_fp80 0xK7FFF8000000000000000, x86_fp80* %207
store x86_fp80 0xK00000000000000000000, x86_fp80* %208
%209 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %23, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %24)
%210 = extractvalue { x86_fp80, x86_fp80 } %209, 0
%211 = extractvalue { x86_fp80, x86_fp80 } %209, 1
%212 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %25, i64 0, i32 0
%213 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %25, i64 0, i32 1
store x86_fp80 %210, x86_fp80* %212
store x86_fp80 %211, x86_fp80* %213
%214 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %25)
%215 = tail call <2 x float> @cpowf(<2 x float> <float 2.500000e+00, float 0.000000e+00>, <2 x float> <float 0xFFF0000000000000, float 0.000000e+00>)
%216 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %215)
%217 = tail call { double, double } @cpow(double 2.500000e+00, double 0.000000e+00, double 0xFFF0000000000000, double 0.000000e+00)
%218 = extractvalue { double, double } %217, 0
%219 = extractvalue { double, double } %217, 1
%220 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %218, double %219)
%221 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %26, i64 0, i32 0
%222 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %26, i64 0, i32 1
store x86_fp80 0xK4000A000000000000000, x86_fp80* %221
store x86_fp80 0xK00000000000000000000, x86_fp80* %222
%223 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %27, i64 0, i32 0
%224 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %27, i64 0, i32 1
store x86_fp80 0xKFFFF8000000000000000, x86_fp80* %223
store x86_fp80 0xK00000000000000000000, x86_fp80* %224
%225 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %26, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %27)
%226 = extractvalue { x86_fp80, x86_fp80 } %225, 0
%227 = extractvalue { x86_fp80, x86_fp80 } %225, 1
%228 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %28, i64 0, i32 0
%229 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %28, i64 0, i32 1
store x86_fp80 %226, x86_fp80* %228
store x86_fp80 %227, x86_fp80* %229
%230 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %28)
%231 = tail call <2 x float> @cpowf(<2 x float> <float -0.000000e+00, float 0.000000e+00>, <2 x float> <float -4.500000e+00, float 0.000000e+00>)
%232 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %231)
%233 = tail call { double, double } @cpow(double -0.000000e+00, double 0.000000e+00, double -4.500000e+00, double 0.000000e+00)
%234 = extractvalue { double, double } %233, 0
%235 = extractvalue { double, double } %233, 1
%236 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %234, double %235)
%237 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %29, i64 0, i32 0
%238 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %29, i64 0, i32 1
store x86_fp80 0xK80000000000000000000, x86_fp80* %237
store x86_fp80 0xK00000000000000000000, x86_fp80* %238
%239 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %30, i64 0, i32 0
%240 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %30, i64 0, i32 1
store x86_fp80 0xKC0019000000000000000, x86_fp80* %239
store x86_fp80 0xK00000000000000000000, x86_fp80* %240
%241 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %29, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %30)
%242 = extractvalue { x86_fp80, x86_fp80 } %241, 0
%243 = extractvalue { x86_fp80, x86_fp80 } %241, 1
%244 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %31, i64 0, i32 0
%245 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %31, i64 0, i32 1
store x86_fp80 %242, x86_fp80* %244
store x86_fp80 %243, x86_fp80* %245
%246 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %31)
%247 = tail call <2 x float> @cpowf(<2 x float> zeroinitializer, <2 x float> <float -4.500000e+00, float 0.000000e+00>)
%248 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %247)
%249 = tail call { double, double } @cpow(double 0.000000e+00, double 0.000000e+00, double -4.500000e+00, double 0.000000e+00)
%250 = extractvalue { double, double } %249, 0
%251 = extractvalue { double, double } %249, 1
%252 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %250, double %251)
%253 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %32, i64 0, i32 0
%254 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %32, i64 0, i32 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %253
store x86_fp80 0xK00000000000000000000, x86_fp80* %254
%255 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %33, i64 0, i32 0
%256 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %33, i64 0, i32 1
store x86_fp80 0xKC0019000000000000000, x86_fp80* %255
store x86_fp80 0xK00000000000000000000, x86_fp80* %256
%257 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %32, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %33)
%258 = extractvalue { x86_fp80, x86_fp80 } %257, 0
%259 = extractvalue { x86_fp80, x86_fp80 } %257, 1
%260 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %34, i64 0, i32 0
%261 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %34, i64 0, i32 1
store x86_fp80 %258, x86_fp80* %260
store x86_fp80 %259, x86_fp80* %261
%262 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %34)
%263 = tail call <2 x float> @cpowf(<2 x float> <float 0x47EFFFFFE0000000, float 0.000000e+00>, <2 x float> <float 3.500000e+00, float 0.000000e+00>)
%264 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %263)
%265 = tail call <2 x float> @cpowf(<2 x float> <float 0.000000e+00, float 0x47EFFFFFE0000000>, <2 x float> <float 3.500000e+00, float 0.000000e+00>)
%266 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %265)
%267 = tail call { double, double } @cpow(double 0x7FEFFFFFFFFFFFFF, double 0.000000e+00, double 3.500000e+00, double 0.000000e+00)
%268 = extractvalue { double, double } %267, 0
%269 = extractvalue { double, double } %267, 1
%270 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %268, double %269)
%271 = tail call { double, double } @cpow(double 0.000000e+00, double 0x7FEFFFFFFFFFFFFF, double 3.500000e+00, double 0.000000e+00)
%272 = extractvalue { double, double } %271, 0
%273 = extractvalue { double, double } %271, 1
%274 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %272, double %273)
%275 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %35, i64 0, i32 0
%276 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %35, i64 0, i32 1
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %275
store x86_fp80 0xK00000000000000000000, x86_fp80* %276
%277 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %36, i64 0, i32 0
%278 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %36, i64 0, i32 1
store x86_fp80 0xK4000E000000000000000, x86_fp80* %277
store x86_fp80 0xK00000000000000000000, x86_fp80* %278
%279 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %35, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %36)
%280 = extractvalue { x86_fp80, x86_fp80 } %279, 0
%281 = extractvalue { x86_fp80, x86_fp80 } %279, 1
%282 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %37, i64 0, i32 0
%283 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %37, i64 0, i32 1
store x86_fp80 %280, x86_fp80* %282
store x86_fp80 %281, x86_fp80* %283
%284 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %37)
%285 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %38, i64 0, i32 0
%286 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %38, i64 0, i32 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %285
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %286
%287 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %39, i64 0, i32 0
%288 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %39, i64 0, i32 1
store x86_fp80 0xK4000E000000000000000, x86_fp80* %287
store x86_fp80 0xK00000000000000000000, x86_fp80* %288
%289 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %38, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %39)
%290 = extractvalue { x86_fp80, x86_fp80 } %289, 0
%291 = extractvalue { x86_fp80, x86_fp80 } %289, 1
%292 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %40, i64 0, i32 0
%293 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %40, i64 0, i32 1
store x86_fp80 %290, x86_fp80* %292
store x86_fp80 %291, x86_fp80* %293
%294 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %40)
%295 = tail call <2 x float> @cpowf(<2 x float> <float 2.000000e+00, float 0.000000e+00>, <2 x float> <float 0x4310000000000000, float 0.000000e+00>)
%296 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %295)
%297 = tail call { double, double } @cpow(double 2.000000e+00, double 0.000000e+00, double 0x4310000000000000, double 0.000000e+00)
%298 = extractvalue { double, double } %297, 0
%299 = extractvalue { double, double } %297, 1
%300 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %298, double %299)
%301 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %41, i64 0, i32 0
%302 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %41, i64 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %301
store x86_fp80 0xK00000000000000000000, x86_fp80* %302
%303 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %42, i64 0, i32 0
%304 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %42, i64 0, i32 1
store x86_fp80 0xK40318000000000000000, x86_fp80* %303
store x86_fp80 0xK00000000000000000000, x86_fp80* %304
%305 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %41, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %42)
%306 = extractvalue { x86_fp80, x86_fp80 } %305, 0
%307 = extractvalue { x86_fp80, x86_fp80 } %305, 1
%308 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %43, i64 0, i32 0
%309 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %43, i64 0, i32 1
store x86_fp80 %306, x86_fp80* %308
store x86_fp80 %307, x86_fp80* %309
%310 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %43)
%311 = tail call <2 x float> @cpowf(<2 x float> <float 2.000000e+00, float 0.000000e+00>, <2 x float> <float 0x41B0000000000000, float 0.000000e+00>)
%312 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %311)
%313 = tail call { double, double } @cpow(double 2.000000e+00, double 0.000000e+00, double 0x41B0000000000000, double 0.000000e+00)
%314 = extractvalue { double, double } %313, 0
%315 = extractvalue { double, double } %313, 1
%316 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %314, double %315)
%317 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %44, i64 0, i32 0
%318 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %44, i64 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %317
store x86_fp80 0xK00000000000000000000, x86_fp80* %318
%319 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %45, i64 0, i32 0
%320 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %45, i64 0, i32 1
store x86_fp80 0xK401B8000000000000000, x86_fp80* %319
store x86_fp80 0xK00000000000000000000, x86_fp80* %320
%321 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %44, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %45)
%322 = extractvalue { x86_fp80, x86_fp80 } %321, 0
%323 = extractvalue { x86_fp80, x86_fp80 } %321, 1
%324 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %46, i64 0, i32 0
%325 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %46, i64 0, i32 1
store x86_fp80 %322, x86_fp80* %324
store x86_fp80 %323, x86_fp80* %325
%326 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %46)
%327 = tail call <2 x float> @cpowf(<2 x float> <float 2.000000e+00, float 0.000000e+00>, <2 x float> <float 0x4170000000000000, float 0.000000e+00>)
%328 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %327)
%329 = tail call { double, double } @cpow(double 2.000000e+00, double 0.000000e+00, double 0x4170000000000000, double 0.000000e+00)
%330 = extractvalue { double, double } %329, 0
%331 = extractvalue { double, double } %329, 1
%332 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %330, double %331)
%333 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %47, i64 0, i32 0
%334 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %47, i64 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %333
store x86_fp80 0xK00000000000000000000, x86_fp80* %334
%335 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %48, i64 0, i32 0
%336 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %48, i64 0, i32 1
store x86_fp80 0xK40178000000000000000, x86_fp80* %335
store x86_fp80 0xK00000000000000000000, x86_fp80* %336
%337 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %47, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %48)
%338 = extractvalue { x86_fp80, x86_fp80 } %337, 0
%339 = extractvalue { x86_fp80, x86_fp80 } %337, 1
%340 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %49, i64 0, i32 0
%341 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %49, i64 0, i32 1
store x86_fp80 %338, x86_fp80* %340
store x86_fp80 %339, x86_fp80* %341
%342 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %49)
%343 = tail call <2 x float> @cpowf(<2 x float> <float 0x47EFFFFFE0000000, float 0.000000e+00>, <2 x float> <float -3.500000e+00, float 0.000000e+00>)
%344 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %343)
%345 = tail call <2 x float> @cpowf(<2 x float> <float 0.000000e+00, float 0x47EFFFFFE0000000>, <2 x float> <float -3.500000e+00, float 0.000000e+00>)
%346 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %345)
%347 = tail call { double, double } @cpow(double 0x7FEFFFFFFFFFFFFF, double 0.000000e+00, double -3.500000e+00, double 0.000000e+00)
%348 = extractvalue { double, double } %347, 0
%349 = extractvalue { double, double } %347, 1
%350 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %348, double %349)
%351 = tail call { double, double } @cpow(double 0.000000e+00, double 0x7FEFFFFFFFFFFFFF, double -3.500000e+00, double 0.000000e+00)
%352 = extractvalue { double, double } %351, 0
%353 = extractvalue { double, double } %351, 1
%354 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %352, double %353)
%355 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %50, i64 0, i32 0
%356 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %50, i64 0, i32 1
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %355
store x86_fp80 0xK00000000000000000000, x86_fp80* %356
%357 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %51, i64 0, i32 0
%358 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %51, i64 0, i32 1
store x86_fp80 0xKC000E000000000000000, x86_fp80* %357
store x86_fp80 0xK00000000000000000000, x86_fp80* %358
%359 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %50, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %51)
%360 = extractvalue { x86_fp80, x86_fp80 } %359, 0
%361 = extractvalue { x86_fp80, x86_fp80 } %359, 1
%362 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %52, i64 0, i32 0
%363 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %52, i64 0, i32 1
store x86_fp80 %360, x86_fp80* %362
store x86_fp80 %361, x86_fp80* %363
%364 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %52)
%365 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %53, i64 0, i32 0
%366 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %53, i64 0, i32 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %365
store x86_fp80 0xK7FFEFFFFFFFFFFFFFFFF, x86_fp80* %366
%367 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %54, i64 0, i32 0
%368 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %54, i64 0, i32 1
store x86_fp80 0xKC000E000000000000000, x86_fp80* %367
store x86_fp80 0xK00000000000000000000, x86_fp80* %368
%369 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %53, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %54)
%370 = extractvalue { x86_fp80, x86_fp80 } %369, 0
%371 = extractvalue { x86_fp80, x86_fp80 } %369, 1
%372 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %55, i64 0, i32 0
%373 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %55, i64 0, i32 1
store x86_fp80 %370, x86_fp80* %372
store x86_fp80 %371, x86_fp80* %373
%374 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %55)
%375 = tail call <2 x float> @cpowf(<2 x float> <float 2.000000e+00, float 0.000000e+00>, <2 x float> <float 0xC310000000000000, float 0.000000e+00>)
%376 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %375)
%377 = tail call { double, double } @cpow(double 2.000000e+00, double 0.000000e+00, double 0xC310000000000000, double 0.000000e+00)
%378 = extractvalue { double, double } %377, 0
%379 = extractvalue { double, double } %377, 1
%380 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %378, double %379)
%381 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %56, i64 0, i32 0
%382 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %56, i64 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %381
store x86_fp80 0xK00000000000000000000, x86_fp80* %382
%383 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %57, i64 0, i32 0
%384 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %57, i64 0, i32 1
store x86_fp80 0xKC0318000000000000000, x86_fp80* %383
store x86_fp80 0xK00000000000000000000, x86_fp80* %384
%385 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %56, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %57)
%386 = extractvalue { x86_fp80, x86_fp80 } %385, 0
%387 = extractvalue { x86_fp80, x86_fp80 } %385, 1
%388 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %58, i64 0, i32 0
%389 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %58, i64 0, i32 1
store x86_fp80 %386, x86_fp80* %388
store x86_fp80 %387, x86_fp80* %389
%390 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %58)
%391 = tail call <2 x float> @cpowf(<2 x float> <float 2.000000e+00, float 0.000000e+00>, <2 x float> <float 0xC1B0000000000000, float 0.000000e+00>)
%392 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %391)
%393 = tail call { double, double } @cpow(double 2.000000e+00, double 0.000000e+00, double 0xC1B0000000000000, double 0.000000e+00)
%394 = extractvalue { double, double } %393, 0
%395 = extractvalue { double, double } %393, 1
%396 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %394, double %395)
%397 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %59, i64 0, i32 0
%398 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %59, i64 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %397
store x86_fp80 0xK00000000000000000000, x86_fp80* %398
%399 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %60, i64 0, i32 0
%400 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %60, i64 0, i32 1
store x86_fp80 0xKC01B8000000000000000, x86_fp80* %399
store x86_fp80 0xK00000000000000000000, x86_fp80* %400
%401 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %59, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %60)
%402 = extractvalue { x86_fp80, x86_fp80 } %401, 0
%403 = extractvalue { x86_fp80, x86_fp80 } %401, 1
%404 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %61, i64 0, i32 0
%405 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %61, i64 0, i32 1
store x86_fp80 %402, x86_fp80* %404
store x86_fp80 %403, x86_fp80* %405
%406 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %61)
%407 = tail call <2 x float> @cpowf(<2 x float> <float 2.000000e+00, float 0.000000e+00>, <2 x float> <float 0xC170000000000000, float 0.000000e+00>)
%408 = tail call i32 (<2 x float>, ...) bitcast (i32 (...)* @foof to i32 (<2 x float>, ...)*)(<2 x float> %407)
%409 = tail call { double, double } @cpow(double 2.000000e+00, double 0.000000e+00, double 0xC170000000000000, double 0.000000e+00)
%410 = extractvalue { double, double } %409, 0
%411 = extractvalue { double, double } %409, 1
%412 = tail call i32 (double, double, ...) bitcast (i32 (...)* @foo to i32 (double, double, ...)*)(double %410, double %411)
%413 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %62, i64 0, i32 0
%414 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %62, i64 0, i32 1
store x86_fp80 0xK40008000000000000000, x86_fp80* %413
store x86_fp80 0xK00000000000000000000, x86_fp80* %414
%415 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %63, i64 0, i32 0
%416 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %63, i64 0, i32 1
store x86_fp80 0xKC0178000000000000000, x86_fp80* %415
store x86_fp80 0xK00000000000000000000, x86_fp80* %416
%417 = tail call { x86_fp80, x86_fp80 } @cpowl({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %62, { x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %63)
%418 = extractvalue { x86_fp80, x86_fp80 } %417, 0
%419 = extractvalue { x86_fp80, x86_fp80 } %417, 1
%420 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %64, i64 0, i32 0
%421 = getelementptr inbounds { x86_fp80, x86_fp80 }, { x86_fp80, x86_fp80 }* %64, i64 0, i32 1
store x86_fp80 %418, x86_fp80* %420
store x86_fp80 %419, x86_fp80* %421
%422 = tail call i32 ({ x86_fp80, x86_fp80 }*, ...) bitcast (i32 (...)* @fool to i32 ({ x86_fp80, x86_fp80 }*, ...)*)({ x86_fp80, x86_fp80 }* byval({ x86_fp80, x86_fp80 }) align 16 %64)
ret void
}