#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float fabs(float);
int /*<<< orphan*/ nrerror(char *);
float sqrt(float);
void hqr(float **a, int n, float wr[], float wi[]) {
  int nn, m, l, k, j, its, i, nmin;
  float z, y, x, w, v, u, t, s, r, q, p, anorm;
  anorm = fabs(a[1][1]);
  for (i = 2; i <= n; i++)
    for (j = (i - 1); j <= n; j++)
      anorm += fabs(a[i][j]);
  nn = n;
  t = 0.0;
  while (nn >= 1) {
    its = 0;
    do {
      for (l = nn; l >= 2; l--) {
        s = fabs(a[l - 1][l - 1]) + fabs(a[l][l]);
        if (s == 0.0)
          s = anorm;
        if ((float)(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)
            nrerror("Too many iterations in hqr");
          if (its == 10 || its == 20) {
            t += x;
            for (i = 1; 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 == 1)
              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 ((float)(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;
              }
              nmin = nn < k + 3 ? nn : k + 3;
              for (i = l; i <= nmin; 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 (l < nn - 1);
  }
}


x86 assembly (clang, -O0):
<hqr>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x70(%rbp)
movl   $0x2,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11ce <hqr+0x9e>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11bb <hqr+0x8b>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117d <hqr+0x4d>
jmp    11c0 <hqr+0x90>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1168 <hqr+0x38>
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpl   $0x1,-0x24(%rbp)
jl     1ff6 <hqr+0xec6>
movl   $0x0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jl     12c3 <hqr+0x193>
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
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1277 <hqr+0x147>
jp     1277 <hqr+0x147>
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
addss  -0x60(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jne    12b0 <hqr+0x180>
jp     12b0 <hqr+0x180>
jmp    12c3 <hqr+0x193>
jmp    12b5 <hqr+0x185>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f3 <hqr+0xc3>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    131f <hqr+0x1ef>
movss  -0x4c(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1fdb <hqr+0xeab>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    155f <hqr+0x42f>
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c6d(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
call   1040 <fabs@plt>
call   1050 <sqrt@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14f7 <hqr+0x3c7>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1439 <hqr+0x309>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x7c(%rbp)
jmp    1455 <hqr+0x325>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14ad <hqr+0x37d>
jp     14ad <hqr+0x37d>
jmp    14cd <hqr+0x39d>
movss  -0x4c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
divss  -0x44(%rbp),%xmm1
subss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1551 <hqr+0x421>
movss  -0x4c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1fd6 <hqr+0xea6>
cmpl   $0x1e,-0x38(%rbp)
jne    1575 <hqr+0x445>
lea    0x1aa8(%rip),%rdi
call   1030 <nrerror@plt>
cmpl   $0xa,-0x38(%rbp)
je     1589 <hqr+0x459>
cmpl   $0x14,-0x38(%rbp)
jne    1683 <hqr+0x553>
movss  -0x4c(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     15dc <hqr+0x4ac>
movss  -0x4c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    159f <hqr+0x46f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x80(%rbp)
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
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x19c2(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1997(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%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     195e <hqr+0x82e>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x48(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %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
divss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
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
movss  (%rax,%rcx,4),%xmm0
subss  -0x44(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x6c(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x68(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x64(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
cmpl   $0x1,-0x28(%rbp)
jne    1826 <hqr+0x6f6>
jmp    195e <hqr+0x82e>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x68(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x64(%rbp),%xmm0
call   1040 <fabs@plt>
movss  -0x9c(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x98(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x6c(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x8c(%rbp)
ff
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
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x94(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  -0x90(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x8c(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
ucomiss -0x54(%rbp),%xmm0
jne    194b <hqr+0x81b>
jp     194b <hqr+0x81b>
jmp    195e <hqr+0x82e>
jmp    1950 <hqr+0x820>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1695 <hqr+0x565>
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     19d1 <hqr+0x8a1>
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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
je     19be <hqr+0x88e>
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
movss  %xmm0,(%rax,%rcx,4)
jmp    19c3 <hqr+0x893>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1967 <hqr+0x837>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1fd1 <hqr+0xea1>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1b1f <hqr+0x9ef>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1a74 <hqr+0x944>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x6c(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x64(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0xa0(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ae1 <hqr+0x9b1>
jp     1ae1 <hqr+0x9b1>
jmp    1b1a <hqr+0x9ea>
movss  -0x4c(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1b1f <hqr+0x9ef>
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b7a <hqr+0xa4a>
movss  -0x6c(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1050 <sqrt@plt>
call   1040 <fabs@plt>
movss  %xmm0,-0xa8(%rbp)
ff
jmp    1bc7 <hqr+0xa97>
movss  -0x6c(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1050 <sqrt@plt>
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0x60(%rbp)
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1bf0 <hqr+0xac0>
jp     1bf0 <hqr+0xac0>
jmp    1fbe <hqr+0xe8e>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1c4e <hqr+0xb1e>
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1c49 <hqr+0xb19>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1c7f <hqr+0xb4f>
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x4c(%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
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x64(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x6c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x6c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1e3c <hqr+0xd0c>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1db5 <hqr+0xc85>
movss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x44(%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
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x48(%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
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ce7 <hqr+0xbb7>
mov    -0x24(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1e5b <hqr+0xd2b>
mov    -0x24(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1e67 <hqr+0xd37>
mov    -0x30(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1fb9 <hqr+0xe89>
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x48(%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
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1f49 <hqr+0xe19>
movss  -0x44(%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
movss  (%rax,%rcx,4),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e76 <hqr+0xd46>
jmp    1fbe <hqr+0xe8e>
jmp    1fc3 <hqr+0xe93>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19d7 <hqr+0x8a7>
jmp    1fd6 <hqr+0xea6>
jmp    1fdb <hqr+0xeab>
jmp    1fe0 <hqr+0xeb0>
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     11ed <hqr+0xbd>
jmp    11dc <hqr+0xac>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hqr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,0x38(%rsp)
mov    %rdi,%r13
mov    0x8(%rdi),%rax
movss  0x4(%rax),%xmm8
andps  0xeb5(%rip),%xmm8
cmp    $0x2,%esi
jl     1236 <hqr+0x116>
lea    0x1(%rsi),%r8d
cmp    $0x3,%r8d
jne    116e <hqr+0x4e>
mov    $0x1,%ebx
mov    $0x2,%r10d
jmp    120b <hqr+0xeb>
lea    -0x2(%r8),%r9
and    $0xfffffffffffffffe,%r9
mov    $0x1,%ebx
mov    $0x2,%r10d
xor    %r11d,%r11d
movaps 0xe75(%rip),%xmm0
mov    %r8,%rax
xchg   %ax,%ax
lea    0x0(,%r11,4),%rdi
mov    0x0(%r13,%r10,8),%rdx
add    %rdi,%rdx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdx,%rbp,4),%xmm1
andps  %xmm0,%xmm1
addss  %xmm1,%xmm8
add    $0x1,%rbp
cmp    %rbp,%rax
jne    11b0 <hqr+0x90>
lea    0x0(,%r10,8),%rdx
or     $0x8,%rdx
add    0x0(%r13,%rdx,1),%rdi
mov    $0x2,%edx
nopl   0x0(%rax)
movss  (%rdi,%rdx,4),%xmm1
andps  %xmm0,%xmm1
addss  %xmm1,%xmm8
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11e0 <hqr+0xc0>
add    $0x2,%r10
add    $0x2,%rbx
add    $0x2,%r11
add    $0xfffffffffffffffe,%rax
cmp    %r9,%r11
jne    1190 <hqr+0x70>
test   $0x1,%r8b
je     1236 <hqr+0x116>
mov    0x0(%r13,%r10,8),%rax
movaps 0xde3(%rip),%xmm0
nopl   (%rax)
movss  (%rax,%rbx,4),%xmm1
andps  %xmm0,%xmm1
addss  %xmm1,%xmm8
add    $0x1,%rbx
cmp    %rbx,%r8
jne    1220 <hqr+0x100>
test   %esi,%esi
jle    1c19 <hqr+0xaf9>
lea    0x10(%r13),%rax
mov    %rax,0xa0(%rsp)
xorps  %xmm9,%xmm9
xor    %ebx,%ebx
movaps 0xda8(%rip),%xmm10
movaps 0xdb0(%rip),%xmm11
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
movaps %xmm8,0x80(%rsp)
mov    %rcx,0x98(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rbx,%r12
mov    %esi,%r11d
test   %esi,%esi
mov    $0x1,%r10d
cmovle %esi,%r10d
lea    0x0(,%r11,4),%r8
lea    0x0(,%r11,8),%rax
add    %r13,%rax
add    $0xffffffff,%esi
lea    0x0(,%rsi,8),%rdi
add    %r13,%rdi
shl    $0x2,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
lea    (%r11,%rdx,1),%ebp
cmp    $0x2,%ebp
jl     1329 <hqr+0x209>
mov    (%rdi,%rdx,8),%rbp
add    %rsi,%rbp
movss  0x0(%rbp,%rdx,4),%xmm0
andps  %xmm10,%xmm0
mov    (%rax,%rdx,8),%rbp
lea    (%r8,%rbp,1),%rbx
movss  (%rbx,%rdx,4),%xmm1
andps  %xmm10,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
cmpeqss %xmm9,%xmm0
movaps %xmm0,%xmm2
andnps %xmm1,%xmm2
andps  %xmm8,%xmm0
orps   %xmm2,%xmm0
add    %rsi,%rbp
movss  0x0(%rbp,%rdx,4),%xmm1
andps  %xmm10,%xmm1
addss  %xmm0,%xmm1
add    $0xffffffffffffffff,%rdx
ucomiss %xmm0,%xmm1
jne    12c0 <hqr+0x1a0>
jp     12c0 <hqr+0x1a0>
lea    (%r11,%rdx,1),%r10d
add    $0x1,%r10d
movslq %r11d,%r14
mov    0x0(%r13,%r14,8),%rax
movss  (%rax,%r14,4),%xmm14
cmp    %r11d,%r10d
mov    %r12,%rbx
jne    1370 <hqr+0x250>
addss  0xc(%rsp),%xmm14
mov    0x38(%rsp),%rax
movss  %xmm14,(%rax,%r14,4)
lea    -0x1(%r11),%esi
movl   $0x0,(%rcx,%r14,4)
jmp    1c00 <hqr+0xae0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %r11d,%rdx
lea    -0x1(%rdx),%r15
lea    -0x1(%rdx),%esi
mov    -0x8(%r13,%rdx,8),%r8
movss  -0x4(%r8,%rdx,4),%xmm6
movss  -0x4(%rax,%rdx,4),%xmm0
movss  (%r8,%r14,4),%xmm7
mulss  %xmm0,%xmm7
cmp    %esi,%r10d
mov    %r10,0x48(%rsp)
mov    %r11,0x40(%rsp)
jne    13e0 <hqr+0x2c0>
subss  %xmm14,%xmm6
mulss  0xc72(%rip),%xmm6
movaps %xmm6,%xmm12
mulss  %xmm6,%xmm12
addss  %xmm7,%xmm12
movaps %xmm12,%xmm0
andps  %xmm10,%xmm0
ucomiss %xmm9,%xmm0
jb     16e6 <hqr+0x5c6>
sqrtss %xmm0,%xmm0
jmp    1750 <hqr+0x630>
nopl   0x0(%rax,%rax,1)
cmp    $0xa,%ebx
je     146d <hqr+0x34d>
cmp    $0x14,%ebx
je     146d <hqr+0x34d>
cmp    $0x1e,%ebx
jne    1584 <hqr+0x464>
lea    0xc32(%rip),%rdi
movaps %xmm12,0x20(%rsp)
movaps %xmm13,0x70(%rsp)
mov    %rcx,%rbp
movaps %xmm14,0x60(%rsp)
movaps %xmm6,0x50(%rsp)
movaps %xmm7,0x10(%rsp)
call   1030 <nrerror@plt>
movaps 0x10(%rsp),%xmm7
movaps 0x50(%rsp),%xmm6
movaps 0x60(%rsp),%xmm14
mov    %rbp,%rcx
movaps 0x70(%rsp),%xmm13
movaps 0x20(%rsp),%xmm12
mov    0x40(%rsp),%r11
mov    0x48(%rsp),%r10
movaps 0xbbd(%rip),%xmm11
movaps 0xba5(%rip),%xmm10
xorps  %xmm9,%xmm9
movaps 0x80(%rsp),%xmm8
jmp    1584 <hqr+0x464>
test   %r11d,%r11d
jle    1534 <hqr+0x414>
lea    -0x1(%r11),%rdi
mov    %r11d,%edx
and    $0x3,%edx
mov    $0x1,%esi
cmp    $0x3,%rdi
jb     1508 <hqr+0x3e8>
mov    %r11d,%edi
and    $0xfffffffc,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%r13,%rsi,8),%rbp
movss  0x4(%rbp,%rsi,4),%xmm0
subss  %xmm14,%xmm0
movss  %xmm0,0x4(%rbp,%rsi,4)
mov    0x10(%r13,%rsi,8),%rbp
movss  0x8(%rbp,%rsi,4),%xmm0
subss  %xmm14,%xmm0
movss  %xmm0,0x8(%rbp,%rsi,4)
mov    0x18(%r13,%rsi,8),%rbp
movss  0xc(%rbp,%rsi,4),%xmm0
subss  %xmm14,%xmm0
movss  %xmm0,0xc(%rbp,%rsi,4)
mov    0x20(%r13,%rsi,8),%rbp
movss  0x10(%rbp,%rsi,4),%xmm0
subss  %xmm14,%xmm0
movss  %xmm0,0x10(%rbp,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    14a0 <hqr+0x380>
add    $0x1,%rsi
mov    %r12,%rbx
test   %rdx,%rdx
je     152e <hqr+0x40e>
nopl   (%rax)
mov    0x0(%r13,%rsi,8),%rdi
movss  (%rdi,%rsi,4),%xmm0
subss  %xmm14,%xmm0
movss  %xmm0,(%rdi,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1510 <hqr+0x3f0>
movss  (%rax,%r15,4),%xmm0
movss  0xc(%rsp),%xmm1
addss  %xmm14,%xmm1
movss  %xmm1,0xc(%rsp)
andps  %xmm10,%xmm0
movslq %r11d,%rax
movss  -0x8(%r8,%rax,4),%xmm6
andps  %xmm10,%xmm6
addss  %xmm0,%xmm6
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
mulss  0xab6(%rip),%xmm6
movaps %xmm0,%xmm1
mulsd  0xab3(%rip),%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm7,%xmm7
cvtsd2ss %xmm1,%xmm7
movaps %xmm6,%xmm14
lea    -0x2(%r11),%eax
cmp    %r10d,%eax
jl     1808 <hqr+0x6e8>
mov    %rcx,%r8
xorps  %xmm11,%xmm7
mov    %rax,0x10(%rsp)
cltq
movslq %r10d,%r9
lea    -0x1(%r10),%ecx
mov    %ecx,0x20(%rsp)
mov    0x0(%r13,%rax,8),%rdx
movss  (%rdx,%rax,4),%xmm0
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
lea    0x0(,%rax,4),%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
lea    (%rax,%rsi,1),%rcx
movaps %xmm14,%xmm2
subss  %xmm0,%xmm2
movaps %xmm6,%xmm3
subss  %xmm0,%xmm3
mov    -0x8(%rdi,%rsi,8),%rbx
add    %rbp,%rbx
movss  0x4(%rbx,%rsi,4),%xmm1
movaps %xmm1,%xmm12
subss  %xmm0,%xmm12
subss  %xmm2,%xmm12
mulss  %xmm3,%xmm2
addss  %xmm7,%xmm2
divss  (%rbx,%rsi,4),%xmm2
add    %rbp,%rdx
addss  0x4(%rdx,%rsi,4),%xmm2
subss  %xmm3,%xmm12
mov    (%rdi,%rsi,8),%rbx
add    %rbp,%rbx
movss  0x4(%rbx,%rsi,4),%xmm13
movaps %xmm13,%xmm3
unpcklps %xmm2,%xmm13
andps  %xmm10,%xmm2
movaps %xmm12,%xmm4
andps  %xmm10,%xmm4
addss  %xmm2,%xmm4
andps  %xmm10,%xmm3
addss  %xmm4,%xmm3
divss  %xmm3,%xmm12
shufps $0x0,%xmm3,%xmm3
divps  %xmm3,%xmm13
cmp    $0x1,%rcx
je     17f4 <hqr+0x6d4>
movaps %xmm13,%xmm3
andps  %xmm10,%xmm3
movss  -0x4(%rdx,%rsi,4),%xmm2
movaps %xmm13,%xmm4
movss  %xmm2,%xmm4
andps  %xmm10,%xmm4
mov    -0x18(%rdi,%rsi,8),%rdx
lea    (%rdx,%rbp,1),%rcx
movss  -0x4(%rcx,%rsi,4),%xmm2
movaps %xmm2,%xmm5
andps  %xmm10,%xmm5
andps  %xmm10,%xmm0
addss  %xmm5,%xmm0
unpcklps %xmm0,%xmm3
movaps %xmm12,%xmm0
unpcklps %xmm1,%xmm0
andps  %xmm10,%xmm0
addps  %xmm3,%xmm0
mulps  %xmm4,%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
addss  %xmm1,%xmm0
ucomiss %xmm1,%xmm0
jne    16c1 <hqr+0x5a1>
jnp    17fb <hqr+0x6db>
lea    (%rax,%rsi,1),%rcx
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rsi
add    $0x1,%rcx
movaps %xmm2,%xmm0
cmp    %r9,%rcx
jg     15d0 <hqr+0x4b0>
mov    0x20(%rsp),%eax
jmp    1802 <hqr+0x6e2>
movaps %xmm12,0x20(%rsp)
movaps %xmm13,0x70(%rsp)
mov    %rcx,%rbp
movaps %xmm14,0x60(%rsp)
movaps %xmm6,0x50(%rsp)
movaps %xmm7,0x10(%rsp)
call   1040 <sqrt@plt>
movaps 0x10(%rsp),%xmm7
movaps 0x50(%rsp),%xmm6
movaps 0x60(%rsp),%xmm14
mov    %rbp,%rcx
movaps 0x70(%rsp),%xmm13
movaps 0x20(%rsp),%xmm12
mov    0x40(%rsp),%r11
mov    0x48(%rsp),%r10
movaps 0x8d5(%rip),%xmm11
movaps 0x8bd(%rip),%xmm10
xorps  %xmm9,%xmm9
movaps 0x80(%rsp),%xmm8
mov    0x38(%rsp),%rax
addss  0xc(%rsp),%xmm14
ucomiss %xmm9,%xmm12
jae    177f <hqr+0x65f>
addss  %xmm6,%xmm14
movss  %xmm14,(%rax,%r14,4)
movss  %xmm14,(%rax,%r15,4)
movss  %xmm0,(%rcx,%r14,4)
xorps  %xmm11,%xmm0
jmp    17d5 <hqr+0x6b5>
movaps %xmm0,%xmm2
andps  %xmm10,%xmm2
orps   %xmm11,%xmm0
xorps  %xmm1,%xmm1
cmpltss %xmm6,%xmm1
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
addss  %xmm6,%xmm1
movaps %xmm14,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%r14,4)
movss  %xmm0,(%rax,%r15,4)
ucomiss %xmm9,%xmm1
jne    17bb <hqr+0x69b>
jnp    17ca <hqr+0x6aa>
divss  %xmm1,%xmm7
subss  %xmm7,%xmm14
movss  %xmm14,(%rax,%r14,4)
movl   $0x0,(%rcx,%r14,4)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rcx,%r15,4)
add    $0xfffffffe,%r11d
movlhps %xmm13,%xmm6
shufps $0xe2,%xmm13,%xmm6
mov    %r11d,%esi
movaps %xmm6,%xmm13
jmp    1c00 <hqr+0xae0>
mov    $0x1,%eax
jmp    1802 <hqr+0x6e2>
mov    0x10(%rsp),%rax
add    %esi,%eax
mov    %r12,%rbx
mov    %r8,%rcx
mov    %rax,0x10(%rsp)
add    $0x2,%eax
cmp    %r11d,%eax
jg     18a0 <hqr+0x780>
movslq %eax,%rdx
lea    0x1(%r11),%ebp
mov    0x0(%r13,%rdx,8),%rax
movl   $0x0,-0x8(%rax,%rdx,4)
lea    0x1(%rdx),%rax
cmp    %eax,%ebp
je     18a0 <hqr+0x780>
mov    %r11d,%edi
mov    0x10(%rsp),%rsi
sub    %esi,%edi
lea    -0x3(%r11),%r8d
test   $0x1,%dil
je     185e <hqr+0x73e>
mov    0x8(%r13,%rdx,8),%rax
movq   $0x0,-0x8(%rax,%rdx,4)
add    $0x2,%rdx
mov    %rdx,%rax
cmp    %esi,%r8d
je     18a0 <hqr+0x780>
mov    %ebp,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rax,8),%rdx
movq   $0x0,-0xc(%rdx,%rax,4)
mov    0x8(%r13,%rax,8),%rdx
movq   $0x0,-0x8(%rdx,%rax,4)
add    $0x2,%rax
cmp    %eax,%esi
jne    1870 <hqr+0x750>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%ebx
mov    0x10(%rsp),%rax
cmp    %eax,%r11d
jle    1be0 <hqr+0xac0>
mov    %rbx,0xa8(%rsp)
movslq %eax,%rbx
movslq %r10d,%rax
lea    -0x1(%rbx),%r12
add    $0xffffffffffffffff,%rax
mov    %rax,0xb0(%rsp)
mov    %rbx,%rbp
jmp    18fe <hqr+0x7de>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movlhps %xmm13,%xmm2
shufps $0xe2,%xmm13,%xmm2
movaps %xmm2,%xmm13
add    $0x1,%rbp
add    $0x1,%r12
cmp    %r14,%rbp
je     1be5 <hqr+0xac5>
cmp    %rbx,%rbp
je     196a <hqr+0x84a>
xorps  %xmm13,%xmm13
cmp    %r15,%rbp
je     1918 <hqr+0x7f8>
mov    0x10(%r13,%rbp,8),%rax
movss  -0x4(%rax,%rbp,4),%xmm13
mov    0x0(%r13,%rbp,8),%rax
mov    0x8(%r13,%rbp,8),%rcx
movss  -0x4(%rax,%rbp,4),%xmm0
movss  -0x4(%rcx,%rbp,4),%xmm12
movaps %xmm13,%xmm14
unpcklps %xmm0,%xmm13
andps  %xmm10,%xmm0
movaps %xmm12,%xmm1
andps  %xmm10,%xmm1
addss  %xmm0,%xmm1
andps  %xmm10,%xmm14
addss  %xmm1,%xmm14
ucomiss %xmm9,%xmm14
jne    1958 <hqr+0x838>
jnp    196a <hqr+0x84a>
divss  %xmm14,%xmm12
movaps %xmm14,%xmm0
shufps $0x0,%xmm14,%xmm0
divps  %xmm0,%xmm13
movaps %xmm13,%xmm3
shufps $0x55,%xmm13,%xmm3
movaps %xmm12,%xmm0
mulss  %xmm12,%xmm0
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps %xmm13,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm9,%xmm0
jb     19a0 <hqr+0x880>
sqrtss %xmm0,%xmm0
jmp    19fa <hqr+0x8da>
movaps %xmm12,0x20(%rsp)
movaps %xmm13,0x70(%rsp)
movaps %xmm14,0x60(%rsp)
movaps %xmm3,0x50(%rsp)
call   1040 <sqrt@plt>
movaps 0x50(%rsp),%xmm3
movaps 0x60(%rsp),%xmm14
movaps 0x70(%rsp),%xmm13
movaps 0x20(%rsp),%xmm12
mov    0x40(%rsp),%r11
mov    0x48(%rsp),%r10
movaps 0x62b(%rip),%xmm11
movaps 0x613(%rip),%xmm10
xorps  %xmm9,%xmm9
movaps 0x80(%rsp),%xmm8
movaps %xmm0,%xmm1
andps  %xmm10,%xmm1
orps   %xmm11,%xmm0
xorps  %xmm2,%xmm2
cmpltss %xmm3,%xmm2
andps  %xmm2,%xmm1
andnps %xmm0,%xmm2
orps   %xmm1,%xmm2
ucomiss %xmm9,%xmm2
jne    1a22 <hqr+0x902>
jnp    18ed <hqr+0x7cd>
cmp    %rbx,%rbp
jne    1a50 <hqr+0x930>
cmp    0x10(%rsp),%r10d
je     1a68 <hqr+0x948>
mov    0x0(%r13,%rbx,8),%rax
movss  -0x4(%rax,%rbx,4),%xmm0
xorps  %xmm11,%xmm0
movss  %xmm0,-0x4(%rax,%rbx,4)
jmp    1a68 <hqr+0x948>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm2,%xmm0
xorps  %xmm11,%xmm0
mulss  %xmm0,%xmm14
mov    0x0(%r13,%rbp,8),%rax
movss  %xmm14,-0x4(%rax,%rbp,4)
addss  %xmm2,%xmm3
movaps %xmm3,%xmm14
divss  %xmm2,%xmm14
movaps %xmm12,%xmm0
divss  %xmm2,%xmm0
movaps %xmm13,%xmm1
divss  %xmm2,%xmm1
divss  %xmm3,%xmm12
divss  %xmm3,%xmm13
mov    0x0(%r13,%rbp,8),%rax
mov    0x8(%r13,%rbp,8),%rcx
mov    %r12,%rdx
jmp    1b00 <hqr+0x9e0>
xchg   %ax,%ax
mov    0x10(%r13,%rbp,8),%rsi
movss  0x4(%rsi,%rdx,4),%xmm4
movaps %xmm13,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm3,%xmm2
movaps %xmm2,%xmm3
xorps  %xmm11,%xmm3
movaps %xmm2,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,0x4(%rsi,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm0,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,0x4(%rcx,%rdx,4)
mulss  %xmm14,%xmm3
addss  0x4(%rax,%rdx,4),%xmm3
movss  %xmm3,0x4(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %r14,%rdx
jge    1b30 <hqr+0xa10>
movss  0x4(%rcx,%rdx,4),%xmm4
movaps %xmm12,%xmm2
mulss  %xmm4,%xmm2
addss  0x4(%rax,%rdx,4),%xmm2
cmp    %r15,%rbp
jne    1aa0 <hqr+0x980>
movaps %xmm2,%xmm3
xorps  %xmm11,%xmm3
jmp    1ad5 <hqr+0x9b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x3(%rbp),%rax
cmp    %r14,%rax
cmovg  %r11d,%eax
cmp    %eax,%r10d
jle    1b50 <hqr+0xa30>
unpcklps %xmm2,%xmm13
jmp    18ed <hqr+0x7cd>
nopl   0x0(%rax)
cltq
mov    0xb0(%rsp),%rcx
jmp    1baf <hqr+0xa8f>
nopl   0x0(%rax)
movss  0x8(%rdx,%rbp,4),%xmm6
movaps %xmm1,%xmm5
mulss  %xmm6,%xmm5
addss  %xmm5,%xmm2
movaps %xmm2,%xmm5
xorps  %xmm11,%xmm5
movaps %xmm2,%xmm7
mulss  %xmm13,%xmm7
subss  %xmm7,%xmm6
movss  %xmm6,0x8(%rdx,%rbp,4)
mulss  %xmm12,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,0x4(%rdx,%rbp,4)
subss  %xmm2,%xmm3
movss  %xmm3,(%rdx,%rbp,4)
add    $0x1,%rcx
cmp    %rax,%rcx
jge    18e0 <hqr+0x7c0>
mov    0x8(%r13,%rcx,8),%rdx
movss  (%rdx,%rbp,4),%xmm3
movss  0x4(%rdx,%rbp,4),%xmm4
movaps %xmm0,%xmm5
mulss  %xmm4,%xmm5
movaps %xmm14,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm5,%xmm2
cmp    %r15,%rbp
jne    1b60 <hqr+0xa40>
movaps %xmm2,%xmm5
xorps  %xmm11,%xmm5
jmp    1b8a <hqr+0xa6a>
mov    %r11d,%esi
jmp    1c00 <hqr+0xae0>
mov    %r11d,%esi
mov    0x98(%rsp),%rcx
mov    0xa8(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rsi),%eax
cmp    %eax,%r10d
jl     1280 <hqr+0x160>
mov    $0x0,%ebx
test   %esi,%esi
jg     1280 <hqr+0x160>
add    $0xb8,%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(float** %0, i32 %1, float* %2, float* %3) {
%5 = alloca float**
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%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 float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
store float** %0, float*** %5
store i32 %1, i32* %6
store float* %2, float** %7
store float* %3, float** %8
%29 = load float**, float*** %5
%30 = getelementptr inbounds float*, float** %29, i64 1
%31 = load float*, float** %30
%32 = getelementptr inbounds float, float* %31, i64 1
%33 = load float, float* %32
%34 = call float @fabs(float %33)
store float %34, float* %28
store i32 2, i32* %15
br label %35
35: ; preds = %63, %4
%36 = load i32, i32* %15
%37 = load i32, i32* %6
%38 = icmp sle i32 %36, %37
br i1 %38, label %39, label %66
39: ; preds = %35
%40 = load i32, i32* %15
%41 = sub nsw i32 %40, 1
store i32 %41, i32* %13
br label %42
42: ; preds = %59, %39
%43 = load i32, i32* %13
%44 = load i32, i32* %6
%45 = icmp sle i32 %43, %44
br i1 %45, label %46, label %62
46: ; preds = %42
%47 = load float**, float*** %5
%48 = load i32, i32* %15
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float*, float** %47, i64 %49
%51 = load float*, float** %50
%52 = load i32, i32* %13
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = call float @fabs(float %55)
%57 = load float, float* %28
%58 = fadd float %57, %56
store float %58, float* %28
br label %59
59: ; preds = %46
%60 = load i32, i32* %13
%61 = add nsw i32 %60, 1
store i32 %61, i32* %13
br label %42
62: ; preds = %42
br label %63
63: ; preds = %62
%64 = load i32, i32* %15
%65 = add nsw i32 %64, 1
store i32 %65, i32* %15
br label %35
66: ; preds = %35
%67 = load i32, i32* %6
store i32 %67, i32* %9
store float 0.000000e+00, float* %23
br label %68
68: ; preds = %922, %66
%69 = load i32, i32* %9
%70 = icmp sge i32 %69, 1
br i1 %70, label %71, label %923
71: ; preds = %68
store i32 0, i32* %14
br label %72
72: ; preds = %917, %71
%73 = load i32, i32* %9
store i32 %73, i32* %11
br label %74
74: ; preds = %124, %72
%75 = load i32, i32* %11
%76 = icmp sge i32 %75, 2
br i1 %76, label %77, label %127
77: ; preds = %74
%78 = load float**, float*** %5
%79 = load i32, i32* %11
%80 = sub nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float*, float** %78, i64 %81
%83 = load float*, float** %82
%84 = load i32, i32* %11
%85 = sub nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %83, i64 %86
%88 = load float, float* %87
%89 = call float @fabs(float %88)
%90 = load float**, float*** %5
%91 = load i32, i32* %11
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float*, float** %90, i64 %92
%94 = load float*, float** %93
%95 = load i32, i32* %11
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %94, i64 %96
%98 = load float, float* %97
%99 = call float @fabs(float %98)
%100 = fadd float %89, %99
store float %100, float* %24
%101 = load float, float* %24
%102 = fpext float %101 to double
%103 = fcmp oeq double %102, 0.000000e+00
br i1 %103, label %104, label %106
104: ; preds = %77
%105 = load float, float* %28
store float %105, float* %24
br label %106
106: ; preds = %104, %77
%107 = load float**, float*** %5
%108 = load i32, i32* %11
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float*, float** %107, i64 %109
%111 = load float*, float** %110
%112 = load i32, i32* %11
%113 = sub nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float, float* %111, i64 %114
%116 = load float, float* %115
%117 = call float @fabs(float %116)
%118 = load float, float* %24
%119 = fadd float %117, %118
%120 = load float, float* %24
%121 = fcmp oeq float %119, %120
br i1 %121, label %122, label %123
122: ; preds = %106
br label %127
123: ; preds = %106
br label %124
124: ; preds = %123
%125 = load i32, i32* %11
%126 = add nsw i32 %125, -1
store i32 %126, i32* %11
br label %74
127: ; preds = %122, %74
%128 = load float**, float*** %5
%129 = load i32, i32* %9
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float*, float** %128, i64 %130
%132 = load float*, float** %131
%133 = load i32, i32* %9
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds float, float* %132, i64 %134
%136 = load float, float* %135
store float %136, float* %19
%137 = load i32, i32* %11
%138 = load i32, i32* %9
%139 = icmp eq i32 %137, %138
br i1 %139, label %140, label %153
140: ; preds = %127
%141 = load float, float* %19
%142 = load float, float* %23
%143 = fadd float %141, %142
%144 = load float*, float** %7
%145 = load i32, i32* %9
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
store float %143, float* %147
%148 = load float*, float** %8
%149 = load i32, i32* %9
%150 = add nsw i32 %149, -1
store i32 %150, i32* %9
%151 = sext i32 %149 to i64
%152 = getelementptr inbounds float, float* %148, i64 %151
store float 0.000000e+00, float* %152
br label %916
153: ; preds = %127
%154 = load float**, float*** %5
%155 = load i32, i32* %9
%156 = sub nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float*, float** %154, i64 %157
%159 = load float*, float** %158
%160 = load i32, i32* %9
%161 = sub nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %159, i64 %162
%164 = load float, float* %163
store float %164, float* %18
%165 = load float**, float*** %5
%166 = load i32, i32* %9
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float*, float** %165, i64 %167
%169 = load float*, float** %168
%170 = load i32, i32* %9
%171 = sub nsw i32 %170, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %169, i64 %172
%174 = load float, float* %173
%175 = load float**, float*** %5
%176 = load i32, i32* %9
%177 = sub nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float*, float** %175, i64 %178
%180 = load float*, float** %179
%181 = load i32, i32* %9
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
%184 = load float, float* %183
%185 = fmul float %174, %184
store float %185, float* %20
%186 = load i32, i32* %11
%187 = load i32, i32* %9
%188 = sub nsw i32 %187, 1
%189 = icmp eq i32 %186, %188
br i1 %189, label %190, label %286
190: ; preds = %153
%191 = load float, float* %18
%192 = load float, float* %19
%193 = fsub float %191, %192
%194 = fpext float %193 to double
%195 = fmul double 5.000000e-01, %194
%196 = fptrunc double %195 to float
store float %196, float* %27
%197 = load float, float* %27
%198 = load float, float* %27
%199 = load float, float* %20
%200 = call float @llvm.fmuladd.f32(float %197, float %198, float %199)
store float %200, float* %26
%201 = load float, float* %26
%202 = call float @fabs(float %201)
%203 = call float @sqrt(float %202)
store float %203, float* %17
%204 = load float, float* %23
%205 = load float, float* %19
%206 = fadd float %205, %204
store float %206, float* %19
%207 = load float, float* %26
%208 = fpext float %207 to double
%209 = fcmp oge double %208, 0.000000e+00
br i1 %209, label %210, label %259
210: ; preds = %190
%211 = load float, float* %27
%212 = load float, float* %27
%213 = fpext float %212 to double
%214 = fcmp ogt double %213, 0.000000e+00
br i1 %214, label %215, label %218
215: ; preds = %210
%216 = load float, float* %17
%217 = call float @fabs(float %216)
br label %222
218: ; preds = %210
%219 = load float, float* %17
%220 = call float @fabs(float %219)
%221 = fneg float %220
br label %222
222: ; preds = %218, %215
%223 = phi float [ %217, %215 ], [ %221, %218 ]
%224 = fadd float %211, %223
store float %224, float* %17
%225 = load float, float* %19
%226 = load float, float* %17
%227 = fadd float %225, %226
%228 = load float*, float** %7
%229 = load i32, i32* %9
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float, float* %228, i64 %230
store float %227, float* %231
%232 = load float*, float** %7
%233 = load i32, i32* %9
%234 = sub nsw i32 %233, 1
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float, float* %232, i64 %235
store float %227, float* %236
%237 = load float, float* %17
%238 = fcmp une float %237, 0.000000e+00
br i1 %238, label %239, label %249
239: ; preds = %222
%240 = load float, float* %19
%241 = load float, float* %20
%242 = load float, float* %17
%243 = fdiv float %241, %242
%244 = fsub float %240, %243
%245 = load float*, float** %7
%246 = load i32, i32* %9
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %245, i64 %247
store float %244, float* %248
br label %249
249: ; preds = %239, %222
%250 = load float*, float** %8
%251 = load i32, i32* %9
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %250, i64 %252
store float 0.000000e+00, float* %253
%254 = load float*, float** %8
%255 = load i32, i32* %9
%256 = sub nsw i32 %255, 1
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %254, i64 %257
store float 0.000000e+00, float* %258
br label %283
259: ; preds = %190
%260 = load float, float* %19
%261 = load float, float* %27
%262 = fadd float %260, %261
%263 = load float*, float** %7
%264 = load i32, i32* %9
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %263, i64 %265
store float %262, float* %266
%267 = load float*, float** %7
%268 = load i32, i32* %9
%269 = sub nsw i32 %268, 1
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds float, float* %267, i64 %270
store float %262, float* %271
%272 = load float, float* %17
%273 = load float*, float** %8
%274 = load i32, i32* %9
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %273, i64 %275
store float %272, float* %276
%277 = fneg float %272
%278 = load float*, float** %8
%279 = load i32, i32* %9
%280 = sub nsw i32 %279, 1
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds float, float* %278, i64 %281
store float %277, float* %282
br label %283
283: ; preds = %259, %249
%284 = load i32, i32* %9
%285 = sub nsw i32 %284, 2
store i32 %285, i32* %9
br label %915
286: ; preds = %153
%287 = load i32, i32* %14
%288 = icmp eq i32 %287, 30
br i1 %288, label %289, label %291
289: ; preds = %286
%290 = call i32 @nrerror(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
br label %291
291: ; preds = %289, %286
%292 = load i32, i32* %14
%293 = icmp eq i32 %292, 10
br i1 %293, label %297, label %294
294: ; preds = %291
%295 = load i32, i32* %14
%296 = icmp eq i32 %295, 20
br i1 %296, label %297, label %356
297: ; preds = %294, %291
%298 = load float, float* %19
%299 = load float, float* %23
%300 = fadd float %299, %298
store float %300, float* %23
store i32 1, i32* %15
br label %301
301: ; preds = %317, %297
%302 = load i32, i32* %15
%303 = load i32, i32* %9
%304 = icmp sle i32 %302, %303
br i1 %304, label %305, label %320
305: ; preds = %301
%306 = load float, float* %19
%307 = load float**, float*** %5
%308 = load i32, i32* %15
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float*, float** %307, i64 %309
%311 = load float*, float** %310
%312 = load i32, i32* %15
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
%315 = load float, float* %314
%316 = fsub float %315, %306
store float %316, float* %314
br label %317
317: ; preds = %305
%318 = load i32, i32* %15
%319 = add nsw i32 %318, 1
store i32 %319, i32* %15
br label %301
320: ; preds = %301
%321 = load float**, float*** %5
%322 = load i32, i32* %9
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float*, float** %321, i64 %323
%325 = load float*, float** %324
%326 = load i32, i32* %9
%327 = sub nsw i32 %326, 1
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds float, float* %325, i64 %328
%330 = load float, float* %329
%331 = call float @fabs(float %330)
%332 = load float**, float*** %5
%333 = load i32, i32* %9
%334 = sub nsw i32 %333, 1
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float*, float** %332, i64 %335
%337 = load float*, float** %336
%338 = load i32, i32* %9
%339 = sub nsw i32 %338, 2
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds float, float* %337, i64 %340
%342 = load float, float* %341
%343 = call float @fabs(float %342)
%344 = fadd float %331, %343
store float %344, float* %24
%345 = load float, float* %24
%346 = fpext float %345 to double
%347 = fmul double 7.500000e-01, %346
%348 = fptrunc double %347 to float
store float %348, float* %19
store float %348, float* %18
%349 = load float, float* %24
%350 = fpext float %349 to double
%351 = fmul double -4.375000e-01, %350
%352 = load float, float* %24
%353 = fpext float %352 to double
%354 = fmul double %351, %353
%355 = fptrunc double %354 to float
store float %355, float* %20
br label %356
356: ; preds = %320, %294
%357 = load i32, i32* %14
%358 = add nsw i32 %357, 1
store i32 %358, i32* %14
%359 = load i32, i32* %9
%360 = sub nsw i32 %359, 2
store i32 %360, i32* %10
br label %361
361: ; preds = %512, %356
%362 = load i32, i32* %10
%363 = load i32, i32* %11
%364 = icmp sge i32 %362, %363
br i1 %364, label %365, label %515
365: ; preds = %361
%366 = load float**, float*** %5
%367 = load i32, i32* %10
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float*, float** %366, i64 %368
%370 = load float*, float** %369
%371 = load i32, i32* %10
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %370, i64 %372
%374 = load float, float* %373
store float %374, float* %17
%375 = load float, float* %19
%376 = load float, float* %17
%377 = fsub float %375, %376
store float %377, float* %25
%378 = load float, float* %18
%379 = load float, float* %17
%380 = fsub float %378, %379
store float %380, float* %24
%381 = load float, float* %25
%382 = load float, float* %24
%383 = load float, float* %20
%384 = fneg float %383
%385 = call float @llvm.fmuladd.f32(float %381, float %382, float %384)
%386 = load float**, float*** %5
%387 = load i32, i32* %10
%388 = add nsw i32 %387, 1
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds float*, float** %386, i64 %389
%391 = load float*, float** %390
%392 = load i32, i32* %10
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float, float* %391, i64 %393
%395 = load float, float* %394
%396 = fdiv float %385, %395
%397 = load float**, float*** %5
%398 = load i32, i32* %10
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds float*, float** %397, i64 %399
%401 = load float*, float** %400
%402 = load i32, i32* %10
%403 = add nsw i32 %402, 1
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds float, float* %401, i64 %404
%406 = load float, float* %405
%407 = fadd float %396, %406
store float %407, float* %27
%408 = load float**, float*** %5
%409 = load i32, i32* %10
%410 = add nsw i32 %409, 1
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds float*, float** %408, i64 %411
%413 = load float*, float** %412
%414 = load i32, i32* %10
%415 = add nsw i32 %414, 1
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %413, i64 %416
%418 = load float, float* %417
%419 = load float, float* %17
%420 = fsub float %418, %419
%421 = load float, float* %25
%422 = fsub float %420, %421
%423 = load float, float* %24
%424 = fsub float %422, %423
store float %424, float* %26
%425 = load float**, float*** %5
%426 = load i32, i32* %10
%427 = add nsw i32 %426, 2
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float*, float** %425, i64 %428
%430 = load float*, float** %429
%431 = load i32, i32* %10
%432 = add nsw i32 %431, 1
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds float, float* %430, i64 %433
%435 = load float, float* %434
store float %435, float* %25
%436 = load float, float* %27
%437 = call float @fabs(float %436)
%438 = load float, float* %26
%439 = call float @fabs(float %438)
%440 = fadd float %437, %439
%441 = load float, float* %25
%442 = call float @fabs(float %441)
%443 = fadd float %440, %442
store float %443, float* %24
%444 = load float, float* %24
%445 = load float, float* %27
%446 = fdiv float %445, %444
store float %446, float* %27
%447 = load float, float* %24
%448 = load float, float* %26
%449 = fdiv float %448, %447
store float %449, float* %26
%450 = load float, float* %24
%451 = load float, float* %25
%452 = fdiv float %451, %450
store float %452, float* %25
%453 = load i32, i32* %10
%454 = icmp eq i32 %453, 1
br i1 %454, label %455, label %456
455: ; preds = %365
br label %515
456: ; preds = %365
%457 = load float**, float*** %5
%458 = load i32, i32* %10
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float*, float** %457, i64 %459
%461 = load float*, float** %460
%462 = load i32, i32* %10
%463 = sub nsw i32 %462, 1
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds float, float* %461, i64 %464
%466 = load float, float* %465
%467 = call float @fabs(float %466)
%468 = load float, float* %26
%469 = call float @fabs(float %468)
%470 = load float, float* %25
%471 = call float @fabs(float %470)
%472 = fadd float %469, %471
%473 = fmul float %467, %472
store float %473, float* %22
%474 = load float, float* %27
%475 = call float @fabs(float %474)
%476 = load float**, float*** %5
%477 = load i32, i32* %10
%478 = sub nsw i32 %477, 1
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds float*, float** %476, i64 %479
%481 = load float*, float** %480
%482 = load i32, i32* %10
%483 = sub nsw i32 %482, 1
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds float, float* %481, i64 %484
%486 = load float, float* %485
%487 = call float @fabs(float %486)
%488 = load float, float* %17
%489 = call float @fabs(float %488)
%490 = fadd float %487, %489
%491 = load float**, float*** %5
%492 = load i32, i32* %10
%493 = add nsw i32 %492, 1
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds float*, float** %491, i64 %494
%496 = load float*, float** %495
%497 = load i32, i32* %10
%498 = add nsw i32 %497, 1
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds float, float* %496, i64 %499
%501 = load float, float* %500
%502 = call float @fabs(float %501)
%503 = fadd float %490, %502
%504 = fmul float %475, %503
store float %504, float* %21
%505 = load float, float* %22
%506 = load float, float* %21
%507 = fadd float %505, %506
%508 = load float, float* %21
%509 = fcmp oeq float %507, %508
br i1 %509, label %510, label %511
510: ; preds = %456
br label %515
511: ; preds = %456
br label %512
512: ; preds = %511
%513 = load i32, i32* %10
%514 = add nsw i32 %513, -1
store i32 %514, i32* %10
br label %361
515: ; preds = %510, %455, %361
%516 = load i32, i32* %10
%517 = add nsw i32 %516, 2
store i32 %517, i32* %15
br label %518
518: ; preds = %547, %515
%519 = load i32, i32* %15
%520 = load i32, i32* %9
%521 = icmp sle i32 %519, %520
br i1 %521, label %522, label %550
522: ; preds = %518
%523 = load float**, float*** %5
%524 = load i32, i32* %15
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float*, float** %523, i64 %525
%527 = load float*, float** %526
%528 = load i32, i32* %15
%529 = sub nsw i32 %528, 2
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds float, float* %527, i64 %530
store float 0.000000e+00, float* %531
%532 = load i32, i32* %15
%533 = load i32, i32* %10
%534 = add nsw i32 %533, 2
%535 = icmp ne i32 %532, %534
br i1 %535, label %536, label %546
536: ; preds = %522
%537 = load float**, float*** %5
%538 = load i32, i32* %15
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds float*, float** %537, i64 %539
%541 = load float*, float** %540
%542 = load i32, i32* %15
%543 = sub nsw i32 %542, 3
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds float, float* %541, i64 %544
store float 0.000000e+00, float* %545
br label %546
546: ; preds = %536, %522
br label %547
547: ; preds = %546
%548 = load i32, i32* %15
%549 = add nsw i32 %548, 1
store i32 %549, i32* %15
br label %518
550: ; preds = %518
%551 = load i32, i32* %10
store i32 %551, i32* %12
br label %552
552: ; preds = %911, %550
%553 = load i32, i32* %12
%554 = load i32, i32* %9
%555 = sub nsw i32 %554, 1
%556 = icmp sle i32 %553, %555
br i1 %556, label %557, label %914
557: ; preds = %552
%558 = load i32, i32* %12
%559 = load i32, i32* %10
%560 = icmp ne i32 %558, %559
br i1 %560, label %561, label %621
561: ; preds = %557
%562 = load float**, float*** %5
%563 = load i32, i32* %12
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds float*, float** %562, i64 %564
%566 = load float*, float** %565
%567 = load i32, i32* %12
%568 = sub nsw i32 %567, 1
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds float, float* %566, i64 %569
%571 = load float, float* %570
store float %571, float* %27
%572 = load float**, float*** %5
%573 = load i32, i32* %12
%574 = add nsw i32 %573, 1
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds float*, float** %572, i64 %575
%577 = load float*, float** %576
%578 = load i32, i32* %12
%579 = sub nsw i32 %578, 1
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds float, float* %577, i64 %580
%582 = load float, float* %581
store float %582, float* %26
store float 0.000000e+00, float* %25
%583 = load i32, i32* %12
%584 = load i32, i32* %9
%585 = sub nsw i32 %584, 1
%586 = icmp ne i32 %583, %585
br i1 %586, label %587, label %599
587: ; preds = %561
%588 = load float**, float*** %5
%589 = load i32, i32* %12
%590 = add nsw i32 %589, 2
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds float*, float** %588, i64 %591
%593 = load float*, float** %592
%594 = load i32, i32* %12
%595 = sub nsw i32 %594, 1
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds float, float* %593, i64 %596
%598 = load float, float* %597
store float %598, float* %25
br label %599
599: ; preds = %587, %561
%600 = load float, float* %27
%601 = call float @fabs(float %600)
%602 = load float, float* %26
%603 = call float @fabs(float %602)
%604 = fadd float %601, %603
%605 = load float, float* %25
%606 = call float @fabs(float %605)
%607 = fadd float %604, %606
store float %607, float* %19
%608 = fpext float %607 to double
%609 = fcmp une double %608, 0.000000e+00
br i1 %609, label %610, label %620
610: ; preds = %599
%611 = load float, float* %19
%612 = load float, float* %27
%613 = fdiv float %612, %611
store float %613, float* %27
%614 = load float, float* %19
%615 = load float, float* %26
%616 = fdiv float %615, %614
store float %616, float* %26
%617 = load float, float* %19
%618 = load float, float* %25
%619 = fdiv float %618, %617
store float %619, float* %25
br label %620
620: ; preds = %610, %599
br label %621
621: ; preds = %620, %557
%622 = load float, float* %27
%623 = fpext float %622 to double
%624 = fcmp ogt double %623, 0.000000e+00
br i1 %624, label %625, label %637
625: ; preds = %621
%626 = load float, float* %27
%627 = load float, float* %27
%628 = load float, float* %26
%629 = load float, float* %26
%630 = fmul float %628, %629
%631 = call float @llvm.fmuladd.f32(float %626, float %627, float %630)
%632 = load float, float* %25
%633 = load float, float* %25
%634 = call float @llvm.fmuladd.f32(float %632, float %633, float %631)
%635 = call float @sqrt(float %634)
%636 = call float @fabs(float %635)
br label %650
637: ; preds = %621
%638 = load float, float* %27
%639 = load float, float* %27
%640 = load float, float* %26
%641 = load float, float* %26
%642 = fmul float %640, %641
%643 = call float @llvm.fmuladd.f32(float %638, float %639, float %642)
%644 = load float, float* %25
%645 = load float, float* %25
%646 = call float @llvm.fmuladd.f32(float %644, float %645, float %643)
%647 = call float @sqrt(float %646)
%648 = call float @fabs(float %647)
%649 = fneg float %648
br label %650
650: ; preds = %637, %625
%651 = phi float [ %636, %625 ], [ %649, %637 ]
store float %651, float* %24
%652 = fpext float %651 to double
%653 = fcmp une double %652, 0.000000e+00
br i1 %653, label %654, label %910
654: ; preds = %650
%655 = load i32, i32* %12
%656 = load i32, i32* %10
%657 = icmp eq i32 %655, %656
br i1 %657, label %658, label %684
658: ; preds = %654
%659 = load i32, i32* %11
%660 = load i32, i32* %10
%661 = icmp ne i32 %659, %660
br i1 %661, label %662, label %683
662: ; preds = %658
%663 = load float**, float*** %5
%664 = load i32, i32* %12
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds float*, float** %663, i64 %665
%667 = load float*, float** %666
%668 = load i32, i32* %12
%669 = sub nsw i32 %668, 1
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds float, float* %667, i64 %670
%672 = load float, float* %671
%673 = fneg float %672
%674 = load float**, float*** %5
%675 = load i32, i32* %12
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds float*, float** %674, i64 %676
%678 = load float*, float** %677
%679 = load i32, i32* %12
%680 = sub nsw i32 %679, 1
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds float, float* %678, i64 %681
store float %673, float* %682
br label %683
683: ; preds = %662, %658
br label %698
684: ; preds = %654
%685 = load float, float* %24
%686 = fneg float %685
%687 = load float, float* %19
%688 = fmul float %686, %687
%689 = load float**, float*** %5
%690 = load i32, i32* %12
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float*, float** %689, i64 %691
%693 = load float*, float** %692
%694 = load i32, i32* %12
%695 = sub nsw i32 %694, 1
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds float, float* %693, i64 %696
store float %688, float* %697
br label %698
698: ; preds = %684, %683
%699 = load float, float* %24
%700 = load float, float* %27
%701 = fadd float %700, %699
store float %701, float* %27
%702 = load float, float* %27
%703 = load float, float* %24
%704 = fdiv float %702, %703
store float %704, float* %19
%705 = load float, float* %26
%706 = load float, float* %24
%707 = fdiv float %705, %706
store float %707, float* %18
%708 = load float, float* %25
%709 = load float, float* %24
%710 = fdiv float %708, %709
store float %710, float* %17
%711 = load float, float* %27
%712 = load float, float* %26
%713 = fdiv float %712, %711
store float %713, float* %26
%714 = load float, float* %27
%715 = load float, float* %25
%716 = fdiv float %715, %714
store float %716, float* %25
%717 = load i32, i32* %12
store i32 %717, i32* %13
br label %718
718: ; preds = %804, %698
%719 = load i32, i32* %13
%720 = load i32, i32* %9
%721 = icmp sle i32 %719, %720
br i1 %721, label %722, label %807
722: ; preds = %718
%723 = load float**, float*** %5
%724 = load i32, i32* %12
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds float*, float** %723, i64 %725
%727 = load float*, float** %726
%728 = load i32, i32* %13
%729 = sext i32 %728 to i64
%730 = getelementptr inbounds float, float* %727, i64 %729
%731 = load float, float* %730
%732 = load float, float* %26
%733 = load float**, float*** %5
%734 = load i32, i32* %12
%735 = add nsw i32 %734, 1
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds float*, float** %733, i64 %736
%738 = load float*, float** %737
%739 = load i32, i32* %13
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds float, float* %738, i64 %740
%742 = load float, float* %741
%743 = call float @llvm.fmuladd.f32(float %732, float %742, float %731)
store float %743, float* %27
%744 = load i32, i32* %12
%745 = load i32, i32* %9
%746 = sub nsw i32 %745, 1
%747 = icmp ne i32 %744, %746
br i1 %747, label %748, label %776
748: ; preds = %722
%749 = load float, float* %25
%750 = load float**, float*** %5
%751 = load i32, i32* %12
%752 = add nsw i32 %751, 2
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds float*, float** %750, i64 %753
%755 = load float*, float** %754
%756 = load i32, i32* %13
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds float, float* %755, i64 %757
%759 = load float, float* %758
%760 = load float, float* %27
%761 = call float @llvm.fmuladd.f32(float %749, float %759, float %760)
store float %761, float* %27
%762 = load float, float* %27
%763 = load float, float* %17
%764 = load float**, float*** %5
%765 = load i32, i32* %12
%766 = add nsw i32 %765, 2
%767 = sext i32 %766 to i64
%768 = getelementptr inbounds float*, float** %764, i64 %767
%769 = load float*, float** %768
%770 = load i32, i32* %13
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds float, float* %769, i64 %771
%773 = load float, float* %772
%774 = fneg float %762
%775 = call float @llvm.fmuladd.f32(float %774, float %763, float %773)
store float %775, float* %772
br label %776
776: ; preds = %748, %722
%777 = load float, float* %27
%778 = load float, float* %18
%779 = load float**, float*** %5
%780 = load i32, i32* %12
%781 = add nsw i32 %780, 1
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds float*, float** %779, i64 %782
%784 = load float*, float** %783
%785 = load i32, i32* %13
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds float, float* %784, i64 %786
%788 = load float, float* %787
%789 = fneg float %777
%790 = call float @llvm.fmuladd.f32(float %789, float %778, float %788)
store float %790, float* %787
%791 = load float, float* %27
%792 = load float, float* %19
%793 = load float**, float*** %5
%794 = load i32, i32* %12
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds float*, float** %793, i64 %795
%797 = load float*, float** %796
%798 = load i32, i32* %13
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds float, float* %797, i64 %799
%801 = load float, float* %800
%802 = fneg float %791
%803 = call float @llvm.fmuladd.f32(float %802, float %792, float %801)
store float %803, float* %800
br label %804
804: ; preds = %776
%805 = load i32, i32* %13
%806 = add nsw i32 %805, 1
store i32 %806, i32* %13
br label %718
807: ; preds = %718
%808 = load i32, i32* %9
%809 = load i32, i32* %12
%810 = add nsw i32 %809, 3
%811 = icmp slt i32 %808, %810
br i1 %811, label %812, label %814
812: ; preds = %807
%813 = load i32, i32* %9
br label %817
814: ; preds = %807
%815 = load i32, i32* %12
%816 = add nsw i32 %815, 3
br label %817
817: ; preds = %814, %812
%818 = phi i32 [ %813, %812 ], [ %816, %814 ]
store i32 %818, i32* %16
%819 = load i32, i32* %11
store i32 %819, i32* %15
br label %820
820: ; preds = %906, %817
%821 = load i32, i32* %15
%822 = load i32, i32* %16
%823 = icmp sle i32 %821, %822
br i1 %823, label %824, label %909
824: ; preds = %820
%825 = load float, float* %19
%826 = load float**, float*** %5
%827 = load i32, i32* %15
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds float*, float** %826, i64 %828
%830 = load float*, float** %829
%831 = load i32, i32* %12
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds float, float* %830, i64 %832
%834 = load float, float* %833
%835 = load float, float* %18
%836 = load float**, float*** %5
%837 = load i32, i32* %15
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds float*, float** %836, i64 %838
%840 = load float*, float** %839
%841 = load i32, i32* %12
%842 = add nsw i32 %841, 1
%843 = sext i32 %842 to i64
%844 = getelementptr inbounds float, float* %840, i64 %843
%845 = load float, float* %844
%846 = fmul float %835, %845
%847 = call float @llvm.fmuladd.f32(float %825, float %834, float %846)
store float %847, float* %27
%848 = load i32, i32* %12
%849 = load i32, i32* %9
%850 = sub nsw i32 %849, 1
%851 = icmp ne i32 %848, %850
br i1 %851, label %852, label %880
852: ; preds = %824
%853 = load float, float* %17
%854 = load float**, float*** %5
%855 = load i32, i32* %15
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds float*, float** %854, i64 %856
%858 = load float*, float** %857
%859 = load i32, i32* %12
%860 = add nsw i32 %859, 2
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds float, float* %858, i64 %861
%863 = load float, float* %862
%864 = load float, float* %27
%865 = call float @llvm.fmuladd.f32(float %853, float %863, float %864)
store float %865, float* %27
%866 = load float, float* %27
%867 = load float, float* %25
%868 = load float**, float*** %5
%869 = load i32, i32* %15
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds float*, float** %868, i64 %870
%872 = load float*, float** %871
%873 = load i32, i32* %12
%874 = add nsw i32 %873, 2
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds float, float* %872, i64 %875
%877 = load float, float* %876
%878 = fneg float %866
%879 = call float @llvm.fmuladd.f32(float %878, float %867, float %877)
store float %879, float* %876
br label %880
880: ; preds = %852, %824
%881 = load float, float* %27
%882 = load float, float* %26
%883 = load float**, float*** %5
%884 = load i32, i32* %15
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds float*, float** %883, i64 %885
%887 = load float*, float** %886
%888 = load i32, i32* %12
%889 = add nsw i32 %888, 1
%890 = sext i32 %889 to i64
%891 = getelementptr inbounds float, float* %887, i64 %890
%892 = load float, float* %891
%893 = fneg float %881
%894 = call float @llvm.fmuladd.f32(float %893, float %882, float %892)
store float %894, float* %891
%895 = load float, float* %27
%896 = load float**, float*** %5
%897 = load i32, i32* %15
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds float*, float** %896, i64 %898
%900 = load float*, float** %899
%901 = load i32, i32* %12
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds float, float* %900, i64 %902
%904 = load float, float* %903
%905 = fsub float %904, %895
store float %905, float* %903
br label %906
906: ; preds = %880
%907 = load i32, i32* %15
%908 = add nsw i32 %907, 1
store i32 %908, i32* %15
br label %820
909: ; preds = %820
br label %910
910: ; preds = %909, %650
br label %911
911: ; preds = %910
%912 = load i32, i32* %12
%913 = add nsw i32 %912, 1
store i32 %913, i32* %12
br label %552
914: ; preds = %552
br label %915
915: ; preds = %914, %283
br label %916
916: ; preds = %915, %140
br label %917
917: ; preds = %916
%918 = load i32, i32* %11
%919 = load i32, i32* %9
%920 = sub nsw i32 %919, 1
%921 = icmp slt i32 %918, %920
br i1 %921, label %72, label %922
922: ; preds = %917
br label %68
923: ; preds = %68
ret void
}

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