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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int eigenRealSym(double *, int, double *, double *);
double sqrt(double);
int eigenQREV(double Q[], double pi[], int n, double Root[], double U[],
              double V[], double spacesqrtpi[]) {
  int i, j, inew, jnew, nnew, status;
  double *pi_sqrt = spacesqrtpi, small = 1e-100;
  for (j = 0, nnew = 0; j < n; j++)
    if (pi[j] > small)
      pi_sqrt[nnew++] = sqrt(pi[j]);
  if (nnew == n) {
    for (i = 0; i < n; i++)
      for (j = 0, U[i * n + i] = Q[i * n + i]; j < i; j++)
        U[i * n + j] = U[j * n + i] = (Q[i * n + j] * pi_sqrt[i] / pi_sqrt[j]);
    status = eigenRealSym(U, n, Root, V);
    for (i = 0; i < n; i++)
      for (j = 0; j < n; j++)
        V[i * n + j] = U[j * n + i] * pi_sqrt[j];
    for (i = 0; i < n; i++)
      for (j = 0; j < n; j++)
        U[i * n + j] /= pi_sqrt[i];
  } else {
    for (i = 0, inew = 0; i < n; i++) {
      if (pi[i] > small) {
        for (j = 0, jnew = 0; j < i; j++)
          if (pi[j] > small) {
            U[inew * nnew + jnew] = U[jnew * nnew + inew] =
                Q[i * n + j] * pi_sqrt[inew] / pi_sqrt[jnew];
            jnew++;
          }
        U[inew * nnew + inew] = Q[i * n + i];
        inew++;
      }
    }
    status = eigenRealSym(U, nnew, Root, V);
    for (i = n - 1, inew = nnew - 1; i >= 0; i--)
      Root[i] = (pi[i] > small ? Root[inew--] : 0);
    for (i = n - 1, inew = nnew - 1; i >= 0; i--) {
      if (pi[i] > small) {
        for (j = n - 1, jnew = nnew - 1; j >= 0; j--)
          if (pi[j] > small) {
            V[i * n + j] = U[jnew * nnew + inew] * pi_sqrt[jnew];
            jnew--;
          } else
            V[i * n + j] = (i == j);
        inew--;
      } else
        for (j = 0; j < n; j++)
          V[i * n + j] = (i == j);
    }
    for (i = n - 1, inew = nnew - 1; i >= 0; i--) {
      if (pi[i] > small) {
        for (j = n - 1, jnew = nnew - 1; j >= 0; j--)
          if (pi[j] > small) {
            U[i * n + j] = U[inew * nnew + jnew] / pi_sqrt[inew];
            jnew--;
          } else
            U[i * n + j] = (i == j);
        inew--;
      } else
        for (j = 0; j < n; j++)
          U[i * n + j] = (i == j);
    }
  }
  return (status);
}


x86 assembly (clang, -O0):
<eigenQREV>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
movsd  0xead(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c6 <eigenQREV+0xa6>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    11b3 <eigenQREV+0x93>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <sqrt@plt>
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    11b8 <eigenQREV+0x98>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1166 <eigenQREV+0x46>
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    13b0 <eigenQREV+0x290>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a1 <eigenQREV+0x181>
movl   $0x0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    128e <eigenQREV+0x16e>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1218 <eigenQREV+0xf8>
jmp    1293 <eigenQREV+0x173>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d9 <eigenQREV+0xb9>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <eigenRealSym@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1338 <eigenQREV+0x218>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1325 <eigenQREV+0x205>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d2 <eigenQREV+0x1b2>
jmp    132a <eigenQREV+0x20a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12bf <eigenQREV+0x19f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ab <eigenQREV+0x28b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1398 <eigenQREV+0x278>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1352 <eigenQREV+0x232>
jmp    139d <eigenQREV+0x27d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133f <eigenQREV+0x21f>
jmp    1824 <eigenQREV+0x704>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14d4 <eigenQREV+0x3b4>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    14c1 <eigenQREV+0x3a1>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    148c <eigenQREV+0x36c>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1479 <eigenQREV+0x359>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    147e <eigenQREV+0x35e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13f0 <eigenQREV+0x2d0>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14c6 <eigenQREV+0x3a6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13be <eigenQREV+0x29e>
mov    -0x28(%rbp),%rdi
mov    -0x44(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <eigenRealSym@plt>
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     156d <eigenQREV+0x44d>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1540 <eigenQREV+0x420>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    154d <eigenQREV+0x42d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    154d <eigenQREV+0x42d>
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    14fd <eigenQREV+0x3dd>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     16c6 <eigenQREV+0x5a6>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1665 <eigenQREV+0x545>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1657 <eigenQREV+0x537>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    161c <eigenQREV+0x4fc>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1644 <eigenQREV+0x524>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1649 <eigenQREV+0x529>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    15b3 <eigenQREV+0x493>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    16b3 <eigenQREV+0x593>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16ae <eigenQREV+0x58e>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    166c <eigenQREV+0x54c>
jmp    16b3 <eigenQREV+0x593>
jmp    16b8 <eigenQREV+0x598>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    157f <eigenQREV+0x45f>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     181f <eigenQREV+0x6ff>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    17be <eigenQREV+0x69e>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     17b0 <eigenQREV+0x690>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1775 <eigenQREV+0x655>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    179d <eigenQREV+0x67d>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17a2 <eigenQREV+0x682>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    170c <eigenQREV+0x5ec>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    180c <eigenQREV+0x6ec>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1807 <eigenQREV+0x6e7>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17c5 <eigenQREV+0x6a5>
jmp    180c <eigenQREV+0x6ec>
jmp    1811 <eigenQREV+0x6f1>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    16d8 <eigenQREV+0x5b8>
jmp    1824 <eigenQREV+0x704>
mov    -0x48(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eigenQREV>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8,%r12
mov    %rcx,0x30(%rsp)
test   %edx,%edx
jle    119c <eigenQREV+0x7c>
mov    %rsi,%r13
mov    %r9,0x18(%rsp)
mov    %r12,0x20(%rsp)
mov    0x90(%rsp),%r15
mov    %edx,%r14d
mov    %rdx,0x38(%rsp)
cmp    $0x1,%edx
mov    %rdi,0x10(%rsp)
jne    11ae <eigenQREV+0x8e>
xor    %r12d,%r12d
xor    %esi,%esi
test   $0x1,%r14b
je     1281 <eigenQREV+0x161>
movsd  0x0(%r13,%r12,8),%xmm0
ucomisd 0xe81(%rip),%xmm0
jbe    1281 <eigenQREV+0x161>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1265 <eigenQREV+0x145>
sqrtsd %xmm0,%xmm0
jmp    1275 <eigenQREV+0x155>
xor    %esi,%esi
test   %edx,%edx
mov    %rdx,%r13
jne    195e <eigenQREV+0x83e>
jmp    1961 <eigenQREV+0x841>
mov    %r14d,%ebx
and    $0xfffffffe,%ebx
xor    %r12d,%r12d
movsd  0xe41(%rip),%xmm1
xorpd  %xmm2,%xmm2
xor    %esi,%esi
jmp    1205 <eigenQREV+0xe5>
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rbp
call   1040 <sqrt@plt>
xorpd  %xmm2,%xmm2
movsd  0xe1c(%rip),%xmm1
mov    0x10(%rsp),%rdi
mov    %rbp,%rsi
movslq %esi,%rax
add    $0x1,%esi
movsd  %xmm0,(%r15,%rax,8)
add    $0x2,%r12
cmp    %r12,%rbx
je     1166 <eigenQREV+0x46>
movsd  0x0(%r13,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1248 <eigenQREV+0x128>
ucomisd %xmm2,%xmm0
jb     1220 <eigenQREV+0x100>
sqrtsd %xmm0,%xmm0
jmp    123c <eigenQREV+0x11c>
xchg   %ax,%ax
mov    %rsi,%rbp
call   1040 <sqrt@plt>
xorpd  %xmm2,%xmm2
movsd  0xdcc(%rip),%xmm1
mov    0x10(%rsp),%rdi
mov    %rbp,%rsi
movslq %esi,%rax
add    $0x1,%esi
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%r13,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    11f8 <eigenQREV+0xd8>
ucomisd %xmm2,%xmm0
jb     11d0 <eigenQREV+0xb0>
sqrtsd %xmm0,%xmm0
jmp    11ec <eigenQREV+0xcc>
mov    %rsi,%rbx
call   1040 <sqrt@plt>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
movslq %esi,%rax
add    $0x1,%esi
movsd  %xmm0,(%r15,%rax,8)
mov    0x38(%rsp),%rax
cmp    %eax,%esi
jne    1328 <eigenQREV+0x208>
test   %eax,%eax
mov    0x20(%rsp),%r12
mov    %rax,%r13
jle    1952 <eigenQREV+0x832>
lea    0x0(,%r14,8),%rbx
xor    %eax,%eax
mov    %r12,%rcx
mov    %rdi,%rdx
mov    %r12,%r8
jmp    12d7 <eigenQREV+0x1b7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
add    $0x8,%r8
add    %rbx,%rdx
add    %rbx,%rcx
cmp    %r14,%rax
je     13fd <eigenQREV+0x2dd>
mov    %eax,%esi
imul   %r13d,%esi
movslq %esi,%rsi
add    %rax,%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%r12,%rsi,8)
test   %rax,%rax
je     12c0 <eigenQREV+0x1a0>
mov    %r8,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
divsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%rsi)
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rbp
add    %rbx,%rsi
cmp    %rbp,%rax
jne    1300 <eigenQREV+0x1e0>
jmp    12c0 <eigenQREV+0x1a0>
test   %eax,%eax
mov    0x20(%rsp),%r12
jle    1959 <eigenQREV+0x839>
lea    0x0(,%r14,8),%rax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
movsd  0xcb4(%rip),%xmm1
mov    %rdi,%r11
xor    %r9d,%r9d
jmp    1388 <eigenQREV+0x268>
mov    %r9d,%ebx
imul   %esi,%ebx
xor    %r8d,%r8d
add    %rax,%r8
movsd  (%rdi,%r8,8),%xmm0
add    %r9d,%ebx
movslq %ebx,%rdx
movsd  %xmm0,(%r12,%rdx,8)
add    $0x1,%r9d
add    $0x1,%rax
add    0x10(%rsp),%r11
cmp    %r14,%rax
je     14d2 <eigenQREV+0x3b2>
movsd  0x0(%r13,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1376 <eigenQREV+0x256>
test   %rax,%rax
je     1354 <eigenQREV+0x234>
mov    %rax,%r8
imul   %r14,%r8
movslq %r9d,%r10
mov    %r9d,%ebx
imul   %esi,%ebx
xor    %ecx,%ecx
xor    %edx,%edx
jmp    13b9 <eigenQREV+0x299>
add    $0x1,%rcx
cmp    %rcx,%rax
je     135d <eigenQREV+0x23d>
movsd  0x0(%r13,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    13b0 <eigenQREV+0x290>
movsd  (%r11,%rcx,8),%xmm0
mulsd  (%r15,%r10,8),%xmm0
movslq %edx,%rdx
divsd  (%r15,%rdx,8),%xmm0
mov    %edx,%ebp
imul   %esi,%ebp
add    %r9d,%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%r12,%rbp,8)
lea    (%rdx,%rbx,1),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%r12,%rbp,8)
add    $0x1,%edx
jmp    13b0 <eigenQREV+0x290>
mov    %r12,%rdi
mov    %r13d,%esi
mov    0x30(%rsp),%rdx
mov    0x18(%rsp),%rbp
mov    %rbp,%rcx
call   1030 <eigenRealSym@plt>
test   %r13d,%r13d
jle    1ba6 <eigenQREV+0xa86>
mov    %r14d,%r10d
and    $0xfffffffe,%r10d
mov    %r14,%rcx
shl    $0x4,%rcx
lea    0x8(%rbp),%rdx
xor    %r9d,%r9d
mov    %r12,%r8
jmp    1454 <eigenQREV+0x334>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x8,%r8
add    %rbx,%rdx
cmp    %r14,%r9
je     15b4 <eigenQREV+0x494>
cmp    $0x1,%r13d
jne    1460 <eigenQREV+0x340>
xor    %ebp,%ebp
jmp    149d <eigenQREV+0x37d>
xchg   %ax,%ax
mov    %r8,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi),%xmm0
mulsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rbp,8)
movsd  (%rsi,%rbx,1),%xmm0
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rsi
cmp    %rbp,%r10
jne    1470 <eigenQREV+0x350>
test   $0x1,%r14b
je     1440 <eigenQREV+0x320>
mov    %r9,%rsi
imul   %r14,%rsi
mov    %rbp,%rdi
imul   %r14,%rdi
add    %r9,%rdi
movsd  (%r12,%rdi,8),%xmm0
mulsd  (%r15,%rbp,8),%xmm0
add    %rbp,%rsi
mov    0x18(%rsp),%rdi
movsd  %xmm0,(%rdi,%rsi,8)
jmp    1440 <eigenQREV+0x320>
mov    %r12,%rdi
mov    0x30(%rsp),%rbx
mov    %rbx,%rdx
mov    0x18(%rsp),%rcx
mov    %rsi,%rbp
call   1030 <eigenRealSym@plt>
mov    0x38(%rsp),%rcx
test   %ecx,%ecx
jle    1ba6 <eigenQREV+0xa86>
lea    -0x1(%rbp),%esi
lea    -0x1(%rcx),%edx
mov    %rdx,%rcx
mov    %esi,0xc(%rsp)
test   $0x1,%dl
movsd  0xaf1(%rip),%xmm2
jne    1540 <eigenQREV+0x420>
movsd  0x0(%r13,%rdx,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd 0xadc(%rip),%xmm1
mov    0xc(%rsp),%esi
jbe    1537 <eigenQREV+0x417>
lea    -0x2(%rbp),%esi
movslq 0xc(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    -0x1(%rdx),%rcx
test   %rdx,%rdx
je     1749 <eigenQREV+0x629>
add    $0x2,%rcx
jmp    1564 <eigenQREV+0x444>
nop
movsd  %xmm0,-0x18(%rbx,%rcx,8)
add    $0xfffffffffffffffe,%rcx
cmp    $0x1,%rcx
jle    1749 <eigenQREV+0x629>
movsd  -0x10(%r13,%rcx,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm1
jbe    1590 <eigenQREV+0x470>
movslq %esi,%rdx
add    $0xffffffff,%esi
movsd  (%rbx,%rdx,8),%xmm1
jmp    1594 <eigenQREV+0x474>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x10(%rbx,%rcx,8)
movsd  -0x18(%r13,%rcx,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1550 <eigenQREV+0x430>
movslq %esi,%rdx
add    $0xffffffff,%esi
movsd  (%rbx,%rdx,8),%xmm0
jmp    1550 <eigenQREV+0x430>
test   %r13d,%r13d
jle    1ba6 <eigenQREV+0xa86>
mov    %eax,0x2c(%rsp)
mov    %r14d,%r9d
and    $0xfffffffe,%r9d
add    $0xfffffffffffffffe,%r9
mov    %r9,%r10
shr    %r10
add    $0x1,%r10
mov    %r14d,%r11d
and    $0xfffffffe,%r11d
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x10(%rsp)
mov    %r14,%r13
neg    %r13
lea    0x10(%r12),%rbx
mov    %r12,%rcx
lea    0x0(,%r14,8),%r12
xor    %eax,%eax
mov    0x20(%rsp),%r8
jmp    1623 <eigenQREV+0x503>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r12,%rbx
add    %r12,%rcx
cmp    %r14,%rax
je     1ba2 <eigenQREV+0xa82>
mov    %rax,%rdx
imul   %r14,%rdx
cmpl   $0x2,0x38(%rsp)
jb     1659 <eigenQREV+0x539>
mov    %rax,%rsi
imul   %r14,%rsi
lea    (%r15,%rax,8),%rdi
add    $0x8,%rdi
lea    (%r8,%rsi,8),%rbp
cmp    %rdi,%rbp
jae    16c0 <eigenQREV+0x5a0>
lea    (%r15,%rax,8),%rdi
add    %r14,%rsi
lea    (%r8,%rsi,8),%rsi
cmp    %rsi,%rdi
jae    16c0 <eigenQREV+0x5a0>
xor    %esi,%esi
mov    %rsi,%rdi
test   $0x1,%r14b
je     1683 <eigenQREV+0x563>
add    %rsi,%rdx
mov    0x20(%rsp),%rdi
movsd  (%rdi,%rdx,8),%xmm0
divsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    %r13,%rsi
je     1610 <eigenQREV+0x4f0>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm0
divsd  (%r15,%rax,8),%xmm0
movsd  0x8(%rcx,%rdi,8),%xmm1
movsd  %xmm0,(%rcx,%rdi,8)
divsd  (%r15,%rax,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r14
jne    1690 <eigenQREV+0x570>
jmp    1610 <eigenQREV+0x4f0>
test   %r9,%r9
je     173f <eigenQREV+0x61f>
movsd  (%r15,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    0x10(%rsp),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rbx,%rdi,8),%xmm1
movupd (%rbx,%rdi,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rbx,%rdi,8)
divpd  %xmm0,%xmm2
movupd %xmm2,(%rbx,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rsi
jne    16e0 <eigenQREV+0x5c0>
test   $0x1,%r10b
je     172e <eigenQREV+0x60e>
movsd  (%r15,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
add    %rdx,%rdi
mov    0x20(%rsp),%rsi
movupd (%rsi,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rdi,8)
mov    %r11,%rsi
cmp    %r14,%r11
je     1610 <eigenQREV+0x4f0>
jmp    165b <eigenQREV+0x53b>
xor    %edi,%edi
test   $0x1,%r10b
jne    170e <eigenQREV+0x5ee>
jmp    172e <eigenQREV+0x60e>
cmpl   $0x0,0x38(%rsp)
jle    1ba6 <eigenQREV+0xa86>
mov    %eax,0x2c(%rsp)
lea    -0x1(%r14),%r11
lea    -0x1(%r14),%rax
mov    %rax,0x48(%rsp)
mov    %r14d,%r12d
and    $0x3,%r12d
mov    %r14d,%ebx
and    $0xfffffffc,%ebx
mov    %r11,%rcx
imul   %r14,%rcx
mov    0x18(%rsp),%rax
mov    %rcx,0x30(%rsp)
lea    (%rax,%rcx,8),%rsi
add    $0x18,%rsi
negq   0x10(%rsp)
mov    %r14,%rcx
imul   %r14,%rcx
mov    %rcx,0x50(%rsp)
lea    (%rax,%rcx,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    -0x8(,%r14,8),%r8
ff
add    %r13,%r8
xor    %eax,%eax
movsd  0x84f(%rip),%xmm0
mov    0xc(%rsp),%r9d
mov    %rbx,0x40(%rsp)
mov    0x20(%rsp),%r10
jmp    17fd <eigenQREV+0x6dd>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%r9d
mov    0x40(%rsp),%rbx
lea    -0x1(%r11),%rdx
mov    0x10(%rsp),%rdi
add    %rdi,%rsi
sub    %r14,0x30(%rsp)
add    %rdi,%rcx
add    $0xffffffffffffffff,%rax
test   %r11,%r11
mov    %rdx,%r11
jle    1982 <eigenQREV+0x862>
movsd  0x0(%r13,%r11,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1880 <eigenQREV+0x760>
xor    %edi,%edi
mov    0xc(%rsp),%ebx
jmp    1836 <eigenQREV+0x716>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm1,(%rcx,%rdi,8)
lea    (%r14,%rdi,1),%rdx
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rdi
test   %rdx,%rdx
jle    17d0 <eigenQREV+0x6b0>
movsd  (%r8,%rdi,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1870 <eigenQREV+0x750>
movslq %ebx,%rdx
imul   %ebp,%ebx
add    %r9d,%ebx
movslq %ebx,%rbx
movsd  (%r10,%rbx,8),%xmm1
mulsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    $0xffffffff,%edx
mov    %edx,%ebx
jmp    1825 <eigenQREV+0x705>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
cmp    %rdi,%rax
je     1820 <eigenQREV+0x700>
xorpd  %xmm1,%xmm1
jmp    1820 <eigenQREV+0x700>
nop
cmpq   $0x3,0x48(%rsp)
jae    18e0 <eigenQREV+0x7c0>
xor    %edi,%edi
test   %r12,%r12
je     17d9 <eigenQREV+0x6b9>
mov    0x30(%rsp),%rdx
add    %rdi,%rdx
mov    0x18(%rsp),%rbx
lea    (%rbx,%rdx,8),%rbx
mov    %r11,%rdx
sub    %rdi,%rdx
xor    %edi,%edi
jmp    18c2 <eigenQREV+0x7a2>
xchg   %ax,%ax
movsd  %xmm1,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r12
je     17d4 <eigenQREV+0x6b4>
movapd %xmm0,%xmm1
cmp    %rdi,%rdx
je     18b0 <eigenQREV+0x790>
xorpd  %xmm1,%xmm1
jmp    18b0 <eigenQREV+0x790>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
jmp    18fe <eigenQREV+0x7de>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm1,(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rbx,%rdi
je     188a <eigenQREV+0x76a>
movapd %xmm0,%xmm1
cmp    %rdi,%r11
je     190b <eigenQREV+0x7eb>
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x18(%rsi,%rdi,8)
lea    0x1(%rdi),%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r11
je     1922 <eigenQREV+0x802>
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x10(%rsi,%rdi,8)
lea    0x2(%rdi),%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r11
je     1939 <eigenQREV+0x819>
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x8(%rsi,%rdi,8)
lea    0x3(%rdi),%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r11
je     18f0 <eigenQREV+0x7d0>
xorpd  %xmm1,%xmm1
jmp    18f0 <eigenQREV+0x7d0>
mov    0x18(%rsp),%r9
jmp    1961 <eigenQREV+0x841>
mov    0x18(%rsp),%r9
mov    %esi,%r13d
mov    %r12,%rdi
mov    %r13d,%esi
mov    0x30(%rsp),%rdx
mov    %r9,%rcx
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <eigenRealSym@plt>
cmpl   $0x0,0x38(%rsp)
jle    1ba2 <eigenQREV+0xa82>
mov    %rbp,0x30(%rsp)
lea    -0x1(%r14),%r10
mov    %r14d,%r12d
and    $0x3,%r12d
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
mov    %r10,%r9
imul   %r14,%r9
mov    0x20(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
add    $0x18,%rax
mov    0x50(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    -0x8(,%r14,8),%rdi
ff
add    %r13,%rdi
xor    %ebp,%ebp
movsd  0x62e(%rip),%xmm0
mov    %r10,0x40(%rsp)
mov    0xc(%rsp),%edx
mov    %edx,0x38(%rsp)
mov    %r8,0x48(%rsp)
mov    0x20(%rsp),%r11
jmp    1a31 <eigenQREV+0x911>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addl   $0xffffffff,0x38(%rsp)
mov    0x48(%rsp),%r8
mov    0x18(%rsp),%r9
lea    -0x1(%r10),%rdx
mov    0x10(%rsp),%rsi
add    %rsi,%rax
sub    %r14,%r9
add    %rsi,%rcx
add    $0xffffffffffffffff,%rbp
test   %r10,%r10
mov    %rdx,%r10
jle    1ba2 <eigenQREV+0xa82>
movsd  0x0(%r13,%r10,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1ad0 <eigenQREV+0x9b0>
mov    %r9,0x18(%rsp)
mov    0x38(%rsp),%edx
mov    %edx,%esi
imul   0x30(%rsp),%esi
movslq %edx,%rbx
xor    %r8d,%r8d
mov    0xc(%rsp),%edx
mov    %edx,%r9d
jmp    1a8b <eigenQREV+0x96b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,(%rcx,%r8,8)
lea    (%r14,%r8,1),%rdx
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%r8
test   %rdx,%rdx
jle    1a00 <eigenQREV+0x8e0>
movsd  (%rdi,%r8,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1ac0 <eigenQREV+0x9a0>
lea    (%r9,%rsi,1),%edx
movslq %edx,%rdx
movsd  (%r11,%rdx,8),%xmm1
divsd  (%r15,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%r8,8)
add    $0xffffffff,%r9d
jmp    1a76 <eigenQREV+0x956>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
cmp    %r8,%rbp
je     1a70 <eigenQREV+0x950>
xorpd  %xmm1,%xmm1
jmp    1a70 <eigenQREV+0x950>
nop
cmpq   $0x3,0x40(%rsp)
jae    1b30 <eigenQREV+0xa10>
xor    %esi,%esi
test   %r12,%r12
je     1a0f <eigenQREV+0x8ef>
lea    (%rsi,%r9,1),%rdx
mov    0x20(%rsp),%rbx
lea    (%rbx,%rdx,8),%rbx
mov    %r10,%rdx
sub    %rsi,%rdx
xor    %esi,%esi
jmp    1b12 <eigenQREV+0x9f2>
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,(%rbx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r12
je     1a0f <eigenQREV+0x8ef>
movapd %xmm0,%xmm1
cmp    %rsi,%rdx
je     1b00 <eigenQREV+0x9e0>
xorpd  %xmm1,%xmm1
jmp    1b00 <eigenQREV+0x9e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
jmp    1b4e <eigenQREV+0xa2e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm1,(%rax,%rsi,8)
add    $0x4,%rsi
cmp    %r8,%rsi
je     1ada <eigenQREV+0x9ba>
movapd %xmm0,%xmm1
cmp    %rsi,%r10
je     1b5b <eigenQREV+0xa3b>
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x18(%rax,%rsi,8)
lea    0x1(%rsi),%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r10
je     1b72 <eigenQREV+0xa52>
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x10(%rax,%rsi,8)
lea    0x2(%rsi),%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r10
je     1b89 <eigenQREV+0xa69>
xorpd  %xmm1,%xmm1
movsd  %xmm1,-0x8(%rax,%rsi,8)
lea    0x3(%rsi),%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r10
je     1b40 <eigenQREV+0xa20>
xorpd  %xmm1,%xmm1
jmp    1b40 <eigenQREV+0xa20>
mov    0x2c(%rsp),%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @eigenQREV(double* %0, double* %1, i32 %2, double* %3, double* %4, double* %5, double* %6) {
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca double*
%22 = alloca double
store double* %0, double** %8
store double* %1, double** %9
store i32 %2, i32* %10
store double* %3, double** %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%23 = load double*, double** %14
store double* %23, double** %21
store double 1.000000e-100, double* %22
store i32 0, i32* %16
store i32 0, i32* %19
br label %24
24: ; preds = %49, %7
%25 = load i32, i32* %16
%26 = load i32, i32* %10
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %52
28: ; preds = %24
%29 = load double*, double** %9
%30 = load i32, i32* %16
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = load double, double* %22
%35 = fcmp ogt double %33, %34
br i1 %35, label %36, label %48
36: ; preds = %28
%37 = load double*, double** %9
%38 = load i32, i32* %16
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %37, i64 %39
%41 = load double, double* %40
%42 = call double @sqrt(double %41)
%43 = load double*, double** %21
%44 = load i32, i32* %19
%45 = add nsw i32 %44, 1
store i32 %45, i32* %19
%46 = sext i32 %44 to i64
%47 = getelementptr inbounds double, double* %43, i64 %46
store double %42, double* %47
br label %48
48: ; preds = %36, %28
br label %49
49: ; preds = %48
%50 = load i32, i32* %16
%51 = add nsw i32 %50, 1
store i32 %51, i32* %16
br label %24
52: ; preds = %24
%53 = load i32, i32* %19
%54 = load i32, i32* %10
%55 = icmp eq i32 %53, %54
br i1 %55, label %56, label %208
56: ; preds = %52
store i32 0, i32* %15
br label %57
57: ; preds = %125, %56
%58 = load i32, i32* %15
%59 = load i32, i32* %10
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %128
61: ; preds = %57
store i32 0, i32* %16
%62 = load double*, double** %8
%63 = load i32, i32* %15
%64 = load i32, i32* %10
%65 = mul nsw i32 %63, %64
%66 = load i32, i32* %15
%67 = add nsw i32 %65, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %62, i64 %68
%70 = load double, double* %69
%71 = load double*, double** %12
%72 = load i32, i32* %15
%73 = load i32, i32* %10
%74 = mul nsw i32 %72, %73
%75 = load i32, i32* %15
%76 = add nsw i32 %74, %75
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %71, i64 %77
store double %70, double* %78
br label %79
79: ; preds = %121, %61
%80 = load i32, i32* %16
%81 = load i32, i32* %15
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %124
83: ; preds = %79
%84 = load double*, double** %8
%85 = load i32, i32* %15
%86 = load i32, i32* %10
%87 = mul nsw i32 %85, %86
%88 = load i32, i32* %16
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %84, i64 %90
%92 = load double, double* %91
%93 = load double*, double** %21
%94 = load i32, i32* %15
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = load double, double* %96
%98 = fmul double %92, %97
%99 = load double*, double** %21
%100 = load i32, i32* %16
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
%103 = load double, double* %102
%104 = fdiv double %98, %103
%105 = load double*, double** %12
%106 = load i32, i32* %16
%107 = load i32, i32* %10
%108 = mul nsw i32 %106, %107
%109 = load i32, i32* %15
%110 = add nsw i32 %108, %109
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %105, i64 %111
store double %104, double* %112
%113 = load double*, double** %12
%114 = load i32, i32* %15
%115 = load i32, i32* %10
%116 = mul nsw i32 %114, %115
%117 = load i32, i32* %16
%118 = add nsw i32 %116, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %113, i64 %119
store double %104, double* %120
br label %121
121: ; preds = %83
%122 = load i32, i32* %16
%123 = add nsw i32 %122, 1
store i32 %123, i32* %16
br label %79
124: ; preds = %79
br label %125
125: ; preds = %124
%126 = load i32, i32* %15
%127 = add nsw i32 %126, 1
store i32 %127, i32* %15
br label %57
128: ; preds = %57
%129 = load double*, double** %12
%130 = load i32, i32* %10
%131 = load double*, double** %11
%132 = load double*, double** %13
%133 = call i32 @eigenRealSym(double* %129, i32 %130, double* %131, double* %132)
store i32 %133, i32* %20
store i32 0, i32* %15
br label %134
134: ; preds = %171, %128
%135 = load i32, i32* %15
%136 = load i32, i32* %10
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %174
138: ; preds = %134
store i32 0, i32* %16
br label %139
139: ; preds = %167, %138
%140 = load i32, i32* %16
%141 = load i32, i32* %10
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %170
143: ; preds = %139
%144 = load double*, double** %12
%145 = load i32, i32* %16
%146 = load i32, i32* %10
%147 = mul nsw i32 %145, %146
%148 = load i32, i32* %15
%149 = add nsw i32 %147, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %144, i64 %150
%152 = load double, double* %151
%153 = load double*, double** %21
%154 = load i32, i32* %16
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %153, i64 %155
%157 = load double, double* %156
%158 = fmul double %152, %157
%159 = load double*, double** %13
%160 = load i32, i32* %15
%161 = load i32, i32* %10
%162 = mul nsw i32 %160, %161
%163 = load i32, i32* %16
%164 = add nsw i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %159, i64 %165
store double %158, double* %166
br label %167
167: ; preds = %143
%168 = load i32, i32* %16
%169 = add nsw i32 %168, 1
store i32 %169, i32* %16
br label %139
170: ; preds = %139
br label %171
171: ; preds = %170
%172 = load i32, i32* %15
%173 = add nsw i32 %172, 1
store i32 %173, i32* %15
br label %134
174: ; preds = %134
store i32 0, i32* %15
br label %175
175: ; preds = %204, %174
%176 = load i32, i32* %15
%177 = load i32, i32* %10
%178 = icmp slt i32 %176, %177
br i1 %178, label %179, label %207
179: ; preds = %175
store i32 0, i32* %16
br label %180
180: ; preds = %200, %179
%181 = load i32, i32* %16
%182 = load i32, i32* %10
%183 = icmp slt i32 %181, %182
br i1 %183, label %184, label %203
184: ; preds = %180
%185 = load double*, double** %21
%186 = load i32, i32* %15
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %185, i64 %187
%189 = load double, double* %188
%190 = load double*, double** %12
%191 = load i32, i32* %15
%192 = load i32, i32* %10
%193 = mul nsw i32 %191, %192
%194 = load i32, i32* %16
%195 = add nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %190, i64 %196
%198 = load double, double* %197
%199 = fdiv double %198, %189
store double %199, double* %197
br label %200
200: ; preds = %184
%201 = load i32, i32* %16
%202 = add nsw i32 %201, 1
store i32 %202, i32* %16
br label %180
203: ; preds = %180
br label %204
204: ; preds = %203
%205 = load i32, i32* %15
%206 = add nsw i32 %205, 1
store i32 %206, i32* %15
br label %175
207: ; preds = %175
br label %553
208: ; preds = %52
store i32 0, i32* %15
store i32 0, i32* %17
br label %209
209: ; preds = %299, %208
%210 = load i32, i32* %15
%211 = load i32, i32* %10
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %302
213: ; preds = %209
%214 = load double*, double** %9
%215 = load i32, i32* %15
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %214, i64 %216
%218 = load double, double* %217
%219 = load double, double* %22
%220 = fcmp ogt double %218, %219
br i1 %220, label %221, label %298
221: ; preds = %213
store i32 0, i32* %16
store i32 0, i32* %18
br label %222
222: ; preds = %275, %221
%223 = load i32, i32* %16
%224 = load i32, i32* %15
%225 = icmp slt i32 %223, %224
br i1 %225, label %226, label %278
226: ; preds = %222
%227 = load double*, double** %9
%228 = load i32, i32* %16
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double, double* %227, i64 %229
%231 = load double, double* %230
%232 = load double, double* %22
%233 = fcmp ogt double %231, %232
br i1 %233, label %234, label %274
234: ; preds = %226
%235 = load double*, double** %8
%236 = load i32, i32* %15
%237 = load i32, i32* %10
%238 = mul nsw i32 %236, %237
%239 = load i32, i32* %16
%240 = add nsw i32 %238, %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %235, i64 %241
%243 = load double, double* %242
%244 = load double*, double** %21
%245 = load i32, i32* %17
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %244, i64 %246
%248 = load double, double* %247
%249 = fmul double %243, %248
%250 = load double*, double** %21
%251 = load i32, i32* %18
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = fdiv double %249, %254
%256 = load double*, double** %12
%257 = load i32, i32* %18
%258 = load i32, i32* %19
%259 = mul nsw i32 %257, %258
%260 = load i32, i32* %17
%261 = add nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %256, i64 %262
store double %255, double* %263
%264 = load double*, double** %12
%265 = load i32, i32* %17
%266 = load i32, i32* %19
%267 = mul nsw i32 %265, %266
%268 = load i32, i32* %18
%269 = add nsw i32 %267, %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %264, i64 %270
store double %255, double* %271
%272 = load i32, i32* %18
%273 = add nsw i32 %272, 1
store i32 %273, i32* %18
br label %274
274: ; preds = %234, %226
br label %275
275: ; preds = %274
%276 = load i32, i32* %16
%277 = add nsw i32 %276, 1
store i32 %277, i32* %16
br label %222
278: ; preds = %222
%279 = load double*, double** %8
%280 = load i32, i32* %15
%281 = load i32, i32* %10
%282 = mul nsw i32 %280, %281
%283 = load i32, i32* %15
%284 = add nsw i32 %282, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %279, i64 %285
%287 = load double, double* %286
%288 = load double*, double** %12
%289 = load i32, i32* %17
%290 = load i32, i32* %19
%291 = mul nsw i32 %289, %290
%292 = load i32, i32* %17
%293 = add nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %288, i64 %294
store double %287, double* %295
%296 = load i32, i32* %17
%297 = add nsw i32 %296, 1
store i32 %297, i32* %17
br label %298
298: ; preds = %278, %213
br label %299
299: ; preds = %298
%300 = load i32, i32* %15
%301 = add nsw i32 %300, 1
store i32 %301, i32* %15
br label %209
302: ; preds = %209
%303 = load double*, double** %12
%304 = load i32, i32* %19
%305 = load double*, double** %11
%306 = load double*, double** %13
%307 = call i32 @eigenRealSym(double* %303, i32 %304, double* %305, double* %306)
store i32 %307, i32* %20
%308 = load i32, i32* %10
%309 = sub nsw i32 %308, 1
store i32 %309, i32* %15
%310 = load i32, i32* %19
%311 = sub nsw i32 %310, 1
store i32 %311, i32* %17
br label %312
312: ; preds = %337, %302
%313 = load i32, i32* %15
%314 = icmp sge i32 %313, 0
br i1 %314, label %315, label %340
315: ; preds = %312
%316 = load double*, double** %9
%317 = load i32, i32* %15
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = load double, double* %22
%322 = fcmp ogt double %320, %321
br i1 %322, label %323, label %330
323: ; preds = %315
%324 = load double*, double** %11
%325 = load i32, i32* %17
%326 = add nsw i32 %325, -1
store i32 %326, i32* %17
%327 = sext i32 %325 to i64
%328 = getelementptr inbounds double, double* %324, i64 %327
%329 = load double, double* %328
br label %331
330: ; preds = %315
br label %331
331: ; preds = %330, %323
%332 = phi double [ %329, %323 ], [ 0.000000e+00, %330 ]
%333 = load double*, double** %11
%334 = load i32, i32* %15
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds double, double* %333, i64 %335
store double %332, double* %336
br label %337
337: ; preds = %331
%338 = load i32, i32* %15
%339 = add nsw i32 %338, -1
store i32 %339, i32* %15
br label %312
340: ; preds = %312
%341 = load i32, i32* %10
%342 = sub nsw i32 %341, 1
store i32 %342, i32* %15
%343 = load i32, i32* %19
%344 = sub nsw i32 %343, 1
store i32 %344, i32* %17
br label %345
345: ; preds = %443, %340
%346 = load i32, i32* %15
%347 = icmp sge i32 %346, 0
br i1 %347, label %348, label %446
348: ; preds = %345
%349 = load double*, double** %9
%350 = load i32, i32* %15
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %349, i64 %351
%353 = load double, double* %352
%354 = load double, double* %22
%355 = fcmp ogt double %353, %354
br i1 %355, label %356, label %419
356: ; preds = %348
%357 = load i32, i32* %10
%358 = sub nsw i32 %357, 1
store i32 %358, i32* %16
%359 = load i32, i32* %19
%360 = sub nsw i32 %359, 1
store i32 %360, i32* %18
br label %361
361: ; preds = %413, %356
%362 = load i32, i32* %16
%363 = icmp sge i32 %362, 0
br i1 %363, label %364, label %416
364: ; preds = %361
%365 = load double*, double** %9
%366 = load i32, i32* %16
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %365, i64 %367
%369 = load double, double* %368
%370 = load double, double* %22
%371 = fcmp ogt double %369, %370
br i1 %371, label %372, label %398
372: ; preds = %364
%373 = load double*, double** %12
%374 = load i32, i32* %18
%375 = load i32, i32* %19
%376 = mul nsw i32 %374, %375
%377 = load i32, i32* %17
%378 = add nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %373, i64 %379
%381 = load double, double* %380
%382 = load double*, double** %21
%383 = load i32, i32* %18
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %382, i64 %384
%386 = load double, double* %385
%387 = fmul double %381, %386
%388 = load double*, double** %13
%389 = load i32, i32* %15
%390 = load i32, i32* %10
%391 = mul nsw i32 %389, %390
%392 = load i32, i32* %16
%393 = add nsw i32 %391, %392
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %388, i64 %394
store double %387, double* %395
%396 = load i32, i32* %18
%397 = add nsw i32 %396, -1
store i32 %397, i32* %18
br label %412
398: ; preds = %364
%399 = load i32, i32* %15
%400 = load i32, i32* %16
%401 = icmp eq i32 %399, %400
%402 = zext i1 %401 to i32
%403 = sitofp i32 %402 to double
%404 = load double*, double** %13
%405 = load i32, i32* %15
%406 = load i32, i32* %10
%407 = mul nsw i32 %405, %406
%408 = load i32, i32* %16
%409 = add nsw i32 %407, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double, double* %404, i64 %410
store double %403, double* %411
br label %412
412: ; preds = %398, %372
br label %413
413: ; preds = %412
%414 = load i32, i32* %16
%415 = add nsw i32 %414, -1
store i32 %415, i32* %16
br label %361
416: ; preds = %361
%417 = load i32, i32* %17
%418 = add nsw i32 %417, -1
store i32 %418, i32* %17
br label %442
419: ; preds = %348
store i32 0, i32* %16
br label %420
420: ; preds = %438, %419
%421 = load i32, i32* %16
%422 = load i32, i32* %10
%423 = icmp slt i32 %421, %422
br i1 %423, label %424, label %441
424: ; preds = %420
%425 = load i32, i32* %15
%426 = load i32, i32* %16
%427 = icmp eq i32 %425, %426
%428 = zext i1 %427 to i32
%429 = sitofp i32 %428 to double
%430 = load double*, double** %13
%431 = load i32, i32* %15
%432 = load i32, i32* %10
%433 = mul nsw i32 %431, %432
%434 = load i32, i32* %16
%435 = add nsw i32 %433, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %430, i64 %436
store double %429, double* %437
br label %438
438: ; preds = %424
%439 = load i32, i32* %16
%440 = add nsw i32 %439, 1
store i32 %440, i32* %16
br label %420
441: ; preds = %420
br label %442
442: ; preds = %441, %416
br label %443
443: ; preds = %442
%444 = load i32, i32* %15
%445 = add nsw i32 %444, -1
store i32 %445, i32* %15
br label %345
446: ; preds = %345
%447 = load i32, i32* %10
%448 = sub nsw i32 %447, 1
store i32 %448, i32* %15
%449 = load i32, i32* %19
%450 = sub nsw i32 %449, 1
store i32 %450, i32* %17
br label %451
451: ; preds = %549, %446
%452 = load i32, i32* %15
%453 = icmp sge i32 %452, 0
br i1 %453, label %454, label %552
454: ; preds = %451
%455 = load double*, double** %9
%456 = load i32, i32* %15
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds double, double* %455, i64 %457
%459 = load double, double* %458
%460 = load double, double* %22
%461 = fcmp ogt double %459, %460
br i1 %461, label %462, label %525
462: ; preds = %454
%463 = load i32, i32* %10
%464 = sub nsw i32 %463, 1
store i32 %464, i32* %16
%465 = load i32, i32* %19
%466 = sub nsw i32 %465, 1
store i32 %466, i32* %18
br label %467
467: ; preds = %519, %462
%468 = load i32, i32* %16
%469 = icmp sge i32 %468, 0
br i1 %469, label %470, label %522
470: ; preds = %467
%471 = load double*, double** %9
%472 = load i32, i32* %16
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %471, i64 %473
%475 = load double, double* %474
%476 = load double, double* %22
%477 = fcmp ogt double %475, %476
br i1 %477, label %478, label %504
478: ; preds = %470
%479 = load double*, double** %12
%480 = load i32, i32* %17
%481 = load i32, i32* %19
%482 = mul nsw i32 %480, %481
%483 = load i32, i32* %18
%484 = add nsw i32 %482, %483
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds double, double* %479, i64 %485
%487 = load double, double* %486
%488 = load double*, double** %21
%489 = load i32, i32* %17
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %488, i64 %490
%492 = load double, double* %491
%493 = fdiv double %487, %492
%494 = load double*, double** %12
%495 = load i32, i32* %15
%496 = load i32, i32* %10
%497 = mul nsw i32 %495, %496
%498 = load i32, i32* %16
%499 = add nsw i32 %497, %498
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %494, i64 %500
store double %493, double* %501
%502 = load i32, i32* %18
%503 = add nsw i32 %502, -1
store i32 %503, i32* %18
br label %518
504: ; preds = %470
%505 = load i32, i32* %15
%506 = load i32, i32* %16
%507 = icmp eq i32 %505, %506
%508 = zext i1 %507 to i32
%509 = sitofp i32 %508 to double
%510 = load double*, double** %12
%511 = load i32, i32* %15
%512 = load i32, i32* %10
%513 = mul nsw i32 %511, %512
%514 = load i32, i32* %16
%515 = add nsw i32 %513, %514
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds double, double* %510, i64 %516
store double %509, double* %517
br label %518
518: ; preds = %504, %478
br label %519
519: ; preds = %518
%520 = load i32, i32* %16
%521 = add nsw i32 %520, -1
store i32 %521, i32* %16
br label %467
522: ; preds = %467
%523 = load i32, i32* %17
%524 = add nsw i32 %523, -1
store i32 %524, i32* %17
br label %548
525: ; preds = %454
store i32 0, i32* %16
br label %526
526: ; preds = %544, %525
%527 = load i32, i32* %16
%528 = load i32, i32* %10
%529 = icmp slt i32 %527, %528
br i1 %529, label %530, label %547
530: ; preds = %526
%531 = load i32, i32* %15
%532 = load i32, i32* %16
%533 = icmp eq i32 %531, %532
%534 = zext i1 %533 to i32
%535 = sitofp i32 %534 to double
%536 = load double*, double** %12
%537 = load i32, i32* %15
%538 = load i32, i32* %10
%539 = mul nsw i32 %537, %538
%540 = load i32, i32* %16
%541 = add nsw i32 %539, %540
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds double, double* %536, i64 %542
store double %535, double* %543
br label %544
544: ; preds = %530
%545 = load i32, i32* %16
%546 = add nsw i32 %545, 1
store i32 %546, i32* %16
br label %526
547: ; preds = %526
br label %548
548: ; preds = %547, %522
br label %549
549: ; preds = %548
%550 = load i32, i32* %15
%551 = add nsw i32 %550, -1
store i32 %551, i32* %15
br label %451
552: ; preds = %451
br label %553
553: ; preds = %552, %207
%554 = load i32, i32* %20
ret i32 %554
}

LLVM IR (-O2):
define i32 @eigenQREV(double* nocapture %0, double* nocapture %1, i32 %2, double* %3, double* %4, double* %5, double* nocapture %6) {
%8 = icmp sgt i32 %2, 0
br i1 %8, label %9, label %60
9: ; preds = %7
%10 = zext i32 %2 to i64
%11 = and i64 %10, 1
%12 = icmp eq i32 %2, 1
br i1 %12, label %43, label %13
13: ; preds = %9
%14 = and i64 %10, 4294967294
br label %15
15: ; preds = %38, %13
%16 = phi i64 [ 0, %13 ], [ %40, %38 ]
%17 = phi i32 [ 0, %13 ], [ %39, %38 ]
%18 = phi i64 [ 0, %13 ], [ %41, %38 ]
%19 = getelementptr inbounds double, double* %1, i64 %16
%20 = load double, double* %19
%21 = fcmp ogt double %20, 1.000000e-100
br i1 %21, label %22, label %27
22: ; preds = %15
%23 = tail call double @sqrt(double %20)
%24 = add nsw i32 %17, 1
%25 = sext i32 %17 to i64
%26 = getelementptr inbounds double, double* %6, i64 %25
store double %23, double* %26
br label %27
27: ; preds = %15, %22
%28 = phi i32 [ %24, %22 ], [ %17, %15 ]
%29 = or i64 %16, 1
%30 = getelementptr inbounds double, double* %1, i64 %29
%31 = load double, double* %30
%32 = fcmp ogt double %31, 1.000000e-100
br i1 %32, label %33, label %38
33: ; preds = %27
%34 = tail call double @sqrt(double %31)
%35 = add nsw i32 %28, 1
%36 = sext i32 %28 to i64
%37 = getelementptr inbounds double, double* %6, i64 %36
store double %34, double* %37
br label %38
38: ; preds = %33, %27
%39 = phi i32 [ %35, %33 ], [ %28, %27 ]
%40 = add nuw nsw i64 %16, 2
%41 = add i64 %18, 2
%42 = icmp eq i64 %41, %14
br i1 %42, label %43, label %15
43: ; preds = %38, %9
%44 = phi i32 [ undef, %9 ], [ %39, %38 ]
%45 = phi i64 [ 0, %9 ], [ %40, %38 ]
%46 = phi i32 [ 0, %9 ], [ %39, %38 ]
%47 = icmp eq i64 %11, 0
br i1 %47, label %57, label %48
48: ; preds = %43
%49 = getelementptr inbounds double, double* %1, i64 %45
%50 = load double, double* %49
%51 = fcmp ogt double %50, 1.000000e-100
br i1 %51, label %52, label %57
52: ; preds = %48
%53 = tail call double @sqrt(double %50)
%54 = add nsw i32 %46, 1
%55 = sext i32 %46 to i64
%56 = getelementptr inbounds double, double* %6, i64 %55
store double %53, double* %56
br label %57
57: ; preds = %48, %52, %43
%58 = phi i32 [ %44, %43 ], [ %54, %52 ], [ %46, %48 ]
%59 = icmp eq i32 %58, %2
br i1 %59, label %66, label %62
60: ; preds = %7
%61 = icmp eq i32 %2, 0
br i1 %61, label %549, label %315
62: ; preds = %57
br i1 %8, label %63, label %315
63: ; preds = %62
%64 = zext i32 %2 to i64
%65 = zext i32 %2 to i64
br label %258
66: ; preds = %57
br i1 %8, label %67, label %549
67: ; preds = %66
%68 = zext i32 %2 to i64
%69 = zext i32 %2 to i64
br label %70
70: ; preds = %67, %99
%71 = phi i64 [ 0, %67 ], [ %100, %99 ]
%72 = trunc i64 %71 to i32
%73 = mul nsw i64 %71, %68
%74 = mul nsw i32 %72, %2
%75 = sext i32 %74 to i64
%76 = add nsw i64 %71, %75
%77 = getelementptr inbounds double, double* %0, i64 %76
%78 = load double, double* %77
%79 = getelementptr inbounds double, double* %4, i64 %76
store double %78, double* %79
%80 = icmp eq i64 %71, 0
br i1 %80, label %99, label %81
81: ; preds = %70
%82 = getelementptr inbounds double, double* %6, i64 %71
br label %83
83: ; preds = %81, %83
%84 = phi i64 [ 0, %81 ], [ %97, %83 ]
%85 = add nuw nsw i64 %84, %73
%86 = getelementptr inbounds double, double* %0, i64 %85
%87 = load double, double* %86
%88 = load double, double* %82
%89 = fmul double %87, %88
%90 = getelementptr inbounds double, double* %6, i64 %84
%91 = load double, double* %90
%92 = fdiv double %89, %91
%93 = mul nsw i64 %84, %68
%94 = add nuw nsw i64 %93, %71
%95 = getelementptr inbounds double, double* %4, i64 %94
store double %92, double* %95
%96 = getelementptr inbounds double, double* %4, i64 %85
store double %92, double* %96
%97 = add nuw nsw i64 %84, 1
%98 = icmp eq i64 %97, %71
br i1 %98, label %99, label %83
99: ; preds = %83, %70
%100 = add nuw nsw i64 %71, 1
%101 = icmp eq i64 %100, %69
br i1 %101, label %102, label %70
102: ; preds = %99
%103 = tail call i32 @eigenRealSym(double* %4, i32 %2, double* %3, double* %5)
br i1 %8, label %104, label %552
104: ; preds = %102
%105 = zext i32 %2 to i64
%106 = zext i32 %2 to i64
%107 = and i64 %10, 1
%108 = icmp eq i32 %2, 1
%109 = and i64 %10, 4294967294
%110 = icmp eq i64 %107, 0
br label %111
111: ; preds = %169, %104
%112 = phi i64 [ 0, %104 ], [ %170, %169 ]
%113 = mul nsw i64 %112, %105
br i1 %108, label %157, label %132
114: ; preds = %169
br i1 %8, label %115, label %552
115: ; preds = %114
%116 = zext i32 %2 to i64
%117 = zext i32 %2 to i64
%118 = and i64 %117, 4294967294
%119 = add nsw i64 %118, -2
%120 = lshr exact i64 %119, 1
%121 = add nuw i64 %120, 1
%122 = icmp ult i32 %2, 2
%123 = and i64 %10, 4294967294
%124 = and i64 %121, 1
%125 = icmp eq i64 %119, 0
%126 = and i64 %121, -2
%127 = icmp eq i64 %124, 0
%128 = icmp eq i64 %123, %10
%129 = and i64 %117, 1
%130 = icmp eq i64 %129, 0
%131 = sub nsw i64 0, %117
br label %172
132: ; preds = %111, %132
%133 = phi i64 [ %154, %132 ], [ 0, %111 ]
%134 = phi i64 [ %155, %132 ], [ 0, %111 ]
%135 = mul nsw i64 %133, %105
%136 = add nuw nsw i64 %135, %112
%137 = getelementptr inbounds double, double* %4, i64 %136
%138 = load double, double* %137
%139 = getelementptr inbounds double, double* %6, i64 %133
%140 = load double, double* %139
%141 = fmul double %138, %140
%142 = add nuw nsw i64 %133, %113
%143 = getelementptr inbounds double, double* %5, i64 %142
store double %141, double* %143
%144 = or i64 %133, 1
%145 = mul nsw i64 %144, %105
%146 = add nuw nsw i64 %145, %112
%147 = getelementptr inbounds double, double* %4, i64 %146
%148 = load double, double* %147
%149 = getelementptr inbounds double, double* %6, i64 %144
%150 = load double, double* %149
%151 = fmul double %148, %150
%152 = add nuw nsw i64 %144, %113
%153 = getelementptr inbounds double, double* %5, i64 %152
store double %151, double* %153
%154 = add nuw nsw i64 %133, 2
%155 = add i64 %134, 2
%156 = icmp eq i64 %155, %109
br i1 %156, label %157, label %132
157: ; preds = %132, %111
%158 = phi i64 [ 0, %111 ], [ %154, %132 ]
br i1 %110, label %169, label %159
159: ; preds = %157
%160 = mul nsw i64 %158, %105
%161 = add nuw nsw i64 %160, %112
%162 = getelementptr inbounds double, double* %4, i64 %161
%163 = load double, double* %162
%164 = getelementptr inbounds double, double* %6, i64 %158
%165 = load double, double* %164
%166 = fmul double %163, %165
%167 = add nuw nsw i64 %158, %113
%168 = getelementptr inbounds double, double* %5, i64 %167
store double %166, double* %168
br label %169
169: ; preds = %157, %159
%170 = add nuw nsw i64 %112, 1
%171 = icmp eq i64 %170, %106
br i1 %171, label %114, label %111
172: ; preds = %255, %115
%173 = phi i64 [ 0, %115 ], [ %256, %255 ]
%174 = mul i64 %173, %10
%175 = getelementptr inbounds double, double* %6, i64 %173
%176 = mul nsw i64 %173, %116
br i1 %122, label %227, label %177
177: ; preds = %172
%178 = add nuw i64 %173, 1
%179 = getelementptr double, double* %6, i64 %178
%180 = getelementptr double, double* %6, i64 %173
%181 = add i64 %174, %10
%182 = getelementptr double, double* %4, i64 %181
%183 = getelementptr double, double* %4, i64 %174
%184 = icmp ult double* %183, %179
%185 = icmp ult double* %180, %182
%186 = and i1 %184, %185
br i1 %186, label %227, label %187
187: ; preds = %177
br i1 %125, label %214, label %188
188: ; preds = %187
%189 = load double, double* %175
%190 = insertelement <2 x double> poison, double %189, i64 0
%191 = shufflevector <2 x double> %190, <2 x double> poison, <2 x i32> zeroinitializer
%192 = load double, double* %175
%193 = insertelement <2 x double> poison, double %192, i64 0
%194 = shufflevector <2 x double> %193, <2 x double> poison, <2 x i32> zeroinitializer
br label %195
195: ; preds = %195, %188
%196 = phi i64 [ 0, %188 ], [ %211, %195 ]
%197 = phi i64 [ 0, %188 ], [ %212, %195 ]
%198 = add nuw nsw i64 %196, %176
%199 = getelementptr inbounds double, double* %4, i64 %198
%200 = bitcast double* %199 to <2 x double>*
%201 = load <2 x double>, <2 x double>* %200
%202 = fdiv <2 x double> %201, %191
%203 = bitcast double* %199 to <2 x double>*
store <2 x double> %202, <2 x double>* %203
%204 = or i64 %196, 2
%205 = add nuw nsw i64 %204, %176
%206 = getelementptr inbounds double, double* %4, i64 %205
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = fdiv <2 x double> %208, %194
%210 = bitcast double* %206 to <2 x double>*
store <2 x double> %209, <2 x double>* %210
%211 = add nuw i64 %196, 4
%212 = add nuw i64 %197, 2
%213 = icmp eq i64 %212, %126
br i1 %213, label %214, label %195
214: ; preds = %195, %187
%215 = phi i64 [ 0, %187 ], [ %211, %195 ]
br i1 %127, label %226, label %216
216: ; preds = %214
%217 = load double, double* %175
%218 = insertelement <2 x double> poison, double %217, i64 0
%219 = shufflevector <2 x double> %218, <2 x double> poison, <2 x i32> zeroinitializer
%220 = add nuw nsw i64 %215, %176
%221 = getelementptr inbounds double, double* %4, i64 %220
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = fdiv <2 x double> %223, %219
%225 = bitcast double* %221 to <2 x double>*
store <2 x double> %224, <2 x double>* %225
br label %226
226: ; preds = %214, %216
br i1 %128, label %255, label %227
227: ; preds = %177, %172, %226
%228 = phi i64 [ 0, %177 ], [ 0, %172 ], [ %123, %226 ]
%229 = xor i64 %228, -1
br i1 %130, label %237, label %230
230: ; preds = %227
%231 = load double, double* %175
%232 = add nuw nsw i64 %228, %176
%233 = getelementptr inbounds double, double* %4, i64 %232
%234 = load double, double* %233
%235 = fdiv double %234, %231
store double %235, double* %233
%236 = or i64 %228, 1
br label %237
237: ; preds = %230, %227
%238 = phi i64 [ %228, %227 ], [ %236, %230 ]
%239 = icmp eq i64 %229, %131
br i1 %239, label %255, label %240
240: ; preds = %237, %240
%241 = phi i64 [ %253, %240 ], [ %238, %237 ]
%242 = load double, double* %175
%243 = add nuw nsw i64 %241, %176
%244 = getelementptr inbounds double, double* %4, i64 %243
%245 = load double, double* %244
%246 = fdiv double %245, %242
store double %246, double* %244
%247 = add nuw nsw i64 %241, 1
%248 = load double, double* %175
%249 = add nuw nsw i64 %247, %176
%250 = getelementptr inbounds double, double* %4, i64 %249
%251 = load double, double* %250
%252 = fdiv double %251, %248
store double %252, double* %250
%253 = add nuw nsw i64 %241, 2
%254 = icmp eq i64 %253, %117
br i1 %254, label %255, label %240
255: ; preds = %237, %240, %226
%256 = add nuw nsw i64 %173, 1
%257 = icmp eq i64 %256, %117
br i1 %257, label %552, label %172
258: ; preds = %63, %311
%259 = phi i64 [ 0, %63 ], [ %313, %311 ]
%260 = phi i32 [ 0, %63 ], [ %312, %311 ]
%261 = getelementptr inbounds double, double* %1, i64 %259
%262 = load double, double* %261
%263 = fcmp ogt double %262, 1.000000e-100
br i1 %263, label %264, label %311
264: ; preds = %258
%265 = icmp eq i64 %259, 0
br i1 %265, label %266, label %268
266: ; preds = %264
%267 = mul nsw i32 %260, %58
br label %301
268: ; preds = %264
%269 = mul nsw i64 %259, %64
%270 = sext i32 %260 to i64
%271 = getelementptr inbounds double, double* %6, i64 %270
%272 = mul nsw i32 %260, %58
br label %273
273: ; preds = %268, %297
%274 = phi i64 [ 0, %268 ], [ %299, %297 ]
%275 = phi i32 [ 0, %268 ], [ %298, %297 ]
%276 = getelementptr inbounds double, double* %1, i64 %274
%277 = load double, double* %276
%278 = fcmp ogt double %277, 1.000000e-100
br i1 %278, label %279, label %297
279: ; preds = %273
%280 = add nuw nsw i64 %274, %269
%281 = getelementptr inbounds double, double* %0, i64 %280
%282 = load double, double* %281
%283 = load double, double* %271
%284 = fmul double %282, %283
%285 = sext i32 %275 to i64
%286 = getelementptr inbounds double, double* %6, i64 %285
%287 = load double, double* %286
%288 = fdiv double %284, %287
%289 = mul nsw i32 %275, %58
%290 = add nsw i32 %289, %260
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double, double* %4, i64 %291
store double %288, double* %292
%293 = add nsw i32 %275, %272
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %4, i64 %294
store double %288, double* %295
%296 = add nsw i32 %275, 1
br label %297
297: ; preds = %273, %279
%298 = phi i32 [ %296, %279 ], [ %275, %273 ]
%299 = add nuw nsw i64 %274, 1
%300 = icmp eq i64 %299, %259
br i1 %300, label %301, label %273
301: ; preds = %297, %266
%302 = phi i32 [ %267, %266 ], [ %272, %297 ]
%303 = phi i64 [ 0, %266 ], [ %269, %297 ]
%304 = add nsw i64 %303, %259
%305 = getelementptr inbounds double, double* %0, i64 %304
%306 = load double, double* %305
%307 = add nsw i32 %302, %260
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %4, i64 %308
store double %306, double* %309
%310 = add nsw i32 %260, 1
br label %311
311: ; preds = %258, %301
%312 = phi i32 [ %310, %301 ], [ %260, %258 ]
%313 = add nuw nsw i64 %259, 1
%314 = icmp eq i64 %313, %65
br i1 %314, label %317, label %258
315: ; preds = %62, %60
%316 = phi i32 [ %58, %62 ], [ 0, %60 ]
br label %549
317: ; preds = %311
%318 = tail call i32 @eigenRealSym(double* %4, i32 %58, double* %3, double* %5)
%319 = add nsw i32 %58, -1
br i1 %8, label %320, label %552
320: ; preds = %317
%321 = add nsw i32 %2, -1
%322 = zext i32 %321 to i64
%323 = and i64 %322, 1
%324 = icmp eq i64 %323, 0
br i1 %324, label %325, label %339
325: ; preds = %320
%326 = getelementptr inbounds double, double* %1, i64 %322
%327 = load double, double* %326
%328 = fcmp ogt double %327, 1.000000e-100
br i1 %328, label %329, label %334
329: ; preds = %325
%330 = add nsw i32 %58, -2
%331 = sext i32 %319 to i64
%332 = getelementptr inbounds double, double* %3, i64 %331
%333 = load double, double* %332
br label %334
334: ; preds = %329, %325
%335 = phi i32 [ %330, %329 ], [ %319, %325 ]
%336 = phi double [ %333, %329 ], [ 0.000000e+00, %325 ]
%337 = getelementptr inbounds double, double* %3, i64 %322
store double %336, double* %337
%338 = add nsw i64 %322, -1
br label %339
339: ; preds = %334, %320
%340 = phi i64 [ %322, %320 ], [ %338, %334 ]
%341 = phi i32 [ %319, %320 ], [ %335, %334 ]
%342 = icmp eq i32 %321, 0
br i1 %342, label %343, label %352
343: ; preds = %376, %339
br i1 %8, label %344, label %552
344: ; preds = %343
%345 = zext i32 %2 to i64
%346 = add nsw i64 %345, -1
%347 = add nsw i64 %10, -1
%348 = and i64 %10, 3
%349 = icmp ult i64 %347, 3
%350 = and i64 %10, 4294967292
%351 = icmp eq i64 %348, 0
br label %390
352: ; preds = %339, %376
%353 = phi i64 [ %380, %376 ], [ %340, %339 ]
%354 = phi i32 [ %377, %376 ], [ %341, %339 ]
%355 = getelementptr inbounds double, double* %1, i64 %353
%356 = load double, double* %355
%357 = fcmp ogt double %356, 1.000000e-100
br i1 %357, label %358, label %363
358: ; preds = %352
%359 = add nsw i32 %354, -1
%360 = sext i32 %354 to i64
%361 = getelementptr inbounds double, double* %3, i64 %360
%362 = load double, double* %361
br label %363
363: ; preds = %352, %358
%364 = phi i32 [ %359, %358 ], [ %354, %352 ]
%365 = phi double [ %362, %358 ], [ 0.000000e+00, %352 ]
%366 = getelementptr inbounds double, double* %3, i64 %353
store double %365, double* %366
%367 = add nsw i64 %353, -1
%368 = getelementptr inbounds double, double* %1, i64 %367
%369 = load double, double* %368
%370 = fcmp ogt double %369, 1.000000e-100
br i1 %370, label %371, label %376
371: ; preds = %363
%372 = add nsw i32 %364, -1
%373 = sext i32 %364 to i64
%374 = getelementptr inbounds double, double* %3, i64 %373
%375 = load double, double* %374
br label %376
376: ; preds = %371, %363
%377 = phi i32 [ %372, %371 ], [ %364, %363 ]
%378 = phi double [ %375, %371 ], [ 0.000000e+00, %363 ]
%379 = getelementptr inbounds double, double* %3, i64 %367
store double %378, double* %379
%380 = add nsw i64 %353, -2
%381 = icmp sgt i64 %353, 1
br i1 %381, label %352, label %343
382: ; preds = %465
br i1 %8, label %383, label %552
383: ; preds = %382
%384 = zext i32 %2 to i64
%385 = add nsw i64 %384, -1
%386 = and i64 %10, 3
%387 = icmp ult i64 %385, 3
%388 = and i64 %10, 4294967292
%389 = icmp eq i64 %386, 0
br label %469
390: ; preds = %344, %465
%391 = phi i64 [ %346, %344 ], [ %467, %465 ]
%392 = phi i32 [ %319, %344 ], [ %466, %465 ]
%393 = getelementptr inbounds double, double* %1, i64 %391
%394 = load double, double* %393
%395 = fcmp ogt double %394, 1.000000e-100
%396 = mul nsw i64 %391, %345
br i1 %395, label %398, label %397
397: ; preds = %390
br i1 %349, label %453, label %428
398: ; preds = %390, %422
%399 = phi i64 [ %424, %422 ], [ %346, %390 ]
%400 = phi i32 [ %423, %422 ], [ %319, %390 ]
%401 = getelementptr inbounds double, double* %1, i64 %399
%402 = load double, double* %401
%403 = fcmp ogt double %402, 1.000000e-100
br i1 %403, label %404, label %417
404: ; preds = %398
%405 = mul nsw i32 %400, %58
%406 = add nsw i32 %405, %392
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %4, i64 %407
%409 = load double, double* %408
%410 = sext i32 %400 to i64
%411 = getelementptr inbounds double, double* %6, i64 %410
%412 = load double, double* %411
%413 = fmul double %409, %412
%414 = add nsw i64 %399, %396
%415 = getelementptr inbounds double, double* %5, i64 %414
store double %413, double* %415
%416 = add nsw i32 %400, -1
br label %422
417: ; preds = %398
%418 = icmp eq i64 %391, %399
%419 = uitofp i1 %418 to double
%420 = add nsw i64 %399, %396
%421 = getelementptr inbounds double, double* %5, i64 %420
store double %419, double* %421
br label %422
422: ; preds = %404, %417
%423 = phi i32 [ %416, %404 ], [ %400, %417 ]
%424 = add nsw i64 %399, -1
%425 = icmp sgt i64 %399, 0
br i1 %425, label %398, label %426
426: ; preds = %422
%427 = add nsw i32 %392, -1
br label %465
428: ; preds = %397, %428
%429 = phi i64 [ %450, %428 ], [ 0, %397 ]
%430 = phi i64 [ %451, %428 ], [ 0, %397 ]
%431 = icmp eq i64 %391, %429
%432 = uitofp i1 %431 to double
%433 = add nsw i64 %429, %396
%434 = getelementptr inbounds double, double* %5, i64 %433
store double %432, double* %434
%435 = or i64 %429, 1
%436 = icmp eq i64 %391, %435
%437 = uitofp i1 %436 to double
%438 = add nsw i64 %435, %396
%439 = getelementptr inbounds double, double* %5, i64 %438
store double %437, double* %439
%440 = or i64 %429, 2
%441 = icmp eq i64 %391, %440
%442 = uitofp i1 %441 to double
%443 = add nsw i64 %440, %396
%444 = getelementptr inbounds double, double* %5, i64 %443
store double %442, double* %444
%445 = or i64 %429, 3
%446 = icmp eq i64 %391, %445
%447 = uitofp i1 %446 to double
%448 = add nsw i64 %445, %396
%449 = getelementptr inbounds double, double* %5, i64 %448
store double %447, double* %449
%450 = add nuw nsw i64 %429, 4
%451 = add i64 %430, 4
%452 = icmp eq i64 %451, %350
br i1 %452, label %453, label %428
453: ; preds = %428, %397
%454 = phi i64 [ 0, %397 ], [ %450, %428 ]
br i1 %351, label %465, label %455
455: ; preds = %453, %455
%456 = phi i64 [ %462, %455 ], [ %454, %453 ]
%457 = phi i64 [ %463, %455 ], [ 0, %453 ]
%458 = icmp eq i64 %391, %456
%459 = uitofp i1 %458 to double
%460 = add nsw i64 %456, %396
%461 = getelementptr inbounds double, double* %5, i64 %460
store double %459, double* %461
%462 = add nuw nsw i64 %456, 1
%463 = add i64 %457, 1
%464 = icmp eq i64 %463, %348
br i1 %464, label %465, label %455
465: ; preds = %453, %455, %426
%466 = phi i32 [ %427, %426 ], [ %392, %455 ], [ %392, %453 ]
%467 = add nsw i64 %391, -1
%468 = icmp sgt i64 %391, 0
br i1 %468, label %390, label %382
469: ; preds = %383, %545
%470 = phi i64 [ %385, %383 ], [ %547, %545 ]
%471 = phi i32 [ %319, %383 ], [ %546, %545 ]
%472 = getelementptr inbounds double, double* %1, i64 %470
%473 = load double, double* %472
%474 = fcmp ogt double %473, 1.000000e-100
%475 = mul nsw i64 %470, %384
br i1 %474, label %477, label %476
476: ; preds = %469
br i1 %387, label %533, label %508
477: ; preds = %469
%478 = mul nsw i32 %471, %58
%479 = sext i32 %471 to i64
%480 = getelementptr inbounds double, double* %6, i64 %479
br label %481
481: ; preds = %477, %502
%482 = phi i64 [ %385, %477 ], [ %504, %502 ]
%483 = phi i32 [ %319, %477 ], [ %503, %502 ]
%484 = getelementptr inbounds double, double* %1, i64 %482
%485 = load double, double* %484
%486 = fcmp ogt double %485, 1.000000e-100
br i1 %486, label %487, label %497
487: ; preds = %481
%488 = add nsw i32 %483, %478
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %4, i64 %489
%491 = load double, double* %490
%492 = load double, double* %480
%493 = fdiv double %491, %492
%494 = add nsw i64 %482, %475
%495 = getelementptr inbounds double, double* %4, i64 %494
store double %493, double* %495
%496 = add nsw i32 %483, -1
br label %502
497: ; preds = %481
%498 = icmp eq i64 %470, %482
%499 = uitofp i1 %498 to double
%500 = add nsw i64 %482, %475
%501 = getelementptr inbounds double, double* %4, i64 %500
store double %499, double* %501
br label %502
502: ; preds = %487, %497
%503 = phi i32 [ %496, %487 ], [ %483, %497 ]
%504 = add nsw i64 %482, -1
%505 = icmp sgt i64 %482, 0
br i1 %505, label %481, label %506
506: ; preds = %502
%507 = add nsw i32 %471, -1
br label %545
508: ; preds = %476, %508
%509 = phi i64 [ %530, %508 ], [ 0, %476 ]
%510 = phi i64 [ %531, %508 ], [ 0, %476 ]
%511 = icmp eq i64 %470, %509
%512 = uitofp i1 %511 to double
%513 = add nsw i64 %509, %475
%514 = getelementptr inbounds double, double* %4, i64 %513
store double %512, double* %514
%515 = or i64 %509, 1
%516 = icmp eq i64 %470, %515
%517 = uitofp i1 %516 to double
%518 = add nsw i64 %515, %475
%519 = getelementptr inbounds double, double* %4, i64 %518
store double %517, double* %519
%520 = or i64 %509, 2
%521 = icmp eq i64 %470, %520
%522 = uitofp i1 %521 to double
%523 = add nsw i64 %520, %475
%524 = getelementptr inbounds double, double* %4, i64 %523
store double %522, double* %524
%525 = or i64 %509, 3
%526 = icmp eq i64 %470, %525
%527 = uitofp i1 %526 to double
%528 = add nsw i64 %525, %475
%529 = getelementptr inbounds double, double* %4, i64 %528
store double %527, double* %529
%530 = add nuw nsw i64 %509, 4
%531 = add i64 %510, 4
%532 = icmp eq i64 %531, %388
br i1 %532, label %533, label %508
533: ; preds = %508, %476
%534 = phi i64 [ 0, %476 ], [ %530, %508 ]
br i1 %389, label %545, label %535
535: ; preds = %533, %535
%536 = phi i64 [ %542, %535 ], [ %534, %533 ]
%537 = phi i64 [ %543, %535 ], [ 0, %533 ]
%538 = icmp eq i64 %470, %536
%539 = uitofp i1 %538 to double
%540 = add nsw i64 %536, %475
%541 = getelementptr inbounds double, double* %4, i64 %540
store double %539, double* %541
%542 = add nuw nsw i64 %536, 1
%543 = add i64 %537, 1
%544 = icmp eq i64 %543, %386
br i1 %544, label %545, label %535
545: ; preds = %533, %535, %506
%546 = phi i32 [ %507, %506 ], [ %471, %535 ], [ %471, %533 ]
%547 = add nsw i64 %470, -1
%548 = icmp sgt i64 %470, 0
br i1 %548, label %469, label %552
549: ; preds = %60, %66, %315
%550 = phi i32 [ %316, %315 ], [ %2, %66 ], [ %2, %60 ]
%551 = tail call i32 @eigenRealSym(double* %4, i32 %550, double* %3, double* %5)
br label %552
552: ; preds = %545, %255, %549, %317, %343, %102, %382, %114
%553 = phi i32 [ %103, %114 ], [ %318, %382 ], [ %103, %102 ], [ %318, %343 ], [ %318, %317 ], [ %551, %549 ], [ %103, %255 ], [ %318, %545 ]
ret i32 %553
}