int hessenberg(a, n, wr, wi)
double **a, wr[], wi[];
int n;
{
  int nn, m, l, k, j, its, i, mmin;
  double z, y, x, w, v, u, t, s, r = 0.0, q = 0.0, p = 0.0, 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 ((double)(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 ? -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) {
            return 0;
          }
          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 == l)
              break;
            u = fabs(a[m][m - 1]) * (fabs(q) + fabs(r));
            v = fabs(p) *
                (fabs(a[m - 1][m - 1]) + fabs(z) + fabs(a[m + 1][m + 1]));
            if ((double)(u + v) == v)
              break;
          }
          for (i = m + 2; i <= nn; i++) {
            a[i][i - 2] = 0.0;
            if (i != (m + 2))
              a[i][i - 3] = 0.0;
          }
          for (k = m; k <= nn - 1; k++) {
            if (k != m) {
              p = a[k][k - 1];
              q = a[k + 1][k - 1];
              r = 0.0;
              if (k != (nn - 1))
                r = a[k + 2][k - 1];
              if (x = fabs(p) + fabs(q) + fabs(r)) {
                p /= x;
                q /= x;
                r /= x;
              }
            }
            if (s = ((p) < 0 ? -fabs(sqrt(p * p + q * q + r * r))
                             : fabs(sqrt(p * p + q * q + r * r)))) {
              if (k == m) {
                if (l != m)
                  a[k][k - 1] = -a[k][k - 1];
              } else
                a[k][k - 1] = -s * x;
              p += s;
              x = p / s;
              y = q / s;
              z = r / s;
              q /= p;
              r /= p;
              for (j = k; j <= nn; j++) {
                p = a[k][j] + q * a[k + 1][j];
                if (k != (nn - 1)) {
                  p += r * a[k + 2][j];
                  a[k + 2][j] -= p * z;
                }
                a[k + 1][j] -= p * y;
                a[k][j] -= p * x;
              }
              mmin = nn < k + 3 ? nn : k + 3;
              for (i = l; i <= mmin; i++) {
                p = x * a[i][k] + y * a[i][k + 1];
                if (k != (nn - 1)) {
                  p += z * a[i][k + 2];
                  a[i][k + 2] -= p * r;
                }
                a[i][k + 1] -= p * q;
                a[i][k] -= p;
              }
            }
          }
        }
      }
    } while (l < nn - 1);
  }
  return 1;
}


x86 assembly (clang, -O0):
<hessenberg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0x8(%rax),%xmm0
movaps 0x1ea1(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x2,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11e4 <hessenberg+0xd4>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11d1 <hessenberg+0xc1>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1e51(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1187 <hessenberg+0x77>
jmp    11d6 <hessenberg+0xc6>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1172 <hessenberg+0x62>
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     2141 <hessenberg+0x1031>
movl   $0x0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jl     12ed <hessenberg+0x1dd>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1dc7(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1da7(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1294 <hessenberg+0x184>
jp     1294 <hessenberg+0x184>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d4b(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jne    12da <hessenberg+0x1ca>
jp     12da <hessenberg+0x1ca>
jmp    12ed <hessenberg+0x1dd>
jmp    12df <hessenberg+0x1cf>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1209 <hessenberg+0xf9>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1349 <hessenberg+0x239>
movsd  -0x60(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2126 <hessenberg+0x1016>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15c6 <hessenberg+0x4b6>
movsd  -0x58(%rbp),%xmm1
subsd  -0x60(%rbp),%xmm1
movsd  0x1c57(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movaps 0x1bf7(%rip),%xmm1
pand   %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1551 <hessenberg+0x441>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1490 <hessenberg+0x380>
movsd  -0x50(%rbp),%xmm0
movaps 0x1b98(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    14a8 <hessenberg+0x398>
movsd  -0x50(%rbp),%xmm0
movaps 0x1b64(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1507 <hessenberg+0x3f7>
jp     1507 <hessenberg+0x3f7>
jmp    1527 <hessenberg+0x417>
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
divsd  -0x50(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    15b8 <hessenberg+0x4a8>
movsd  -0x60(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2121 <hessenberg+0x1011>
cmpl   $0x1e,-0x40(%rbp)
jne    15dc <hessenberg+0x4cc>
movl   $0x0,-0x4(%rbp)
jmp    2148 <hessenberg+0x1038>
cmpl   $0xa,-0x40(%rbp)
je     15f0 <hessenberg+0x4e0>
cmpl   $0x14,-0x40(%rbp)
jne    16d5 <hessenberg+0x5c5>
movsd  -0x60(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1643 <hessenberg+0x533>
movsd  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1606 <hessenberg+0x4f6>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x199c(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1972(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x1972(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  %xmm0,-0x58(%rbp)
movsd  0x1950(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     19c5 <hessenberg+0x8b5>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0x17ed(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movaps 0x17da(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x17c3(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    18b2 <hessenberg+0x7a2>
jmp    19c5 <hessenberg+0x8b5>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x172d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movaps 0x171a(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movaps 0x1707(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0x16e7(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x16bd(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x50(%rbp),%xmm2
movaps 0x16ad(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x167f(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jne    19b2 <hessenberg+0x8a2>
jp     19b2 <hessenberg+0x8a2>
jmp    19c5 <hessenberg+0x8b5>
jmp    19b7 <hessenberg+0x8a7>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    16e7 <hessenberg+0x5d7>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1a38 <hessenberg+0x928>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
je     1a25 <hessenberg+0x915>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a2a <hessenberg+0x91a>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    19ce <hessenberg+0x8be>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     211c <hessenberg+0x100c>
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1b95 <hessenberg+0xa85>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1ae7 <hessenberg+0x9d7>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0x150a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movaps 0x14f7(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x14e0(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b45 <hessenberg+0xa35>
jp     1b45 <hessenberg+0xa35>
jmp    1b90 <hessenberg+0xa80>
movsd  -0x60(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1b95 <hessenberg+0xa85>
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1c1a <hessenberg+0xb0a>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps 0x140e(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1c72 <hessenberg+0xb62>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps 0x139a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c9a <hessenberg+0xb8a>
jp     1c9a <hessenberg+0xb8a>
jmp    2109 <hessenberg+0xff9>
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    1d02 <hessenberg+0xbf2>
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1cfd <hessenberg+0xbed>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d40 <hessenberg+0xc30>
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1f5d <hessenberg+0xe4d>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1ebe <hessenberg+0xdae>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1dd5 <hessenberg+0xcc5>
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1f7c <hessenberg+0xe6c>
mov    -0x2c(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    1f88 <hessenberg+0xe78>
mov    -0x38(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     2104 <hessenberg+0xff4>
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     2082 <hessenberg+0xf72>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1f97 <hessenberg+0xe87>
jmp    2109 <hessenberg+0xff9>
jmp    210e <hessenberg+0xffe>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a3e <hessenberg+0x92e>
jmp    2121 <hessenberg+0x1011>
jmp    2126 <hessenberg+0x1016>
jmp    212b <hessenberg+0x101b>
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     1203 <hessenberg+0xf3>
jmp    11f2 <hessenberg+0xe2>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hessenberg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rcx,%r13
mov    %rdx,0x20(%rsp)
mov    %rdi,%r12
mov    0x8(%rdi),%rax
movsd  0x8(%rax),%xmm12
andpd  0xec1(%rip),%xmm12
cmp    $0x2,%esi
jl     1237 <hessenberg+0x127>
lea    0x1(%rsi),%r8d
cmp    $0x3,%r8d
jne    1162 <hessenberg+0x52>
mov    $0x1,%ecx
mov    $0x2,%r10d
jmp    120c <hessenberg+0xfc>
lea    -0x2(%r8),%r9
and    $0xfffffffffffffffe,%r9
mov    $0x1,%ecx
mov    $0x2,%r10d
xor    %r11d,%r11d
movapd 0xe80(%rip),%xmm0
mov    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%r11,8),%rdi
mov    (%r12,%r10,8),%rdx
add    %rdi,%rdx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rbp,8),%xmm1
andpd  %xmm0,%xmm1
addsd  %xmm1,%xmm12
add    $0x1,%rbp
cmp    %rbp,%rax
jne    11b0 <hessenberg+0xa0>
lea    0x0(,%r10,8),%rdx
or     $0x8,%rdx
add    (%r12,%rdx,1),%rdi
mov    $0x2,%edx
nopl   0x0(%rax)
movsd  (%rdi,%rdx,8),%xmm1
andpd  %xmm0,%xmm1
addsd  %xmm1,%xmm12
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11e0 <hessenberg+0xd0>
add    $0x2,%r10
add    $0x2,%rcx
add    $0x2,%r11
add    $0xfffffffffffffffe,%rax
cmp    %r9,%r11
jne    1190 <hessenberg+0x80>
test   $0x1,%r8b
je     1237 <hessenberg+0x127>
mov    (%r12,%r10,8),%rax
movapd 0xde2(%rip),%xmm0
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm1
andpd  %xmm0,%xmm1
addsd  %xmm1,%xmm12
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1220 <hessenberg+0x110>
test   %esi,%esi
jle    1c70 <hessenberg+0xb60>
lea    0x10(%r12),%rax
mov    %rax,0x90(%rsp)
lea    0x18(%r12),%rax
mov    %rax,0x80(%rsp)
xorpd  %xmm9,%xmm9
xor    %r8d,%r8d
movapd 0xd96(%rip),%xmm10
movapd 0xd8d(%rip),%xmm11
movapd 0xd95(%rip),%xmm7
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
xorpd  %xmm14,%xmm14
xorpd  %xmm13,%xmm13
movapd %xmm12,0xa0(%rsp)
mov    %r13,0x88(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %esi,%r10d
test   %esi,%esi
mov    $0x1,%r9d
cmovle %esi,%r9d
lea    0x0(,%r10,8),%rax
lea    (%r12,%r10,8),%rcx
add    $0xffffffff,%esi
lea    (%r12,%rsi,8),%rdi
shl    $0x3,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
lea    (%r10,%rdx,1),%ebp
cmp    $0x2,%ebp
jl     1352 <hessenberg+0x242>
mov    (%rdi,%rdx,8),%rbp
add    %rsi,%rbp
movsd  0x0(%rbp,%rdx,8),%xmm0
andpd  %xmm10,%xmm0
mov    (%rcx,%rdx,8),%rbp
lea    (%rax,%rbp,1),%rbx
movsd  (%rbx,%rdx,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
cmpeqsd %xmm9,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm1,%xmm2
andpd  %xmm12,%xmm0
orpd   %xmm2,%xmm0
add    %rsi,%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
add    $0xffffffffffffffff,%rdx
ucomisd %xmm0,%xmm1
jne    12e0 <hessenberg+0x1d0>
jp     12e0 <hessenberg+0x1d0>
lea    (%r10,%rdx,1),%r9d
add    $0x1,%r9d
movslq %r10d,%r14
mov    (%r12,%r14,8),%rax
movsd  (%rax,%r14,8),%xmm15
cmp    %r10d,%r9d
jne    1390 <hessenberg+0x280>
addsd  0x18(%rsp),%xmm15
mov    0x20(%rsp),%rax
movsd  %xmm15,(%rax,%r14,8)
add    $0xffffffff,%r10d
movq   $0x0,0x0(%r13,%r14,8)
mov    %r10d,%esi
jmp    1c56 <hessenberg+0xb46>
nopl   0x0(%rax,%rax,1)
mov    %r8,0x8(%rsp)
movslq %r10d,%rdx
lea    -0x1(%rdx),%r15
lea    -0x1(%rdx),%esi
mov    -0x8(%r12,%rdx,8),%rcx
movsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  -0x8(%rax,%rdx,8),%xmm1
movsd  (%rcx,%r14,8),%xmm8
mulsd  %xmm1,%xmm8
cmp    %esi,%r9d
mov    %r9d,0x14(%rsp)
mov    %r10,0x28(%rsp)
jne    1410 <hessenberg+0x300>
subsd  %xmm15,%xmm0
movapd %xmm0,%xmm14
mulsd  0xc63(%rip),%xmm14
movapd %xmm14,%xmm3
mulsd  %xmm14,%xmm3
addsd  %xmm8,%xmm3
movapd %xmm3,%xmm0
andpd  %xmm11,%xmm0
ucomisd %xmm9,%xmm0
jb     16aa <hessenberg+0x59a>
sqrtsd %xmm0,%xmm0
jmp    1726 <hessenberg+0x616>
nopl   0x0(%rax)
mov    0x8(%rsp),%rdx
cmp    $0xa,%edx
je     143a <hessenberg+0x32a>
cmp    $0x14,%edx
je     143a <hessenberg+0x32a>
cmp    $0x1e,%edx
je     1c87 <hessenberg+0xb77>
lea    -0x2(%r10),%ebx
cmp    %r9d,%ebx
jge    1547 <hessenberg+0x437>
jmp    17d3 <hessenberg+0x6c3>
test   %r10d,%r10d
jle    14f3 <hessenberg+0x3e3>
lea    -0x1(%r10),%rdi
mov    %r10d,%edx
and    $0x3,%edx
mov    $0x1,%esi
cmp    $0x3,%rdi
jb     14c5 <hessenberg+0x3b5>
mov    %r10d,%edi
and    $0xfffffffc,%edi
xor    %esi,%esi
mov    0x8(%r12,%rsi,8),%rbp
movsd  0x8(%rbp,%rsi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x8(%rbp,%rsi,8)
mov    0x10(%r12,%rsi,8),%rbp
movsd  0x10(%rbp,%rsi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x10(%rbp,%rsi,8)
mov    0x18(%r12,%rsi,8),%rbp
movsd  0x18(%rbp,%rsi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x18(%rbp,%rsi,8)
mov    0x20(%r12,%rsi,8),%rbp
movsd  0x20(%rbp,%rsi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,0x20(%rbp,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1460 <hessenberg+0x350>
add    $0x1,%rsi
test   %rdx,%rdx
je     14ed <hessenberg+0x3dd>
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rsi,8),%rdi
movsd  (%rdi,%rsi,8),%xmm0
subsd  %xmm15,%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    14d0 <hessenberg+0x3c0>
movsd  (%rax,%r15,8),%xmm1
movsd  0x18(%rsp),%xmm0
addsd  %xmm15,%xmm0
movsd  %xmm0,0x18(%rsp)
andpd  %xmm10,%xmm1
lea    -0x2(%r10),%ebx
movslq %ebx,%rax
movsd  (%rcx,%rax,8),%xmm0
andpd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm8
mulsd  0xb0c(%rip),%xmm8
mulsd  %xmm0,%xmm8
mulsd  0xaf7(%rip),%xmm0
movapd %xmm0,%xmm15
cmp    %r9d,%ebx
jl     17d3 <hessenberg+0x6c3>
xorpd  %xmm7,%xmm8
mov    %rbx,%r8
movslq %ebx,%rax
movslq %r9d,%rcx
mov    (%r12,%rax,8),%rdi
movsd  (%rdi,%rax,8),%xmm1
sub    %rax,%rcx
mov    0x90(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
shl    $0x3,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm15,%xmm3
subsd  %xmm1,%xmm3
movapd %xmm0,%xmm4
subsd  %xmm1,%xmm4
mov    -0x8(%rsi,%rdx,8),%rbp
add    %rax,%rbp
movsd  0x8(%rbp,%rdx,8),%xmm2
movapd %xmm2,%xmm13
subsd  %xmm1,%xmm13
subsd  %xmm3,%xmm13
movapd %xmm3,%xmm14
mulsd  %xmm4,%xmm14
addsd  %xmm8,%xmm14
divsd  0x0(%rbp,%rdx,8),%xmm14
add    %rax,%rdi
addsd  0x8(%rdi,%rdx,8),%xmm14
subsd  %xmm4,%xmm13
mov    (%rsi,%rdx,8),%rbp
add    %rax,%rbp
movapd %xmm14,%xmm3
andpd  %xmm10,%xmm3
movapd %xmm13,%xmm4
andpd  %xmm10,%xmm4
addsd  %xmm3,%xmm4
movsd  0x8(%rbp,%rdx,8),%xmm3
unpcklpd %xmm3,%xmm13
andpd  %xmm10,%xmm3
addsd  %xmm4,%xmm3
divsd  %xmm3,%xmm14
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm13
cmp    %rdx,%rcx
je     17d0 <hessenberg+0x6c0>
movapd %xmm13,%xmm3
unpckhpd %xmm13,%xmm3
andpd  %xmm11,%xmm3
movsd  -0x8(%rdi,%rdx,8),%xmm4
unpcklpd %xmm14,%xmm4
andpd  %xmm11,%xmm4
mov    -0x18(%rsi,%rdx,8),%rdi
lea    (%rdi,%rax,1),%rbp
movsd  -0x8(%rbp,%rdx,8),%xmm5
movapd %xmm5,%xmm6
andpd  %xmm11,%xmm6
andpd  %xmm11,%xmm1
addsd  %xmm6,%xmm1
unpcklpd %xmm1,%xmm3
movapd %xmm13,%xmm1
unpcklpd %xmm2,%xmm1
andpd  %xmm11,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm4,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm2,%xmm1
add    $0xffffffffffffffff,%rdx
ucomisd %xmm2,%xmm1
movapd %xmm5,%xmm1
jne    1580 <hessenberg+0x470>
jp     1580 <hessenberg+0x470>
mov    %r8,%rbx
lea    (%r8,%rdx,1),%ebx
add    $0x1,%ebx
jmp    17d3 <hessenberg+0x6c3>
movapd %xmm13,0x70(%rsp)
movapd %xmm14,0x60(%rsp)
movapd %xmm15,0x50(%rsp)
movapd %xmm8,0x40(%rsp)
movapd %xmm3,0x30(%rsp)
call   1030 <sqrt@plt>
movapd 0x30(%rsp),%xmm3
movapd 0x40(%rsp),%xmm8
movapd 0x50(%rsp),%xmm15
movapd 0x60(%rsp),%xmm14
mov    0x28(%rsp),%r10
movapd 0x70(%rsp),%xmm13
mov    0x14(%rsp),%r9d
movapd 0x90b(%rip),%xmm7
movapd 0x8f2(%rip),%xmm11
movapd 0x8e9(%rip),%xmm10
xorpd  %xmm9,%xmm9
movapd 0xa0(%rsp),%xmm12
mov    0x20(%rsp),%rax
addsd  0x18(%rsp),%xmm15
ucomisd %xmm9,%xmm3
jae    1757 <hessenberg+0x647>
addsd  %xmm14,%xmm15
movsd  %xmm15,(%rax,%r14,8)
movsd  %xmm15,(%rax,%r15,8)
movsd  %xmm0,0x0(%r13,%r14,8)
xorpd  %xmm7,%xmm0
jmp    17bb <hessenberg+0x6ab>
movapd %xmm0,%xmm2
andpd  %xmm11,%xmm2
orpd   %xmm7,%xmm0
movapd %xmm14,%xmm1
cmpltsd %xmm9,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
addsd  %xmm14,%xmm1
movapd %xmm15,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%r14,8)
movsd  %xmm0,(%rax,%r15,8)
ucomisd %xmm9,%xmm1
jne    179e <hessenberg+0x68e>
jnp    17ae <hessenberg+0x69e>
divsd  %xmm1,%xmm8
subsd  %xmm8,%xmm15
movsd  %xmm15,(%rax,%r14,8)
movq   $0x0,0x0(%r13,%r14,8)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
lea    -0x2(%r10),%esi
movsd  %xmm3,%xmm13
jmp    1c51 <hessenberg+0xb41>
mov    %r9d,%ebx
lea    0x2(%rbx),%eax
cmp    %r10d,%eax
jg     18b0 <hessenberg+0x7a0>
cltq
lea    0x1(%r10),%ecx
mov    (%r12,%rax,8),%rdx
movq   $0x0,-0x10(%rdx,%rax,8)
add    $0x1,%rax
cmp    %eax,%ecx
je     18b0 <hessenberg+0x7a0>
mov    %r10d,%edx
sub    %ebx,%edx
add    $0x2,%edx
mov    %r10d,%ecx
sub    %ebx,%ecx
add    $0xfffffffd,%ecx
and    $0x3,%edx
je     1837 <hessenberg+0x727>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rax,8),%rsi
xorpd  %xmm0,%xmm0
movupd %xmm0,-0x18(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1820 <hessenberg+0x710>
cmp    $0x3,%ecx
jb     18b0 <hessenberg+0x7a0>
mov    %r10d,%ecx
sub    %eax,%ecx
add    $0x1,%ecx
mov    0x80(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
shl    $0x3,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    -0x18(%rdx,%rsi,8),%rdi
add    %rax,%rdi
xorpd  %xmm0,%xmm0
movupd %xmm0,-0x18(%rdi,%rsi,8)
mov    -0x10(%rdx,%rsi,8),%rdi
add    %rax,%rdi
movupd %xmm0,-0x10(%rdi,%rsi,8)
mov    -0x8(%rdx,%rsi,8),%rdi
add    %rax,%rdi
movupd %xmm0,-0x8(%rdi,%rsi,8)
mov    (%rdx,%rsi,8),%rdi
add    %rax,%rdi
movupd %xmm0,(%rdi,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    1860 <hessenberg+0x750>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
cmp    %r10d,%ebx
jge    1c41 <hessenberg+0xb31>
mov    %rbx,0x30(%rsp)
movslq %ebx,%rbx
movslq %r9d,%rax
lea    -0x1(%rbx),%r13
add    $0xffffffffffffffff,%rax
mov    %rax,0x98(%rsp)
mov    %rbx,%rbp
jmp    1901 <hessenberg+0x7f1>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x1,%r13
cmp    %r14,%rbp
je     1c46 <hessenberg+0xb36>
cmp    %rbx,%rbp
je     1977 <hessenberg+0x867>
xorpd  %xmm15,%xmm15
cmp    %r15,%rbp
je     191c <hessenberg+0x80c>
mov    0x10(%r12,%rbp,8),%rax
movsd  -0x8(%rax,%rbp,8),%xmm15
mov    (%r12,%rbp,8),%rax
mov    0x8(%r12,%rbp,8),%rcx
movsd  -0x8(%rax,%rbp,8),%xmm14
movsd  -0x8(%rcx,%rbp,8),%xmm13
movapd %xmm14,%xmm0
andpd  %xmm10,%xmm0
movapd %xmm13,%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
unpcklpd %xmm15,%xmm13
andpd  %xmm10,%xmm15
addsd  %xmm1,%xmm15
ucomisd %xmm9,%xmm15
jne    1963 <hessenberg+0x853>
jnp    1977 <hessenberg+0x867>
divsd  %xmm15,%xmm14
movapd %xmm15,%xmm0
unpcklpd %xmm15,%xmm0
divpd  %xmm0,%xmm13
movapd %xmm13,%xmm0
mulsd  %xmm13,%xmm0
movapd %xmm14,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm13,%xmm8
unpckhpd %xmm13,%xmm8
movapd %xmm8,%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm9,%xmm0
jb     19c0 <hessenberg+0x8b0>
sqrtsd %xmm0,%xmm0
jmp    1a30 <hessenberg+0x920>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm13,0x70(%rsp)
movapd %xmm14,0x60(%rsp)
movapd %xmm15,0x50(%rsp)
movapd %xmm8,0x40(%rsp)
call   1030 <sqrt@plt>
movapd 0x40(%rsp),%xmm8
movapd 0x50(%rsp),%xmm15
movapd 0x60(%rsp),%xmm14
mov    0x28(%rsp),%r10
movapd 0x70(%rsp),%xmm13
mov    0x14(%rsp),%r9d
movapd 0x601(%rip),%xmm7
movapd 0x5e8(%rip),%xmm11
movapd 0x5df(%rip),%xmm10
xorpd  %xmm9,%xmm9
movapd 0xa0(%rsp),%xmm12
movapd %xmm0,%xmm2
andpd  %xmm11,%xmm2
orpd   %xmm7,%xmm0
movapd %xmm14,%xmm1
cmpltsd %xmm9,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
ucomisd %xmm9,%xmm1
jne    1a61 <hessenberg+0x951>
jnp    18f0 <hessenberg+0x7e0>
cmp    %rbx,%rbp
jne    1a90 <hessenberg+0x980>
cmp    0x30(%rsp),%r9d
je     1aa8 <hessenberg+0x998>
mov    (%r12,%rbx,8),%rax
movsd  -0x8(%rax,%rbx,8),%xmm0
xorpd  %xmm7,%xmm0
movlpd %xmm0,-0x8(%rax,%rbx,8)
jmp    1aa8 <hessenberg+0x998>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm1,%xmm0
xorpd  %xmm7,%xmm0
mulsd  %xmm0,%xmm15
mov    (%r12,%rbp,8),%rax
movsd  %xmm15,-0x8(%rax,%rbp,8)
addsd  %xmm1,%xmm14
movapd %xmm14,%xmm15
divsd  %xmm1,%xmm15
movapd %xmm13,%xmm0
divsd  %xmm1,%xmm0
divsd  %xmm1,%xmm8
unpcklpd %xmm14,%xmm14
divpd  %xmm14,%xmm13
mov    (%r12,%rbp,8),%rax
mov    0x8(%r12,%rbp,8),%rcx
movapd %xmm13,%xmm1
unpckhpd %xmm13,%xmm1
mov    %r13,%rdx
jmp    1b57 <hessenberg+0xa47>
nopw   0x0(%rax,%rax,1)
mov    0x10(%r12,%rbp,8),%rsi
movsd  0x8(%rsi,%rdx,8),%xmm3
movapd %xmm1,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm2,%xmm14
movapd %xmm14,%xmm2
xorpd  %xmm7,%xmm2
movapd %xmm14,%xmm4
mulsd  %xmm8,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%rsi,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x8(%rcx,%rdx,8)
mulsd  %xmm15,%xmm2
addsd  0x8(%rax,%rdx,8),%xmm2
movsd  %xmm2,0x8(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %r14,%rdx
jge    1b90 <hessenberg+0xa80>
movsd  0x8(%rcx,%rdx,8),%xmm3
movapd %xmm13,%xmm14
mulsd  %xmm3,%xmm14
addsd  0x8(%rax,%rdx,8),%xmm14
cmp    %r15,%rbp
jne    1af0 <hessenberg+0x9e0>
movapd %xmm14,%xmm2
xorpd  %xmm7,%xmm2
jmp    1b2b <hessenberg+0xa1b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x3(%rbp),%rax
cmp    %r14,%rax
cmovg  %r10d,%eax
cmp    %eax,%r9d
jg     18f0 <hessenberg+0x7e0>
cltq
mov    0x98(%rsp),%rcx
jmp    1c06 <hessenberg+0xaf6>
movsd  0x10(%rdx,%rbp,8),%xmm5
movapd %xmm8,%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm4,%xmm14
movapd %xmm14,%xmm4
xorpd  %xmm7,%xmm4
movapd %xmm14,%xmm6
mulsd  %xmm1,%xmm6
subsd  %xmm6,%xmm5
movsd  %xmm5,0x10(%rdx,%rbp,8)
mulsd  %xmm13,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x8(%rdx,%rbp,8)
subsd  %xmm14,%xmm2
movsd  %xmm2,(%rdx,%rbp,8)
add    $0x1,%rcx
cmp    %rax,%rcx
jge    18f0 <hessenberg+0x7e0>
mov    0x8(%r12,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm2
movsd  0x8(%rdx,%rbp,8),%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm15,%xmm14
mulsd  %xmm2,%xmm14
addsd  %xmm4,%xmm14
cmp    %r15,%rbp
jne    1bb0 <hessenberg+0xaa0>
movapd %xmm14,%xmm4
xorpd  %xmm7,%xmm4
jmp    1be0 <hessenberg+0xad0>
mov    %r10d,%esi
jmp    1c51 <hessenberg+0xb41>
mov    %r10d,%esi
mov    0x88(%rsp),%r13
mov    0x8(%rsp),%r8
lea    -0x1(%rsi),%eax
cmp    %eax,%r9d
jl     12b0 <hessenberg+0x1a0>
mov    $0x0,%r8d
test   %esi,%esi
jg     12b0 <hessenberg+0x1a0>
mov    $0x1,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
jmp    1c75 <hessenberg+0xb65>

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

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