#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 */
double copysign(double, double);
double fabs(double);
int /*<<< orphan*/ quit(char *);
double sqrt(double);
void imtql2(int n, double *d, double *e, double *z) {
  int nm1 = n - 1;
  double b, c, f, g, p, r, s;
  int i, l;
  if (n <= 1)
    return;
  e[nm1] = 0.0;
  for (l = 0; l < n; ++l) {
    int j = 0;
    int m, mml;
    while (1) {
      for (m = l; m < nm1; ++m)
        if (fabs(e[m]) < 1.11e-16 * (fabs(d[m]) + fabs(d[m + 1])))
          break;
      p = d[l];
      if (m == l)
        goto continue_l;
      if (j == 30)
        quit("error: imtql2(): number of iterations > 30\n");
      j++;
      g = (d[l + 1] - p) / e[l] / 2.0;
      r = sqrt(g * g + 1.0);
      g = d[m] - p + e[l] / (g + copysign(r, g));
      s = 1.0;
      c = 1.0;
      p = 0.0;
      mml = m - l;
      for (i = m - 1; i >= l; --i) {
        f = s * e[i];
        b = c * e[i];
        if (fabs(f) >= fabs(g)) {
          c = g / f;
          r = sqrt(c * c + 1.0);
          e[i + 1] = f * r;
          s = 1.0 / r;
          c *= s;
        } else {
          s = f / g;
          r = sqrt(s * s + 1.0);
          e[i + 1] = g * r;
          c = 1.0 / r;
          s *= c;
        }
        g = d[i + 1] - p;
        r = (d[i] - g) * s + 2.0 * c * b;
        p = s * r;
        d[i + 1] = g + p;
        g = c * r - b;
        f = z[i + 1];
        z[i + 1] = s * z[i] + c * f;
        z[i] = c * z[i] - s * f;
      }
      d[l] -= p;
      e[l] = g;
      e[m] = 0.0;
    }
  continue_l:;
  }
  for (i = 0; i < nm1; ++i) {
    int k = i;
    int j;
    p = d[i];
    for (j = i + 1; j < n; ++j) {
      if (d[j] < p) {
        k = j;
        p = d[j];
      }
    }
    if (k != i) {
      d[k] = d[i];
      d[i] = p;
      p = z[i];
      z[i] = z[k];
      z[k] = p;
    }
  }
}


x86 assembly (clang, -O0):
<imtql2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x1,-0x4(%rbp)
jg     1152 <imtql2+0x32>
jmp    1736 <imtql2+0x616>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1626 <imtql2+0x506>
movl   $0x0,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    120d <imtql2+0xed>
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe7e(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0xe66(%rip),%xmm0
pand   %xmm0,%xmm2
mov    -0x10(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe49(%rip),%xmm3
pand   %xmm3,%xmm0
addsd  %xmm0,%xmm2
movsd  0xe19(%rip),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    11fa <imtql2+0xda>
jmp    120d <imtql2+0xed>
jmp    11ff <imtql2+0xdf>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1182 <imtql2+0x62>
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x68(%rbp),%eax
jne    1230 <imtql2+0x110>
jmp    1613 <imtql2+0x4f3>
cmpl   $0x1e,-0x6c(%rbp)
jne    1246 <imtql2+0x126>
lea    0xdff(%rip),%rdi
call   1030 <quit@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0xd95(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd6e(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm4
movaps 0xd53(%rip),%xmm5
pand   %xmm5,%xmm4
movaps 0xd38(%rip),%xmm5
pand   %xmm5,%xmm3
por    %xmm4,%xmm3
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xcff(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xcf2(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x70(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jl     15d1 <imtql2+0x4b1>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x40(%rbp),%xmm0
movaps 0xca5(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0xc95(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jb     140e <imtql2+0x2ee>
movsd  -0x48(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc4a(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xc18(%rip),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    147e <imtql2+0x35e>
movsd  -0x40(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbd5(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xba3(%rip),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  0xb57(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x40(%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 -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    1335 <imtql2+0x215>
movsd  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    117c <imtql2+0x5c>
jmp    1618 <imtql2+0x4f8>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1169 <imtql2+0x49>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1736 <imtql2+0x616>
mov    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ad <imtql2+0x58d>
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    169a <imtql2+0x57a>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    169f <imtql2+0x57f>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    165a <imtql2+0x53a>
mov    -0x78(%rbp),%eax
cmp    -0x64(%rbp),%eax
je     1723 <imtql2+0x603>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1728 <imtql2+0x608>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    162d <imtql2+0x50d>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imtql2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
cmp    $0x2,%edi
jl     15f7 <imtql2+0x4d7>
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%rbx
lea    -0x1(%rdi),%eax
mov    %eax,0x18(%rsp)
mov    %eax,%eax
mov    %rax,0x78(%rsp)
movq   $0x0,(%rdx,%rax,8)
mov    %rdi,0x70(%rsp)
mov    %edi,%eax
mov    %rax,0x48(%rsp)
movq   $0xffffffffffffffff,0x58(%rsp)
ff ff
xor    %r12d,%r12d
movsd  0xeb7(%rip),%xmm4
jmp    1199 <imtql2+0x79>
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x58(%rsp)
mov    0x50(%rsp),%rax
mov    %rax,%r12
cmp    0x48(%rsp),%rax
je     1548 <imtql2+0x428>
mov    0x18(%rsp),%eax
cmp    %eax,%r12d
cmovg  %r12d,%eax
mov    %rax,0x80(%rsp)
mov    %rax,%rdx
neg    %rdx
lea    0x1(%r12),%rax
mov    %rax,0x50(%rsp)
xor    %r13d,%r13d
mov    %rdx,0x88(%rsp)
jmp    1207 <imtql2+0xe7>
nopl   0x0(%rax)
mov    0x1c(%rsp),%r13d
add    $0x1,%r13d
movsd  (%rbx,%r12,8),%xmm0
subsd  %xmm6,%xmm0
movsd  %xmm0,(%rbx,%r12,8)
movsd  %xmm5,(%r15,%r12,8)
mov    0x90(%rsp),%rax
movq   $0x0,(%r15,%rax,8)
mov    0x88(%rsp),%rdx
mov    0x58(%rsp),%rax
nopl   0x0(%rax)
lea    (%rdx,%rax,1),%rcx
cmp    $0xffffffffffffffff,%rcx
je     1260 <imtql2+0x140>
movq   0x8(%r15,%rax,8),%xmm0
movdqa 0xdd7(%rip),%xmm2
pand   %xmm2,%xmm0
movdqu 0x8(%rbx,%rax,8),%xmm1
pand   %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
addsd  %xmm1,%xmm2
mulsd  0xdd8(%rip),%xmm2
add    $0x1,%rax
ucomisd %xmm0,%xmm2
jbe    1210 <imtql2+0xf0>
mov    %eax,%ebp
cmp    %r12,%rbp
jne    1271 <imtql2+0x151>
jmp    1180 <imtql2+0x60>
xchg   %ax,%ax
mov    0x80(%rsp),%rbp
cmp    %r12,%rbp
je     1180 <imtql2+0x60>
movsd  (%rbx,%r12,8),%xmm2
cmp    $0x1e,%r13d
movsd  %xmm2,0x20(%rsp)
jne    129d <imtql2+0x17d>
lea    0xdb6(%rip),%rdi
call   1030 <quit@plt>
movsd  0x20(%rsp),%xmm2
movsd  0xd93(%rip),%xmm4
mov    0x50(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm3
subsd  %xmm2,%xmm3
divsd  (%r15,%r12,8),%xmm3
mulsd  0xd6f(%rip),%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
ucomisd 0xd6b(%rip),%xmm0
jb     12e0 <imtql2+0x1c0>
sqrtsd %xmm0,%xmm0
jmp    12ff <imtql2+0x1df>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm3,0x30(%rsp)
call   1040 <sqrt@plt>
movapd 0x30(%rsp),%xmm3
movsd  0x20(%rsp),%xmm2
movsd  0xd31(%rip),%xmm4
movsd  (%rbx,%rbp,8),%xmm1
subsd  %xmm2,%xmm1
movsd  (%r15,%r12,8),%xmm5
movapd %xmm3,%xmm2
andpd  0xcf6(%rip),%xmm2
andpd  0xcde(%rip),%xmm0
orpd   %xmm2,%xmm0
addsd  %xmm3,%xmm0
divsd  %xmm0,%xmm5
addsd  %xmm1,%xmm5
xorpd  %xmm6,%xmm6
cmp    %r12,%rbp
mov    %r13d,0x1c(%rsp)
mov    %rbp,0x90(%rsp)
jbe    11d0 <imtql2+0xb0>
xorpd  %xmm6,%xmm6
movapd %xmm4,%xmm3
movapd %xmm4,%xmm7
jmp    145e <imtql2+0x33e>
nopl   (%rax)
movapd %xmm5,0x20(%rsp)
movapd %xmm6,0x30(%rsp)
movapd %xmm7,0x60(%rsp)
movsd  %xmm3,0x10(%rsp)
movsd  %xmm8,0x8(%rsp)
call   1040 <sqrt@plt>
movsd  0x8(%rsp),%xmm8
movsd  0x10(%rsp),%xmm3
movapd 0x60(%rsp),%xmm7
movapd 0x30(%rsp),%xmm6
movapd 0x20(%rsp),%xmm5
movsd  0xc85(%rip),%xmm4
mulsd  %xmm0,%xmm5
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm7
unpcklpd %xmm7,%xmm1
movapd %xmm5,%xmm7
mulsd  %xmm8,%xmm3
movsd  %xmm7,(%r15,%rbp,8)
movsd  -0x8(%rbx,%rbp,8),%xmm5
movsd  (%rbx,%rbp,8),%xmm0
subsd  %xmm6,%xmm0
subsd  %xmm0,%xmm5
movapd %xmm1,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm1,%xmm7
unpckhpd %xmm1,%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm7,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm6,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mulsd  %xmm1,%xmm5
subsd  %xmm3,%xmm5
movapd %xmm7,%xmm0
xorpd  0xbee(%rip),%xmm0
movsd  -0x8(%r14,%rbp,8),%xmm2
movsd  (%r14,%rbp,8),%xmm3
unpcklpd %xmm3,%xmm3
unpcklpd %xmm1,%xmm0
mulpd  %xmm3,%xmm0
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,-0x8(%r14,%rbp,8)
mov    %r13,%rbp
movapd %xmm1,%xmm3
cmp    %r12,%r13
jle    11d0 <imtql2+0xb0>
lea    -0x1(%rbp),%r13
movsd  -0x8(%r15,%rbp,8),%xmm8
mulsd  %xmm8,%xmm7
movapd %xmm7,%xmm0
movapd 0xb86(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm5,%xmm1
andpd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jae    14c0 <imtql2+0x3a0>
divsd  %xmm5,%xmm7
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm4,%xmm0
ucomisd 0xb94(%rip),%xmm0
jb     1360 <imtql2+0x240>
sqrtsd %xmm0,%xmm0
jmp    13ab <imtql2+0x28b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
divsd  %xmm7,%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm4,%xmm0
ucomisd 0xb60(%rip),%xmm0
jb     14e0 <imtql2+0x3c0>
sqrtsd %xmm0,%xmm0
jmp    152b <imtql2+0x40b>
movapd %xmm5,0x20(%rsp)
movapd %xmm6,0x30(%rsp)
movapd %xmm7,0x60(%rsp)
movsd  %xmm3,0x10(%rsp)
movsd  %xmm8,0x8(%rsp)
call   1040 <sqrt@plt>
movsd  0x8(%rsp),%xmm8
movsd  0x10(%rsp),%xmm3
movapd 0x60(%rsp),%xmm7
movapd 0x30(%rsp),%xmm6
movapd 0x20(%rsp),%xmm5
movsd  0xb05(%rip),%xmm4
mulsd  %xmm0,%xmm7
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm5
unpcklpd %xmm1,%xmm5
movapd %xmm5,%xmm1
jmp    13c3 <imtql2+0x2a3>
cmpl   $0x2,0x70(%rsp)
mov    0x78(%rsp),%r8
mov    0x48(%rsp),%rbp
jl     15f7 <imtql2+0x4d7>
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    157c <imtql2+0x45c>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %rdx,%rcx
cmp    %r8,%rdx
je     15f7 <imtql2+0x4d7>
movsd  (%rbx,%rcx,8),%xmm0
lea    0x1(%rcx),%rdx
cmp    %rbp,%rdx
jae    15c0 <imtql2+0x4a0>
mov    %rax,%rdi
mov    %ecx,%esi
movapd %xmm0,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rdi,8),%xmm1
ucomisd %xmm1,%xmm2
cmova  %edi,%esi
minsd  %xmm2,%xmm1
add    $0x1,%rdi
movapd %xmm1,%xmm2
cmp    %rdi,%rbp
jne    15a0 <imtql2+0x480>
jmp    15c6 <imtql2+0x4a6>
nop
movapd %xmm0,%xmm1
mov    %ecx,%esi
mov    %esi,%edi
cmp    %rdi,%rcx
je     1570 <imtql2+0x450>
movslq %esi,%rsi
movsd  %xmm0,(%rbx,%rsi,8)
movsd  %xmm1,(%rbx,%rcx,8)
movsd  (%r14,%rcx,8),%xmm0
movsd  (%r14,%rsi,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  %xmm0,(%r14,%rsi,8)
jmp    1570 <imtql2+0x450>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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