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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ P;

/* Variables and functions */
int /*<<< orphan*/ memset(long double **, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, long);
int main(void) {
  long double T[5];
  long double P[5][5];
  int i, j;
  long double X0, X1, X2, S;
  long double inc = 1. / 64;
  long double D = inc * 0.5;
  long i0, i1, i2;
  memset(P, 0, sizeof(P));
  P[0][0] = 1.;
  for (i = 1; i < 5; i++)
    P[i][i] = 1 << i - 1;
  P[2][0] = -D * D;
  for (X0 = 1.; X0 < 2.; X0 += inc) {
    X1 = X0 + inc * 0.5;
    X2 = X1 + inc;
    S = D / X1;
    T[0] = 1. / X1;
    for (i = 1; i < 5; i++)
      T[i] = T[i - 1] * -T[0];
    P[1][0] = S * D;
    P[2][1] = S * D;
    for (i = 3; i < 5; i++) {
      P[i][0] = -D * D * P[i - 2][0];
      for (j = 1; j < i; j++)
        P[i][j] = 2 * P[i - 1][j - 1] - D * D * P[i - 2][j];
    }
    for (i = 4; i > 1; i--) {
      long double a = T[i] / P[i][i];
      for (j = 0; j < i; j++)
        T[j] -= a * P[i][j];
    }
    i2 = 0;
    for (i = 0, i0 = 0; i < 4; i++) {
      long double T0, Ti1;
      i1 = T[1] * 8192. + i0 / (long double)(1 << 19) - 0.5;
      i1 = -(-i1 & 0x1fff);
      Ti1 = ((unsigned)(-i1 << 19) | i0) / -(long double)(1LL << 32LL);
      T0 = T[0] - (T[1] - Ti1) / P[1][1] * P[1][0] - (X1 - 1) * Ti1;
      i0 = T0 * 512 * 1024 + 0.5;
      i0 &= 0x7ffff;
    }
    printf("\t.long 0x%x\n", (-i1 << 19) | i0);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2e0,%rsp
movl   $0x0,-0x4(%rbp)
flds   0xec8(%rip)
fstpt  -0x250(%rbp)
fldt   -0x250(%rbp)
flds   0xeba(%rip)
fmulp  %st,%st(1)
fstpt  -0x260(%rbp)
lea    -0x1f0(%rbp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
fld1
fstpt  -0x1f0(%rbp)
movl   $0x1,-0x1f4(%rbp)
cmpl   $0x5,-0x1f4(%rbp)
jge    11d0 <main+0xb0>
movslq -0x1f4(%rbp),%rax
mov    %al,%cl
add    $0xff,%cl
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
mov    %ecx,-0x2d4(%rbp)
fildl  -0x2d4(%rbp)
lea    (%rax,%rax,4),%rcx
shl    $0x4,%rcx
lea    -0x1f0(%rbp,%rcx,1),%rcx
ff
shl    $0x4,%rax
fstpt  (%rax,%rcx,1)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    1177 <main+0x57>
fldt   -0x260(%rbp)
fld    %st(0)
fchs
fmulp  %st,%st(1)
fstpt  -0x150(%rbp)
fld1
fstpt  -0x210(%rbp)
fldt   -0x210(%rbp)
flds   0xe12(%rip)
fucomip %st(1),%st
fstp   %st(0)
jbe    1674 <main+0x554>
jmp    1205 <main+0xe5>
fldt   -0x210(%rbp)
fldt   -0x250(%rbp)
flds   0xded(%rip)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x220(%rbp)
fldt   -0x220(%rbp)
fldt   -0x250(%rbp)
faddp  %st,%st(1)
fstpt  -0x230(%rbp)
fldt   -0x260(%rbp)
fldt   -0x220(%rbp)
fdivrp %st,%st(1)
fstpt  -0x240(%rbp)
fldt   -0x220(%rbp)
fld1
fdivp  %st,%st(1)
fstpt  -0x60(%rbp)
movl   $0x1,-0x1f4(%rbp)
cmpl   $0x5,-0x1f4(%rbp)
jge    12a7 <main+0x187>
movslq -0x1f4(%rbp),%rax
mov    %eax,%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
shl    $0x4,%rcx
fldt   -0x60(%rbp,%rcx,1)
fldt   -0x60(%rbp)
fchs
fmulp  %st,%st(1)
shl    $0x4,%rax
fstpt  -0x60(%rbp,%rax,1)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    1260 <main+0x140>
fldt   -0x240(%rbp)
fldt   -0x260(%rbp)
fmulp  %st,%st(1)
fstpt  -0x1a0(%rbp)
fldt   -0x240(%rbp)
fldt   -0x260(%rbp)
fmulp  %st,%st(1)
fstpt  -0x140(%rbp)
movl   $0x3,-0x1f4(%rbp)
cmpl   $0x5,-0x1f4(%rbp)
jge    13e0 <main+0x2c0>
fldt   -0x260(%rbp)
fld    %st(0)
fchs
fmulp  %st,%st(1)
movslq -0x1f4(%rbp),%rax
mov    %eax,%ecx
add    $0xfffffffe,%ecx
movslq %ecx,%rcx
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
fldt   -0x1f0(%rbp,%rcx,1)
fmulp  %st,%st(1)
lea    (%rax,%rax,4),%rax
shl    $0x4,%rax
fstpt  -0x1f0(%rbp,%rax,1)
movl   $0x1,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%eax
cmp    -0x1f4(%rbp),%eax
jge    13c7 <main+0x2a7>
movslq -0x1f4(%rbp),%rcx
mov    %ecx,%edx
mov    %edx,%eax
add    $0xffffffff,%eax
cltq
lea    (%rax,%rax,4),%rax
shl    $0x4,%rax
lea    -0x1f0(%rbp,%rax,1),%rdi
ff
movslq -0x1f8(%rbp),%rax
mov    %eax,%esi
add    $0xffffffff,%esi
movslq %esi,%rsi
shl    $0x4,%rsi
fldt   (%rsi,%rdi,1)
fldt   -0x260(%rbp)
fmul   %st,%st(0)
add    $0xfffffffe,%edx
movslq %edx,%rdx
lea    (%rdx,%rdx,4),%rdx
shl    $0x4,%rdx
lea    -0x1f0(%rbp,%rdx,1),%rdx
ff
shl    $0x4,%rax
fldt   (%rax,%rdx,1)
fmulp  %st,%st(1)
fxch   %st(1)
fadd   %st,%st(0)
fsubp  %st,%st(1)
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
lea    -0x1f0(%rbp,%rcx,1),%rcx
ff
fstpt  (%rax,%rcx,1)
mov    -0x1f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f8(%rbp)
jmp    132b <main+0x20b>
jmp    13cc <main+0x2ac>
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    12d9 <main+0x1b9>
movl   $0x4,-0x1f4(%rbp)
cmpl   $0x1,-0x1f4(%rbp)
jle    14a6 <main+0x386>
movslq -0x1f4(%rbp),%rcx
mov    %rcx,%rax
shl    $0x4,%rax
fldt   -0x60(%rbp,%rax,1)
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
lea    -0x1f0(%rbp,%rcx,1),%rcx
ff
fldt   (%rax,%rcx,1)
fdivrp %st,%st(1)
fstpt  -0x290(%rbp)
movl   $0x0,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%eax
cmp    -0x1f4(%rbp),%eax
jge    148d <main+0x36d>
fldt   -0x290(%rbp)
movslq -0x1f4(%rbp),%rax
lea    (%rax,%rax,4),%rax
shl    $0x4,%rax
lea    -0x1f0(%rbp,%rax,1),%rcx
ff
movslq -0x1f8(%rbp),%rax
shl    $0x4,%rax
fldt   (%rax,%rcx,1)
fldt   -0x60(%rbp,%rax,1)
fxch   %st(2)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  -0x60(%rbp,%rax,1)
mov    -0x1f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f8(%rbp)
jmp    142e <main+0x30e>
jmp    1492 <main+0x372>
mov    -0x1f4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1f4(%rbp)
jmp    13ea <main+0x2ca>
movq   $0x0,-0x278(%rbp)
movl   $0x0,-0x1f4(%rbp)
movq   $0x0,-0x268(%rbp)
cmpl   $0x4,-0x1f4(%rbp)
jge    1639 <main+0x519>
fldt   -0x50(%rbp)
mov    -0x268(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
fildll -0x2d0(%rbp)
flds   0xb1c(%rip)
fdivrp %st,%st(1)
flds   0xb18(%rip)
fmulp  %st,%st(2)
faddp  %st,%st(1)
flds   0xb02(%rip)
fsubr  %st,%st(1)
fnstcw -0x2d6(%rbp)
movzwl -0x2d6(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x2d8(%rbp)
fldcw  -0x2d8(%rbp)
fxch   %st(1)
fistpll -0x2c8(%rbp)
fldcw  -0x2d6(%rbp)
mov    -0x2c8(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%ecx
neg    %ecx
mov    %ecx,%eax
and    $0x1fff,%eax
neg    %rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%eax
neg    %eax
shl    $0x13,%eax
mov    -0x268(%rbp),%rcx
or     %rcx,%rax
mov    %rax,-0x2c0(%rbp)
fildll -0x2c0(%rbp)
flds   0xa94(%rip)
fdivrp %st,%st(1)
fstpt  -0x2b0(%rbp)
fldt   -0x60(%rbp)
fldt   -0x50(%rbp)
fldt   -0x2b0(%rbp)
fsubr  %st,%st(1)
fldt   -0x190(%rbp)
fdivrp %st,%st(2)
fldt   -0x1a0(%rbp)
fmulp  %st,%st(2)
fxch   %st(2)
fsubp  %st,%st(1)
fldt   -0x220(%rbp)
fld1
fchs
faddp  %st,%st(1)
fmulp  %st,%st(2)
fsubp  %st,%st(1)
fstpt  -0x2a0(%rbp)
fldt   -0x2a0(%rbp)
flds   0xa4c(%rip)
fmulp  %st,%st(1)
flds   0xa48(%rip)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fnstcw -0x2da(%rbp)
movzwl -0x2da(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x2dc(%rbp)
fldcw  -0x2dc(%rbp)
fistpll -0x2b8(%rbp)
fldcw  -0x2da(%rbp)
mov    -0x2b8(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x268(%rbp),%rax
and    $0x7ffff,%rax
mov    %rax,-0x268(%rbp)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    14c6 <main+0x3a6>
xor    %eax,%eax
mov    %eax,%esi
sub    -0x270(%rbp),%rsi
shl    $0x13,%rsi
or     -0x268(%rbp),%rsi
lea    0x9ca(%rip),%rdi
call   1030 <printf@plt>
fldt   -0x250(%rbp)
fldt   -0x210(%rbp)
faddp  %st,%st(1)
fstpt  -0x210(%rbp)
jmp    11ea <main+0xca>
xor    %eax,%eax
add    $0x2e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x2d0,%rsp
lea    0x140(%rsp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
fld1
fld    %st(0)
fstpt  0x140(%rsp)
fld    %st(0)
fstpt  0x1a0(%rsp)
flds   0xeaa(%rip)
fld    %st(0)
fstpt  0x2c(%rsp)
fstpt  0x200(%rsp)
flds   0xe9b(%rip)
fstpt  0x260(%rsp)
flds   0xe92(%rip)
fstpt  0x2c0(%rsp)
flds   0xe89(%rip)
fld    %st(0)
fstpt  0x1e0(%rsp)
lea    0xea1(%rip),%rbx
fld    %st(1)
cs nopw 0x0(%rax,%rax,1)
nop
fld    %st(2)
fstpt  0xbc(%rsp)
fld    %st(0)
fstpt  0x134(%rsp)
flds   0xe58(%rip)
fadd   %st,%st(1)
fld    %st(1)
fstpt  0x50(%rsp)
fdiv   %st,%st(1)
fmulp  %st,%st(1)
flds   0xe42(%rip)
fmul   %st,%st(3)
fld    %st(2)
fstpt  0x44(%rsp)
fxch   %st(2)
fadd   %st,%st(0)
faddp  %st,%st(3)
fld    %st(0)
fstpt  0xb0(%rsp)
fld    %st(0)
fstpt  0x190(%rsp)
fld    %st(0)
fstpt  0x1f0(%rsp)
fld    %st(0)
fmul   %st(2),%st
fld    %st(0)
fstpt  0x38(%rsp)
fstpt  0x230(%rsp)
fld    %st(2)
fstpt  0x240(%rsp)
fld    %st(2)
fxch   %st(3)
fstpt  0x8c(%rsp)
fldt   0x1b0(%rsp)
fmul   %st(2),%st
fxch   %st(1)
fadd   %st,%st(0)
faddp  %st,%st(1)
fldt   0x2c(%rsp)
fld    %st(0)
fstpt  0x2c(%rsp)
fmul   %st(2),%st
fxch   %st(3)
fadd   %st,%st(0)
faddp  %st,%st(3)
fld    %st(2)
fstpt  0x68(%rsp)
fld    %st(0)
fstpt  0x250(%rsp)
fld    %st(0)
fxch   %st(1)
fstpt  0x74(%rsp)
fldt   0x44(%rsp)
fmul   %st(2),%st
fld    %st(0)
fstpt  0x280(%rsp)
fldt   0x38(%rsp)
fld    %st(0)
fadd   %st(1),%st
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x128(%rsp)
fstpt  0x290(%rsp)
fxch   %st(3)
fstpt  0x2a0(%rsp)
fldt   0x210(%rsp)
fmulp  %st,%st(2)
fadd   %st,%st(0)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x5c(%rsp)
fld1
fld    %st(0)
fstpt  0x80(%rsp)
fldt   0x50(%rsp)
fdivrp %st,%st(1)
fld    %st(0)
fchs
fld    %st(1)
fmul   %st(1),%st
fld    %st(0)
fmul   %st(2),%st
fmul   %st,%st(2)
fxch   %st(4)
fstpt  0x2b0(%rsp)
fldt   0x2c0(%rsp)
fstpt  0xa4(%rsp)
fld    %st(1)
fmul   %st(3),%st
fldt   0xa4(%rsp)
fdivrp %st,%st(1)
fmul   %st,%st(5)
fxch   %st(5)
faddp  %st,%st(3)
fldt   0x128(%rsp)
fmul   %st(5),%st
faddp  %st,%st(1)
fldt   0x68(%rsp)
fmul   %st(5),%st
faddp  %st,%st(4)
fldt   0x5c(%rsp)
fmulp  %st,%st(5)
fxch   %st(4)
faddp  %st,%st(1)
fchs
fldt   0x260(%rsp)
fdivrp %st,%st(1)
fldt   0x38(%rsp)
fmul   %st(1),%st
faddp  %st,%st(2)
fldt   0x8c(%rsp)
fmul   %st(1),%st
faddp  %st,%st(4)
fldt   0x74(%rsp)
fmulp  %st,%st(1)
faddp  %st,%st(2)
fxch   %st(1)
fchs
fldt   0x2c(%rsp)
fdivrp %st,%st(1)
fldt   0x44(%rsp)
fmul   %st(1),%st
faddp  %st,%st(2)
fldt   0xb0(%rsp)
fmul   %st,%st(1)
fxch   %st(1)
faddp  %st,%st(3)
fldt   0x80(%rsp)
fchs
fldt   0x50(%rsp)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x68(%rsp)
fld    %st(3)
fmuls  0xcb7(%rip)
fld    %st(0)
fstpt  0x5c(%rsp)
fld    %st(4)
fstpt  0x74(%rsp)
fldz
faddp  %st,%st(1)
flds   0xca5(%rip)
fld    %st(0)
fstpt  0x2c(%rsp)
faddp  %st,%st(1)
fnstcw 0x1a(%rsp)
movzwl 0x1a(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x2a(%rsp)
fldcw  0x2a(%rsp)
fistpll 0xc8(%rsp)
fldcw  0x1a(%rsp)
mov    0xc8(%rsp),%eax
shl    $0x13,%eax
neg    %eax
mov    %rax,0xd0(%rsp)
fildll 0xd0(%rsp)
flds   0xc5e(%rip)
fmul   %st,%st(1)
fld    %st(0)
fxch   %st(1)
fstpt  0x8c(%rsp)
fxch   %st(5)
fsub   %st(1),%st
fldt   0xbc(%rsp)
fdivr  %st,%st(1)
fxch   %st(1)
fmulp  %st,%st(4)
fxch   %st(3)
fsubr  %st(4),%st
fxch   %st(2)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
flds   0xc34(%rip)
fld    %st(0)
fstpt  0x50(%rsp)
fmulp  %st,%st(1)
flds   0xc2a(%rip)
fld    %st(0)
fstpt  0x44(%rsp)
fmulp  %st,%st(1)
flds   0xc20(%rip)
fld    %st(0)
fstpt  0x38(%rsp)
faddp  %st,%st(1)
fnstcw 0x18(%rsp)
movzwl 0x18(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x28(%rsp)
fldcw  0x28(%rsp)
fistpll 0xd8(%rsp)
fldcw  0x18(%rsp)
mov    0xd8(%rsp),%rax
and    $0x7ffff,%eax
mov    %eax,0x98(%rsp)
flds   0xbe0(%rip)
fld    %st(0)
fstpt  0x80(%rsp)
fimull 0x98(%rsp)
fldt   0x5c(%rsp)
fadd   %st,%st(1)
fldt   0x2c(%rsp)
faddp  %st,%st(2)
fnstcw 0x16(%rsp)
movzwl 0x16(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x26(%rsp)
fldcw  0x26(%rsp)
fxch   %st(1)
fistpll 0xe0(%rsp)
fldcw  0x16(%rsp)
mov    0xe0(%rsp),%ecx
shl    $0x13,%ecx
neg    %ecx
or     %rax,%rcx
mov    %rcx,0xe8(%rsp)
fildll 0xe8(%rsp)
fmulp  %st,%st(4)
fldt   0x74(%rsp)
fld    %st(0)
fsub   %st(5),%st
fdivp  %st,%st(3)
fldt   0xb0(%rsp)
fmul   %st,%st(3)
fld    %st(4)
fld    %st(5)
fstpt  0xa4(%rsp)
fxch   %st(5)
fsubp  %st,%st(4)
fldt   0x68(%rsp)
fmul   %st,%st(6)
fxch   %st(4)
fsubp  %st,%st(6)
fldt   0x50(%rsp)
fmulp  %st,%st(6)
fldt   0x44(%rsp)
fmulp  %st,%st(6)
fldt   0x38(%rsp)
faddp  %st,%st(6)
fnstcw 0x14(%rsp)
movzwl 0x14(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x24(%rsp)
fldcw  0x24(%rsp)
fxch   %st(5)
fistpll 0xf0(%rsp)
fldcw  0x14(%rsp)
mov    0xf0(%rsp),%rax
and    $0x7ffff,%eax
mov    %eax,0x9c(%rsp)
fldt   0x80(%rsp)
fimull 0x9c(%rsp)
faddp  %st,%st(2)
fldt   0x2c(%rsp)
fadd   %st,%st(2)
fnstcw 0x12(%rsp)
movzwl 0x12(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x22(%rsp)
fldcw  0x22(%rsp)
fxch   %st(2)
fistpll 0xf8(%rsp)
fldcw  0x12(%rsp)
mov    0xf8(%rsp),%ecx
shl    $0x13,%ecx
neg    %ecx
or     %rax,%rcx
mov    %rcx,0x100(%rsp)
fildll 0x100(%rsp)
fldt   0x8c(%rsp)
fmulp  %st,%st(1)
fsubr  %st,%st(1)
fldt   0xbc(%rsp)
fdivr  %st,%st(2)
fxch   %st(2)
fmulp  %st,%st(6)
fxch   %st(4)
fsubp  %st,%st(5)
fxch   %st(2)
fmulp  %st,%st(3)
fxch   %st(3)
fsubp  %st,%st(2)
fldt   0x50(%rsp)
fmul   %st,%st(2)
fldt   0x44(%rsp)
fmul   %st,%st(3)
fldt   0x38(%rsp)
fadd   %st,%st(4)
fnstcw 0x10(%rsp)
movzwl 0x10(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x20(%rsp)
fldcw  0x20(%rsp)
fxch   %st(4)
fistpll 0x108(%rsp)
fldcw  0x10(%rsp)
mov    0x108(%rsp),%rcx
and    $0x7ffff,%ecx
mov    %ecx,0xa0(%rsp)
fldt   0x80(%rsp)
fimull 0xa0(%rsp)
fldt   0x5c(%rsp)
faddp  %st,%st(1)
faddp  %st,%st(5)
fnstcw 0xe(%rsp)
movzwl 0xe(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x1e(%rsp)
fldcw  0x1e(%rsp)
fxch   %st(4)
fistpll 0x110(%rsp)
fldcw  0xe(%rsp)
mov    0x110(%rsp),%eax
shl    $0x13,%eax
neg    %eax
or     %rax,%rcx
mov    %rcx,0x118(%rsp)
fildll 0x118(%rsp)
fldt   0x8c(%rsp)
fmulp  %st,%st(1)
fldt   0x74(%rsp)
fsub   %st(1),%st
fdivp  %st,%st(3)
fldt   0xb0(%rsp)
fmulp  %st,%st(3)
fldt   0xa4(%rsp)
fsubp  %st,%st(3)
fldt   0x68(%rsp)
fmulp  %st,%st(1)
fsubrp %st,%st(2)
fmulp  %st,%st(1)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fnstcw 0xc(%rsp)
movzwl 0xc(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x1c(%rsp)
fldcw  0x1c(%rsp)
fistpll 0x120(%rsp)
fldcw  0xc(%rsp)
mov    0x120(%rsp),%rsi
and    $0x7ffff,%esi
or     %rax,%rsi
mov    %rbx,%rdi
call   1030 <printf@plt>
fldt   0x134(%rsp)
fadds  0x973(%rip)
flds   0x93d(%rip)
fucomip %st(1),%st
jbe    16e7 <main+0x5c7>
fldt   0x1e0(%rsp)
fldt   0x1a0(%rsp)
fldt   0x200(%rsp)
fstpt  0x2c(%rsp)
fxch   %st(2)
jmp    11a0 <main+0x80>
fstp   %st(0)
xor    %eax,%eax
add    $0x2d0,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [13 x i8] c"\09.long 0x%x\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [5 x x86_fp80]
%3 = alloca [5 x [5 x x86_fp80]]
%4 = alloca i32
%5 = alloca i32
%6 = alloca x86_fp80
%7 = alloca x86_fp80
%8 = alloca x86_fp80
%9 = alloca x86_fp80
%10 = alloca x86_fp80
%11 = alloca x86_fp80
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca x86_fp80
%16 = alloca x86_fp80
%17 = alloca x86_fp80
store i32 0, i32* %1
store x86_fp80 0xK3FF98000000000000000, x86_fp80* %10
%18 = load x86_fp80, x86_fp80* %10
%19 = fmul x86_fp80 %18, 0xK3FFE8000000000000000
store x86_fp80 %19, x86_fp80* %11
%20 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 0
%21 = bitcast [5 x x86_fp80]* %20 to x86_fp80**
%22 = call i32 @memset(x86_fp80** %21, i32 0, i32 400)
%23 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 0
%24 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %23, i64 0, i64 0
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %24
store i32 1, i32* %4
br label %25
25: ; preds = %39, %0
%26 = load i32, i32* %4
%27 = icmp slt i32 %26, 5
br i1 %27, label %28, label %42
28: ; preds = %25
%29 = load i32, i32* %4
%30 = sub nsw i32 %29, 1
%31 = shl i32 1, %30
%32 = sitofp i32 %31 to x86_fp80
%33 = load i32, i32* %4
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %34
%36 = load i32, i32* %4
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %35, i64 0, i64 %37
store x86_fp80 %32, x86_fp80* %38
br label %39
39: ; preds = %28
%40 = load i32, i32* %4
%41 = add nsw i32 %40, 1
store i32 %41, i32* %4
br label %25
42: ; preds = %25
%43 = load x86_fp80, x86_fp80* %11
%44 = fneg x86_fp80 %43
%45 = load x86_fp80, x86_fp80* %11
%46 = fmul x86_fp80 %44, %45
%47 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 2
%48 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %47, i64 0, i64 0
store x86_fp80 %46, x86_fp80* %48
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %6
br label %49
49: ; preds = %260, %42
%50 = load x86_fp80, x86_fp80* %6
%51 = fcmp olt x86_fp80 %50, 0xK40008000000000000000
br i1 %51, label %52, label %264
52: ; preds = %49
%53 = load x86_fp80, x86_fp80* %6
%54 = load x86_fp80, x86_fp80* %10
%55 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %54, x86_fp80 0xK3FFE8000000000000000, x86_fp80 %53)
store x86_fp80 %55, x86_fp80* %7
%56 = load x86_fp80, x86_fp80* %7
%57 = load x86_fp80, x86_fp80* %10
%58 = fadd x86_fp80 %56, %57
store x86_fp80 %58, x86_fp80* %8
%59 = load x86_fp80, x86_fp80* %11
%60 = load x86_fp80, x86_fp80* %7
%61 = fdiv x86_fp80 %59, %60
store x86_fp80 %61, x86_fp80* %9
%62 = load x86_fp80, x86_fp80* %7
%63 = fdiv x86_fp80 0xK3FFF8000000000000000, %62
%64 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 0
store x86_fp80 %63, x86_fp80* %64
store i32 1, i32* %4
br label %65
65: ; preds = %81, %52
%66 = load i32, i32* %4
%67 = icmp slt i32 %66, 5
br i1 %67, label %68, label %84
68: ; preds = %65
%69 = load i32, i32* %4
%70 = sub nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %71
%73 = load x86_fp80, x86_fp80* %72
%74 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 0
%75 = load x86_fp80, x86_fp80* %74
%76 = fneg x86_fp80 %75
%77 = fmul x86_fp80 %73, %76
%78 = load i32, i32* %4
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %79
store x86_fp80 %77, x86_fp80* %80
br label %81
81: ; preds = %68
%82 = load i32, i32* %4
%83 = add nsw i32 %82, 1
store i32 %83, i32* %4
br label %65
84: ; preds = %65
%85 = load x86_fp80, x86_fp80* %9
%86 = load x86_fp80, x86_fp80* %11
%87 = fmul x86_fp80 %85, %86
%88 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 1
%89 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %88, i64 0, i64 0
store x86_fp80 %87, x86_fp80* %89
%90 = load x86_fp80, x86_fp80* %9
%91 = load x86_fp80, x86_fp80* %11
%92 = fmul x86_fp80 %90, %91
%93 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 2
%94 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %93, i64 0, i64 1
store x86_fp80 %92, x86_fp80* %94
store i32 3, i32* %4
br label %95
95: ; preds = %152, %84
%96 = load i32, i32* %4
%97 = icmp slt i32 %96, 5
br i1 %97, label %98, label %155
98: ; preds = %95
%99 = load x86_fp80, x86_fp80* %11
%100 = fneg x86_fp80 %99
%101 = load x86_fp80, x86_fp80* %11
%102 = fmul x86_fp80 %100, %101
%103 = load i32, i32* %4
%104 = sub nsw i32 %103, 2
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %105
%107 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %106, i64 0, i64 0
%108 = load x86_fp80, x86_fp80* %107
%109 = fmul x86_fp80 %102, %108
%110 = load i32, i32* %4
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %111
%113 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %112, i64 0, i64 0
store x86_fp80 %109, x86_fp80* %113
store i32 1, i32* %5
br label %114
114: ; preds = %148, %98
%115 = load i32, i32* %5
%116 = load i32, i32* %4
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %151
118: ; preds = %114
%119 = load i32, i32* %4
%120 = sub nsw i32 %119, 1
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %121
%123 = load i32, i32* %5
%124 = sub nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %122, i64 0, i64 %125
%127 = load x86_fp80, x86_fp80* %126
%128 = load x86_fp80, x86_fp80* %11
%129 = load x86_fp80, x86_fp80* %11
%130 = fmul x86_fp80 %128, %129
%131 = load i32, i32* %4
%132 = sub nsw i32 %131, 2
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %133
%135 = load i32, i32* %5
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %134, i64 0, i64 %136
%138 = load x86_fp80, x86_fp80* %137
%139 = fmul x86_fp80 %130, %138
%140 = fneg x86_fp80 %139
%141 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xK40008000000000000000, x86_fp80 %127, x86_fp80 %140)
%142 = load i32, i32* %4
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %143
%145 = load i32, i32* %5
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %144, i64 0, i64 %146
store x86_fp80 %141, x86_fp80* %147
br label %148
148: ; preds = %118
%149 = load i32, i32* %5
%150 = add nsw i32 %149, 1
store i32 %150, i32* %5
br label %114
151: ; preds = %114
br label %152
152: ; preds = %151
%153 = load i32, i32* %4
%154 = add nsw i32 %153, 1
store i32 %154, i32* %4
br label %95
155: ; preds = %95
store i32 4, i32* %4
br label %156
156: ; preds = %195, %155
%157 = load i32, i32* %4
%158 = icmp sgt i32 %157, 1
br i1 %158, label %159, label %198
159: ; preds = %156
%160 = load i32, i32* %4
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %161
%163 = load x86_fp80, x86_fp80* %162
%164 = load i32, i32* %4
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %165
%167 = load i32, i32* %4
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %166, i64 0, i64 %168
%170 = load x86_fp80, x86_fp80* %169
%171 = fdiv x86_fp80 %163, %170
store x86_fp80 %171, x86_fp80* %15
store i32 0, i32* %5
br label %172
172: ; preds = %191, %159
%173 = load i32, i32* %5
%174 = load i32, i32* %4
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %194
176: ; preds = %172
%177 = load x86_fp80, x86_fp80* %15
%178 = load i32, i32* %4
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %179
%181 = load i32, i32* %5
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %180, i64 0, i64 %182
%184 = load x86_fp80, x86_fp80* %183
%185 = load i32, i32* %5
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %186
%188 = load x86_fp80, x86_fp80* %187
%189 = fneg x86_fp80 %177
%190 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %189, x86_fp80 %184, x86_fp80 %188)
store x86_fp80 %190, x86_fp80* %187
br label %191
191: ; preds = %176
%192 = load i32, i32* %5
%193 = add nsw i32 %192, 1
store i32 %193, i32* %5
br label %172
194: ; preds = %172
br label %195
195: ; preds = %194
%196 = load i32, i32* %4
%197 = add nsw i32 %196, -1
store i32 %197, i32* %4
br label %156
198: ; preds = %156
store i64 0, i64* %14
store i32 0, i32* %4
store i64 0, i64* %12
br label %199
199: ; preds = %250, %198
%200 = load i32, i32* %4
%201 = icmp slt i32 %200, 4
br i1 %201, label %202, label %253
202: ; preds = %199
%203 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 1
%204 = load x86_fp80, x86_fp80* %203
%205 = load i64, i64* %12
%206 = sitofp i64 %205 to x86_fp80
%207 = fdiv x86_fp80 %206, 0xK40128000000000000000
%208 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %204, x86_fp80 0xK400C8000000000000000, x86_fp80 %207)
%209 = fsub x86_fp80 %208, 0xK3FFE8000000000000000
%210 = fptosi x86_fp80 %209 to i64
store i64 %210, i64* %13
%211 = load i64, i64* %13
%212 = sub nsw i64 0, %211
%213 = and i64 %212, 8191
%214 = sub nsw i64 0, %213
store i64 %214, i64* %13
%215 = load i64, i64* %13
%216 = sub nsw i64 0, %215
%217 = shl i64 %216, 19
%218 = trunc i64 %217 to i32
%219 = zext i32 %218 to i64
%220 = load i64, i64* %12
%221 = or i64 %219, %220
%222 = sitofp i64 %221 to x86_fp80
%223 = fdiv x86_fp80 %222, 0xKC01F8000000000000000
store x86_fp80 %223, x86_fp80* %17
%224 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 0
%225 = load x86_fp80, x86_fp80* %224
%226 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 1
%227 = load x86_fp80, x86_fp80* %226
%228 = load x86_fp80, x86_fp80* %17
%229 = fsub x86_fp80 %227, %228
%230 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 1
%231 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %230, i64 0, i64 1
%232 = load x86_fp80, x86_fp80* %231
%233 = fdiv x86_fp80 %229, %232
%234 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 1
%235 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %234, i64 0, i64 0
%236 = load x86_fp80, x86_fp80* %235
%237 = fneg x86_fp80 %233
%238 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %237, x86_fp80 %236, x86_fp80 %225)
%239 = load x86_fp80, x86_fp80* %7
%240 = fsub x86_fp80 %239, 0xK3FFF8000000000000000
%241 = load x86_fp80, x86_fp80* %17
%242 = fneg x86_fp80 %240
%243 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %242, x86_fp80 %241, x86_fp80 %238)
store x86_fp80 %243, x86_fp80* %16
%244 = load x86_fp80, x86_fp80* %16
%245 = fmul x86_fp80 %244, 0xK40088000000000000000
%246 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %245, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%247 = fptosi x86_fp80 %246 to i64
store i64 %247, i64* %12
%248 = load i64, i64* %12
%249 = and i64 %248, 524287
store i64 %249, i64* %12
br label %250
250: ; preds = %202
%251 = load i32, i32* %4
%252 = add nsw i32 %251, 1
store i32 %252, i32* %4
br label %199
253: ; preds = %199
%254 = load i64, i64* %13
%255 = sub nsw i64 0, %254
%256 = shl i64 %255, 19
%257 = load i64, i64* %12
%258 = or i64 %256, %257
%259 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i64 %258)
br label %260
260: ; preds = %253
%261 = load x86_fp80, x86_fp80* %10
%262 = load x86_fp80, x86_fp80* %6
%263 = fadd x86_fp80 %262, %261
store x86_fp80 %263, x86_fp80* %6
br label %49
264: ; preds = %49
ret i32 0
}

LLVM IR (-O2):
@.str = [13 x i8] c"\09.long 0x%x\0A\00"
define i32 @main() {
%1 = alloca [5 x [5 x x86_fp80]]
%2 = bitcast [5 x [5 x x86_fp80]]* %1 to i8*
%3 = bitcast [5 x [5 x x86_fp80]]* %1 to x86_fp80**
%4 = call i32 @memset(x86_fp80** %3, i32 0, i32 400)
%5 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 0, i64 0
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %5
%6 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 1, i64 1
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %6
%7 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 2, i64 2
store x86_fp80 0xK40008000000000000000, x86_fp80* %7
%8 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 3, i64 3
store x86_fp80 0xK40018000000000000000, x86_fp80* %8
%9 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 4, i64 4
store x86_fp80 0xK40028000000000000000, x86_fp80* %9
%10 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 2, i64 0
store x86_fp80 0xKBFF18000000000000000, x86_fp80* %10
%11 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 1, i64 0
%12 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 2, i64 1
%13 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 3, i64 0
%14 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 3, i64 1
%15 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 1, i64 2
%16 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 3, i64 2
%17 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 4, i64 0
%18 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 4, i64 1
%19 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 4, i64 2
%20 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 2, i64 3
%21 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %1, i64 0, i64 4, i64 3
br label %22
22: ; preds = %144, %0
%23 = phi x86_fp80 [ 0xK40008000000000000000, %0 ], [ %147, %144 ]
%24 = phi x86_fp80 [ 0xK3FFF8000000000000000, %0 ], [ %146, %144 ]
%25 = phi x86_fp80 [ 0xKBFF18000000000000000, %0 ], [ %145, %144 ]
%26 = phi x86_fp80 [ 0xK3FFF8000000000000000, %0 ], [ %142, %144 ]
%27 = fadd x86_fp80 %26, 0xK3FF88000000000000000
%28 = fdiv x86_fp80 0xK3FFF8000000000000000, %27
%29 = fneg x86_fp80 %28
%30 = fmul x86_fp80 %28, %29
%31 = fmul x86_fp80 %30, %29
%32 = fmul x86_fp80 %31, %29
%33 = fdiv x86_fp80 0xK3FF88000000000000000, %27
%34 = fmul x86_fp80 %33, 0xK3FF88000000000000000
store x86_fp80 %34, x86_fp80* %11
store x86_fp80 %34, x86_fp80* %12
%35 = fmul x86_fp80 %34, 0xKBFF18000000000000000
store x86_fp80 %35, x86_fp80* %13
%36 = fmul x86_fp80 %24, 0xKBFF18000000000000000
%37 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %25, x86_fp80 0xK40008000000000000000, x86_fp80 %36)
store x86_fp80 %37, x86_fp80* %14
%38 = load x86_fp80, x86_fp80* %15
%39 = fmul x86_fp80 %38, 0xKBFF18000000000000000
%40 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %34, x86_fp80 0xK40008000000000000000, x86_fp80 %39)
store x86_fp80 %40, x86_fp80* %16
%41 = fmul x86_fp80 %25, 0xKBFF18000000000000000
store x86_fp80 %41, x86_fp80* %17
%42 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %35, x86_fp80 0xK40008000000000000000, x86_fp80 %35)
store x86_fp80 %42, x86_fp80* %18
%43 = fmul x86_fp80 %23, 0xKBFF18000000000000000
%44 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %37, x86_fp80 0xK40008000000000000000, x86_fp80 %43)
store x86_fp80 %44, x86_fp80* %19
%45 = load x86_fp80, x86_fp80* %20
%46 = fmul x86_fp80 %45, 0xKBFF18000000000000000
%47 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %40, x86_fp80 0xK40008000000000000000, x86_fp80 %46)
store x86_fp80 %47, x86_fp80* %21
%48 = load x86_fp80, x86_fp80* %9
%49 = fmul x86_fp80 %32, %28
%50 = fdiv x86_fp80 %49, %48
%51 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %50, x86_fp80 %41, x86_fp80 %28)
%52 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %50, x86_fp80 %42, x86_fp80 %30)
%53 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %50, x86_fp80 %44, x86_fp80 %31)
%54 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %50, x86_fp80 %47, x86_fp80 %32)
%55 = load x86_fp80, x86_fp80* %8
%56 = fneg x86_fp80 %54
%57 = fdiv x86_fp80 %56, %55
%58 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %57, x86_fp80 %35, x86_fp80 %51)
%59 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %57, x86_fp80 %37, x86_fp80 %52)
%60 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %57, x86_fp80 %40, x86_fp80 %53)
%61 = fneg x86_fp80 %60
%62 = fdiv x86_fp80 %61, %23
%63 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %62, x86_fp80 %25, x86_fp80 %58)
%64 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %62, x86_fp80 %34, x86_fp80 %59)
%65 = fadd x86_fp80 %27, 0xKBFFF8000000000000000
%66 = fneg x86_fp80 %65
%67 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400C8000000000000000, x86_fp80 0xK00000000000000000000)
%68 = fadd x86_fp80 %67, 0xKBFFE8000000000000000
%69 = fptosi x86_fp80 %68 to i64
%70 = mul i64 %69, -524288
%71 = and i64 %70, 4294443008
%72 = sitofp i64 %71 to x86_fp80
%73 = fmul x86_fp80 %72, 0xKBFDF8000000000000000
%74 = fsub x86_fp80 %64, %73
%75 = fneg x86_fp80 %74
%76 = fdiv x86_fp80 %75, %24
%77 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %76, x86_fp80 %34, x86_fp80 %63)
%78 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %66, x86_fp80 %73, x86_fp80 %77)
%79 = fmul x86_fp80 %78, 0xK40088000000000000000
%80 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %79, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%81 = fptosi x86_fp80 %80 to i64
%82 = and i64 %81, 524287
%83 = sitofp i64 %82 to x86_fp80
%84 = fmul x86_fp80 %83, 0xK3FEC8000000000000000
%85 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400C8000000000000000, x86_fp80 %84)
%86 = fadd x86_fp80 %85, 0xKBFFE8000000000000000
%87 = fptosi x86_fp80 %86 to i64
%88 = mul i64 %87, -524288
%89 = and i64 %88, 4294443008
%90 = or i64 %89, %82
%91 = sitofp i64 %90 to x86_fp80
%92 = fmul x86_fp80 %91, 0xKBFDF8000000000000000
%93 = fsub x86_fp80 %64, %92
%94 = fneg x86_fp80 %93
%95 = fdiv x86_fp80 %94, %24
%96 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %95, x86_fp80 %34, x86_fp80 %63)
%97 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %66, x86_fp80 %92, x86_fp80 %96)
%98 = fmul x86_fp80 %97, 0xK40088000000000000000
%99 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %98, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%100 = fptosi x86_fp80 %99 to i64
%101 = and i64 %100, 524287
%102 = sitofp i64 %101 to x86_fp80
%103 = fmul x86_fp80 %102, 0xK3FEC8000000000000000
%104 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400C8000000000000000, x86_fp80 %103)
%105 = fadd x86_fp80 %104, 0xKBFFE8000000000000000
%106 = fptosi x86_fp80 %105 to i64
%107 = mul i64 %106, -524288
%108 = and i64 %107, 4294443008
%109 = or i64 %108, %101
%110 = sitofp i64 %109 to x86_fp80
%111 = fmul x86_fp80 %110, 0xKBFDF8000000000000000
%112 = fsub x86_fp80 %64, %111
%113 = fneg x86_fp80 %112
%114 = fdiv x86_fp80 %113, %24
%115 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %114, x86_fp80 %34, x86_fp80 %63)
%116 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %66, x86_fp80 %111, x86_fp80 %115)
%117 = fmul x86_fp80 %116, 0xK40088000000000000000
%118 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %117, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%119 = fptosi x86_fp80 %118 to i64
%120 = and i64 %119, 524287
%121 = sitofp i64 %120 to x86_fp80
%122 = fmul x86_fp80 %121, 0xK3FEC8000000000000000
%123 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400C8000000000000000, x86_fp80 %122)
%124 = fadd x86_fp80 %123, 0xKBFFE8000000000000000
%125 = fptosi x86_fp80 %124 to i64
%126 = mul i64 %125, -524288
%127 = and i64 %126, 4294443008
%128 = or i64 %127, %120
%129 = sitofp i64 %128 to x86_fp80
%130 = fmul x86_fp80 %129, 0xKBFDF8000000000000000
%131 = fsub x86_fp80 %64, %130
%132 = fneg x86_fp80 %131
%133 = fdiv x86_fp80 %132, %24
%134 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %133, x86_fp80 %34, x86_fp80 %63)
%135 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %66, x86_fp80 %130, x86_fp80 %134)
%136 = fmul x86_fp80 %135, 0xK40088000000000000000
%137 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %136, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%138 = fptosi x86_fp80 %137 to i64
%139 = and i64 %138, 524287
%140 = or i64 %127, %139
%141 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i64 %140)
%142 = fadd x86_fp80 %26, 0xK3FF98000000000000000
%143 = fcmp olt x86_fp80 %142, 0xK40008000000000000000
br i1 %143, label %144, label %148
144: ; preds = %22
%145 = load x86_fp80, x86_fp80* %10
%146 = load x86_fp80, x86_fp80* %6
%147 = load x86_fp80, x86_fp80* %7
br label %22
148: ; preds = %22
ret i32 0
}