void hqr(int n, int low, int igh, double *h, double *ev, int *ierr) {
  int i, j, k, l = 0, m = 0, en, ll, mm, na, its, mp2, enm2;
  double p = 0.0, q = 0.0, r = 0.0, s, t, w, x, y, zz, norm, machep = 1.e-10;
  int notlas;
  *ierr = 0;
  norm = 0.0;
  k = 1;
  for (i = 1; i <= n; i++) {
    for (j = k; j <= n; j++)
      norm = norm + fabs(h[i - 1 + (j - 1) * n]);
    k = i;
    if ((i >= low) && (i <= igh))
      continue;
    ev[(i - 1) * 2] = h[i - 1 + (i - 1) * n];
    ev[1 + (i - 1) * 2] = 0.0;
  }
  en = igh;
  t = 0.0;
l60:
  if (en < low)
    return;
  its = 0;
  na = en - 1;
  enm2 = na - 1;
l70:
  for (ll = low; ll <= en; ll++) {
    l = en + low - ll;
    if (l == low)
      break;
    s = fabs(h[l - 2 + (l - 2) * n]) + fabs(h[l - 1 + (l - 1) * n]);
    if (s == 0.0)
      s = norm;
    if (fabs(h[l - 1 + (l - 2) * n]) <= machep * s)
      break;
  }
  x = h[en - 1 + (en - 1) * n];
  if (l == en)
    goto l270;
  y = h[na - 1 + (na - 1) * n];
  w = h[en - 1 + (na - 1) * n] * h[na - 1 + (en - 1) * n];
  if (l == na)
    goto l280;
  if (its == 30)
    goto l1000;
  if ((its != 10) && (its != 20))
    goto l130;
  t = t + x;
  for (i = low; i <= en; i++)
    h[i - 1 + (i - 1) * n] = h[i - 1 + (i - 1) * n] - x;
  s = fabs(h[en - 1 + (na - 1) * n]) + fabs(h[na - 1 + (enm2 - 1) * n]);
  x = 0.75 * s;
  y = x;
  w = -0.4375 * s * s;
l130:
  its++;
  for (mm = l; mm <= enm2; mm++) {
    m = enm2 + l - mm;
    zz = h[m - 1 + (m - 1) * n];
    r = x - zz;
    s = y - zz;
    p = (r * s - w) / h[m + (m - 1) * n] + h[m - 1 + m * n];
    q = h[m + m * n] - zz - r - s;
    r = h[m + 1 + m * n];
    s = fabs(p) + fabs(q) + fabs(r);
    p = p / s;
    q = q / s;
    r = r / s;
    if (m == l)
      break;
    if ((fabs(h[m - 1 + (m - 2) * n]) * (fabs(q) + fabs(r))) <=
        (machep * fabs(p) *
         (fabs(h[m - 2 + (m - 2) * n]) + fabs(zz) + fabs(h[m + m * n]))))
      break;
  }
  mp2 = m + 2;
  for (i = mp2; i <= en; i++) {
    h[i - 1 + (i - 3) * n] = 0.0;
    if (i == mp2)
      continue;
    h[i - 1 + (i - 4) * n] = 0.0;
  }
  for (k = m; k <= na; k++) {
    notlas = 0;
    if (k != na)
      notlas = 1;
    if (k == m)
      goto l170;
    p = h[k - 1 + (k - 2) * n];
    q = h[k + (k - 2) * n];
    r = 0.0;
    if (notlas)
      r = h[k + 1 + (k - 2) * n];
    x = fabs(p) + fabs(q) + fabs(r);
    if (x == 0.0)
      continue;
    p = p / x;
    q = q / x;
    r = r / x;
  l170:
    s = sign(sqrt(p * p + q * q + r * r), p);
    if (k != m)
      h[k - 1 + (k - 2) * n] = -s * x;
    else if (l != m)
      h[k - 1 + (k - 2) * n] = -h[k - 1 + (k - 2) * n];
    p = p + s;
    x = p / s;
    y = q / s;
    zz = r / s;
    q = q / p;
    r = r / p;
    for (j = k; j <= en; j++) {
      p = h[k - 1 + (j - 1) * n] + q * h[k + (j - 1) * n];
      if (notlas) {
        p = p + r * h[k + 1 + (j - 1) * n];
        h[k + 1 + (j - 1) * n] = h[k + 1 + (j - 1) * n] - p * zz;
      }
      h[k + (j - 1) * n] = h[k + (j - 1) * n] - p * y;
      h[k - 1 + (j - 1) * n] = h[k - 1 + (j - 1) * n] - p * x;
    }
    j = imin(en, k + 3);
    for (i = l; i <= j; i++) {
      p = x * h[i - 1 + (k - 1) * n] + y * h[i - 1 + k * n];
      if (notlas) {
        p = p + zz * h[i - 1 + (k + 1) * n];
        h[i - 1 + (k + 1) * n] = h[i - 1 + (k + 1) * n] - p * r;
      }
      h[i - 1 + k * n] = h[i - 1 + k * n] - p * q;
      h[i - 1 + (k - 1) * n] = h[i - 1 + (k - 1) * n] - p;
    }
  }
  goto l70;
l270:
  ev[(en - 1) * 2] = x + t;
  ev[1 + (en - 1) * 2] = 0.0;
  en = na;
  goto l60;
l280:
  p = (y - x) / 2.0;
  q = p * p + w;
  zz = sqrt(fabs(q));
  x = x + t;
  if (q < 0.0)
    goto l320;
  zz = p + sign(zz, p);
  ev[(na - 1) * 2] = x + zz;
  ev[(en - 1) * 2] = ev[(na - 1) * 2];
  if (zz != 0.0)
    ev[(en - 1) * 2] = x - w / zz;
  ev[1 + (na - 1) * 2] = 0.0;
  ev[1 + (en - 1) * 2] = 0.0;
  goto l330;
l320:
  ev[(na - 1) * 2] = x + p;
  ev[(en - 1) * 2] = x + p;
  ev[1 + (na - 1) * 2] = zz;
  ev[1 + (en - 1) * 2] = -zz;
l330:
  en = enm2;
  goto l60;
l1000:
  *ierr = en;
}


x86 assembly (clang, -O0):
<hqr>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1e82(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x1,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1291 <hqr+0x161>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1212 <hqr+0xe2>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1e2c(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11bb <hqr+0x8b>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     1235 <hqr+0x105>
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1235 <hqr+0x105>
jmp    1283 <hqr+0x153>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a9 <hqr+0x79>
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12b0 <hqr+0x180>
jmp    21ed <hqr+0x10bd>
movl   $0x0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     13d0 <hqr+0x2a0>
mov    -0x40(%rbp),%eax
add    -0x8(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    12f8 <hqr+0x1c8>
jmp    13d0 <hqr+0x2a0>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x38(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d03(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1cda(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1378 <hqr+0x248>
jp     1378 <hqr+0x248>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1c83(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     13bd <hqr+0x28d>
jmp    13d0 <hqr+0x2a0>
jmp    13c2 <hqr+0x292>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12cf <hqr+0x19f>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    1407 <hqr+0x2d7>
jmp    1f5d <hqr+0xe2d>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jne    1482 <hqr+0x352>
jmp    1fa5 <hqr+0xe75>
cmpl   $0x1e,-0x50(%rbp)
jne    1491 <hqr+0x361>
jmp    21e4 <hqr+0x10b4>
cmpl   $0xa,-0x50(%rbp)
je     14aa <hqr+0x37a>
cmpl   $0x14,-0x50(%rbp)
je     14aa <hqr+0x37a>
jmp    15ba <hqr+0x48a>
movsd  -0x80(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1520 <hqr+0x3f0>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c2 <hqr+0x392>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1adb(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x58(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1ab2(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x1a8d(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1a60(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1861 <hqr+0x731>
mov    -0x58(%rbp),%eax
add    -0x38(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x70(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x1928(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movaps 0x1918(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
movaps 0x1904(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    1767 <hqr+0x637>
jmp    1861 <hqr+0x731>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1894(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movaps 0x1884(%rip),%xmm2
pand   %xmm2,%xmm0
movsd  -0x70(%rbp),%xmm2
movaps 0x1874(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movaps 0x1854(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x1827(%rip),%xmm3
pand   %xmm3,%xmm2
movsd  -0xa0(%rbp),%xmm3
ff
movaps 0x1814(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movaps 0x17ed(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     184e <hqr+0x71e>
jmp    1861 <hqr+0x731>
jmp    1853 <hqr+0x723>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    15c9 <hqr+0x499>
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     18dd <hqr+0x7ad>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    18ae <hqr+0x77e>
jmp    18cf <hqr+0x79f>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x4,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1870 <hqr+0x740>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1f58 <hqr+0xe28>
movl   $0x0,-0xb4(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     190f <hqr+0x7df>
movl   $0x1,-0xb4(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jne    1920 <hqr+0x7f0>
jmp    1a31 <hqr+0x901>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpl   $0x0,-0xb4(%rbp)
je     199b <hqr+0x86b>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x1679(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movaps 0x1669(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
movaps 0x1655(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19fb <hqr+0x8cb>
jp     19fb <hqr+0x8cb>
jmp    1f4a <hqr+0xe1a>
movsd  -0x60(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  -0x60(%rbp),%xmm1
mov    $0x2,%al
call   1040 <sign@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1acc <hqr+0x99c>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b30 <hqr+0xa00>
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1b2b <hqr+0x9fb>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b30 <hqr+0xa00>
movsd  -0x60(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1d72 <hqr+0xc42>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0xb4(%rbp)
je     1c9a <hqr+0xb6a>
movsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b99 <hqr+0xa69>
mov    -0x40(%rbp),%edi
mov    -0x34(%rbp),%esi
add    $0x3,%esi
mov    $0x0,%al
call   1030 <imin@plt>
mov    %eax,-0x30(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1f45 <hqr+0xe15>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0xb4(%rbp)
je     1e97 <hqr+0xd67>
movsd  -0x60(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d8b <hqr+0xc5b>
jmp    1f4a <hqr+0xe1a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18e3 <hqr+0x7b3>
jmp    12c9 <hqr+0x199>
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    129f <hqr+0x16f>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0x105b(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0x102f(%rip),%xmm1
pand   %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
movsd  -0x90(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    202a <hqr+0xefa>
jmp    213e <hqr+0x100e>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
mov    $0x2,%al
call   1040 <sign@plt>
movsd  -0xc0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    20d2 <hqr+0xfa2>
jp     20d2 <hqr+0xfa2>
jmp    2103 <hqr+0xfd3>
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
divsd  -0xa0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    21d9 <hqr+0x10a9>
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    129f <hqr+0x16f>
mov    -0x40(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hqr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    %r8,%r12
mov    %rcx,%r13
mov    %r9,0x140(%rsp)
movl   $0x0,(%r9)
mov    %rsi,0x18(%rsp)
movslq %esi,%rax
mov    %rax,0x80(%rsp)
test   %edi,%edi
mov    %rdi,0x30(%rsp)
mov    %rdx,0x10(%rsp)
jle    12d3 <hqr+0x1a3>
mov    %edi,%r9d
lea    0x1(%rdi),%r14d
movslq %edx,%r11
mov    %r14,%r10
neg    %r10
mov    %r9,%rdi
shl    $0x4,%rdi
lea    0x0(,%r9,8),%r8
mov    $0x1,%edx
xorpd  %xmm9,%xmm9
mov    $0x1,%ecx
xor    %r15d,%r15d
movapd 0x1e4f(%rip),%xmm0
movapd 0x1e47(%rip),%xmm1
xor    %ebp,%ebp
jmp    1216 <hqr+0xe6>
nopl   (%rax)
lea    -0x1(%rax),%rcx
lea    -0x1(%rax),%edx
imul   0x30(%rsp),%edx
movslq %edx,%rdx
add    %rax,%rdx
add    $0xffffffffffffffff,%rdx
movsd  0x0(%r13,%rdx,8),%xmm2
lea    (%rcx,%rcx,1),%edx
add    $0x1,%edx
shl    $0x21,%rcx
sar    $0x1d,%rcx
movsd  %xmm2,(%r12,%rcx,1)
movslq %edx,%rcx
movq   $0x0,(%r12,%rcx,8)
mov    %rax,%rcx
add    $0x1,%rcx
add    $0x1,%rbp
add    $0x8,%r15
mov    %eax,%edx
cmp    %r14,%rcx
je     12d8 <hqr+0x1a8>
mov    %rcx,%rax
cmp    0x30(%rsp),%edx
jg     12b7 <hqr+0x187>
mov    %edx,%ecx
mov    %r14d,%esi
sub    %edx,%esi
test   $0x1,%sil
jne    1240 <hqr+0x110>
mov    %rcx,%rsi
jmp    1263 <hqr+0x133>
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rax),%rdx
lea    -0x1(%rcx),%rsi
imul   %r9,%rsi
add    %rdx,%rsi
movsd  0x0(%r13,%rsi,8),%xmm2
andpd  %xmm1,%xmm2
addsd  %xmm2,%xmm9
lea    0x1(%rcx),%rsi
not    %rcx
cmp    %r10,%rcx
je     12b7 <hqr+0x187>
mov    %r14,%rcx
sub    %rsi,%rcx
mov    %r9,%rdx
imul   %rsi,%rdx
add    %rbp,%rdx
add    $0xffffffffffffffff,%rsi
imul   %r8,%rsi
add    %r15,%rsi
mov    %r13,%rbx
nopl   0x0(%rax)
movsd  (%rbx,%rsi,1),%xmm2
andpd  %xmm0,%xmm2
addsd  %xmm9,%xmm2
movsd  (%rbx,%rdx,8),%xmm9
andpd  %xmm0,%xmm9
addsd  %xmm2,%xmm9
add    %rdi,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1290 <hqr+0x160>
cmp    0x80(%rsp),%rax
jl     11c0 <hqr+0x90>
cmp    %r11,%rax
jle    11fc <hqr+0xcc>
jmp    11c0 <hqr+0x90>
xorpd  %xmm9,%xmm9
mov    0x10(%rsp),%r8
cmp    0x18(%rsp),%r8d
jl     21f1 <hqr+0x10c1>
mov    0x30(%rsp),%rcx
movslq %ecx,%rsi
mov    $0x1,%eax
mov    0x18(%rsp),%rdi
sub    %edi,%eax
mov    %rax,0x150(%rsp)
lea    -0x1(%rdi),%eax
imul   %ecx,%eax
cltq
mov    0x80(%rsp),%rdx
add    %rdx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x160(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0x158(%rsp)
mov    %ecx,%eax
not    %eax
mov    %eax,0x5c(%rsp)
mov    %edi,%eax
neg    %eax
mov    %rax,0x148(%rsp)
lea    (%rcx,%rcx,1),%r14d
lea    0x0(,%rsi,8),%r9
mov    %rsi,%rbx
shl    $0x4,%rbx
add    $0x10,%rbx
mov    %rsi,0x40(%rsp)
lea    0x8(,%rsi,8),%rax
mov    %rax,0x1c0(%rsp)
lea    -0x8(%r13),%rax
mov    %rax,0x168(%rsp)
xorpd  %xmm6,%xmm6
xorpd  %xmm8,%xmm8
movapd 0x1c83(%rip),%xmm14
movapd 0x1c6a(%rip),%xmm10
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
xorpd  %xmm4,%xmm4
xor    %eax,%eax
xor    %ebp,%ebp
movapd %xmm9,0x110(%rsp)
mov    %r14d,0x24(%rsp)
mov    %r9,0x8(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r12,0xb8(%rsp)
mov    %r13,0x48(%rsp)
jmp    141d <hqr+0x2ed>
addsd  0x78(%rsp),%xmm12
mov    0x38(%rsp),%r15
lea    (%r15,%r15,1),%eax
movslq %eax,%rcx
mov    0xb8(%rsp),%r12
movsd  %xmm12,(%r12,%rcx,8)
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
xorpd  %xmm0,%xmm0
or     $0x1,%eax
cltq
movsd  %xmm0,(%r12,%rax,8)
unpcklpd %xmm1,%xmm6
mov    %r8d,%eax
mov    %r15d,%r8d
cmp    0x18(%rsp),%r15d
jl     21f1 <hqr+0x10c1>
mov    %eax,0x4(%rsp)
lea    -0x1(%r8),%r10d
lea    -0x2(%r8),%r11d
mov    %r10d,%edi
mov    0x30(%rsp),%rcx
imul   %ecx,%edi
lea    (%rdi,%r8,1),%eax
add    $0xffffffff,%eax
cltq
mov    %rax,0x1a8(%rsp)
mov    %r11d,%edx
imul   %ecx,%edx
lea    (%rdx,%r8,1),%eax
add    $0xfffffffe,%eax
cltq
mov    %rax,0x1a0(%rsp)
lea    -0x1(%rdx,%r8,1),%eax
cltq
mov    %rax,0xf8(%rsp)
lea    -0x2(%rdi,%r8,1),%eax
cltq
mov    %rax,0x198(%rsp)
lea    -0x3(%r8),%eax
mov    %eax,0xc8(%rsp)
mov    %eax,%esi
imul   %ecx,%esi
lea    (%rsi,%r8,1),%eax
add    $0xfffffffe,%eax
cltq
mov    %rax,0x190(%rsp)
movslq %r8d,%r15
add    $0xffffffff,%edi
mov    %rdi,0x188(%rsp)
lea    -0x4(%r15),%eax
imul   %ecx,%eax
lea    -0x4(%rax),%ecx
mov    %ecx,0xd4(%rsp)
add    $0xfffffffd,%eax
mov    %rax,0x170(%rsp)
lea    -0x3(%rsi),%eax
mov    %eax,0xd0(%rsp)
add    $0xfffffffe,%esi
mov    %rsi,0x178(%rsp)
lea    -0x1(%rdx),%eax
mov    %eax,0x54(%rsp)
lea    -0x2(%rdx),%eax
mov    %eax,0x50(%rsp)
add    $0xfffffffd,%edx
mov    %rdx,0x180(%rsp)
lea    0x1(%r15),%eax
mov    %r11,0xc0(%rsp)
movslq %r11d,%rcx
mov    %rcx,0x1b8(%rsp)
mov    %rax,%r11
mov    %r10,%rax
mov    %r10,0x38(%rsp)
movslq %r10d,%r12
mov    0x4(%rsp),%r10d
mov    0x150(%rsp),%rax
add    %r8d,%eax
mov    %eax,0xcc(%rsp)
mov    0x148(%rsp),%rax
add    %r8d,%eax
mov    %eax,0xdc(%rsp)
movl   $0x0,0x58(%rsp)
mov    %r8,0x10(%rsp)
mov    %r11,0x88(%rsp)
jmp    1577 <hqr+0x447>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%r13
mov    0x24(%rsp),%r14d
mov    0x28(%rsp),%rbx
mov    0x100(%rsp),%rbp
cmp    0x18(%rsp),%r8d
jl     1650 <hqr+0x520>
mov    %rbp,%r10
xor    %eax,%eax
mov    0x50(%rsp),%ecx
mov    0x54(%rsp),%edx
mov    0x188(%rsp),%rsi
mov    0x80(%rsp),%rdi
nop
mov    0xdc(%rsp),%ebp
add    %eax,%ebp
je     1640 <hqr+0x510>
lea    (%r8,%rcx,1),%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm0
andpd  %xmm10,%xmm0
lea    (%r8,%rsi,1),%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
cmpeqsd %xmm8,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm1,%xmm2
andpd  %xmm9,%xmm0
orpd   %xmm2,%xmm0
lea    (%r8,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
andpd  %xmm10,%xmm1
mulsd  0x1a11(%rip),%xmm0
add    $0xffffffff,%eax
ucomisd %xmm1,%xmm0
jae    1632 <hqr+0x502>
lea    0x1(%rdi),%rbp
mov    0x5c(%rsp),%ebx
add    %ebx,%esi
add    %ebx,%edx
add    %ebx,%ecx
cmp    %r15,%rdi
mov    %rbp,%rdi
jl     15a0 <hqr+0x470>
add    %r8d,%eax
add    $0x1,%eax
jmp    1645 <hqr+0x515>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
mov    0x28(%rsp),%rbx
mov    %r10,%rbp
mov    %eax,%r10d
mov    0x1a8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm12
cmp    %r8d,%r10d
je     13d0 <hqr+0x2a0>
mov    0x1a0(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm11
mov    0xf8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x198(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm13
mulsd  %xmm1,%xmm13
cmp    0x38(%rsp),%r10d
je     2010 <hqr+0xee0>
mov    0x58(%rsp),%eax
cmp    $0xa,%eax
mov    %r10d,0x4(%rsp)
je     16e0 <hqr+0x5b0>
cmp    $0x14,%eax
je     16e0 <hqr+0x5b0>
cmp    $0x1e,%eax
je     21e6 <hqr+0x10b6>
cmp    0xc0(%rsp),%r10d
jle    1815 <hqr+0x6e5>
jmp    1a0f <hqr+0x8df>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    0x18(%rsp),%r8d
jl     17b3 <hqr+0x683>
mov    %rbp,%r10
mov    0x80(%rsp),%rax
testb  $0x1,0xcc(%rsp)
01
je     1723 <hqr+0x5f3>
mov    0x160(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
subsd  %xmm12,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0x158(%rsp),%rax
cmp    0x18(%rsp),%r8d
je     1797 <hqr+0x667>
mov    0x30(%rsp),%rdi
mov    %edi,%ecx
imul   %eax,%ecx
mov    %r11d,%edx
sub    %eax,%edx
lea    -0x1(%rax),%esi
imul   %edi,%esi
lea    -0x1(%rax),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ecx,%rcx
lea    (%rax,%rcx,1),%rbp
movslq %esi,%rsi
lea    (%rdi,%rsi,1),%rbx
movsd  0x0(%r13,%rbx,8),%xmm0
subsd  %xmm12,%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
movsd  0x0(%r13,%rbp,8),%xmm0
subsd  %xmm12,%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x2,%rax
add    %r14d,%ecx
add    %r14d,%esi
add    $0x2,%rdi
add    $0xfffffffe,%edx
jne    1750 <hqr+0x620>
mov    0xf8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x28(%rsp),%rbx
mov    %r10,%rbp
mov    0x4(%rsp),%r10d
movsd  0x78(%rsp),%xmm0
addsd  %xmm12,%xmm0
movsd  %xmm0,0x78(%rsp)
andpd  %xmm10,%xmm1
mov    0x190(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
andpd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm13
mulsd  0x1841(%rip),%xmm13
mulsd  %xmm0,%xmm13
movapd %xmm0,%xmm12
mulsd  0x1826(%rip),%xmm12
movapd %xmm12,%xmm11
cmp    0xc0(%rsp),%r10d
jg     1a0f <hqr+0x8df>
xorpd  %xmm14,%xmm13
movslq %r10d,%r9
mov    %r8d,%eax
sub    %r10d,%eax
mov    %eax,0x60(%rsp)
mov    $0xffffffff,%r14d
mov    $0xfffffffe,%r10d
mov    0x50(%rsp),%eax
mov    %eax,%r11d
mov    0x54(%rsp),%eax
mov    %eax,%esi
mov    0x180(%rsp),%rdi
mov    0x178(%rsp),%rbp
mov    0xd0(%rsp),%eax
mov    0x170(%rsp),%rbx
mov    0xd4(%rsp),%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%r8
lea    (%r8,%rax,1),%edx
movslq %edx,%rdx
movsd  0x0(%r13,%rdx,8),%xmm1
movapd %xmm12,%xmm4
subsd  %xmm1,%xmm4
movapd %xmm11,%xmm6
subsd  %xmm1,%xmm6
lea    (%r8,%r11,1),%edx
movslq %edx,%rdx
movsd  0x0(%r13,%rdx,8),%xmm2
movapd %xmm2,%xmm5
subsd  %xmm1,%xmm5
subsd  %xmm4,%xmm5
mulsd  %xmm6,%xmm4
addsd  %xmm13,%xmm4
lea    (%r8,%rbp,1),%edx
movslq %edx,%rdx
divsd  0x0(%r13,%rdx,8),%xmm4
lea    (%r8,%rdi,1),%edx
movslq %edx,%rdx
addsd  0x0(%r13,%rdx,8),%xmm4
subsd  %xmm6,%xmm5
lea    (%r8,%rsi,1),%edx
movslq %edx,%rdx
movapd %xmm4,%xmm3
andpd  %xmm10,%xmm3
movsd  0x0(%r13,%rdx,8),%xmm6
movapd %xmm6,%xmm0
unpcklpd %xmm5,%xmm6
andpd  %xmm10,%xmm5
addsd  %xmm3,%xmm5
andpd  %xmm10,%xmm0
addsd  %xmm5,%xmm0
divsd  %xmm0,%xmm4
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
mov    0x60(%rsp),%edx
add    %r10d,%edx
je     19f0 <hqr+0x8c0>
lea    (%r8,%rbx,1),%edx
movslq %edx,%rdx
movapd %xmm6,%xmm0
movapd 0x16cb(%rip),%xmm5
andpd  %xmm5,%xmm0
pshufd $0xee,%xmm0,%xmm3
addpd  %xmm0,%xmm3
movsd  0x0(%r13,%rdx,8),%xmm0
unpcklpd %xmm4,%xmm0
andpd  %xmm5,%xmm0
movhpd 0x16c7(%rip),%xmm3
mulpd  %xmm0,%xmm3
lea    (%r8,%rcx,1),%edx
movslq %edx,%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
andpd  %xmm5,%xmm0
andpd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
andpd  %xmm5,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
mulsd  %xmm2,%xmm1
add    $0xffffffff,%r14d
ucomisd %xmm3,%xmm1
jae    19c1 <hqr+0x891>
lea    0x1(%r9),%r8
mov    0x5c(%rsp),%edx
add    %edx,%ecx
add    %edx,%ebx
add    %edx,%eax
add    %edx,%ebp
add    %edx,%edi
add    $0xffffffff,%r10d
add    %edx,%esi
add    %edx,%r11d
cmp    0x1b8(%rsp),%r9
mov    %r8,%r9
jl     1870 <hqr+0x740>
mov    0x10(%rsp),%r8
mov    %r14,%rbp
add    %r8d,%ebp
mov    0x24(%rsp),%r14d
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%rbx
mov    0x88(%rsp),%r11
mov    0x4(%rsp),%r10d
jmp    1a0f <hqr+0x8df>
nopw   0x0(%rax,%rax,1)
mov    0x4(%rsp),%r10d
mov    %r10d,%ebp
mov    0x24(%rsp),%r14d
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%rbx
mov    0x88(%rsp),%r11
lea    0x2(%rbp),%eax
cmp    %r8d,%eax
jg     1ad0 <hqr+0x9a0>
movslq %eax,%rcx
lea    -0x3(%rcx),%rdx
imul   0x40(%rsp),%rdx
add    %rcx,%rdx
movq   $0x0,-0x8(%r13,%rdx,8)
lea    0x1(%rcx),%rax
cmp    %eax,%r11d
je     1ad0 <hqr+0x9a0>
mov    %r8d,%esi
sub    %ebp,%esi
test   $0x1,%sil
je     1a72 <hqr+0x942>
lea    -0x2(%rcx),%rax
imul   0x40(%rsp),%rax
add    %rcx,%rax
movq   $0x0,0x0(%r13,%rax,8)
movq   $0x0,0x0(%r13,%rdx,8)
add    $0x2,%rcx
mov    %rcx,%rax
cmp    %ebp,0xc8(%rsp)
je     1ad0 <hqr+0x9a0>
lea    -0x3(%rax),%rcx
imul   %r9,%rcx
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
lea    -0x2(%rax),%rsi
imul   %r9,%rsi
lea    -0x4(%rax),%rdi
imul   %r9,%rdi
xchg   %ax,%ax
movq   $0x0,-0x8(%rdx,%rcx,1)
movq   $0x0,-0x8(%rdx,%rdi,1)
movq   $0x0,(%rdx,%rsi,1)
movq   $0x0,(%rdx,%rcx,1)
add    $0x2,%rax
add    %rbx,%rdx
cmp    %eax,%r11d
jne    1aa0 <hqr+0x970>
xchg   %ax,%ax
addl   $0x1,0x58(%rsp)
cmp    %ebp,%r8d
jle    1577 <hqr+0x447>
mov    %rbp,0x100(%rsp)
movslq %ebp,%rdi
movslq %r10d,%rax
lea    -0x1(%rdi),%rdx
lea    -0x2(%rdi),%rcx
mov    0x40(%rsp),%rsi
imul   %rsi,%rcx
add    %rdi,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x1b0(%rsp)
mov    %rsi,%rcx
mov    %rdx,0x108(%rsp)
imul   %rdx,%rcx
lea    (%rcx,%rdi,1),%rdx
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
mov    %rdx,0xe0(%rsp)
add    %rax,%rcx
mov    0x168(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
mov    %rsi,%rcx
imul   %rdi,%rcx
add    %rax,%rcx
lea    (%rdx,%rcx,8),%r14
lea    0x1(%rdi),%rcx
imul   %rsi,%rcx
add    %rax,%rcx
lea    (%rdx,%rcx,8),%rbp
mov    $0x1,%eax
sub    %r10d,%eax
mov    %eax,0xd8(%rsp)
mov    %rdi,0x130(%rsp)
mov    %rdi,%r13
jmp    1c0d <hqr+0xadd>
nopl   (%rax)
movapd 0x110(%rsp),%xmm9
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%r9
xorpd  %xmm8,%xmm8
movapd 0x146e(%rip),%xmm14
movapd 0x1455(%rip),%xmm10
movapd 0x60(%rsp),%xmm6
movapd 0xa0(%rsp),%xmm4
mov    0x88(%rsp),%r11
movapd 0x90(%rsp),%xmm12
add    $0x1,%r13
unpcklpd %xmm12,%xmm6
unpckhpd %xmm12,%xmm12
addq   $0x1,0x108(%rsp)
mov    0xe0(%rsp),%rax
add    0x1c0(%rsp),%rax
mov    %rax,0xe0(%rsp)
add    %r9,%rbx
add    %r9,%r14
add    %r9,%rbp
cmp    %r13d,%r8d
je     1560 <hqr+0x430>
cmp    0x130(%rsp),%r13
je     1caf <hqr+0xb7f>
lea    -0x2(%r13),%rax
imul   0x40(%rsp),%rax
add    %r13,%rax
lea    -0x2(%r13),%ecx
imul   0x30(%rsp),%ecx
movslq %ecx,%rcx
add    %r13,%rcx
xorpd  %xmm6,%xmm6
cmp    %r12,%r13
je     1c4b <hqr+0xb1b>
mov    0x48(%rsp),%rdx
movsd  0x8(%rdx,%rax,8),%xmm6
mov    0x48(%rsp),%rdx
movsd  -0x8(%rdx,%rax,8),%xmm4
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm4,%xmm1
andpd  %xmm10,%xmm1
movapd %xmm0,%xmm2
andpd  %xmm10,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm6,%xmm12
andpd  %xmm10,%xmm12
addsd  %xmm2,%xmm12
ucomisd %xmm8,%xmm12
jne    1c98 <hqr+0xb68>
jp     1c98 <hqr+0xb68>
unpcklpd %xmm12,%xmm0
movapd %xmm0,%xmm12
jmp    1bcc <hqr+0xa9c>
divsd  %xmm12,%xmm4
unpcklpd %xmm0,%xmm6
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
divpd  %xmm0,%xmm6
movapd %xmm6,%xmm2
unpckhpd %xmm6,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm4,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
movapd %xmm6,0x60(%rsp)
movapd %xmm4,0xa0(%rsp)
movapd %xmm12,0x90(%rsp)
movapd %xmm2,0x120(%rsp)
jb     1d10 <hqr+0xbe0>
sqrtsd %xmm0,%xmm0
jmp    1d1e <hqr+0xbee>
cs nopw 0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
movapd 0xa0(%rsp),%xmm4
movapd %xmm4,%xmm1
mov    $0x2,%al
call   1040 <sign@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmp    0x130(%rsp),%r13
jne    1da0 <hqr+0xc70>
mov    0x4(%rsp),%eax
cmp    0x100(%rsp),%eax
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rdx
movapd 0x12b8(%rip),%xmm10
movapd 0x60(%rsp),%xmm8
movapd 0xa0(%rsp),%xmm2
movapd 0x120(%rsp),%xmm4
je     1dfa <hqr+0xcca>
mov    0x48(%rsp),%rax
mov    0x1b0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
xorpd  %xmm10,%xmm1
movlpd %xmm1,(%rax,%rcx,8)
jmp    1dfa <hqr+0xcca>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,%xmm1
movapd 0x1263(%rip),%xmm10
xorpd  %xmm10,%xmm1
movapd 0x90(%rsp),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x2(%r13),%rax
imul   0x40(%rsp),%rax
add    %r13,%rax
mov    0x48(%rsp),%rcx
movsd  %xmm2,-0x8(%rcx,%rax,8)
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rdx
movapd 0x60(%rsp),%xmm8
movapd 0xa0(%rsp),%xmm2
movapd 0x120(%rsp),%xmm4
addsd  %xmm0,%xmm2
movapd %xmm4,%xmm5
divsd  %xmm0,%xmm5
movapd %xmm8,%xmm9
divsd  %xmm0,%xmm9
unpcklpd %xmm2,%xmm4
divsd  %xmm2,%xmm8
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm4
movapd %xmm4,%xmm7
unpckhpd %xmm4,%xmm7
mov    0xe0(%rsp),%rax
mov    0x108(%rsp),%rcx
jmp    1e9b <hqr+0xd6b>
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm2
movapd %xmm8,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm6
movapd %xmm6,%xmm1
xorpd  %xmm10,%xmm1
movapd %xmm6,%xmm3
mulsd  %xmm9,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rax)
movapd %xmm1,%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rax)
mulsd  %xmm7,%xmm1
addsd  -0x8(%rax),%xmm1
movsd  %xmm1,-0x8(%rax)
add    $0x1,%rcx
add    %rdx,%rax
cmp    %r15,%rcx
jge    1ec0 <hqr+0xd90>
movsd  (%rax),%xmm0
movapd %xmm4,%xmm6
mulsd  %xmm0,%xmm6
addsd  -0x8(%rax),%xmm6
cmp    %r12,%r13
jne    1e40 <hqr+0xd10>
movapd %xmm6,%xmm1
xorpd  %xmm10,%xmm1
jmp    1e71 <hqr+0xd41>
nopl   0x0(%rax)
movapd %xmm7,0x1d0(%rsp)
movsd  %xmm9,0x1c8(%rsp)
movsd  %xmm5,0x120(%rsp)
movapd %xmm4,0x90(%rsp)
movapd %xmm6,0xa0(%rsp)
movapd %xmm8,0x60(%rsp)
lea    0x3(%r13),%esi
xor    %eax,%eax
call   1030 <imin@plt>
mov    0x4(%rsp),%r10d
cmp    %eax,%r10d
jg     1b80 <hqr+0xa50>
add    0xd8(%rsp),%eax
xor    %ecx,%ecx
movapd 0x110(%rsp),%xmm9
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%r9
xorpd  %xmm8,%xmm8
movapd 0x10d7(%rip),%xmm14
movapd 0x10be(%rip),%xmm10
movapd 0x60(%rsp),%xmm6
mov    0x88(%rsp),%r11
movapd 0x90(%rsp),%xmm12
movsd  0x120(%rsp),%xmm3
movsd  0x1c8(%rsp),%xmm5
movapd 0x1d0(%rsp),%xmm7
jmp    1fdc <hqr+0xeac>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm5,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm4
movapd %xmm4,%xmm1
xorpd  %xmm14,%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm6,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm12,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
subsd  %xmm4,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%eax
je     1bcc <hqr+0xa9c>
movsd  (%r14,%rcx,8),%xmm0
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rbx,%rcx,8),%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm1,%xmm4
cmp    %r12,%r13
jne    1f80 <hqr+0xe50>
movapd %xmm4,%xmm1
xorpd  %xmm14,%xmm1
jmp    1fb3 <hqr+0xe83>
nopw   0x0(%rax,%rax,1)
subsd  %xmm12,%xmm11
movapd %xmm11,%xmm4
mulsd  0x1016(%rip),%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm13,%xmm1
movapd %xmm1,%xmm0
andpd  0xfc5(%rip),%xmm0
ucomisd %xmm8,%xmm0
movapd %xmm6,0x60(%rsp)
movapd %xmm4,0xa0(%rsp)
movapd %xmm13,0x130(%rsp)
movapd %xmm1,0xe0(%rsp)
jb     2070 <hqr+0xf40>
sqrtsd %xmm0,%xmm0
jmp    20b3 <hqr+0xf83>
nopw   0x0(%rax,%rax,1)
movapd %xmm12,0x90(%rsp)
call   1050 <sqrt@plt>
movapd 0xe0(%rsp),%xmm1
movapd 0x90(%rsp),%xmm12
movapd 0xa0(%rsp),%xmm4
movapd 0xf6c(%rip),%xmm14
xorpd  %xmm8,%xmm8
movapd 0x110(%rsp),%xmm9
mov    0xb8(%rsp),%r12
mov    0xc0(%rsp),%r15
addsd  0x78(%rsp),%xmm12
ucomisd %xmm1,%xmm8
jbe    2120 <hqr+0xff0>
addsd  %xmm4,%xmm12
lea    (%r15,%r15,1),%eax
cltq
movsd  %xmm12,(%r12,%rax,8)
mov    0x38(%rsp),%r8
lea    (%r8,%r8,1),%eax
movslq %eax,%rcx
movsd  %xmm12,(%r12,%rcx,8)
lea    0x1(%r15,%r15,1),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%r12,%rcx,8)
xorpd  %xmm14,%xmm0
mov    0x8(%rsp),%r9
movapd 0xeeb(%rip),%xmm10
movapd 0x60(%rsp),%xmm6
jmp    13fd <hqr+0x2cd>
movapd %xmm4,%xmm1
mov    $0x2,%al
movapd %xmm12,0x90(%rsp)
call   1040 <sign@plt>
movapd 0x90(%rsp),%xmm2
movapd 0xa0(%rsp),%xmm4
xorpd  %xmm8,%xmm8
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm4,%xmm0
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
lea    (%r15,%r15,1),%ecx
movslq %ecx,%rax
movsd  %xmm1,(%r12,%rax,8)
mov    0x38(%rsp),%rax
add    %eax,%eax
ucomisd %xmm8,%xmm0
jne    217c <hqr+0x104c>
jnp    2191 <hqr+0x1061>
movapd 0x130(%rsp),%xmm1
divsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movapd %xmm2,%xmm1
movslq %eax,%rdx
movsd  %xmm1,(%r12,%rdx,8)
or     $0x1,%ecx
movslq %ecx,%rcx
movq   $0x0,(%r12,%rcx,8)
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r8
movapd 0x110(%rsp),%xmm9
mov    0x8(%rsp),%r9
movapd 0xe47(%rip),%xmm14
movapd 0xe2e(%rip),%xmm10
movapd 0x60(%rsp),%xmm6
movapd 0xe0(%rsp),%xmm1
jmp    13fd <hqr+0x2cd>
mov    0x140(%rsp),%rax
mov    %r8d,(%rax)
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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