void hqr(double **a, int n, double wr[], double wi[]) {
  int nn, m, l, k, j, its, i, mmin;
  double z, y, x, w, v, u, t, s, r, q, p, anorm;
  anorm = p = q = r = 0.0;
  for (i = 0; i < n; i++)
    for (j = imax(i - 1, 0); j < n; j++)
      anorm += fabs(a[i][j]);
  nn = n - 1;
  t = 0.0;
  while (nn >= 0) {
    its = 0;
    do {
      for (l = nn; l >= 1; l--) {
        s = fabs(a[l - 1][l - 1]) + fabs(a[l][l]);
        if (s == 0.0)
          s = anorm;
        if (fabs(a[l][l - 1] + s) == s)
          break;
      }
      x = a[nn][nn];
      if (l == nn) {
        wr[nn] = x + t;
        wi[nn--] = 0.0;
      } else {
        y = a[nn - 1][nn - 1];
        w = a[nn][nn - 1] * a[nn - 1][nn];
        if (l == (nn - 1)) {
          p = 0.5 * (y - x);
          q = p * p + w;
          z = sqrt(fabs(q));
          x += t;
          if (q >= 0.0) {
            z = p + ((p) >= 0.0 ? fabs(z) : -fabs(z));
            wr[nn - 1] = wr[nn] = x + z;
            if (z)
              wr[nn] = x - w / z;
            wi[nn - 1] = wi[nn] = 0.0;
          } else {
            wr[nn - 1] = wr[nn] = x + p;
            wi[nn - 1] = -(wi[nn] = z);
          }
          nn -= 2;
        } else {
          if (its == 30)
            error("Too many iterations in hqr");
          if (its == 10 || its == 20) {
            t += x;
            for (i = 0; i <= nn; i++)
              a[i][i] -= x;
            s = fabs(a[nn][nn - 1]) + fabs(a[nn - 1][nn - 2]);
            y = x = 0.75 * s;
            w = -0.4375 * s * s;
          }
          ++its;
          for (m = (nn - 2); m >= l; m--) {
            z = a[m][m];
            r = x - z;
            s = y - z;
            p = (r * s - w) / a[m + 1][m] + a[m][m + 1];
            q = a[m + 1][m + 1] - z - r - s;
            r = a[m + 2][m + 1];
            s = fabs(p) + fabs(q) + fabs(r);
            p /= s;
            q /= s;
            r /= s;
            if (m == l)
              break;
            u = fabs(a[m][m - 1]) * (fabs(q) + fabs(r));
            v = fabs(p) *
                (fabs(a[m - 1][m - 1]) + fabs(z) + fabs(a[m + 1][m + 1]));
            if ((double)(u + v) == v)
              break;
          }
          for (i = m + 2; i <= nn; i++) {
            a[i][i - 2] = 0.0;
            if (i != (m + 2))
              a[i][i - 3] = 0.0;
          }
          for (k = m; k <= nn - 1; k++) {
            if (k != m) {
              p = a[k][k - 1];
              q = a[k + 1][k - 1];
              r = 0.0;
              if (k != (nn - 1))
                r = a[k + 2][k - 1];
              if ((x = fabs(p) + fabs(q) + fabs(r)) != 0.0) {
                p /= x;
                q /= x;
                r /= x;
              }
            }
            if ((s = ((p) >= 0.0 ? fabs(sqrt(p * p + q * q + r * r))
                                 : -fabs(sqrt(p * p + q * q + r * r)))) !=
                0.0) {
              if (k == m) {
                if (l != m)
                  a[k][k - 1] = -a[k][k - 1];
              } else
                a[k][k - 1] = -s * x;
              p += s;
              x = p / s;
              y = q / s;
              z = r / s;
              q /= p;
              r /= p;
              for (j = k; j <= nn; j++) {
                p = a[k][j] + q * a[k + 1][j];
                if (k != (nn - 1)) {
                  p += r * a[k + 2][j];
                  a[k + 2][j] -= p * z;
                }
                a[k + 1][j] -= p * y;
                a[k][j] -= p * x;
              }
              mmin = nn < k + 3 ? nn : k + 3;
              for (i = l; i <= mmin; i++) {
                p = x * a[i][k] + y * a[i][k + 1];
                if (k != (nn - 1)) {
                  p += z * a[i][k + 2];
                  a[i][k + 2] -= p * r;
                }
                a[i][k + 1] -= p * q;
                a[i][k] -= p;
              }
            }
          }
        }
      }
    } while (1 < nn - 1);
  }
}


x86 assembly (clang, -O0):
<hqr>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f8 <hqr+0xc8>
mov    -0x3c(%rbp),%edi
sub    $0x1,%edi
xor    %esi,%esi
mov    $0x0,%al
call   1030 <imax@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11e5 <hqr+0xb5>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1e3d(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119b <hqr+0x6b>
jmp    11ea <hqr+0xba>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    117d <hqr+0x4d>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     2122 <hqr+0xff2>
movl   $0x0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     12f5 <hqr+0x1c5>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1db0(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1d90(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12a2 <hqr+0x172>
jp     12a2 <hqr+0x172>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movaps 0x1d38(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x80(%rbp),%xmm0
jne    12e2 <hqr+0x1b2>
jp     12e2 <hqr+0x1b2>
jmp    12f5 <hqr+0x1c5>
jmp    12e7 <hqr+0x1b7>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1220 <hqr+0xf0>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1351 <hqr+0x221>
movsd  -0x58(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2105 <hqr+0xfd5>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15d2 <hqr+0x4a2>
movsd  -0x50(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
movsd  0x1c4f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movaps 0x1bef(%rip),%xmm1
pand   %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x78(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     155d <hqr+0x42d>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1485 <hqr+0x355>
movsd  -0x48(%rbp),%xmm0
movaps 0x1b8c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    14b4 <hqr+0x384>
movsd  -0x48(%rbp),%xmm0
movaps 0x1b6f(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1513 <hqr+0x3e3>
jp     1513 <hqr+0x3e3>
jmp    1533 <hqr+0x403>
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
divsd  -0x48(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    15c4 <hqr+0x494>
movsd  -0x58(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    2100 <hqr+0xfd0>
cmpl   $0x1e,-0x38(%rbp)
jne    15ea <hqr+0x4ba>
lea    0x1a45(%rip),%rdi
mov    $0x0,%al
call   1040 <error@plt>
cmpl   $0xa,-0x38(%rbp)
je     15fe <hqr+0x4ce>
cmpl   $0x14,-0x38(%rbp)
jne    16d7 <hqr+0x5a7>
movsd  -0x58(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1651 <hqr+0x521>
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1614 <hqr+0x4e4>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x198e(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1964(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1967(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  %xmm0,-0x50(%rbp)
movsd  0x1948(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jl     19b2 <hqr+0x882>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movaps 0x17f4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x17e1(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movaps 0x17ca(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    189f <hqr+0x76f>
jmp    19b2 <hqr+0x882>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1740(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x172d(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x88(%rbp),%xmm2
ff
movaps 0x171a(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movaps 0x16fa(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x16d0(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x48(%rbp),%xmm2
movaps 0x16c0(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x1692(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jne    199f <hqr+0x86f>
jp     199f <hqr+0x86f>
jmp    19b2 <hqr+0x882>
jmp    19a4 <hqr+0x874>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    16e9 <hqr+0x5b9>
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1a25 <hqr+0x8f5>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
je     1a12 <hqr+0x8e2>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a17 <hqr+0x8e7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    19bb <hqr+0x88b>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     20fb <hqr+0xfcb>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1b82 <hqr+0xa52>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1ad4 <hqr+0x9a4>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movaps 0x151d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x150a(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movaps 0x14f3(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b32 <hqr+0xa02>
jp     1b32 <hqr+0xa02>
jmp    1b7d <hqr+0xa4d>
movsd  -0x58(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1b82 <hqr+0xa52>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1bf4 <hqr+0xac4>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps 0x141d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1c63 <hqr+0xb33>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps 0x13c0(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c88 <hqr+0xb58>
jp     1c88 <hqr+0xb58>
jmp    20e8 <hqr+0xfb8>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1cf0 <hqr+0xbc0>
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1ceb <hqr+0xbbb>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d2b <hqr+0xbfb>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1f3c <hqr+0xe0c>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1e9d <hqr+0xd6d>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1db4 <hqr+0xc84>
mov    -0x24(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1f5b <hqr+0xe2b>
mov    -0x24(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    1f67 <hqr+0xe37>
mov    -0x30(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     20e3 <hqr+0xfb3>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     2061 <hqr+0xf31>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1f76 <hqr+0xe46>
jmp    20e8 <hqr+0xfb8>
jmp    20ed <hqr+0xfbd>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a2b <hqr+0x8fb>
jmp    2100 <hqr+0xfd0>
jmp    2105 <hqr+0xfd5>
jmp    210a <hqr+0xfda>
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jl     121a <hqr+0xea>
jmp    1209 <hqr+0xd9>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hqr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
test   %esi,%esi
jle    1d04 <hqr+0xbd4>
mov    %rcx,%r12
mov    %esi,%r9d
mov    %rdi,%rbx
mov    %rdx,0x78(%rsp)
mov    %esi,%r14d
movslq %esi,%r15
xorpd  %xmm9,%xmm9
xor    %r13d,%r13d
jmp    1195 <hqr+0x65>
nopw   0x0(%rax,%rax,1)
movapd 0xe88(%rip),%xmm7
movapd 0xe7f(%rip),%xmm8
movapd 0x10(%rsp),%xmm9
add    $0x1,%r13
cmp    %r14,%r13
je     127d <hqr+0x14d>
movapd %xmm9,0x10(%rsp)
lea    -0x1(%r13),%edi
xor    %esi,%esi
xor    %eax,%eax
mov    %r9,%rbp
call   1030 <imax@plt>
mov    %rbp,%r9
cmp    %r9d,%eax
jge    1170 <hqr+0x40>
mov    (%rbx,%r13,8),%rcx
movslq %eax,%rdx
mov    %r9d,%esi
sub    %eax,%esi
mov    %rdx,%rax
not    %rax
add    %r15,%rax
movapd 0xe2f(%rip),%xmm7
movapd 0xe26(%rip),%xmm8
and    $0x3,%rsi
je     1215 <hqr+0xe5>
movapd 0x10(%rsp),%xmm9
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm0,%xmm9
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    11f0 <hqr+0xc0>
cmp    $0x3,%rax
jb     1188 <hqr+0x58>
jmp    1226 <hqr+0xf6>
movapd 0x10(%rsp),%xmm9
cmp    $0x3,%rax
jb     1188 <hqr+0x58>
movapd %xmm9,%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm1
movsd  0x8(%rcx,%rdx,8),%xmm2
movsd  0x10(%rcx,%rdx,8),%xmm3
movsd  0x18(%rcx,%rdx,8),%xmm9
andpd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
andpd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
andpd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm7,%xmm9
addsd  %xmm3,%xmm9
add    $0x4,%rdx
movapd %xmm9,%xmm0
cmp    %rdx,%r15
jne    1230 <hqr+0x100>
jmp    1188 <hqr+0x58>
test   %r9d,%r9d
mov    0x78(%rsp),%r15
jle    1d04 <hqr+0xbd4>
add    $0xffffffff,%r9d
lea    0x10(%rbx),%rax
mov    %rax,0xb0(%rsp)
lea    0x18(%rbx),%rax
mov    %rax,0xa8(%rsp)
xorpd  %xmm11,%xmm11
movapd 0xd5b(%rip),%xmm12
xor    %r13d,%r13d
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xorpd  %xmm14,%xmm14
xorpd  %xmm13,%xmm13
movapd %xmm9,0x10(%rsp)
mov    %r12,0xb8(%rsp)
mov    %rbx,0xc0(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9d,%eax
test   %r9d,%r9d
mov    $0x0,%r10d
cmovs  %r9d,%r10d
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %edx,%edx
jle    1372 <hqr+0x242>
lea    -0x1(%rdx),%rcx
mov    -0x8(%rbx,%rdx,8),%rsi
mov    (%rbx,%rdx,8),%rdi
movsd  -0x8(%rsi,%rdx,8),%xmm0
andpd  %xmm7,%xmm0
movsd  (%rdi,%rdx,8),%xmm1
andpd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
cmpeqsd %xmm11,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm1,%xmm2
andpd  %xmm9,%xmm0
orpd   %xmm2,%xmm0
movsd  -0x8(%rdi,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
andpd  %xmm7,%xmm1
ucomisd %xmm0,%xmm1
mov    %rcx,%rdx
jne    1310 <hqr+0x1e0>
jp     1310 <hqr+0x1e0>
add    $0x1,%ecx
mov    %ecx,%r10d
movslq %r9d,%rbp
mov    (%rbx,%rbp,8),%rcx
movsd  (%rcx,%rbp,8),%xmm15
cmp    %r9d,%r10d
jne    13b0 <hqr+0x280>
addsd  0x8(%rsp),%xmm15
movsd  %xmm15,(%r15,%rbp,8)
add    $0xffffffff,%r9d
movq   $0x0,(%r12,%rbp,8)
jmp    1ceb <hqr+0xbbb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rbp),%r14
lea    -0x1(%r9),%esi
mov    -0x8(%rbx,%rbp,8),%r8
movsd  -0x8(%r8,%rbp,8),%xmm10
movsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  (%r8,%rbp,8),%xmm6
mulsd  %xmm0,%xmm6
cmp    %esi,%r10d
mov    %r9,0x28(%rsp)
jne    1420 <hqr+0x2f0>
subsd  %xmm15,%xmm10
movapd %xmm10,%xmm14
mulsd  0xc4f(%rip),%xmm14
movapd %xmm14,%xmm3
mulsd  %xmm14,%xmm3
addsd  %xmm6,%xmm3
movapd %xmm3,%xmm0
andpd  %xmm8,%xmm0
ucomisd %xmm11,%xmm0
jb     14fe <hqr+0x3ce>
sqrtsd %xmm0,%xmm0
jmp    1576 <hqr+0x446>
nopl   0x0(%rax)
cmp    $0xa,%r13d
mov    %r10d,0x80(%rsp)
mov    %r13d,0x4(%rsp)
je     14db <hqr+0x3ab>
cmp    $0x14,%r13d
je     14db <hqr+0x3ab>
cmp    $0x1e,%r13d
jne    16fa <hqr+0x5ca>
lea    0xbf6(%rip),%rdi
xor    %eax,%eax
movapd %xmm13,0x60(%rsp)
movapd %xmm14,0x50(%rsp)
movapd %xmm15,0x40(%rsp)
movapd %xmm6,0x30(%rsp)
movapd %xmm10,0x90(%rsp)
call   1040 <error@plt>
movapd 0x90(%rsp),%xmm10
movapd 0x30(%rsp),%xmm6
movapd 0x40(%rsp),%xmm15
mov    0x80(%rsp),%r10d
movapd 0x50(%rsp),%xmm14
movapd 0x60(%rsp),%xmm13
movapd 0xb5c(%rip),%xmm12
xorpd  %xmm11,%xmm11
movapd 0x10(%rsp),%xmm9
movapd 0xb37(%rip),%xmm8
movapd 0xb2f(%rip),%xmm7
mov    0x28(%rsp),%r9
jmp    16fa <hqr+0x5ca>
test   %r9d,%r9d
js     16b3 <hqr+0x583>
add    $0x1,%rax
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r9d
jae    1618 <hqr+0x4e8>
xor    %edi,%edi
jmp    167e <hqr+0x54e>
movapd %xmm13,0x60(%rsp)
movapd %xmm14,0x50(%rsp)
movapd %xmm15,0x40(%rsp)
movapd %xmm6,0x30(%rsp)
movapd %xmm3,0x80(%rsp)
call   1050 <sqrt@plt>
movapd 0x80(%rsp),%xmm3
movapd 0x30(%rsp),%xmm6
movapd 0x40(%rsp),%xmm15
movapd 0x50(%rsp),%xmm14
movapd 0x60(%rsp),%xmm13
movapd 0xabc(%rip),%xmm12
xorpd  %xmm11,%xmm11
movapd 0x10(%rsp),%xmm9
movapd 0xa97(%rip),%xmm8
movapd 0xa8f(%rip),%xmm7
mov    0x28(%rsp),%r9
addsd  0x8(%rsp),%xmm15
ucomisd %xmm11,%xmm3
jae    15a2 <hqr+0x472>
addsd  %xmm14,%xmm15
movsd  %xmm15,(%r15,%rbp,8)
movsd  %xmm15,(%r15,%r14,8)
movsd  %xmm0,(%r12,%rbp,8)
xorpd  %xmm12,%xmm0
jmp    1604 <hqr+0x4d4>
movapd %xmm0,%xmm2
andpd  %xmm8,%xmm2
orpd   %xmm12,%xmm0
xorpd  %xmm1,%xmm1
cmpnlesd %xmm14,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
addsd  %xmm14,%xmm1
movapd %xmm15,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rbp,8)
movsd  %xmm0,(%r15,%r14,8)
ucomisd %xmm11,%xmm1
jne    15e9 <hqr+0x4b9>
jnp    15f8 <hqr+0x4c8>
divsd  %xmm1,%xmm6
subsd  %xmm6,%xmm15
movsd  %xmm15,(%r15,%rbp,8)
movq   $0x0,(%r12,%rbp,8)
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%r12,%r14,8)
add    $0xfffffffe,%r9d
movsd  %xmm3,%xmm13
jmp    1ceb <hqr+0xbbb>
and    $0xfffffffc,%eax
xor    %edi,%edi
nopl   (%rax)
mov    (%rbx,%rdi,8),%rdx
movsd  (%rdx,%rdi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
mov    0x8(%rbx,%rdi,8),%rdx
movsd  0x8(%rdx,%rdi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x8(%rdx,%rdi,8)
mov    0x10(%rbx,%rdi,8),%rdx
movsd  0x10(%rdx,%rdi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x10(%rdx,%rdi,8)
mov    0x18(%rbx,%rdi,8),%rdx
movsd  0x18(%rdx,%rdi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x18(%rdx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1620 <hqr+0x4f0>
test   %rsi,%rsi
je     16ad <hqr+0x57d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rdi,8),%rax
movsd  (%rax,%rdi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,(%rax,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1690 <hqr+0x560>
movsd  (%rcx,%r14,8),%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm15,%xmm1
movsd  %xmm1,0x8(%rsp)
andpd  %xmm7,%xmm0
movsd  -0x10(%r8,%rbp,8),%xmm1
andpd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm6
mulsd  0x955(%rip),%xmm6
mulsd  %xmm1,%xmm6
movapd %xmm1,%xmm10
mulsd  0x93b(%rip),%xmm10
movapd %xmm10,%xmm15
lea    -0x2(%r9),%r8d
cmp    %r10d,%r8d
jl     1864 <hqr+0x734>
xorpd  %xmm12,%xmm6
movslq %r8d,%rax
movslq %r10d,%rcx
mov    (%rbx,%rax,8),%rsi
movsd  (%rsi,%rax,8),%xmm0
sub    %rax,%rcx
mov    0xb0(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
shl    $0x3,%rax
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm15,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm10,%xmm3
subsd  %xmm0,%xmm3
mov    -0x8(%rdx,%r8,8),%rdi
add    %rax,%rdi
movsd  0x8(%rdi,%r8,8),%xmm1
movapd %xmm1,%xmm13
subsd  %xmm0,%xmm13
subsd  %xmm2,%xmm13
movapd %xmm2,%xmm14
mulsd  %xmm3,%xmm14
addsd  %xmm6,%xmm14
divsd  (%rdi,%r8,8),%xmm14
add    %rax,%rsi
addsd  0x8(%rsi,%r8,8),%xmm14
subsd  %xmm3,%xmm13
mov    (%rdx,%r8,8),%rdi
add    %rax,%rdi
movapd %xmm14,%xmm2
andpd  %xmm7,%xmm2
movapd %xmm13,%xmm3
andpd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  0x8(%rdi,%r8,8),%xmm2
unpcklpd %xmm2,%xmm13
andpd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm14
unpcklpd %xmm2,%xmm2
divpd  %xmm2,%xmm13
cmp    %r8,%rcx
je     1861 <hqr+0x731>
movapd %xmm13,%xmm2
unpckhpd %xmm13,%xmm2
andpd  %xmm8,%xmm2
movsd  -0x8(%rsi,%r8,8),%xmm3
unpcklpd %xmm14,%xmm3
andpd  %xmm8,%xmm3
mov    -0x18(%rdx,%r8,8),%rsi
lea    (%rsi,%rax,1),%rdi
movsd  -0x8(%rdi,%r8,8),%xmm4
movapd %xmm4,%xmm5
andpd  %xmm8,%xmm5
andpd  %xmm8,%xmm0
addsd  %xmm5,%xmm0
unpcklpd %xmm0,%xmm2
movapd %xmm13,%xmm0
unpcklpd %xmm1,%xmm0
andpd  %xmm8,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm3,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm1,%xmm0
add    $0xffffffffffffffff,%r8
ucomisd %xmm1,%xmm0
movapd %xmm4,%xmm0
jne    1740 <hqr+0x610>
jp     1740 <hqr+0x610>
add    %r14d,%r8d
jmp    1864 <hqr+0x734>
mov    %r10d,%r8d
lea    0x2(%r8),%eax
cmp    %r9d,%eax
jg     1940 <hqr+0x810>
cltq
lea    0x1(%r9),%ecx
mov    (%rbx,%rax,8),%rdx
movq   $0x0,-0x10(%rdx,%rax,8)
add    $0x1,%rax
cmp    %eax,%ecx
je     1940 <hqr+0x810>
mov    %r9d,%ecx
sub    %r8d,%ecx
lea    0x2(%rcx),%edx
add    $0xfffffffd,%ecx
and    $0x3,%edx
je     18c7 <hqr+0x797>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rsi
xorpd  %xmm0,%xmm0
movupd %xmm0,-0x18(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    18b0 <hqr+0x780>
cmp    $0x3,%ecx
jb     1940 <hqr+0x810>
mov    %r9d,%ecx
sub    %eax,%ecx
add    $0x1,%ecx
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
shl    $0x3,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    -0x18(%rdx,%rsi,8),%rdi
add    %rax,%rdi
xorpd  %xmm0,%xmm0
movupd %xmm0,-0x18(%rdi,%rsi,8)
mov    -0x10(%rdx,%rsi,8),%rdi
add    %rax,%rdi
movupd %xmm0,-0x10(%rdi,%rsi,8)
mov    -0x8(%rdx,%rsi,8),%rdi
add    %rax,%rdi
movupd %xmm0,-0x8(%rdi,%rsi,8)
mov    (%rdx,%rsi,8),%rdi
add    %rax,%rdi
movupd %xmm0,(%rdi,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    18f0 <hqr+0x7c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addl   $0x1,0x4(%rsp)
cmp    %r9d,%r8d
jge    1ce6 <hqr+0xbb6>
movslq %r8d,%r13
movslq %r10d,%rax
lea    -0x1(%r13),%rdi
add    $0xffffffffffffffff,%rax
mov    %rax,0x90(%rsp)
mov    %r13,%r15
jmp    1981 <hqr+0x851>
nopl   0x0(%rax)
add    $0x1,%r15
add    $0x1,%rdi
cmp    %rbp,%r15
je     1cd9 <hqr+0xba9>
cmp    %r13,%r15
je     19f5 <hqr+0x8c5>
xorpd  %xmm15,%xmm15
cmp    %r14,%r15
je     199c <hqr+0x86c>
mov    0x10(%rbx,%r15,8),%rax
movsd  -0x8(%rax,%r15,8),%xmm15
mov    (%rbx,%r15,8),%rax
mov    0x8(%rbx,%r15,8),%rcx
movsd  -0x8(%rax,%r15,8),%xmm14
movsd  -0x8(%rcx,%r15,8),%xmm13
movapd %xmm14,%xmm0
andpd  %xmm7,%xmm0
movapd %xmm13,%xmm1
andpd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
unpcklpd %xmm15,%xmm13
andpd  %xmm7,%xmm15
addsd  %xmm1,%xmm15
ucomisd %xmm11,%xmm15
jne    19e1 <hqr+0x8b1>
jnp    19f5 <hqr+0x8c5>
divsd  %xmm15,%xmm14
movapd %xmm15,%xmm0
unpcklpd %xmm15,%xmm0
divpd  %xmm0,%xmm13
movapd %xmm13,%xmm0
mulsd  %xmm13,%xmm0
movapd %xmm14,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm13,%xmm10
unpckhpd %xmm13,%xmm10
movapd %xmm10,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
jb     1a40 <hqr+0x910>
sqrtsd %xmm0,%xmm0
jmp    1aca <hqr+0x99a>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm13,0x60(%rsp)
movapd %xmm14,0x50(%rsp)
movapd %xmm15,0x40(%rsp)
mov    %r8,%r12
mov    %rbp,%rbx
mov    %rdi,%rbp
movapd %xmm10,0x30(%rsp)
call   1050 <sqrt@plt>
movapd 0x30(%rsp),%xmm10
mov    %rbp,%rdi
mov    %rbx,%rbp
mov    0xc0(%rsp),%rbx
mov    %r12,%r8
movapd 0x40(%rsp),%xmm15
mov    0x80(%rsp),%r10d
movapd 0x50(%rsp),%xmm14
movapd 0x60(%rsp),%xmm13
movapd 0x568(%rip),%xmm12
xorpd  %xmm11,%xmm11
movapd 0x10(%rsp),%xmm9
movapd 0x543(%rip),%xmm8
movapd 0x53b(%rip),%xmm7
mov    0x28(%rsp),%r9
movapd %xmm0,%xmm2
andpd  %xmm8,%xmm2
orpd   %xmm12,%xmm0
xorpd  %xmm1,%xmm1
cmpnlesd %xmm14,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
ucomisd %xmm11,%xmm1
jne    1afb <hqr+0x9cb>
jnp    1970 <hqr+0x840>
cmp    %r13,%r15
jne    1b20 <hqr+0x9f0>
cmp    %r8d,%r10d
je     1b39 <hqr+0xa09>
mov    (%rbx,%r13,8),%rax
movsd  -0x8(%rax,%r13,8),%xmm0
xorpd  %xmm12,%xmm0
movlpd %xmm0,-0x8(%rax,%r13,8)
jmp    1b39 <hqr+0xa09>
xchg   %ax,%ax
movapd %xmm1,%xmm0
xorpd  %xmm12,%xmm0
mulsd  %xmm0,%xmm15
mov    (%rbx,%r15,8),%rax
movsd  %xmm15,-0x8(%rax,%r15,8)
addsd  %xmm1,%xmm14
movapd %xmm14,%xmm15
divsd  %xmm1,%xmm15
movapd %xmm13,%xmm0
divsd  %xmm1,%xmm0
divsd  %xmm1,%xmm10
unpcklpd %xmm14,%xmm14
divpd  %xmm14,%xmm13
mov    (%rbx,%r15,8),%rax
mov    0x8(%rbx,%r15,8),%rcx
movapd %xmm13,%xmm1
unpckhpd %xmm13,%xmm1
mov    %rdi,%rdx
jmp    1be8 <hqr+0xab8>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rbx,%r15,8),%rsi
movsd  0x8(%rsi,%rdx,8),%xmm3
movapd %xmm1,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm2,%xmm14
movapd %xmm14,%xmm2
xorpd  %xmm12,%xmm2
movapd %xmm14,%xmm4
mulsd  %xmm10,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%rsi,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x8(%rcx,%rdx,8)
mulsd  %xmm15,%xmm2
addsd  0x8(%rax,%rdx,8),%xmm2
movsd  %xmm2,0x8(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rbp,%rdx
jge    1c20 <hqr+0xaf0>
movsd  0x8(%rcx,%rdx,8),%xmm3
movapd %xmm13,%xmm14
mulsd  %xmm3,%xmm14
addsd  0x8(%rax,%rdx,8),%xmm14
cmp    %r14,%r15
jne    1b80 <hqr+0xa50>
movapd %xmm14,%xmm2
xorpd  %xmm12,%xmm2
jmp    1bbc <hqr+0xa8c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x3(%r15),%rax
cmp    %rbp,%rax
cmovg  %r9d,%eax
cmp    %eax,%r10d
jg     1970 <hqr+0x840>
cltq
mov    0x90(%rsp),%rcx
jmp    1c9b <hqr+0xb6b>
movsd  0x10(%rdx,%r15,8),%xmm5
movapd %xmm10,%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm4,%xmm14
movapd %xmm14,%xmm4
xorpd  %xmm12,%xmm4
movapd %xmm14,%xmm6
mulsd  %xmm1,%xmm6
subsd  %xmm6,%xmm5
movsd  %xmm5,0x10(%rdx,%r15,8)
mulsd  %xmm13,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x8(%rdx,%r15,8)
subsd  %xmm14,%xmm2
movsd  %xmm2,(%rdx,%r15,8)
add    $0x1,%rcx
cmp    %rax,%rcx
jge    1970 <hqr+0x840>
mov    0x8(%rbx,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
movsd  0x8(%rdx,%r15,8),%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm15,%xmm14
mulsd  %xmm2,%xmm14
addsd  %xmm4,%xmm14
cmp    %r14,%r15
jne    1c40 <hqr+0xb10>
movapd %xmm14,%xmm4
xorpd  %xmm12,%xmm4
jmp    1c73 <hqr+0xb43>
mov    0xb8(%rsp),%r12
mov    0x78(%rsp),%r15
mov    0x4(%rsp),%r13d
cmp    $0x2,%r9d
jg     12f0 <hqr+0x1c0>
mov    $0x0,%r13d
test   %r9d,%r9d
jns    12f0 <hqr+0x1c0>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [27 x i8] c"Too many iterations in hqr\00"
define void @hqr(double** %0, i32 %1, double* %2, double* %3) {
%5 = alloca double**
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
store double** %0, double*** %5
store i32 %1, i32* %6
store double* %2, double** %7
store double* %3, double** %8
store double 0.000000e+00, double* %25
store double 0.000000e+00, double* %26
store double 0.000000e+00, double* %27
store double 0.000000e+00, double* %28
store i32 0, i32* %15
br label %29
29: ; preds = %58, %4
%30 = load i32, i32* %15
%31 = load i32, i32* %6
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %61
33: ; preds = %29
%34 = load i32, i32* %15
%35 = sub nsw i32 %34, 1
%36 = call i32 (i32, i32, ...) bitcast (i32 (...)* @imax to i32 (i32, i32, ...)*)(i32 %35, i32 0)
store i32 %36, i32* %13
br label %37
37: ; preds = %54, %33
%38 = load i32, i32* %13
%39 = load i32, i32* %6
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %57
41: ; preds = %37
%42 = load double**, double*** %5
%43 = load i32, i32* %15
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double*, double** %42, i64 %44
%46 = load double*, double** %45
%47 = load i32, i32* %13
%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* %28
%53 = fadd double %52, %51
store double %53, double* %28
br label %54
54: ; preds = %41
%55 = load i32, i32* %13
%56 = add nsw i32 %55, 1
store i32 %56, i32* %13
br label %37
57: ; preds = %37
br label %58
58: ; preds = %57
%59 = load i32, i32* %15
%60 = add nsw i32 %59, 1
store i32 %60, i32* %15
br label %29
61: ; preds = %29
%62 = load i32, i32* %6
%63 = sub nsw i32 %62, 1
store i32 %63, i32* %9
store double 0.000000e+00, double* %23
br label %64
64: ; preds = %905, %61
%65 = load i32, i32* %9
%66 = icmp sge i32 %65, 0
br i1 %66, label %67, label %906
67: ; preds = %64
store i32 0, i32* %14
br label %68
68: ; preds = %901, %67
%69 = load i32, i32* %9
store i32 %69, i32* %11
br label %70
70: ; preds = %119, %68
%71 = load i32, i32* %11
%72 = icmp sge i32 %71, 1
br i1 %72, label %73, label %122
73: ; preds = %70
%74 = load double**, double*** %5
%75 = load i32, i32* %11
%76 = sub nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double*, double** %74, i64 %77
%79 = load double*, double** %78
%80 = load i32, i32* %11
%81 = sub nsw i32 %80, 1
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %79, i64 %82
%84 = load double, double* %83
%85 = call double @llvm.fabs.f64(double %84)
%86 = load double**, double*** %5
%87 = load i32, i32* %11
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double*, double** %86, i64 %88
%90 = load double*, double** %89
%91 = load i32, i32* %11
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %90, i64 %92
%94 = load double, double* %93
%95 = call double @llvm.fabs.f64(double %94)
%96 = fadd double %85, %95
store double %96, double* %24
%97 = load double, double* %24
%98 = fcmp oeq double %97, 0.000000e+00
br i1 %98, label %99, label %101
99: ; preds = %73
%100 = load double, double* %28
store double %100, double* %24
br label %101
101: ; preds = %99, %73
%102 = load double**, double*** %5
%103 = load i32, i32* %11
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double*, double** %102, i64 %104
%106 = load double*, double** %105
%107 = load i32, i32* %11
%108 = sub nsw i32 %107, 1
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %106, i64 %109
%111 = load double, double* %110
%112 = load double, double* %24
%113 = fadd double %111, %112
%114 = call double @llvm.fabs.f64(double %113)
%115 = load double, double* %24
%116 = fcmp oeq double %114, %115
br i1 %116, label %117, label %118
117: ; preds = %101
br label %122
118: ; preds = %101
br label %119
119: ; preds = %118
%120 = load i32, i32* %11
%121 = add nsw i32 %120, -1
store i32 %121, i32* %11
br label %70
122: ; preds = %117, %70
%123 = load double**, double*** %5
%124 = load i32, i32* %9
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double*, double** %123, i64 %125
%127 = load double*, double** %126
%128 = load i32, i32* %9
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
%131 = load double, double* %130
store double %131, double* %19
%132 = load i32, i32* %11
%133 = load i32, i32* %9
%134 = icmp eq i32 %132, %133
br i1 %134, label %135, label %148
135: ; preds = %122
%136 = load double, double* %19
%137 = load double, double* %23
%138 = fadd double %136, %137
%139 = load double*, double** %7
%140 = load i32, i32* %9
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
store double %138, double* %142
%143 = load double*, double** %8
%144 = load i32, i32* %9
%145 = add nsw i32 %144, -1
store i32 %145, i32* %9
%146 = sext i32 %144 to i64
%147 = getelementptr inbounds double, double* %143, i64 %146
store double 0.000000e+00, double* %147
br label %900
148: ; preds = %122
%149 = load double**, double*** %5
%150 = load i32, i32* %9
%151 = sub nsw i32 %150, 1
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double*, double** %149, i64 %152
%154 = load double*, double** %153
%155 = load i32, i32* %9
%156 = sub nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %154, i64 %157
%159 = load double, double* %158
store double %159, double* %18
%160 = load double**, double*** %5
%161 = load i32, i32* %9
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double*, double** %160, i64 %162
%164 = load double*, double** %163
%165 = load i32, i32* %9
%166 = sub nsw i32 %165, 1
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %164, i64 %167
%169 = load double, double* %168
%170 = load double**, double*** %5
%171 = load i32, i32* %9
%172 = sub nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double*, double** %170, i64 %173
%175 = load double*, double** %174
%176 = load i32, i32* %9
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds double, double* %175, i64 %177
%179 = load double, double* %178
%180 = fmul double %169, %179
store double %180, double* %20
%181 = load i32, i32* %11
%182 = load i32, i32* %9
%183 = sub nsw i32 %182, 1
%184 = icmp eq i32 %181, %183
br i1 %184, label %185, label %277
185: ; preds = %148
%186 = load double, double* %18
%187 = load double, double* %19
%188 = fsub double %186, %187
%189 = fmul double 5.000000e-01, %188
store double %189, double* %27
%190 = load double, double* %27
%191 = load double, double* %27
%192 = load double, double* %20
%193 = call double @llvm.fmuladd.f64(double %190, double %191, double %192)
store double %193, double* %26
%194 = load double, double* %26
%195 = call double @llvm.fabs.f64(double %194)
%196 = call double @sqrt(double %195)
store double %196, double* %17
%197 = load double, double* %23
%198 = load double, double* %19
%199 = fadd double %198, %197
store double %199, double* %19
%200 = load double, double* %26
%201 = fcmp oge double %200, 0.000000e+00
br i1 %201, label %202, label %250
202: ; preds = %185
%203 = load double, double* %27
%204 = load double, double* %27
%205 = fcmp oge double %204, 0.000000e+00
br i1 %205, label %206, label %209
206: ; preds = %202
%207 = load double, double* %17
%208 = call double @llvm.fabs.f64(double %207)
br label %213
209: ; preds = %202
%210 = load double, double* %17
%211 = call double @llvm.fabs.f64(double %210)
%212 = fneg double %211
br label %213
213: ; preds = %209, %206
%214 = phi double [ %208, %206 ], [ %212, %209 ]
%215 = fadd double %203, %214
store double %215, double* %17
%216 = load double, double* %19
%217 = load double, double* %17
%218 = fadd double %216, %217
%219 = load double*, double** %7
%220 = load i32, i32* %9
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
store double %218, double* %222
%223 = load double*, double** %7
%224 = load i32, i32* %9
%225 = sub nsw i32 %224, 1
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %223, i64 %226
store double %218, double* %227
%228 = load double, double* %17
%229 = fcmp une double %228, 0.000000e+00
br i1 %229, label %230, label %240
230: ; preds = %213
%231 = load double, double* %19
%232 = load double, double* %20
%233 = load double, double* %17
%234 = fdiv double %232, %233
%235 = fsub double %231, %234
%236 = load double*, double** %7
%237 = load i32, i32* %9
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %236, i64 %238
store double %235, double* %239
br label %240
240: ; preds = %230, %213
%241 = load double*, double** %8
%242 = load i32, i32* %9
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double, double* %241, i64 %243
store double 0.000000e+00, double* %244
%245 = load double*, double** %8
%246 = load i32, i32* %9
%247 = sub nsw i32 %246, 1
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %245, i64 %248
store double 0.000000e+00, double* %249
br label %274
250: ; preds = %185
%251 = load double, double* %19
%252 = load double, double* %27
%253 = fadd double %251, %252
%254 = load double*, double** %7
%255 = load i32, i32* %9
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
store double %253, double* %257
%258 = load double*, double** %7
%259 = load i32, i32* %9
%260 = sub nsw i32 %259, 1
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %258, i64 %261
store double %253, double* %262
%263 = load double, double* %17
%264 = load double*, double** %8
%265 = load i32, i32* %9
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %264, i64 %266
store double %263, double* %267
%268 = fneg double %263
%269 = load double*, double** %8
%270 = load i32, i32* %9
%271 = sub nsw i32 %270, 1
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %269, i64 %272
store double %268, double* %273
br label %274
274: ; preds = %250, %240
%275 = load i32, i32* %9
%276 = sub nsw i32 %275, 2
store i32 %276, i32* %9
br label %899
277: ; preds = %148
%278 = load i32, i32* %14
%279 = icmp eq i32 %278, 30
br i1 %279, label %280, label %282
280: ; preds = %277
%281 = call i32 (i8*, ...) bitcast (i32 (...)* @error to i32 (i8*, ...)*)(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
br label %282
282: ; preds = %280, %277
%283 = load i32, i32* %14
%284 = icmp eq i32 %283, 10
br i1 %284, label %288, label %285
285: ; preds = %282
%286 = load i32, i32* %14
%287 = icmp eq i32 %286, 20
br i1 %287, label %288, label %342
288: ; preds = %285, %282
%289 = load double, double* %19
%290 = load double, double* %23
%291 = fadd double %290, %289
store double %291, double* %23
store i32 0, i32* %15
br label %292
292: ; preds = %308, %288
%293 = load i32, i32* %15
%294 = load i32, i32* %9
%295 = icmp sle i32 %293, %294
br i1 %295, label %296, label %311
296: ; preds = %292
%297 = load double, double* %19
%298 = load double**, double*** %5
%299 = load i32, i32* %15
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double*, double** %298, i64 %300
%302 = load double*, double** %301
%303 = load i32, i32* %15
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds double, double* %302, i64 %304
%306 = load double, double* %305
%307 = fsub double %306, %297
store double %307, double* %305
br label %308
308: ; preds = %296
%309 = load i32, i32* %15
%310 = add nsw i32 %309, 1
store i32 %310, i32* %15
br label %292
311: ; preds = %292
%312 = load double**, double*** %5
%313 = load i32, i32* %9
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double*, double** %312, i64 %314
%316 = load double*, double** %315
%317 = load i32, i32* %9
%318 = sub nsw i32 %317, 1
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %316, i64 %319
%321 = load double, double* %320
%322 = call double @llvm.fabs.f64(double %321)
%323 = load double**, double*** %5
%324 = load i32, i32* %9
%325 = sub nsw i32 %324, 1
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double*, double** %323, i64 %326
%328 = load double*, double** %327
%329 = load i32, i32* %9
%330 = sub nsw i32 %329, 2
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %328, i64 %331
%333 = load double, double* %332
%334 = call double @llvm.fabs.f64(double %333)
%335 = fadd double %322, %334
store double %335, double* %24
%336 = load double, double* %24
%337 = fmul double 7.500000e-01, %336
store double %337, double* %19
store double %337, double* %18
%338 = load double, double* %24
%339 = fmul double -4.375000e-01, %338
%340 = load double, double* %24
%341 = fmul double %339, %340
store double %341, double* %20
br label %342
342: ; preds = %311, %285
%343 = load i32, i32* %14
%344 = add nsw i32 %343, 1
store i32 %344, i32* %14
%345 = load i32, i32* %9
%346 = sub nsw i32 %345, 2
store i32 %346, i32* %10
br label %347
347: ; preds = %499, %342
%348 = load i32, i32* %10
%349 = load i32, i32* %11
%350 = icmp sge i32 %348, %349
br i1 %350, label %351, label %502
351: ; preds = %347
%352 = load double**, double*** %5
%353 = load i32, i32* %10
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double*, double** %352, i64 %354
%356 = load double*, double** %355
%357 = load i32, i32* %10
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
%360 = load double, double* %359
store double %360, double* %17
%361 = load double, double* %19
%362 = load double, double* %17
%363 = fsub double %361, %362
store double %363, double* %25
%364 = load double, double* %18
%365 = load double, double* %17
%366 = fsub double %364, %365
store double %366, double* %24
%367 = load double, double* %25
%368 = load double, double* %24
%369 = load double, double* %20
%370 = fneg double %369
%371 = call double @llvm.fmuladd.f64(double %367, double %368, double %370)
%372 = load double**, double*** %5
%373 = load i32, i32* %10
%374 = add nsw i32 %373, 1
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double*, double** %372, i64 %375
%377 = load double*, double** %376
%378 = load i32, i32* %10
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %377, i64 %379
%381 = load double, double* %380
%382 = fdiv double %371, %381
%383 = load double**, double*** %5
%384 = load i32, i32* %10
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds double*, double** %383, i64 %385
%387 = load double*, double** %386
%388 = load i32, i32* %10
%389 = add nsw i32 %388, 1
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %387, i64 %390
%392 = load double, double* %391
%393 = fadd double %382, %392
store double %393, double* %27
%394 = load double**, double*** %5
%395 = load i32, i32* %10
%396 = add nsw i32 %395, 1
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double*, double** %394, i64 %397
%399 = load double*, double** %398
%400 = load i32, i32* %10
%401 = add nsw i32 %400, 1
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %399, i64 %402
%404 = load double, double* %403
%405 = load double, double* %17
%406 = fsub double %404, %405
%407 = load double, double* %25
%408 = fsub double %406, %407
%409 = load double, double* %24
%410 = fsub double %408, %409
store double %410, double* %26
%411 = load double**, double*** %5
%412 = load i32, i32* %10
%413 = add nsw i32 %412, 2
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double*, double** %411, i64 %414
%416 = load double*, double** %415
%417 = load i32, i32* %10
%418 = add nsw i32 %417, 1
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double, double* %416, i64 %419
%421 = load double, double* %420
store double %421, double* %25
%422 = load double, double* %27
%423 = call double @llvm.fabs.f64(double %422)
%424 = load double, double* %26
%425 = call double @llvm.fabs.f64(double %424)
%426 = fadd double %423, %425
%427 = load double, double* %25
%428 = call double @llvm.fabs.f64(double %427)
%429 = fadd double %426, %428
store double %429, double* %24
%430 = load double, double* %24
%431 = load double, double* %27
%432 = fdiv double %431, %430
store double %432, double* %27
%433 = load double, double* %24
%434 = load double, double* %26
%435 = fdiv double %434, %433
store double %435, double* %26
%436 = load double, double* %24
%437 = load double, double* %25
%438 = fdiv double %437, %436
store double %438, double* %25
%439 = load i32, i32* %10
%440 = load i32, i32* %11
%441 = icmp eq i32 %439, %440
br i1 %441, label %442, label %443
442: ; preds = %351
br label %502
443: ; preds = %351
%444 = load double**, double*** %5
%445 = load i32, i32* %10
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double*, double** %444, i64 %446
%448 = load double*, double** %447
%449 = load i32, i32* %10
%450 = sub nsw i32 %449, 1
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %448, i64 %451
%453 = load double, double* %452
%454 = call double @llvm.fabs.f64(double %453)
%455 = load double, double* %26
%456 = call double @llvm.fabs.f64(double %455)
%457 = load double, double* %25
%458 = call double @llvm.fabs.f64(double %457)
%459 = fadd double %456, %458
%460 = fmul double %454, %459
store double %460, double* %22
%461 = load double, double* %27
%462 = call double @llvm.fabs.f64(double %461)
%463 = load double**, double*** %5
%464 = load i32, i32* %10
%465 = sub nsw i32 %464, 1
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds double*, double** %463, i64 %466
%468 = load double*, double** %467
%469 = load i32, i32* %10
%470 = sub nsw i32 %469, 1
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %468, i64 %471
%473 = load double, double* %472
%474 = call double @llvm.fabs.f64(double %473)
%475 = load double, double* %17
%476 = call double @llvm.fabs.f64(double %475)
%477 = fadd double %474, %476
%478 = load double**, double*** %5
%479 = load i32, i32* %10
%480 = add nsw i32 %479, 1
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds double*, double** %478, i64 %481
%483 = load double*, double** %482
%484 = load i32, i32* %10
%485 = add nsw i32 %484, 1
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %483, i64 %486
%488 = load double, double* %487
%489 = call double @llvm.fabs.f64(double %488)
%490 = fadd double %477, %489
%491 = fmul double %462, %490
store double %491, double* %21
%492 = load double, double* %22
%493 = load double, double* %21
%494 = fadd double %492, %493
%495 = load double, double* %21
%496 = fcmp oeq double %494, %495
br i1 %496, label %497, label %498
497: ; preds = %443
br label %502
498: ; preds = %443
br label %499
499: ; preds = %498
%500 = load i32, i32* %10
%501 = add nsw i32 %500, -1
store i32 %501, i32* %10
br label %347
502: ; preds = %497, %442, %347
%503 = load i32, i32* %10
%504 = add nsw i32 %503, 2
store i32 %504, i32* %15
br label %505
505: ; preds = %534, %502
%506 = load i32, i32* %15
%507 = load i32, i32* %9
%508 = icmp sle i32 %506, %507
br i1 %508, label %509, label %537
509: ; preds = %505
%510 = load double**, double*** %5
%511 = load i32, i32* %15
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double*, double** %510, i64 %512
%514 = load double*, double** %513
%515 = load i32, i32* %15
%516 = sub nsw i32 %515, 2
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds double, double* %514, i64 %517
store double 0.000000e+00, double* %518
%519 = load i32, i32* %15
%520 = load i32, i32* %10
%521 = add nsw i32 %520, 2
%522 = icmp ne i32 %519, %521
br i1 %522, label %523, label %533
523: ; preds = %509
%524 = load double**, double*** %5
%525 = load i32, i32* %15
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double*, double** %524, i64 %526
%528 = load double*, double** %527
%529 = load i32, i32* %15
%530 = sub nsw i32 %529, 3
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %528, i64 %531
store double 0.000000e+00, double* %532
br label %533
533: ; preds = %523, %509
br label %534
534: ; preds = %533
%535 = load i32, i32* %15
%536 = add nsw i32 %535, 1
store i32 %536, i32* %15
br label %505
537: ; preds = %505
%538 = load i32, i32* %10
store i32 %538, i32* %12
br label %539
539: ; preds = %895, %537
%540 = load i32, i32* %12
%541 = load i32, i32* %9
%542 = sub nsw i32 %541, 1
%543 = icmp sle i32 %540, %542
br i1 %543, label %544, label %898
544: ; preds = %539
%545 = load i32, i32* %12
%546 = load i32, i32* %10
%547 = icmp ne i32 %545, %546
br i1 %547, label %548, label %607
548: ; preds = %544
%549 = load double**, double*** %5
%550 = load i32, i32* %12
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds double*, double** %549, i64 %551
%553 = load double*, double** %552
%554 = load i32, i32* %12
%555 = sub nsw i32 %554, 1
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds double, double* %553, i64 %556
%558 = load double, double* %557
store double %558, double* %27
%559 = load double**, double*** %5
%560 = load i32, i32* %12
%561 = add nsw i32 %560, 1
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds double*, double** %559, i64 %562
%564 = load double*, double** %563
%565 = load i32, i32* %12
%566 = sub nsw i32 %565, 1
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds double, double* %564, i64 %567
%569 = load double, double* %568
store double %569, double* %26
store double 0.000000e+00, double* %25
%570 = load i32, i32* %12
%571 = load i32, i32* %9
%572 = sub nsw i32 %571, 1
%573 = icmp ne i32 %570, %572
br i1 %573, label %574, label %586
574: ; preds = %548
%575 = load double**, double*** %5
%576 = load i32, i32* %12
%577 = add nsw i32 %576, 2
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds double*, double** %575, i64 %578
%580 = load double*, double** %579
%581 = load i32, i32* %12
%582 = sub nsw i32 %581, 1
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %580, i64 %583
%585 = load double, double* %584
store double %585, double* %25
br label %586
586: ; preds = %574, %548
%587 = load double, double* %27
%588 = call double @llvm.fabs.f64(double %587)
%589 = load double, double* %26
%590 = call double @llvm.fabs.f64(double %589)
%591 = fadd double %588, %590
%592 = load double, double* %25
%593 = call double @llvm.fabs.f64(double %592)
%594 = fadd double %591, %593
store double %594, double* %19
%595 = fcmp une double %594, 0.000000e+00
br i1 %595, label %596, label %606
596: ; preds = %586
%597 = load double, double* %19
%598 = load double, double* %27
%599 = fdiv double %598, %597
store double %599, double* %27
%600 = load double, double* %19
%601 = load double, double* %26
%602 = fdiv double %601, %600
store double %602, double* %26
%603 = load double, double* %19
%604 = load double, double* %25
%605 = fdiv double %604, %603
store double %605, double* %25
br label %606
606: ; preds = %596, %586
br label %607
607: ; preds = %606, %544
%608 = load double, double* %27
%609 = fcmp oge double %608, 0.000000e+00
br i1 %609, label %610, label %622
610: ; preds = %607
%611 = load double, double* %27
%612 = load double, double* %27
%613 = load double, double* %26
%614 = load double, double* %26
%615 = fmul double %613, %614
%616 = call double @llvm.fmuladd.f64(double %611, double %612, double %615)
%617 = load double, double* %25
%618 = load double, double* %25
%619 = call double @llvm.fmuladd.f64(double %617, double %618, double %616)
%620 = call double @sqrt(double %619)
%621 = call double @llvm.fabs.f64(double %620)
br label %635
622: ; preds = %607
%623 = load double, double* %27
%624 = load double, double* %27
%625 = load double, double* %26
%626 = load double, double* %26
%627 = fmul double %625, %626
%628 = call double @llvm.fmuladd.f64(double %623, double %624, double %627)
%629 = load double, double* %25
%630 = load double, double* %25
%631 = call double @llvm.fmuladd.f64(double %629, double %630, double %628)
%632 = call double @sqrt(double %631)
%633 = call double @llvm.fabs.f64(double %632)
%634 = fneg double %633
br label %635
635: ; preds = %622, %610
%636 = phi double [ %621, %610 ], [ %634, %622 ]
store double %636, double* %24
%637 = fcmp une double %636, 0.000000e+00
br i1 %637, label %638, label %894
638: ; preds = %635
%639 = load i32, i32* %12
%640 = load i32, i32* %10
%641 = icmp eq i32 %639, %640
br i1 %641, label %642, label %668
642: ; preds = %638
%643 = load i32, i32* %11
%644 = load i32, i32* %10
%645 = icmp ne i32 %643, %644
br i1 %645, label %646, label %667
646: ; preds = %642
%647 = load double**, double*** %5
%648 = load i32, i32* %12
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds double*, double** %647, i64 %649
%651 = load double*, double** %650
%652 = load i32, i32* %12
%653 = sub nsw i32 %652, 1
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %651, i64 %654
%656 = load double, double* %655
%657 = fneg double %656
%658 = load double**, double*** %5
%659 = load i32, i32* %12
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double*, double** %658, i64 %660
%662 = load double*, double** %661
%663 = load i32, i32* %12
%664 = sub nsw i32 %663, 1
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %662, i64 %665
store double %657, double* %666
br label %667
667: ; preds = %646, %642
br label %682
668: ; preds = %638
%669 = load double, double* %24
%670 = fneg double %669
%671 = load double, double* %19
%672 = fmul double %670, %671
%673 = load double**, double*** %5
%674 = load i32, i32* %12
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double*, double** %673, i64 %675
%677 = load double*, double** %676
%678 = load i32, i32* %12
%679 = sub nsw i32 %678, 1
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds double, double* %677, i64 %680
store double %672, double* %681
br label %682
682: ; preds = %668, %667
%683 = load double, double* %24
%684 = load double, double* %27
%685 = fadd double %684, %683
store double %685, double* %27
%686 = load double, double* %27
%687 = load double, double* %24
%688 = fdiv double %686, %687
store double %688, double* %19
%689 = load double, double* %26
%690 = load double, double* %24
%691 = fdiv double %689, %690
store double %691, double* %18
%692 = load double, double* %25
%693 = load double, double* %24
%694 = fdiv double %692, %693
store double %694, double* %17
%695 = load double, double* %27
%696 = load double, double* %26
%697 = fdiv double %696, %695
store double %697, double* %26
%698 = load double, double* %27
%699 = load double, double* %25
%700 = fdiv double %699, %698
store double %700, double* %25
%701 = load i32, i32* %12
store i32 %701, i32* %13
br label %702
702: ; preds = %788, %682
%703 = load i32, i32* %13
%704 = load i32, i32* %9
%705 = icmp sle i32 %703, %704
br i1 %705, label %706, label %791
706: ; preds = %702
%707 = load double**, double*** %5
%708 = load i32, i32* %12
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds double*, double** %707, i64 %709
%711 = load double*, double** %710
%712 = load i32, i32* %13
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double, double* %711, i64 %713
%715 = load double, double* %714
%716 = load double, double* %26
%717 = load double**, double*** %5
%718 = load i32, i32* %12
%719 = add nsw i32 %718, 1
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds double*, double** %717, i64 %720
%722 = load double*, double** %721
%723 = load i32, i32* %13
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds double, double* %722, i64 %724
%726 = load double, double* %725
%727 = call double @llvm.fmuladd.f64(double %716, double %726, double %715)
store double %727, double* %27
%728 = load i32, i32* %12
%729 = load i32, i32* %9
%730 = sub nsw i32 %729, 1
%731 = icmp ne i32 %728, %730
br i1 %731, label %732, label %760
732: ; preds = %706
%733 = load double, double* %25
%734 = load double**, double*** %5
%735 = load i32, i32* %12
%736 = add nsw i32 %735, 2
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double*, double** %734, i64 %737
%739 = load double*, double** %738
%740 = load i32, i32* %13
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds double, double* %739, i64 %741
%743 = load double, double* %742
%744 = load double, double* %27
%745 = call double @llvm.fmuladd.f64(double %733, double %743, double %744)
store double %745, double* %27
%746 = load double, double* %27
%747 = load double, double* %17
%748 = load double**, double*** %5
%749 = load i32, i32* %12
%750 = add nsw i32 %749, 2
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds double*, double** %748, i64 %751
%753 = load double*, double** %752
%754 = load i32, i32* %13
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds double, double* %753, i64 %755
%757 = load double, double* %756
%758 = fneg double %746
%759 = call double @llvm.fmuladd.f64(double %758, double %747, double %757)
store double %759, double* %756
br label %760
760: ; preds = %732, %706
%761 = load double, double* %27
%762 = load double, double* %18
%763 = load double**, double*** %5
%764 = load i32, i32* %12
%765 = add nsw i32 %764, 1
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds double*, double** %763, i64 %766
%768 = load double*, double** %767
%769 = load i32, i32* %13
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %768, i64 %770
%772 = load double, double* %771
%773 = fneg double %761
%774 = call double @llvm.fmuladd.f64(double %773, double %762, double %772)
store double %774, double* %771
%775 = load double, double* %27
%776 = load double, double* %19
%777 = load double**, double*** %5
%778 = load i32, i32* %12
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds double*, double** %777, i64 %779
%781 = load double*, double** %780
%782 = load i32, i32* %13
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds double, double* %781, i64 %783
%785 = load double, double* %784
%786 = fneg double %775
%787 = call double @llvm.fmuladd.f64(double %786, double %776, double %785)
store double %787, double* %784
br label %788
788: ; preds = %760
%789 = load i32, i32* %13
%790 = add nsw i32 %789, 1
store i32 %790, i32* %13
br label %702
791: ; preds = %702
%792 = load i32, i32* %9
%793 = load i32, i32* %12
%794 = add nsw i32 %793, 3
%795 = icmp slt i32 %792, %794
br i1 %795, label %796, label %798
796: ; preds = %791
%797 = load i32, i32* %9
br label %801
798: ; preds = %791
%799 = load i32, i32* %12
%800 = add nsw i32 %799, 3
br label %801
801: ; preds = %798, %796
%802 = phi i32 [ %797, %796 ], [ %800, %798 ]
store i32 %802, i32* %16
%803 = load i32, i32* %11
store i32 %803, i32* %15
br label %804
804: ; preds = %890, %801
%805 = load i32, i32* %15
%806 = load i32, i32* %16
%807 = icmp sle i32 %805, %806
br i1 %807, label %808, label %893
808: ; preds = %804
%809 = load double, double* %19
%810 = load double**, double*** %5
%811 = load i32, i32* %15
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds double*, double** %810, i64 %812
%814 = load double*, double** %813
%815 = load i32, i32* %12
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds double, double* %814, i64 %816
%818 = load double, double* %817
%819 = load double, double* %18
%820 = load double**, double*** %5
%821 = load i32, i32* %15
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds double*, double** %820, i64 %822
%824 = load double*, double** %823
%825 = load i32, i32* %12
%826 = add nsw i32 %825, 1
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds double, double* %824, i64 %827
%829 = load double, double* %828
%830 = fmul double %819, %829
%831 = call double @llvm.fmuladd.f64(double %809, double %818, double %830)
store double %831, double* %27
%832 = load i32, i32* %12
%833 = load i32, i32* %9
%834 = sub nsw i32 %833, 1
%835 = icmp ne i32 %832, %834
br i1 %835, label %836, label %864
836: ; preds = %808
%837 = load double, double* %17
%838 = load double**, double*** %5
%839 = load i32, i32* %15
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double*, double** %838, i64 %840
%842 = load double*, double** %841
%843 = load i32, i32* %12
%844 = add nsw i32 %843, 2
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds double, double* %842, i64 %845
%847 = load double, double* %846
%848 = load double, double* %27
%849 = call double @llvm.fmuladd.f64(double %837, double %847, double %848)
store double %849, double* %27
%850 = load double, double* %27
%851 = load double, double* %25
%852 = load double**, double*** %5
%853 = load i32, i32* %15
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds double*, double** %852, i64 %854
%856 = load double*, double** %855
%857 = load i32, i32* %12
%858 = add nsw i32 %857, 2
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds double, double* %856, i64 %859
%861 = load double, double* %860
%862 = fneg double %850
%863 = call double @llvm.fmuladd.f64(double %862, double %851, double %861)
store double %863, double* %860
br label %864
864: ; preds = %836, %808
%865 = load double, double* %27
%866 = load double, double* %26
%867 = load double**, double*** %5
%868 = load i32, i32* %15
%869 = sext i32 %868 to i64
%870 = getelementptr inbounds double*, double** %867, i64 %869
%871 = load double*, double** %870
%872 = load i32, i32* %12
%873 = add nsw i32 %872, 1
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds double, double* %871, i64 %874
%876 = load double, double* %875
%877 = fneg double %865
%878 = call double @llvm.fmuladd.f64(double %877, double %866, double %876)
store double %878, double* %875
%879 = load double, double* %27
%880 = load double**, double*** %5
%881 = load i32, i32* %15
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds double*, double** %880, i64 %882
%884 = load double*, double** %883
%885 = load i32, i32* %12
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %884, i64 %886
%888 = load double, double* %887
%889 = fsub double %888, %879
store double %889, double* %887
br label %890
890: ; preds = %864
%891 = load i32, i32* %15
%892 = add nsw i32 %891, 1
store i32 %892, i32* %15
br label %804
893: ; preds = %804
br label %894
894: ; preds = %893, %635
br label %895
895: ; preds = %894
%896 = load i32, i32* %12
%897 = add nsw i32 %896, 1
store i32 %897, i32* %12
br label %539
898: ; preds = %539
br label %899
899: ; preds = %898, %274
br label %900
900: ; preds = %899, %135
br label %901
901: ; preds = %900
%902 = load i32, i32* %9
%903 = sub nsw i32 %902, 1
%904 = icmp slt i32 1, %903
br i1 %904, label %68, label %905
905: ; preds = %901
br label %64
906: ; preds = %64
ret void
}

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