int Hqr2(n, low, high, h, wr, wi, z)
int n, low, high;
double **h, *wr, *wi, **z;
{
  int i, j, k, l, m, na, en, notlas, mp2, itn, its, enm2, twoRoots;
  double norm, p, q, r, s, t, w, x, y, ra, sa, vi, vr, zz, tst1, tst2;
  p = q = r = s = w = y = zz = 0.0;
  norm = 0.0;
  k = 0;
  for (i = 0; i < n; i++) {
    for (j = k; j < n; j++)
      norm += fabs(h[i][j]);
    k = i;
    if ((i < low) || (i > high)) {
      wr[i] = h[i][i];
      wi[i] = 0.0;
    }
  }
  en = high;
  t = 0.0;
  itn = n * 30;
  while (en >= low) {
    its = 0;
    na = en - 1;
    enm2 = na - 1;
    twoRoots = 0;
    for (;;) {
      for (l = en; l > low; l--) {
        s = fabs(h[l - 1][l - 1]) + fabs(h[l][l]);
        if (fabs(s) < (1E-30))
          s = norm;
        tst1 = s;
        tst2 = tst1 + fabs(h[l][l - 1]);
        if (fabs(tst2 - tst1) < (1E-30))
          break;
      }
      x = h[en][en];
      if (l == en)
        break;
      y = h[na][na];
      w = h[en][na] * h[na][en];
      if (l == na) {
        twoRoots = 1;
        break;
      }
      if (itn == 0) {
        printf(
            "Error in Hqr2.  Eigenvalues have not converged.  Returning en=%i",
            en);
        return en;
      }
      if ((its == 10) || (its == 20)) {
        t += x;
        for (i = low; i <= en; i++)
          h[i][i] -= x;
        s = fabs(h[en][na]) + fabs(h[na][enm2]);
        x = s * 0.75;
        y = x;
        w = s * -0.4375 * s;
      }
      its++;
      --itn;
      for (m = enm2; m >= l; m--) {
        zz = h[m][m];
        r = x - zz;
        s = y - zz;
        p = (r * s - w) / h[m + 1][m] + h[m][m + 1];
        q = h[m + 1][m + 1] - zz - r - s;
        r = h[m + 2][m + 1];
        s = fabs(p) + fabs(q) + fabs(r);
        p /= s;
        q /= s;
        r /= s;
        if (m == l)
          break;
        tst1 = fabs(p) *
               (fabs(h[m - 1][m - 1]) + fabs(zz) + fabs(h[m + 1][m + 1]));
        tst2 = tst1 + fabs(h[m][m - 1]) * (fabs(q) + fabs(r));
        if (fabs(tst2 - tst1) < (1E-30))
          break;
      }
      mp2 = m + 2;
      for (i = mp2; i <= en; i++) {
        h[i][i - 2] = 0.0;
        if (i != mp2)
          h[i][i - 3] = 0.0;
      }
      for (k = m; k <= na; k++) {
        notlas = (k != na);
        if (k != m) {
          p = h[k][k - 1];
          q = h[k + 1][k - 1];
          r = 0.0;
          if (notlas)
            r = h[k + 2][k - 1];
          x = fabs(p) + fabs(q) + fabs(r);
          if (x < (1E-30))
            continue;
          p /= x;
          q /= x;
          r /= x;
        }
        s = D_sign(sqrt(p * p + q * q + r * r), p);
        if (k != m)
          h[k][k - 1] = -s * x;
        else if (l != m)
          h[k][k - 1] = -h[k][k - 1];
        p += s;
        x = p / s;
        y = q / s;
        zz = r / s;
        q /= p;
        r /= p;
        if (!notlas) {
          for (j = k; j < n; j++) {
            p = h[k][j] + q * h[k + 1][j];
            h[k][j] -= p * x;
            h[k + 1][j] -= p * y;
          }
          j = (((en) < (k + 3)) ? (en) : (k + 3));
          for (i = 0; i <= j; i++) {
            p = x * h[i][k] + y * h[i][k + 1];
            h[i][k] -= p;
            h[i][k + 1] -= p * q;
          }
          for (i = low; i <= high; i++) {
            p = x * z[i][k] + y * z[i][k + 1];
            z[i][k] -= p;
            z[i][k + 1] -= p * q;
          }
        } else {
          for (j = k; j < n; j++) {
            p = h[k][j] + q * h[k + 1][j] + r * h[k + 2][j];
            h[k][j] -= p * x;
            h[k + 1][j] -= p * y;
            h[k + 2][j] -= p * zz;
          }
          j = (((en) < (k + 3)) ? (en) : (k + 3));
          for (i = 0; i <= j; i++) {
            p = x * h[i][k] + y * h[i][k + 1] + zz * h[i][k + 2];
            h[i][k] -= p;
            h[i][k + 1] -= p * q;
            h[i][k + 2] -= p * r;
          }
          for (i = low; i <= high; i++) {
            p = x * z[i][k] + y * z[i][k + 1] + zz * z[i][k + 2];
            z[i][k] -= p;
            z[i][k + 1] -= p * q;
            z[i][k + 2] -= p * r;
          }
        }
      }
    }
    if (twoRoots) {
      p = (y - x) / 2.0;
      q = p * p + w;
      zz = sqrt(fabs(q));
      h[en][en] = x + t;
      x = h[en][en];
      h[na][na] = y + t;
      if (q >= -1e-12) {
        zz = p + D_sign(zz, p);
        wr[na] = x + zz;
        wr[en] = wr[na];
        if (fabs(zz) > (1E-30))
          wr[en] = x - w / zz;
        wi[na] = 0.0;
        wi[en] = 0.0;
        x = h[en][na];
        s = fabs(x) + fabs(zz);
        p = x / s;
        q = zz / s;
        r = sqrt(p * p + q * q);
        p /= r;
        q /= r;
        for (j = na; j < n; j++) {
          zz = h[na][j];
          h[na][j] = q * zz + p * h[en][j];
          h[en][j] = q * h[en][j] - p * zz;
        }
        for (i = 0; i <= en; i++) {
          zz = h[i][na];
          h[i][na] = q * zz + p * h[i][en];
          h[i][en] = q * h[i][en] - p * zz;
        }
        for (i = low; i <= high; i++) {
          zz = z[i][na];
          z[i][na] = q * zz + p * z[i][en];
          z[i][en] = q * z[i][en] - p * zz;
        }
      } else {
        wr[na] = x + p;
        wr[en] = x + p;
        wi[na] = zz;
        wi[en] = -zz;
      }
      en = enm2;
    } else {
      h[en][en] = x + t;
      wr[en] = h[en][en];
      wi[en] = 0.0;
      en = na;
    }
  }
  if (fabs(norm) < (1E-30))
    return 0;
  for (en = n - 1; en >= 0; en--) {
    p = wr[en];
    q = wi[en];
    na = en - 1;
    if (q < -1e-12) {
      m = na;
      if (fabs(h[en][na]) > fabs(h[na][en])) {
        h[na][na] = q / h[en][na];
        h[na][en] = -(h[en][en] - p) / h[en][na];
      } else
        CDiv(0.0, -h[na][en], h[na][na] - p, q, &h[na][na], &h[na][en]);
      h[en][na] = 0.0;
      h[en][en] = 1.0;
      enm2 = na - 1;
      if (enm2 >= 0) {
        for (i = enm2; i >= 0; i--) {
          w = h[i][i] - p;
          ra = 0.0;
          sa = 0.0;
          for (j = m; j <= en; j++) {
            ra += h[i][j] * h[j][na];
            sa += h[i][j] * h[j][en];
          }
          if (wi[i] < 0.0) {
            zz = w;
            r = ra;
            s = sa;
          } else {
            m = i;
            if (fabs(wi[i]) < (1E-30))
              CDiv(-ra, -sa, w, q, &h[i][na], &h[i][en]);
            else {
              x = h[i][i + 1];
              y = h[i + 1][i];
              vr = (wr[i] - p) * (wr[i] - p) + wi[i] * wi[i] - q * q;
              vi = (wr[i] - p) * 2.0 * q;
              if ((fabs(vr) < (1E-30)) && (fabs(vi) < (1E-30))) {
                tst1 =
                    norm * (fabs(w) + fabs(q) + fabs(x) + fabs(y) + fabs(zz));
                vr = tst1;
                do {
                  vr *= .01;
                  tst2 = tst1 + vr;
                } while (tst2 > tst1);
              }
              CDiv(x * r - zz * ra + q * sa, x * s - zz * sa - q * ra, vr, vi,
                   &h[i][na], &h[i][en]);
              if (fabs(x) > fabs(zz) + fabs(q)) {
                h[i + 1][na] = (-ra - w * h[i][na] + q * h[i][en]) / x;
                h[i + 1][en] = (-sa - w * h[i][en] - q * h[i][na]) / x;
              } else
                CDiv(-r - y * h[i][na], -s - y * h[i][en], zz, q, &h[i + 1][na],
                     &h[i + 1][en]);
            }
            tst1 = fabs(h[i][na]);
            tst2 = fabs(h[i][en]);
            t = (((tst1) > (tst2)) ? (tst1) : (tst2));
            if (t > (1E-30)) {
              tst1 = t;
              tst2 = tst1 + 1.0 / tst1;
              if (tst2 <= tst1) {
                for (j = i; j <= en; j++) {
                  h[j][na] /= t;
                  h[j][en] /= t;
                }
              }
            }
          }
        }
      }
    } else if (fabs(q) < (1E-30)) {
      m = en;
      h[en][en] = 1.0;
      if (na >= 0) {
        for (i = na; i >= 0; i--) {
          w = h[i][i] - p;
          r = 0.0;
          for (j = m; j <= en; j++)
            r += h[i][j] * h[j][en];
          if (wi[i] < 0.0) {
            zz = w;
            s = r;
            continue;
          } else {
            m = i;
            if (fabs(wi[i]) < (1E-30)) {
              t = w;
              if (fabs(t) < (1E-30)) {
                tst1 = norm;
                t = tst1;
                do {
                  t *= .01;
                  tst2 = norm + t;
                } while (tst2 > tst1);
              }
              h[i][en] = -r / t;
            } else {
              x = h[i][i + 1];
              y = h[i + 1][i];
              q = (wr[i] - p) * (wr[i] - p) + wi[i] * wi[i];
              t = (x * s - zz * r) / q;
              h[i][en] = t;
              if (fabs(x) > fabs(zz))
                h[i + 1][en] = (-r - w * t) / x;
              else
                h[i + 1][en] = (-s - y * t) / zz;
            }
            t = fabs(h[i][en]);
            if (t > (1E-30)) {
              tst1 = t;
              tst2 = tst1 + 1. / tst1;
              if (tst2 <= tst1) {
                for (j = i; j <= en; j++)
                  h[j][en] /= t;
              }
            }
          }
        }
      }
    }
  }
  for (i = 0; i < n; i++) {
    if ((i < low) || (i > high)) {
      for (j = i; j < n; j++)
        z[i][j] = h[i][j];
    }
  }
  for (j = n - 1; j >= low; j--) {
    m = (((j) < (high)) ? (j) : (high));
    for (i = low; i <= high; i++) {
      zz = 0.0;
      for (k = low; k <= m; k++)
        zz += z[i][k] * h[k][j];
      z[i][j] = zz;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<Hqr2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1277 <Hqr2+0x137>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1214 <Hqr2+0xd4>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2e48(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d0 <Hqr2+0x90>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1232 <Hqr2+0xf2>
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    1264 <Hqr2+0x124>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1269 <Hqr2+0x129>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11be <Hqr2+0x7e>
mov    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
imul   $0x1e,-0x8(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     28f9 <Hqr2+0x17b9>
movl   $0x0,-0x54(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    13e3 <Hqr2+0x2a3>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2d4d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x2d2d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movaps 0x2d0e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2cc2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1355 <Hqr2+0x215>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x2cb2(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
subsd  -0xd8(%rbp),%xmm1
ff
movaps 0x2c8b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2c3f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13d0 <Hqr2+0x290>
jmp    13e3 <Hqr2+0x2a3>
jmp    13d5 <Hqr2+0x295>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    12c1 <Hqr2+0x181>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jne    1411 <Hqr2+0x2d1>
jmp    22f5 <Hqr2+0x11b5>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    1478 <Hqr2+0x338>
movl   $0x1,-0x5c(%rbp)
jmp    22f5 <Hqr2+0x11b5>
cmpl   $0x0,-0x50(%rbp)
jne    149e <Hqr2+0x35e>
mov    -0x44(%rbp),%esi
lea    0x2bc4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3b30 <Hqr2+0x29f0>
cmpl   $0xa,-0x54(%rbp)
je     14b2 <Hqr2+0x372>
cmpl   $0x14,-0x54(%rbp)
jne    15a4 <Hqr2+0x464>
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1510 <Hqr2+0x3d0>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d0 <Hqr2+0x390>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2b14(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x2af4(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x2acc(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x2a9c(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jl     18a0 <Hqr2+0x760>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x98(%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
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xd0(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movaps 0x2958(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
movaps 0x2948(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
movaps 0x2934(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    176f <Hqr2+0x62f>
jmp    18a0 <Hqr2+0x760>
movsd  -0x70(%rbp),%xmm0
movaps 0x28c5(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x289b(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0xd0(%rbp),%xmm2
ff
movaps 0x2888(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x285a(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x281d(%rip),%xmm2
pand   %xmm2,%xmm0
movsd  -0x78(%rbp),%xmm2
movaps 0x280d(%rip),%xmm3
pand   %xmm3,%xmm2
movsd  -0x80(%rbp),%xmm3
movaps 0x27fd(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
subsd  -0xd8(%rbp),%xmm1
ff
movaps 0x27ce(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2782(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    188d <Hqr2+0x74d>
jmp    18a0 <Hqr2+0x760>
jmp    1892 <Hqr2+0x752>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    15bc <Hqr2+0x47c>
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1914 <Hqr2+0x7d4>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1901 <Hqr2+0x7c1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1906 <Hqr2+0x7c6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18af <Hqr2+0x76f>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     22f0 <Hqr2+0x11b0>
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1a59 <Hqr2+0x919>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     19bc <Hqr2+0x87c>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movaps 0x2678(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
movaps 0x2668(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
movaps 0x2654(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x25fc(%rip),%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1a17 <Hqr2+0x8d7>
jmp    22e2 <Hqr2+0x11a2>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  -0x70(%rbp),%xmm1
mov    $0x2,%al
call   1040 <D_sign@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1af6 <Hqr2+0x9b6>
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b52 <Hqr2+0xa12>
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1b4d <Hqr2+0xa0d>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b52 <Hqr2+0xa12>
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0x48(%rbp)
jne    1ead <Hqr2+0xd6d>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1cc5 <Hqr2+0xb85>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bd9 <Hqr2+0xa99>
mov    -0x44(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1ce4 <Hqr2+0xba4>
mov    -0x44(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    1cf0 <Hqr2+0xbb0>
mov    -0x34(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1dd1 <Hqr2+0xc91>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d00 <Hqr2+0xbc0>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1ea8 <Hqr2+0xd68>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1dd7 <Hqr2+0xc97>
jmp    22dd <Hqr2+0x119d>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2011 <Hqr2+0xed1>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1eb3 <Hqr2+0xd73>
mov    -0x44(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    2030 <Hqr2+0xef0>
mov    -0x44(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    203c <Hqr2+0xefc>
mov    -0x34(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     218f <Hqr2+0x104f>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    204c <Hqr2+0xf0c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     22d8 <Hqr2+0x1198>
movsd  -0xa0(%rbp),%xmm1
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2195 <Hqr2+0x1055>
jmp    22dd <Hqr2+0x119d>
jmp    22e2 <Hqr2+0x11a2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    191a <Hqr2+0x7da>
jmp    12bb <Hqr2+0x17b>
cmpl   $0x0,-0x5c(%rbp)
je     2897 <Hqr2+0x1757>
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0x1d09(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movaps 0x1cf5(%rip),%xmm1
pand   %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  0x1c38(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     2817 <Hqr2+0x16d7>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
mov    $0x2,%al
call   1040 <D_sign@plt>
movsd  -0xf0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
movaps 0x1be7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1b9b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2498 <Hqr2+0x1358>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
divsd  -0xd0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0x1b5c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
movaps 0x1b49(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2659 <Hqr2+0x1519>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0xd0(%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
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2583 <Hqr2+0x1443>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2736 <Hqr2+0x15f6>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0xd0(%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
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2660 <Hqr2+0x1520>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     2812 <Hqr2+0x16d2>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    273c <Hqr2+0x15fc>
jmp    288c <Hqr2+0x174c>
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    28f4 <Hqr2+0x17b4>
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    128f <Hqr2+0x14f>
movsd  -0x68(%rbp),%xmm1
movaps 0x173b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x16ef(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2927 <Hqr2+0x17e7>
movl   $0x0,-0x4(%rbp)
jmp    3b30 <Hqr2+0x29f0>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     399e <Hqr2+0x285e>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
movsd  0x1699(%rip),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    3453 <Hqr2+0x2313>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x16a4(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1684(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    2a59 <Hqr2+0x1919>
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2adc <Hqr2+0x199c>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
xorps  %xmm0,%xmm0
mov    $0x4,%al
call   1050 <CDiv@plt>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  0x1504(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
jl     344e <Hqr2+0x230e>
mov    -0x58(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     3449 <Hqr2+0x2309>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2c10 <Hqr2+0x1ad0>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2b72 <Hqr2+0x1a32>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    2c58 <Hqr2+0x1b18>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
jmp    3436 <Hqr2+0x22f6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x13ce(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1382(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2d0d <Hqr2+0x1bcd>
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x4,%al
call   1050 <CDiv@plt>
jmp    32b8 <Hqr2+0x2178>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x70(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x70(%rbp),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  0x123e(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movaps 0x123e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x11f2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2f15 <Hqr2+0x1dd5>
movsd  -0xc0(%rbp),%xmm1
ff
movaps 0x1219(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x11cd(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2f15 <Hqr2+0x1dd5>
movsd  -0x68(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
movaps 0x11ef(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x78(%rbp),%xmm2
movaps 0x11df(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0xa0(%rbp),%xmm2
ff
movaps 0x11c8(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0xa8(%rbp),%xmm2
ff
movaps 0x11b1(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0xd0(%rbp),%xmm2
ff
movaps 0x119a(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x1146(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
ja     2eca <Hqr2+0x1d8a>
jmp    2f15 <Hqr2+0x1dd5>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x78(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm3
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x4,%al
call   1050 <CDiv@plt>
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0x101b(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
movaps 0x1008(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x78(%rbp),%xmm2
movaps 0xff8(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    31b4 <Hqr2+0x2074>
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    32b3 <Hqr2+0x2173>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x4,%al
call   1050 <CDiv@plt>
jmp    32b8 <Hqr2+0x2178>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd6c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd44(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    3333 <Hqr2+0x21f3>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    3343 <Hqr2+0x2203>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  0xc9d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    3431 <Hqr2+0x22f1>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  0xc83(%rip),%xmm1
divsd  -0xd8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     342c <Hqr2+0x22ec>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3427 <Hqr2+0x22e7>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    33c1 <Hqr2+0x2281>
jmp    342c <Hqr2+0x22ec>
jmp    3431 <Hqr2+0x22f1>
jmp    3436 <Hqr2+0x22f6>
jmp    343b <Hqr2+0x22fb>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    2b2a <Hqr2+0x19ea>
jmp    344e <Hqr2+0x230e>
jmp    398b <Hqr2+0x284b>
movsd  -0x78(%rbp),%xmm1
movaps 0xbe1(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xb95(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    3986 <Hqr2+0x2846>
mov    -0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  0xb7d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x40(%rbp)
jl     3981 <Hqr2+0x2841>
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     397c <Hqr2+0x283c>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3538 <Hqr2+0x23f8>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    34e2 <Hqr2+0x23a2>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    3570 <Hqr2+0x2430>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    396e <Hqr2+0x282e>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xab6(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xa6a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    3678 <Hqr2+0x2538>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movaps 0xa81(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xa35(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    363a <Hqr2+0x24fa>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xa1e(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
ja     35f2 <Hqr2+0x24b2>
jmp    363a <Hqr2+0x24fa>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    3884 <Hqr2+0x2744>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x70(%rbp),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0x8c4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
movaps 0x8b1(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    380f <Hqr2+0x26cf>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    387f <Hqr2+0x273f>
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xd0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    3884 <Hqr2+0x2744>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x7a0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  0x744(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    3964 <Hqr2+0x2824>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  0x72a(%rip),%xmm1
divsd  -0xd8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     395f <Hqr2+0x281f>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     395a <Hqr2+0x281a>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    391a <Hqr2+0x27da>
jmp    395f <Hqr2+0x281f>
jmp    3964 <Hqr2+0x2824>
jmp    3969 <Hqr2+0x2829>
jmp    396e <Hqr2+0x282e>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    34a8 <Hqr2+0x2368>
jmp    3981 <Hqr2+0x2841>
jmp    3986 <Hqr2+0x2846>
jmp    398b <Hqr2+0x284b>
jmp    3990 <Hqr2+0x2850>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    2930 <Hqr2+0x17f0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3a2b <Hqr2+0x28eb>
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     39c9 <Hqr2+0x2889>
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    3a18 <Hqr2+0x28d8>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3a13 <Hqr2+0x28d3>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    39cf <Hqr2+0x288f>
jmp    3a18 <Hqr2+0x28d8>
jmp    3a1d <Hqr2+0x28dd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    39a5 <Hqr2+0x2865>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     3b29 <Hqr2+0x29e9>
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    3a5a <Hqr2+0x291a>
mov    -0x30(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    3a63 <Hqr2+0x2923>
mov    -0x10(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     3b16 <Hqr2+0x29d6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     3aeb <Hqr2+0x29ab>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3a8f <Hqr2+0x294f>
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    3a72 <Hqr2+0x2932>
jmp    3b1b <Hqr2+0x29db>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    3a34 <Hqr2+0x28f4>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Hqr2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
mov    %r9,0x40(%rsp)
mov    %r8,0x20(%rsp)
mov    %rcx,%r14
mov    %esi,0x8(%rsp)
xorpd  %xmm10,%xmm10
mov    %edi,%eax
xorpd  %xmm9,%xmm9
test   %edi,%edi
jle    128f <Hqr2+0x14f>
movslq %edx,%r8
movslq 0x8(%rsp),%r9
xor    %r10d,%r10d
xorpd  %xmm9,%xmm9
movapd 0x2e72(%rip),%xmm0
movapd 0x2e6a(%rip),%xmm1
xor    %ecx,%ecx
jmp    11d5 <Hqr2+0x95>
nopw   0x0(%rax,%rax,1)
mov    (%r14,%r10,8),%rsi
movsd  (%rsi,%r10,8),%xmm2
mov    0x20(%rsp),%rcx
movsd  %xmm2,(%rcx,%r10,8)
mov    0x40(%rsp),%rcx
movq   $0x0,(%rcx,%r10,8)
mov    %r10d,%ecx
lea    0x1(%r10),%rsi
mov    %rsi,%r10
cmp    %rax,%rsi
je     128f <Hqr2+0x14f>
cmp    %edi,%ecx
jge    1278 <Hqr2+0x138>
mov    (%r14,%r10,8),%rsi
mov    %ecx,%ebp
mov    %eax,%ebx
sub    %ecx,%ebx
mov    %rbp,%rcx
not    %rcx
add    %rax,%rcx
and    $0x3,%rbx
je     1218 <Hqr2+0xd8>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm2
andpd  %xmm1,%xmm2
addsd  %xmm2,%xmm9
add    $0x1,%rbp
add    $0xffffffffffffffff,%rbx
jne    1200 <Hqr2+0xc0>
cmp    $0x3,%rcx
jb     1278 <Hqr2+0x138>
movapd %xmm9,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rbp,8),%xmm3
movsd  0x8(%rsi,%rbp,8),%xmm4
movsd  0x10(%rsi,%rbp,8),%xmm5
movsd  0x18(%rsi,%rbp,8),%xmm9
andpd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
andpd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
andpd  %xmm0,%xmm9
addsd  %xmm5,%xmm9
add    $0x4,%rbp
movapd %xmm9,%xmm2
cmp    %rbp,%rax
jne    1230 <Hqr2+0xf0>
cmp    %r9,%r10
jl     11a0 <Hqr2+0x60>
cmp    %r8,%r10
jle    11c2 <Hqr2+0x82>
jmp    11a0 <Hqr2+0x60>
mov    %rax,0xf0(%rsp)
mov    0x210(%rsp),%rax
mov    %edx,%ebx
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
mov    0x8(%rsp),%r12d
sub    %r12d,%ebx
mov    %rdx,0x110(%rsp)
movapd %xmm9,0xe0(%rsp)
jge    1d12 <Hqr2+0xbd2>
movapd 0x2d2d(%rip),%xmm0
andpd  %xmm9,%xmm0
xor    %eax,%eax
movsd  0x2d3d(%rip),%xmm15
ucomisd %xmm0,%xmm15
ja     3401 <Hqr2+0x22c1>
mov    %rdi,0x28(%rsp)
test   %edi,%edi
mov    0xf0(%rsp),%rdi
jle    32ac <Hqr2+0x216c>
mov    0x28(%rsp),%rcx
lea    -0x2(%rcx),%eax
movslq %eax,%rdx
lea    -0x3(%rcx),%eax
movslq %eax,%r12
lea    -0x1(%rdi),%r13
movslq %ecx,%r9
xorpd  %xmm0,%xmm0
movhpd 0x2d29(%rip),%xmm0
movapd %xmm0,0x160(%rsp)
movapd 0x2cc7(%rip),%xmm8
xorpd  %xmm6,%xmm6
movsd  0x2d02(%rip),%xmm13
jmp    1387 <Hqr2+0x247>
nopl   0x0(%rax,%rax,1)
movapd %xmm12,%xmm2
mov    0x128(%rsp),%rdx
add    $0xffffffffffffffff,%rdx
mov    0x120(%rsp),%r12
add    $0xffffffffffffffff,%r12
add    $0xffffffffffffffff,%r9
movapd %xmm2,%xmm12
test   %rbp,%rbp
mov    0xf0(%rsp),%rdi
jle    3089 <Hqr2+0x1f49>
mov    %r13,%rbp
mov    0x20(%rsp),%rax
movsd  (%rax,%r13,8),%xmm14
mov    0x40(%rsp),%rax
movsd  (%rax,%r13,8),%xmm4
add    $0xffffffffffffffff,%r13
movsd  0x2c94(%rip),%xmm0
ucomisd %xmm4,%xmm0
mov    %rdx,0x128(%rsp)
mov    %r12,0x120(%rsp)
jbe    1440 <Hqr2+0x300>
mov    (%r14,%rbp,8),%rax
movsd  (%rax,%r13,8),%xmm0
movapd %xmm0,%xmm2
movapd 0x2c24(%rip),%xmm5
andpd  %xmm5,%xmm2
mov    (%r14,%r13,8),%rcx
movsd  (%rcx,%rbp,8),%xmm1
movapd %xmm1,%xmm3
andpd  %xmm5,%xmm3
ucomisd %xmm3,%xmm2
mov    %r9,0xd0(%rsp)
movsd  %xmm14,0x50(%rsp)
movapd %xmm4,0x10(%rsp)
jbe    16c0 <Hqr2+0x580>
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%r13,8)
movsd  (%rax,%rbp,8),%xmm0
subsd  %xmm14,%xmm0
xorpd  0x2be0(%rip),%xmm0
divsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
jmp    1762 <Hqr2+0x622>
andpd  %xmm8,%xmm4
ucomisd %xmm4,%xmm15
jbe    1350 <Hqr2+0x210>
mov    (%r14,%rbp,8),%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rax,%rbp,8)
test   %rbp,%rbp
je     3089 <Hqr2+0x1f49>
mov    %edx,%eax
xor    %ecx,%ecx
mov    %ebp,%r8d
jmp    14a2 <Hqr2+0x362>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%esi
mov    %eax,%r8d
movapd %xmm12,%xmm2
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rax
add    $0x1,%ecx
movapd %xmm2,%xmm12
test   %esi,%esi
jle    1355 <Hqr2+0x215>
mov    (%r14,%rax,8),%rsi
movslq %r8d,%rbx
xorpd  %xmm10,%xmm10
cmp    %rbx,%rbp
jl     14de <Hqr2+0x39e>
add    $0xffffffffffffffff,%rbx
xorpd  %xmm10,%xmm10
nopl   0x0(%rax)
movsd  0x8(%rsi,%rbx,8),%xmm0
mov    0x8(%r14,%rbx,8),%rdi
mulsd  (%rdi,%rbp,8),%xmm0
addsd  %xmm0,%xmm10
add    $0x1,%rbx
cmp    %rbp,%rbx
jl     14c0 <Hqr2+0x380>
movsd  (%rsi,%rax,8),%xmm2
subsd  %xmm14,%xmm2
mov    0x40(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm4
ucomisd %xmm4,%xmm6
jbe    1510 <Hqr2+0x3d0>
mov    %eax,%esi
movapd %xmm10,%xmm11
jmp    148a <Hqr2+0x34a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
andpd  %xmm8,%xmm0
ucomisd %xmm0,%xmm15
jbe    1570 <Hqr2+0x430>
movapd %xmm2,%xmm0
andpd  %xmm8,%xmm0
ucomisd %xmm0,%xmm15
jbe    1555 <Hqr2+0x415>
movapd %xmm9,%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  %xmm13,%xmm2
movapd %xmm9,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm9,%xmm0
ja     1540 <Hqr2+0x400>
movapd %xmm10,%xmm0
xorpd  0x2aae(%rip),%xmm0
divsd  %xmm2,%xmm0
mov    %rsi,%rdi
jmp    1610 <Hqr2+0x4d0>
xchg   %ax,%ax
lea    0x1(%rdx),%edi
movsd  (%rsi,%rdi,8),%xmm1
mov    (%r14,%rdi,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
mov    0x20(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm3
subsd  %xmm14,%xmm3
mulsd  %xmm4,%xmm4
mulsd  %xmm3,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm10,%xmm4
mulsd  %xmm12,%xmm4
movapd %xmm1,%xmm6
mulsd  %xmm11,%xmm6
subsd  %xmm4,%xmm6
divsd  %xmm3,%xmm6
movsd  %xmm6,(%rsi,%rbp,8)
movapd %xmm1,%xmm3
movapd 0x2a38(%rip),%xmm5
andpd  %xmm5,%xmm3
movapd %xmm12,%xmm4
andpd  %xmm5,%xmm4
ucomisd %xmm4,%xmm3
jbe    15f6 <Hqr2+0x4b6>
xorpd  0x2a2d(%rip),%xmm2
mulsd  %xmm6,%xmm2
subsd  %xmm10,%xmm2
divsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
jmp    160c <Hqr2+0x4cc>
xorpd  0x2a12(%rip),%xmm0
mulsd  %xmm6,%xmm0
subsd  %xmm11,%xmm0
divsd  %xmm12,%xmm0
xorpd  %xmm6,%xmm6
movsd  %xmm0,(%rdi,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm0
andpd  %xmm8,%xmm0
ucomisd %xmm15,%xmm0
jbe    1480 <Hqr2+0x340>
movsd  0x2a1e(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm0
jb     1480 <Hqr2+0x340>
movslq %eax,%rsi
cmp    %rbp,%rsi
jg     1480 <Hqr2+0x340>
mov    %rdx,%rsi
test   $0x1,%cl
je     166e <Hqr2+0x52e>
mov    (%r14,%rdx,8),%rsi
movsd  (%rsi,%rbp,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
lea    0x1(%rdx),%rsi
cmp    $0xffffffff,%ecx
je     1480 <Hqr2+0x340>
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rsi,8),%rdi
movsd  (%rdi,%rbp,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
mov    0x8(%r14,%rsi,8),%rdi
movsd  (%rdi,%rbp,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
add    $0x2,%rsi
cmp    %esi,%r9d
jne    1680 <Hqr2+0x540>
jmp    1480 <Hqr2+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rbp,8),%rsi
xorpd  0x2944(%rip),%xmm1
lea    (%rcx,%r13,8),%rdi
movsd  (%rcx,%r13,8),%xmm2
subsd  %xmm14,%xmm2
xorpd  %xmm0,%xmm0
movapd %xmm4,%xmm3
mov    $0x4,%al
movapd %xmm10,0x90(%rsp)
movapd %xmm11,0x60(%rsp)
movapd %xmm12,0x80(%rsp)
call   1050 <CDiv@plt>
movapd 0x10(%rsp),%xmm4
movsd  0x50(%rsp),%xmm14
movsd  0x292d(%rip),%xmm13
xorpd  %xmm6,%xmm6
movapd 0x28d8(%rip),%xmm8
mov    0xd0(%rsp),%r9
movsd  0x28e7(%rip),%xmm15
movapd 0x80(%rsp),%xmm12
movapd 0x60(%rsp),%xmm11
movapd 0x90(%rsp),%xmm10
movapd 0xe0(%rsp),%xmm9
mov    (%r14,%rbp,8),%rax
movapd 0x160(%rsp),%xmm0
movupd %xmm0,(%rax,%r13,8)
cmp    $0x2,%rbp
jb     1350 <Hqr2+0x210>
mov    %r12d,%ebx
movapd %xmm4,%xmm0
xorpd  0x2886(%rip),%xmm0
movapd %xmm0,0x100(%rsp)
movapd %xmm4,%xmm0
andpd  %xmm8,%xmm0
movapd %xmm0,0x140(%rsp)
xor    %r15d,%r15d
mov    %r13d,%ecx
jmp    17da <Hqr2+0x69a>
nopl   (%rax)
movapd %xmm3,%xmm11
unpckhpd %xmm3,%xmm11
mov    %ebx,%eax
movapd %xmm3,%xmm10
add    $0xffffffffffffffff,%r12
add    $0xffffffffffffffff,%rbx
add    $0x1,%r15d
movapd %xmm2,%xmm12
test   %eax,%eax
jle    1355 <Hqr2+0x215>
mov    (%r14,%rbx,8),%rax
movslq %ecx,%rdx
xorpd  %xmm3,%xmm3
cmp    %rdx,%rbp
jl     1832 <Hqr2+0x6f2>
add    $0xffffffffffffffff,%rdx
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm1,%xmm0
mov    0x8(%r14,%rdx,8),%rsi
movupd (%rsi,%r13,8),%xmm1
movsd  0x8(%rax,%rdx,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm1,%xmm3
movapd %xmm3,%xmm1
addpd  %xmm0,%xmm1
add    $0x1,%rdx
cmp    %rbp,%rdx
jl     1800 <Hqr2+0x6c0>
addpd  %xmm0,%xmm3
movsd  (%rax,%rbx,8),%xmm2
subsd  %xmm14,%xmm2
mov    0x40(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm0
ucomisd %xmm0,%xmm6
ja     17b0 <Hqr2+0x670>
movapd %xmm0,%xmm1
andpd  %xmm8,%xmm1
ucomisd %xmm1,%xmm15
movapd %xmm3,%xmm7
unpckhpd %xmm3,%xmm7
movapd %xmm10,0x90(%rsp)
movapd %xmm11,0x60(%rsp)
movapd %xmm12,0x80(%rsp)
jbe    1910 <Hqr2+0x7d0>
movapd 0x2781(%rip),%xmm0
xorpd  %xmm0,%xmm3
xorpd  %xmm0,%xmm7
lea    (%rax,%r13,8),%rdi
lea    (%rax,%rbp,8),%rsi
movapd %xmm3,%xmm0
movapd %xmm7,%xmm1
movapd %xmm4,%xmm3
mov    $0x4,%al
call   1050 <CDiv@plt>
movapd 0x10(%rsp),%xmm4
movsd  0x50(%rsp),%xmm14
movsd  0x2780(%rip),%xmm13
xorpd  %xmm6,%xmm6
movdqa 0x272b(%rip),%xmm8
mov    0xd0(%rsp),%r9
movsd  0x273a(%rip),%xmm15
movapd 0x60(%rsp),%xmm11
movapd 0x90(%rsp),%xmm10
movapd 0xe0(%rsp),%xmm9
jmp    1c38 <Hqr2+0xaf8>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm3,0x30(%rsp)
movapd %xmm2,0xa0(%rsp)
lea    0x1(%r12),%edx
movsd  (%rax,%rdx,8),%xmm5
mov    (%r14,%rdx,8),%rcx
movsd  (%rcx,%rbx,8),%xmm1
movaps %xmm1,0xc0(%rsp)
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm3
subsd  %xmm14,%xmm3
mulsd  %xmm0,%xmm0
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd 0x100(%rsp),%xmm14
movapd %xmm14,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm3,%xmm3
mulsd  %xmm4,%xmm3
movapd %xmm2,%xmm0
movapd 0x267c(%rip),%xmm1
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm15
mov    %rdx,0xb0(%rsp)
jbe    1a1c <Hqr2+0x8dc>
movapd %xmm3,%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm15
jbe    1a1c <Hqr2+0x8dc>
movapd 0xa0(%rsp),%xmm0
andpd  %xmm8,%xmm0
addsd  0x140(%rsp),%xmm0
movapd %xmm12,%xmm2
unpcklpd %xmm5,%xmm2
andpd  %xmm8,%xmm2
pshufd $0xee,%xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd 0xc0(%rsp),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm2,%xmm8
addsd  %xmm2,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm0,%xmm2
nopl   0x0(%rax)
mulsd  %xmm13,%xmm2
movapd %xmm0,%xmm1
addsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
ja     1a00 <Hqr2+0x8c0>
movapd %xmm8,0x70(%rsp)
jmp    1a30 <Hqr2+0x8f0>
movapd %xmm12,%xmm0
unpcklpd %xmm5,%xmm0
andpd  %xmm8,%xmm0
movapd %xmm0,0x70(%rsp)
movapd %xmm5,0x180(%rsp)
movapd 0x30(%rsp),%xmm6
movapd %xmm6,%xmm0
mulsd  %xmm12,%xmm0
movapd %xmm5,%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm12,%xmm1
movapd %xmm5,%xmm4
mulsd  %xmm11,%xmm4
subsd  %xmm1,%xmm4
movapd %xmm14,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm4,%xmm1
lea    (%rax,%r13,8),%rdi
lea    (%rax,%rbp,8),%rsi
mov    $0x4,%al
movapd %xmm7,0x170(%rsp)
call   1050 <CDiv@plt>
movapd 0x140(%rsp),%xmm0
movapd 0x70(%rsp),%xmm1
addsd  %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    1b8c <Hqr2+0xa4c>
mov    (%r14,%rbx,8),%rax
movapd 0xa0(%rsp),%xmm2
xorpd  0x253e(%rip),%xmm2
movsd  (%rax,%r13,8),%xmm0
mulsd  %xmm2,%xmm0
subsd  0x30(%rsp),%xmm0
movsd  (%rax,%rbp,8),%xmm1
movapd 0x10(%rsp),%xmm4
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movapd 0x180(%rsp),%xmm3
divsd  %xmm3,%xmm1
mov    0xb0(%rsp),%rcx
mov    (%r14,%rcx,8),%rcx
movsd  %xmm1,(%rcx,%r13,8)
mulsd  (%rax,%rbp,8),%xmm2
subsd  0x170(%rsp),%xmm2
movsd  (%rax,%r13,8),%xmm0
mulsd  0x100(%rsp),%xmm0
addsd  %xmm2,%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
movapd 0xe0(%rsp),%xmm9
movapd 0x90(%rsp),%xmm10
movapd 0x60(%rsp),%xmm11
movsd  0x24be(%rip),%xmm15
mov    0xd0(%rsp),%r9
movdqa 0x248d(%rip),%xmm8
xorpd  %xmm6,%xmm6
movsd  0x24c8(%rip),%xmm13
movsd  0x50(%rsp),%xmm14
jmp    1c38 <Hqr2+0xaf8>
mov    (%r14,%rbx,8),%rax
movapd 0xc0(%rsp),%xmm1
xorpd  0x246f(%rip),%xmm1
movsd  (%rax,%r13,8),%xmm0
mulsd  %xmm1,%xmm0
subsd  0x90(%rsp),%xmm0
mulsd  (%rax,%rbp,8),%xmm1
subsd  0x60(%rsp),%xmm1
mov    0xb0(%rsp),%rax
mov    (%r14,%rax,8),%rax
lea    (%rax,%r13,8),%rdi
lea    (%rax,%rbp,8),%rsi
movapd 0x80(%rsp),%xmm2
movapd 0x10(%rsp),%xmm3
mov    $0x4,%al
call   1050 <CDiv@plt>
movapd 0xe0(%rsp),%xmm9
movapd 0x90(%rsp),%xmm10
movapd 0x60(%rsp),%xmm11
movsd  0x2413(%rip),%xmm15
mov    0xd0(%rsp),%r9
movdqa 0x23e2(%rip),%xmm8
xorpd  %xmm6,%xmm6
movsd  0x241d(%rip),%xmm13
movsd  0x50(%rsp),%xmm14
movapd 0x10(%rsp),%xmm4
mov    (%r14,%rbx,8),%rax
movdqu (%rax,%r13,8),%xmm0
pand   %xmm8,%xmm0
pshufd $0xee,%xmm0,%xmm1
maxsd  %xmm1,%xmm0
ucomisd %xmm15,%xmm0
jbe    1d00 <Hqr2+0xbc0>
movsd  0x23ed(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm0
jb     1d00 <Hqr2+0xbc0>
movslq %ebx,%rax
cmp    %rbp,%rax
movapd 0x80(%rsp),%xmm3
jg     1cf2 <Hqr2+0xbb2>
mov    %r12,%rax
test   $0x1,%r15b
jne    1cb0 <Hqr2+0xb70>
mov    (%r14,%r12,8),%rax
movupd (%rax,%r13,8),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,(%rax,%r13,8)
lea    0x1(%r12),%rax
cmp    $0xfffffffe,%r15d
je     1cf2 <Hqr2+0xbb2>
unpcklpd %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%r13,8)
mov    0x8(%r14,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%r13,8)
add    $0x2,%rax
cmp    %eax,%r9d
jne    1cc0 <Hqr2+0xb80>
mov    %ebx,%eax
mov    %ebx,%ecx
movapd %xmm3,%xmm2
jmp    17c1 <Hqr2+0x681>
nop
mov    %ebx,%eax
mov    %ebx,%ecx
movapd 0x80(%rsp),%xmm2
jmp    17c1 <Hqr2+0x681>
movslq %r12d,%rbp
mov    %edi,%ecx
shl    $0x5,%ecx
sub    %edi,%ecx
sub    %edi,%ecx
mov    %ecx,0x13c(%rsp)
mov    %rdi,0x28(%rsp)
movslq %edi,%r11
mov    $0x1,%ecx
sub    %r12d,%ecx
mov    %rcx,0x1a0(%rsp)
lea    0x10(%r14),%rcx
mov    %rcx,0x198(%rsp)
lea    0x18(%r14),%rcx
mov    %rcx,0x190(%rsp)
lea    (%rax,%rbp,8),%r13
add    $0x1,%ebx
xorpd  %xmm13,%xmm13
movapd 0x2296(%rip),%xmm14
movsd  0x22ad(%rip),%xmm15
xorpd  %xmm12,%xmm12
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xf8(%rsp)
xorpd  %xmm11,%xmm11
xorpd  %xmm6,%xmm6
mov    %edx,%esi
xorpd  %xmm10,%xmm10
mov    %rbp,0x118(%rsp)
mov    %r11,0xa0(%rsp)
mov    %rbx,0x120(%rsp)
nopl   (%rax)
lea    -0x1(%rsi),%eax
movslq %esi,%rcx
mov    %eax,0x170(%rsp)
movslq %eax,%r15
lea    0x3(%r15),%rdx
mov    %rcx,%rax
mov    %rcx,0x70(%rsp)
cmp    %rcx,%rdx
cmovg  %esi,%edx
mov    %esi,%eax
sub    %r12d,%eax
jle    2ae0 <Hqr2+0x19a0>
mov    %eax,0x138(%rsp)
mov    %rdx,0x128(%rsp)
lea    -0x2(%rsi),%eax
lea    0x1(%rsi),%r8d
mov    %eax,0x4c(%rsp)
movslq %eax,%rdx
mov    %r11,%rdi
sub    %r15,%rdi
mov    0x1a0(%rsp),%rax
add    %esi,%eax
lea    0x2(%rsi),%ecx
mov    %ecx,0x134(%rsp)
lea    -0x3(%rsi),%ecx
mov    %ecx,0x130(%rsp)
and    $0x3,%eax
mov    %eax,0xb8(%rsp)
mov    %rdi,0x160(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x100(%rsp)
lea    (%rdi,%r15,1),%rax
mov    %rax,0x1c8(%rsp)
mov    %r8d,0xbc(%rsp)
mov    %r8d,%eax
mov    %rax,0x150(%rsp)
mov    %r15d,%eax
mov    %rax,0x1a8(%rsp)
mov    %rdx,%rax
neg    %rax
mov    %rax,0x1c0(%rsp)
mov    0x198(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    %rax,0x1b8(%rsp)
mov    %rdx,0x158(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x1b0(%rsp)
xor    %r8d,%r8d
mov    %rsi,0xc0(%rsp)
jmp    1eca <Hqr2+0xd8a>
nopl   (%rax)
add    $0x1,%r8d
mov    0x8(%rsp),%r12d
cmp    %r12d,%esi
mov    0x118(%rsp),%rbp
jle    2ae0 <Hqr2+0x19a0>
mov    0x70(%rsp),%rdx
mov    (%r14,%rdx,8),%rax
movsd  (%rax,%rdx,8),%xmm7
movapd %xmm7,%xmm0
mov    %rax,%rcx
mov    %rdx,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm0,%xmm1
movsd  -0x8(%rcx,%rdi,8),%xmm2
mov    -0x8(%r14,%rdi,8),%rcx
movsd  -0x8(%rcx,%rdi,8),%xmm0
movapd %xmm0,%xmm3
andpd  %xmm14,%xmm3
andpd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm11
cmpltsd %xmm15,%xmm11
movapd %xmm11,%xmm3
andnpd %xmm1,%xmm3
andpd  %xmm9,%xmm11
orpd   %xmm3,%xmm11
andpd  %xmm14,%xmm2
addsd  %xmm11,%xmm2
subsd  %xmm11,%xmm2
andpd  %xmm14,%xmm2
ucomisd %xmm2,%xmm15
ja     1f5c <Hqr2+0xe1c>
add    $0xffffffffffffffff,%rdi
cmp    %rbp,%rdi
jg     1ef0 <Hqr2+0xdb0>
mov    %r12d,%edi
cmp    %esi,%edi
je     2b33 <Hqr2+0x19f3>
mov    (%r14,%r15,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%rax,%r15,8),%xmm0
mov    0x70(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm8
mulsd  %xmm0,%xmm8
cmp    %r15d,%edi
je     2b3a <Hqr2+0x19fa>
subl   $0x1,0x13c(%rsp)
01
jb     306e <Hqr2+0x1f2e>
cmp    $0x14,%r8d
mov    %rdi,0x140(%rsp)
je     1fb9 <Hqr2+0xe79>
cmp    $0xa,%r8d
jne    20f0 <Hqr2+0xfb0>
cmp    %r12d,%esi
mov    0x100(%rsp),%r12
jl     2087 <Hqr2+0xf47>
mov    %rbp,%rdx
cmpl   $0x0,0xb8(%rsp)
je     200b <Hqr2+0xecb>
mov    0xb8(%rsp),%ebp
mov    0x118(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rdx,8),%rdi
movsd  (%rdi,%rdx,8),%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffff,%ebp
jne    1ff0 <Hqr2+0xeb0>
cmpl   $0x3,0x138(%rsp)
03
mov    0x150(%rsp),%rbp
jb     2079 <Hqr2+0xf39>
nopl   (%rax)
mov    (%r14,%rdx,8),%rdi
movsd  (%rdi,%rdx,8),%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
mov    0x8(%r14,%rdx,8),%rdi
movsd  0x8(%rdi,%rdx,8),%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,0x8(%rdi,%rdx,8)
mov    0x10(%r14,%rdx,8),%rdi
movsd  0x10(%rdi,%rdx,8),%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,0x10(%rdi,%rdx,8)
mov    0x18(%r14,%rdx,8),%rdi
movsd  0x18(%rdi,%rdx,8),%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,0x18(%rdi,%rdx,8)
add    $0x4,%rdx
cmp    %edx,%ebp
jne    2020 <Hqr2+0xee0>
movsd  (%rax,%r15,8),%xmm0
mov    0x140(%rsp),%rdi
movsd  0xf8(%rsp),%xmm1
addsd  %xmm7,%xmm1
movsd  %xmm1,0xf8(%rsp)
andpd  %xmm14,%xmm0
mov    0x158(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm11
andpd  %xmm14,%xmm11
addsd  %xmm0,%xmm11
movapd %xmm11,%xmm7
mulsd  0x1f61(%rip),%xmm7
movapd %xmm11,%xmm8
mulsd  0x1f5b(%rip),%xmm8
mulsd  %xmm11,%xmm8
movsd  %xmm7,0x10(%rsp)
jmp    20f8 <Hqr2+0xfb8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x100(%rsp),%r12
mov    0x4c(%rsp),%eax
mov    %eax,%r10d
cmp    %edi,%eax
jl     227b <Hqr2+0x113b>
xorpd  0x1f00(%rip),%xmm8
movslq %edi,%rax
add    0x1c0(%rsp),%rax
mov    0x158(%rsp),%rdx
mov    (%r14,%rdx,8),%rcx
movsd  (%rcx,%rdx,8),%xmm1
xor    %r10d,%r10d
mov    0x1b8(%rsp),%rdi
mov    0x1b0(%rsp),%rbp
nop
movapd %xmm1,%xmm12
movapd %xmm7,%xmm6
subsd  %xmm1,%xmm6
movsd  0x10(%rsp),%xmm2
subsd  %xmm1,%xmm2
mov    -0x8(%rdi,%r10,8),%rdx
add    %rbp,%rdx
movsd  0x8(%rdx,%r10,8),%xmm0
movapd %xmm0,%xmm10
subsd  %xmm1,%xmm10
subsd  %xmm6,%xmm10
mulsd  %xmm2,%xmm6
addsd  %xmm8,%xmm6
divsd  (%rdx,%r10,8),%xmm6
add    %rbp,%rcx
addsd  0x8(%rcx,%r10,8),%xmm6
subsd  %xmm2,%xmm10
mov    (%rdi,%r10,8),%rdx
add    %rbp,%rdx
movapd %xmm6,%xmm1
andpd  %xmm14,%xmm1
movapd %xmm10,%xmm2
andpd  %xmm14,%xmm2
addsd  %xmm1,%xmm2
movsd  0x8(%rdx,%r10,8),%xmm1
unpcklpd %xmm1,%xmm10
movapd %xmm1,%xmm11
andpd  %xmm14,%xmm11
addsd  %xmm2,%xmm11
divsd  %xmm11,%xmm6
movapd %xmm11,%xmm1
unpcklpd %xmm11,%xmm1
divpd  %xmm1,%xmm10
cmp    %r10,%rax
je     2270 <Hqr2+0x1130>
movsd  -0x8(%rcx,%r10,8),%xmm2
mov    -0x18(%rdi,%r10,8),%rcx
lea    (%rcx,%rbp,1),%rdx
movsd  -0x8(%rdx,%r10,8),%xmm1
movapd %xmm1,%xmm3
movapd 0x1df4(%rip),%xmm5
andpd  %xmm5,%xmm3
movapd %xmm12,%xmm4
andpd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm6,%xmm3
andpd  %xmm5,%xmm3
andpd  %xmm5,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
andpd  %xmm5,%xmm2
movapd %xmm10,%xmm3
andpd  %xmm5,%xmm3
pshufd $0xee,%xmm3,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm0,%xmm4
subsd  %xmm0,%xmm4
andpd  %xmm5,%xmm4
add    $0xffffffffffffffff,%r10
ucomisd %xmm4,%xmm15
jbe    2140 <Hqr2+0x1000>
add    0x1a8(%rsp),%r10d
jmp    227b <Hqr2+0x113b>
mov    0x140(%rsp),%rax
mov    %eax,%r10d
lea    0x2(%r10),%eax
cmp    %esi,%eax
jg     2350 <Hqr2+0x1210>
cltq
mov    (%r14,%rax,8),%rcx
movq   $0x0,-0x10(%rcx,%rax,8)
add    $0x1,%rax
cmp    %eax,0xbc(%rsp)
je     2350 <Hqr2+0x1210>
mov    0x134(%rsp),%edx
sub    %r10d,%edx
mov    0x130(%rsp),%ecx
sub    %r10d,%ecx
and    $0x3,%edx
je     22d4 <Hqr2+0x1194>
mov    (%r14,%rax,8),%rdi
movupd %xmm13,-0x18(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    22c0 <Hqr2+0x1180>
cmp    $0x3,%ecx
jb     2350 <Hqr2+0x1210>
mov    0xbc(%rsp),%ecx
sub    %eax,%ecx
mov    0x190(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
shl    $0x3,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x18(%rdx,%rbp,8),%rdi
add    %rax,%rdi
movupd %xmm13,-0x18(%rdi,%rbp,8)
mov    -0x10(%rdx,%rbp,8),%rdi
add    %rax,%rdi
movupd %xmm13,-0x10(%rdi,%rbp,8)
mov    -0x8(%rdx,%rbp,8),%rdi
add    %rax,%rdi
movupd %xmm13,-0x8(%rdi,%rbp,8)
mov    (%rdx,%rbp,8),%rdi
add    %rax,%rdi
movupd %xmm13,(%rdi,%rbp,8)
add    $0x4,%rbp
cmp    %ebp,%ecx
jne    2300 <Hqr2+0x11c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %esi,%r10d
jge    1eb0 <Hqr2+0xd70>
movslq %r10d,%rbp
mov    %r11,%rdx
sub    %rbp,%rdx
xor    %edi,%edi
mov    %rbp,%rax
mov    %rbp,0x10(%rsp)
mov    %r8d,0xb0(%rsp)
mov    %r10,0x180(%rsp)
jmp    2394 <Hqr2+0x1254>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
cmp    %ebp,%esi
je     1eb0 <Hqr2+0xd70>
cmp    0x10(%rsp),%rbp
je     2402 <Hqr2+0x12c2>
xorpd  %xmm7,%xmm7
cmp    %r15,%rbp
je     23af <Hqr2+0x126f>
mov    0x10(%r14,%rbp,8),%rax
movsd  -0x8(%rax,%rbp,8),%xmm7
mov    (%r14,%rbp,8),%rax
mov    0x8(%r14,%rbp,8),%rcx
movsd  -0x8(%rax,%rbp,8),%xmm6
movsd  -0x8(%rcx,%rbp,8),%xmm10
movapd %xmm6,%xmm0
andpd  %xmm14,%xmm0
movapd %xmm10,%xmm1
andpd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
unpcklpd %xmm7,%xmm10
andpd  %xmm14,%xmm7
addsd  %xmm1,%xmm7
ucomisd %xmm7,%xmm15
ja     2380 <Hqr2+0x1240>
divsd  %xmm7,%xmm6
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
divpd  %xmm0,%xmm10
movapd %xmm7,0x50(%rsp)
movapd %xmm10,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm10,%xmm2
unpckhpd %xmm10,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x1c1c(%rip),%xmm0
movapd %xmm10,0x90(%rsp)
movapd %xmm2,0x80(%rsp)
movapd %xmm6,0x30(%rsp)
mov    %rdx,0xd0(%rsp)
mov    %rdi,0x60(%rsp)
jb     2470 <Hqr2+0x1330>
sqrtsd %xmm0,%xmm0
jmp    247b <Hqr2+0x133b>
nopw   0x0(%rax,%rax,1)
call   1060 <sqrt@plt>
movapd 0x30(%rsp),%xmm6
movapd %xmm6,%xmm1
mov    $0x2,%al
call   1040 <D_sign@plt>
xorps  %xmm11,%xmm11
cvtsi2sd %eax,%xmm11
cmp    0x10(%rsp),%rbp
jne    2510 <Hqr2+0x13d0>
mov    0x180(%rsp),%r10
cmp    %r10d,0x140(%rsp)
movapd 0xe0(%rsp),%xmm9
movapd 0x90(%rsp),%xmm10
movapd 0x80(%rsp),%xmm12
mov    0xa0(%rsp),%r11
xorpd  %xmm13,%xmm13
movapd 0x1b26(%rip),%xmm14
movsd  0x1b3d(%rip),%xmm15
je     256e <Hqr2+0x142e>
mov    0x10(%rsp),%rcx
mov    (%r14,%rcx,8),%rax
movsd  -0x8(%rax,%rcx,8),%xmm0
xorpd  0x1b10(%rip),%xmm0
movlpd %xmm0,-0x8(%rax,%rcx,8)
jmp    256e <Hqr2+0x142e>
nopl   0x0(%rax,%rax,1)
movapd %xmm11,%xmm0
xorpd  0x1af3(%rip),%xmm0
movapd 0x50(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mov    (%r14,%rbp,8),%rax
movsd  %xmm1,-0x8(%rax,%rbp,8)
movapd 0xe0(%rsp),%xmm9
movapd 0x90(%rsp),%xmm10
movapd 0x80(%rsp),%xmm12
mov    0xa0(%rsp),%r11
xorpd  %xmm13,%xmm13
movapd 0x1a9b(%rip),%xmm14
movsd  0x1ab2(%rip),%xmm15
movapd 0x30(%rsp),%xmm1
addsd  %xmm11,%xmm1
movapd %xmm1,%xmm7
divsd  %xmm11,%xmm7
movapd %xmm10,%xmm0
divsd  %xmm11,%xmm0
divsd  %xmm11,%xmm12
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm10
cmp    %r15,%rbp
jne    2790 <Hqr2+0x1650>
mov    0x170(%rsp),%eax
cmp    0x28(%rsp),%eax
mov    0xb0(%rsp),%r8d
jge    26af <Hqr2+0x156f>
mov    (%r14,%r15,8),%rax
mov    0x8(%r14,%r15,8),%rcx
mov    %r15,%rdi
cmpq   $0x2,0x160(%rsp)
jb     2670 <Hqr2+0x1530>
lea    (%rax,%r15,8),%rdx
lea    (%rcx,%r15,8),%rsi
lea    (%rcx,%r11,8),%rdi
cmp    %rdi,%rdx
jae    25fc <Hqr2+0x14bc>
lea    (%rax,%r11,8),%r9
mov    %r15,%rdi
cmp    %r9,%rsi
mov    0x100(%rsp),%r12
jb     2670 <Hqr2+0x1530>
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
movapd %xmm7,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rdi,8),%xmm4
movupd (%rsi,%rdi,8),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm5,%xmm6
mulpd  %xmm2,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,(%rdx,%rdi,8)
movupd (%rsi,%rdi,8),%xmm4
mulpd  %xmm3,%xmm5
subpd  %xmm5,%xmm4
movupd %xmm4,(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r12
jne    2620 <Hqr2+0x14e0>
mov    0x1c8(%rsp),%rdi
cmp    %r12,0x160(%rsp)
je     26af <Hqr2+0x156f>
movsd  (%rax,%rdi,8),%xmm1
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm7,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    $0x1,%rdi
cmp    %r11,%rdi
jl     2670 <Hqr2+0x1530>
mov    0x128(%rsp),%rdx
test   %edx,%edx
js     2719 <Hqr2+0x15d9>
mov    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%r14,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm1
movsd  0x8(%rcx,%r15,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%r15,8)
mulsd  %xmm10,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%rcx,%r15,8)
add    $0x1,%rax
cmp    %rdx,%rax
jb     26d0 <Hqr2+0x1590>
xor    %eax,%eax
mov    0xc0(%rsp),%rsi
mov    0x60(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm1
movsd  0x8(%rcx,%r15,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm7,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm3,%xmm6
subsd  %xmm6,%xmm1
movsd  %xmm1,(%rcx,%r15,8)
movapd %xmm6,%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rcx,%r15,8)
add    $0x1,%rax
cmp    %eax,%ebx
jne    2730 <Hqr2+0x15f0>
mov    0xd0(%rsp),%rdx
jmp    2380 <Hqr2+0x1240>
nopl   0x0(%rax)
cmp    %r11,%rbp
jge    2843 <Hqr2+0x1703>
mov    0x10(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %rcx,%rax
mov    %r11,%rdi
sub    %rax,%rdi
mov    (%r14,%rbp,8),%rax
mov    0x8(%r14,%rbp,8),%rcx
mov    0x10(%r14,%rbp,8),%rdx
movapd %xmm10,%xmm1
unpckhpd %xmm10,%xmm1
mov    %rbp,%rsi
cmp    $0x2,%rdi
jae    2957 <Hqr2+0x1817>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm2
movsd  (%rcx,%rsi,8),%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm2,%xmm3
movsd  (%rdx,%rsi,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm4,%xmm3
mulsd  %xmm7,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rax,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm2
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm2
mulsd  %xmm12,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %r11,%rsi
jl     27e0 <Hqr2+0x16a0>
lea    0x3(%rbp),%rax
cmp    0x70(%rsp),%rax
mov    0xc0(%rsp),%rsi
cmovg  %esi,%eax
test   %eax,%eax
js     28ca <Hqr2+0x178a>
mov    %eax,%eax
mov    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%r14,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
movupd 0x8(%rdx,%rbp,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
mulsd  %xmm12,%xmm3
addsd  %xmm4,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
unpcklpd %xmm3,%xmm3
mulpd  %xmm10,%xmm3
subpd  %xmm3,%xmm2
movupd %xmm2,0x8(%rdx,%rbp,8)
add    $0x1,%rcx
cmp    %rax,%rcx
jb     2870 <Hqr2+0x1730>
xor    %eax,%eax
mov    0xb0(%rsp),%r8d
mov    0x120(%rsp),%rbx
nopl   0x0(%rax)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm1
movupd 0x8(%rcx,%rbp,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm2,%xmm6
unpckhpd %xmm2,%xmm6
mulsd  %xmm12,%xmm6
addsd  %xmm4,%xmm6
subsd  %xmm6,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
mulpd  %xmm10,%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%ebx
jne    28e0 <Hqr2+0x17a0>
mov    0x100(%rsp),%r12
mov    0xd0(%rsp),%rdx
mov    0x60(%rsp),%rdi
jmp    2380 <Hqr2+0x1240>
lea    (%rax,%rbp,8),%r9
mov    %rdi,0x1d0(%rsp)
lea    (%rax,%r11,8),%r8
lea    (%rcx,%rbp,8),%r12
lea    (%rcx,%r11,8),%r10
lea    (%rdx,%rbp,8),%rdi
mov    0xa0(%rsp),%rsi
lea    (%rdx,%rsi,8),%r11
cmp    %r10,%r9
setb   0x30(%rsp)
cmp    %r8,%r12
setb   0x90(%rsp)
cmp    %r11,%r9
setb   0x80(%rsp)
cmp    %r8,%rdi
setb   0x50(%rsp)
cmp    %r11,%r12
mov    0xa0(%rsp),%r11
setb   0xf(%rsp)
cmp    %r10,%rdi
setb   0xe(%rsp)
mov    %rbp,%rsi
mov    0x90(%rsp),%r8b
test   %r8b,0x30(%rsp)
jne    27e0 <Hqr2+0x16a0>
mov    %rbp,%rsi
mov    0x50(%rsp),%bl
and    %bl,0x80(%rsp)
jne    27e0 <Hqr2+0x16a0>
mov    %rbp,%rsi
mov    0xe(%rsp),%r8b
and    %r8b,0xf(%rsp)
jne    27e0 <Hqr2+0x16a0>
mov    0xd0(%rsp),%r10
and    $0xfffffffffffffffe,%r10
mov    0x1d0(%rsp),%r8
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x30(%rsp)
add    %rbp,%rsi
movapd %xmm10,%xmm8
unpcklpd %xmm10,%xmm8
movapd %xmm7,0x50(%rsp)
movapd %xmm7,%xmm3
unpcklpd %xmm7,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
movapd %xmm12,%xmm5
unpcklpd %xmm12,%xmm5
xor    %r11d,%r11d
nopw   0x0(%rax,%rax,1)
movupd (%r9,%r11,8),%xmm6
movupd (%r12,%r11,8),%xmm7
mulpd  %xmm8,%xmm7
addpd  %xmm6,%xmm7
movupd (%rdi,%r11,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm7,%xmm2
movapd %xmm2,%xmm7
mulpd  %xmm3,%xmm7
subpd  %xmm7,%xmm6
movupd %xmm6,(%r9,%r11,8)
movupd (%r12,%r11,8),%xmm6
movapd %xmm2,%xmm7
mulpd  %xmm4,%xmm7
subpd  %xmm7,%xmm6
movupd %xmm6,(%r12,%r11,8)
movupd (%rdi,%r11,8),%xmm6
mulpd  %xmm5,%xmm2
subpd  %xmm2,%xmm6
movupd %xmm6,(%rdi,%r11,8)
add    $0x2,%r11
cmp    %r11,%r10
jne    2a50 <Hqr2+0x1910>
cmp    0x30(%rsp),%r8
mov    0xa0(%rsp),%r11
movapd 0x50(%rsp),%xmm7
jne    27e0 <Hqr2+0x16a0>
jmp    2843 <Hqr2+0x1703>
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rcx
mov    (%r14,%rcx,8),%rax
movsd  (%rax,%rcx,8),%xmm7
addsd  0xf8(%rsp),%xmm7
movsd  %xmm7,(%rax,%rcx,8)
mov    0x20(%rsp),%rax
movsd  %xmm7,(%rax,%rcx,8)
xorpd  %xmm0,%xmm0
mov    0x170(%rsp),%eax
mov    %eax,0x4c(%rsp)
mov    0x40(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4c(%rsp),%eax
mov    %eax,%esi
cmp    %r12d,%eax
jge    1db0 <Hqr2+0xc70>
jmp    3413 <Hqr2+0x22d3>
mov    0x70(%rsp),%rcx
jmp    2aee <Hqr2+0x19ae>
movsd  0x10(%rsp),%xmm6
subsd  %xmm7,%xmm6
mulsd  0x14ec(%rip),%xmm6
movapd %xmm6,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm8,%xmm2
movapd %xmm2,%xmm0
andpd  0x149b(%rip),%xmm0
ucomisd 0x14eb(%rip),%xmm0
movapd %xmm6,0x30(%rsp)
movapd %xmm8,0x80(%rsp)
jb     2b86 <Hqr2+0x1a46>
sqrtsd %xmm0,%xmm12
jmp    2bdf <Hqr2+0x1a9f>
movapd %xmm10,0x90(%rsp)
movapd %xmm11,0x60(%rsp)
movapd %xmm7,0x50(%rsp)
movapd %xmm2,0xd0(%rsp)
call   1060 <sqrt@plt>
movapd 0xd0(%rsp),%xmm2
movapd 0x50(%rsp),%xmm7
movapd 0x30(%rsp),%xmm6
movapd 0x1437(%rip),%xmm14
movapd 0x60(%rsp),%xmm11
movapd 0x90(%rsp),%xmm10
movapd %xmm0,%xmm12
mov    0x70(%rsp),%rcx
movsd  0xf8(%rsp),%xmm0
addsd  %xmm0,%xmm7
mov    (%r14,%rcx,8),%rax
movsd  %xmm7,(%rax,%rcx,8)
movsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    (%r14,%r15,8),%rax
movsd  %xmm1,(%rax,%r15,8)
ucomisd 0x142a(%rip),%xmm2
jae    2c6e <Hqr2+0x1b2e>
addsd  %xmm6,%xmm7
mov    0x20(%rsp),%rax
movsd  %xmm7,(%rax,%r15,8)
movsd  %xmm7,(%rax,%rcx,8)
mov    0x40(%rsp),%rax
movsd  %xmm12,(%rax,%r15,8)
movapd %xmm12,%xmm0
xorpd  0x13cc(%rip),%xmm0
movsd  %xmm2,%xmm10
movapd 0xe0(%rsp),%xmm9
mov    0xa0(%rsp),%r11
xorpd  %xmm13,%xmm13
movsd  0x13b7(%rip),%xmm15
jmp    2b15 <Hqr2+0x19d5>
movapd %xmm12,%xmm0
movapd %xmm6,%xmm1
mov    $0x2,%al
movapd %xmm7,0x50(%rsp)
call   1040 <D_sign@plt>
movapd 0x50(%rsp),%xmm1
xorps  %xmm7,%xmm7
cvtsi2sd %eax,%xmm7
addsd  0x30(%rsp),%xmm7
movapd %xmm1,%xmm0
addsd  %xmm7,%xmm0
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
movapd %xmm7,%xmm11
andpd  0x1348(%rip),%xmm11
movsd  0x135f(%rip),%xmm15
ucomisd %xmm15,%xmm11
jbe    2cdd <Hqr2+0x1b9d>
movapd 0x80(%rsp),%xmm0
divsd  %xmm7,%xmm0
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    0x20(%rsp),%rax
mov    0x70(%rsp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rsp),%rax
movq   $0x0,(%rax,%r15,8)
movq   $0x0,(%rax,%rcx,8)
mov    (%r14,%rcx,8),%rax
movsd  (%rax,%r15,8),%xmm6
movapd %xmm6,%xmm0
andpd  0x12e9(%rip),%xmm0
addsd  %xmm0,%xmm11
divsd  %xmm11,%xmm6
divsd  %xmm11,%xmm7
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x1316(%rip),%xmm0
jb     2d4a <Hqr2+0x1c0a>
sqrtsd %xmm0,%xmm0
jmp    2d7e <Hqr2+0x1c3e>
movapd %xmm11,0x60(%rsp)
movapd %xmm6,0x30(%rsp)
movapd %xmm7,0x10(%rsp)
call   1060 <sqrt@plt>
movapd 0x10(%rsp),%xmm7
movapd 0x30(%rsp),%xmm6
movsd  0x12a9(%rip),%xmm15
movapd 0x60(%rsp),%xmm11
mov    0xc0(%rsp),%rdi
movapd 0xe0(%rsp),%xmm9
mov    0xa0(%rsp),%r11
xorpd  %xmm13,%xmm13
movapd 0x125a(%rip),%xmm14
divsd  %xmm0,%xmm6
divsd  %xmm0,%xmm7
cmp    0x28(%rsp),%edi
jg     2f9f <Hqr2+0x1e5f>
mov    (%r14,%r15,8),%r10
mov    0x70(%rsp),%rcx
mov    (%r14,%rcx,8),%rcx
movapd %xmm6,%xmm1
xorpd  0x123f(%rip),%xmm1
mov    0x28(%rsp),%r9
mov    %r15,%rdx
sub    %edi,%r9d
je     2f50 <Hqr2+0x1e10>
lea    (%r10,%r15,8),%rsi
lea    (%r9,%r15,1),%rdx
lea    (%rcx,%rdx,8),%rdi
add    $0x8,%rdi
cmp    %rdi,%rsi
jae    2e0f <Hqr2+0x1ccf>
lea    (%r10,%rdx,8),%rsi
add    $0x8,%rsi
lea    (%rcx,%r15,8),%rdi
mov    %r15,%rdx
cmp    %rsi,%rdi
jb     2f50 <Hqr2+0x1e10>
add    $0x1,%r9
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
movapd %xmm6,%xmm10
movapd %xmm6,%xmm4
unpcklpd %xmm6,%xmm4
movapd %xmm7,%xmm12
movapd %xmm7,%xmm3
unpcklpd %xmm7,%xmm3
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
lea    -0x2(%rdx),%rsi
mov    %rsi,%r8
shr    %r8
add    $0x1,%r8
test   %rsi,%rsi
je     2eea <Hqr2+0x1daa>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rcx,%r15,8),%rax
add    $0x10,%rax
lea    (%r10,%r15,8),%rsi
add    $0x10,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movupd -0x10(%rsi,%rdi,8),%xmm5
movupd -0x10(%rax,%rdi,8),%xmm6
movapd %xmm4,%xmm7
mulpd  %xmm6,%xmm7
movapd %xmm3,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm7,%xmm2
movupd %xmm2,-0x10(%rsi,%rdi,8)
mulpd  %xmm8,%xmm5
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,-0x10(%rax,%rdi,8)
movupd (%rsi,%rdi,8),%xmm2
movupd (%rax,%rdi,8),%xmm5
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm3,%xmm7
mulpd  %xmm2,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,(%rsi,%rdi,8)
mulpd  %xmm8,%xmm2
mulpd  %xmm3,%xmm5
addpd  %xmm2,%xmm5
movupd %xmm5,(%rax,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rbp
jne    2e70 <Hqr2+0x1d30>
jmp    2eec <Hqr2+0x1dac>
xor    %edi,%edi
test   $0x1,%r8b
je     2f29 <Hqr2+0x1de9>
add    %r15,%rdi
movupd (%r10,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm5
mulpd  %xmm5,%xmm4
movapd %xmm3,%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%r10,%rdi,8)
mulpd  %xmm2,%xmm8
mulpd  %xmm5,%xmm3
addpd  %xmm8,%xmm3
movupd %xmm3,(%rcx,%rdi,8)
cmp    %rdx,%r9
mov    0x8(%rsp),%r12d
mov    0xc0(%rsp),%rdi
mov    0x118(%rsp),%rbp
movapd %xmm10,%xmm6
movapd %xmm12,%xmm7
je     2f9f <Hqr2+0x1e5f>
add    %r15,%rdx
mov    0xf0(%rsp),%rsi
mov    0xc0(%rsp),%rdi
movsd  (%r10,%rdx,8),%xmm2
movsd  (%rcx,%rdx,8),%xmm3
mulsd  %xmm6,%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r10,%rdx,8)
mulsd  %xmm1,%xmm2
movsd  (%rcx,%rdx,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%esi
jne    2f60 <Hqr2+0x1e20>
test   %edi,%edi
mov    0x70(%rsp),%rdx
mov    0x150(%rsp),%rsi
js     3003 <Hqr2+0x1ec3>
movapd %xmm6,%xmm1
xorpd  0x1054(%rip),%xmm1
xor    %eax,%eax
xchg   %ax,%ax
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm2
movsd  (%rcx,%rdx,8),%xmm3
movapd %xmm6,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm7,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rcx,%r15,8)
mulsd  %xmm1,%xmm2
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%rdx,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2fc0 <Hqr2+0x1e80>
movapd %xmm6,%xmm1
xorpd  0x1001(%rip),%xmm1
movapd %xmm7,%xmm10
unpcklpd %xmm0,%xmm10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm12
movsd  (%rcx,%rdx,8),%xmm0
movapd %xmm6,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm7,%xmm3
mulsd  %xmm12,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%r15,8)
movapd %xmm12,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm7,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rax
cmp    %eax,%ebx
jne    3020 <Hqr2+0x1ee0>
jmp    2b1f <Hqr2+0x19df>
lea    0xfeb(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    0xc0(%rsp),%rax
jmp    3401 <Hqr2+0x22c1>
cmpl   $0x0,0x28(%rsp)
jle    32ac <Hqr2+0x216c>
movslq 0x110(%rsp),%r8
movslq 0x8(%rsp),%r12
lea    -0x4(%rdi),%r15
mov    $0xe,%r13d
mov    $0x2,%r11d
xor    %r9d,%r9d
mov    %r8,0x10(%rsp)
mov    %r12,0x30(%rsp)
jmp    30d9 <Hqr2+0x1f99>
add    $0x1,%r9
add    $0x1,%r13
add    $0xffffffffffffffff,%r15
add    $0x1,%r11
cmp    %rdi,%r9
je     32ac <Hqr2+0x216c>
cmp    %r12,%r9
jl     30e3 <Hqr2+0x1fa3>
cmp    %r8,%r9
jle    30c0 <Hqr2+0x1f80>
mov    %rdi,%r10
sub    %r9,%r10
mov    (%r14,%r9,8),%rax
mov    0x210(%rsp),%rcx
mov    (%rcx,%r9,8),%rcx
mov    %r9,%rbp
cmp    $0x4,%r10
jb     3230 <Hqr2+0x20f0>
lea    (%rcx,%r9,8),%rdx
lea    (%rax,%rdi,8),%rsi
cmp    %rsi,%rdx
jae    3127 <Hqr2+0x1fe7>
lea    (%rcx,%rdi,8),%rdx
lea    (%rax,%r9,8),%rsi
mov    %r9,%rbp
cmp    %rdx,%rsi
jb     3230 <Hqr2+0x20f0>
mov    %r15,%rdx
shr    $0x2,%rdx
lea    -0x4(%r10),%rsi
mov    %rsi,%r12
shr    $0x2,%r12
add    $0x1,%r12
cmp    $0xc,%rsi
jae    3147 <Hqr2+0x2007>
xor    %ebx,%ebx
jmp    31c4 <Hqr2+0x2084>
lea    0x1(%rdx),%rbp
and    $0xfffffffffffffffc,%rbp
lea    (%rcx,%r13,8),%rsi
lea    (%rax,%r13,8),%r8
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x70(%r8,%rbx,8),%xmm0
movups -0x60(%r8,%rbx,8),%xmm1
movups %xmm0,-0x70(%rsi,%rbx,8)
movups %xmm1,-0x60(%rsi,%rbx,8)
movups -0x50(%r8,%rbx,8),%xmm0
movups -0x40(%r8,%rbx,8),%xmm1
movups %xmm0,-0x50(%rsi,%rbx,8)
movups %xmm1,-0x40(%rsi,%rbx,8)
movups -0x30(%r8,%rbx,8),%xmm0
movups -0x20(%r8,%rbx,8),%xmm1
movups %xmm0,-0x30(%rsi,%rbx,8)
movups %xmm1,-0x20(%rsi,%rbx,8)
movupd -0x10(%r8,%rbx,8),%xmm0
movupd (%r8,%rbx,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rbx,8)
movupd %xmm1,(%rsi,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rbp
jne    3160 <Hqr2+0x2020>
mov    %r10,%rbp
and    $0xfffffffffffffffc,%rbp
test   $0x3,%r12b
je     320f <Hqr2+0x20cf>
add    $0x1,%dl
movzbl %dl,%esi
and    $0x3,%esi
shl    $0x5,%rsi
add    %r11,%rbx
lea    (%rcx,%rbx,8),%rdx
lea    (%rax,%rbx,8),%rbx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rbx,%rdi,1),%xmm0
movupd (%rbx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    31f0 <Hqr2+0x20b0>
cmp    %rbp,%r10
mov    0xf0(%rsp),%rdi
mov    0x10(%rsp),%r8
mov    0x30(%rsp),%r12
je     30c0 <Hqr2+0x1f80>
add    %r9,%rbp
nopl   (%rax)
mov    %edi,%ebx
sub    %ebp,%ebx
mov    %rbp,%rsi
not    %rsi
add    %rdi,%rsi
and    $0x3,%rbx
je     3264 <Hqr2+0x2124>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rbx
jne    3250 <Hqr2+0x2110>
cmp    $0x3,%rsi
jb     30c0 <Hqr2+0x1f80>
xchg   %ax,%ax
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
movsd  0x8(%rax,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rbp,8)
movsd  0x10(%rax,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rbp,8)
movsd  0x18(%rax,%rbp,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    3270 <Hqr2+0x2130>
jmp    30c0 <Hqr2+0x1f80>
mov    0x8(%rsp),%edx
mov    0x28(%rsp),%rcx
cmp    %edx,%ecx
jle    33ff <Hqr2+0x22bf>
movslq %edx,%r10
mov    0x110(%rsp),%rax
lea    0x1(%rax),%r15d
movslq %ecx,%rdi
movslq %eax,%r9
mov    $0x1,%r8d
sub    %r10,%r8
jmp    32e9 <Hqr2+0x21a9>
nopl   (%rax)
cmp    %r10,%rdi
jle    33ff <Hqr2+0x22bf>
cmp    %r9,%rdi
lea    -0x1(%rdi),%rdi
mov    %edi,%r13d
mov    0x110(%rsp),%rax
cmovg  %eax,%r13d
cmp    %edx,%eax
jl     32e0 <Hqr2+0x21a0>
movslq %r13d,%rsi
lea    (%r8,%r13,1),%r12d
mov    %rsi,%r11
sub    %r10,%r11
and    $0x3,%r12d
mov    %r10,%rax
jmp    3332 <Hqr2+0x21f2>
nopl   0x0(%rax)
movsd  %xmm0,(%rcx,%rdi,8)
add    $0x1,%rax
cmp    %eax,%r15d
mov    0x8(%rsp),%edx
je     32e0 <Hqr2+0x21a0>
mov    0x210(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
xorpd  %xmm0,%xmm0
cmp    %edx,%r13d
jl     3320 <Hqr2+0x21e0>
xorpd  %xmm0,%xmm0
test   %r12,%r12
je     3385 <Hqr2+0x2245>
mov    %r12,%rdx
mov    %r10,%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm1
mov    (%r14,%rbx,8),%rbp
mulsd  0x0(%rbp,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    3360 <Hqr2+0x2220>
cmp    $0x3,%r11
jb     3320 <Hqr2+0x21e0>
jmp    338e <Hqr2+0x224e>
mov    %r10,%rbx
cmp    $0x3,%r11
jb     3320 <Hqr2+0x21e0>
add    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%rcx,%rbx,8),%xmm1
movsd  0x10(%rcx,%rbx,8),%xmm2
mov    0x8(%r14,%rbx,8),%rdx
mov    0x10(%r14,%rbx,8),%rbp
mulsd  (%rdx,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x18(%rcx,%rbx,8),%xmm1
mov    0x18(%r14,%rbx,8),%rdx
mulsd  (%rdx,%rdi,8),%xmm1
movsd  0x20(%rcx,%rbx,8),%xmm0
mov    0x20(%r14,%rbx,8),%rdx
mulsd  (%rdx,%rdi,8),%xmm0
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x4,%rbx
cmp    %rsi,%rbx
jl     33a0 <Hqr2+0x2260>
jmp    3320 <Hqr2+0x21e0>
xor    %eax,%eax
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
unpckhpd %xmm10,%xmm10
mov    0x28(%rsp),%rdi
jmp    12cb <Hqr2+0x18b>

LLVM IR (-O0):
@.str = [65 x i8] c"Error in Hqr2. Eigenvalues have not converged. Returning en=%i\00"
define i32 @Hqr2(i32 %0, i32 %1, i32 %2, double** %3, double* %4, double* %5, double** %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double**
%13 = alloca double*
%14 = alloca double*
%15 = alloca double**
%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 i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
store i32 %0, i32* %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store double** %3, double*** %12
store double* %4, double** %13
store double* %5, double** %14
store double** %6, double*** %15
store double 0.000000e+00, double* %42
store double 0.000000e+00, double* %37
store double 0.000000e+00, double* %35
store double 0.000000e+00, double* %33
store double 0.000000e+00, double* %32
store double 0.000000e+00, double* %31
store double 0.000000e+00, double* %30
store double 0.000000e+00, double* %29
store i32 0, i32* %18
store i32 0, i32* %16
br label %45
45: ; preds = %99, %7
%46 = load i32, i32* %16
%47 = load i32, i32* %9
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %102
49: ; preds = %45
%50 = load i32, i32* %18
store i32 %50, i32* %17
br label %51
51: ; preds = %68, %49
%52 = load i32, i32* %17
%53 = load i32, i32* %9
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %71
55: ; preds = %51
%56 = load double**, double*** %12
%57 = load i32, i32* %16
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double*, double** %56, i64 %58
%60 = load double*, double** %59
%61 = load i32, i32* %17
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %60, i64 %62
%64 = load double, double* %63
%65 = call double @llvm.fabs.f64(double %64)
%66 = load double, double* %29
%67 = fadd double %66, %65
store double %67, double* %29
br label %68
68: ; preds = %55
%69 = load i32, i32* %17
%70 = add nsw i32 %69, 1
store i32 %70, i32* %17
br label %51
71: ; preds = %51
%72 = load i32, i32* %16
store i32 %72, i32* %18
%73 = load i32, i32* %16
%74 = load i32, i32* %10
%75 = icmp slt i32 %73, %74
br i1 %75, label %80, label %76
76: ; preds = %71
%77 = load i32, i32* %16
%78 = load i32, i32* %11
%79 = icmp sgt i32 %77, %78
br i1 %79, label %80, label %98
80: ; preds = %76, %71
%81 = load double**, double*** %12
%82 = load i32, i32* %16
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double*, double** %81, i64 %83
%85 = load double*, double** %84
%86 = load i32, i32* %16
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds double, double* %85, i64 %87
%89 = load double, double* %88
%90 = load double*, double** %13
%91 = load i32, i32* %16
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %90, i64 %92
store double %89, double* %93
%94 = load double*, double** %14
%95 = load i32, i32* %16
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
store double 0.000000e+00, double* %97
br label %98
98: ; preds = %80, %76
br label %99
99: ; preds = %98
%100 = load i32, i32* %16
%101 = add nsw i32 %100, 1
store i32 %101, i32* %16
br label %45
102: ; preds = %45
%103 = load i32, i32* %11
store i32 %103, i32* %22
store double 0.000000e+00, double* %34
%104 = load i32, i32* %9
%105 = mul nsw i32 %104, 30
store i32 %105, i32* %25
br label %106
106: ; preds = %1463, %102
%107 = load i32, i32* %22
%108 = load i32, i32* %10
%109 = icmp sge i32 %107, %108
br i1 %109, label %110, label %1464
110: ; preds = %106
store i32 0, i32* %26
%111 = load i32, i32* %22
%112 = sub nsw i32 %111, 1
store i32 %112, i32* %21
%113 = load i32, i32* %21
%114 = sub nsw i32 %113, 1
store i32 %114, i32* %27
store i32 0, i32* %28
br label %115
115: ; preds = %1087, %110
%116 = load i32, i32* %22
store i32 %116, i32* %19
br label %117
117: ; preds = %172, %115
%118 = load i32, i32* %19
%119 = load i32, i32* %10
%120 = icmp sgt i32 %118, %119
br i1 %120, label %121, label %175
121: ; preds = %117
%122 = load double**, double*** %12
%123 = load i32, i32* %19
%124 = sub nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double*, double** %122, i64 %125
%127 = load double*, double** %126
%128 = load i32, i32* %19
%129 = sub nsw i32 %128, 1
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double, double* %127, i64 %130
%132 = load double, double* %131
%133 = call double @llvm.fabs.f64(double %132)
%134 = load double**, double*** %12
%135 = load i32, i32* %19
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double*, double** %134, i64 %136
%138 = load double*, double** %137
%139 = load i32, i32* %19
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %138, i64 %140
%142 = load double, double* %141
%143 = call double @llvm.fabs.f64(double %142)
%144 = fadd double %133, %143
store double %144, double* %33
%145 = load double, double* %33
%146 = call double @llvm.fabs.f64(double %145)
%147 = fcmp olt double %146, 1.000000e-30
br i1 %147, label %148, label %150
148: ; preds = %121
%149 = load double, double* %29
store double %149, double* %33
br label %150
150: ; preds = %148, %121
%151 = load double, double* %33
store double %151, double* %43
%152 = load double, double* %43
%153 = load double**, double*** %12
%154 = load i32, i32* %19
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double*, double** %153, i64 %155
%157 = load double*, double** %156
%158 = load i32, i32* %19
%159 = sub nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %157, i64 %160
%162 = load double, double* %161
%163 = call double @llvm.fabs.f64(double %162)
%164 = fadd double %152, %163
store double %164, double* %44
%165 = load double, double* %44
%166 = load double, double* %43
%167 = fsub double %165, %166
%168 = call double @llvm.fabs.f64(double %167)
%169 = fcmp olt double %168, 1.000000e-30
br i1 %169, label %170, label %171
170: ; preds = %150
br label %175
171: ; preds = %150
br label %172
172: ; preds = %171
%173 = load i32, i32* %19
%174 = add nsw i32 %173, -1
store i32 %174, i32* %19
br label %117
175: ; preds = %170, %117
%176 = load double**, double*** %12
%177 = load i32, i32* %22
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double*, double** %176, i64 %178
%180 = load double*, double** %179
%181 = load i32, i32* %22
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %180, i64 %182
%184 = load double, double* %183
store double %184, double* %36
%185 = load i32, i32* %19
%186 = load i32, i32* %22
%187 = icmp eq i32 %185, %186
br i1 %187, label %188, label %189
188: ; preds = %175
br label %1088
189: ; preds = %175
%190 = load double**, double*** %12
%191 = load i32, i32* %21
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double*, double** %190, i64 %192
%194 = load double*, double** %193
%195 = load i32, i32* %21
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
%198 = load double, double* %197
store double %198, double* %37
%199 = load double**, double*** %12
%200 = load i32, i32* %22
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double*, double** %199, i64 %201
%203 = load double*, double** %202
%204 = load i32, i32* %21
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %203, i64 %205
%207 = load double, double* %206
%208 = load double**, double*** %12
%209 = load i32, i32* %21
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds double*, double** %208, i64 %210
%212 = load double*, double** %211
%213 = load i32, i32* %22
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds double, double* %212, i64 %214
%216 = load double, double* %215
%217 = fmul double %207, %216
store double %217, double* %35
%218 = load i32, i32* %19
%219 = load i32, i32* %21
%220 = icmp eq i32 %218, %219
br i1 %220, label %221, label %222
221: ; preds = %189
store i32 1, i32* %28
br label %1088
222: ; preds = %189
%223 = load i32, i32* %25
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %229
225: ; preds = %222
%226 = load i32, i32* %22
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 %226)
%228 = load i32, i32* %22
store i32 %228, i32* %8
br label %2479
229: ; preds = %222
%230 = load i32, i32* %26
%231 = icmp eq i32 %230, 10
br i1 %231, label %235, label %232
232: ; preds = %229
%233 = load i32, i32* %26
%234 = icmp eq i32 %233, 20
br i1 %234, label %235, label %288
235: ; preds = %232, %229
%236 = load double, double* %36
%237 = load double, double* %34
%238 = fadd double %237, %236
store double %238, double* %34
%239 = load i32, i32* %10
store i32 %239, i32* %16
br label %240
240: ; preds = %256, %235
%241 = load i32, i32* %16
%242 = load i32, i32* %22
%243 = icmp sle i32 %241, %242
br i1 %243, label %244, label %259
244: ; preds = %240
%245 = load double, double* %36
%246 = load double**, double*** %12
%247 = load i32, i32* %16
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double*, double** %246, i64 %248
%250 = load double*, double** %249
%251 = load i32, i32* %16
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = fsub double %254, %245
store double %255, double* %253
br label %256
256: ; preds = %244
%257 = load i32, i32* %16
%258 = add nsw i32 %257, 1
store i32 %258, i32* %16
br label %240
259: ; preds = %240
%260 = load double**, double*** %12
%261 = load i32, i32* %22
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double*, double** %260, i64 %262
%264 = load double*, double** %263
%265 = load i32, i32* %21
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %264, i64 %266
%268 = load double, double* %267
%269 = call double @llvm.fabs.f64(double %268)
%270 = load double**, double*** %12
%271 = load i32, i32* %21
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double*, double** %270, i64 %272
%274 = load double*, double** %273
%275 = load i32, i32* %27
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %274, i64 %276
%278 = load double, double* %277
%279 = call double @llvm.fabs.f64(double %278)
%280 = fadd double %269, %279
store double %280, double* %33
%281 = load double, double* %33
%282 = fmul double %281, 7.500000e-01
store double %282, double* %36
%283 = load double, double* %36
store double %283, double* %37
%284 = load double, double* %33
%285 = fmul double %284, -4.375000e-01
%286 = load double, double* %33
%287 = fmul double %285, %286
store double %287, double* %35
br label %288
288: ; preds = %259, %232
%289 = load i32, i32* %26
%290 = add nsw i32 %289, 1
store i32 %290, i32* %26
%291 = load i32, i32* %25
%292 = add nsw i32 %291, -1
store i32 %292, i32* %25
%293 = load i32, i32* %27
store i32 %293, i32* %20
br label %294
294: ; preds = %447, %288
%295 = load i32, i32* %20
%296 = load i32, i32* %19
%297 = icmp sge i32 %295, %296
br i1 %297, label %298, label %450
298: ; preds = %294
%299 = load double**, double*** %12
%300 = load i32, i32* %20
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds double*, double** %299, i64 %301
%303 = load double*, double** %302
%304 = load i32, i32* %20
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds double, double* %303, i64 %305
%307 = load double, double* %306
store double %307, double* %42
%308 = load double, double* %36
%309 = load double, double* %42
%310 = fsub double %308, %309
store double %310, double* %32
%311 = load double, double* %37
%312 = load double, double* %42
%313 = fsub double %311, %312
store double %313, double* %33
%314 = load double, double* %32
%315 = load double, double* %33
%316 = load double, double* %35
%317 = fneg double %316
%318 = call double @llvm.fmuladd.f64(double %314, double %315, double %317)
%319 = load double**, double*** %12
%320 = load i32, i32* %20
%321 = add nsw i32 %320, 1
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double*, double** %319, i64 %322
%324 = load double*, double** %323
%325 = load i32, i32* %20
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %324, i64 %326
%328 = load double, double* %327
%329 = fdiv double %318, %328
%330 = load double**, double*** %12
%331 = load i32, i32* %20
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double*, double** %330, i64 %332
%334 = load double*, double** %333
%335 = load i32, i32* %20
%336 = add nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %334, i64 %337
%339 = load double, double* %338
%340 = fadd double %329, %339
store double %340, double* %30
%341 = load double**, double*** %12
%342 = load i32, i32* %20
%343 = add nsw i32 %342, 1
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double*, double** %341, i64 %344
%346 = load double*, double** %345
%347 = load i32, i32* %20
%348 = add nsw i32 %347, 1
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %346, i64 %349
%351 = load double, double* %350
%352 = load double, double* %42
%353 = fsub double %351, %352
%354 = load double, double* %32
%355 = fsub double %353, %354
%356 = load double, double* %33
%357 = fsub double %355, %356
store double %357, double* %31
%358 = load double**, double*** %12
%359 = load i32, i32* %20
%360 = add nsw i32 %359, 2
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double*, double** %358, i64 %361
%363 = load double*, double** %362
%364 = load i32, i32* %20
%365 = add nsw i32 %364, 1
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %363, i64 %366
%368 = load double, double* %367
store double %368, double* %32
%369 = load double, double* %30
%370 = call double @llvm.fabs.f64(double %369)
%371 = load double, double* %31
%372 = call double @llvm.fabs.f64(double %371)
%373 = fadd double %370, %372
%374 = load double, double* %32
%375 = call double @llvm.fabs.f64(double %374)
%376 = fadd double %373, %375
store double %376, double* %33
%377 = load double, double* %33
%378 = load double, double* %30
%379 = fdiv double %378, %377
store double %379, double* %30
%380 = load double, double* %33
%381 = load double, double* %31
%382 = fdiv double %381, %380
store double %382, double* %31
%383 = load double, double* %33
%384 = load double, double* %32
%385 = fdiv double %384, %383
store double %385, double* %32
%386 = load i32, i32* %20
%387 = load i32, i32* %19
%388 = icmp eq i32 %386, %387
br i1 %388, label %389, label %390
389: ; preds = %298
br label %450
390: ; preds = %298
%391 = load double, double* %30
%392 = call double @llvm.fabs.f64(double %391)
%393 = load double**, double*** %12
%394 = load i32, i32* %20
%395 = sub nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double*, double** %393, i64 %396
%398 = load double*, double** %397
%399 = load i32, i32* %20
%400 = sub nsw i32 %399, 1
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %398, i64 %401
%403 = load double, double* %402
%404 = call double @llvm.fabs.f64(double %403)
%405 = load double, double* %42
%406 = call double @llvm.fabs.f64(double %405)
%407 = fadd double %404, %406
%408 = load double**, double*** %12
%409 = load i32, i32* %20
%410 = add nsw i32 %409, 1
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double*, double** %408, i64 %411
%413 = load double*, double** %412
%414 = load i32, i32* %20
%415 = add nsw i32 %414, 1
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %413, i64 %416
%418 = load double, double* %417
%419 = call double @llvm.fabs.f64(double %418)
%420 = fadd double %407, %419
%421 = fmul double %392, %420
store double %421, double* %43
%422 = load double, double* %43
%423 = load double**, double*** %12
%424 = load i32, i32* %20
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double*, double** %423, i64 %425
%427 = load double*, double** %426
%428 = load i32, i32* %20
%429 = sub nsw i32 %428, 1
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %427, i64 %430
%432 = load double, double* %431
%433 = call double @llvm.fabs.f64(double %432)
%434 = load double, double* %31
%435 = call double @llvm.fabs.f64(double %434)
%436 = load double, double* %32
%437 = call double @llvm.fabs.f64(double %436)
%438 = fadd double %435, %437
%439 = call double @llvm.fmuladd.f64(double %433, double %438, double %422)
store double %439, double* %44
%440 = load double, double* %44
%441 = load double, double* %43
%442 = fsub double %440, %441
%443 = call double @llvm.fabs.f64(double %442)
%444 = fcmp olt double %443, 1.000000e-30
br i1 %444, label %445, label %446
445: ; preds = %390
br label %450
446: ; preds = %390
br label %447
447: ; preds = %446
%448 = load i32, i32* %20
%449 = add nsw i32 %448, -1
store i32 %449, i32* %20
br label %294
450: ; preds = %445, %389, %294
%451 = load i32, i32* %20
%452 = add nsw i32 %451, 2
store i32 %452, i32* %24
%453 = load i32, i32* %24
store i32 %453, i32* %16
br label %454
454: ; preds = %482, %450
%455 = load i32, i32* %16
%456 = load i32, i32* %22
%457 = icmp sle i32 %455, %456
br i1 %457, label %458, label %485
458: ; preds = %454
%459 = load double**, double*** %12
%460 = load i32, i32* %16
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double*, double** %459, i64 %461
%463 = load double*, double** %462
%464 = load i32, i32* %16
%465 = sub nsw i32 %464, 2
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds double, double* %463, i64 %466
store double 0.000000e+00, double* %467
%468 = load i32, i32* %16
%469 = load i32, i32* %24
%470 = icmp ne i32 %468, %469
br i1 %470, label %471, label %481
471: ; preds = %458
%472 = load double**, double*** %12
%473 = load i32, i32* %16
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double*, double** %472, i64 %474
%476 = load double*, double** %475
%477 = load i32, i32* %16
%478 = sub nsw i32 %477, 3
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %476, i64 %479
store double 0.000000e+00, double* %480
br label %481
481: ; preds = %471, %458
br label %482
482: ; preds = %481
%483 = load i32, i32* %16
%484 = add nsw i32 %483, 1
store i32 %484, i32* %16
br label %454
485: ; preds = %454
%486 = load i32, i32* %20
store i32 %486, i32* %18
br label %487
487: ; preds = %1084, %485
%488 = load i32, i32* %18
%489 = load i32, i32* %21
%490 = icmp sle i32 %488, %489
br i1 %490, label %491, label %1087
491: ; preds = %487
%492 = load i32, i32* %18
%493 = load i32, i32* %21
%494 = icmp ne i32 %492, %493
%495 = zext i1 %494 to i32
store i32 %495, i32* %23
%496 = load i32, i32* %18
%497 = load i32, i32* %20
%498 = icmp ne i32 %496, %497
br i1 %498, label %499, label %557
499: ; preds = %491
%500 = load double**, double*** %12
%501 = load i32, i32* %18
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds double*, double** %500, i64 %502
%504 = load double*, double** %503
%505 = load i32, i32* %18
%506 = sub nsw i32 %505, 1
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds double, double* %504, i64 %507
%509 = load double, double* %508
store double %509, double* %30
%510 = load double**, double*** %12
%511 = load i32, i32* %18
%512 = add nsw i32 %511, 1
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds double*, double** %510, i64 %513
%515 = load double*, double** %514
%516 = load i32, i32* %18
%517 = sub nsw i32 %516, 1
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds double, double* %515, i64 %518
%520 = load double, double* %519
store double %520, double* %31
store double 0.000000e+00, double* %32
%521 = load i32, i32* %23
%522 = icmp ne i32 %521, 0
br i1 %522, label %523, label %535
523: ; preds = %499
%524 = load double**, double*** %12
%525 = load i32, i32* %18
%526 = add nsw i32 %525, 2
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds double*, double** %524, i64 %527
%529 = load double*, double** %528
%530 = load i32, i32* %18
%531 = sub nsw i32 %530, 1
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %529, i64 %532
%534 = load double, double* %533
store double %534, double* %32
br label %535
535: ; preds = %523, %499
%536 = load double, double* %30
%537 = call double @llvm.fabs.f64(double %536)
%538 = load double, double* %31
%539 = call double @llvm.fabs.f64(double %538)
%540 = fadd double %537, %539
%541 = load double, double* %32
%542 = call double @llvm.fabs.f64(double %541)
%543 = fadd double %540, %542
store double %543, double* %36
%544 = load double, double* %36
%545 = fcmp olt double %544, 1.000000e-30
br i1 %545, label %546, label %547
546: ; preds = %535
br label %1084
547: ; preds = %535
%548 = load double, double* %36
%549 = load double, double* %30
%550 = fdiv double %549, %548
store double %550, double* %30
%551 = load double, double* %36
%552 = load double, double* %31
%553 = fdiv double %552, %551
store double %553, double* %31
%554 = load double, double* %36
%555 = load double, double* %32
%556 = fdiv double %555, %554
store double %556, double* %32
br label %557
557: ; preds = %547, %491
%558 = load double, double* %30
%559 = load double, double* %30
%560 = load double, double* %31
%561 = load double, double* %31
%562 = fmul double %560, %561
%563 = call double @llvm.fmuladd.f64(double %558, double %559, double %562)
%564 = load double, double* %32
%565 = load double, double* %32
%566 = call double @llvm.fmuladd.f64(double %564, double %565, double %563)
%567 = call double @sqrt(double %566)
%568 = load double, double* %30
%569 = call i32 (double, double, ...) bitcast (i32 (...)* @D_sign to i32 (double, double, ...)*)(double %567, double %568)
%570 = sitofp i32 %569 to double
store double %570, double* %33
%571 = load i32, i32* %18
%572 = load i32, i32* %20
%573 = icmp ne i32 %571, %572
br i1 %573, label %574, label %588
574: ; preds = %557
%575 = load double, double* %33
%576 = fneg double %575
%577 = load double, double* %36
%578 = fmul double %576, %577
%579 = load double**, double*** %12
%580 = load i32, i32* %18
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double*, double** %579, i64 %581
%583 = load double*, double** %582
%584 = load i32, i32* %18
%585 = sub nsw i32 %584, 1
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %583, i64 %586
store double %578, double* %587
br label %614
588: ; preds = %557
%589 = load i32, i32* %19
%590 = load i32, i32* %20
%591 = icmp ne i32 %589, %590
br i1 %591, label %592, label %613
592: ; preds = %588
%593 = load double**, double*** %12
%594 = load i32, i32* %18
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds double*, double** %593, i64 %595
%597 = load double*, double** %596
%598 = load i32, i32* %18
%599 = sub nsw i32 %598, 1
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %597, i64 %600
%602 = load double, double* %601
%603 = fneg double %602
%604 = load double**, double*** %12
%605 = load i32, i32* %18
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double*, double** %604, i64 %606
%608 = load double*, double** %607
%609 = load i32, i32* %18
%610 = sub nsw i32 %609, 1
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %608, i64 %611
store double %603, double* %612
br label %613
613: ; preds = %592, %588
br label %614
614: ; preds = %613, %574
%615 = load double, double* %33
%616 = load double, double* %30
%617 = fadd double %616, %615
store double %617, double* %30
%618 = load double, double* %30
%619 = load double, double* %33
%620 = fdiv double %618, %619
store double %620, double* %36
%621 = load double, double* %31
%622 = load double, double* %33
%623 = fdiv double %621, %622
store double %623, double* %37
%624 = load double, double* %32
%625 = load double, double* %33
%626 = fdiv double %624, %625
store double %626, double* %42
%627 = load double, double* %30
%628 = load double, double* %31
%629 = fdiv double %628, %627
store double %629, double* %31
%630 = load double, double* %30
%631 = load double, double* %32
%632 = fdiv double %631, %630
store double %632, double* %32
%633 = load i32, i32* %23
%634 = icmp ne i32 %633, 0
br i1 %634, label %820, label %635
635: ; preds = %614
%636 = load i32, i32* %18
store i32 %636, i32* %17
br label %637
637: ; preds = %690, %635
%638 = load i32, i32* %17
%639 = load i32, i32* %9
%640 = icmp slt i32 %638, %639
br i1 %640, label %641, label %693
641: ; preds = %637
%642 = load double**, double*** %12
%643 = load i32, i32* %18
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds double*, double** %642, i64 %644
%646 = load double*, double** %645
%647 = load i32, i32* %17
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %646, i64 %648
%650 = load double, double* %649
%651 = load double, double* %31
%652 = load double**, double*** %12
%653 = load i32, i32* %18
%654 = add nsw i32 %653, 1
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds double*, double** %652, i64 %655
%657 = load double*, double** %656
%658 = load i32, i32* %17
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %657, i64 %659
%661 = load double, double* %660
%662 = call double @llvm.fmuladd.f64(double %651, double %661, double %650)
store double %662, double* %30
%663 = load double, double* %30
%664 = load double, double* %36
%665 = load double**, double*** %12
%666 = load i32, i32* %18
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds double*, double** %665, i64 %667
%669 = load double*, double** %668
%670 = load i32, i32* %17
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %669, i64 %671
%673 = load double, double* %672
%674 = fneg double %663
%675 = call double @llvm.fmuladd.f64(double %674, double %664, double %673)
store double %675, double* %672
%676 = load double, double* %30
%677 = load double, double* %37
%678 = load double**, double*** %12
%679 = load i32, i32* %18
%680 = add nsw i32 %679, 1
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double*, double** %678, i64 %681
%683 = load double*, double** %682
%684 = load i32, i32* %17
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds double, double* %683, i64 %685
%687 = load double, double* %686
%688 = fneg double %676
%689 = call double @llvm.fmuladd.f64(double %688, double %677, double %687)
store double %689, double* %686
br label %690
690: ; preds = %641
%691 = load i32, i32* %17
%692 = add nsw i32 %691, 1
store i32 %692, i32* %17
br label %637
693: ; preds = %637
%694 = load i32, i32* %22
%695 = load i32, i32* %18
%696 = add nsw i32 %695, 3
%697 = icmp slt i32 %694, %696
br i1 %697, label %698, label %700
698: ; preds = %693
%699 = load i32, i32* %22
br label %703
700: ; preds = %693
%701 = load i32, i32* %18
%702 = add nsw i32 %701, 3
br label %703
703: ; preds = %700, %698
%704 = phi i32 [ %699, %698 ], [ %702, %700 ]
store i32 %704, i32* %17
store i32 0, i32* %16
br label %705
705: ; preds = %758, %703
%706 = load i32, i32* %16
%707 = load i32, i32* %17
%708 = icmp sle i32 %706, %707
br i1 %708, label %709, label %761
709: ; preds = %705
%710 = load double, double* %36
%711 = load double**, double*** %12
%712 = load i32, i32* %16
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double*, double** %711, i64 %713
%715 = load double*, double** %714
%716 = load i32, i32* %18
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double, double* %715, i64 %717
%719 = load double, double* %718
%720 = load double, double* %37
%721 = load double**, double*** %12
%722 = load i32, i32* %16
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double*, double** %721, i64 %723
%725 = load double*, double** %724
%726 = load i32, i32* %18
%727 = add nsw i32 %726, 1
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds double, double* %725, i64 %728
%730 = load double, double* %729
%731 = fmul double %720, %730
%732 = call double @llvm.fmuladd.f64(double %710, double %719, double %731)
store double %732, double* %30
%733 = load double, double* %30
%734 = load double**, double*** %12
%735 = load i32, i32* %16
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds double*, double** %734, i64 %736
%738 = load double*, double** %737
%739 = load i32, i32* %18
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds double, double* %738, i64 %740
%742 = load double, double* %741
%743 = fsub double %742, %733
store double %743, double* %741
%744 = load double, double* %30
%745 = load double, double* %31
%746 = load double**, double*** %12
%747 = load i32, i32* %16
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds double*, double** %746, i64 %748
%750 = load double*, double** %749
%751 = load i32, i32* %18
%752 = add nsw i32 %751, 1
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds double, double* %750, i64 %753
%755 = load double, double* %754
%756 = fneg double %744
%757 = call double @llvm.fmuladd.f64(double %756, double %745, double %755)
store double %757, double* %754
br label %758
758: ; preds = %709
%759 = load i32, i32* %16
%760 = add nsw i32 %759, 1
store i32 %760, i32* %16
br label %705
761: ; preds = %705
%762 = load i32, i32* %10
store i32 %762, i32* %16
br label %763
763: ; preds = %816, %761
%764 = load i32, i32* %16
%765 = load i32, i32* %11
%766 = icmp sle i32 %764, %765
br i1 %766, label %767, label %819
767: ; preds = %763
%768 = load double, double* %36
%769 = load double**, double*** %15
%770 = load i32, i32* %16
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds double*, double** %769, i64 %771
%773 = load double*, double** %772
%774 = load i32, i32* %18
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds double, double* %773, i64 %775
%777 = load double, double* %776
%778 = load double, double* %37
%779 = load double**, double*** %15
%780 = load i32, i32* %16
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double*, double** %779, i64 %781
%783 = load double*, double** %782
%784 = load i32, i32* %18
%785 = add nsw i32 %784, 1
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds double, double* %783, i64 %786
%788 = load double, double* %787
%789 = fmul double %778, %788
%790 = call double @llvm.fmuladd.f64(double %768, double %777, double %789)
store double %790, double* %30
%791 = load double, double* %30
%792 = load double**, double*** %15
%793 = load i32, i32* %16
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double*, double** %792, i64 %794
%796 = load double*, double** %795
%797 = load i32, i32* %18
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %796, i64 %798
%800 = load double, double* %799
%801 = fsub double %800, %791
store double %801, double* %799
%802 = load double, double* %30
%803 = load double, double* %31
%804 = load double**, double*** %15
%805 = load i32, i32* %16
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds double*, double** %804, i64 %806
%808 = load double*, double** %807
%809 = load i32, i32* %18
%810 = add nsw i32 %809, 1
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds double, double* %808, i64 %811
%813 = load double, double* %812
%814 = fneg double %802
%815 = call double @llvm.fmuladd.f64(double %814, double %803, double %813)
store double %815, double* %812
br label %816
816: ; preds = %767
%817 = load i32, i32* %16
%818 = add nsw i32 %817, 1
store i32 %818, i32* %16
br label %763
819: ; preds = %763
br label %1083
820: ; preds = %614
%821 = load i32, i32* %18
store i32 %821, i32* %17
br label %822
822: ; preds = %901, %820
%823 = load i32, i32* %17
%824 = load i32, i32* %9
%825 = icmp slt i32 %823, %824
br i1 %825, label %826, label %904
826: ; preds = %822
%827 = load double**, double*** %12
%828 = load i32, i32* %18
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds double*, double** %827, i64 %829
%831 = load double*, double** %830
%832 = load i32, i32* %17
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double, double* %831, i64 %833
%835 = load double, double* %834
%836 = load double, double* %31
%837 = load double**, double*** %12
%838 = load i32, i32* %18
%839 = add nsw i32 %838, 1
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double*, double** %837, i64 %840
%842 = load double*, double** %841
%843 = load i32, i32* %17
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds double, double* %842, i64 %844
%846 = load double, double* %845
%847 = call double @llvm.fmuladd.f64(double %836, double %846, double %835)
%848 = load double, double* %32
%849 = load double**, double*** %12
%850 = load i32, i32* %18
%851 = add nsw i32 %850, 2
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds double*, double** %849, i64 %852
%854 = load double*, double** %853
%855 = load i32, i32* %17
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds double, double* %854, i64 %856
%858 = load double, double* %857
%859 = call double @llvm.fmuladd.f64(double %848, double %858, double %847)
store double %859, double* %30
%860 = load double, double* %30
%861 = load double, double* %36
%862 = load double**, double*** %12
%863 = load i32, i32* %18
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds double*, double** %862, i64 %864
%866 = load double*, double** %865
%867 = load i32, i32* %17
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds double, double* %866, i64 %868
%870 = load double, double* %869
%871 = fneg double %860
%872 = call double @llvm.fmuladd.f64(double %871, double %861, double %870)
store double %872, double* %869
%873 = load double, double* %30
%874 = load double, double* %37
%875 = load double**, double*** %12
%876 = load i32, i32* %18
%877 = add nsw i32 %876, 1
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds double*, double** %875, i64 %878
%880 = load double*, double** %879
%881 = load i32, i32* %17
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds double, double* %880, i64 %882
%884 = load double, double* %883
%885 = fneg double %873
%886 = call double @llvm.fmuladd.f64(double %885, double %874, double %884)
store double %886, double* %883
%887 = load double, double* %30
%888 = load double, double* %42
%889 = load double**, double*** %12
%890 = load i32, i32* %18
%891 = add nsw i32 %890, 2
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds double*, double** %889, i64 %892
%894 = load double*, double** %893
%895 = load i32, i32* %17
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds double, double* %894, i64 %896
%898 = load double, double* %897
%899 = fneg double %887
%900 = call double @llvm.fmuladd.f64(double %899, double %888, double %898)
store double %900, double* %897
br label %901
901: ; preds = %826
%902 = load i32, i32* %17
%903 = add nsw i32 %902, 1
store i32 %903, i32* %17
br label %822
904: ; preds = %822
%905 = load i32, i32* %22
%906 = load i32, i32* %18
%907 = add nsw i32 %906, 3
%908 = icmp slt i32 %905, %907
br i1 %908, label %909, label %911
909: ; preds = %904
%910 = load i32, i32* %22
br label %914
911: ; preds = %904
%912 = load i32, i32* %18
%913 = add nsw i32 %912, 3
br label %914
914: ; preds = %911, %909
%915 = phi i32 [ %910, %909 ], [ %913, %911 ]
store i32 %915, i32* %17
store i32 0, i32* %16
br label %916
916: ; preds = %995, %914
%917 = load i32, i32* %16
%918 = load i32, i32* %17
%919 = icmp sle i32 %917, %918
br i1 %919, label %920, label %998
920: ; preds = %916
%921 = load double, double* %36
%922 = load double**, double*** %12
%923 = load i32, i32* %16
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds double*, double** %922, i64 %924
%926 = load double*, double** %925
%927 = load i32, i32* %18
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds double, double* %926, i64 %928
%930 = load double, double* %929
%931 = load double, double* %37
%932 = load double**, double*** %12
%933 = load i32, i32* %16
%934 = sext i32 %933 to i64
%935 = getelementptr inbounds double*, double** %932, i64 %934
%936 = load double*, double** %935
%937 = load i32, i32* %18
%938 = add nsw i32 %937, 1
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds double, double* %936, i64 %939
%941 = load double, double* %940
%942 = fmul double %931, %941
%943 = call double @llvm.fmuladd.f64(double %921, double %930, double %942)
%944 = load double, double* %42
%945 = load double**, double*** %12
%946 = load i32, i32* %16
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double*, double** %945, i64 %947
%949 = load double*, double** %948
%950 = load i32, i32* %18
%951 = add nsw i32 %950, 2
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds double, double* %949, i64 %952
%954 = load double, double* %953
%955 = call double @llvm.fmuladd.f64(double %944, double %954, double %943)
store double %955, double* %30
%956 = load double, double* %30
%957 = load double**, double*** %12
%958 = load i32, i32* %16
%959 = sext i32 %958 to i64
%960 = getelementptr inbounds double*, double** %957, i64 %959
%961 = load double*, double** %960
%962 = load i32, i32* %18
%963 = sext i32 %962 to i64
%964 = getelementptr inbounds double, double* %961, i64 %963
%965 = load double, double* %964
%966 = fsub double %965, %956
store double %966, double* %964
%967 = load double, double* %30
%968 = load double, double* %31
%969 = load double**, double*** %12
%970 = load i32, i32* %16
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds double*, double** %969, i64 %971
%973 = load double*, double** %972
%974 = load i32, i32* %18
%975 = add nsw i32 %974, 1
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds double, double* %973, i64 %976
%978 = load double, double* %977
%979 = fneg double %967
%980 = call double @llvm.fmuladd.f64(double %979, double %968, double %978)
store double %980, double* %977
%981 = load double, double* %30
%982 = load double, double* %32
%983 = load double**, double*** %12
%984 = load i32, i32* %16
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds double*, double** %983, i64 %985
%987 = load double*, double** %986
%988 = load i32, i32* %18
%989 = add nsw i32 %988, 2
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds double, double* %987, i64 %990
%992 = load double, double* %991
%993 = fneg double %981
%994 = call double @llvm.fmuladd.f64(double %993, double %982, double %992)
store double %994, double* %991
br label %995
995: ; preds = %920
%996 = load i32, i32* %16
%997 = add nsw i32 %996, 1
store i32 %997, i32* %16
br label %916
998: ; preds = %916
%999 = load i32, i32* %10
store i32 %999, i32* %16
br label %1000
1000: ; preds = %1079, %998
%1001 = load i32, i32* %16
%1002 = load i32, i32* %11
%1003 = icmp sle i32 %1001, %1002
br i1 %1003, label %1004, label %1082
1004: ; preds = %1000
%1005 = load double, double* %36
%1006 = load double**, double*** %15
%1007 = load i32, i32* %16
%1008 = sext i32 %1007 to i64
%1009 = getelementptr inbounds double*, double** %1006, i64 %1008
%1010 = load double*, double** %1009
%1011 = load i32, i32* %18
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double, double* %1010, i64 %1012
%1014 = load double, double* %1013
%1015 = load double, double* %37
%1016 = load double**, double*** %15
%1017 = load i32, i32* %16
%1018 = sext i32 %1017 to i64
%1019 = getelementptr inbounds double*, double** %1016, i64 %1018
%1020 = load double*, double** %1019
%1021 = load i32, i32* %18
%1022 = add nsw i32 %1021, 1
%1023 = sext i32 %1022 to i64
%1024 = getelementptr inbounds double, double* %1020, i64 %1023
%1025 = load double, double* %1024
%1026 = fmul double %1015, %1025
%1027 = call double @llvm.fmuladd.f64(double %1005, double %1014, double %1026)
%1028 = load double, double* %42
%1029 = load double**, double*** %15
%1030 = load i32, i32* %16
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds double*, double** %1029, i64 %1031
%1033 = load double*, double** %1032
%1034 = load i32, i32* %18
%1035 = add nsw i32 %1034, 2
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds double, double* %1033, i64 %1036
%1038 = load double, double* %1037
%1039 = call double @llvm.fmuladd.f64(double %1028, double %1038, double %1027)
store double %1039, double* %30
%1040 = load double, double* %30
%1041 = load double**, double*** %15
%1042 = load i32, i32* %16
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds double*, double** %1041, i64 %1043
%1045 = load double*, double** %1044
%1046 = load i32, i32* %18
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds double, double* %1045, i64 %1047
%1049 = load double, double* %1048
%1050 = fsub double %1049, %1040
store double %1050, double* %1048
%1051 = load double, double* %30
%1052 = load double, double* %31
%1053 = load double**, double*** %15
%1054 = load i32, i32* %16
%1055 = sext i32 %1054 to i64
%1056 = getelementptr inbounds double*, double** %1053, i64 %1055
%1057 = load double*, double** %1056
%1058 = load i32, i32* %18
%1059 = add nsw i32 %1058, 1
%1060 = sext i32 %1059 to i64
%1061 = getelementptr inbounds double, double* %1057, i64 %1060
%1062 = load double, double* %1061
%1063 = fneg double %1051
%1064 = call double @llvm.fmuladd.f64(double %1063, double %1052, double %1062)
store double %1064, double* %1061
%1065 = load double, double* %30
%1066 = load double, double* %32
%1067 = load double**, double*** %15
%1068 = load i32, i32* %16
%1069 = sext i32 %1068 to i64
%1070 = getelementptr inbounds double*, double** %1067, i64 %1069
%1071 = load double*, double** %1070
%1072 = load i32, i32* %18
%1073 = add nsw i32 %1072, 2
%1074 = sext i32 %1073 to i64
%1075 = getelementptr inbounds double, double* %1071, i64 %1074
%1076 = load double, double* %1075
%1077 = fneg double %1065
%1078 = call double @llvm.fmuladd.f64(double %1077, double %1066, double %1076)
store double %1078, double* %1075
br label %1079
1079: ; preds = %1004
%1080 = load i32, i32* %16
%1081 = add nsw i32 %1080, 1
store i32 %1081, i32* %16
br label %1000
1082: ; preds = %1000
br label %1083
1083: ; preds = %1082, %819
br label %1084
1084: ; preds = %1083, %546
%1085 = load i32, i32* %18
%1086 = add nsw i32 %1085, 1
store i32 %1086, i32* %18
br label %487
1087: ; preds = %487
br label %115
1088: ; preds = %221, %188
%1089 = load i32, i32* %28
%1090 = icmp ne i32 %1089, 0
br i1 %1090, label %1091, label %1433
1091: ; preds = %1088
%1092 = load double, double* %37
%1093 = load double, double* %36
%1094 = fsub double %1092, %1093
%1095 = fdiv double %1094, 2.000000e+00
store double %1095, double* %30
%1096 = load double, double* %30
%1097 = load double, double* %30
%1098 = load double, double* %35
%1099 = call double @llvm.fmuladd.f64(double %1096, double %1097, double %1098)
store double %1099, double* %31
%1100 = load double, double* %31
%1101 = call double @llvm.fabs.f64(double %1100)
%1102 = call double @sqrt(double %1101)
store double %1102, double* %42
%1103 = load double, double* %36
%1104 = load double, double* %34
%1105 = fadd double %1103, %1104
%1106 = load double**, double*** %12
%1107 = load i32, i32* %22
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds double*, double** %1106, i64 %1108
%1110 = load double*, double** %1109
%1111 = load i32, i32* %22
%1112 = sext i32 %1111 to i64
%1113 = getelementptr inbounds double, double* %1110, i64 %1112
store double %1105, double* %1113
%1114 = load double**, double*** %12
%1115 = load i32, i32* %22
%1116 = sext i32 %1115 to i64
%1117 = getelementptr inbounds double*, double** %1114, i64 %1116
%1118 = load double*, double** %1117
%1119 = load i32, i32* %22
%1120 = sext i32 %1119 to i64
%1121 = getelementptr inbounds double, double* %1118, i64 %1120
%1122 = load double, double* %1121
store double %1122, double* %36
%1123 = load double, double* %37
%1124 = load double, double* %34
%1125 = fadd double %1123, %1124
%1126 = load double**, double*** %12
%1127 = load i32, i32* %21
%1128 = sext i32 %1127 to i64
%1129 = getelementptr inbounds double*, double** %1126, i64 %1128
%1130 = load double*, double** %1129
%1131 = load i32, i32* %21
%1132 = sext i32 %1131 to i64
%1133 = getelementptr inbounds double, double* %1130, i64 %1132
store double %1125, double* %1133
%1134 = load double, double* %31
%1135 = fcmp oge double %1134, 0xBD719799812DEA11
br i1 %1135, label %1136, label %1405
1136: ; preds = %1091
%1137 = load double, double* %30
%1138 = load double, double* %42
%1139 = load double, double* %30
%1140 = call i32 (double, double, ...) bitcast (i32 (...)* @D_sign to i32 (double, double, ...)*)(double %1138, double %1139)
%1141 = sitofp i32 %1140 to double
%1142 = fadd double %1137, %1141
store double %1142, double* %42
%1143 = load double, double* %36
%1144 = load double, double* %42
%1145 = fadd double %1143, %1144
%1146 = load double*, double** %13
%1147 = load i32, i32* %21
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds double, double* %1146, i64 %1148
store double %1145, double* %1149
%1150 = load double*, double** %13
%1151 = load i32, i32* %21
%1152 = sext i32 %1151 to i64
%1153 = getelementptr inbounds double, double* %1150, i64 %1152
%1154 = load double, double* %1153
%1155 = load double*, double** %13
%1156 = load i32, i32* %22
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds double, double* %1155, i64 %1157
store double %1154, double* %1158
%1159 = load double, double* %42
%1160 = call double @llvm.fabs.f64(double %1159)
%1161 = fcmp ogt double %1160, 1.000000e-30
br i1 %1161, label %1162, label %1172
1162: ; preds = %1136
%1163 = load double, double* %36
%1164 = load double, double* %35
%1165 = load double, double* %42
%1166 = fdiv double %1164, %1165
%1167 = fsub double %1163, %1166
%1168 = load double*, double** %13
%1169 = load i32, i32* %22
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds double, double* %1168, i64 %1170
store double %1167, double* %1171
br label %1172
1172: ; preds = %1162, %1136
%1173 = load double*, double** %14
%1174 = load i32, i32* %21
%1175 = sext i32 %1174 to i64
%1176 = getelementptr inbounds double, double* %1173, i64 %1175
store double 0.000000e+00, double* %1176
%1177 = load double*, double** %14
%1178 = load i32, i32* %22
%1179 = sext i32 %1178 to i64
%1180 = getelementptr inbounds double, double* %1177, i64 %1179
store double 0.000000e+00, double* %1180
%1181 = load double**, double*** %12
%1182 = load i32, i32* %22
%1183 = sext i32 %1182 to i64
%1184 = getelementptr inbounds double*, double** %1181, i64 %1183
%1185 = load double*, double** %1184
%1186 = load i32, i32* %21
%1187 = sext i32 %1186 to i64
%1188 = getelementptr inbounds double, double* %1185, i64 %1187
%1189 = load double, double* %1188
store double %1189, double* %36
%1190 = load double, double* %36
%1191 = call double @llvm.fabs.f64(double %1190)
%1192 = load double, double* %42
%1193 = call double @llvm.fabs.f64(double %1192)
%1194 = fadd double %1191, %1193
store double %1194, double* %33
%1195 = load double, double* %36
%1196 = load double, double* %33
%1197 = fdiv double %1195, %1196
store double %1197, double* %30
%1198 = load double, double* %42
%1199 = load double, double* %33
%1200 = fdiv double %1198, %1199
store double %1200, double* %31
%1201 = load double, double* %30
%1202 = load double, double* %30
%1203 = load double, double* %31
%1204 = load double, double* %31
%1205 = fmul double %1203, %1204
%1206 = call double @llvm.fmuladd.f64(double %1201, double %1202, double %1205)
%1207 = call double @sqrt(double %1206)
store double %1207, double* %32
%1208 = load double, double* %32
%1209 = load double, double* %30
%1210 = fdiv double %1209, %1208
store double %1210, double* %30
%1211 = load double, double* %32
%1212 = load double, double* %31
%1213 = fdiv double %1212, %1211
store double %1213, double* %31
%1214 = load i32, i32* %21
store i32 %1214, i32* %17
br label %1215
1215: ; preds = %1274, %1172
%1216 = load i32, i32* %17
%1217 = load i32, i32* %9
%1218 = icmp slt i32 %1216, %1217
br i1 %1218, label %1219, label %1277
1219: ; preds = %1215
%1220 = load double**, double*** %12
%1221 = load i32, i32* %21
%1222 = sext i32 %1221 to i64
%1223 = getelementptr inbounds double*, double** %1220, i64 %1222
%1224 = load double*, double** %1223
%1225 = load i32, i32* %17
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds double, double* %1224, i64 %1226
%1228 = load double, double* %1227
store double %1228, double* %42
%1229 = load double, double* %31
%1230 = load double, double* %42
%1231 = load double, double* %30
%1232 = load double**, double*** %12
%1233 = load i32, i32* %22
%1234 = sext i32 %1233 to i64
%1235 = getelementptr inbounds double*, double** %1232, i64 %1234
%1236 = load double*, double** %1235
%1237 = load i32, i32* %17
%1238 = sext i32 %1237 to i64
%1239 = getelementptr inbounds double, double* %1236, i64 %1238
%1240 = load double, double* %1239
%1241 = fmul double %1231, %1240
%1242 = call double @llvm.fmuladd.f64(double %1229, double %1230, double %1241)
%1243 = load double**, double*** %12
%1244 = load i32, i32* %21
%1245 = sext i32 %1244 to i64
%1246 = getelementptr inbounds double*, double** %1243, i64 %1245
%1247 = load double*, double** %1246
%1248 = load i32, i32* %17
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds double, double* %1247, i64 %1249
store double %1242, double* %1250
%1251 = load double, double* %31
%1252 = load double**, double*** %12
%1253 = load i32, i32* %22
%1254 = sext i32 %1253 to i64
%1255 = getelementptr inbounds double*, double** %1252, i64 %1254
%1256 = load double*, double** %1255
%1257 = load i32, i32* %17
%1258 = sext i32 %1257 to i64
%1259 = getelementptr inbounds double, double* %1256, i64 %1258
%1260 = load double, double* %1259
%1261 = load double, double* %30
%1262 = load double, double* %42
%1263 = fmul double %1261, %1262
%1264 = fneg double %1263
%1265 = call double @llvm.fmuladd.f64(double %1251, double %1260, double %1264)
%1266 = load double**, double*** %12
%1267 = load i32, i32* %22
%1268 = sext i32 %1267 to i64
%1269 = getelementptr inbounds double*, double** %1266, i64 %1268
%1270 = load double*, double** %1269
%1271 = load i32, i32* %17
%1272 = sext i32 %1271 to i64
%1273 = getelementptr inbounds double, double* %1270, i64 %1272
store double %1265, double* %1273
br label %1274
1274: ; preds = %1219
%1275 = load i32, i32* %17
%1276 = add nsw i32 %1275, 1
store i32 %1276, i32* %17
br label %1215
1277: ; preds = %1215
store i32 0, i32* %16
br label %1278
1278: ; preds = %1337, %1277
%1279 = load i32, i32* %16
%1280 = load i32, i32* %22
%1281 = icmp sle i32 %1279, %1280
br i1 %1281, label %1282, label %1340
1282: ; preds = %1278
%1283 = load double**, double*** %12
%1284 = load i32, i32* %16
%1285 = sext i32 %1284 to i64
%1286 = getelementptr inbounds double*, double** %1283, i64 %1285
%1287 = load double*, double** %1286
%1288 = load i32, i32* %21
%1289 = sext i32 %1288 to i64
%1290 = getelementptr inbounds double, double* %1287, i64 %1289
%1291 = load double, double* %1290
store double %1291, double* %42
%1292 = load double, double* %31
%1293 = load double, double* %42
%1294 = load double, double* %30
%1295 = load double**, double*** %12
%1296 = load i32, i32* %16
%1297 = sext i32 %1296 to i64
%1298 = getelementptr inbounds double*, double** %1295, i64 %1297
%1299 = load double*, double** %1298
%1300 = load i32, i32* %22
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds double, double* %1299, i64 %1301
%1303 = load double, double* %1302
%1304 = fmul double %1294, %1303
%1305 = call double @llvm.fmuladd.f64(double %1292, double %1293, double %1304)
%1306 = load double**, double*** %12
%1307 = load i32, i32* %16
%1308 = sext i32 %1307 to i64
%1309 = getelementptr inbounds double*, double** %1306, i64 %1308
%1310 = load double*, double** %1309
%1311 = load i32, i32* %21
%1312 = sext i32 %1311 to i64
%1313 = getelementptr inbounds double, double* %1310, i64 %1312
store double %1305, double* %1313
%1314 = load double, double* %31
%1315 = load double**, double*** %12
%1316 = load i32, i32* %16
%1317 = sext i32 %1316 to i64
%1318 = getelementptr inbounds double*, double** %1315, i64 %1317
%1319 = load double*, double** %1318
%1320 = load i32, i32* %22
%1321 = sext i32 %1320 to i64
%1322 = getelementptr inbounds double, double* %1319, i64 %1321
%1323 = load double, double* %1322
%1324 = load double, double* %30
%1325 = load double, double* %42
%1326 = fmul double %1324, %1325
%1327 = fneg double %1326
%1328 = call double @llvm.fmuladd.f64(double %1314, double %1323, double %1327)
%1329 = load double**, double*** %12
%1330 = load i32, i32* %16
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds double*, double** %1329, i64 %1331
%1333 = load double*, double** %1332
%1334 = load i32, i32* %22
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds double, double* %1333, i64 %1335
store double %1328, double* %1336
br label %1337
1337: ; preds = %1282
%1338 = load i32, i32* %16
%1339 = add nsw i32 %1338, 1
store i32 %1339, i32* %16
br label %1278
1340: ; preds = %1278
%1341 = load i32, i32* %10
store i32 %1341, i32* %16
br label %1342
1342: ; preds = %1401, %1340
%1343 = load i32, i32* %16
%1344 = load i32, i32* %11
%1345 = icmp sle i32 %1343, %1344
br i1 %1345, label %1346, label %1404
1346: ; preds = %1342
%1347 = load double**, double*** %15
%1348 = load i32, i32* %16
%1349 = sext i32 %1348 to i64
%1350 = getelementptr inbounds double*, double** %1347, i64 %1349
%1351 = load double*, double** %1350
%1352 = load i32, i32* %21
%1353 = sext i32 %1352 to i64
%1354 = getelementptr inbounds double, double* %1351, i64 %1353
%1355 = load double, double* %1354
store double %1355, double* %42
%1356 = load double, double* %31
%1357 = load double, double* %42
%1358 = load double, double* %30
%1359 = load double**, double*** %15
%1360 = load i32, i32* %16
%1361 = sext i32 %1360 to i64
%1362 = getelementptr inbounds double*, double** %1359, i64 %1361
%1363 = load double*, double** %1362
%1364 = load i32, i32* %22
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds double, double* %1363, i64 %1365
%1367 = load double, double* %1366
%1368 = fmul double %1358, %1367
%1369 = call double @llvm.fmuladd.f64(double %1356, double %1357, double %1368)
%1370 = load double**, double*** %15
%1371 = load i32, i32* %16
%1372 = sext i32 %1371 to i64
%1373 = getelementptr inbounds double*, double** %1370, i64 %1372
%1374 = load double*, double** %1373
%1375 = load i32, i32* %21
%1376 = sext i32 %1375 to i64
%1377 = getelementptr inbounds double, double* %1374, i64 %1376
store double %1369, double* %1377
%1378 = load double, double* %31
%1379 = load double**, double*** %15
%1380 = load i32, i32* %16
%1381 = sext i32 %1380 to i64
%1382 = getelementptr inbounds double*, double** %1379, i64 %1381
%1383 = load double*, double** %1382
%1384 = load i32, i32* %22
%1385 = sext i32 %1384 to i64
%1386 = getelementptr inbounds double, double* %1383, i64 %1385
%1387 = load double, double* %1386
%1388 = load double, double* %30
%1389 = load double, double* %42
%1390 = fmul double %1388, %1389
%1391 = fneg double %1390
%1392 = call double @llvm.fmuladd.f64(double %1378, double %1387, double %1391)
%1393 = load double**, double*** %15
%1394 = load i32, i32* %16
%1395 = sext i32 %1394 to i64
%1396 = getelementptr inbounds double*, double** %1393, i64 %1395
%1397 = load double*, double** %1396
%1398 = load i32, i32* %22
%1399 = sext i32 %1398 to i64
%1400 = getelementptr inbounds double, double* %1397, i64 %1399
store double %1392, double* %1400
br label %1401
1401: ; preds = %1346
%1402 = load i32, i32* %16
%1403 = add nsw i32 %1402, 1
store i32 %1403, i32* %16
br label %1342
1404: ; preds = %1342
br label %1431
1405: ; preds = %1091
%1406 = load double, double* %36
%1407 = load double, double* %30
%1408 = fadd double %1406, %1407
%1409 = load double*, double** %13
%1410 = load i32, i32* %21
%1411 = sext i32 %1410 to i64
%1412 = getelementptr inbounds double, double* %1409, i64 %1411
store double %1408, double* %1412
%1413 = load double, double* %36
%1414 = load double, double* %30
%1415 = fadd double %1413, %1414
%1416 = load double*, double** %13
%1417 = load i32, i32* %22
%1418 = sext i32 %1417 to i64
%1419 = getelementptr inbounds double, double* %1416, i64 %1418
store double %1415, double* %1419
%1420 = load double, double* %42
%1421 = load double*, double** %14
%1422 = load i32, i32* %21
%1423 = sext i32 %1422 to i64
%1424 = getelementptr inbounds double, double* %1421, i64 %1423
store double %1420, double* %1424
%1425 = load double, double* %42
%1426 = fneg double %1425
%1427 = load double*, double** %14
%1428 = load i32, i32* %22
%1429 = sext i32 %1428 to i64
%1430 = getelementptr inbounds double, double* %1427, i64 %1429
store double %1426, double* %1430
br label %1431
1431: ; preds = %1405, %1404
%1432 = load i32, i32* %27
store i32 %1432, i32* %22
br label %1463
1433: ; preds = %1088
%1434 = load double, double* %36
%1435 = load double, double* %34
%1436 = fadd double %1434, %1435
%1437 = load double**, double*** %12
%1438 = load i32, i32* %22
%1439 = sext i32 %1438 to i64
%1440 = getelementptr inbounds double*, double** %1437, i64 %1439
%1441 = load double*, double** %1440
%1442 = load i32, i32* %22
%1443 = sext i32 %1442 to i64
%1444 = getelementptr inbounds double, double* %1441, i64 %1443
store double %1436, double* %1444
%1445 = load double**, double*** %12
%1446 = load i32, i32* %22
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds double*, double** %1445, i64 %1447
%1449 = load double*, double** %1448
%1450 = load i32, i32* %22
%1451 = sext i32 %1450 to i64
%1452 = getelementptr inbounds double, double* %1449, i64 %1451
%1453 = load double, double* %1452
%1454 = load double*, double** %13
%1455 = load i32, i32* %22
%1456 = sext i32 %1455 to i64
%1457 = getelementptr inbounds double, double* %1454, i64 %1456
store double %1453, double* %1457
%1458 = load double*, double** %14
%1459 = load i32, i32* %22
%1460 = sext i32 %1459 to i64
%1461 = getelementptr inbounds double, double* %1458, i64 %1460
store double 0.000000e+00, double* %1461
%1462 = load i32, i32* %21
store i32 %1462, i32* %22
br label %1463
1463: ; preds = %1433, %1431
br label %106
1464: ; preds = %106
%1465 = load double, double* %29
%1466 = call double @llvm.fabs.f64(double %1465)
%1467 = fcmp olt double %1466, 1.000000e-30
br i1 %1467, label %1468, label %1469
1468: ; preds = %1464
store i32 0, i32* %8
br label %2479
1469: ; preds = %1464
%1470 = load i32, i32* %9
%1471 = sub nsw i32 %1470, 1
store i32 %1471, i32* %22
br label %1472
1472: ; preds = %2361, %1469
%1473 = load i32, i32* %22
%1474 = icmp sge i32 %1473, 0
br i1 %1474, label %1475, label %2364
1475: ; preds = %1472
%1476 = load double*, double** %13
%1477 = load i32, i32* %22
%1478 = sext i32 %1477 to i64
%1479 = getelementptr inbounds double, double* %1476, i64 %1478
%1480 = load double, double* %1479
store double %1480, double* %30
%1481 = load double*, double** %14
%1482 = load i32, i32* %22
%1483 = sext i32 %1482 to i64
%1484 = getelementptr inbounds double, double* %1481, i64 %1483
%1485 = load double, double* %1484
store double %1485, double* %31
%1486 = load i32, i32* %22
%1487 = sub nsw i32 %1486, 1
store i32 %1487, i32* %21
%1488 = load double, double* %31
%1489 = fcmp olt double %1488, 0xBD719799812DEA11
br i1 %1489, label %1490, label %2087
1490: ; preds = %1475
%1491 = load i32, i32* %21
store i32 %1491, i32* %20
%1492 = load double**, double*** %12
%1493 = load i32, i32* %22
%1494 = sext i32 %1493 to i64
%1495 = getelementptr inbounds double*, double** %1492, i64 %1494
%1496 = load double*, double** %1495
%1497 = load i32, i32* %21
%1498 = sext i32 %1497 to i64
%1499 = getelementptr inbounds double, double* %1496, i64 %1498
%1500 = load double, double* %1499
%1501 = call double @llvm.fabs.f64(double %1500)
%1502 = load double**, double*** %12
%1503 = load i32, i32* %21
%1504 = sext i32 %1503 to i64
%1505 = getelementptr inbounds double*, double** %1502, i64 %1504
%1506 = load double*, double** %1505
%1507 = load i32, i32* %22
%1508 = sext i32 %1507 to i64
%1509 = getelementptr inbounds double, double* %1506, i64 %1508
%1510 = load double, double* %1509
%1511 = call double @llvm.fabs.f64(double %1510)
%1512 = fcmp ogt double %1501, %1511
br i1 %1512, label %1513, label %1563
1513: ; preds = %1490
%1514 = load double, double* %31
%1515 = load double**, double*** %12
%1516 = load i32, i32* %22
%1517 = sext i32 %1516 to i64
%1518 = getelementptr inbounds double*, double** %1515, i64 %1517
%1519 = load double*, double** %1518
%1520 = load i32, i32* %21
%1521 = sext i32 %1520 to i64
%1522 = getelementptr inbounds double, double* %1519, i64 %1521
%1523 = load double, double* %1522
%1524 = fdiv double %1514, %1523
%1525 = load double**, double*** %12
%1526 = load i32, i32* %21
%1527 = sext i32 %1526 to i64
%1528 = getelementptr inbounds double*, double** %1525, i64 %1527
%1529 = load double*, double** %1528
%1530 = load i32, i32* %21
%1531 = sext i32 %1530 to i64
%1532 = getelementptr inbounds double, double* %1529, i64 %1531
store double %1524, double* %1532
%1533 = load double**, double*** %12
%1534 = load i32, i32* %22
%1535 = sext i32 %1534 to i64
%1536 = getelementptr inbounds double*, double** %1533, i64 %1535
%1537 = load double*, double** %1536
%1538 = load i32, i32* %22
%1539 = sext i32 %1538 to i64
%1540 = getelementptr inbounds double, double* %1537, i64 %1539
%1541 = load double, double* %1540
%1542 = load double, double* %30
%1543 = fsub double %1541, %1542
%1544 = fneg double %1543
%1545 = load double**, double*** %12
%1546 = load i32, i32* %22
%1547 = sext i32 %1546 to i64
%1548 = getelementptr inbounds double*, double** %1545, i64 %1547
%1549 = load double*, double** %1548
%1550 = load i32, i32* %21
%1551 = sext i32 %1550 to i64
%1552 = getelementptr inbounds double, double* %1549, i64 %1551
%1553 = load double, double* %1552
%1554 = fdiv double %1544, %1553
%1555 = load double**, double*** %12
%1556 = load i32, i32* %21
%1557 = sext i32 %1556 to i64
%1558 = getelementptr inbounds double*, double** %1555, i64 %1557
%1559 = load double*, double** %1558
%1560 = load i32, i32* %22
%1561 = sext i32 %1560 to i64
%1562 = getelementptr inbounds double, double* %1559, i64 %1561
store double %1554, double* %1562
br label %1603
1563: ; preds = %1490
%1564 = load double**, double*** %12
%1565 = load i32, i32* %21
%1566 = sext i32 %1565 to i64
%1567 = getelementptr inbounds double*, double** %1564, i64 %1566
%1568 = load double*, double** %1567
%1569 = load i32, i32* %22
%1570 = sext i32 %1569 to i64
%1571 = getelementptr inbounds double, double* %1568, i64 %1570
%1572 = load double, double* %1571
%1573 = fneg double %1572
%1574 = load double**, double*** %12
%1575 = load i32, i32* %21
%1576 = sext i32 %1575 to i64
%1577 = getelementptr inbounds double*, double** %1574, i64 %1576
%1578 = load double*, double** %1577
%1579 = load i32, i32* %21
%1580 = sext i32 %1579 to i64
%1581 = getelementptr inbounds double, double* %1578, i64 %1580
%1582 = load double, double* %1581
%1583 = load double, double* %30
%1584 = fsub double %1582, %1583
%1585 = load double, double* %31
%1586 = load double**, double*** %12
%1587 = load i32, i32* %21
%1588 = sext i32 %1587 to i64
%1589 = getelementptr inbounds double*, double** %1586, i64 %1588
%1590 = load double*, double** %1589
%1591 = load i32, i32* %21
%1592 = sext i32 %1591 to i64
%1593 = getelementptr inbounds double, double* %1590, i64 %1592
%1594 = load double**, double*** %12
%1595 = load i32, i32* %21
%1596 = sext i32 %1595 to i64
%1597 = getelementptr inbounds double*, double** %1594, i64 %1596
%1598 = load double*, double** %1597
%1599 = load i32, i32* %22
%1600 = sext i32 %1599 to i64
%1601 = getelementptr inbounds double, double* %1598, i64 %1600
%1602 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double 0.000000e+00, double %1573, double %1584, double %1585, double* %1593, double* %1601)
br label %1603
1603: ; preds = %1563, %1513
%1604 = load double**, double*** %12
%1605 = load i32, i32* %22
%1606 = sext i32 %1605 to i64
%1607 = getelementptr inbounds double*, double** %1604, i64 %1606
%1608 = load double*, double** %1607
%1609 = load i32, i32* %21
%1610 = sext i32 %1609 to i64
%1611 = getelementptr inbounds double, double* %1608, i64 %1610
store double 0.000000e+00, double* %1611
%1612 = load double**, double*** %12
%1613 = load i32, i32* %22
%1614 = sext i32 %1613 to i64
%1615 = getelementptr inbounds double*, double** %1612, i64 %1614
%1616 = load double*, double** %1615
%1617 = load i32, i32* %22
%1618 = sext i32 %1617 to i64
%1619 = getelementptr inbounds double, double* %1616, i64 %1618
store double 1.000000e+00, double* %1619
%1620 = load i32, i32* %21
%1621 = sub nsw i32 %1620, 1
store i32 %1621, i32* %27
%1622 = load i32, i32* %27
%1623 = icmp sge i32 %1622, 0
br i1 %1623, label %1624, label %2086
1624: ; preds = %1603
%1625 = load i32, i32* %27
store i32 %1625, i32* %16
br label %1626
1626: ; preds = %2082, %1624
%1627 = load i32, i32* %16
%1628 = icmp sge i32 %1627, 0
br i1 %1628, label %1629, label %2085
1629: ; preds = %1626
%1630 = load double**, double*** %12
%1631 = load i32, i32* %16
%1632 = sext i32 %1631 to i64
%1633 = getelementptr inbounds double*, double** %1630, i64 %1632
%1634 = load double*, double** %1633
%1635 = load i32, i32* %16
%1636 = sext i32 %1635 to i64
%1637 = getelementptr inbounds double, double* %1634, i64 %1636
%1638 = load double, double* %1637
%1639 = load double, double* %30
%1640 = fsub double %1638, %1639
store double %1640, double* %35
store double 0.000000e+00, double* %38
store double 0.000000e+00, double* %39
%1641 = load i32, i32* %20
store i32 %1641, i32* %17
br label %1642
1642: ; preds = %1687, %1629
%1643 = load i32, i32* %17
%1644 = load i32, i32* %22
%1645 = icmp sle i32 %1643, %1644
br i1 %1645, label %1646, label %1690
1646: ; preds = %1642
%1647 = load double**, double*** %12
%1648 = load i32, i32* %16
%1649 = sext i32 %1648 to i64
%1650 = getelementptr inbounds double*, double** %1647, i64 %1649
%1651 = load double*, double** %1650
%1652 = load i32, i32* %17
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds double, double* %1651, i64 %1653
%1655 = load double, double* %1654
%1656 = load double**, double*** %12
%1657 = load i32, i32* %17
%1658 = sext i32 %1657 to i64
%1659 = getelementptr inbounds double*, double** %1656, i64 %1658
%1660 = load double*, double** %1659
%1661 = load i32, i32* %21
%1662 = sext i32 %1661 to i64
%1663 = getelementptr inbounds double, double* %1660, i64 %1662
%1664 = load double, double* %1663
%1665 = load double, double* %38
%1666 = call double @llvm.fmuladd.f64(double %1655, double %1664, double %1665)
store double %1666, double* %38
%1667 = load double**, double*** %12
%1668 = load i32, i32* %16
%1669 = sext i32 %1668 to i64
%1670 = getelementptr inbounds double*, double** %1667, i64 %1669
%1671 = load double*, double** %1670
%1672 = load i32, i32* %17
%1673 = sext i32 %1672 to i64
%1674 = getelementptr inbounds double, double* %1671, i64 %1673
%1675 = load double, double* %1674
%1676 = load double**, double*** %12
%1677 = load i32, i32* %17
%1678 = sext i32 %1677 to i64
%1679 = getelementptr inbounds double*, double** %1676, i64 %1678
%1680 = load double*, double** %1679
%1681 = load i32, i32* %22
%1682 = sext i32 %1681 to i64
%1683 = getelementptr inbounds double, double* %1680, i64 %1682
%1684 = load double, double* %1683
%1685 = load double, double* %39
%1686 = call double @llvm.fmuladd.f64(double %1675, double %1684, double %1685)
store double %1686, double* %39
br label %1687
1687: ; preds = %1646
%1688 = load i32, i32* %17
%1689 = add nsw i32 %1688, 1
store i32 %1689, i32* %17
br label %1642
1690: ; preds = %1642
%1691 = load double*, double** %14
%1692 = load i32, i32* %16
%1693 = sext i32 %1692 to i64
%1694 = getelementptr inbounds double, double* %1691, i64 %1693
%1695 = load double, double* %1694
%1696 = fcmp olt double %1695, 0.000000e+00
br i1 %1696, label %1697, label %1701
1697: ; preds = %1690
%1698 = load double, double* %35
store double %1698, double* %42
%1699 = load double, double* %38
store double %1699, double* %32
%1700 = load double, double* %39
store double %1700, double* %33
br label %2081
1701: ; preds = %1690
%1702 = load i32, i32* %16
store i32 %1702, i32* %20
%1703 = load double*, double** %14
%1704 = load i32, i32* %16
%1705 = sext i32 %1704 to i64
%1706 = getelementptr inbounds double, double* %1703, i64 %1705
%1707 = load double, double* %1706
%1708 = call double @llvm.fabs.f64(double %1707)
%1709 = fcmp olt double %1708, 1.000000e-30
br i1 %1709, label %1710, label %1734
1710: ; preds = %1701
%1711 = load double, double* %38
%1712 = fneg double %1711
%1713 = load double, double* %39
%1714 = fneg double %1713
%1715 = load double, double* %35
%1716 = load double, double* %31
%1717 = load double**, double*** %12
%1718 = load i32, i32* %16
%1719 = sext i32 %1718 to i64
%1720 = getelementptr inbounds double*, double** %1717, i64 %1719
%1721 = load double*, double** %1720
%1722 = load i32, i32* %21
%1723 = sext i32 %1722 to i64
%1724 = getelementptr inbounds double, double* %1721, i64 %1723
%1725 = load double**, double*** %12
%1726 = load i32, i32* %16
%1727 = sext i32 %1726 to i64
%1728 = getelementptr inbounds double*, double** %1725, i64 %1727
%1729 = load double*, double** %1728
%1730 = load i32, i32* %22
%1731 = sext i32 %1730 to i64
%1732 = getelementptr inbounds double, double* %1729, i64 %1731
%1733 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double %1712, double %1714, double %1715, double %1716, double* %1724, double* %1732)
br label %2005
1734: ; preds = %1701
%1735 = load double**, double*** %12
%1736 = load i32, i32* %16
%1737 = sext i32 %1736 to i64
%1738 = getelementptr inbounds double*, double** %1735, i64 %1737
%1739 = load double*, double** %1738
%1740 = load i32, i32* %16
%1741 = add nsw i32 %1740, 1
%1742 = sext i32 %1741 to i64
%1743 = getelementptr inbounds double, double* %1739, i64 %1742
%1744 = load double, double* %1743
store double %1744, double* %36
%1745 = load double**, double*** %12
%1746 = load i32, i32* %16
%1747 = add nsw i32 %1746, 1
%1748 = sext i32 %1747 to i64
%1749 = getelementptr inbounds double*, double** %1745, i64 %1748
%1750 = load double*, double** %1749
%1751 = load i32, i32* %16
%1752 = sext i32 %1751 to i64
%1753 = getelementptr inbounds double, double* %1750, i64 %1752
%1754 = load double, double* %1753
store double %1754, double* %37
%1755 = load double*, double** %13
%1756 = load i32, i32* %16
%1757 = sext i32 %1756 to i64
%1758 = getelementptr inbounds double, double* %1755, i64 %1757
%1759 = load double, double* %1758
%1760 = load double, double* %30
%1761 = fsub double %1759, %1760
%1762 = load double*, double** %13
%1763 = load i32, i32* %16
%1764 = sext i32 %1763 to i64
%1765 = getelementptr inbounds double, double* %1762, i64 %1764
%1766 = load double, double* %1765
%1767 = load double, double* %30
%1768 = fsub double %1766, %1767
%1769 = load double*, double** %14
%1770 = load i32, i32* %16
%1771 = sext i32 %1770 to i64
%1772 = getelementptr inbounds double, double* %1769, i64 %1771
%1773 = load double, double* %1772
%1774 = load double*, double** %14
%1775 = load i32, i32* %16
%1776 = sext i32 %1775 to i64
%1777 = getelementptr inbounds double, double* %1774, i64 %1776
%1778 = load double, double* %1777
%1779 = fmul double %1773, %1778
%1780 = call double @llvm.fmuladd.f64(double %1761, double %1768, double %1779)
%1781 = load double, double* %31
%1782 = load double, double* %31
%1783 = fneg double %1781
%1784 = call double @llvm.fmuladd.f64(double %1783, double %1782, double %1780)
store double %1784, double* %41
%1785 = load double*, double** %13
%1786 = load i32, i32* %16
%1787 = sext i32 %1786 to i64
%1788 = getelementptr inbounds double, double* %1785, i64 %1787
%1789 = load double, double* %1788
%1790 = load double, double* %30
%1791 = fsub double %1789, %1790
%1792 = fmul double %1791, 2.000000e+00
%1793 = load double, double* %31
%1794 = fmul double %1792, %1793
store double %1794, double* %40
%1795 = load double, double* %41
%1796 = call double @llvm.fabs.f64(double %1795)
%1797 = fcmp olt double %1796, 1.000000e-30
br i1 %1797, label %1798, label %1831
1798: ; preds = %1734
%1799 = load double, double* %40
%1800 = call double @llvm.fabs.f64(double %1799)
%1801 = fcmp olt double %1800, 1.000000e-30
br i1 %1801, label %1802, label %1831
1802: ; preds = %1798
%1803 = load double, double* %29
%1804 = load double, double* %35
%1805 = call double @llvm.fabs.f64(double %1804)
%1806 = load double, double* %31
%1807 = call double @llvm.fabs.f64(double %1806)
%1808 = fadd double %1805, %1807
%1809 = load double, double* %36
%1810 = call double @llvm.fabs.f64(double %1809)
%1811 = fadd double %1808, %1810
%1812 = load double, double* %37
%1813 = call double @llvm.fabs.f64(double %1812)
%1814 = fadd double %1811, %1813
%1815 = load double, double* %42
%1816 = call double @llvm.fabs.f64(double %1815)
%1817 = fadd double %1814, %1816
%1818 = fmul double %1803, %1817
store double %1818, double* %43
%1819 = load double, double* %43
store double %1819, double* %41
br label %1820
1820: ; preds = %1826, %1802
%1821 = load double, double* %41
%1822 = fmul double %1821, 1.000000e-02
store double %1822, double* %41
%1823 = load double, double* %43
%1824 = load double, double* %41
%1825 = fadd double %1823, %1824
store double %1825, double* %44
br label %1826
1826: ; preds = %1820
%1827 = load double, double* %44
%1828 = load double, double* %43
%1829 = fcmp ogt double %1827, %1828
br i1 %1829, label %1820, label %1830
1830: ; preds = %1826
br label %1831
1831: ; preds = %1830, %1798, %1734
%1832 = load double, double* %36
%1833 = load double, double* %32
%1834 = load double, double* %42
%1835 = load double, double* %38
%1836 = fmul double %1834, %1835
%1837 = fneg double %1836
%1838 = call double @llvm.fmuladd.f64(double %1832, double %1833, double %1837)
%1839 = load double, double* %31
%1840 = load double, double* %39
%1841 = call double @llvm.fmuladd.f64(double %1839, double %1840, double %1838)
%1842 = load double, double* %36
%1843 = load double, double* %33
%1844 = load double, double* %42
%1845 = load double, double* %39
%1846 = fmul double %1844, %1845
%1847 = fneg double %1846
%1848 = call double @llvm.fmuladd.f64(double %1842, double %1843, double %1847)
%1849 = load double, double* %31
%1850 = load double, double* %38
%1851 = fneg double %1849
%1852 = call double @llvm.fmuladd.f64(double %1851, double %1850, double %1848)
%1853 = load double, double* %41
%1854 = load double, double* %40
%1855 = load double**, double*** %12
%1856 = load i32, i32* %16
%1857 = sext i32 %1856 to i64
%1858 = getelementptr inbounds double*, double** %1855, i64 %1857
%1859 = load double*, double** %1858
%1860 = load i32, i32* %21
%1861 = sext i32 %1860 to i64
%1862 = getelementptr inbounds double, double* %1859, i64 %1861
%1863 = load double**, double*** %12
%1864 = load i32, i32* %16
%1865 = sext i32 %1864 to i64
%1866 = getelementptr inbounds double*, double** %1863, i64 %1865
%1867 = load double*, double** %1866
%1868 = load i32, i32* %22
%1869 = sext i32 %1868 to i64
%1870 = getelementptr inbounds double, double* %1867, i64 %1869
%1871 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double %1841, double %1852, double %1853, double %1854, double* %1862, double* %1870)
%1872 = load double, double* %36
%1873 = call double @llvm.fabs.f64(double %1872)
%1874 = load double, double* %42
%1875 = call double @llvm.fabs.f64(double %1874)
%1876 = load double, double* %31
%1877 = call double @llvm.fabs.f64(double %1876)
%1878 = fadd double %1875, %1877
%1879 = fcmp ogt double %1873, %1878
br i1 %1879, label %1880, label %1954
1880: ; preds = %1831
%1881 = load double, double* %38
%1882 = fneg double %1881
%1883 = load double, double* %35
%1884 = load double**, double*** %12
%1885 = load i32, i32* %16
%1886 = sext i32 %1885 to i64
%1887 = getelementptr inbounds double*, double** %1884, i64 %1886
%1888 = load double*, double** %1887
%1889 = load i32, i32* %21
%1890 = sext i32 %1889 to i64
%1891 = getelementptr inbounds double, double* %1888, i64 %1890
%1892 = load double, double* %1891
%1893 = fneg double %1883
%1894 = call double @llvm.fmuladd.f64(double %1893, double %1892, double %1882)
%1895 = load double, double* %31
%1896 = load double**, double*** %12
%1897 = load i32, i32* %16
%1898 = sext i32 %1897 to i64
%1899 = getelementptr inbounds double*, double** %1896, i64 %1898
%1900 = load double*, double** %1899
%1901 = load i32, i32* %22
%1902 = sext i32 %1901 to i64
%1903 = getelementptr inbounds double, double* %1900, i64 %1902
%1904 = load double, double* %1903
%1905 = call double @llvm.fmuladd.f64(double %1895, double %1904, double %1894)
%1906 = load double, double* %36
%1907 = fdiv double %1905, %1906
%1908 = load double**, double*** %12
%1909 = load i32, i32* %16
%1910 = add nsw i32 %1909, 1
%1911 = sext i32 %1910 to i64
%1912 = getelementptr inbounds double*, double** %1908, i64 %1911
%1913 = load double*, double** %1912
%1914 = load i32, i32* %21
%1915 = sext i32 %1914 to i64
%1916 = getelementptr inbounds double, double* %1913, i64 %1915
store double %1907, double* %1916
%1917 = load double, double* %39
%1918 = fneg double %1917
%1919 = load double, double* %35
%1920 = load double**, double*** %12
%1921 = load i32, i32* %16
%1922 = sext i32 %1921 to i64
%1923 = getelementptr inbounds double*, double** %1920, i64 %1922
%1924 = load double*, double** %1923
%1925 = load i32, i32* %22
%1926 = sext i32 %1925 to i64
%1927 = getelementptr inbounds double, double* %1924, i64 %1926
%1928 = load double, double* %1927
%1929 = fneg double %1919
%1930 = call double @llvm.fmuladd.f64(double %1929, double %1928, double %1918)
%1931 = load double, double* %31
%1932 = load double**, double*** %12
%1933 = load i32, i32* %16
%1934 = sext i32 %1933 to i64
%1935 = getelementptr inbounds double*, double** %1932, i64 %1934
%1936 = load double*, double** %1935
%1937 = load i32, i32* %21
%1938 = sext i32 %1937 to i64
%1939 = getelementptr inbounds double, double* %1936, i64 %1938
%1940 = load double, double* %1939
%1941 = fneg double %1931
%1942 = call double @llvm.fmuladd.f64(double %1941, double %1940, double %1930)
%1943 = load double, double* %36
%1944 = fdiv double %1942, %1943
%1945 = load double**, double*** %12
%1946 = load i32, i32* %16
%1947 = add nsw i32 %1946, 1
%1948 = sext i32 %1947 to i64
%1949 = getelementptr inbounds double*, double** %1945, i64 %1948
%1950 = load double*, double** %1949
%1951 = load i32, i32* %22
%1952 = sext i32 %1951 to i64
%1953 = getelementptr inbounds double, double* %1950, i64 %1952
store double %1944, double* %1953
br label %2004
1954: ; preds = %1831
%1955 = load double, double* %32
%1956 = fneg double %1955
%1957 = load double, double* %37
%1958 = load double**, double*** %12
%1959 = load i32, i32* %16
%1960 = sext i32 %1959 to i64
%1961 = getelementptr inbounds double*, double** %1958, i64 %1960
%1962 = load double*, double** %1961
%1963 = load i32, i32* %21
%1964 = sext i32 %1963 to i64
%1965 = getelementptr inbounds double, double* %1962, i64 %1964
%1966 = load double, double* %1965
%1967 = fneg double %1957
%1968 = call double @llvm.fmuladd.f64(double %1967, double %1966, double %1956)
%1969 = load double, double* %33
%1970 = fneg double %1969
%1971 = load double, double* %37
%1972 = load double**, double*** %12
%1973 = load i32, i32* %16
%1974 = sext i32 %1973 to i64
%1975 = getelementptr inbounds double*, double** %1972, i64 %1974
%1976 = load double*, double** %1975
%1977 = load i32, i32* %22
%1978 = sext i32 %1977 to i64
%1979 = getelementptr inbounds double, double* %1976, i64 %1978
%1980 = load double, double* %1979
%1981 = fneg double %1971
%1982 = call double @llvm.fmuladd.f64(double %1981, double %1980, double %1970)
%1983 = load double, double* %42
%1984 = load double, double* %31
%1985 = load double**, double*** %12
%1986 = load i32, i32* %16
%1987 = add nsw i32 %1986, 1
%1988 = sext i32 %1987 to i64
%1989 = getelementptr inbounds double*, double** %1985, i64 %1988
%1990 = load double*, double** %1989
%1991 = load i32, i32* %21
%1992 = sext i32 %1991 to i64
%1993 = getelementptr inbounds double, double* %1990, i64 %1992
%1994 = load double**, double*** %12
%1995 = load i32, i32* %16
%1996 = add nsw i32 %1995, 1
%1997 = sext i32 %1996 to i64
%1998 = getelementptr inbounds double*, double** %1994, i64 %1997
%1999 = load double*, double** %1998
%2000 = load i32, i32* %22
%2001 = sext i32 %2000 to i64
%2002 = getelementptr inbounds double, double* %1999, i64 %2001
%2003 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double %1968, double %1982, double %1983, double %1984, double* %1993, double* %2002)
br label %2004
2004: ; preds = %1954, %1880
br label %2005
2005: ; preds = %2004, %1710
%2006 = load double**, double*** %12
%2007 = load i32, i32* %16
%2008 = sext i32 %2007 to i64
%2009 = getelementptr inbounds double*, double** %2006, i64 %2008
%2010 = load double*, double** %2009
%2011 = load i32, i32* %21
%2012 = sext i32 %2011 to i64
%2013 = getelementptr inbounds double, double* %2010, i64 %2012
%2014 = load double, double* %2013
%2015 = call double @llvm.fabs.f64(double %2014)
store double %2015, double* %43
%2016 = load double**, double*** %12
%2017 = load i32, i32* %16
%2018 = sext i32 %2017 to i64
%2019 = getelementptr inbounds double*, double** %2016, i64 %2018
%2020 = load double*, double** %2019
%2021 = load i32, i32* %22
%2022 = sext i32 %2021 to i64
%2023 = getelementptr inbounds double, double* %2020, i64 %2022
%2024 = load double, double* %2023
%2025 = call double @llvm.fabs.f64(double %2024)
store double %2025, double* %44
%2026 = load double, double* %43
%2027 = load double, double* %44
%2028 = fcmp ogt double %2026, %2027
br i1 %2028, label %2029, label %2031
2029: ; preds = %2005
%2030 = load double, double* %43
br label %2033
2031: ; preds = %2005
%2032 = load double, double* %44
br label %2033
2033: ; preds = %2031, %2029
%2034 = phi double [ %2030, %2029 ], [ %2032, %2031 ]
store double %2034, double* %34
%2035 = load double, double* %34
%2036 = fcmp ogt double %2035, 1.000000e-30
br i1 %2036, label %2037, label %2080
2037: ; preds = %2033
%2038 = load double, double* %34
store double %2038, double* %43
%2039 = load double, double* %43
%2040 = load double, double* %43
%2041 = fdiv double 1.000000e+00, %2040
%2042 = fadd double %2039, %2041
store double %2042, double* %44
%2043 = load double, double* %44
%2044 = load double, double* %43
%2045 = fcmp ole double %2043, %2044
br i1 %2045, label %2046, label %2079
2046: ; preds = %2037
%2047 = load i32, i32* %16
store i32 %2047, i32* %17
br label %2048
2048: ; preds = %2075, %2046
%2049 = load i32, i32* %17
%2050 = load i32, i32* %22
%2051 = icmp sle i32 %2049, %2050
br i1 %2051, label %2052, label %2078
2052: ; preds = %2048
%2053 = load double, double* %34
%2054 = load double**, double*** %12
%2055 = load i32, i32* %17
%2056 = sext i32 %2055 to i64
%2057 = getelementptr inbounds double*, double** %2054, i64 %2056
%2058 = load double*, double** %2057
%2059 = load i32, i32* %21
%2060 = sext i32 %2059 to i64
%2061 = getelementptr inbounds double, double* %2058, i64 %2060
%2062 = load double, double* %2061
%2063 = fdiv double %2062, %2053
store double %2063, double* %2061
%2064 = load double, double* %34
%2065 = load double**, double*** %12
%2066 = load i32, i32* %17
%2067 = sext i32 %2066 to i64
%2068 = getelementptr inbounds double*, double** %2065, i64 %2067
%2069 = load double*, double** %2068
%2070 = load i32, i32* %22
%2071 = sext i32 %2070 to i64
%2072 = getelementptr inbounds double, double* %2069, i64 %2071
%2073 = load double, double* %2072
%2074 = fdiv double %2073, %2064
store double %2074, double* %2072
br label %2075
2075: ; preds = %2052
%2076 = load i32, i32* %17
%2077 = add nsw i32 %2076, 1
store i32 %2077, i32* %17
br label %2048
2078: ; preds = %2048
br label %2079
2079: ; preds = %2078, %2037
br label %2080
2080: ; preds = %2079, %2033
br label %2081
2081: ; preds = %2080, %1697
br label %2082
2082: ; preds = %2081
%2083 = load i32, i32* %16
%2084 = add nsw i32 %2083, -1
store i32 %2084, i32* %16
br label %1626
2085: ; preds = %1626
br label %2086
2086: ; preds = %2085, %1603
br label %2360
2087: ; preds = %1475
%2088 = load double, double* %31
%2089 = call double @llvm.fabs.f64(double %2088)
%2090 = fcmp olt double %2089, 1.000000e-30
br i1 %2090, label %2091, label %2359
2091: ; preds = %2087
%2092 = load i32, i32* %22
store i32 %2092, i32* %20
%2093 = load double**, double*** %12
%2094 = load i32, i32* %22
%2095 = sext i32 %2094 to i64
%2096 = getelementptr inbounds double*, double** %2093, i64 %2095
%2097 = load double*, double** %2096
%2098 = load i32, i32* %22
%2099 = sext i32 %2098 to i64
%2100 = getelementptr inbounds double, double* %2097, i64 %2099
store double 1.000000e+00, double* %2100
%2101 = load i32, i32* %21
%2102 = icmp sge i32 %2101, 0
br i1 %2102, label %2103, label %2358
2103: ; preds = %2091
%2104 = load i32, i32* %21
store i32 %2104, i32* %16
br label %2105
2105: ; preds = %2354, %2103
%2106 = load i32, i32* %16
%2107 = icmp sge i32 %2106, 0
br i1 %2107, label %2108, label %2357
2108: ; preds = %2105
%2109 = load double**, double*** %12
%2110 = load i32, i32* %16
%2111 = sext i32 %2110 to i64
%2112 = getelementptr inbounds double*, double** %2109, i64 %2111
%2113 = load double*, double** %2112
%2114 = load i32, i32* %16
%2115 = sext i32 %2114 to i64
%2116 = getelementptr inbounds double, double* %2113, i64 %2115
%2117 = load double, double* %2116
%2118 = load double, double* %30
%2119 = fsub double %2117, %2118
store double %2119, double* %35
store double 0.000000e+00, double* %32
%2120 = load i32, i32* %20
store i32 %2120, i32* %17
br label %2121
2121: ; preds = %2146, %2108
%2122 = load i32, i32* %17
%2123 = load i32, i32* %22
%2124 = icmp sle i32 %2122, %2123
br i1 %2124, label %2125, label %2149
2125: ; preds = %2121
%2126 = load double**, double*** %12
%2127 = load i32, i32* %16
%2128 = sext i32 %2127 to i64
%2129 = getelementptr inbounds double*, double** %2126, i64 %2128
%2130 = load double*, double** %2129
%2131 = load i32, i32* %17
%2132 = sext i32 %2131 to i64
%2133 = getelementptr inbounds double, double* %2130, i64 %2132
%2134 = load double, double* %2133
%2135 = load double**, double*** %12
%2136 = load i32, i32* %17
%2137 = sext i32 %2136 to i64
%2138 = getelementptr inbounds double*, double** %2135, i64 %2137
%2139 = load double*, double** %2138
%2140 = load i32, i32* %22
%2141 = sext i32 %2140 to i64
%2142 = getelementptr inbounds double, double* %2139, i64 %2141
%2143 = load double, double* %2142
%2144 = load double, double* %32
%2145 = call double @llvm.fmuladd.f64(double %2134, double %2143, double %2144)
store double %2145, double* %32
br label %2146
2146: ; preds = %2125
%2147 = load i32, i32* %17
%2148 = add nsw i32 %2147, 1
store i32 %2148, i32* %17
br label %2121
2149: ; preds = %2121
%2150 = load double*, double** %14
%2151 = load i32, i32* %16
%2152 = sext i32 %2151 to i64
%2153 = getelementptr inbounds double, double* %2150, i64 %2152
%2154 = load double, double* %2153
%2155 = fcmp olt double %2154, 0.000000e+00
br i1 %2155, label %2156, label %2159
2156: ; preds = %2149
%2157 = load double, double* %35
store double %2157, double* %42
%2158 = load double, double* %32
store double %2158, double* %33
br label %2354
2159: ; preds = %2149
%2160 = load i32, i32* %16
store i32 %2160, i32* %20
%2161 = load double*, double** %14
%2162 = load i32, i32* %16
%2163 = sext i32 %2162 to i64
%2164 = getelementptr inbounds double, double* %2161, i64 %2163
%2165 = load double, double* %2164
%2166 = call double @llvm.fabs.f64(double %2165)
%2167 = fcmp olt double %2166, 1.000000e-30
br i1 %2167, label %2168, label %2200
2168: ; preds = %2159
%2169 = load double, double* %35
store double %2169, double* %34
%2170 = load double, double* %34
%2171 = call double @llvm.fabs.f64(double %2170)
%2172 = fcmp olt double %2171, 1.000000e-30
br i1 %2172, label %2173, label %2187
2173: ; preds = %2168
%2174 = load double, double* %29
store double %2174, double* %43
%2175 = load double, double* %43
store double %2175, double* %34
br label %2176
2176: ; preds = %2182, %2173
%2177 = load double, double* %34
%2178 = fmul double %2177, 1.000000e-02
store double %2178, double* %34
%2179 = load double, double* %29
%2180 = load double, double* %34
%2181 = fadd double %2179, %2180
store double %2181, double* %44
br label %2182
2182: ; preds = %2176
%2183 = load double, double* %44
%2184 = load double, double* %43
%2185 = fcmp ogt double %2183, %2184
br i1 %2185, label %2176, label %2186
2186: ; preds = %2182
br label %2187
2187: ; preds = %2186, %2168
%2188 = load double, double* %32
%2189 = fneg double %2188
%2190 = load double, double* %34
%2191 = fdiv double %2189, %2190
%2192 = load double**, double*** %12
%2193 = load i32, i32* %16
%2194 = sext i32 %2193 to i64
%2195 = getelementptr inbounds double*, double** %2192, i64 %2194
%2196 = load double*, double** %2195
%2197 = load i32, i32* %22
%2198 = sext i32 %2197 to i64
%2199 = getelementptr inbounds double, double* %2196, i64 %2198
store double %2191, double* %2199
br label %2307
2200: ; preds = %2159
%2201 = load double**, double*** %12
%2202 = load i32, i32* %16
%2203 = sext i32 %2202 to i64
%2204 = getelementptr inbounds double*, double** %2201, i64 %2203
%2205 = load double*, double** %2204
%2206 = load i32, i32* %16
%2207 = add nsw i32 %2206, 1
%2208 = sext i32 %2207 to i64
%2209 = getelementptr inbounds double, double* %2205, i64 %2208
%2210 = load double, double* %2209
store double %2210, double* %36
%2211 = load double**, double*** %12
%2212 = load i32, i32* %16
%2213 = add nsw i32 %2212, 1
%2214 = sext i32 %2213 to i64
%2215 = getelementptr inbounds double*, double** %2211, i64 %2214
%2216 = load double*, double** %2215
%2217 = load i32, i32* %16
%2218 = sext i32 %2217 to i64
%2219 = getelementptr inbounds double, double* %2216, i64 %2218
%2220 = load double, double* %2219
store double %2220, double* %37
%2221 = load double*, double** %13
%2222 = load i32, i32* %16
%2223 = sext i32 %2222 to i64
%2224 = getelementptr inbounds double, double* %2221, i64 %2223
%2225 = load double, double* %2224
%2226 = load double, double* %30
%2227 = fsub double %2225, %2226
%2228 = load double*, double** %13
%2229 = load i32, i32* %16
%2230 = sext i32 %2229 to i64
%2231 = getelementptr inbounds double, double* %2228, i64 %2230
%2232 = load double, double* %2231
%2233 = load double, double* %30
%2234 = fsub double %2232, %2233
%2235 = load double*, double** %14
%2236 = load i32, i32* %16
%2237 = sext i32 %2236 to i64
%2238 = getelementptr inbounds double, double* %2235, i64 %2237
%2239 = load double, double* %2238
%2240 = load double*, double** %14
%2241 = load i32, i32* %16
%2242 = sext i32 %2241 to i64
%2243 = getelementptr inbounds double, double* %2240, i64 %2242
%2244 = load double, double* %2243
%2245 = fmul double %2239, %2244
%2246 = call double @llvm.fmuladd.f64(double %2227, double %2234, double %2245)
store double %2246, double* %31
%2247 = load double, double* %36
%2248 = load double, double* %33
%2249 = load double, double* %42
%2250 = load double, double* %32
%2251 = fmul double %2249, %2250
%2252 = fneg double %2251
%2253 = call double @llvm.fmuladd.f64(double %2247, double %2248, double %2252)
%2254 = load double, double* %31
%2255 = fdiv double %2253, %2254
store double %2255, double* %34
%2256 = load double, double* %34
%2257 = load double**, double*** %12
%2258 = load i32, i32* %16
%2259 = sext i32 %2258 to i64
%2260 = getelementptr inbounds double*, double** %2257, i64 %2259
%2261 = load double*, double** %2260
%2262 = load i32, i32* %22
%2263 = sext i32 %2262 to i64
%2264 = getelementptr inbounds double, double* %2261, i64 %2263
store double %2256, double* %2264
%2265 = load double, double* %36
%2266 = call double @llvm.fabs.f64(double %2265)
%2267 = load double, double* %42
%2268 = call double @llvm.fabs.f64(double %2267)
%2269 = fcmp ogt double %2266, %2268
br i1 %2269, label %2270, label %2288
2270: ; preds = %2200
%2271 = load double, double* %32
%2272 = fneg double %2271
%2273 = load double, double* %35
%2274 = load double, double* %34
%2275 = fneg double %2273
%2276 = call double @llvm.fmuladd.f64(double %2275, double %2274, double %2272)
%2277 = load double, double* %36
%2278 = fdiv double %2276, %2277
%2279 = load double**, double*** %12
%2280 = load i32, i32* %16
%2281 = add nsw i32 %2280, 1
%2282 = sext i32 %2281 to i64
%2283 = getelementptr inbounds double*, double** %2279, i64 %2282
%2284 = load double*, double** %2283
%2285 = load i32, i32* %22
%2286 = sext i32 %2285 to i64
%2287 = getelementptr inbounds double, double* %2284, i64 %2286
store double %2278, double* %2287
br label %2306
2288: ; preds = %2200
%2289 = load double, double* %33
%2290 = fneg double %2289
%2291 = load double, double* %37
%2292 = load double, double* %34
%2293 = fneg double %2291
%2294 = call double @llvm.fmuladd.f64(double %2293, double %2292, double %2290)
%2295 = load double, double* %42
%2296 = fdiv double %2294, %2295
%2297 = load double**, double*** %12
%2298 = load i32, i32* %16
%2299 = add nsw i32 %2298, 1
%2300 = sext i32 %2299 to i64
%2301 = getelementptr inbounds double*, double** %2297, i64 %2300
%2302 = load double*, double** %2301
%2303 = load i32, i32* %22
%2304 = sext i32 %2303 to i64
%2305 = getelementptr inbounds double, double* %2302, i64 %2304
store double %2296, double* %2305
br label %2306
2306: ; preds = %2288, %2270
br label %2307
2307: ; preds = %2306, %2187
%2308 = load double**, double*** %12
%2309 = load i32, i32* %16
%2310 = sext i32 %2309 to i64
%2311 = getelementptr inbounds double*, double** %2308, i64 %2310
%2312 = load double*, double** %2311
%2313 = load i32, i32* %22
%2314 = sext i32 %2313 to i64
%2315 = getelementptr inbounds double, double* %2312, i64 %2314
%2316 = load double, double* %2315
%2317 = call double @llvm.fabs.f64(double %2316)
store double %2317, double* %34
%2318 = load double, double* %34
%2319 = fcmp ogt double %2318, 1.000000e-30
br i1 %2319, label %2320, label %2352
2320: ; preds = %2307
%2321 = load double, double* %34
store double %2321, double* %43
%2322 = load double, double* %43
%2323 = load double, double* %43
%2324 = fdiv double 1.000000e+00, %2323
%2325 = fadd double %2322, %2324
store double %2325, double* %44
%2326 = load double, double* %44
%2327 = load double, double* %43
%2328 = fcmp ole double %2326, %2327
br i1 %2328, label %2329, label %2351
2329: ; preds = %2320
%2330 = load i32, i32* %16
store i32 %2330, i32* %17
br label %2331
2331: ; preds = %2347, %2329
%2332 = load i32, i32* %17
%2333 = load i32, i32* %22
%2334 = icmp sle i32 %2332, %2333
br i1 %2334, label %2335, label %2350
2335: ; preds = %2331
%2336 = load double, double* %34
%2337 = load double**, double*** %12
%2338 = load i32, i32* %17
%2339 = sext i32 %2338 to i64
%2340 = getelementptr inbounds double*, double** %2337, i64 %2339
%2341 = load double*, double** %2340
%2342 = load i32, i32* %22
%2343 = sext i32 %2342 to i64
%2344 = getelementptr inbounds double, double* %2341, i64 %2343
%2345 = load double, double* %2344
%2346 = fdiv double %2345, %2336
store double %2346, double* %2344
br label %2347
2347: ; preds = %2335
%2348 = load i32, i32* %17
%2349 = add nsw i32 %2348, 1
store i32 %2349, i32* %17
br label %2331
2350: ; preds = %2331
br label %2351
2351: ; preds = %2350, %2320
br label %2352
2352: ; preds = %2351, %2307
br label %2353
2353: ; preds = %2352
br label %2354
2354: ; preds = %2353, %2156
%2355 = load i32, i32* %16
%2356 = add nsw i32 %2355, -1
store i32 %2356, i32* %16
br label %2105
2357: ; preds = %2105
br label %2358
2358: ; preds = %2357, %2091
br label %2359
2359: ; preds = %2358, %2087
br label %2360
2360: ; preds = %2359, %2086
br label %2361
2361: ; preds = %2360
%2362 = load i32, i32* %22
%2363 = add nsw i32 %2362, -1
store i32 %2363, i32* %22
br label %1472
2364: ; preds = %1472
store i32 0, i32* %16
br label %2365
2365: ; preds = %2406, %2364
%2366 = load i32, i32* %16
%2367 = load i32, i32* %9
%2368 = icmp slt i32 %2366, %2367
br i1 %2368, label %2369, label %2409
2369: ; preds = %2365
%2370 = load i32, i32* %16
%2371 = load i32, i32* %10
%2372 = icmp slt i32 %2370, %2371
br i1 %2372, label %2377, label %2373
2373: ; preds = %2369
%2374 = load i32, i32* %16
%2375 = load i32, i32* %11
%2376 = icmp sgt i32 %2374, %2375
br i1 %2376, label %2377, label %2405
2377: ; preds = %2373, %2369
%2378 = load i32, i32* %16
store i32 %2378, i32* %17
br label %2379
2379: ; preds = %2401, %2377
%2380 = load i32, i32* %17
%2381 = load i32, i32* %9
%2382 = icmp slt i32 %2380, %2381
br i1 %2382, label %2383, label %2404
2383: ; preds = %2379
%2384 = load double**, double*** %12
%2385 = load i32, i32* %16
%2386 = sext i32 %2385 to i64
%2387 = getelementptr inbounds double*, double** %2384, i64 %2386
%2388 = load double*, double** %2387
%2389 = load i32, i32* %17
%2390 = sext i32 %2389 to i64
%2391 = getelementptr inbounds double, double* %2388, i64 %2390
%2392 = load double, double* %2391
%2393 = load double**, double*** %15
%2394 = load i32, i32* %16
%2395 = sext i32 %2394 to i64
%2396 = getelementptr inbounds double*, double** %2393, i64 %2395
%2397 = load double*, double** %2396
%2398 = load i32, i32* %17
%2399 = sext i32 %2398 to i64
%2400 = getelementptr inbounds double, double* %2397, i64 %2399
store double %2392, double* %2400
br label %2401
2401: ; preds = %2383
%2402 = load i32, i32* %17
%2403 = add nsw i32 %2402, 1
store i32 %2403, i32* %17
br label %2379
2404: ; preds = %2379
br label %2405
2405: ; preds = %2404, %2373
br label %2406
2406: ; preds = %2405
%2407 = load i32, i32* %16
%2408 = add nsw i32 %2407, 1
store i32 %2408, i32* %16
br label %2365
2409: ; preds = %2365
%2410 = load i32, i32* %9
%2411 = sub nsw i32 %2410, 1
store i32 %2411, i32* %17
br label %2412
2412: ; preds = %2475, %2409
%2413 = load i32, i32* %17
%2414 = load i32, i32* %10
%2415 = icmp sge i32 %2413, %2414
br i1 %2415, label %2416, label %2478
2416: ; preds = %2412
%2417 = load i32, i32* %17
%2418 = load i32, i32* %11
%2419 = icmp slt i32 %2417, %2418
br i1 %2419, label %2420, label %2422
2420: ; preds = %2416
%2421 = load i32, i32* %17
br label %2424
2422: ; preds = %2416
%2423 = load i32, i32* %11
br label %2424
2424: ; preds = %2422, %2420
%2425 = phi i32 [ %2421, %2420 ], [ %2423, %2422 ]
store i32 %2425, i32* %20
%2426 = load i32, i32* %10
store i32 %2426, i32* %16
br label %2427
2427: ; preds = %2471, %2424
%2428 = load i32, i32* %16
%2429 = load i32, i32* %11
%2430 = icmp sle i32 %2428, %2429
br i1 %2430, label %2431, label %2474
2431: ; preds = %2427
store double 0.000000e+00, double* %42
%2432 = load i32, i32* %10
store i32 %2432, i32* %18
br label %2433
2433: ; preds = %2458, %2431
%2434 = load i32, i32* %18
%2435 = load i32, i32* %20
%2436 = icmp sle i32 %2434, %2435
br i1 %2436, label %2437, label %2461
2437: ; preds = %2433
%2438 = load double**, double*** %15
%2439 = load i32, i32* %16
%2440 = sext i32 %2439 to i64
%2441 = getelementptr inbounds double*, double** %2438, i64 %2440
%2442 = load double*, double** %2441
%2443 = load i32, i32* %18
%2444 = sext i32 %2443 to i64
%2445 = getelementptr inbounds double, double* %2442, i64 %2444
%2446 = load double, double* %2445
%2447 = load double**, double*** %12
%2448 = load i32, i32* %18
%2449 = sext i32 %2448 to i64
%2450 = getelementptr inbounds double*, double** %2447, i64 %2449
%2451 = load double*, double** %2450
%2452 = load i32, i32* %17
%2453 = sext i32 %2452 to i64
%2454 = getelementptr inbounds double, double* %2451, i64 %2453
%2455 = load double, double* %2454
%2456 = load double, double* %42
%2457 = call double @llvm.fmuladd.f64(double %2446, double %2455, double %2456)
store double %2457, double* %42
br label %2458
2458: ; preds = %2437
%2459 = load i32, i32* %18
%2460 = add nsw i32 %2459, 1
store i32 %2460, i32* %18
br label %2433
2461: ; preds = %2433
%2462 = load double, double* %42
%2463 = load double**, double*** %15
%2464 = load i32, i32* %16
%2465 = sext i32 %2464 to i64
%2466 = getelementptr inbounds double*, double** %2463, i64 %2465
%2467 = load double*, double** %2466
%2468 = load i32, i32* %17
%2469 = sext i32 %2468 to i64
%2470 = getelementptr inbounds double, double* %2467, i64 %2469
store double %2462, double* %2470
br label %2471
2471: ; preds = %2461
%2472 = load i32, i32* %16
%2473 = add nsw i32 %2472, 1
store i32 %2473, i32* %16
br label %2427
2474: ; preds = %2427
br label %2475
2475: ; preds = %2474
%2476 = load i32, i32* %17
%2477 = add nsw i32 %2476, -1
store i32 %2477, i32* %17
br label %2412
2478: ; preds = %2412
store i32 0, i32* %8
br label %2479
2479: ; preds = %2478, %1468, %225
%2480 = load i32, i32* %8
ret i32 %2480
}

LLVM IR (-O2):
@.str = [65 x i8] c"Error in Hqr2. Eigenvalues have not converged. Returning en=%i\00"
define i32 @Hqr2(i32 %0, i32 %1, i32 %2, double** %3, double* nocapture %4, double* nocapture %5, double** nocapture %6) {
%8 = icmp sgt i32 %0, 0
br i1 %8, label %9, label %83
9: ; preds = %7
%10 = sext i32 %2 to i64
%11 = sext i32 %1 to i64
%12 = zext i32 %0 to i64
br label %13
13: ; preds = %9, %79
%14 = phi i64 [ 0, %9 ], [ %80, %79 ]
%15 = phi double [ 0.000000e+00, %9 ], [ %68, %79 ]
%16 = phi i32 [ 0, %9 ], [ %81, %79 ]
%17 = icmp slt i32 %16, %0
br i1 %17, label %18, label %67
18: ; preds = %13
%19 = getelementptr inbounds double*, double** %3, i64 %14
%20 = load double*, double** %19
%21 = zext i32 %16 to i64
%22 = sub nsw i64 %12, %21
%23 = xor i64 %21, -1
%24 = add nsw i64 %23, %12
%25 = and i64 %22, 3
%26 = icmp eq i64 %25, 0
br i1 %26, label %38, label %27
27: ; preds = %18, %27
%28 = phi i64 [ %35, %27 ], [ %21, %18 ]
%29 = phi double [ %34, %27 ], [ %15, %18 ]
%30 = phi i64 [ %36, %27 ], [ 0, %18 ]
%31 = getelementptr inbounds double, double* %20, i64 %28
%32 = load double, double* %31
%33 = tail call double @llvm.fabs.f64(double %32)
%34 = fadd double %29, %33
%35 = add nuw nsw i64 %28, 1
%36 = add i64 %30, 1
%37 = icmp eq i64 %36, %25
br i1 %37, label %38, label %27
38: ; preds = %27, %18
%39 = phi double [ undef, %18 ], [ %34, %27 ]
%40 = phi i64 [ %21, %18 ], [ %35, %27 ]
%41 = phi double [ %15, %18 ], [ %34, %27 ]
%42 = icmp ult i64 %24, 3
br i1 %42, label %67, label %43
43: ; preds = %38, %43
%44 = phi i64 [ %65, %43 ], [ %40, %38 ]
%45 = phi double [ %64, %43 ], [ %41, %38 ]
%46 = getelementptr inbounds double, double* %20, i64 %44
%47 = load double, double* %46
%48 = tail call double @llvm.fabs.f64(double %47)
%49 = fadd double %45, %48
%50 = add nuw nsw i64 %44, 1
%51 = getelementptr inbounds double, double* %20, i64 %50
%52 = load double, double* %51
%53 = tail call double @llvm.fabs.f64(double %52)
%54 = fadd double %49, %53
%55 = add nuw nsw i64 %44, 2
%56 = getelementptr inbounds double, double* %20, i64 %55
%57 = load double, double* %56
%58 = tail call double @llvm.fabs.f64(double %57)
%59 = fadd double %54, %58
%60 = add nuw nsw i64 %44, 3
%61 = getelementptr inbounds double, double* %20, i64 %60
%62 = load double, double* %61
%63 = tail call double @llvm.fabs.f64(double %62)
%64 = fadd double %59, %63
%65 = add nuw nsw i64 %44, 4
%66 = icmp eq i64 %65, %12
br i1 %66, label %67, label %43
67: ; preds = %38, %43, %13
%68 = phi double [ %15, %13 ], [ %39, %38 ], [ %64, %43 ]
%69 = icmp slt i64 %14, %11
%70 = icmp sgt i64 %14, %10
%71 = or i1 %69, %70
br i1 %71, label %72, label %79
72: ; preds = %67
%73 = getelementptr inbounds double*, double** %3, i64 %14
%74 = load double*, double** %73
%75 = getelementptr inbounds double, double* %74, i64 %14
%76 = load double, double* %75
%77 = getelementptr inbounds double, double* %4, i64 %14
store double %76, double* %77
%78 = getelementptr inbounds double, double* %5, i64 %14
store double 0.000000e+00, double* %78
br label %79
79: ; preds = %67, %72
%80 = add nuw nsw i64 %14, 1
%81 = trunc i64 %14 to i32
%82 = icmp eq i64 %80, %12
br i1 %82, label %83, label %13
83: ; preds = %79, %7
%84 = phi double [ 0.000000e+00, %7 ], [ %68, %79 ]
%85 = icmp slt i32 %2, %1
br i1 %85, label %959, label %86
86: ; preds = %83
%87 = mul nsw i32 %0, 30
%88 = sext i32 %1 to i64
%89 = sext i32 %0 to i64
%90 = add i32 %2, 1
%91 = sub i32 1, %1
br label %92
92: ; preds = %86, %948
%93 = phi double [ 0.000000e+00, %86 ], [ %954, %948 ]
%94 = phi double [ 0.000000e+00, %86 ], [ %950, %948 ]
%95 = phi double [ 0.000000e+00, %86 ], [ %953, %948 ]
%96 = phi double [ 0.000000e+00, %86 ], [ %952, %948 ]
%97 = phi i32 [ %87, %86 ], [ %949, %948 ]
%98 = phi i32 [ %2, %86 ], [ %951, %948 ]
%99 = phi <2 x double> [ zeroinitializer, %86 ], [ %955, %948 ]
%100 = add i32 %98, -1
%101 = add i32 %98, -2
%102 = icmp sgt i32 %98, %1
%103 = sext i32 %98 to i64
%104 = getelementptr inbounds double*, double** %3, i64 %103
%105 = sext i32 %100 to i64
%106 = getelementptr inbounds double*, double** %3, i64 %105
%107 = icmp slt i32 %98, %1
%108 = sext i32 %101 to i64
%109 = add i32 %98, 1
%110 = getelementptr inbounds double*, double** %3, i64 %108
%111 = icmp slt i32 %100, %0
%112 = add nsw i64 %105, 1
%113 = getelementptr inbounds double*, double** %3, i64 %112
%114 = add nsw i64 %105, 3
%115 = icmp sgt i64 %114, %103
%116 = trunc i64 %114 to i32
%117 = select i1 %115, i32 %98, i32 %116
%118 = icmp slt i32 %117, 0
%119 = add nsw i64 %105, 1
%120 = zext i32 %117 to i64
%121 = add nsw i64 %105, 1
br i1 %102, label %122, label %140
122: ; preds = %92
%123 = sub nsw i64 %89, %105
%124 = add i32 %91, %98
%125 = sub i32 %98, %1
%126 = add i32 %98, 2
%127 = add i32 %98, -3
%128 = and i32 %124, 3
%129 = icmp eq i32 %128, 0
%130 = icmp ult i32 %125, 3
%131 = icmp ult i64 %123, 2
%132 = and i64 %123, -2
%133 = add nsw i64 %132, %105
%134 = icmp eq i64 %123, %132
br label %150
135: ; preds = %724, %374
%136 = phi double [ %340, %374 ], [ %725, %724 ]
%137 = phi double [ %341, %374 ], [ %726, %724 ]
%138 = phi double [ %342, %374 ], [ %728, %724 ]
%139 = phi <2 x double> [ %343, %374 ], [ %729, %724 ]
br i1 %102, label %150, label %140
140: ; preds = %135, %92
%141 = phi i32 [ %97, %92 ], [ %266, %135 ]
%142 = phi double [ %96, %92 ], [ %136, %135 ]
%143 = phi double [ %95, %92 ], [ %137, %135 ]
%144 = phi double [ %94, %92 ], [ %261, %135 ]
%145 = phi double [ %93, %92 ], [ %138, %135 ]
%146 = phi <2 x double> [ %99, %92 ], [ %139, %135 ]
%147 = load double*, double** %104
%148 = getelementptr inbounds double, double* %147, i64 %103
%149 = load double, double* %148
br label %926
150: ; preds = %122, %135
%151 = phi double [ %93, %122 ], [ %138, %135 ]
%152 = phi double [ %94, %122 ], [ %261, %135 ]
%153 = phi double [ %96, %122 ], [ %136, %135 ]
%154 = phi i32 [ 0, %122 ], [ %265, %135 ]
%155 = phi i32 [ %97, %122 ], [ %266, %135 ]
%156 = phi <2 x double> [ %99, %122 ], [ %139, %135 ]
%157 = load double*, double** %104
%158 = getelementptr inbounds double, double* %157, i64 %103
%159 = load double, double* %158
br label %162
160: ; preds = %162
%161 = icmp sgt i64 %166, %88
br i1 %161, label %162, label %185
162: ; preds = %150, %160
%163 = phi double [ %159, %150 ], [ %170, %160 ]
%164 = phi double* [ %157, %150 ], [ %168, %160 ]
%165 = phi i64 [ %103, %150 ], [ %166, %160 ]
%166 = add nsw i64 %165, -1
%167 = getelementptr inbounds double*, double** %3, i64 %166
%168 = load double*, double** %167
%169 = getelementptr inbounds double, double* %168, i64 %166
%170 = load double, double* %169
%171 = tail call double @llvm.fabs.f64(double %170)
%172 = tail call double @llvm.fabs.f64(double %163)
%173 = fadd double %171, %172
%174 = fcmp olt double %173, 1.000000e-30
%175 = select i1 %174, double %84, double %173
%176 = getelementptr inbounds double, double* %164, i64 %166
%177 = load double, double* %176
%178 = tail call double @llvm.fabs.f64(double %177)
%179 = fadd double %178, %175
%180 = fsub double %179, %175
%181 = tail call double @llvm.fabs.f64(double %180)
%182 = fcmp olt double %181, 1.000000e-30
br i1 %182, label %183, label %160
183: ; preds = %162
%184 = trunc i64 %165 to i32
br label %185
185: ; preds = %160, %183
%186 = phi i32 [ %184, %183 ], [ %1, %160 ]
%187 = icmp eq i32 %186, %98
br i1 %187, label %926, label %188
188: ; preds = %185
%189 = load double*, double** %106
%190 = getelementptr inbounds double, double* %189, i64 %105
%191 = load double, double* %190
%192 = getelementptr inbounds double, double* %157, i64 %105
%193 = load double, double* %192
%194 = getelementptr inbounds double, double* %189, i64 %103
%195 = load double, double* %194
%196 = fmul double %193, %195
%197 = icmp eq i32 %186, %100
br i1 %197, label %734, label %198
198: ; preds = %188
%199 = icmp eq i32 %155, 0
br i1 %199, label %200, label %202
200: ; preds = %198
%201 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 %98)
br label %1642
202: ; preds = %198
switch i32 %154, label %259 [
i32 20, label %203
i32 10, label %203
]
203: ; preds = %202, %202
%204 = fadd double %152, %159
br i1 %107, label %249, label %205
205: ; preds = %203
br i1 %129, label %217, label %206
206: ; preds = %205, %206
%207 = phi i64 [ %214, %206 ], [ %88, %205 ]
%208 = phi i32 [ %215, %206 ], [ 0, %205 ]
%209 = getelementptr inbounds double*, double** %3, i64 %207
%210 = load double*, double** %209
%211 = getelementptr inbounds double, double* %210, i64 %207
%212 = load double, double* %211
%213 = fsub double %212, %159
store double %213, double* %211
%214 = add nsw i64 %207, 1
%215 = add i32 %208, 1
%216 = icmp eq i32 %215, %128
br i1 %216, label %217, label %206
217: ; preds = %206, %205
%218 = phi i64 [ %88, %205 ], [ %214, %206 ]
br i1 %130, label %247, label %219
219: ; preds = %217, %219
%220 = phi i64 [ %244, %219 ], [ %218, %217 ]
%221 = getelementptr inbounds double*, double** %3, i64 %220
%222 = load double*, double** %221
%223 = getelementptr inbounds double, double* %222, i64 %220
%224 = load double, double* %223
%225 = fsub double %224, %159
store double %225, double* %223
%226 = add nsw i64 %220, 1
%227 = getelementptr inbounds double*, double** %3, i64 %226
%228 = load double*, double** %227
%229 = getelementptr inbounds double, double* %228, i64 %226
%230 = load double, double* %229
%231 = fsub double %230, %159
store double %231, double* %229
%232 = add nsw i64 %220, 2
%233 = getelementptr inbounds double*, double** %3, i64 %232
%234 = load double*, double** %233
%235 = getelementptr inbounds double, double* %234, i64 %232
%236 = load double, double* %235
%237 = fsub double %236, %159
store double %237, double* %235
%238 = add nsw i64 %220, 3
%239 = getelementptr inbounds double*, double** %3, i64 %238
%240 = load double*, double** %239
%241 = getelementptr inbounds double, double* %240, i64 %238
%242 = load double, double* %241
%243 = fsub double %242, %159
store double %243, double* %241
%244 = add nsw i64 %220, 4
%245 = trunc i64 %244 to i32
%246 = icmp eq i32 %109, %245
br i1 %246, label %247, label %219
247: ; preds = %219, %217
%248 = load double, double* %192
br label %249
249: ; preds = %247, %203
%250 = phi double [ %248, %247 ], [ %193, %203 ]
%251 = tail call double @llvm.fabs.f64(double %250)
%252 = getelementptr inbounds double, double* %189, i64 %108
%253 = load double, double* %252
%254 = tail call double @llvm.fabs.f64(double %253)
%255 = fadd double %251, %254
%256 = fmul double %255, 7.500000e-01
%257 = fmul double %255, -4.375000e-01
%258 = fmul double %255, %257
br label %259
259: ; preds = %202, %249
%260 = phi double [ %255, %249 ], [ %175, %202 ]
%261 = phi double [ %204, %249 ], [ %152, %202 ]
%262 = phi double [ %258, %249 ], [ %196, %202 ]
%263 = phi double [ %256, %249 ], [ %159, %202 ]
%264 = phi double [ %256, %249 ], [ %191, %202 ]
%265 = add nuw nsw i32 %154, 1
%266 = add nsw i32 %155, -1
%267 = icmp slt i32 %101, %186
br i1 %267, label %338, label %268
268: ; preds = %259
%269 = fneg double %262
%270 = sext i32 %186 to i64
%271 = load double*, double** %110
%272 = getelementptr inbounds double, double* %271, i64 %108
%273 = load double, double* %272
br label %274
274: ; preds = %312, %268
%275 = phi double [ %273, %268 ], [ %318, %312 ]
%276 = phi double* [ %271, %268 ], [ %316, %312 ]
%277 = phi i64 [ %108, %268 ], [ %314, %312 ]
%278 = fsub double %263, %275
%279 = fsub double %264, %275
%280 = tail call double @llvm.fmuladd.f64(double %278, double %279, double %269)
%281 = add nsw i64 %277, 1
%282 = getelementptr inbounds double*, double** %3, i64 %281
%283 = load double*, double** %282
%284 = getelementptr inbounds double, double* %283, i64 %277
%285 = load double, double* %284
%286 = fdiv double %280, %285
%287 = getelementptr inbounds double, double* %276, i64 %281
%288 = load double, double* %287
%289 = fadd double %286, %288
%290 = getelementptr inbounds double, double* %283, i64 %281
%291 = load double, double* %290
%292 = fsub double %291, %275
%293 = fsub double %292, %278
%294 = fsub double %293, %279
%295 = add nsw i64 %277, 2
%296 = getelementptr inbounds double*, double** %3, i64 %295
%297 = load double*, double** %296
%298 = getelementptr inbounds double, double* %297, i64 %281
%299 = load double, double* %298
%300 = tail call double @llvm.fabs.f64(double %289)
%301 = tail call double @llvm.fabs.f64(double %294)
%302 = fadd double %300, %301
%303 = tail call double @llvm.fabs.f64(double %299)
%304 = fadd double %303, %302
%305 = fdiv double %289, %304
%306 = insertelement <2 x double> poison, double %294, i64 0
%307 = insertelement <2 x double> %306, double %299, i64 1
%308 = insertelement <2 x double> poison, double %304, i64 0
%309 = shufflevector <2 x double> %308, <2 x double> poison, <2 x i32> zeroinitializer
%310 = fdiv <2 x double> %307, %309
%311 = icmp eq i64 %277, %270
br i1 %311, label %338, label %312
312: ; preds = %274
%313 = tail call double @llvm.fabs.f64(double %305)
%314 = add nsw i64 %277, -1
%315 = getelementptr inbounds double*, double** %3, i64 %314
%316 = load double*, double** %315
%317 = getelementptr inbounds double, double* %316, i64 %314
%318 = load double, double* %317
%319 = tail call double @llvm.fabs.f64(double %318)
%320 = tail call double @llvm.fabs.f64(double %275)
%321 = fadd double %320, %319
%322 = tail call double @llvm.fabs.f64(double %291)
%323 = fadd double %322, %321
%324 = fmul double %313, %323
%325 = getelementptr inbounds double, double* %276, i64 %314
%326 = load double, double* %325
%327 = tail call double @llvm.fabs.f64(double %326)
%328 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %310)
%329 = shufflevector <2 x double> %328, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%330 = fadd <2 x double> %328, %329
%331 = extractelement <2 x double> %330, i64 0
%332 = tail call double @llvm.fmuladd.f64(double %327, double %331, double %324)
%333 = fsub double %332, %324
%334 = tail call double @llvm.fabs.f64(double %333)
%335 = fcmp olt double %334, 1.000000e-30
br i1 %335, label %336, label %274
336: ; preds = %312
%337 = trunc i64 %277 to i32
br label %338
338: ; preds = %274, %336, %259
%339 = phi i32 [ %101, %259 ], [ %337, %336 ], [ %186, %274 ]
%340 = phi double [ %153, %259 ], [ %305, %336 ], [ %305, %274 ]
%341 = phi double [ %260, %259 ], [ %304, %336 ], [ %304, %274 ]
%342 = phi double [ %151, %259 ], [ %275, %336 ], [ %275, %274 ]
%343 = phi <2 x double> [ %156, %259 ], [ %310, %336 ], [ %310, %274 ]
%344 = add i32 %339, 2
%345 = icmp sgt i32 %344, %98
br i1 %345, label %374, label %346
346: ; preds = %338
%347 = sext i32 %344 to i64
%348 = getelementptr inbounds double*, double** %3, i64 %347
%349 = load double*, double** %348
%350 = add nsw i64 %347, -2
%351 = getelementptr inbounds double, double* %349, i64 %350
store double 0.000000e+00, double* %351
%352 = add nsw i64 %347, 1
%353 = trunc i64 %352 to i32
%354 = icmp eq i32 %109, %353
br i1 %354, label %374, label %355
355: ; preds = %346
%356 = sub i32 %126, %339
%357 = sub i32 %127, %339
%358 = and i32 %356, 3
%359 = icmp eq i32 %358, 0
br i1 %359, label %371, label %360
360: ; preds = %355, %360
%361 = phi i64 [ %368, %360 ], [ %352, %355 ]
%362 = phi i32 [ %369, %360 ], [ 0, %355 ]
%363 = getelementptr inbounds double*, double** %3, i64 %361
%364 = load double*, double** %363
%365 = add nsw i64 %361, -3
%366 = getelementptr inbounds double, double* %364, i64 %365
%367 = bitcast double* %366 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %367
%368 = add nsw i64 %361, 1
%369 = add i32 %362, 1
%370 = icmp eq i32 %369, %358
br i1 %370, label %371, label %360
371: ; preds = %360, %355
%372 = phi i64 [ %352, %355 ], [ %368, %360 ]
%373 = icmp ult i32 %357, 3
br i1 %373, label %374, label %381
374: ; preds = %371, %381, %346, %338
%375 = icmp slt i32 %339, %98
br i1 %375, label %376, label %135
376: ; preds = %374
%377 = icmp eq i32 %186, %339
%378 = sext i32 %339 to i64
%379 = getelementptr inbounds double*, double** %3, i64 %378
%380 = add nsw i64 %378, -1
br label %408
381: ; preds = %371, %381
%382 = phi i64 [ %405, %381 ], [ %372, %371 ]
%383 = getelementptr inbounds double*, double** %3, i64 %382
%384 = load double*, double** %383
%385 = add nsw i64 %382, -3
%386 = getelementptr inbounds double, double* %384, i64 %385
%387 = bitcast double* %386 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %387
%388 = add nsw i64 %382, 1
%389 = getelementptr inbounds double*, double** %3, i64 %388
%390 = load double*, double** %389
%391 = add nsw i64 %382, -2
%392 = getelementptr inbounds double, double* %390, i64 %391
%393 = bitcast double* %392 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %393
%394 = add nsw i64 %382, 2
%395 = getelementptr inbounds double*, double** %3, i64 %394
%396 = load double*, double** %395
%397 = add nsw i64 %382, -1
%398 = getelementptr inbounds double, double* %396, i64 %397
%399 = bitcast double* %398 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %399
%400 = add nsw i64 %382, 3
%401 = getelementptr inbounds double*, double** %3, i64 %400
%402 = load double*, double** %401
%403 = getelementptr inbounds double, double* %402, i64 %382
%404 = bitcast double* %403 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %404
%405 = add nsw i64 %382, 4
%406 = trunc i64 %405 to i32
%407 = icmp eq i32 %109, %406
br i1 %407, label %374, label %381
408: ; preds = %376, %724
%409 = phi i64 [ 0, %376 ], [ %733, %724 ]
%410 = phi i64 [ %378, %376 ], [ %730, %724 ]
%411 = phi double [ %342, %376 ], [ %728, %724 ]
%412 = phi double [ %263, %376 ], [ %727, %724 ]
%413 = phi double [ %341, %376 ], [ %726, %724 ]
%414 = phi double [ %340, %376 ], [ %725, %724 ]
%415 = phi <2 x double> [ %343, %376 ], [ %729, %724 ]
%416 = add i64 %409, %378
%417 = sub i64 %89, %416
%418 = icmp eq i64 %410, %105
%419 = icmp eq i64 %410, %378
br i1 %419, label %452, label %420
420: ; preds = %408
%421 = getelementptr inbounds double*, double** %3, i64 %410
%422 = load double*, double** %421
%423 = add nsw i64 %410, -1
%424 = getelementptr inbounds double, double* %422, i64 %423
%425 = load double, double* %424
%426 = add nsw i64 %410, 1
%427 = getelementptr inbounds double*, double** %3, i64 %426
%428 = load double*, double** %427
%429 = getelementptr inbounds double, double* %428, i64 %423
%430 = load double, double* %429
br i1 %418, label %437, label %431
431: ; preds = %420
%432 = add nsw i64 %410, 2
%433 = getelementptr inbounds double*, double** %3, i64 %432
%434 = load double*, double** %433
%435 = getelementptr inbounds double, double* %434, i64 %423
%436 = load double, double* %435
br label %437
437: ; preds = %431, %420
%438 = phi double [ %436, %431 ], [ 0.000000e+00, %420 ]
%439 = tail call double @llvm.fabs.f64(double %425)
%440 = tail call double @llvm.fabs.f64(double %430)
%441 = fadd double %439, %440
%442 = tail call double @llvm.fabs.f64(double %438)
%443 = fadd double %441, %442
%444 = fcmp olt double %443, 1.000000e-30
%445 = insertelement <2 x double> poison, double %430, i64 0
%446 = insertelement <2 x double> %445, double %438, i64 1
br i1 %444, label %724, label %447
447: ; preds = %437
%448 = fdiv double %425, %443
%449 = insertelement <2 x double> poison, double %443, i64 0
%450 = shufflevector <2 x double> %449, <2 x double> poison, <2 x i32> zeroinitializer
%451 = fdiv <2 x double> %446, %450
br label %452
452: ; preds = %447, %408
%453 = phi double [ %448, %447 ], [ %414, %408 ]
%454 = phi double [ %443, %447 ], [ %412, %408 ]
%455 = phi <2 x double> [ %451, %447 ], [ %415, %408 ]
%456 = extractelement <2 x double> %455, i64 0
%457 = fmul <2 x double> %455, %455
%458 = extractelement <2 x double> %457, i64 0
%459 = tail call double @llvm.fmuladd.f64(double %453, double %453, double %458)
%460 = extractelement <2 x double> %455, i64 1
%461 = tail call double @llvm.fmuladd.f64(double %460, double %460, double %459)
%462 = tail call double @sqrt(double %461)
%463 = tail call i32 (double, double, ...) bitcast (i32 (...)* @D_sign to i32 (double, double, ...)*)(double %462, double %453)
%464 = sitofp i32 %463 to double
br i1 %419, label %472, label %465
465: ; preds = %452
%466 = fneg double %464
%467 = fmul double %454, %466
%468 = getelementptr inbounds double*, double** %3, i64 %410
%469 = load double*, double** %468
%470 = add nsw i64 %410, -1
%471 = getelementptr inbounds double, double* %469, i64 %470
store double %467, double* %471
br label %478
472: ; preds = %452
br i1 %377, label %478, label %473
473: ; preds = %472
%474 = load double*, double** %379
%475 = getelementptr inbounds double, double* %474, i64 %380
%476 = load double, double* %475
%477 = fneg double %476
store double %477, double* %475
br label %478
478: ; preds = %472, %473, %465
%479 = fadd double %453, %464
%480 = fdiv double %479, %464
%481 = fdiv double %456, %464
%482 = fdiv double %460, %464
%483 = insertelement <2 x double> poison, double %479, i64 0
%484 = shufflevector <2 x double> %483, <2 x double> poison, <2 x i32> zeroinitializer
%485 = fdiv <2 x double> %455, %484
br i1 %418, label %560, label %486
486: ; preds = %478
%487 = icmp slt i64 %410, %89
br i1 %487, label %488, label %668
488: ; preds = %486
%489 = getelementptr inbounds double*, double** %3, i64 %410
%490 = load double*, double** %489
%491 = add nsw i64 %410, 1
%492 = getelementptr inbounds double*, double** %3, i64 %491
%493 = load double*, double** %492
%494 = add nsw i64 %410, 2
%495 = getelementptr inbounds double*, double** %3, i64 %494
%496 = load double*, double** %495
%497 = icmp ult i64 %417, 2
br i1 %497, label %556, label %498
498: ; preds = %488
%499 = getelementptr double, double* %490, i64 %410
%500 = getelementptr double, double* %490, i64 %89
%501 = getelementptr double, double* %493, i64 %410
%502 = getelementptr double, double* %493, i64 %89
%503 = getelementptr double, double* %496, i64 %410
%504 = getelementptr double, double* %496, i64 %89
%505 = icmp ult double* %499, %502
%506 = icmp ult double* %501, %500
%507 = and i1 %505, %506
%508 = icmp ult double* %499, %504
%509 = icmp ult double* %503, %500
%510 = and i1 %508, %509
%511 = or i1 %507, %510
%512 = icmp ult double* %501, %504
%513 = icmp ult double* %503, %502
%514 = and i1 %512, %513
%515 = or i1 %511, %514
br i1 %515, label %556, label %516
516: ; preds = %498
%517 = and i64 %417, -2
%518 = add i64 %410, %517
%519 = shufflevector <2 x double> %485, <2 x double> poison, <2 x i32> zeroinitializer
%520 = shufflevector <2 x double> %485, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%521 = insertelement <2 x double> poison, double %480, i64 0
%522 = shufflevector <2 x double> %521, <2 x double> poison, <2 x i32> zeroinitializer
%523 = insertelement <2 x double> poison, double %481, i64 0
%524 = shufflevector <2 x double> %523, <2 x double> poison, <2 x i32> zeroinitializer
%525 = insertelement <2 x double> poison, double %482, i64 0
%526 = shufflevector <2 x double> %525, <2 x double> poison, <2 x i32> zeroinitializer
br label %527
527: ; preds = %527, %516
%528 = phi i64 [ 0, %516 ], [ %552, %527 ]
%529 = add i64 %410, %528
%530 = getelementptr inbounds double, double* %490, i64 %529
%531 = bitcast double* %530 to <2 x double>*
%532 = load <2 x double>, <2 x double>* %531
%533 = getelementptr inbounds double, double* %493, i64 %529
%534 = bitcast double* %533 to <2 x double>*
%535 = load <2 x double>, <2 x double>* %534
%536 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %519, <2 x double> %535, <2 x double> %532)
%537 = getelementptr inbounds double, double* %496, i64 %529
%538 = bitcast double* %537 to <2 x double>*
%539 = load <2 x double>, <2 x double>* %538
%540 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %520, <2 x double> %539, <2 x double> %536)
%541 = fneg <2 x double> %540
%542 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %541, <2 x double> %522, <2 x double> %532)
%543 = bitcast double* %530 to <2 x double>*
store <2 x double> %542, <2 x double>* %543
%544 = bitcast double* %533 to <2 x double>*
%545 = load <2 x double>, <2 x double>* %544
%546 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %541, <2 x double> %524, <2 x double> %545)
%547 = bitcast double* %533 to <2 x double>*
store <2 x double> %546, <2 x double>* %547
%548 = bitcast double* %537 to <2 x double>*
%549 = load <2 x double>, <2 x double>* %548
%550 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %541, <2 x double> %526, <2 x double> %549)
%551 = bitcast double* %537 to <2 x double>*
store <2 x double> %550, <2 x double>* %551
%552 = add nuw i64 %528, 2
%553 = icmp eq i64 %552, %517
br i1 %553, label %554, label %527
554: ; preds = %527
%555 = icmp eq i64 %417, %517
br i1 %555, label %668, label %556
556: ; preds = %498, %488, %554
%557 = phi i64 [ %410, %498 ], [ %410, %488 ], [ %518, %554 ]
%558 = extractelement <2 x double> %485, i64 0
%559 = extractelement <2 x double> %485, i64 1
br label %650
560: ; preds = %478
br i1 %111, label %561, label %614
561: ; preds = %560
%562 = load double*, double** %106
%563 = load double*, double** %113
br i1 %131, label %598, label %564
564: ; preds = %561
%565 = getelementptr double, double* %562, i64 %105
%566 = getelementptr double, double* %562, i64 %89
%567 = getelementptr double, double* %563, i64 %105
%568 = getelementptr double, double* %563, i64 %89
%569 = icmp ult double* %565, %568
%570 = icmp ult double* %567, %566
%571 = and i1 %569, %570
br i1 %571, label %598, label %572
572: ; preds = %564
%573 = shufflevector <2 x double> %485, <2 x double> poison, <2 x i32> zeroinitializer
%574 = insertelement <2 x double> poison, double %480, i64 0
%575 = shufflevector <2 x double> %574, <2 x double> poison, <2 x i32> zeroinitializer
%576 = insertelement <2 x double> poison, double %481, i64 0
%577 = shufflevector <2 x double> %576, <2 x double> poison, <2 x i32> zeroinitializer
br label %578
578: ; preds = %578, %572
%579 = phi i64 [ 0, %572 ], [ %595, %578 ]
%580 = add i64 %579, %105
%581 = getelementptr inbounds double, double* %562, i64 %580
%582 = bitcast double* %581 to <2 x double>*
%583 = load <2 x double>, <2 x double>* %582
%584 = getelementptr inbounds double, double* %563, i64 %580
%585 = bitcast double* %584 to <2 x double>*
%586 = load <2 x double>, <2 x double>* %585
%587 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %573, <2 x double> %586, <2 x double> %583)
%588 = fneg <2 x double> %587
%589 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %588, <2 x double> %575, <2 x double> %583)
%590 = bitcast double* %581 to <2 x double>*
store <2 x double> %589, <2 x double>* %590
%591 = bitcast double* %584 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591
%593 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %588, <2 x double> %577, <2 x double> %592)
%594 = bitcast double* %584 to <2 x double>*
store <2 x double> %593, <2 x double>* %594
%595 = add nuw i64 %579, 2
%596 = icmp eq i64 %595, %132
br i1 %596, label %597, label %578
597: ; preds = %578
br i1 %134, label %614, label %598
598: ; preds = %564, %561, %597
%599 = phi i64 [ %105, %564 ], [ %105, %561 ], [ %133, %597 ]
%600 = extractelement <2 x double> %485, i64 0
br label %601
601: ; preds = %598, %601
%602 = phi i64 [ %612, %601 ], [ %599, %598 ]
%603 = getelementptr inbounds double, double* %562, i64 %602
%604 = load double, double* %603
%605 = getelementptr inbounds double, double* %563, i64 %602
%606 = load double, double* %605
%607 = tail call double @llvm.fmuladd.f64(double %600, double %606, double %604)
%608 = fneg double %607
%609 = tail call double @llvm.fmuladd.f64(double %608, double %480, double %604)
store double %609, double* %603
%610 = load double, double* %605
%611 = tail call double @llvm.fmuladd.f64(double %608, double %481, double %610)
store double %611, double* %605
%612 = add nsw i64 %602, 1
%613 = icmp slt i64 %612, %89
br i1 %613, label %601, label %614
614: ; preds = %601, %597, %560
br i1 %118, label %632, label %615
615: ; preds = %614
%616 = extractelement <2 x double> %485, i64 0
br label %617
617: ; preds = %615, %617
%618 = phi i64 [ %630, %617 ], [ 0, %615 ]
%619 = getelementptr inbounds double*, double** %3, i64 %618
%620 = load double*, double** %619
%621 = getelementptr inbounds double, double* %620, i64 %105
%622 = load double, double* %621
%623 = getelementptr inbounds double, double* %620, i64 %119
%624 = load double, double* %623
%625 = fmul double %481, %624
%626 = tail call double @llvm.fmuladd.f64(double %480, double %622, double %625)
%627 = fsub double %622, %626
store double %627, double* %621
%628 = fneg double %626
%629 = tail call double @llvm.fmuladd.f64(double %628, double %616, double %624)
store double %629, double* %623
%630 = add nuw nsw i64 %618, 1
%631 = icmp ult i64 %618, %120
br i1 %631, label %617, label %632
632: ; preds = %617, %614
%633 = extractelement <2 x double> %485, i64 0
br label %634
634: ; preds = %632, %634
%635 = phi i64 [ %647, %634 ], [ %88, %632 ]
%636 = getelementptr inbounds double*, double** %6, i64 %635
%637 = load double*, double** %636
%638 = getelementptr inbounds double, double* %637, i64 %105
%639 = load double, double* %638
%640 = getelementptr inbounds double, double* %637, i64 %121
%641 = load double, double* %640
%642 = fmul double %481, %641
%643 = tail call double @llvm.fmuladd.f64(double %480, double %639, double %642)
%644 = fsub double %639, %643
store double %644, double* %638
%645 = fneg double %643
%646 = tail call double @llvm.fmuladd.f64(double %645, double %633, double %641)
store double %646, double* %640
%647 = add nsw i64 %635, 1
%648 = trunc i64 %647 to i32
%649 = icmp eq i32 %90, %648
br i1 %649, label %724, label %634
650: ; preds = %556, %650
%651 = phi i64 [ %666, %650 ], [ %557, %556 ]
%652 = getelementptr inbounds double, double* %490, i64 %651
%653 = load double, double* %652
%654 = getelementptr inbounds double, double* %493, i64 %651
%655 = load double, double* %654
%656 = tail call double @llvm.fmuladd.f64(double %558, double %655, double %653)
%657 = getelementptr inbounds double, double* %496, i64 %651
%658 = load double, double* %657
%659 = tail call double @llvm.fmuladd.f64(double %559, double %658, double %656)
%660 = fneg double %659
%661 = tail call double @llvm.fmuladd.f64(double %660, double %480, double %653)
store double %661, double* %652
%662 = load double, double* %654
%663 = tail call double @llvm.fmuladd.f64(double %660, double %481, double %662)
store double %663, double* %654
%664 = load double, double* %657
%665 = tail call double @llvm.fmuladd.f64(double %660, double %482, double %664)
store double %665, double* %657
%666 = add nsw i64 %651, 1
%667 = icmp slt i64 %666, %89
br i1 %667, label %650, label %668
668: ; preds = %650, %554, %486
%669 = add nsw i64 %410, 3
%670 = icmp sgt i64 %669, %103
%671 = trunc i64 %669 to i32
%672 = select i1 %670, i32 %98, i32 %671
%673 = icmp slt i32 %672, 0
br i1 %673, label %677, label %674
674: ; preds = %668
%675 = add nsw i64 %410, 1
%676 = zext i32 %672 to i64
br label %679
677: ; preds = %679, %668
%678 = add nsw i64 %410, 1
br label %701
679: ; preds = %674, %679
%680 = phi i64 [ 0, %674 ], [ %699, %679 ]
%681 = getelementptr inbounds double*, double** %3, i64 %680
%682 = load double*, double** %681
%683 = getelementptr inbounds double, double* %682, i64 %410
%684 = load double, double* %683
%685 = getelementptr inbounds double, double* %682, i64 %675
%686 = bitcast double* %685 to <2 x double>*
%687 = load <2 x double>, <2 x double>* %686
%688 = extractelement <2 x double> %687, i64 0
%689 = fmul double %481, %688
%690 = tail call double @llvm.fmuladd.f64(double %480, double %684, double %689)
%691 = extractelement <2 x double> %687, i64 1
%692 = tail call double @llvm.fmuladd.f64(double %482, double %691, double %690)
%693 = fsub double %684, %692
store double %693, double* %683
%694 = fneg double %692
%695 = insertelement <2 x double> poison, double %694, i64 0
%696 = shufflevector <2 x double> %695, <2 x double> poison, <2 x i32> zeroinitializer
%697 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %696, <2 x double> %485, <2 x double> %687)
%698 = bitcast double* %685 to <2 x double>*
store <2 x double> %697, <2 x double>* %698
%699 = add nuw nsw i64 %680, 1
%700 = icmp ult i64 %680, %676
br i1 %700, label %679, label %677
701: ; preds = %677, %701
%702 = phi i64 [ %88, %677 ], [ %721, %701 ]
%703 = getelementptr inbounds double*, double** %6, i64 %702
%704 = load double*, double** %703
%705 = getelementptr inbounds double, double* %704, i64 %410
%706 = load double, double* %705
%707 = getelementptr inbounds double, double* %704, i64 %678
%708 = bitcast double* %707 to <2 x double>*
%709 = load <2 x double>, <2 x double>* %708
%710 = extractelement <2 x double> %709, i64 0
%711 = fmul double %481, %710
%712 = tail call double @llvm.fmuladd.f64(double %480, double %706, double %711)
%713 = extractelement <2 x double> %709, i64 1
%714 = tail call double @llvm.fmuladd.f64(double %482, double %713, double %712)
%715 = fsub double %706, %714
store double %715, double* %705
%716 = fneg double %714
%717 = insertelement <2 x double> poison, double %716, i64 0
%718 = shufflevector <2 x double> %717, <2 x double> poison, <2 x i32> zeroinitializer
%719 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %718, <2 x double> %485, <2 x double> %709)
%720 = bitcast double* %707 to <2 x double>*
store <2 x double> %719, <2 x double>* %720
%721 = add nsw i64 %702, 1
%722 = trunc i64 %721 to i32
%723 = icmp eq i32 %90, %722
br i1 %723, label %724, label %701
724: ; preds = %701, %634, %437
%725 = phi double [ %425, %437 ], [ %643, %634 ], [ %714, %701 ]
%726 = phi double [ %413, %437 ], [ %464, %634 ], [ %464, %701 ]
%727 = phi double [ %443, %437 ], [ %480, %634 ], [ %480, %701 ]
%728 = phi double [ %411, %437 ], [ %482, %634 ], [ %482, %701 ]
%729 = phi <2 x double> [ %446, %437 ], [ %485, %634 ], [ %485, %701 ]
%730 = add nsw i64 %410, 1
%731 = trunc i64 %730 to i32
%732 = icmp eq i32 %98, %731
%733 = add i64 %409, 1
br i1 %732, label %135, label %408
734: ; preds = %188
%735 = fsub double %191, %159
%736 = fmul double %735, 5.000000e-01
%737 = tail call double @llvm.fmuladd.f64(double %736, double %736, double %196)
%738 = tail call double @llvm.fabs.f64(double %737)
%739 = tail call double @sqrt(double %738)
%740 = fadd double %152, %159
%741 = load double*, double** %104
%742 = getelementptr inbounds double, double* %741, i64 %103
store double %740, double* %742
%743 = fadd double %152, %191
%744 = load double*, double** %106
%745 = getelementptr inbounds double, double* %744, i64 %105
store double %743, double* %745
%746 = fcmp ult double %737, 0xBD719799812DEA11
br i1 %746, label %919, label %747
747: ; preds = %734
%748 = tail call i32 (double, double, ...) bitcast (i32 (...)* @D_sign to i32 (double, double, ...)*)(double %739, double %736)
%749 = sitofp i32 %748 to double
%750 = fadd double %736, %749
%751 = fadd double %740, %750
%752 = getelementptr inbounds double, double* %4, i64 %105
store double %751, double* %752
%753 = getelementptr inbounds double, double* %4, i64 %103
%754 = tail call double @llvm.fabs.f64(double %750)
%755 = fcmp ogt double %754, 1.000000e-30
br i1 %755, label %756, label %759
756: ; preds = %747
%757 = fdiv double %196, %750
%758 = fsub double %740, %757
br label %759
759: ; preds = %756, %747
%760 = phi double [ %758, %756 ], [ %751, %747 ]
store double %760, double* %753
%761 = getelementptr inbounds double, double* %5, i64 %105
store double 0.000000e+00, double* %761
%762 = getelementptr inbounds double, double* %5, i64 %103
store double 0.000000e+00, double* %762
%763 = load double*, double** %104
%764 = getelementptr inbounds double, double* %763, i64 %105
%765 = load double, double* %764
%766 = tail call double @llvm.fabs.f64(double %765)
%767 = fadd double %754, %766
%768 = fdiv double %765, %767
%769 = fdiv double %750, %767
%770 = fmul double %769, %769
%771 = tail call double @llvm.fmuladd.f64(double %768, double %768, double %770)
%772 = tail call double @sqrt(double %771)
%773 = fdiv double %768, %772
%774 = fdiv double %769, %772
%775 = icmp sgt i32 %98, %0
br i1 %775, label %867, label %776
776: ; preds = %759
%777 = load double*, double** %106
%778 = load double*, double** %104
%779 = fneg double %773
%780 = sub i32 %0, %98
%781 = zext i32 %780 to i64
%782 = add nuw nsw i64 %781, 1
%783 = icmp eq i32 %780, 0
br i1 %783, label %865, label %784
784: ; preds = %776
%785 = getelementptr double, double* %777, i64 %105
%786 = getelementptr double, double* %777, i64 1
%787 = sub i32 %0, %98
%788 = zext i32 %787 to i64
%789 = add nsw i64 %105, %788
%790 = getelementptr double, double* %786, i64 %789
%791 = getelementptr double, double* %778, i64 %105
%792 = getelementptr double, double* %778, i64 1
%793 = getelementptr double, double* %792, i64 %789
%794 = icmp ult double* %785, %793
%795 = icmp ult double* %791, %790
%796 = and i1 %794, %795
br i1 %796, label %865, label %797
797: ; preds = %784
%798 = and i64 %782, 8589934590
%799 = add nsw i64 %798, %105
%800 = insertelement <2 x double> poison, double %773, i64 0
%801 = shufflevector <2 x double> %800, <2 x double> poison, <2 x i32> zeroinitializer
%802 = insertelement <2 x double> poison, double %774, i64 0
%803 = shufflevector <2 x double> %802, <2 x double> poison, <2 x i32> zeroinitializer
%804 = insertelement <2 x double> poison, double %779, i64 0
%805 = shufflevector <2 x double> %804, <2 x double> poison, <2 x i32> zeroinitializer
%806 = add nsw i64 %798, -2
%807 = lshr exact i64 %806, 1
%808 = add nuw i64 %807, 1
%809 = and i64 %808, 1
%810 = icmp eq i64 %806, 0
br i1 %810, label %846, label %811
811: ; preds = %797
%812 = and i64 %808, -2
br label %813
813: ; preds = %813, %811
%814 = phi i64 [ 0, %811 ], [ %843, %813 ]
%815 = phi i64 [ 0, %811 ], [ %844, %813 ]
%816 = add i64 %814, %105
%817 = getelementptr inbounds double, double* %777, i64 %816
%818 = bitcast double* %817 to <2 x double>*
%819 = load <2 x double>, <2 x double>* %818
%820 = getelementptr inbounds double, double* %778, i64 %816
%821 = bitcast double* %820 to <2 x double>*
%822 = load <2 x double>, <2 x double>* %821
%823 = fmul <2 x double> %801, %822
%824 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %803, <2 x double> %819, <2 x double> %823)
%825 = bitcast double* %817 to <2 x double>*
store <2 x double> %824, <2 x double>* %825
%826 = fmul <2 x double> %819, %805
%827 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %803, <2 x double> %822, <2 x double> %826)
%828 = bitcast double* %820 to <2 x double>*
store <2 x double> %827, <2 x double>* %828
%829 = or i64 %814, 2
%830 = add i64 %829, %105
%831 = getelementptr inbounds double, double* %777, i64 %830
%832 = bitcast double* %831 to <2 x double>*
%833 = load <2 x double>, <2 x double>* %832
%834 = getelementptr inbounds double, double* %778, i64 %830
%835 = bitcast double* %834 to <2 x double>*
%836 = load <2 x double>, <2 x double>* %835
%837 = fmul <2 x double> %801, %836
%838 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %803, <2 x double> %833, <2 x double> %837)
%839 = bitcast double* %831 to <2 x double>*
store <2 x double> %838, <2 x double>* %839
%840 = fmul <2 x double> %833, %805
%841 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %803, <2 x double> %836, <2 x double> %840)
%842 = bitcast double* %834 to <2 x double>*
store <2 x double> %841, <2 x double>* %842
%843 = add nuw i64 %814, 4
%844 = add nuw i64 %815, 2
%845 = icmp eq i64 %844, %812
br i1 %845, label %846, label %813
846: ; preds = %813, %797
%847 = phi i64 [ 0, %797 ], [ %843, %813 ]
%848 = icmp eq i64 %809, 0
br i1 %848, label %863, label %849
849: ; preds = %846
%850 = add i64 %847, %105
%851 = getelementptr inbounds double, double* %777, i64 %850
%852 = bitcast double* %851 to <2 x double>*
%853 = load <2 x double>, <2 x double>* %852
%854 = getelementptr inbounds double, double* %778, i64 %850
%855 = bitcast double* %854 to <2 x double>*
%856 = load <2 x double>, <2 x double>* %855
%857 = fmul <2 x double> %801, %856
%858 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %803, <2 x double> %853, <2 x double> %857)
%859 = bitcast double* %851 to <2 x double>*
store <2 x double> %858, <2 x double>* %859
%860 = fmul <2 x double> %853, %805
%861 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %803, <2 x double> %856, <2 x double> %860)
%862 = bitcast double* %854 to <2 x double>*
store <2 x double> %861, <2 x double>* %862
br label %863
863: ; preds = %846, %849
%864 = icmp eq i64 %782, %798
br i1 %864, label %867, label %865
865: ; preds = %784, %776, %863
%866 = phi i64 [ %105, %784 ], [ %105, %776 ], [ %799, %863 ]
br label %872
867: ; preds = %872, %863, %759
%868 = icmp slt i32 %98, 0
br i1 %868, label %886, label %869
869: ; preds = %867
%870 = fneg double %773
%871 = zext i32 %109 to i64
br label %890
872: ; preds = %865, %872
%873 = phi i64 [ %883, %872 ], [ %866, %865 ]
%874 = getelementptr inbounds double, double* %777, i64 %873
%875 = load double, double* %874
%876 = getelementptr inbounds double, double* %778, i64 %873
%877 = load double, double* %876
%878 = fmul double %773, %877
%879 = tail call double @llvm.fmuladd.f64(double %774, double %875, double %878)
store double %879, double* %874
%880 = load double, double* %876
%881 = fmul double %875, %779
%882 = tail call double @llvm.fmuladd.f64(double %774, double %880, double %881)
store double %882, double* %876
%883 = add nsw i64 %873, 1
%884 = trunc i64 %883 to i32
%885 = icmp eq i32 %884, %0
br i1 %885, label %867, label %872
886: ; preds = %890, %867
%887 = fneg double %773
%888 = insertelement <2 x double> poison, double %774, i64 0
%889 = insertelement <2 x double> %888, double %772, i64 1
br label %904
890: ; preds = %869, %890
%891 = phi i64 [ 0, %869 ], [ %902, %890 ]
%892 = getelementptr inbounds double*, double** %3, i64 %891
%893 = load double*, double** %892
%894 = getelementptr inbounds double, double* %893, i64 %105
%895 = load double, double* %894
%896 = getelementptr inbounds double, double* %893, i64 %103
%897 = load double, double* %896
%898 = fmul double %773, %897
%899 = tail call double @llvm.fmuladd.f64(double %774, double %895, double %898)
store double %899, double* %894
%900 = fmul double %895, %870
%901 = tail call double @llvm.fmuladd.f64(double %774, double %897, double %900)
store double %901, double* %896
%902 = add nuw nsw i64 %891, 1
%903 = icmp eq i64 %902, %871
br i1 %903, label %886, label %890
904: ; preds = %886, %904
%905 = phi i64 [ %88, %886 ], [ %916, %904 ]
%906 = getelementptr inbounds double*, double** %6, i64 %905
%907 = load double*, double** %906
%908 = getelementptr inbounds double, double* %907, i64 %105
%909 = load double, double* %908
%910 = getelementptr inbounds double, double* %907, i64 %103
%911 = load double, double* %910
%912 = fmul double %773, %911
%913 = tail call double @llvm.fmuladd.f64(double %774, double %909, double %912)
store double %913, double* %908
%914 = fmul double %909, %887
%915 = tail call double @llvm.fmuladd.f64(double %774, double %911, double %914)
store double %915, double* %910
%916 = add nsw i64 %905, 1
%917 = trunc i64 %916 to i32
%918 = icmp eq i32 %90, %917
br i1 %918, label %948, label %904
919: ; preds = %734
%920 = fadd double %740, %736
%921 = getelementptr inbounds double, double* %4, i64 %105
store double %920, double* %921
%922 = getelementptr inbounds double, double* %4, i64 %103
store double %920, double* %922
%923 = getelementptr inbounds double, double* %5, i64 %105
store double %739, double* %923
%924 = fneg double %739
%925 = insertelement <2 x double> %156, double %737, i64 0
br label %938
926: ; preds = %185, %140
%927 = phi i32 [ %141, %140 ], [ %155, %185 ]
%928 = phi double [ %142, %140 ], [ %153, %185 ]
%929 = phi double [ %144, %140 ], [ %152, %185 ]
%930 = phi double [ %145, %140 ], [ %151, %185 ]
%931 = phi double [ %143, %140 ], [ %175, %185 ]
%932 = phi double* [ %147, %140 ], [ %157, %185 ]
%933 = phi double [ %149, %140 ], [ %159, %185 ]
%934 = phi <2 x double> [ %146, %140 ], [ %156, %185 ]
%935 = getelementptr inbounds double, double* %932, i64 %103
%936 = fadd double %929, %933
store double %936, double* %935
%937 = getelementptr inbounds double, double* %4, i64 %103
store double %936, double* %937
br label %938
938: ; preds = %926, %919
%939 = phi i32 [ %155, %919 ], [ %927, %926 ]
%940 = phi double [ %152, %919 ], [ %929, %926 ]
%941 = phi double [ %924, %919 ], [ 0.000000e+00, %926 ]
%942 = phi i32 [ %101, %919 ], [ %100, %926 ]
%943 = phi double [ %736, %919 ], [ %928, %926 ]
%944 = phi double [ %175, %919 ], [ %931, %926 ]
%945 = phi double [ %739, %919 ], [ %930, %926 ]
%946 = phi <2 x double> [ %925, %919 ], [ %934, %926 ]
%947 = getelementptr inbounds double, double* %5, i64 %103
store double %941, double* %947
br label %948
948: ; preds = %904, %938
%949 = phi i32 [ %939, %938 ], [ %155, %904 ]
%950 = phi double [ %940, %938 ], [ %152, %904 ]
%951 = phi i32 [ %942, %938 ], [ %101, %904 ]
%952 = phi double [ %943, %938 ], [ %773, %904 ]
%953 = phi double [ %944, %938 ], [ %767, %904 ]
%954 = phi double [ %945, %938 ], [ %909, %904 ]
%955 = phi <2 x double> [ %946, %938 ], [ %889, %904 ]
%956 = icmp slt i32 %951, %1
br i1 %956, label %957, label %92
957: ; preds = %948
%958 = extractelement <2 x double> %955, i64 1
br label %959
959: ; preds = %957, %83
%960 = phi double [ 0.000000e+00, %83 ], [ %958, %957 ]
%961 = phi double [ 0.000000e+00, %83 ], [ %953, %957 ]
%962 = phi double [ 0.000000e+00, %83 ], [ %954, %957 ]
%963 = tail call double @llvm.fabs.f64(double %84)
%964 = fcmp olt double %963, 1.000000e-30
br i1 %964, label %1642, label %965
965: ; preds = %959
br i1 %8, label %966, label %1406
966: ; preds = %965
%967 = add nsw i32 %0, -2
%968 = sext i32 %967 to i64
%969 = add nsw i32 %0, -3
%970 = sext i32 %969 to i64
%971 = zext i32 %0 to i64
%972 = add nsw i64 %971, -1
br label %978
973: ; preds = %1256, %1398
br i1 %8, label %974, label %1406
974: ; preds = %973
%975 = sext i32 %2 to i64
%976 = sext i32 %1 to i64
%977 = zext i32 %0 to i64
br label %1414
978: ; preds = %966, %1398
%979 = phi i64 [ %972, %966 ], [ %992, %1398 ]
%980 = phi i64 [ %970, %966 ], [ %1405, %1398 ]
%981 = phi i32 [ %0, %966 ], [ %1404, %1398 ]
%982 = phi i64 [ %968, %966 ], [ %1403, %1398 ]
%983 = phi double [ %962, %966 ], [ %1401, %1398 ]
%984 = phi double [ %961, %966 ], [ %1400, %1398 ]
%985 = phi double [ %960, %966 ], [ %1399, %1398 ]
%986 = and i64 %980, 4294967295
%987 = and i64 %982, 4294967295
%988 = getelementptr inbounds double, double* %4, i64 %979
%989 = load double, double* %988
%990 = getelementptr inbounds double, double* %5, i64 %979
%991 = load double, double* %990
%992 = add nsw i64 %979, -1
%993 = fcmp olt double %991, 0xBD719799812DEA11
br i1 %993, label %994, label %1253
994: ; preds = %978
%995 = getelementptr inbounds double*, double** %3, i64 %979
%996 = load double*, double** %995
%997 = getelementptr inbounds double, double* %996, i64 %992
%998 = load double, double* %997
%999 = tail call double @llvm.fabs.f64(double %998)
%1000 = getelementptr inbounds double*, double** %3, i64 %992
%1001 = load double*, double** %1000
%1002 = getelementptr inbounds double, double* %1001, i64 %979
%1003 = load double, double* %1002
%1004 = tail call double @llvm.fabs.f64(double %1003)
%1005 = fcmp ogt double %999, %1004
br i1 %1005, label %1006, label %1015
1006: ; preds = %994
%1007 = fdiv double %991, %998
%1008 = getelementptr inbounds double, double* %1001, i64 %992
store double %1007, double* %1008
%1009 = getelementptr inbounds double, double* %996, i64 %979
%1010 = load double, double* %1009
%1011 = fsub double %1010, %989
%1012 = fneg double %1011
%1013 = load double, double* %997
%1014 = fdiv double %1012, %1013
store double %1014, double* %1002
br label %1022
1015: ; preds = %994
%1016 = fneg double %1003
%1017 = getelementptr inbounds double, double* %1001, i64 %992
%1018 = load double, double* %1017
%1019 = fsub double %1018, %989
%1020 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double 0.000000e+00, double %1016, double %1019, double %991, double* %1017, double* %1002)
%1021 = load double*, double** %995
br label %1022
1022: ; preds = %1015, %1006
%1023 = phi double* [ %1021, %1015 ], [ %996, %1006 ]
%1024 = getelementptr inbounds double, double* %1023, i64 %992
%1025 = bitcast double* %1024 to <2 x double>*
store <2 x double> <double 0.000000e+00, double 1.000000e+00>, <2 x double>* %1025
%1026 = icmp ugt i64 %979, 1
br i1 %1026, label %1027, label %1398
1027: ; preds = %1022
%1028 = fneg double %991
%1029 = tail call double @llvm.fabs.f64(double %991)
%1030 = trunc i64 %992 to i32
br label %1031
1031: ; preds = %1027, %1243
%1032 = phi i32 [ 0, %1027 ], [ %1252, %1243 ]
%1033 = phi i64 [ %986, %1027 ], [ %1251, %1243 ]
%1034 = phi i64 [ %980, %1027 ], [ %1249, %1243 ]
%1035 = phi double [ %983, %1027 ], [ %1248, %1243 ]
%1036 = phi double [ %984, %1027 ], [ %1247, %1243 ]
%1037 = phi double [ %985, %1027 ], [ %1246, %1243 ]
%1038 = phi i32 [ %1030, %1027 ], [ %1245, %1243 ]
%1039 = getelementptr inbounds double*, double** %3, i64 %1033
%1040 = load double*, double** %1039
%1041 = getelementptr inbounds double, double* %1040, i64 %1033
%1042 = load double, double* %1041
%1043 = fsub double %1042, %989
%1044 = sext i32 %1038 to i64
%1045 = icmp slt i64 %979, %1044
br i1 %1045, label %1063, label %1046
1046: ; preds = %1031, %1046
%1047 = phi i64 [ %1059, %1046 ], [ %1044, %1031 ]
%1048 = phi <2 x double> [ %1058, %1046 ], [ zeroinitializer, %1031 ]
%1049 = getelementptr inbounds double, double* %1040, i64 %1047
%1050 = load double, double* %1049
%1051 = getelementptr inbounds double*, double** %3, i64 %1047
%1052 = load double*, double** %1051
%1053 = getelementptr inbounds double, double* %1052, i64 %992
%1054 = bitcast double* %1053 to <2 x double>*
%1055 = load <2 x double>, <2 x double>* %1054
%1056 = insertelement <2 x double> poison, double %1050, i64 0
%1057 = shufflevector <2 x double> %1056, <2 x double> poison, <2 x i32> zeroinitializer
%1058 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1057, <2 x double> %1055, <2 x double> %1048)
%1059 = add nsw i64 %1047, 1
%1060 = icmp slt i64 %1047, %979
br i1 %1060, label %1046, label %1061
1061: ; preds = %1046
%1062 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1057, <2 x double> %1055, <2 x double> %1048)
br label %1063
1063: ; preds = %1061, %1031
%1064 = phi <2 x double> [ zeroinitializer, %1031 ], [ %1062, %1061 ]
%1065 = getelementptr inbounds double, double* %5, i64 %1033
%1066 = load double, double* %1065
%1067 = fcmp olt double %1066, 0.000000e+00
br i1 %1067, label %1068, label %1072
1068: ; preds = %1063
%1069 = trunc i64 %1033 to i32
%1070 = extractelement <2 x double> %1064, i64 0
%1071 = extractelement <2 x double> %1064, i64 1
br label %1243
1072: ; preds = %1063
%1073 = tail call double @llvm.fabs.f64(double %1066)
%1074 = fcmp olt double %1073, 1.000000e-30
br i1 %1074, label %1075, label %1083
1075: ; preds = %1072
%1076 = extractelement <2 x double> %1064, i64 0
%1077 = fneg double %1076
%1078 = extractelement <2 x double> %1064, i64 1
%1079 = fneg double %1078
%1080 = getelementptr inbounds double, double* %1040, i64 %992
%1081 = getelementptr inbounds double, double* %1040, i64 %979
%1082 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double %1077, double %1079, double %1043, double %991, double* %1080, double* %1081)
br label %1181
1083: ; preds = %1072
%1084 = add i64 %1034, 1
%1085 = and i64 %1084, 4294967295
%1086 = getelementptr inbounds double, double* %1040, i64 %1085
%1087 = load double, double* %1086
%1088 = getelementptr inbounds double*, double** %3, i64 %1085
%1089 = load double*, double** %1088
%1090 = getelementptr inbounds double, double* %1089, i64 %1033
%1091 = load double, double* %1090
%1092 = getelementptr inbounds double, double* %4, i64 %1033
%1093 = load double, double* %1092
%1094 = fsub double %1093, %989
%1095 = fmul double %1066, %1066
%1096 = tail call double @llvm.fmuladd.f64(double %1094, double %1094, double %1095)
%1097 = tail call double @llvm.fmuladd.f64(double %1028, double %991, double %1096)
%1098 = fmul double %1094, 2.000000e+00
%1099 = fmul double %991, %1098
%1100 = tail call double @llvm.fabs.f64(double %1097)
%1101 = fcmp olt double %1100, 1.000000e-30
%1102 = tail call double @llvm.fabs.f64(double %1099)
%1103 = fcmp olt double %1102, 1.000000e-30
%1104 = select i1 %1101, i1 %1103, i1 false
br i1 %1104, label %1109, label %1105
1105: ; preds = %1083
%1106 = insertelement <2 x double> poison, double %1035, i64 0
%1107 = insertelement <2 x double> %1106, double %1087, i64 1
%1108 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %1107)
br label %1127
1109: ; preds = %1083
%1110 = tail call double @llvm.fabs.f64(double %1043)
%1111 = fadd double %1029, %1110
%1112 = insertelement <2 x double> poison, double %1035, i64 0
%1113 = insertelement <2 x double> %1112, double %1087, i64 1
%1114 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %1113)
%1115 = extractelement <2 x double> %1114, i64 1
%1116 = fadd double %1111, %1115
%1117 = tail call double @llvm.fabs.f64(double %1091)
%1118 = fadd double %1116, %1117
%1119 = extractelement <2 x double> %1114, i64 0
%1120 = fadd double %1119, %1118
%1121 = fmul double %84, %1120
br label %1122
1122: ; preds = %1122, %1109
%1123 = phi double [ %1121, %1109 ], [ %1124, %1122 ]
%1124 = fmul double %1123, 1.000000e-02
%1125 = fadd double %1121, %1124
%1126 = fcmp ogt double %1125, %1121
br i1 %1126, label %1122, label %1127
1127: ; preds = %1122, %1105
%1128 = phi double [ %1097, %1105 ], [ %1124, %1122 ]
%1129 = phi <2 x double> [ %1108, %1105 ], [ %1114, %1122 ]
%1130 = fneg double %1035
%1131 = extractelement <2 x double> %1064, i64 0
%1132 = fmul double %1131, %1130
%1133 = tail call double @llvm.fmuladd.f64(double %1087, double %1037, double %1132)
%1134 = extractelement <2 x double> %1064, i64 1
%1135 = tail call double @llvm.fmuladd.f64(double %991, double %1134, double %1133)
%1136 = fmul double %1134, %1130
%1137 = tail call double @llvm.fmuladd.f64(double %1087, double %1036, double %1136)
%1138 = tail call double @llvm.fmuladd.f64(double %1028, double %1131, double %1137)
%1139 = getelementptr inbounds double, double* %1040, i64 %992
%1140 = getelementptr inbounds double, double* %1040, i64 %979
%1141 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double %1135, double %1138, double %1128, double %1099, double* %1139, double* %1140)
%1142 = extractelement <2 x double> %1129, i64 0
%1143 = fadd double %1029, %1142
%1144 = extractelement <2 x double> %1129, i64 1
%1145 = fcmp ogt double %1144, %1143
br i1 %1145, label %1146, label %1166
1146: ; preds = %1127
%1147 = fneg double %1131
%1148 = load double*, double** %1039
%1149 = getelementptr inbounds double, double* %1148, i64 %992
%1150 = load double, double* %1149
%1151 = fneg double %1043
%1152 = tail call double @llvm.fmuladd.f64(double %1151, double %1150, double %1147)
%1153 = getelementptr inbounds double, double* %1148, i64 %979
%1154 = load double, double* %1153
%1155 = tail call double @llvm.fmuladd.f64(double %991, double %1154, double %1152)
%1156 = fdiv double %1155, %1087
%1157 = load double*, double** %1088
%1158 = getelementptr inbounds double, double* %1157, i64 %992
store double %1156, double* %1158
%1159 = fneg double %1134
%1160 = load double, double* %1153
%1161 = tail call double @llvm.fmuladd.f64(double %1151, double %1160, double %1159)
%1162 = load double, double* %1149
%1163 = tail call double @llvm.fmuladd.f64(double %1028, double %1162, double %1161)
%1164 = fdiv double %1163, %1087
%1165 = getelementptr inbounds double, double* %1157, i64 %979
store double %1164, double* %1165
br label %1181
1166: ; preds = %1127
%1167 = fneg double %1037
%1168 = load double*, double** %1039
%1169 = getelementptr inbounds double, double* %1168, i64 %992
%1170 = load double, double* %1169
%1171 = fneg double %1091
%1172 = tail call double @llvm.fmuladd.f64(double %1171, double %1170, double %1167)
%1173 = fneg double %1036
%1174 = getelementptr inbounds double, double* %1168, i64 %979
%1175 = load double, double* %1174
%1176 = tail call double @llvm.fmuladd.f64(double %1171, double %1175, double %1173)
%1177 = load double*, double** %1088
%1178 = getelementptr inbounds double, double* %1177, i64 %992
%1179 = getelementptr inbounds double, double* %1177, i64 %979
%1180 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @CDiv to i32 (double, double, double, double, double*, double*, ...)*)(double %1172, double %1176, double %1035, double %991, double* %1178, double* %1179)
br label %1181
1181: ; preds = %1146, %1166, %1075
%1182 = load double*, double** %1039
%1183 = getelementptr inbounds double, double* %1182, i64 %992
%1184 = bitcast double* %1183 to <2 x double>*
%1185 = load <2 x double>, <2 x double>* %1184
%1186 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %1185)
%1187 = extractelement <2 x double> %1186, i64 0
%1188 = extractelement <2 x double> %1186, i64 1
%1189 = fcmp ogt double %1187, %1188
%1190 = select i1 %1189, double %1187, double %1188
%1191 = fcmp ogt double %1190, 1.000000e-30
%1192 = trunc i64 %1033 to i32
br i1 %1191, label %1193, label %1243
1193: ; preds = %1181
%1194 = fdiv double 1.000000e+00, %1190
%1195 = fadd double %1190, %1194
%1196 = fcmp ugt double %1195, %1190
%1197 = shl i64 %1033, 32
%1198 = ashr exact i64 %1197, 32
%1199 = icmp sgt i64 %1198, %979
%1200 = select i1 %1196, i1 true, i1 %1199
br i1 %1200, label %1243, label %1201
1201: ; preds = %1193
%1202 = and i32 %1032, 1
%1203 = icmp eq i32 %1202, 0
br i1 %1203, label %1204, label %1215
1204: ; preds = %1201
%1205 = getelementptr inbounds double*, double** %3, i64 %1034
%1206 = load double*, double** %1205
%1207 = getelementptr inbounds double, double* %1206, i64 %992
%1208 = bitcast double* %1207 to <2 x double>*
%1209 = load <2 x double>, <2 x double>* %1208
%1210 = insertelement <2 x double> poison, double %1190, i64 0
%1211 = shufflevector <2 x double> %1210, <2 x double> poison, <2 x i32> zeroinitializer
%1212 = fdiv <2 x double> %1209, %1211
%1213 = bitcast double* %1207 to <2 x double>*
store <2 x double> %1212, <2 x double>* %1213
%1214 = add nsw i64 %1034, 1
br label %1215
1215: ; preds = %1204, %1201
%1216 = phi i64 [ %1034, %1201 ], [ %1214, %1204 ]
%1217 = icmp eq i32 %1032, -2
br i1 %1217, label %1243, label %1218
1218: ; preds = %1215
%1219 = insertelement <2 x double> poison, double %1190, i64 0
%1220 = shufflevector <2 x double> %1219, <2 x double> poison, <2 x i32> zeroinitializer
%1221 = insertelement <2 x double> poison, double %1190, i64 0
%1222 = shufflevector <2 x double> %1221, <2 x double> poison, <2 x i32> zeroinitializer
br label %1223
1223: ; preds = %1223, %1218
%1224 = phi i64 [ %1216, %1218 ], [ %1240, %1223 ]
%1225 = getelementptr inbounds double*, double** %3, i64 %1224
%1226 = load double*, double** %1225
%1227 = getelementptr inbounds double, double* %1226, i64 %992
%1228 = bitcast double* %1227 to <2 x double>*
%1229 = load <2 x double>, <2 x double>* %1228
%1230 = fdiv <2 x double> %1229, %1220
%1231 = bitcast double* %1227 to <2 x double>*
store <2 x double> %1230, <2 x double>* %1231
%1232 = add nsw i64 %1224, 1
%1233 = getelementptr inbounds double*, double** %3, i64 %1232
%1234 = load double*, double** %1233
%1235 = getelementptr inbounds double, double* %1234, i64 %992
%1236 = bitcast double* %1235 to <2 x double>*
%1237 = load <2 x double>, <2 x double>* %1236
%1238 = fdiv <2 x double> %1237, %1222
%1239 = bitcast double* %1235 to <2 x double>*
store <2 x double> %1238, <2 x double>* %1239
%1240 = add nsw i64 %1224, 2
%1241 = trunc i64 %1240 to i32
%1242 = icmp eq i32 %981, %1241
br i1 %1242, label %1243, label %1223
1243: ; preds = %1215, %1223, %1068, %1193, %1181
%1244 = phi i32 [ %1069, %1068 ], [ %1192, %1193 ], [ %1192, %1181 ], [ %1192, %1223 ], [ %1192, %1215 ]
%1245 = phi i32 [ %1038, %1068 ], [ %1192, %1193 ], [ %1192, %1181 ], [ %1192, %1223 ], [ %1192, %1215 ]
%1246 = phi double [ %1070, %1068 ], [ %1037, %1193 ], [ %1037, %1181 ], [ %1037, %1223 ], [ %1037, %1215 ]
%1247 = phi double [ %1071, %1068 ], [ %1036, %1193 ], [ %1036, %1181 ], [ %1036, %1223 ], [ %1036, %1215 ]
%1248 = phi double [ %1043, %1068 ], [ %1035, %1193 ], [ %1035, %1181 ], [ %1035, %1223 ], [ %1035, %1215 ]
%1249 = add nsw i64 %1034, -1
%1250 = icmp sgt i32 %1244, 0
%1251 = add nsw i64 %1033, -1
%1252 = add i32 %1032, 1
br i1 %1250, label %1031, label %1398
1253: ; preds = %978
%1254 = tail call double @llvm.fabs.f64(double %991)
%1255 = fcmp olt double %1254, 1.000000e-30
br i1 %1255, label %1256, label %1398
1256: ; preds = %1253
%1257 = getelementptr inbounds double*, double** %3, i64 %979
%1258 = load double*, double** %1257
%1259 = getelementptr inbounds double, double* %1258, i64 %979
store double 1.000000e+00, double* %1259
%1260 = icmp eq i64 %979, 0
br i1 %1260, label %973, label %1261
1261: ; preds = %1256
%1262 = trunc i64 %979 to i32
br label %1263
1263: ; preds = %1261, %1389
%1264 = phi i32 [ 0, %1261 ], [ %1397, %1389 ]
%1265 = phi i64 [ %987, %1261 ], [ %1396, %1389 ]
%1266 = phi i64 [ %982, %1261 ], [ %1394, %1389 ]
%1267 = phi double [ %983, %1261 ], [ %1393, %1389 ]
%1268 = phi double [ %984, %1261 ], [ %1392, %1389 ]
%1269 = phi i32 [ %1262, %1261 ], [ %1391, %1389 ]
%1270 = getelementptr inbounds double*, double** %3, i64 %1265
%1271 = load double*, double** %1270
%1272 = getelementptr inbounds double, double* %1271, i64 %1265
%1273 = load double, double* %1272
%1274 = fsub double %1273, %989
%1275 = sext i32 %1269 to i64
%1276 = icmp slt i64 %979, %1275
br i1 %1276, label %1289, label %1277
1277: ; preds = %1263, %1277
%1278 = phi i64 [ %1287, %1277 ], [ %1275, %1263 ]
%1279 = phi double [ %1286, %1277 ], [ 0.000000e+00, %1263 ]
%1280 = getelementptr inbounds double, double* %1271, i64 %1278
%1281 = load double, double* %1280
%1282 = getelementptr inbounds double*, double** %3, i64 %1278
%1283 = load double*, double** %1282
%1284 = getelementptr inbounds double, double* %1283, i64 %979
%1285 = load double, double* %1284
%1286 = tail call double @llvm.fmuladd.f64(double %1281, double %1285, double %1279)
%1287 = add nsw i64 %1278, 1
%1288 = icmp slt i64 %1278, %979
br i1 %1288, label %1277, label %1289
1289: ; preds = %1277, %1263
%1290 = phi double [ 0.000000e+00, %1263 ], [ %1286, %1277 ]
%1291 = getelementptr inbounds double, double* %5, i64 %1265
%1292 = load double, double* %1291
%1293 = fcmp olt double %1292, 0.000000e+00
br i1 %1293, label %1294, label %1296
1294: ; preds = %1289
%1295 = trunc i64 %1265 to i32
br label %1389
1296: ; preds = %1289
%1297 = tail call double @llvm.fabs.f64(double %1292)
%1298 = fcmp olt double %1297, 1.000000e-30
br i1 %1298, label %1299, label %1311
1299: ; preds = %1296
%1300 = tail call double @llvm.fabs.f64(double %1274)
%1301 = fcmp olt double %1300, 1.000000e-30
br i1 %1301, label %1302, label %1307
1302: ; preds = %1299, %1302
%1303 = phi double [ %1304, %1302 ], [ %84, %1299 ]
%1304 = fmul double %1303, 1.000000e-02
%1305 = fadd double %84, %1304
%1306 = fcmp ogt double %1305, %84
br i1 %1306, label %1302, label %1307
1307: ; preds = %1302, %1299
%1308 = phi double [ %1274, %1299 ], [ %1304, %1302 ]
%1309 = fneg double %1290
%1310 = fdiv double %1309, %1308
br label %1343
1311: ; preds = %1296
%1312 = add i64 %1266, 1
%1313 = and i64 %1312, 4294967295
%1314 = getelementptr inbounds double, double* %1271, i64 %1313
%1315 = load double, double* %1314
%1316 = getelementptr inbounds double*, double** %3, i64 %1313
%1317 = load double*, double** %1316
%1318 = getelementptr inbounds double, double* %1317, i64 %1265
%1319 = load double, double* %1318
%1320 = getelementptr inbounds double, double* %4, i64 %1265
%1321 = load double, double* %1320
%1322 = fsub double %1321, %989
%1323 = fmul double %1292, %1292
%1324 = tail call double @llvm.fmuladd.f64(double %1322, double %1322, double %1323)
%1325 = fneg double %1267
%1326 = fmul double %1290, %1325
%1327 = tail call double @llvm.fmuladd.f64(double %1315, double %1268, double %1326)
%1328 = fdiv double %1327, %1324
%1329 = getelementptr inbounds double, double* %1271, i64 %979
store double %1328, double* %1329
%1330 = tail call double @llvm.fabs.f64(double %1315)
%1331 = tail call double @llvm.fabs.f64(double %1267)
%1332 = fcmp ogt double %1330, %1331
br i1 %1332, label %1333, label %1338
1333: ; preds = %1311
%1334 = fneg double %1290
%1335 = fneg double %1274
%1336 = tail call double @llvm.fmuladd.f64(double %1335, double %1328, double %1334)
%1337 = fdiv double %1336, %1315
br label %1343
1338: ; preds = %1311
%1339 = fneg double %1268
%1340 = fneg double %1319
%1341 = tail call double @llvm.fmuladd.f64(double %1340, double %1328, double %1339)
%1342 = fdiv double %1341, %1267
br label %1343
1343: ; preds = %1333, %1338, %1307
%1344 = phi double* [ %1317, %1333 ], [ %1317, %1338 ], [ %1271, %1307 ]
%1345 = phi double [ %1337, %1333 ], [ %1342, %1338 ], [ %1310, %1307 ]
%1346 = getelementptr inbounds double, double* %1344, i64 %979
store double %1345, double* %1346
%1347 = getelementptr inbounds double, double* %1271, i64 %979
%1348 = load double, double* %1347
%1349 = tail call double @llvm.fabs.f64(double %1348)
%1350 = fcmp ogt double %1349, 1.000000e-30
%1351 = trunc i64 %1265 to i32
br i1 %1350, label %1352, label %1389
1352: ; preds = %1343
%1353 = fdiv double 1.000000e+00, %1349
%1354 = fadd double %1349, %1353
%1355 = fcmp ugt double %1354, %1349
%1356 = shl i64 %1265, 32
%1357 = ashr exact i64 %1356, 32
%1358 = icmp sgt i64 %1357, %979
%1359 = select i1 %1355, i1 true, i1 %1358
br i1 %1359, label %1389, label %1360
1360: ; preds = %1352
%1361 = and i32 %1264, 1
%1362 = icmp eq i32 %1361, 0
br i1 %1362, label %1370, label %1363
1363: ; preds = %1360
%1364 = getelementptr inbounds double*, double** %3, i64 %1266
%1365 = load double*, double** %1364
%1366 = getelementptr inbounds double, double* %1365, i64 %979
%1367 = load double, double* %1366
%1368 = fdiv double %1367, %1349
store double %1368, double* %1366
%1369 = add nsw i64 %1266, 1
br label %1370
1370: ; preds = %1363, %1360
%1371 = phi i64 [ %1266, %1360 ], [ %1369, %1363 ]
%1372 = icmp eq i32 %1264, -1
br i1 %1372, label %1389, label %1373
1373: ; preds = %1370, %1373
%1374 = phi i64 [ %1386, %1373 ], [ %1371, %1370 ]
%1375 = getelementptr inbounds double*, double** %3, i64 %1374
%1376 = load double*, double** %1375
%1377 = getelementptr inbounds double, double* %1376, i64 %979
%1378 = load double, double* %1377
%1379 = fdiv double %1378, %1349
store double %1379, double* %1377
%1380 = add nsw i64 %1374, 1
%1381 = getelementptr inbounds double*, double** %3, i64 %1380
%1382 = load double*, double** %1381
%1383 = getelementptr inbounds double, double* %1382, i64 %979
%1384 = load double, double* %1383
%1385 = fdiv double %1384, %1349
store double %1385, double* %1383
%1386 = add nsw i64 %1374, 2
%1387 = trunc i64 %1386 to i32
%1388 = icmp eq i32 %981, %1387
br i1 %1388, label %1389, label %1373
1389: ; preds = %1370, %1373, %1294, %1352, %1343
%1390 = phi i32 [ %1295, %1294 ], [ %1351, %1352 ], [ %1351, %1343 ], [ %1351, %1373 ], [ %1351, %1370 ]
%1391 = phi i32 [ %1269, %1294 ], [ %1351, %1352 ], [ %1351, %1343 ], [ %1351, %1373 ], [ %1351, %1370 ]
%1392 = phi double [ %1290, %1294 ], [ %1268, %1352 ], [ %1268, %1343 ], [ %1268, %1373 ], [ %1268, %1370 ]
%1393 = phi double [ %1274, %1294 ], [ %1267, %1352 ], [ %1267, %1343 ], [ %1267, %1373 ], [ %1267, %1370 ]
%1394 = add nsw i64 %1266, -1
%1395 = icmp sgt i32 %1390, 0
%1396 = add nsw i64 %1265, -1
%1397 = add i32 %1264, 1
br i1 %1395, label %1263, label %1398
1398: ; preds = %1389, %1243, %1022, %1253
%1399 = phi double [ %985, %1022 ], [ %985, %1253 ], [ %1246, %1243 ], [ %1290, %1389 ]
%1400 = phi double [ %984, %1022 ], [ %984, %1253 ], [ %1247, %1243 ], [ %1392, %1389 ]
%1401 = phi double [ %983, %1022 ], [ %983, %1253 ], [ %1248, %1243 ], [ %1393, %1389 ]
%1402 = icmp sgt i64 %979, 0
%1403 = add nsw i64 %982, -1
%1404 = add nsw i32 %981, -1
%1405 = add nsw i64 %980, -1
br i1 %1402, label %978, label %973
1406: ; preds = %1558, %965, %973
%1407 = icmp sgt i32 %0, %1
br i1 %1407, label %1408, label %1642
1408: ; preds = %1406
%1409 = sext i32 %1 to i64
%1410 = add i32 %2, 1
%1411 = sext i32 %0 to i64
%1412 = sext i32 %2 to i64
%1413 = sub nsw i64 1, %1409
br label %1561
1414: ; preds = %974, %1558
%1415 = phi i64 [ 0, %974 ], [ %1559, %1558 ]
%1416 = sub nsw i64 %971, %1415
%1417 = add i64 %1416, -4
%1418 = lshr i64 %1417, 2
%1419 = add nuw nsw i64 %1418, 1
%1420 = sub nsw i64 %971, %1415
%1421 = icmp slt i64 %1415, %976
%1422 = icmp sgt i64 %1415, %975
%1423 = or i1 %1421, %1422
br i1 %1423, label %1424, label %1558
1424: ; preds = %1414
%1425 = getelementptr inbounds double*, double** %3, i64 %1415
%1426 = load double*, double** %1425
%1427 = getelementptr inbounds double*, double** %6, i64 %1415
%1428 = load double*, double** %1427
%1429 = icmp ult i64 %1420, 4
br i1 %1429, label %1520, label %1430
1430: ; preds = %1424
%1431 = getelementptr double, double* %1428, i64 %1415
%1432 = getelementptr double, double* %1428, i64 %971
%1433 = getelementptr double, double* %1426, i64 %1415
%1434 = getelementptr double, double* %1426, i64 %971
%1435 = icmp ult double* %1431, %1434
%1436 = icmp ult double* %1433, %1432
%1437 = and i1 %1435, %1436
br i1 %1437, label %1520, label %1438
1438: ; preds = %1430
%1439 = and i64 %1420, -4
%1440 = add i64 %1415, %1439
%1441 = and i64 %1419, 3
%1442 = icmp ult i64 %1417, 12
br i1 %1442, label %1498, label %1443
1443: ; preds = %1438
%1444 = and i64 %1419, 9223372036854775804
br label %1445
1445: ; preds = %1445, %1443
%1446 = phi i64 [ 0, %1443 ], [ %1495, %1445 ]
%1447 = phi i64 [ 0, %1443 ], [ %1496, %1445 ]
%1448 = add i64 %1415, %1446
%1449 = getelementptr inbounds double, double* %1426, i64 %1448
%1450 = bitcast double* %1449 to <2 x double>*
%1451 = load <2 x double>, <2 x double>* %1450
%1452 = getelementptr inbounds double, double* %1449, i64 2
%1453 = bitcast double* %1452 to <2 x double>*
%1454 = load <2 x double>, <2 x double>* %1453
%1455 = getelementptr inbounds double, double* %1428, i64 %1448
%1456 = bitcast double* %1455 to <2 x double>*
store <2 x double> %1451, <2 x double>* %1456
%1457 = getelementptr inbounds double, double* %1455, i64 2
%1458 = bitcast double* %1457 to <2 x double>*
store <2 x double> %1454, <2 x double>* %1458
%1459 = or i64 %1446, 4
%1460 = add i64 %1415, %1459
%1461 = getelementptr inbounds double, double* %1426, i64 %1460
%1462 = bitcast double* %1461 to <2 x double>*
%1463 = load <2 x double>, <2 x double>* %1462
%1464 = getelementptr inbounds double, double* %1461, i64 2
%1465 = bitcast double* %1464 to <2 x double>*
%1466 = load <2 x double>, <2 x double>* %1465
%1467 = getelementptr inbounds double, double* %1428, i64 %1460
%1468 = bitcast double* %1467 to <2 x double>*
store <2 x double> %1463, <2 x double>* %1468
%1469 = getelementptr inbounds double, double* %1467, i64 2
%1470 = bitcast double* %1469 to <2 x double>*
store <2 x double> %1466, <2 x double>* %1470
%1471 = or i64 %1446, 8
%1472 = add i64 %1415, %1471
%1473 = getelementptr inbounds double, double* %1426, i64 %1472
%1474 = bitcast double* %1473 to <2 x double>*
%1475 = load <2 x double>, <2 x double>* %1474
%1476 = getelementptr inbounds double, double* %1473, i64 2
%1477 = bitcast double* %1476 to <2 x double>*
%1478 = load <2 x double>, <2 x double>* %1477
%1479 = getelementptr inbounds double, double* %1428, i64 %1472
%1480 = bitcast double* %1479 to <2 x double>*
store <2 x double> %1475, <2 x double>* %1480
%1481 = getelementptr inbounds double, double* %1479, i64 2
%1482 = bitcast double* %1481 to <2 x double>*
store <2 x double> %1478, <2 x double>* %1482
%1483 = or i64 %1446, 12
%1484 = add i64 %1415, %1483
%1485 = getelementptr inbounds double, double* %1426, i64 %1484
%1486 = bitcast double* %1485 to <2 x double>*
%1487 = load <2 x double>, <2 x double>* %1486
%1488 = getelementptr inbounds double, double* %1485, i64 2
%1489 = bitcast double* %1488 to <2 x double>*
%1490 = load <2 x double>, <2 x double>* %1489
%1491 = getelementptr inbounds double, double* %1428, i64 %1484
%1492 = bitcast double* %1491 to <2 x double>*
store <2 x double> %1487, <2 x double>* %1492
%1493 = getelementptr inbounds double, double* %1491, i64 2
%1494 = bitcast double* %1493 to <2 x double>*
store <2 x double> %1490, <2 x double>* %1494
%1495 = add nuw i64 %1446, 16
%1496 = add nuw i64 %1447, 4
%1497 = icmp eq i64 %1496, %1444
br i1 %1497, label %1498, label %1445
1498: ; preds = %1445, %1438
%1499 = phi i64 [ 0, %1438 ], [ %1495, %1445 ]
%1500 = icmp eq i64 %1441, 0
br i1 %1500, label %1518, label %1501
1501: ; preds = %1498, %1501
%1502 = phi i64 [ %1515, %1501 ], [ %1499, %1498 ]
%1503 = phi i64 [ %1516, %1501 ], [ 0, %1498 ]
%1504 = add i64 %1415, %1502
%1505 = getelementptr inbounds double, double* %1426, i64 %1504
%1506 = bitcast double* %1505 to <2 x double>*
%1507 = load <2 x double>, <2 x double>* %1506
%1508 = getelementptr inbounds double, double* %1505, i64 2
%1509 = bitcast double* %1508 to <2 x double>*
%1510 = load <2 x double>, <2 x double>* %1509
%1511 = getelementptr inbounds double, double* %1428, i64 %1504
%1512 = bitcast double* %1511 to <2 x double>*
store <2 x double> %1507, <2 x double>* %1512
%1513 = getelementptr inbounds double, double* %1511, i64 2
%1514 = bitcast double* %1513 to <2 x double>*
store <2 x double> %1510, <2 x double>* %1514
%1515 = add nuw i64 %1502, 4
%1516 = add i64 %1503, 1
%1517 = icmp eq i64 %1516, %1441
br i1 %1517, label %1518, label %1501
1518: ; preds = %1501, %1498
%1519 = icmp eq i64 %1420, %1439
br i1 %1519, label %1558, label %1520
1520: ; preds = %1430, %1424, %1518
%1521 = phi i64 [ %1415, %1430 ], [ %1415, %1424 ], [ %1440, %1518 ]
%1522 = sub i64 %971, %1521
%1523 = xor i64 %1521, -1
%1524 = add i64 %1523, %971
%1525 = and i64 %1522, 3
%1526 = icmp eq i64 %1525, 0
br i1 %1526, label %1536, label %1527
1527: ; preds = %1520, %1527
%1528 = phi i64 [ %1533, %1527 ], [ %1521, %1520 ]
%1529 = phi i64 [ %1534, %1527 ], [ 0, %1520 ]
%1530 = getelementptr inbounds double, double* %1426, i64 %1528
%1531 = load double, double* %1530
%1532 = getelementptr inbounds double, double* %1428, i64 %1528
store double %1531, double* %1532
%1533 = add nuw nsw i64 %1528, 1
%1534 = add i64 %1529, 1
%1535 = icmp eq i64 %1534, %1525
br i1 %1535, label %1536, label %1527
1536: ; preds = %1527, %1520
%1537 = phi i64 [ %1521, %1520 ], [ %1533, %1527 ]
%1538 = icmp ult i64 %1524, 3
br i1 %1538, label %1558, label %1539
1539: ; preds = %1536, %1539
%1540 = phi i64 [ %1556, %1539 ], [ %1537, %1536 ]
%1541 = getelementptr inbounds double, double* %1426, i64 %1540
%1542 = load double, double* %1541
%1543 = getelementptr inbounds double, double* %1428, i64 %1540
store double %1542, double* %1543
%1544 = add nuw nsw i64 %1540, 1
%1545 = getelementptr inbounds double, double* %1426, i64 %1544
%1546 = load double, double* %1545
%1547 = getelementptr inbounds double, double* %1428, i64 %1544
store double %1546, double* %1547
%1548 = add nuw nsw i64 %1540, 2
%1549 = getelementptr inbounds double, double* %1426, i64 %1548
%1550 = load double, double* %1549
%1551 = getelementptr inbounds double, double* %1428, i64 %1548
store double %1550, double* %1551
%1552 = add nuw nsw i64 %1540, 3
%1553 = getelementptr inbounds double, double* %1426, i64 %1552
%1554 = load double, double* %1553
%1555 = getelementptr inbounds double, double* %1428, i64 %1552
store double %1554, double* %1555
%1556 = add nuw nsw i64 %1540, 4
%1557 = icmp eq i64 %1556, %977
br i1 %1557, label %1558, label %1539
1558: ; preds = %1536, %1539, %1518, %1414
%1559 = add nuw nsw i64 %1415, 1
%1560 = icmp eq i64 %1559, %977
br i1 %1560, label %1406, label %1414
1561: ; preds = %1408, %1640
%1562 = phi i64 [ %1411, %1408 ], [ %1563, %1640 ]
%1563 = add nsw i64 %1562, -1
%1564 = icmp sgt i64 %1562, %1412
%1565 = trunc i64 %1563 to i32
%1566 = select i1 %1564, i32 %2, i32 %1565
br i1 %85, label %1640, label %1567
1567: ; preds = %1561
%1568 = icmp slt i32 %1566, %1
%1569 = sext i32 %1566 to i64
%1570 = add nsw i64 %1413, %1569
%1571 = sub nsw i64 %1569, %1409
%1572 = and i64 %1570, 3
%1573 = icmp eq i64 %1572, 0
%1574 = icmp ult i64 %1571, 3
br label %1575
1575: ; preds = %1567, %1634
%1576 = phi i64 [ %1409, %1567 ], [ %1637, %1634 ]
%1577 = getelementptr inbounds double*, double** %6, i64 %1576
%1578 = load double*, double** %1577
br i1 %1568, label %1634, label %1579
1579: ; preds = %1575
br i1 %1573, label %1594, label %1580
1580: ; preds = %1579, %1580
%1581 = phi i64 [ %1591, %1580 ], [ %1409, %1579 ]
%1582 = phi double [ %1590, %1580 ], [ 0.000000e+00, %1579 ]
%1583 = phi i64 [ %1592, %1580 ], [ 0, %1579 ]
%1584 = getelementptr inbounds double, double* %1578, i64 %1581
%1585 = load double, double* %1584
%1586 = getelementptr inbounds double*, double** %3, i64 %1581
%1587 = load double*, double** %1586
%1588 = getelementptr inbounds double, double* %1587, i64 %1563
%1589 = load double, double* %1588
%1590 = tail call double @llvm.fmuladd.f64(double %1585, double %1589, double %1582)
%1591 = add nsw i64 %1581, 1
%1592 = add i64 %1583, 1
%1593 = icmp eq i64 %1592, %1572
br i1 %1593, label %1594, label %1580
1594: ; preds = %1580, %1579
%1595 = phi i64 [ %1409, %1579 ], [ %1591, %1580 ]
%1596 = phi double [ 0.000000e+00, %1579 ], [ %1590, %1580 ]
%1597 = phi double [ undef, %1579 ], [ %1590, %1580 ]
br i1 %1574, label %1634, label %1598
1598: ; preds = %1594, %1598
%1599 = phi i64 [ %1632, %1598 ], [ %1595, %1594 ]
%1600 = phi double [ %1631, %1598 ], [ %1596, %1594 ]
%1601 = getelementptr inbounds double, double* %1578, i64 %1599
%1602 = load double, double* %1601
%1603 = getelementptr inbounds double*, double** %3, i64 %1599
%1604 = load double*, double** %1603
%1605 = getelementptr inbounds double, double* %1604, i64 %1563
%1606 = load double, double* %1605
%1607 = tail call double @llvm.fmuladd.f64(double %1602, double %1606, double %1600)
%1608 = add nsw i64 %1599, 1
%1609 = getelementptr inbounds double, double* %1578, i64 %1608
%1610 = load double, double* %1609
%1611 = getelementptr inbounds double*, double** %3, i64 %1608
%1612 = load double*, double** %1611
%1613 = getelementptr inbounds double, double* %1612, i64 %1563
%1614 = load double, double* %1613
%1615 = tail call double @llvm.fmuladd.f64(double %1610, double %1614, double %1607)
%1616 = add nsw i64 %1599, 2
%1617 = getelementptr inbounds double, double* %1578, i64 %1616
%1618 = load double, double* %1617
%1619 = getelementptr inbounds double*, double** %3, i64 %1616
%1620 = load double*, double** %1619
%1621 = getelementptr inbounds double, double* %1620, i64 %1563
%1622 = load double, double* %1621
%1623 = tail call double @llvm.fmuladd.f64(double %1618, double %1622, double %1615)
%1624 = add nsw i64 %1599, 3
%1625 = getelementptr inbounds double, double* %1578, i64 %1624
%1626 = load double, double* %1625
%1627 = getelementptr inbounds double*, double** %3, i64 %1624
%1628 = load double*, double** %1627
%1629 = getelementptr inbounds double, double* %1628, i64 %1563
%1630 = load double, double* %1629
%1631 = tail call double @llvm.fmuladd.f64(double %1626, double %1630, double %1623)
%1632 = add nsw i64 %1599, 4
%1633 = icmp slt i64 %1624, %1569
br i1 %1633, label %1598, label %1634
1634: ; preds = %1594, %1598, %1575
%1635 = phi double [ 0.000000e+00, %1575 ], [ %1597, %1594 ], [ %1631, %1598 ]
%1636 = getelementptr inbounds double, double* %1578, i64 %1563
store double %1635, double* %1636
%1637 = add nsw i64 %1576, 1
%1638 = trunc i64 %1637 to i32
%1639 = icmp eq i32 %1410, %1638
br i1 %1639, label %1640, label %1575
1640: ; preds = %1634, %1561
%1641 = icmp sgt i64 %1563, %1409
br i1 %1641, label %1561, label %1642
1642: ; preds = %1640, %1406, %959, %200
%1643 = phi i32 [ %98, %200 ], [ 0, %959 ], [ 0, %1406 ], [ 0, %1640 ]
ret i32 %1643
}