#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 */
scalar_t__ fabs(double);
double sqrt(double);
void eig1(double **a, long n, double *d, double *e) {
  long l, k, j, i;
  double scale, hh, h, g, f;
  for (i = n - 1; i > 0; i--) {
    l = i - 1;
    h = scale = 0.0;
    if (l > 0) {
      for (k = 0; k <= l; k++)
        scale += fabs(a[i][k]);
      if (scale == 0.0)
        e[i] = a[i][l];
      else {
        for (k = 0; k <= l; k++) {
          a[i][k] /= scale;
          h += a[i][k] * a[i][k];
        }
        f = a[i][l];
        g = (f >= 0.0 ? -sqrt(h) : sqrt(h));
        e[i] = scale * g;
        h -= f * g;
        a[i][l] = f - g;
        f = 0.0;
        for (j = 0; j <= l; j++) {
          a[j][i] = a[i][j] / h;
          g = 0.0;
          for (k = 0; k <= j; k++)
            g += a[j][k] * a[i][k];
          for (k = j + 1; k <= l; k++)
            g += a[k][j] * a[i][k];
          e[j] = g / h;
          f += e[j] * a[i][j];
        }
        hh = f / (h + h);
        for (j = 0; j <= l; j++) {
          f = a[i][j];
          e[j] = g = e[j] - hh * f;
          for (k = 0; k <= j; k++)
            a[j][k] -= (f * e[k] + g * a[i][k]);
        }
      }
    } else
      e[i] = a[i][l];
    d[i] = h;
  }
  d[0] = 0.0;
  e[0] = 0.0;
  for (i = 0; i < n; i++) {
    l = i - 1;
    if (d[i]) {
      for (j = 0; j <= l; j++) {
        g = 0.0;
        for (k = 0; k <= l; k++)
          g += a[i][k] * a[k][j];
        for (k = 0; k <= l; k++)
          a[k][j] -= g * a[k][i];
      }
    }
    d[i] = a[i][i];
    a[i][i] = 1.0;
    for (j = 0; j <= l; j++)
      a[j][i] = a[i][j] = 0.0;
  }
}


x86 assembly (clang, -O0):
<eig1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jle    164d <eig1+0x52d>
mov    -0x40(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpq   $0x0,-0x28(%rbp)
jle    1608 <eig1+0x4e8>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     11c6 <eig1+0xa6>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    117e <eig1+0x5e>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1205 <eig1+0xe5>
jp     1205 <eig1+0xe5>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1603 <eig1+0x4e3>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     128b <eig1+0x16b>
movsd  -0x48(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    120d <eig1+0xed>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12e2 <eig1+0x1c2>
movsd  -0x58(%rbp),%xmm0
call   1040 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    12f1 <eig1+0x1d1>
movsd  -0x58(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     14df <eig1+0x3bf>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jg     141c <eig1+0x2fc>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    13c1 <eig1+0x2a1>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     1483 <eig1+0x363>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1428 <eig1+0x308>
movsd  -0x60(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1374 <eig1+0x254>
movsd  -0x68(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     15fe <eig1+0x4de>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jg     15e8 <eig1+0x4c8>
movsd  -0x68(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1577 <eig1+0x457>
jmp    15ed <eig1+0x4cd>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    14ff <eig1+0x3df>
jmp    1603 <eig1+0x4e3>
jmp    162a <eig1+0x50a>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    1144 <eig1+0x24>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    186c <eig1+0x74c>
mov    -0x40(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16aa <eig1+0x58a>
jp     16aa <eig1+0x58a>
jmp    17c0 <eig1+0x6a0>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     17bb <eig1+0x69b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     172b <eig1+0x60b>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    16d0 <eig1+0x5b0>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     17a5 <eig1+0x685>
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1733 <eig1+0x613>
jmp    17aa <eig1+0x68a>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    16b2 <eig1+0x592>
jmp    17c0 <eig1+0x6a0>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  0x806(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     1856 <eig1+0x736>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1807 <eig1+0x6e7>
jmp    185b <eig1+0x73b>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    166b <eig1+0x54b>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eig1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rdi,%r15
mov    %rsi,0x20(%rsp)
cmp    $0x2,%rsi
jl     1751 <eig1+0x631>
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%rcx
lea    -0x2(%rax),%rdx
mov    %rdx,0x30(%rsp)
xor    %edx,%edx
mov    %rcx,0x50(%rsp)
mov    %rcx,0x10(%rsp)
mov    %r13,0x28(%rsp)
jmp    11af <eig1+0x8f>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%r14,8),%xmm0
movsd  %xmm0,(%r12,%r14,8)
xorpd  %xmm9,%xmm9
mov    0x28(%rsp),%r13
mov    0x18(%rsp),%rdx
mov    0x38(%rsp),%rbx
movsd  %xmm9,0x0(%r13,%r14,8)
add    $0x1,%rdx
addq   $0xffffffffffffffff,0x10(%rsp)
cmp    $0x2,%rbx
mov    %r14,%rax
jle    1751 <eig1+0x631>
lea    -0x1(%rax),%r14
cmp    $0x2,%rax
je     173a <eig1+0x61a>
mov    %rax,0x38(%rsp)
mov    0x50(%rsp),%rbx
sub    %rdx,%rbx
mov    0x30(%rsp),%rax
mov    %rdx,0x18(%rsp)
sub    %rdx,%rax
cmp    $0x3,%rax
jae    11f0 <eig1+0xd0>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    1298 <eig1+0x178>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r13
and    $0xfffffffffffffffc,%r13
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  %xmm4,0x8(%rsp)
mov    (%r15,%r14,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15,%r14,8),%rax
movsd  0x8(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15,%r14,8),%rax
movsd  0x10(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15,%r14,8),%rax
movsd  0x18(%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
xorps  %xmm4,%xmm4
cvtsi2sd %rax,%xmm4
addsd  0x8(%rsp),%xmm4
add    $0x4,%rbp
cmp    %rbp,%r13
jne    1200 <eig1+0xe0>
test   $0x3,%bl
je     12e0 <eig1+0x1c0>
mov    0x10(%rsp),%r13
and    $0x3,%r13d
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm4,0x8(%rsp)
mov    (%r15,%r14,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1030 <fabs@plt>
movsd  0x8(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rbp
add    $0xffffffffffffffff,%r13
jne    12b0 <eig1+0x190>
ucomisd 0xd28(%rip),%xmm4
mov    (%r15,%r14,8),%rax
jne    12f4 <eig1+0x1d4>
jnp    1170 <eig1+0x50>
mov    0x18(%rsp),%rcx
cmp    %rcx,0x30(%rsp)
mov    0x28(%rsp),%r13
jne    130e <eig1+0x1ee>
xorpd  %xmm9,%xmm9
xor    %ecx,%ecx
jmp    1361 <eig1+0x241>
mov    0x10(%rsp),%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm9
divsd  %xmm4,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm4,%xmm9
movsd  %xmm9,0x8(%rax,%rcx,8)
mulsd  %xmm9,%xmm9
addsd  %xmm1,%xmm9
add    $0x2,%rcx
movapd %xmm9,%xmm0
cmp    %rcx,%rdx
jne    1320 <eig1+0x200>
test   $0x1,%bl
je     137d <eig1+0x25d>
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm9
movsd  -0x8(%rax,%r14,8),%xmm1
ucomisd 0xc83(%rip),%xmm9
mov    0x38(%rsp),%rbx
jb     139e <eig1+0x27e>
xorps  %xmm0,%xmm0
sqrtsd %xmm9,%xmm0
jmp    13ce <eig1+0x2ae>
movapd %xmm9,%xmm0
movsd  %xmm9,0x48(%rsp)
movsd  %xmm4,0x8(%rsp)
movsd  %xmm1,0x40(%rsp)
call   1040 <sqrt@plt>
movsd  0x40(%rsp),%xmm1
movsd  0x8(%rsp),%xmm4
movsd  0x48(%rsp),%xmm9
lea    -0x2(%rbx),%r9
xorpd  %xmm8,%xmm8
xorpd  %xmm2,%xmm2
cmpnlesd %xmm1,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
xorpd  0xc10(%rip),%xmm0
andnpd %xmm0,%xmm2
orpd   %xmm3,%xmm2
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r12,%r14,8)
movapd %xmm1,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm9
subsd  %xmm2,%xmm1
mov    (%r15,%r14,8),%rax
movsd  %xmm1,-0x8(%rax,%r14,8)
mov    $0x1,%r8d
xor    %esi,%esi
jmp    1455 <eig1+0x335>
nopl   0x0(%rax,%rax,1)
divsd  %xmm9,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
mulsd  (%rax,%rsi,8),%xmm0
addsd  %xmm0,%xmm8
add    $0x1,%r8
mov    %rdi,%rsi
cmp    %r14,%rdi
je     1550 <eig1+0x430>
movsd  (%rax,%rsi,8),%xmm0
divsd  %xmm9,%xmm0
mov    (%r15,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%r14,8)
cmp    $0x3,%rsi
jae    1480 <eig1+0x360>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    14d7 <eig1+0x3b7>
nopw   0x0(%rax,%rax,1)
mov    %r8,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rdi,%rbp,8),%xmm2
movsd  0x8(%rdi,%rbp,8),%xmm3
mulsd  (%rax,%rbp,8),%xmm2
mulsd  0x8(%rax,%rbp,8),%xmm3
addsd  %xmm0,%xmm2
movsd  0x10(%rdi,%rbp,8),%xmm4
mulsd  0x10(%rax,%rbp,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rdi,%rbp,8),%xmm0
mulsd  0x18(%rax,%rbp,8),%xmm0
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    1490 <eig1+0x370>
test   $0x3,%r8b
je     1507 <eig1+0x3e7>
mov    %r8d,%edx
and    $0x3,%edx
lea    (%rax,%rbp,8),%rcx
lea    (%rdi,%rbp,8),%rdi
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rdi,%rbp,8),%xmm2
mulsd  (%rcx,%rbp,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    14f0 <eig1+0x3d0>
lea    0x1(%rsi),%rdi
cmp    %r9,%rsi
jge    1430 <eig1+0x310>
mov    %rsi,%rcx
nopw   0x0(%rax,%rax,1)
mov    0x8(%r15,%rcx,8),%rdx
movsd  (%rdx,%rsi,8),%xmm2
mulsd  0x8(%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rcx
cmp    %r9,%rcx
jl     1520 <eig1+0x400>
jmp    1430 <eig1+0x310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm9,%xmm0
addsd  %xmm9,%xmm0
xorpd  0xa9d(%rip),%xmm8
divsd  %xmm0,%xmm8
mov    $0x1,%ecx
xor    %r8d,%r8d
jmp    158d <eig1+0x46d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %r14,%r8
je     1730 <eig1+0x610>
mov    %r8,%r9
movsd  (%rax,%r8,8),%xmm0
movapd %xmm8,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%r12,%r8,8),%xmm2
add    $0x1,%r8
movsd  %xmm2,(%r12,%r9,8)
mov    (%r15,%r9,8),%rsi
cmp    $0x4,%r8
jb     1690 <eig1+0x570>
lea    (%rax,%r8,8),%rdx
lea    (%r12,%r8,8),%rdi
lea    (%rsi,%r8,8),%rbp
cmp    %rdi,%rsi
setb   %r10b
cmp    %r12,%rbp
seta   %r11b
cmp    %rdx,%rsi
setb   %dl
cmp    %rbp,%rax
setb   %dil
test   %r11b,%r10b
jne    1690 <eig1+0x570>
mov    $0x0,%ebp
and    %dil,%dl
jne    1692 <eig1+0x572>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd (%r12,%rdi,8),%xmm5
movupd 0x10(%r12,%rdi,8),%xmm6
movupd (%rax,%rdi,8),%xmm7
movupd 0x10(%rax,%rdi,8),%xmm1
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm1
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd (%rsi,%rdi,8),%xmm1
subpd  %xmm5,%xmm1
movupd 0x10(%rsi,%rdi,8),%xmm5
subpd  %xmm6,%xmm5
movupd %xmm1,(%rsi,%rdi,8)
movupd %xmm5,0x10(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1620 <eig1+0x500>
cmp    %rbp,%r8
je     1580 <eig1+0x460>
jmp    1692 <eig1+0x572>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebp,%ebp
mov    %rbp,%rdx
test   $0x1,%cl
je     16c6 <eig1+0x5a6>
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%r12,%rbp,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rbp,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
mov    %rbp,%rdx
or     $0x1,%rdx
cmp    %rbp,%r9
je     1580 <eig1+0x460>
nop
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%r12,%rdx,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rdx,8),%xmm1
subsd  %xmm3,%xmm1
movsd  0x8(%rsi,%rdx,8),%xmm3
movsd  %xmm1,(%rsi,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x8(%r12,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    16d0 <eig1+0x5b0>
jmp    1580 <eig1+0x460>
nopl   0x0(%rax)
mov    0x18(%rsp),%rdx
jmp    1191 <eig1+0x71>
mov    (%r15,%r14,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,(%r12,%r14,8)
movq   $0x0,0x0(%r13,%r14,8)
movq   $0x0,0x0(%r13)
movq   $0x0,(%r12)
mov    0x20(%rsp),%r12
test   %r12,%r12
jle    19d2 <eig1+0x8b2>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movapd 0x883(%rip),%xmm1
movabs $0x3ff0000000000000,%r8
jmp    179d <eig1+0x67d>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %r12,%rax
je     19d2 <eig1+0x8b2>
mov    %eax,%r11d
and    $0x3,%r11d
mov    %rax,%r10
and    $0xfffffffffffffffc,%r10
mov    %rax,%r9
add    $0xffffffffffffffff,%r9
setb   %cl
movsd  0x0(%r13,%rax,8),%xmm2
ucomisd %xmm0,%xmm2
mov    (%r15,%rax,8),%rsi
jne    17cc <eig1+0x6ac>
jnp    1900 <eig1+0x7e0>
test   %cl,%cl
je     1900 <eig1+0x7e0>
mov    %rax,%r14
and    $0xfffffffffffffffe,%r14
xor    %ebp,%ebp
jmp    17ed <eig1+0x6cd>
nop
add    $0x1,%rbp
cmp    %rax,%rbp
je     1900 <eig1+0x7e0>
xorpd  %xmm2,%xmm2
xor    %edi,%edi
cmp    $0x3,%r9
jb     1857 <eig1+0x737>
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm3
movsd  0x8(%rsi,%rdi,8),%xmm4
mov    (%r15,%rdi,8),%rcx
mov    0x8(%r15,%rdi,8),%rdx
mulsd  (%rcx,%rbp,8),%xmm3
addsd  %xmm2,%xmm3
mulsd  (%rdx,%rbp,8),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rsi,%rdi,8),%xmm3
mov    0x10(%r15,%rdi,8),%rcx
mulsd  (%rcx,%rbp,8),%xmm3
movsd  0x18(%rsi,%rdi,8),%xmm2
mov    0x18(%r15,%rdi,8),%rcx
mulsd  (%rcx,%rbp,8),%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
add    $0x4,%rdi
cmp    %rdi,%r10
jne    1800 <eig1+0x6e0>
test   $0x3,%al
je     188b <eig1+0x76b>
lea    (%r15,%rdi,8),%rdx
lea    (%rsi,%rdi,8),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rcx,8),%xmm3
mov    (%rdx,%rcx,8),%rbx
mulsd  (%rbx,%rbp,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1870 <eig1+0x750>
xorpd  %xmm1,%xmm2
xor    %edi,%edi
cmp    $0x1,%rax
je     18d8 <eig1+0x7b8>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdi,8),%rcx
movsd  (%rcx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rbp,8),%xmm3
movsd  %xmm3,(%rcx,%rbp,8)
mov    0x8(%r15,%rdi,8),%rcx
movsd  (%rcx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rbp,8),%xmm3
movsd  %xmm3,(%rcx,%rbp,8)
add    $0x2,%rdi
cmp    %rdi,%r14
jne    18a0 <eig1+0x780>
test   $0x1,%al
je     17e0 <eig1+0x6c0>
mov    (%r15,%rdi,8),%rcx
mulsd  (%rcx,%rax,8),%xmm2
addsd  (%rcx,%rbp,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
jmp    17e0 <eig1+0x6c0>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
mov    %r8,(%rsi,%rax,8)
test   %rax,%rax
je     1790 <eig1+0x670>
xor    %ecx,%ecx
cmp    $0x3,%r9
jb     198f <eig1+0x86f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rsi,%rcx,8)
mov    (%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x8(%rsi,%rcx,8)
mov    0x8(%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x10(%rsi,%rcx,8)
mov    0x10(%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x18(%rsi,%rcx,8)
mov    0x18(%r15,%rcx,8),%rdx
movq   $0x0,(%rdx,%rax,8)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    1930 <eig1+0x810>
test   $0x3,%al
je     1790 <eig1+0x670>
lea    (%r15,%rcx,8),%rdx
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rcx,%rsi,8)
mov    (%rdx,%rsi,8),%rdi
movq   $0x0,(%rdi,%rax,8)
add    $0x1,%rsi
cmp    %rsi,%r11
jne    19b0 <eig1+0x890>
jmp    1790 <eig1+0x670>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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