#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 sqrt(long double);
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, io;
  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 = X0 + 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;
    long double T0, Ti1;
    for (i = 0, i0 = 0; i < 4; i++) {
      i1 = T[1] * 4096. + i0 / (long double)(1 << 20) - 0.5;
      i1 = -(-i1 & 0x0fff);
      Ti1 = ((unsigned)(-i1 << 20) | i0) / -(long double)(1LL << 32LL);
      T0 = T[0] - (T[1] - Ti1) / P[1][1] * P[1][0] - (X1 - 1) * Ti1;
      i0 = T0 * 1024 * 1024 + 0.5;
      i0 &= 0xfffff;
    }
    io = (unsigned)(-i1 << 20) | i0;
    long double A1 = (unsigned)io / -65536. / 65536.;
    long double A0 = (unsigned)(io << 12) / 65536. / 65536.;
    long double Xm0 = 1. / sqrt(-A1);
    long double Xm1 = 0.5 + 0.5 * -A0 / A1;
    printf("\t.long 0x%x\n", io);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x350,%rsp
movl   $0x0,-0x4(%rbp)
flds   0xeb8(%rip)
fstpt  -0x250(%rbp)
fldt   -0x250(%rbp)
flds   0xeaa(%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    11e0 <main+0xb0>
movslq -0x1f4(%rbp),%rax
mov    %al,%cl
add    $0xff,%cl
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
mov    %ecx,-0x32c(%rbp)
fildl  -0x32c(%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    1187 <main+0x57>
fldt   -0x260(%rbp)
fld    %st(0)
fchs
fmulp  %st,%st(1)
fstpt  -0x150(%rbp)
fld1
fstpt  -0x210(%rbp)
fldt   -0x210(%rbp)
flds   0xe02(%rip)
fucomip %st(1),%st
fstp   %st(0)
jbe    1740 <main+0x610>
jmp    1215 <main+0xe5>
fldt   -0x210(%rbp)
fldt   -0x250(%rbp)
flds   0xddd(%rip)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x220(%rbp)
fldt   -0x210(%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    12b7 <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    1270 <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    13f0 <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    13d7 <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    133b <main+0x20b>
jmp    13dc <main+0x2ac>
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    12e9 <main+0x1b9>
movl   $0x4,-0x1f4(%rbp)
cmpl   $0x1,-0x1f4(%rbp)
jle    14b6 <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    149d <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    143e <main+0x30e>
jmp    14a2 <main+0x372>
mov    -0x1f4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1f4(%rbp)
jmp    13fa <main+0x2ca>
movq   $0x0,-0x278(%rbp)
movl   $0x0,-0x1f4(%rbp)
movq   $0x0,-0x268(%rbp)
cmpl   $0x4,-0x1f4(%rbp)
jge    1643 <main+0x513>
fldt   -0x50(%rbp)
mov    -0x268(%rbp),%rax
mov    %rax,-0x328(%rbp)
fildll -0x328(%rbp)
flds   0xb0c(%rip)
fdivrp %st,%st(1)
flds   0xb08(%rip)
fmulp  %st,%st(2)
faddp  %st,%st(1)
flds   0xaf2(%rip)
fsubr  %st,%st(1)
fnstcw -0x32e(%rbp)
movzwl -0x32e(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x330(%rbp)
fldcw  -0x330(%rbp)
fxch   %st(1)
fistpll -0x320(%rbp)
fldcw  -0x32e(%rbp)
mov    -0x320(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%ecx
neg    %ecx
mov    %ecx,%eax
and    $0xfff,%eax
neg    %rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%eax
neg    %eax
shl    $0x14,%eax
mov    -0x268(%rbp),%rcx
or     %rcx,%rax
mov    %rax,-0x318(%rbp)
fildll -0x318(%rbp)
flds   0xa84(%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   0xa3c(%rip)
fmul   %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fnstcw -0x332(%rbp)
movzwl -0x332(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x334(%rbp)
fldcw  -0x334(%rbp)
fistpll -0x310(%rbp)
fldcw  -0x332(%rbp)
mov    -0x310(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x268(%rbp),%rax
and    $0xfffff,%rax
mov    %rax,-0x268(%rbp)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    14d6 <main+0x3a6>
mov    -0x270(%rbp),%eax
neg    %eax
shl    $0x14,%eax
mov    -0x268(%rbp),%rcx
or     %rcx,%rax
mov    %rax,-0x280(%rbp)
mov    -0x280(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x9ae(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x9aa(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
fldl   -0x2f8(%rbp)
fstpt  -0x2c0(%rbp)
mov    -0x280(%rbp),%eax
shl    $0xc,%eax
cvtsi2sd %rax,%xmm0
divsd  %xmm1,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x300(%rbp)
ff
fldl   -0x300(%rbp)
fstpt  -0x2d0(%rbp)
fldt   -0x2c0(%rbp)
fchs
mov    %rsp,%rax
fstpt  (%rax)
call   1050 <sqrt@plt>
cvtsi2sd %eax,%xmm1
movsd  0x952(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
fldl   -0x308(%rbp)
fstpt  -0x2e0(%rbp)
fldt   -0x2d0(%rbp)
flds   0x902(%rip)
fmul   %st,%st(1)
fldt   -0x2c0(%rbp)
fdivrp %st,%st(2)
fsubp  %st,%st(1)
fstpt  -0x2f0(%rbp)
mov    -0x280(%rbp),%rsi
lea    0x916(%rip),%rdi
call   1030 <printf@plt>
fldt   -0x250(%rbp)
fldt   -0x210(%rbp)
faddp  %st,%st(1)
fstpt  -0x210(%rbp)
jmp    11fa <main+0xca>
xor    %eax,%eax
add    $0x350,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x2e8,%rsp
lea    0x150(%rsp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1040 <memset@plt>
fld1
fld    %st(0)
fstpt  0x150(%rsp)
fld    %st(0)
fstpt  0x1b0(%rsp)
flds   0xe98(%rip)
fld    %st(0)
fstpt  0x30(%rsp)
fstpt  0x210(%rsp)
flds   0xe89(%rip)
fstpt  0x270(%rsp)
flds   0xe80(%rip)
fstpt  0x2d0(%rsp)
flds   0xe77(%rip)
fld    %st(0)
fstpt  0x1f0(%rsp)
lea    0xe93(%rip),%r14
fld    %st(1)
nopw   0x0(%rax,%rax,1)
fld    %st(2)
fstpt  0xb4(%rsp)
fld    %st(0)
fstpt  0x144(%rsp)
flds   0xe48(%rip)
fadd   %st,%st(1)
fld    %st(1)
fstpt  0x54(%rsp)
fdiv   %st,%st(1)
fmulp  %st,%st(1)
flds   0xe32(%rip)
fmul   %st,%st(3)
fld    %st(2)
fstpt  0x48(%rsp)
fxch   %st(2)
fadd   %st,%st(0)
faddp  %st,%st(3)
fld    %st(0)
fstpt  0xa8(%rsp)
fld    %st(0)
fstpt  0x1a0(%rsp)
fld    %st(0)
fstpt  0x200(%rsp)
fld    %st(0)
fmul   %st(2),%st
fld    %st(0)
fstpt  0x3c(%rsp)
fstpt  0x240(%rsp)
fld    %st(2)
fstpt  0x250(%rsp)
fld    %st(2)
fxch   %st(3)
fstpt  0x78(%rsp)
fldt   0x1c0(%rsp)
fmul   %st(2),%st
fxch   %st(1)
fadd   %st,%st(0)
faddp  %st,%st(1)
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x30(%rsp)
fmul   %st(2),%st
fxch   %st(3)
fadd   %st,%st(0)
faddp  %st,%st(3)
fld    %st(2)
fstpt  0x9c(%rsp)
fld    %st(0)
fstpt  0x260(%rsp)
fld    %st(0)
fxch   %st(1)
fstpt  0x60(%rsp)
fldt   0x48(%rsp)
fmul   %st(2),%st
fld    %st(0)
fstpt  0x290(%rsp)
fldt   0x3c(%rsp)
fld    %st(0)
fadd   %st(1),%st
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x12c(%rsp)
fstpt  0x2a0(%rsp)
fxch   %st(3)
fstpt  0x2b0(%rsp)
fldt   0x220(%rsp)
fmulp  %st,%st(2)
fadd   %st,%st(0)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x90(%rsp)
fld1
fld    %st(0)
fstpt  0x6c(%rsp)
fldt   0x54(%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  0x2c0(%rsp)
fldt   0x2d0(%rsp)
fstpt  0x138(%rsp)
fld    %st(1)
fmul   %st(3),%st
fldt   0x138(%rsp)
fdivrp %st,%st(1)
fmul   %st,%st(5)
fxch   %st(5)
faddp  %st,%st(3)
fldt   0x12c(%rsp)
fmul   %st(5),%st
faddp  %st,%st(1)
fldt   0x9c(%rsp)
fmul   %st(5),%st
faddp  %st,%st(4)
fldt   0x90(%rsp)
fmulp  %st,%st(5)
fxch   %st(4)
faddp  %st,%st(1)
fchs
fldt   0x270(%rsp)
fdivrp %st,%st(1)
fldt   0x3c(%rsp)
fmul   %st(1),%st
faddp  %st,%st(2)
fldt   0x78(%rsp)
fmul   %st(1),%st
faddp  %st,%st(4)
fldt   0x60(%rsp)
fmulp  %st,%st(1)
faddp  %st,%st(2)
fxch   %st(1)
fchs
fldt   0x30(%rsp)
fdivrp %st,%st(1)
fldt   0x48(%rsp)
fmul   %st(1),%st
faddp  %st,%st(2)
fld    %st(1)
fstpt  0x60(%rsp)
fldt   0xa8(%rsp)
fmul   %st,%st(1)
fxch   %st(1)
faddp  %st,%st(3)
fldt   0x6c(%rsp)
fchs
fldt   0x54(%rsp)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x54(%rsp)
fld    %st(3)
fmuls  0xca1(%rip)
fld    %st(0)
fstpt  0x6c(%rsp)
fld    %st(4)
fstpt  0x9c(%rsp)
fldz
faddp  %st,%st(1)
flds   0xc8c(%rip)
fadd   %st,%st(1)
fld    %st(0)
fstpt  0x78(%rsp)
fnstcw 0x1e(%rsp)
movzwl 0x1e(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x2e(%rsp)
fldcw  0x2e(%rsp)
fxch   %st(1)
fistpll 0xc8(%rsp)
fldcw  0x1e(%rsp)
mov    0xc8(%rsp),%eax
shl    $0x14,%eax
neg    %eax
mov    %rax,0xd0(%rsp)
fildll 0xd0(%rsp)
flds   0xc43(%rip)
fld    %st(0)
fstpt  0x30(%rsp)
fmulp  %st,%st(1)
fsubr  %st,%st(5)
fldt   0xb4(%rsp)
fdivr  %st,%st(6)
fxch   %st(6)
fmulp  %st,%st(4)
fxch   %st(4)
fsubp  %st,%st(3)
fxch   %st(1)
fmulp  %st,%st(3)
fxch   %st(1)
fsubp  %st,%st(2)
flds   0xc1e(%rip)
fld    %st(0)
fstpt  0x90(%rsp)
fmul   %st,%st(2)
fmulp  %st,%st(2)
flds   0xc0f(%rip)
fld    %st(0)
fstpt  0x48(%rsp)
faddp  %st,%st(2)
fnstcw 0x1c(%rsp)
movzwl 0x1c(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x2c(%rsp)
fldcw  0x2c(%rsp)
fxch   %st(1)
fistpll 0xd8(%rsp)
fldcw  0x1c(%rsp)
mov    0xd8(%rsp),%rax
and    $0xfffff,%eax
mov    %eax,0x84(%rsp)
flds   0xbcd(%rip)
fld    %st(0)
fstpt  0x3c(%rsp)
fimull 0x84(%rsp)
fldt   0x6c(%rsp)
fadd   %st,%st(1)
fxch   %st(1)
faddp  %st,%st(2)
fnstcw 0x1a(%rsp)
movzwl 0x1a(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x2a(%rsp)
fldcw  0x2a(%rsp)
fxch   %st(1)
fistpll 0xe0(%rsp)
fldcw  0x1a(%rsp)
mov    0xe0(%rsp),%ecx
shl    $0x14,%ecx
neg    %ecx
or     %rax,%rcx
mov    %rcx,0xe8(%rsp)
fildll 0xe8(%rsp)
fldt   0x30(%rsp)
fmulp  %st,%st(1)
fldt   0x9c(%rsp)
fld    %st(0)
fsub   %st(2),%st
fdivp  %st,%st(4)
fldt   0xa8(%rsp)
fmul   %st,%st(4)
fldt   0x60(%rsp)
fsub   %st,%st(5)
fldt   0x54(%rsp)
fmulp  %st,%st(4)
fxch   %st(5)
fsubp  %st,%st(3)
fldt   0x90(%rsp)
fmul   %st,%st(3)
fmul   %st,%st(3)
fldt   0x48(%rsp)
faddp  %st,%st(4)
fnstcw 0x18(%rsp)
movzwl 0x18(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x28(%rsp)
fldcw  0x28(%rsp)
fxch   %st(3)
fistpll 0xf0(%rsp)
fldcw  0x18(%rsp)
mov    0xf0(%rsp),%rax
and    $0xfffff,%eax
mov    %eax,0x88(%rsp)
fldt   0x3c(%rsp)
fimull 0x88(%rsp)
faddp  %st,%st(4)
fldt   0x78(%rsp)
faddp  %st,%st(4)
fnstcw 0x16(%rsp)
movzwl 0x16(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x26(%rsp)
fldcw  0x26(%rsp)
fxch   %st(3)
fistpll 0xf8(%rsp)
fldcw  0x16(%rsp)
mov    0xf8(%rsp),%ecx
shl    $0x14,%ecx
neg    %ecx
or     %rax,%rcx
mov    %rcx,0x100(%rsp)
fildll 0x100(%rsp)
fldt   0x30(%rsp)
fmulp  %st,%st(1)
fld    %st(1)
fsub   %st(1),%st
fldt   0xb4(%rsp)
fdivr  %st,%st(1)
fxch   %st(1)
fmulp  %st,%st(5)
fxch   %st(5)
fsubp  %st,%st(4)
fldt   0x54(%rsp)
fmul   %st,%st(1)
fxch   %st(4)
fsubp  %st,%st(1)
fmul   %st(2),%st
fmul   %st(2),%st
fldt   0x48(%rsp)
fadd   %st,%st(1)
fnstcw 0x14(%rsp)
movzwl 0x14(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x24(%rsp)
fldcw  0x24(%rsp)
fxch   %st(1)
fistpll 0x108(%rsp)
fldcw  0x14(%rsp)
mov    0x108(%rsp),%rcx
and    $0xfffff,%ecx
mov    %ecx,0x8c(%rsp)
fldt   0x3c(%rsp)
fimull 0x8c(%rsp)
fldt   0x6c(%rsp)
faddp  %st,%st(1)
fldt   0x78(%rsp)
faddp  %st,%st(1)
fnstcw 0x12(%rsp)
movzwl 0x12(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x22(%rsp)
fldcw  0x22(%rsp)
fistpll 0x110(%rsp)
fldcw  0x12(%rsp)
xor    %eax,%eax
sub    0x110(%rsp),%eax
shl    $0x14,%eax
or     %rax,%rcx
mov    %rcx,0x118(%rsp)
fildll 0x118(%rsp)
fldt   0x30(%rsp)
fmulp  %st,%st(1)
fsubr  %st,%st(2)
fxch   %st(2)
fdivp  %st,%st(5)
fldt   0xa8(%rsp)
fmulp  %st,%st(5)
fldt   0x60(%rsp)
fsubp  %st,%st(5)
fxch   %st(3)
fmulp  %st,%st(1)
fsubrp %st,%st(3)
fmul   %st,%st(2)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fnstcw 0x10(%rsp)
movzwl 0x10(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x20(%rsp)
fldcw  0x20(%rsp)
fistpll 0x120(%rsp)
fldcw  0x10(%rsp)
mov    0x120(%rsp),%rbx
and    $0xfffff,%ebx
or     %rax,%rbx
cvtsi2sd %rbx,%xmm0
movsd  0x989(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xc0(%rsp)
fldl   0xc0(%rsp)
fstpt  (%rsp)
call   1050 <sqrt@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1030 <printf@plt>
fldt   0x144(%rsp)
fadds  0x94d(%rip)
flds   0x91b(%rip)
fucomip %st(1),%st
jbe    1709 <main+0x5d9>
fldt   0x1f0(%rsp)
fldt   0x1b0(%rsp)
fldt   0x210(%rsp)
fstpt  0x30(%rsp)
fxch   %st(2)
jmp    11b0 <main+0x80>
fstp   %st(0)
xor    %eax,%eax
add    $0x2e8,%rsp
pop    %rbx
pop    %r14
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 i64
%16 = alloca x86_fp80
%17 = alloca x86_fp80
%18 = alloca x86_fp80
%19 = alloca x86_fp80
%20 = alloca x86_fp80
%21 = alloca x86_fp80
%22 = alloca x86_fp80
store i32 0, i32* %1
store x86_fp80 0xK3FF98000000000000000, x86_fp80* %10
%23 = load x86_fp80, x86_fp80* %10
%24 = fmul x86_fp80 %23, 0xK3FFE8000000000000000
store x86_fp80 %24, x86_fp80* %11
%25 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 0
%26 = bitcast [5 x x86_fp80]* %25 to x86_fp80**
%27 = call i32 @memset(x86_fp80** %26, i32 0, i32 400)
%28 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 0
%29 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %28, i64 0, i64 0
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %29
store i32 1, i32* %4
br label %30
30: ; preds = %44, %0
%31 = load i32, i32* %4
%32 = icmp slt i32 %31, 5
br i1 %32, label %33, label %47
33: ; preds = %30
%34 = load i32, i32* %4
%35 = sub nsw i32 %34, 1
%36 = shl i32 1, %35
%37 = sitofp i32 %36 to x86_fp80
%38 = load i32, i32* %4
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %39
%41 = load i32, i32* %4
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %40, i64 0, i64 %42
store x86_fp80 %37, x86_fp80* %43
br label %44
44: ; preds = %33
%45 = load i32, i32* %4
%46 = add nsw i32 %45, 1
store i32 %46, i32* %4
br label %30
47: ; preds = %30
%48 = load x86_fp80, x86_fp80* %11
%49 = fneg x86_fp80 %48
%50 = load x86_fp80, x86_fp80* %11
%51 = fmul x86_fp80 %49, %50
%52 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 2
%53 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %52, i64 0, i64 0
store x86_fp80 %51, x86_fp80* %53
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %6
br label %54
54: ; preds = %293, %47
%55 = load x86_fp80, x86_fp80* %6
%56 = fcmp olt x86_fp80 %55, 0xK40008000000000000000
br i1 %56, label %57, label %297
57: ; preds = %54
%58 = load x86_fp80, x86_fp80* %6
%59 = load x86_fp80, x86_fp80* %10
%60 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %59, x86_fp80 0xK3FFE8000000000000000, x86_fp80 %58)
store x86_fp80 %60, x86_fp80* %7
%61 = load x86_fp80, x86_fp80* %6
%62 = load x86_fp80, x86_fp80* %10
%63 = fadd x86_fp80 %61, %62
store x86_fp80 %63, x86_fp80* %8
%64 = load x86_fp80, x86_fp80* %11
%65 = load x86_fp80, x86_fp80* %7
%66 = fdiv x86_fp80 %64, %65
store x86_fp80 %66, x86_fp80* %9
%67 = load x86_fp80, x86_fp80* %7
%68 = fdiv x86_fp80 0xK3FFF8000000000000000, %67
%69 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 0
store x86_fp80 %68, x86_fp80* %69
store i32 1, i32* %4
br label %70
70: ; preds = %86, %57
%71 = load i32, i32* %4
%72 = icmp slt i32 %71, 5
br i1 %72, label %73, label %89
73: ; preds = %70
%74 = load i32, i32* %4
%75 = sub nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %76
%78 = load x86_fp80, x86_fp80* %77
%79 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 0
%80 = load x86_fp80, x86_fp80* %79
%81 = fneg x86_fp80 %80
%82 = fmul x86_fp80 %78, %81
%83 = load i32, i32* %4
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %84
store x86_fp80 %82, x86_fp80* %85
br label %86
86: ; preds = %73
%87 = load i32, i32* %4
%88 = add nsw i32 %87, 1
store i32 %88, i32* %4
br label %70
89: ; preds = %70
%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 1
%94 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %93, i64 0, i64 0
store x86_fp80 %92, x86_fp80* %94
%95 = load x86_fp80, x86_fp80* %9
%96 = load x86_fp80, x86_fp80* %11
%97 = fmul x86_fp80 %95, %96
%98 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 2
%99 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %98, i64 0, i64 1
store x86_fp80 %97, x86_fp80* %99
store i32 3, i32* %4
br label %100
100: ; preds = %157, %89
%101 = load i32, i32* %4
%102 = icmp slt i32 %101, 5
br i1 %102, label %103, label %160
103: ; preds = %100
%104 = load x86_fp80, x86_fp80* %11
%105 = fneg x86_fp80 %104
%106 = load x86_fp80, x86_fp80* %11
%107 = fmul x86_fp80 %105, %106
%108 = load i32, i32* %4
%109 = sub nsw i32 %108, 2
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %110
%112 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %111, i64 0, i64 0
%113 = load x86_fp80, x86_fp80* %112
%114 = fmul x86_fp80 %107, %113
%115 = load i32, i32* %4
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %116
%118 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %117, i64 0, i64 0
store x86_fp80 %114, x86_fp80* %118
store i32 1, i32* %5
br label %119
119: ; preds = %153, %103
%120 = load i32, i32* %5
%121 = load i32, i32* %4
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %156
123: ; preds = %119
%124 = load i32, i32* %4
%125 = sub nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %126
%128 = load i32, i32* %5
%129 = sub nsw i32 %128, 1
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %127, i64 0, i64 %130
%132 = load x86_fp80, x86_fp80* %131
%133 = load x86_fp80, x86_fp80* %11
%134 = load x86_fp80, x86_fp80* %11
%135 = fmul x86_fp80 %133, %134
%136 = load i32, i32* %4
%137 = sub nsw i32 %136, 2
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %138
%140 = load i32, i32* %5
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %139, i64 0, i64 %141
%143 = load x86_fp80, x86_fp80* %142
%144 = fmul x86_fp80 %135, %143
%145 = fneg x86_fp80 %144
%146 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xK40008000000000000000, x86_fp80 %132, x86_fp80 %145)
%147 = load i32, i32* %4
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %148
%150 = load i32, i32* %5
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %149, i64 0, i64 %151
store x86_fp80 %146, x86_fp80* %152
br label %153
153: ; preds = %123
%154 = load i32, i32* %5
%155 = add nsw i32 %154, 1
store i32 %155, i32* %5
br label %119
156: ; preds = %119
br label %157
157: ; preds = %156
%158 = load i32, i32* %4
%159 = add nsw i32 %158, 1
store i32 %159, i32* %4
br label %100
160: ; preds = %100
store i32 4, i32* %4
br label %161
161: ; preds = %200, %160
%162 = load i32, i32* %4
%163 = icmp sgt i32 %162, 1
br i1 %163, label %164, label %203
164: ; preds = %161
%165 = load i32, i32* %4
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %166
%168 = load x86_fp80, x86_fp80* %167
%169 = load i32, i32* %4
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %170
%172 = load i32, i32* %4
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %171, i64 0, i64 %173
%175 = load x86_fp80, x86_fp80* %174
%176 = fdiv x86_fp80 %168, %175
store x86_fp80 %176, x86_fp80* %16
store i32 0, i32* %5
br label %177
177: ; preds = %196, %164
%178 = load i32, i32* %5
%179 = load i32, i32* %4
%180 = icmp slt i32 %178, %179
br i1 %180, label %181, label %199
181: ; preds = %177
%182 = load x86_fp80, x86_fp80* %16
%183 = load i32, i32* %4
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 %184
%186 = load i32, i32* %5
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %185, i64 0, i64 %187
%189 = load x86_fp80, x86_fp80* %188
%190 = load i32, i32* %5
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 %191
%193 = load x86_fp80, x86_fp80* %192
%194 = fneg x86_fp80 %182
%195 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %194, x86_fp80 %189, x86_fp80 %193)
store x86_fp80 %195, x86_fp80* %192
br label %196
196: ; preds = %181
%197 = load i32, i32* %5
%198 = add nsw i32 %197, 1
store i32 %198, i32* %5
br label %177
199: ; preds = %177
br label %200
200: ; preds = %199
%201 = load i32, i32* %4
%202 = add nsw i32 %201, -1
store i32 %202, i32* %4
br label %161
203: ; preds = %161
store i64 0, i64* %14
store i32 0, i32* %4
store i64 0, i64* %12
br label %204
204: ; preds = %255, %203
%205 = load i32, i32* %4
%206 = icmp slt i32 %205, 4
br i1 %206, label %207, label %258
207: ; preds = %204
%208 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 1
%209 = load x86_fp80, x86_fp80* %208
%210 = load i64, i64* %12
%211 = sitofp i64 %210 to x86_fp80
%212 = fdiv x86_fp80 %211, 0xK40138000000000000000
%213 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %209, x86_fp80 0xK400B8000000000000000, x86_fp80 %212)
%214 = fsub x86_fp80 %213, 0xK3FFE8000000000000000
%215 = fptosi x86_fp80 %214 to i64
store i64 %215, i64* %13
%216 = load i64, i64* %13
%217 = sub nsw i64 0, %216
%218 = and i64 %217, 4095
%219 = sub nsw i64 0, %218
store i64 %219, i64* %13
%220 = load i64, i64* %13
%221 = sub nsw i64 0, %220
%222 = shl i64 %221, 20
%223 = trunc i64 %222 to i32
%224 = zext i32 %223 to i64
%225 = load i64, i64* %12
%226 = or i64 %224, %225
%227 = sitofp i64 %226 to x86_fp80
%228 = fdiv x86_fp80 %227, 0xKC01F8000000000000000
store x86_fp80 %228, x86_fp80* %18
%229 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 0
%230 = load x86_fp80, x86_fp80* %229
%231 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %2, i64 0, i64 1
%232 = load x86_fp80, x86_fp80* %231
%233 = load x86_fp80, x86_fp80* %18
%234 = fsub x86_fp80 %232, %233
%235 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 1
%236 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %235, i64 0, i64 1
%237 = load x86_fp80, x86_fp80* %236
%238 = fdiv x86_fp80 %234, %237
%239 = getelementptr inbounds [5 x [5 x x86_fp80]], [5 x [5 x x86_fp80]]* %3, i64 0, i64 1
%240 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* %239, i64 0, i64 0
%241 = load x86_fp80, x86_fp80* %240
%242 = fneg x86_fp80 %238
%243 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %242, x86_fp80 %241, x86_fp80 %230)
%244 = load x86_fp80, x86_fp80* %7
%245 = fsub x86_fp80 %244, 0xK3FFF8000000000000000
%246 = load x86_fp80, x86_fp80* %18
%247 = fneg x86_fp80 %245
%248 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %247, x86_fp80 %246, x86_fp80 %243)
store x86_fp80 %248, x86_fp80* %17
%249 = load x86_fp80, x86_fp80* %17
%250 = fmul x86_fp80 %249, 0xK40098000000000000000
%251 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %250, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%252 = fptosi x86_fp80 %251 to i64
store i64 %252, i64* %12
%253 = load i64, i64* %12
%254 = and i64 %253, 1048575
store i64 %254, i64* %12
br label %255
255: ; preds = %207
%256 = load i32, i32* %4
%257 = add nsw i32 %256, 1
store i32 %257, i32* %4
br label %204
258: ; preds = %204
%259 = load i64, i64* %13
%260 = sub nsw i64 0, %259
%261 = shl i64 %260, 20
%262 = trunc i64 %261 to i32
%263 = zext i32 %262 to i64
%264 = load i64, i64* %12
%265 = or i64 %263, %264
store i64 %265, i64* %15
%266 = load i64, i64* %15
%267 = trunc i64 %266 to i32
%268 = uitofp i32 %267 to double
%269 = fdiv double %268, -6.553600e+04
%270 = fdiv double %269, 6.553600e+04
%271 = fpext double %270 to x86_fp80
store x86_fp80 %271, x86_fp80* %19
%272 = load i64, i64* %15
%273 = shl i64 %272, 12
%274 = trunc i64 %273 to i32
%275 = uitofp i32 %274 to double
%276 = fdiv double %275, 6.553600e+04
%277 = fdiv double %276, 6.553600e+04
%278 = fpext double %277 to x86_fp80
store x86_fp80 %278, x86_fp80* %20
%279 = load x86_fp80, x86_fp80* %19
%280 = fneg x86_fp80 %279
%281 = call i32 @sqrt(x86_fp80 %280)
%282 = sitofp i32 %281 to double
%283 = fdiv double 1.000000e+00, %282
%284 = fpext double %283 to x86_fp80
store x86_fp80 %284, x86_fp80* %21
%285 = load x86_fp80, x86_fp80* %20
%286 = fneg x86_fp80 %285
%287 = fmul x86_fp80 0xK3FFE8000000000000000, %286
%288 = load x86_fp80, x86_fp80* %19
%289 = fdiv x86_fp80 %287, %288
%290 = fadd x86_fp80 0xK3FFE8000000000000000, %289
store x86_fp80 %290, x86_fp80* %22
%291 = load i64, i64* %15
%292 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i64 %291)
br label %293
293: ; preds = %258
%294 = load x86_fp80, x86_fp80* %10
%295 = load x86_fp80, x86_fp80* %6
%296 = fadd x86_fp80 %295, %294
store x86_fp80 %296, x86_fp80* %6
br label %54
297: ; preds = %54
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 = %155, %0
%23 = phi x86_fp80 [ 0xK40008000000000000000, %0 ], [ %158, %155 ]
%24 = phi x86_fp80 [ 0xK3FFF8000000000000000, %0 ], [ %157, %155 ]
%25 = phi x86_fp80 [ 0xKBFF18000000000000000, %0 ], [ %156, %155 ]
%26 = phi x86_fp80 [ 0xK3FFF8000000000000000, %0 ], [ %153, %155 ]
%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 0xK400B8000000000000000, x86_fp80 0xK00000000000000000000)
%68 = fadd x86_fp80 %67, 0xKBFFE8000000000000000
%69 = fptosi x86_fp80 %68 to i64
%70 = mul i64 %69, -1048576
%71 = and i64 %70, 4293918720
%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, 0xK40098000000000000000
%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, 1048575
%83 = sitofp i64 %82 to x86_fp80
%84 = fmul x86_fp80 %83, 0xK3FEB8000000000000000
%85 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400B8000000000000000, x86_fp80 %84)
%86 = fadd x86_fp80 %85, 0xKBFFE8000000000000000
%87 = fptosi x86_fp80 %86 to i64
%88 = mul i64 %87, -1048576
%89 = and i64 %88, 4293918720
%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, 0xK40098000000000000000
%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, 1048575
%102 = sitofp i64 %101 to x86_fp80
%103 = fmul x86_fp80 %102, 0xK3FEB8000000000000000
%104 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400B8000000000000000, x86_fp80 %103)
%105 = fadd x86_fp80 %104, 0xKBFFE8000000000000000
%106 = fptosi x86_fp80 %105 to i64
%107 = mul i64 %106, -1048576
%108 = and i64 %107, 4293918720
%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, 0xK40098000000000000000
%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, 1048575
%121 = sitofp i64 %120 to x86_fp80
%122 = fmul x86_fp80 %121, 0xK3FEB8000000000000000
%123 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %64, x86_fp80 0xK400B8000000000000000, x86_fp80 %122)
%124 = fadd x86_fp80 %123, 0xKBFFE8000000000000000
%125 = fptosi x86_fp80 %124 to i64
%126 = sub nsw i64 0, %125
%127 = shl i64 %126, 20
%128 = and i64 %127, 4293918720
%129 = or i64 %128, %120
%130 = sitofp i64 %129 to x86_fp80
%131 = fmul x86_fp80 %130, 0xKBFDF8000000000000000
%132 = fsub x86_fp80 %64, %131
%133 = fneg x86_fp80 %132
%134 = fdiv x86_fp80 %133, %24
%135 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %134, x86_fp80 %34, x86_fp80 %63)
%136 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %66, x86_fp80 %131, x86_fp80 %135)
%137 = fmul x86_fp80 %136, 0xK40098000000000000000
%138 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %137, x86_fp80 0xK40098000000000000000, x86_fp80 0xK3FFE8000000000000000)
%139 = fptosi x86_fp80 %138 to i64
%140 = and i64 %139, 1048575
%141 = and i64 %126, 4095
%142 = mul nsw i64 %141, -4293918720
%143 = and i64 %142, 4293918720
%144 = or i64 %143, %140
%145 = trunc i64 %144 to i32
%146 = uitofp i32 %145 to double
%147 = fmul double %146, 0xBEF0000000000000
%148 = fmul double %147, 0x3EF0000000000000
%149 = fpext double %148 to x86_fp80
%150 = fneg x86_fp80 %149
%151 = call i32 @sqrt(x86_fp80 %150)
%152 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i64 %144)
%153 = fadd x86_fp80 %26, 0xK3FF98000000000000000
%154 = fcmp olt x86_fp80 %153, 0xK40008000000000000000
br i1 %154, label %155, label %159
155: ; preds = %22
%156 = load x86_fp80, x86_fp80* %10
%157 = load x86_fp80, x86_fp80* %6
%158 = load x86_fp80, x86_fp80* %7
br label %22
159: ; preds = %22
ret i32 0
}