#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 /*<<< orphan*/ exit(int);
double fabs(double);
int /*<<< orphan*/ printf(char *);
double pythag(double, double);
void eigenvector_tqli(double d[], double e[], int n, double **z) {
  register int m, l, iter, i, k;
  double s, r, p, g, f, dd, c, b;
  for (i = 2; i <= n; i++)
    e[i - 1] = e[i];
  e[n] = 0.0;
  for (l = 1; l <= n; l++) {
    iter = 0;
    do {
      for (m = l; m <= n - 1; m++) {
        dd = fabs(d[m]) + fabs(d[m + 1]);
        if ((double)(fabs(e[m]) + dd) == dd)
          break;
      }
      if (m != l) {
        if (iter++ == 30) {
          printf("\n\nToo many iterations in tqli.\n");
          exit(1);
        }
        g = (d[l + 1] - d[l]) / (2.0 * e[l]);
        r = pythag(g, 1.0);
        g = d[m] - d[l] + e[l] / (g + ((g) < 0 ? -fabs(r) : fabs(r)));
        s = c = 1.0;
        p = 0.0;
        for (i = m - 1; i >= l; i--) {
          f = s * e[i];
          b = c * e[i];
          e[i + 1] = (r = pythag(f, g));
          if (r == 0.0) {
            d[i + 1] -= p;
            e[m] = 0.0;
            break;
          }
          s = f / r;
          c = g / r;
          g = d[i + 1] - p;
          r = (d[i] - g) * s + 2.0 * c * b;
          d[i + 1] = g + (p = s * r);
          g = c * r - b;
          for (k = 1; k <= n; k++) {
            f = z[k][i + 1];
            z[k][i + 1] = s * z[k][i] + c * f;
            z[k][i] = c * z[k][i] - s * f;
          }
        }
        if (r == 0.0 && i >= l)
          continue;
        d[l] -= p;
        e[l] = g;
        e[m] = 0.0;
      }
    } while (m != l);
  }
}


x86 assembly (clang, -O0):
<eigenvector_tqli>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     118a <eigenvector_tqli+0x5a>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1151 <eigenvector_tqli+0x21>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16c2 <eigenvector_tqli+0x592>
movl   $0x0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     124f <eigenvector_tqli+0x11f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe21(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe04(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xde3(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x68(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jne    123c <eigenvector_tqli+0x10c>
jp     123c <eigenvector_tqli+0x10c>
jmp    124f <eigenvector_tqli+0x11f>
jmp    1241 <eigenvector_tqli+0x111>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ba <eigenvector_tqli+0x8a>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     169e <eigenvector_tqli+0x56e>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x1e,%eax
jne    1285 <eigenvector_tqli+0x155>
lea    0xdaa(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  0xd64(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xd41(%rip),%xmm1
call   1040 <pythag@plt>
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    135c <eigenvector_tqli+0x22c>
movsd  -0x48(%rbp),%xmm0
movaps 0xccc(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1374 <eigenvector_tqli+0x244>
movsd  -0x48(%rbp),%xmm0
movaps 0xc98(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm3
ff
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xc66(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xc59(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1638 <eigenvector_tqli+0x508>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
call   1040 <pythag@plt>
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    147a <eigenvector_tqli+0x34a>
jp     147a <eigenvector_tqli+0x34a>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1638 <eigenvector_tqli+0x508>
movsd  -0x60(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  0xb45(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movsd  %xmm1,-0x50(%rbp)
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1625 <eigenvector_tqli+0x4f5>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    154e <eigenvector_tqli+0x41e>
jmp    162a <eigenvector_tqli+0x4fa>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13cd <eigenvector_tqli+0x29d>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1661 <eigenvector_tqli+0x531>
jp     1661 <eigenvector_tqli+0x531>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1661 <eigenvector_tqli+0x531>
jmp    16a3 <eigenvector_tqli+0x573>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16a3 <eigenvector_tqli+0x573>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    11b4 <eigenvector_tqli+0x84>
jmp    16b4 <eigenvector_tqli+0x584>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a1 <eigenvector_tqli+0x71>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eigenvector_tqli>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rcx,%rbx
mov    %rsi,%r15
mov    %rdi,%r12
mov    %edx,%ebp
cmp    $0x2,%edx
mov    %rdx,0x20(%rsp)
mov    %rbp,0x30(%rsp)
jge    118d <eigenvector_tqli+0x4d>
movslq %edx,%rbp
movq   $0x0,(%r15,%rbp,8)
cmp    $0x1,%edx
je     11ae <eigenvector_tqli+0x6e>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x8(%r15),%rdi
lea    0x10(%r15),%rsi
add    $0xffffffff,%edx
shl    $0x3,%rdx
call   1050 <memmove@plt>
mov    0x20(%rsp),%rdx
movq   $0x0,(%r15,%rbp,8)
mov    0x30(%rsp),%r13
lea    0x1(%r13),%rax
mov    %rax,0x38(%rsp)
and    $0xfffffffe,%r13d
neg    %r13
mov    $0x1,%r14d
movdqa 0xe2f(%rip),%xmm2
movsd  0xe47(%rip),%xmm1
mov    %rbp,0x28(%rsp)
jmp    11f4 <eigenvector_tqli+0xb4>
mov    0x50(%rsp),%rax
mov    %rax,%r14
cmp    0x38(%rsp),%rax
mov    0x20(%rsp),%rdx
je     117b <eigenvector_tqli+0x3b>
cmp    %r14d,%edx
mov    %r14d,%eax
cmovg  %edx,%eax
mov    %eax,0x1c(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x50(%rsp)
mov    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %edx,%edx
jmp    125d <eigenvector_tqli+0x11d>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%r14,8),%xmm0
subsd  %xmm8,%xmm0
movsd  %xmm0,(%r12,%r14,8)
movsd  %xmm1,(%r15,%r14,8)
mov    0x10(%rsp),%rax
movq   $0x0,(%r15,%rax,8)
mov    0x28(%rsp),%rbp
movdqa 0xdaf(%rip),%xmm2
movsd  0xdc7(%rip),%xmm1
mov    0xc(%rsp),%edx
mov    %r14,%rcx
cmp    %rbp,%rcx
jge    12a0 <eigenvector_tqli+0x160>
lea    0x1(%rcx),%rax
movdqu (%r12,%rcx,8),%xmm0
pand   %xmm2,%xmm0
pshufd $0xee,%xmm0,%xmm3
addsd  %xmm0,%xmm3
movq   (%r15,%rcx,8),%xmm0
pand   %xmm2,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm3,%xmm0
mov    %rax,%rcx
jne    1260 <eigenvector_tqli+0x120>
jp     1260 <eigenvector_tqli+0x120>
add    $0xffffffff,%eax
jmp    12a4 <eigenvector_tqli+0x164>
nopw   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%eax
mov    %eax,%eax
cmp    %rax,%r14
je     11e0 <eigenvector_tqli+0xa0>
cmp    $0x1e,%edx
je     1517 <eigenvector_tqli+0x3d7>
mov    %rax,0x10(%rsp)
mov    0x58(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
subsd  (%r12,%r14,8),%xmm0
add    $0x1,%edx
mov    %edx,0xc(%rsp)
movsd  (%r15,%r14,8),%xmm2
addsd  %xmm2,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x40(%rsp)
call   1040 <pythag@plt>
mov    0x10(%rsp),%rax
movsd  (%r12,%rax,8),%xmm4
subsd  (%r12,%r14,8),%xmm4
movsd  (%r15,%r14,8),%xmm1
movapd %xmm0,%xmm2
andpd  0xcef(%rip),%xmm2
orpd   0xcf7(%rip),%xmm0
xorpd  %xmm8,%xmm8
movsd  0x40(%rsp),%xmm5
movapd %xmm5,%xmm3
cmpltsd %xmm8,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm2,%xmm3
orpd   %xmm0,%xmm3
addsd  %xmm5,%xmm3
divsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
cmp    %rax,%r14
jae    1220 <eigenvector_tqli+0xe0>
xorpd  %xmm8,%xmm8
movsd  0xcc4(%rip),%xmm0
movapd %xmm0,%xmm5
jmp    1381 <eigenvector_tqli+0x241>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mulsd  %xmm5,%xmm1
subsd  %xmm7,%xmm1
cmp    %r14,%rax
jle    1220 <eigenvector_tqli+0xe0>
movapd %xmm1,0x80(%rsp)
movsd  %xmm5,0x68(%rsp)
movapd %xmm8,0x40(%rsp)
mov    %rax,%rbp
movsd  -0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,0x60(%rsp)
mulsd  %xmm2,%xmm0
movapd %xmm0,0x70(%rsp)
call   1040 <pythag@plt>
movsd  %xmm0,(%r15,%rbp,8)
ucomisd 0xc64(%rip),%xmm0
jne    13cc <eigenvector_tqli+0x28c>
jnp    1500 <eigenvector_tqli+0x3c0>
lea    -0x1(%rbp),%rax
movsd  0x68(%rsp),%xmm7
mulsd  0x60(%rsp),%xmm7
movapd 0x80(%rsp),%xmm5
unpcklpd 0x70(%rsp),%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
movsd  (%r12,%rbp,8),%xmm3
subsd  0x40(%rsp),%xmm3
movsd  (%r12,%rax,8),%xmm1
subsd  %xmm3,%xmm1
movapd %xmm5,%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm7,%xmm2
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movapd %xmm0,%xmm8
mulsd  %xmm1,%xmm8
addsd  %xmm8,%xmm3
movsd  %xmm3,(%r12,%rbp,8)
movapd %xmm0,%xmm6
xorpd  0xbca(%rip),%xmm6
mov    $0x1,%ecx
cmpl   $0x2,0x38(%rsp)
je     14c1 <eigenvector_tqli+0x381>
movapd %xmm6,%xmm2
unpcklpd %xmm5,%xmm2
mov    $0x1,%ecx
nop
mov    (%rbx,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm2,%xmm3
movsd  (%rdx,%rax,8),%xmm4
unpcklpd %xmm4,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%rdx,%rax,8)
mov    0x8(%rbx,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm2,%xmm3
movsd  (%rdx,%rax,8),%xmm4
unpcklpd %xmm4,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%rdx,%rax,8)
lea    (%rcx,%r13,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
jne    1460 <eigenvector_tqli+0x320>
testb  $0x1,0x30(%rsp)
je     1370 <eigenvector_tqli+0x230>
mov    (%rbx,%rcx,8),%rcx
movsd  (%rcx,%rbp,8),%xmm2
unpcklpd %xmm2,%xmm2
unpcklpd %xmm5,%xmm6
mulpd  %xmm2,%xmm6
movsd  (%rcx,%rax,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm2,(%rcx,%rax,8)
jmp    1370 <eigenvector_tqli+0x230>
nopl   0x0(%rax)
movsd  (%r12,%rbp,8),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
jmp    1237 <eigenvector_tqli+0xf7>
lea    0xb12(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%edi
call   1060 <exit@plt>

LLVM IR (-O0):
@.str = [32 x i8] c"\0A\0AToo many iterations in tqli.\0A\00"
define void @eigenvector_tqli(double* %0, double* %1, i32 %2, double** %3) {
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca double**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
store double* %0, double** %5
store double* %1, double** %6
store i32 %2, i32* %7
store double** %3, double*** %8
store i32 2, i32* %12
br label %22
22: ; preds = %37, %4
%23 = load i32, i32* %12
%24 = load i32, i32* %7
%25 = icmp sle i32 %23, %24
br i1 %25, label %26, label %40
26: ; preds = %22
%27 = load double*, double** %6
%28 = load i32, i32* %12
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %27, i64 %29
%31 = load double, double* %30
%32 = load double*, double** %6
%33 = load i32, i32* %12
%34 = sub nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %32, i64 %35
store double %31, double* %36
br label %37
37: ; preds = %26
%38 = load i32, i32* %12
%39 = add nsw i32 %38, 1
store i32 %39, i32* %12
br label %22
40: ; preds = %22
%41 = load double*, double** %6
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
store double 0.000000e+00, double* %44
store i32 1, i32* %10
br label %45
45: ; preds = %337, %40
%46 = load i32, i32* %10
%47 = load i32, i32* %7
%48 = icmp sle i32 %46, %47
br i1 %48, label %49, label %340
49: ; preds = %45
store i32 0, i32* %11
br label %50
50: ; preds = %332, %49
%51 = load i32, i32* %10
store i32 %51, i32* %9
br label %52
52: ; preds = %84, %50
%53 = load i32, i32* %9
%54 = load i32, i32* %7
%55 = sub nsw i32 %54, 1
%56 = icmp sle i32 %53, %55
br i1 %56, label %57, label %87
57: ; preds = %52
%58 = load double*, double** %5
%59 = load i32, i32* %9
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %58, i64 %60
%62 = load double, double* %61
%63 = call double @llvm.fabs.f64(double %62)
%64 = load double*, double** %5
%65 = load i32, i32* %9
%66 = add nsw i32 %65, 1
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %64, i64 %67
%69 = load double, double* %68
%70 = call double @llvm.fabs.f64(double %69)
%71 = fadd double %63, %70
store double %71, double* %19
%72 = load double*, double** %6
%73 = load i32, i32* %9
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
%76 = load double, double* %75
%77 = call double @llvm.fabs.f64(double %76)
%78 = load double, double* %19
%79 = fadd double %77, %78
%80 = load double, double* %19
%81 = fcmp oeq double %79, %80
br i1 %81, label %82, label %83
82: ; preds = %57
br label %87
83: ; preds = %57
br label %84
84: ; preds = %83
%85 = load i32, i32* %9
%86 = add nsw i32 %85, 1
store i32 %86, i32* %9
br label %52
87: ; preds = %82, %52
%88 = load i32, i32* %9
%89 = load i32, i32* %10
%90 = icmp ne i32 %88, %89
br i1 %90, label %91, label %331
91: ; preds = %87
%92 = load i32, i32* %11
%93 = add nsw i32 %92, 1
store i32 %93, i32* %11
%94 = icmp eq i32 %92, 30
br i1 %94, label %95, label %98
95: ; preds = %91
%96 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0))
%97 = call i32 @exit(i32 1)
unreachable
98: ; preds = %91
%99 = load double*, double** %5
%100 = load i32, i32* %10
%101 = add nsw i32 %100, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %99, i64 %102
%104 = load double, double* %103
%105 = load double*, double** %5
%106 = load i32, i32* %10
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = fsub double %104, %109
%111 = load double*, double** %6
%112 = load i32, i32* %10
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %111, i64 %113
%115 = load double, double* %114
%116 = fmul double 2.000000e+00, %115
%117 = fdiv double %110, %116
store double %117, double* %17
%118 = load double, double* %17
%119 = call double @pythag(double %118, double 1.000000e+00)
store double %119, double* %15
%120 = load double*, double** %5
%121 = load i32, i32* %9
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
%124 = load double, double* %123
%125 = load double*, double** %5
%126 = load i32, i32* %10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = fsub double %124, %129
%131 = load double*, double** %6
%132 = load i32, i32* %10
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
%135 = load double, double* %134
%136 = load double, double* %17
%137 = load double, double* %17
%138 = fcmp olt double %137, 0.000000e+00
br i1 %138, label %139, label %143
139: ; preds = %98
%140 = load double, double* %15
%141 = call double @llvm.fabs.f64(double %140)
%142 = fneg double %141
br label %146
143: ; preds = %98
%144 = load double, double* %15
%145 = call double @llvm.fabs.f64(double %144)
br label %146
146: ; preds = %143, %139
%147 = phi double [ %142, %139 ], [ %145, %143 ]
%148 = fadd double %136, %147
%149 = fdiv double %135, %148
%150 = fadd double %130, %149
store double %150, double* %17
store double 1.000000e+00, double* %20
store double 1.000000e+00, double* %14
store double 0.000000e+00, double* %16
%151 = load i32, i32* %9
%152 = sub nsw i32 %151, 1
store i32 %152, i32* %12
br label %153
153: ; preds = %303, %146
%154 = load i32, i32* %12
%155 = load i32, i32* %10
%156 = icmp sge i32 %154, %155
br i1 %156, label %157, label %306
157: ; preds = %153
%158 = load double, double* %14
%159 = load double*, double** %6
%160 = load i32, i32* %12
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %159, i64 %161
%163 = load double, double* %162
%164 = fmul double %158, %163
store double %164, double* %18
%165 = load double, double* %20
%166 = load double*, double** %6
%167 = load i32, i32* %12
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %166, i64 %168
%170 = load double, double* %169
%171 = fmul double %165, %170
store double %171, double* %21
%172 = load double, double* %18
%173 = load double, double* %17
%174 = call double @pythag(double %172, double %173)
store double %174, double* %15
%175 = load double*, double** %6
%176 = load i32, i32* %12
%177 = add nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %175, i64 %178
store double %174, double* %179
%180 = load double, double* %15
%181 = fcmp oeq double %180, 0.000000e+00
br i1 %181, label %182, label %195
182: ; preds = %157
%183 = load double, double* %16
%184 = load double*, double** %5
%185 = load i32, i32* %12
%186 = add nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %184, i64 %187
%189 = load double, double* %188
%190 = fsub double %189, %183
store double %190, double* %188
%191 = load double*, double** %6
%192 = load i32, i32* %9
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
store double 0.000000e+00, double* %194
br label %306
195: ; preds = %157
%196 = load double, double* %18
%197 = load double, double* %15
%198 = fdiv double %196, %197
store double %198, double* %14
%199 = load double, double* %17
%200 = load double, double* %15
%201 = fdiv double %199, %200
store double %201, double* %20
%202 = load double*, double** %5
%203 = load i32, i32* %12
%204 = add nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %202, i64 %205
%207 = load double, double* %206
%208 = load double, double* %16
%209 = fsub double %207, %208
store double %209, double* %17
%210 = load double*, double** %5
%211 = load i32, i32* %12
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %210, i64 %212
%214 = load double, double* %213
%215 = load double, double* %17
%216 = fsub double %214, %215
%217 = load double, double* %14
%218 = load double, double* %20
%219 = fmul double 2.000000e+00, %218
%220 = load double, double* %21
%221 = fmul double %219, %220
%222 = call double @llvm.fmuladd.f64(double %216, double %217, double %221)
store double %222, double* %15
%223 = load double, double* %17
%224 = load double, double* %14
%225 = load double, double* %15
%226 = fmul double %224, %225
store double %226, double* %16
%227 = fadd double %223, %226
%228 = load double*, double** %5
%229 = load i32, i32* %12
%230 = add nsw i32 %229, 1
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %228, i64 %231
store double %227, double* %232
%233 = load double, double* %20
%234 = load double, double* %15
%235 = load double, double* %21
%236 = fneg double %235
%237 = call double @llvm.fmuladd.f64(double %233, double %234, double %236)
store double %237, double* %17
store i32 1, i32* %13
br label %238
238: ; preds = %299, %195
%239 = load i32, i32* %13
%240 = load i32, i32* %7
%241 = icmp sle i32 %239, %240
br i1 %241, label %242, label %302
242: ; preds = %238
%243 = load double**, double*** %8
%244 = load i32, i32* %13
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double*, double** %243, i64 %245
%247 = load double*, double** %246
%248 = load i32, i32* %12
%249 = add nsw i32 %248, 1
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %247, i64 %250
%252 = load double, double* %251
store double %252, double* %18
%253 = load double, double* %14
%254 = load double**, double*** %8
%255 = load i32, i32* %13
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double*, double** %254, i64 %256
%258 = load double*, double** %257
%259 = load i32, i32* %12
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = load double, double* %20
%264 = load double, double* %18
%265 = fmul double %263, %264
%266 = call double @llvm.fmuladd.f64(double %253, double %262, double %265)
%267 = load double**, double*** %8
%268 = load i32, i32* %13
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double*, double** %267, i64 %269
%271 = load double*, double** %270
%272 = load i32, i32* %12
%273 = add nsw i32 %272, 1
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %271, i64 %274
store double %266, double* %275
%276 = load double, double* %20
%277 = load double**, double*** %8
%278 = load i32, i32* %13
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double*, double** %277, i64 %279
%281 = load double*, double** %280
%282 = load i32, i32* %12
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = load double, double* %14
%287 = load double, double* %18
%288 = fmul double %286, %287
%289 = fneg double %288
%290 = call double @llvm.fmuladd.f64(double %276, double %285, double %289)
%291 = load double**, double*** %8
%292 = load i32, i32* %13
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double*, double** %291, i64 %293
%295 = load double*, double** %294
%296 = load i32, i32* %12
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds double, double* %295, i64 %297
store double %290, double* %298
br label %299
299: ; preds = %242
%300 = load i32, i32* %13
%301 = add nsw i32 %300, 1
store i32 %301, i32* %13
br label %238
302: ; preds = %238
br label %303
303: ; preds = %302
%304 = load i32, i32* %12
%305 = add nsw i32 %304, -1
store i32 %305, i32* %12
br label %153
306: ; preds = %182, %153
%307 = load double, double* %15
%308 = fcmp oeq double %307, 0.000000e+00
br i1 %308, label %309, label %314
309: ; preds = %306
%310 = load i32, i32* %12
%311 = load i32, i32* %10
%312 = icmp sge i32 %310, %311
br i1 %312, label %313, label %314
313: ; preds = %309
br label %332
314: ; preds = %309, %306
%315 = load double, double* %16
%316 = load double*, double** %5
%317 = load i32, i32* %10
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = fsub double %320, %315
store double %321, double* %319
%322 = load double, double* %17
%323 = load double*, double** %6
%324 = load i32, i32* %10
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %323, i64 %325
store double %322, double* %326
%327 = load double*, double** %6
%328 = load i32, i32* %9
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %327, i64 %329
store double 0.000000e+00, double* %330
br label %331
331: ; preds = %314, %87
br label %332
332: ; preds = %331, %313
%333 = load i32, i32* %9
%334 = load i32, i32* %10
%335 = icmp ne i32 %333, %334
br i1 %335, label %50, label %336
336: ; preds = %332
br label %337
337: ; preds = %336
%338 = load i32, i32* %10
%339 = add nsw i32 %338, 1
store i32 %339, i32* %10
br label %45
340: ; preds = %45
ret void
}

LLVM IR (-O2):
@str = [31 x i8] c"\0A\0AToo many iterations in tqli.\00"
define void @eigenvector_tqli(double* nocapture %0, double* nocapture %1, i32 %2, double** nocapture %3) {
%5 = icmp slt i32 %2, 2
br i1 %5, label %16, label %6
6: ; preds = %4
%7 = getelementptr double, double* %1, i64 1
%8 = bitcast double* %7 to i8*
%9 = getelementptr double, double* %1, i64 2
%10 = bitcast double* %9 to i8*
%11 = add nsw i32 %2, -1
%12 = zext i32 %11 to i64
%13 = shl nuw nsw i64 %12, 3
%14 = zext i32 %2 to i64
%15 = getelementptr inbounds double, double* %1, i64 %14
store double 0.000000e+00, double* %15
br label %20
16: ; preds = %4
%17 = sext i32 %2 to i64
%18 = getelementptr inbounds double, double* %1, i64 %17
store double 0.000000e+00, double* %18
%19 = icmp eq i32 %2, 1
br i1 %19, label %20, label %195
20: ; preds = %6, %16
%21 = phi i64 [ %14, %6 ], [ %17, %16 ]
%22 = add nuw i32 %2, 1
%23 = zext i32 %22 to i64
%24 = add nsw i64 %23, -1
%25 = and i64 %24, 1
%26 = icmp eq i32 %22, 2
%27 = and i64 %24, -2
%28 = icmp eq i64 %25, 0
br label %29
29: ; preds = %20, %193
%30 = phi i64 [ 1, %20 ], [ %33, %193 ]
%31 = trunc i64 %30 to i32
%32 = call i32 @llvm.smax.i32(i32 %2, i32 %31)
%33 = add nuw nsw i64 %30, 1
%34 = and i64 %33, 4294967295
%35 = getelementptr inbounds double, double* %0, i64 %34
%36 = getelementptr inbounds double, double* %0, i64 %30
%37 = getelementptr inbounds double, double* %1, i64 %30
br label %38
38: ; preds = %191, %29
%39 = phi i32 [ %64, %191 ], [ 0, %29 ]
br label %40
40: ; preds = %43, %38
%41 = phi i64 [ %45, %43 ], [ %30, %38 ]
%42 = icmp slt i64 %41, %21
br i1 %42, label %43, label %59
43: ; preds = %40
%44 = getelementptr inbounds double, double* %0, i64 %41
%45 = add nuw nsw i64 %41, 1
%46 = bitcast double* %44 to <2 x double>*
%47 = load <2 x double>, <2 x double>* %46
%48 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %47)
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%50 = fadd <2 x double> %48, %49
%51 = extractelement <2 x double> %50, i64 0
%52 = getelementptr inbounds double, double* %1, i64 %41
%53 = load double, double* %52
%54 = tail call double @llvm.fabs.f64(double %53)
%55 = fadd double %54, %51
%56 = fcmp oeq double %55, %51
br i1 %56, label %57, label %40
57: ; preds = %43
%58 = trunc i64 %41 to i32
br label %59
59: ; preds = %40, %57
%60 = phi i32 [ %58, %57 ], [ %32, %40 ]
%61 = zext i32 %60 to i64
%62 = icmp eq i64 %30, %61
br i1 %62, label %193, label %63
63: ; preds = %59
%64 = add nuw nsw i32 %39, 1
%65 = icmp eq i32 %39, 30
br i1 %65, label %66, label %69
66: ; preds = %63
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str, i64 0, i64 0))
%68 = tail call i32 @exit(i32 1)
unreachable
69: ; preds = %63
%70 = load double, double* %35
%71 = load double, double* %36
%72 = fsub double %70, %71
%73 = load double, double* %37
%74 = fmul double %73, 2.000000e+00
%75 = fdiv double %72, %74
%76 = tail call double @pythag(double %75, double 1.000000e+00)
%77 = getelementptr inbounds double, double* %0, i64 %61
%78 = load double, double* %77
%79 = load double, double* %36
%80 = fsub double %78, %79
%81 = load double, double* %37
%82 = fcmp olt double %75, 0.000000e+00
%83 = tail call double @llvm.fabs.f64(double %76)
%84 = fneg double %83
%85 = select i1 %82, double %84, double %83
%86 = fadd double %75, %85
%87 = fdiv double %81, %86
%88 = fadd double %80, %87
%89 = icmp ult i64 %30, %61
br i1 %89, label %109, label %186
90: ; preds = %149, %123
%91 = phi i64 [ 1, %123 ], [ %179, %149 ]
br i1 %28, label %107, label %92
92: ; preds = %90
%93 = getelementptr inbounds double*, double** %3, i64 %91
%94 = load double*, double** %93
%95 = getelementptr inbounds double, double* %94, i64 %110
%96 = load double, double* %95
%97 = getelementptr inbounds double, double* %94, i64 %115
%98 = load double, double* %97
%99 = insertelement <2 x double> poison, double %96, i64 0
%100 = shufflevector <2 x double> %99, <2 x double> poison, <2 x i32> zeroinitializer
%101 = shufflevector <2 x double> %145, <2 x double> %128, <2 x i32> <i32 0, i32 2>
%102 = fmul <2 x double> %100, %101
%103 = insertelement <2 x double> poison, double %98, i64 0
%104 = shufflevector <2 x double> %103, <2 x double> poison, <2 x i32> zeroinitializer
%105 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> %104, <2 x double> %102)
%106 = bitcast double* %97 to <2 x double>*
store <2 x double> %105, <2 x double>* %106
br label %107
107: ; preds = %90, %92
%108 = icmp sgt i64 %115, %30
br i1 %108, label %109, label %186
109: ; preds = %69, %107
%110 = phi i64 [ %115, %107 ], [ %61, %69 ]
%111 = phi double [ %135, %107 ], [ 1.000000e+00, %69 ]
%112 = phi double [ %143, %107 ], [ %88, %69 ]
%113 = phi double [ %140, %107 ], [ 0.000000e+00, %69 ]
%114 = phi double [ %138, %107 ], [ 1.000000e+00, %69 ]
%115 = add nsw i64 %110, -1
%116 = getelementptr inbounds double, double* %1, i64 %115
%117 = load double, double* %116
%118 = fmul double %114, %117
%119 = fmul double %111, %117
%120 = tail call double @pythag(double %118, double %112)
%121 = getelementptr inbounds double, double* %1, i64 %110
store double %120, double* %121
%122 = fcmp oeq double %120, 0.000000e+00
br i1 %122, label %182, label %123
123: ; preds = %109
%124 = insertelement <2 x double> poison, double %112, i64 0
%125 = insertelement <2 x double> %124, double %118, i64 1
%126 = insertelement <2 x double> poison, double %120, i64 0
%127 = shufflevector <2 x double> %126, <2 x double> poison, <2 x i32> zeroinitializer
%128 = fdiv <2 x double> %125, %127
%129 = getelementptr inbounds double, double* %0, i64 %110
%130 = load double, double* %129
%131 = fsub double %130, %113
%132 = getelementptr inbounds double, double* %0, i64 %115
%133 = load double, double* %132
%134 = fsub double %133, %131
%135 = extractelement <2 x double> %128, i64 0
%136 = fmul double %135, 2.000000e+00
%137 = fmul double %119, %136
%138 = extractelement <2 x double> %128, i64 1
%139 = tail call double @llvm.fmuladd.f64(double %134, double %138, double %137)
%140 = fmul double %138, %139
%141 = fadd double %131, %140
store double %141, double* %129
%142 = fneg double %119
%143 = tail call double @llvm.fmuladd.f64(double %135, double %139, double %142)
%144 = fneg double %138
%145 = insertelement <2 x double> poison, double %144, i64 0
br i1 %26, label %90, label %146
146: ; preds = %123
%147 = shufflevector <2 x double> %145, <2 x double> %128, <2 x i32> <i32 0, i32 2>
%148 = shufflevector <2 x double> %145, <2 x double> %128, <2 x i32> <i32 0, i32 2>
br label %149
149: ; preds = %149, %146
%150 = phi i64 [ 1, %146 ], [ %179, %149 ]
%151 = phi i64 [ 0, %146 ], [ %180, %149 ]
%152 = getelementptr inbounds double*, double** %3, i64 %150
%153 = load double*, double** %152
%154 = getelementptr inbounds double, double* %153, i64 %110
%155 = load double, double* %154
%156 = getelementptr inbounds double, double* %153, i64 %115
%157 = load double, double* %156
%158 = insertelement <2 x double> poison, double %155, i64 0
%159 = shufflevector <2 x double> %158, <2 x double> poison, <2 x i32> zeroinitializer
%160 = fmul <2 x double> %159, %147
%161 = insertelement <2 x double> poison, double %157, i64 0
%162 = shufflevector <2 x double> %161, <2 x double> poison, <2 x i32> zeroinitializer
%163 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> %162, <2 x double> %160)
%164 = bitcast double* %156 to <2 x double>*
store <2 x double> %163, <2 x double>* %164
%165 = add nuw nsw i64 %150, 1
%166 = getelementptr inbounds double*, double** %3, i64 %165
%167 = load double*, double** %166
%168 = getelementptr inbounds double, double* %167, i64 %110
%169 = load double, double* %168
%170 = getelementptr inbounds double, double* %167, i64 %115
%171 = load double, double* %170
%172 = insertelement <2 x double> poison, double %169, i64 0
%173 = shufflevector <2 x double> %172, <2 x double> poison, <2 x i32> zeroinitializer
%174 = fmul <2 x double> %173, %148
%175 = insertelement <2 x double> poison, double %171, i64 0
%176 = shufflevector <2 x double> %175, <2 x double> poison, <2 x i32> zeroinitializer
%177 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> %176, <2 x double> %174)
%178 = bitcast double* %170 to <2 x double>*
store <2 x double> %177, <2 x double>* %178
%179 = add nuw nsw i64 %150, 2
%180 = add i64 %151, 2
%181 = icmp eq i64 %180, %27
br i1 %181, label %90, label %149
182: ; preds = %109
%183 = getelementptr inbounds double, double* %0, i64 %110
%184 = load double, double* %183
%185 = fsub double %184, %113
store double %185, double* %183
br label %191
186: ; preds = %107, %69
%187 = phi double [ 0.000000e+00, %69 ], [ %140, %107 ]
%188 = phi double [ %88, %69 ], [ %143, %107 ]
%189 = load double, double* %36
%190 = fsub double %189, %187
store double %190, double* %36
store double %188, double* %37
br label %191
191: ; preds = %182, %186
%192 = getelementptr inbounds double, double* %1, i64 %61
store double 0.000000e+00, double* %192
br label %38
193: ; preds = %59
%194 = icmp eq i64 %33, %23
br i1 %194, label %195, label %29
195: ; preds = %193, %16
ret void
}