#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 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 = 1; i < n; i++)
    e[i - 1] = e[i];
  e[n] = 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("\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 = 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
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16c2 <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
jge    124f <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 <tqli+0x10c>
jp     123c <tqli+0x10c>
jmp    124f <tqli+0x11f>
jmp    1241 <tqli+0x111>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ba <tqli+0x8a>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     169e <tqli+0x56e>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x1e,%eax
jne    1285 <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 <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 <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 <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 <tqli+0x34a>
jp     147a <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 <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   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1625 <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 <tqli+0x41e>
jmp    162a <tqli+0x4fa>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13cd <tqli+0x29d>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1661 <tqli+0x531>
jp     1661 <tqli+0x531>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1661 <tqli+0x531>
jmp    16a3 <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 <tqli+0x573>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    11b4 <tqli+0x84>
jmp    16b4 <tqli+0x584>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a1 <tqli+0x71>
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
mov    %edx,%r14d
cmp    $0x2,%edx
mov    %rdx,0x30(%rsp)
jl     1184 <tqli+0x44>
lea    0x8(%r15),%rsi
add    $0xffffffff,%edx
shl    $0x3,%rdx
mov    %r15,%rdi
call   1050 <memmove@plt>
movq   $0x0,(%r15,%r14,8)
jmp    1198 <tqli+0x58>
movslq %edx,%rax
movq   $0x0,(%r15,%rax,8)
cmp    $0x1,%edx
jne    1547 <tqli+0x407>
mov    0x30(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x14(%rsp)
mov    %r14d,%r13d
and    $0xfffffffe,%r13d
movq   $0xffffffffffffffff,0x28(%rsp)
ff ff
xor    %ebp,%ebp
movsd  0xe62(%rip),%xmm1
movdqa 0xe3a(%rip),%xmm3
mov    %r14,0x38(%rsp)
jmp    11ec <tqli+0xac>
nopl   (%rax)
addq   $0x1,0x28(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,%rbp
mov    0x38(%rsp),%r14
cmp    %r14,%rax
je     1547 <tqli+0x407>
mov    0x14(%rsp),%eax
cmp    %eax,%ebp
cmovg  %ebp,%eax
mov    %rax,0x58(%rsp)
mov    %rax,%rdx
neg    %rdx
lea    0x1(%rbp),%rax
mov    %rax,0x20(%rsp)
xor    %r14d,%r14d
mov    %rdx,0x18(%rsp)
jmp    125e <tqli+0x11e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rbp,8),%xmm0
subsd  %xmm8,%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  %xmm1,(%r15,%rbp,8)
mov    0x8(%rsp),%rax
movq   $0x0,(%r15,%rax,8)
movsd  0xdd4(%rip),%xmm1
movdqa 0xdac(%rip),%xmm3
mov    0x18(%rsp),%rdx
mov    0x4(%rsp),%r14d
mov    0x28(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%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    %rbp,%rax
jne    12ce <tqli+0x18e>
jmp    11d0 <tqli+0x90>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x58(%rsp),%rax
cmp    %rbp,%rax
je     11d0 <tqli+0x90>
cmp    $0x1e,%r14d
je     1559 <tqli+0x419>
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
subsd  (%r12,%rbp,8),%xmm0
add    $0x1,%r14d
movsd  (%r15,%rbp,8),%xmm2
addsd  %xmm2,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x40(%rsp)
call   1040 <pythag@plt>
mov    0x8(%rsp),%rax
movsd  (%r12,%rax,8),%xmm4
subsd  (%r12,%rbp,8),%xmm4
movsd  (%r15,%rbp,8),%xmm1
movapd %xmm0,%xmm2
andpd  0xcd2(%rip),%xmm2
orpd   0xcda(%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    %rbp,%rax
mov    %r14d,0x4(%rsp)
jbe    1220 <tqli+0xe0>
xorpd  %xmm8,%xmm8
movsd  0xca2(%rip),%xmm0
movapd %xmm0,%xmm5
jmp    13a1 <tqli+0x261>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mulsd  %xmm5,%xmm1
subsd  %xmm7,%xmm1
cmp    %rbp,%rax
jle    1220 <tqli+0xe0>
movapd %xmm1,0x80(%rsp)
movsd  %xmm5,0x68(%rsp)
movapd %xmm8,0x40(%rsp)
mov    %rax,%r14
movsd  -0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,0x60(%rsp)
mulsd  %xmm2,%xmm0
movapd %xmm0,0x70(%rsp)
call   1040 <pythag@plt>
movsd  %xmm0,(%r15,%r14,8)
ucomisd 0xc44(%rip),%xmm0
jne    13ec <tqli+0x2ac>
jnp    1530 <tqli+0x3f0>
lea    -0x1(%r14),%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,%r14,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,%r14,8)
movapd %xmm0,%xmm6
xorpd  0xbaa(%rip),%xmm6
cmpl   $0x1,0x30(%rsp)
jne    1480 <tqli+0x340>
xor    %ecx,%ecx
jmp    14ea <tqli+0x3aa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm6,%xmm2
unpcklpd %xmm5,%xmm2
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,8),%rdx
movsd  (%rdx,%r14,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,%r14,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)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1490 <tqli+0x350>
testb  $0x1,0x38(%rsp)
je     1390 <tqli+0x250>
mov    (%rbx,%rcx,8),%rcx
movsd  (%rcx,%r14,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    1390 <tqli+0x250>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%r14,8),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r12,%r14,8)
jmp    1237 <tqli+0xf7>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xad0(%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 @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 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
store double 0.000000e+00, double* %44
store i32 0, i32* %10
br label %45
45: ; preds = %337, %40
%46 = load i32, i32* %10
%47 = load i32, i32* %7
%48 = icmp slt 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 slt 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 0, i32* %13
br label %238
238: ; preds = %299, %195
%239 = load i32, i32* %13
%240 = load i32, i32* %7
%241 = icmp slt 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 @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 %2 to i64
%14 = getelementptr inbounds double, double* %1, i64 %13
store double 0.000000e+00, double* %14
br label %19
15: ; preds = %4
%16 = sext i32 %2 to i64
%17 = getelementptr inbounds double, double* %1, i64 %16
store double 0.000000e+00, double* %17
%18 = icmp eq i32 %2, 1
br i1 %18, label %19, label %191
19: ; preds = %6, %15
%20 = add nsw i32 %2, -1
%21 = zext i32 %2 to i64
%22 = and i64 %21, 1
%23 = icmp eq i32 %2, 1
%24 = and i64 %21, 4294967294
%25 = icmp eq i64 %22, 0
br label %26
26: ; preds = %19, %189
%27 = phi i64 [ 0, %19 ], [ %30, %189 ]
%28 = trunc i64 %27 to i32
%29 = call i32 @llvm.smax.i32(i32 %28, i32 %20)
%30 = add nuw nsw i64 %27, 1
%31 = getelementptr inbounds double, double* %0, i64 %30
%32 = getelementptr inbounds double, double* %0, i64 %27
%33 = getelementptr inbounds double, double* %1, i64 %27
%34 = zext i32 %29 to i64
br label %35
35: ; preds = %187, %26
%36 = phi i32 [ %60, %187 ], [ 0, %26 ]
br label %37
37: ; preds = %40, %35
%38 = phi i64 [ %42, %40 ], [ %27, %35 ]
%39 = icmp eq i64 %38, %34
br i1 %39, label %56, label %40
40: ; preds = %37
%41 = getelementptr inbounds double, double* %0, i64 %38
%42 = add nuw nsw i64 %38, 1
%43 = bitcast double* %41 to <2 x double>*
%44 = load <2 x double>, <2 x double>* %43
%45 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %44)
%46 = shufflevector <2 x double> %45, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%47 = fadd <2 x double> %45, %46
%48 = extractelement <2 x double> %47, i64 0
%49 = getelementptr inbounds double, double* %1, i64 %38
%50 = load double, double* %49
%51 = tail call double @llvm.fabs.f64(double %50)
%52 = fadd double %51, %48
%53 = fcmp oeq double %52, %48
br i1 %53, label %54, label %37
54: ; preds = %40
%55 = and i64 %38, 4294967295
br label %56
56: ; preds = %37, %54
%57 = phi i64 [ %55, %54 ], [ %34, %37 ]
%58 = icmp eq i64 %57, %27
br i1 %58, label %189, label %59
59: ; preds = %56
%60 = add nuw nsw i32 %36, 1
%61 = icmp eq i32 %36, 30
br i1 %61, label %62, label %65
62: ; preds = %59
%63 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str, i64 0, i64 0))
%64 = tail call i32 @exit(i32 1)
unreachable
65: ; preds = %59
%66 = load double, double* %31
%67 = load double, double* %32
%68 = fsub double %66, %67
%69 = load double, double* %33
%70 = fmul double %69, 2.000000e+00
%71 = fdiv double %68, %70
%72 = tail call double @pythag(double %71, double 1.000000e+00)
%73 = getelementptr inbounds double, double* %0, i64 %57
%74 = load double, double* %73
%75 = load double, double* %32
%76 = fsub double %74, %75
%77 = load double, double* %33
%78 = fcmp olt double %71, 0.000000e+00
%79 = tail call double @llvm.fabs.f64(double %72)
%80 = fneg double %79
%81 = select i1 %78, double %80, double %79
%82 = fadd double %71, %81
%83 = fdiv double %77, %82
%84 = fadd double %76, %83
%85 = icmp ugt i64 %57, %27
br i1 %85, label %105, label %182
86: ; preds = %145, %119
%87 = phi i64 [ 0, %119 ], [ %175, %145 ]
br i1 %25, label %103, label %88
88: ; preds = %86
%89 = getelementptr inbounds double*, double** %3, i64 %87
%90 = load double*, double** %89
%91 = getelementptr inbounds double, double* %90, i64 %106
%92 = load double, double* %91
%93 = getelementptr inbounds double, double* %90, i64 %111
%94 = load double, double* %93
%95 = insertelement <2 x double> poison, double %92, i64 0
%96 = shufflevector <2 x double> %95, <2 x double> poison, <2 x i32> zeroinitializer
%97 = shufflevector <2 x double> %141, <2 x double> %124, <2 x i32> <i32 0, i32 2>
%98 = fmul <2 x double> %96, %97
%99 = insertelement <2 x double> poison, double %94, i64 0
%100 = shufflevector <2 x double> %99, <2 x double> poison, <2 x i32> zeroinitializer
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %124, <2 x double> %100, <2 x double> %98)
%102 = bitcast double* %93 to <2 x double>*
store <2 x double> %101, <2 x double>* %102
br label %103
103: ; preds = %86, %88
%104 = icmp sgt i64 %111, %27
br i1 %104, label %105, label %182
105: ; preds = %65, %103
%106 = phi i64 [ %111, %103 ], [ %57, %65 ]
%107 = phi double [ %131, %103 ], [ 1.000000e+00, %65 ]
%108 = phi double [ %139, %103 ], [ %84, %65 ]
%109 = phi double [ %136, %103 ], [ 0.000000e+00, %65 ]
%110 = phi double [ %134, %103 ], [ 1.000000e+00, %65 ]
%111 = add nsw i64 %106, -1
%112 = getelementptr inbounds double, double* %1, i64 %111
%113 = load double, double* %112
%114 = fmul double %110, %113
%115 = fmul double %107, %113
%116 = tail call double @pythag(double %114, double %108)
%117 = getelementptr inbounds double, double* %1, i64 %106
store double %116, double* %117
%118 = fcmp oeq double %116, 0.000000e+00
br i1 %118, label %178, label %119
119: ; preds = %105
%120 = insertelement <2 x double> poison, double %108, i64 0
%121 = insertelement <2 x double> %120, double %114, i64 1
%122 = insertelement <2 x double> poison, double %116, i64 0
%123 = shufflevector <2 x double> %122, <2 x double> poison, <2 x i32> zeroinitializer
%124 = fdiv <2 x double> %121, %123
%125 = getelementptr inbounds double, double* %0, i64 %106
%126 = load double, double* %125
%127 = fsub double %126, %109
%128 = getelementptr inbounds double, double* %0, i64 %111
%129 = load double, double* %128
%130 = fsub double %129, %127
%131 = extractelement <2 x double> %124, i64 0
%132 = fmul double %131, 2.000000e+00
%133 = fmul double %115, %132
%134 = extractelement <2 x double> %124, i64 1
%135 = tail call double @llvm.fmuladd.f64(double %130, double %134, double %133)
%136 = fmul double %134, %135
%137 = fadd double %127, %136
store double %137, double* %125
%138 = fneg double %115
%139 = tail call double @llvm.fmuladd.f64(double %131, double %135, double %138)
%140 = fneg double %134
%141 = insertelement <2 x double> poison, double %140, i64 0
br i1 %23, label %86, label %142
142: ; preds = %119
%143 = shufflevector <2 x double> %141, <2 x double> %124, <2 x i32> <i32 0, i32 2>
%144 = shufflevector <2 x double> %141, <2 x double> %124, <2 x i32> <i32 0, i32 2>
br label %145
145: ; preds = %145, %142
%146 = phi i64 [ 0, %142 ], [ %175, %145 ]
%147 = phi i64 [ 0, %142 ], [ %176, %145 ]
%148 = getelementptr inbounds double*, double** %3, i64 %146
%149 = load double*, double** %148
%150 = getelementptr inbounds double, double* %149, i64 %106
%151 = load double, double* %150
%152 = getelementptr inbounds double, double* %149, i64 %111
%153 = load double, double* %152
%154 = insertelement <2 x double> poison, double %151, i64 0
%155 = shufflevector <2 x double> %154, <2 x double> poison, <2 x i32> zeroinitializer
%156 = fmul <2 x double> %155, %143
%157 = insertelement <2 x double> poison, double %153, i64 0
%158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> zeroinitializer
%159 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %124, <2 x double> %158, <2 x double> %156)
%160 = bitcast double* %152 to <2 x double>*
store <2 x double> %159, <2 x double>* %160
%161 = or i64 %146, 1
%162 = getelementptr inbounds double*, double** %3, i64 %161
%163 = load double*, double** %162
%164 = getelementptr inbounds double, double* %163, i64 %106
%165 = load double, double* %164
%166 = getelementptr inbounds double, double* %163, i64 %111
%167 = load double, double* %166
%168 = insertelement <2 x double> poison, double %165, i64 0
%169 = shufflevector <2 x double> %168, <2 x double> poison, <2 x i32> zeroinitializer
%170 = fmul <2 x double> %169, %144
%171 = insertelement <2 x double> poison, double %167, i64 0
%172 = shufflevector <2 x double> %171, <2 x double> poison, <2 x i32> zeroinitializer
%173 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %124, <2 x double> %172, <2 x double> %170)
%174 = bitcast double* %166 to <2 x double>*
store <2 x double> %173, <2 x double>* %174
%175 = add nuw nsw i64 %146, 2
%176 = add i64 %147, 2
%177 = icmp eq i64 %176, %24
br i1 %177, label %86, label %145
178: ; preds = %105
%179 = getelementptr inbounds double, double* %0, i64 %106
%180 = load double, double* %179
%181 = fsub double %180, %109
store double %181, double* %179
br label %187
182: ; preds = %103, %65
%183 = phi double [ 0.000000e+00, %65 ], [ %136, %103 ]
%184 = phi double [ %84, %65 ], [ %139, %103 ]
%185 = load double, double* %32
%186 = fsub double %185, %183
store double %186, double* %32
store double %184, double* %33
br label %187
187: ; preds = %178, %182
%188 = getelementptr inbounds double, double* %1, i64 %57
store double 0.000000e+00, double* %188
br label %35
189: ; preds = %56
%190 = icmp eq i64 %30, %21
br i1 %190, label %191, label %26
191: ; preds = %189, %15
ret void
}