#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*/ Finalize(int);
double fabs(double);
int /*<<< orphan*/ printf(char *);
double pythag(double, double);
void tqli(double *d, double *e, int n, double **z) {
  int m, l, iter, i, k;
  double s, r, p, g, f, dd, c, b;
  for (i = 1; i < n; i++)
    e[i - 1] = e[i];
  e[n - 1] = 0.0;
  for (l = 0; 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("ERROR: Too many iterations in tqli\n");
          Finalize(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.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 = 0; 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):
<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   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    118a <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 <tqli+0x21>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16cb <tqli+0x59b>
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
jge    1254 <tqli+0x124>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe1c(%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 0xdff(%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 0xdde(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x68(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jne    1241 <tqli+0x111>
jp     1241 <tqli+0x111>
jmp    1254 <tqli+0x124>
jmp    1246 <tqli+0x116>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11bf <tqli+0x8f>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     16a7 <tqli+0x577>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x1e,%eax
jne    128a <tqli+0x15a>
lea    0xda5(%rip),%rdi
call   1040 <printf@plt>
mov    $0x1,%edi
call   1030 <Finalize@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  0xd5f(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xd3c(%rip),%xmm1
call   1050 <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)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     134e <tqli+0x21e>
movsd  -0x48(%rbp),%xmm0
movaps 0xcc3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    137d <tqli+0x24d>
movsd  -0x48(%rbp),%xmm0
movaps 0xca6(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%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  0xc5d(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xc50(%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     1641 <tqli+0x511>
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   1050 <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    1483 <tqli+0x353>
jp     1483 <tqli+0x353>
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    1641 <tqli+0x511>
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  0xb3c(%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   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    162e <tqli+0x4fe>
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    1557 <tqli+0x427>
jmp    1633 <tqli+0x503>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13d6 <tqli+0x2a6>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    166a <tqli+0x53a>
jp     166a <tqli+0x53a>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     166a <tqli+0x53a>
jmp    16ac <tqli+0x57c>
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    16ac <tqli+0x57c>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    11b9 <tqli+0x89>
jmp    16bd <tqli+0x58d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a6 <tqli+0x76>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<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
cmp    $0x2,%edx
mov    %rdx,0x30(%rsp)
jl     118a <tqli+0x4a>
lea    0x8(%r15),%rsi
lea    -0x1(%rdx),%ebp
lea    0x0(,%rbp,8),%rdx
mov    %r15,%rdi
call   1060 <memmove@plt>
mov    %rbp,0x10(%rsp)
movq   $0x0,(%r15,%rbp,8)
jmp    11a6 <tqli+0x66>
movslq %edx,%rax
movq   $0x0,-0x8(%r15,%rax,8)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
cmp    $0x1,%edx
jne    1577 <tqli+0x437>
mov    0x30(%rsp),%ebp
mov    %rbp,0x38(%rsp)
and    $0xfffffffe,%ebp
movq   $0xffffffffffffffff,0x28(%rsp)
ff ff
xor    %r14d,%r14d
movsd  0xe5a(%rip),%xmm1
movdqa 0xe32(%rip),%xmm3
jmp    11e9 <tqli+0xa9>
addq   $0x1,0x28(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,%r14
cmp    0x38(%rsp),%rax
je     1577 <tqli+0x437>
mov    0x10(%rsp),%rax
cmp    %eax,%r14d
cmovg  %r14d,%eax
mov    %rax,0x58(%rsp)
mov    %rax,%rdx
neg    %rdx
lea    0x1(%r14),%rax
mov    %rax,0x20(%rsp)
xor    %r13d,%r13d
mov    %rdx,0x18(%rsp)
jmp    125d <tqli+0x11d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%r14,8),%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,(%r12,%r14,8)
movsd  %xmm1,(%r15,%r14,8)
mov    0x8(%rsp),%rax
movq   $0x0,(%r15,%rax,8)
movsd  0xdd5(%rip),%xmm1
movdqa 0xdad(%rip),%xmm3
mov    0x18(%rsp),%rdx
mov    0x4(%rsp),%r13d
mov    0x28(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdx,%rax,1),%rcx
cmp    $0xffffffffffffffff,%rcx
je     12c0 <tqli+0x180>
movdqu 0x8(%r12,%rax,8),%xmm0
pand   %xmm3,%xmm0
pshufd $0xee,%xmm0,%xmm2
addsd  %xmm0,%xmm2
movq   0x8(%r15,%rax,8),%xmm0
pand   %xmm3,%xmm0
addsd  %xmm2,%xmm0
add    $0x1,%rax
ucomisd %xmm2,%xmm0
jne    1270 <tqli+0x130>
jp     1270 <tqli+0x130>
mov    %eax,%eax
cmp    %r14,%rax
jne    12ce <tqli+0x18e>
jmp    11d0 <tqli+0x90>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x58(%rsp),%rax
cmp    %r14,%rax
je     11d0 <tqli+0x90>
mov    %rax,0x8(%rsp)
cmp    $0x1e,%r13d
jne    12f7 <tqli+0x1b7>
lea    0xd50(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%edi
call   1040 <Finalize@plt>
movsd  0xd29(%rip),%xmm1
mov    0x20(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
subsd  (%r12,%r14,8),%xmm0
add    $0x1,%r13d
movsd  (%r15,%r14,8),%xmm2
addsd  %xmm2,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x40(%rsp)
call   1050 <pythag@plt>
mov    0x8(%rsp),%rax
movsd  (%r12,%rax,8),%xmm4
subsd  (%r12,%r14,8),%xmm4
movsd  (%r15,%r14,8),%xmm1
movapd %xmm0,%xmm2
andpd  0xcb8(%rip),%xmm2
orpd   0xcc0(%rip),%xmm0
xorpd  %xmm5,%xmm5
pxor   %xmm3,%xmm3
movsd  0x40(%rsp),%xmm6
cmpnlesd %xmm6,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm2,%xmm3
orpd   %xmm0,%xmm3
addsd  %xmm6,%xmm3
divsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
cmp    %r14,%rax
mov    %r13d,0x4(%rsp)
jbe    1220 <tqli+0xe0>
xorpd  %xmm5,%xmm5
movsd  0xc8b(%rip),%xmm0
movapd %xmm0,%xmm4
jmp    13b4 <tqli+0x274>
nopl   0x0(%rax,%rax,1)
mulsd  %xmm4,%xmm1
subsd  %xmm6,%xmm1
mov    %r13,%r14
cmp    %r13,%rax
jle    1220 <tqli+0xe0>
movapd %xmm1,0x80(%rsp)
movsd  %xmm4,0x68(%rsp)
movapd %xmm5,0x40(%rsp)
mov    %r14,%r13
mov    %rax,%r14
movsd  -0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,0x60(%rsp)
mulsd  %xmm2,%xmm0
movapd %xmm0,0x70(%rsp)
call   1050 <pythag@plt>
movsd  %xmm0,(%r15,%r14,8)
ucomisd 0xc2f(%rip),%xmm0
jne    1401 <tqli+0x2c1>
jnp    1540 <tqli+0x400>
lea    -0x1(%r14),%rax
movsd  0x68(%rsp),%xmm6
mulsd  0x60(%rsp),%xmm6
movapd 0x80(%rsp),%xmm4
unpcklpd 0x70(%rsp),%xmm4
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm4
movsd  (%r12,%r14,8),%xmm3
subsd  0x40(%rsp),%xmm3
movsd  (%r12,%rax,8),%xmm1
subsd  %xmm3,%xmm1
movapd %xmm4,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm6,%xmm2
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movapd %xmm0,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm5,%xmm3
movsd  %xmm3,(%r12,%r14,8)
movapd %xmm0,%xmm7
xorpd  0xb98(%rip),%xmm7
unpcklpd %xmm4,%xmm7
cmpl   $0x1,0x30(%rsp)
jne    1490 <tqli+0x350>
xor    %ecx,%ecx
jmp    14fa <tqli+0x3ba>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm7,%xmm2
movsd  (%rdx,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rdx,%rax,8)
mov    0x8(%rbx,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm7,%xmm2
movsd  (%rdx,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rdx,%rax,8)
add    $0x2,%rcx
cmp    %rcx,%rbp
jne    14a0 <tqli+0x360>
testb  $0x1,0x38(%rsp)
je     13a0 <tqli+0x260>
mov    (%rbx,%rcx,8),%rcx
movsd  (%rcx,%r14,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm7,%xmm2
movsd  (%rcx,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rcx,%rax,8)
jmp    13a0 <tqli+0x260>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%r14,8),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r12,%r14,8)
mov    0x8(%rsp),%rax
movq   $0x0,(%r15,%rax,8)
movsd  0xab9(%rip),%xmm1
movdqa 0xa91(%rip),%xmm3
mov    %r13,%r14
jmp    1253 <tqli+0x113>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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