int svd(int m, int n, double **u, double w[], double **vt) {
  int i, j, k, i1, k1, l1, its;
  double c, f, h, s, x, y, z;
  int l = 0;
  int ierr = 0;
  double g = 0.0;
  double scale = 0.0;
  double anorm = 0.0;
  double *rv1 = malloc(n * sizeof(double));
  if (!rv1)
    return -1;
  if (m >= n) {
    for (i = 0; i < n; i++) {
      l = i + 1;
      rv1[i] = scale * g;
      g = 0.0;
      s = 0.0;
      scale = 0.0;
      for (k = i; k < m; k++)
        scale += fabs(u[k][i]);
      if (scale != 0.0) {
        for (k = i; k < m; k++) {
          u[k][i] /= scale;
          s += u[k][i] * u[k][i];
        }
        f = u[i][i];
        g = (f >= 0) ? -sqrt(s) : sqrt(s);
        h = f * g - s;
        u[i][i] = f - g;
        if (i < n - 1) {
          for (j = l; j < n; j++) {
            s = 0.0;
            for (k = i; k < m; k++)
              s += u[k][i] * u[k][j];
            f = s / h;
            for (k = i; k < m; k++)
              u[k][j] += f * u[k][i];
          }
        }
        for (k = i; k < m; k++)
          u[k][i] *= scale;
      }
      w[i] = scale * g;
      g = 0.0;
      s = 0.0;
      scale = 0.0;
      if (i < n - 1) {
        for (k = l; k < n; k++)
          scale += fabs(u[i][k]);
        if (scale != 0.0) {
          for (k = l; k < n; k++) {
            u[i][k] /= scale;
            s += u[i][k] * u[i][k];
          }
          f = u[i][l];
          g = (f >= 0) ? -sqrt(s) : sqrt(s);
          h = f * g - s;
          u[i][l] = f - g;
          for (k = l; k < n; k++)
            rv1[k] = u[i][k] / h;
          for (j = l; j < m; j++) {
            s = 0.0;
            for (k = l; k < n; k++)
              s += u[j][k] * u[i][k];
            for (k = l; k < n; k++)
              u[j][k] += s * rv1[k];
          }
          for (k = l; k < n; k++)
            u[i][k] *= scale;
        }
      }
      anorm =
          ((anorm) > (fabs(w[i]) + fabs(rv1[i])) ? (anorm)
                                                 : (fabs(w[i]) + fabs(rv1[i])));
    }
    for (i = n - 1; i >= 0; i--) {
      if (i < n - 1) {
        if (g != 0.0) {
          for (j = l; j < n; j++)
            vt[i][j] = (u[i][j] / u[i][l]) / g;
          for (j = l; j < n; j++) {
            s = 0.0;
            for (k = l; k < n; k++)
              s += u[i][k] * vt[j][k];
            for (k = l; k < n; k++)
              vt[j][k] += s * vt[i][k];
          }
        }
      }
      for (j = l; j < n; j++) {
        vt[j][i] = 0.0;
        vt[i][j] = 0.0;
      }
      vt[i][i] = 1.0;
      g = rv1[i];
      l = i;
    }
    for (i = n - 1; i >= 0; i--) {
      l = i + 1;
      g = w[i];
      if (i != n - 1)
        for (j = l; j < n; j++)
          u[i][j] = 0.0;
      if (g != 0.0) {
        if (i != n - 1) {
          for (j = l; j < n; j++) {
            s = 0.0;
            for (k = l; k < m; k++)
              s += u[k][i] * u[k][j];
            f = (s / u[i][i]) / g;
            for (k = i; k < m; k++)
              u[k][j] += f * u[k][i];
          }
        }
        for (j = i; j < m; j++)
          u[j][i] /= g;
      } else
        for (j = i; j < m; j++)
          u[j][i] = 0.0;
      u[i][i] += 1.0;
    }
    for (k = n - 1; k >= 0; k--) {
      k1 = k - 1;
      its = 0;
      while (1) {
        for (l = k; l >= 0; l--) {
          l1 = l - 1;
          if (fabs(rv1[l]) + anorm == anorm)
            break;
          if (fabs(w[l1]) + anorm == anorm) {
            c = 0.0;
            s = 1.0;
            for (i = l; i <= k; i++) {
              f = s * rv1[i];
              rv1[i] *= c;
              if (fabs(f) + anorm == anorm)
                break;
              g = w[i];
              h = sqrt(f * f + g * g);
              w[i] = h;
              c = g / h;
              s = -f / h;
              for (j = 0; j < m; j++) {
                y = u[j][l1];
                z = u[j][i];
                u[j][l1] = y * c + z * s;
                u[j][i] = -y * s + z * c;
              }
            }
            break;
          }
        }
        z = w[k];
        if (l == k) {
          if (z < 0.0) {
            w[k] = -z;
            for (j = 0; j < n; j++)
              vt[k][j] = -vt[k][j];
          }
          break;
        } else if (its == 30) {
          ierr = k;
          break;
        } else {
          its++;
          x = w[l];
          y = w[k1];
          g = rv1[k1];
          h = rv1[k];
          f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
          g = sqrt(f * f + 1.0);
          f = ((x - z) * (x + z) + h * (y / (f + (f >= 0 ? g : -g)) - h)) / x;
          c = 1.0;
          s = 1.0;
          for (i1 = l; i1 <= k1; i1++) {
            i = i1 + 1;
            g = rv1[i];
            y = w[i];
            h = s * g;
            g = c * g;
            z = sqrt(f * f + h * h);
            rv1[i1] = z;
            c = f / z;
            s = h / z;
            f = x * c + g * s;
            g = -x * s + g * c;
            h = y * s;
            y = y * c;
            for (j = 0; j < n; j++) {
              x = vt[i1][j];
              z = vt[i][j];
              vt[i1][j] = x * c + z * s;
              vt[i][j] = -x * s + z * c;
            }
            z = sqrt(f * f + h * h);
            w[i1] = z;
            if (z != 0.0) {
              c = f / z;
              s = h / z;
            }
            f = c * g + s * y;
            x = -s * g + c * y;
            for (j = 0; j < m; j++) {
              y = u[j][i1];
              z = u[j][i];
              u[j][i1] = y * c + z * s;
              u[j][i] = -y * s + z * c;
            }
          }
          rv1[l] = 0.0;
          rv1[k] = f;
          w[k] = x;
        }
      }
    }
  } else {
    for (i = 0; i < m; i++) {
      l = i + 1;
      rv1[i] = scale * g;
      g = 0.0;
      s = 0.0;
      scale = 0.0;
      for (k = i; k < n; k++)
        scale += fabs(u[i][k]);
      if (scale != 0.0) {
        for (k = i; k < n; k++) {
          u[i][k] /= scale;
          s += u[i][k] * u[i][k];
        }
        f = u[i][i];
        g = (f >= 0) ? -sqrt(s) : sqrt(s);
        h = f * g - s;
        u[i][i] = f - g;
        if (i < m - 1) {
          for (j = l; j < m; j++) {
            s = 0.0;
            for (k = i; k < n; k++)
              s += u[i][k] * u[j][k];
            f = s / h;
            for (k = i; k < n; k++)
              u[j][k] += f * u[i][k];
          }
        }
        for (k = i; k < n; k++)
          u[i][k] *= scale;
      }
      w[i] = scale * g;
      g = 0.0;
      s = 0.0;
      scale = 0.0;
      if (i < m - 1) {
        for (k = l; k < m; k++)
          scale += fabs(u[k][i]);
        if (scale != 0.0) {
          for (k = l; k < m; k++) {
            u[k][i] /= scale;
            s += u[k][i] * u[k][i];
          }
          f = u[l][i];
          g = (f >= 0) ? -sqrt(s) : sqrt(s);
          h = f * g - s;
          u[l][i] = f - g;
          for (k = l; k < m; k++)
            rv1[k] = u[k][i] / h;
          for (j = l; j < n; j++) {
            s = 0.0;
            for (k = l; k < m; k++)
              s += u[k][j] * u[k][i];
            for (k = l; k < m; k++)
              u[k][j] += s * rv1[k];
          }
          for (k = l; k < m; k++)
            u[k][i] *= scale;
        }
      }
      anorm =
          ((anorm) > (fabs(w[i]) + fabs(rv1[i])) ? (anorm)
                                                 : (fabs(w[i]) + fabs(rv1[i])));
    }
    for (i = m - 1; i >= 0; i--) {
      if (i < m - 1) {
        if (g != 0.0) {
          for (j = l; j < m; j++)
            vt[j][i] = (u[j][i] / u[l][i]) / g;
          for (j = l; j < m; j++) {
            s = 0.0;
            for (k = l; k < m; k++)
              s += u[k][i] * vt[k][j];
            for (k = l; k < m; k++)
              vt[k][j] += s * vt[k][i];
          }
        }
      }
      for (j = l; j < m; j++) {
        vt[i][j] = 0.0;
        vt[j][i] = 0.0;
      }
      vt[i][i] = 1.0;
      g = rv1[i];
      l = i;
    }
    for (i = m - 1; i >= 0; i--) {
      l = i + 1;
      g = w[i];
      if (i != m - 1)
        for (j = l; j < m; j++)
          u[j][i] = 0.0;
      if (g != 0.0) {
        if (i != m - 1) {
          for (j = l; j < m; j++) {
            s = 0.0;
            for (k = l; k < n; k++)
              s += u[i][k] * u[j][k];
            f = (s / u[i][i]) / g;
            for (k = i; k < n; k++)
              u[j][k] += f * u[i][k];
          }
        }
        for (j = i; j < n; j++)
          u[i][j] /= g;
      } else
        for (j = i; j < n; j++)
          u[i][j] = 0.0;
      u[i][i] += 1.0;
    }
    for (k = m - 1; k >= 0; k--) {
      k1 = k - 1;
      its = 0;
      while (1) {
        for (l = k; l >= 0; l--) {
          l1 = l - 1;
          if (fabs(rv1[l]) + anorm == anorm)
            break;
          if (fabs(w[l1]) + anorm == anorm) {
            c = 0.0;
            s = 1.0;
            for (i = l; i <= k; i++) {
              f = s * rv1[i];
              rv1[i] *= c;
              if (fabs(f) + anorm == anorm)
                break;
              g = w[i];
              h = sqrt(f * f + g * g);
              w[i] = h;
              c = g / h;
              s = -f / h;
              for (j = 0; j < n; j++) {
                y = u[l1][j];
                z = u[i][j];
                u[l1][j] = y * c + z * s;
                u[i][j] = -y * s + z * c;
              }
            }
            break;
          }
        }
        z = w[k];
        if (l == k) {
          if (z < 0.0) {
            w[k] = -z;
            for (j = 0; j < m; j++)
              vt[j][k] = -vt[j][k];
          }
          break;
        } else if (its == 30) {
          ierr = k;
          break;
        } else {
          its++;
          x = w[l];
          y = w[k1];
          g = rv1[k1];
          h = rv1[k];
          f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
          g = sqrt(f * f + 1.0);
          f = ((x - z) * (x + z) + h * (y / (f + (f >= 0 ? g : -g)) - h)) / x;
          c = 1.0;
          s = 1.0;
          for (i1 = l; i1 <= k1; i1++) {
            i = i1 + 1;
            g = rv1[i];
            y = w[i];
            h = s * g;
            g = c * g;
            z = sqrt(f * f + h * h);
            rv1[i1] = z;
            c = f / z;
            s = h / z;
            f = x * c + g * s;
            g = -x * s + g * c;
            h = y * s;
            y = y * c;
            for (j = 0; j < m; j++) {
              x = vt[j][i1];
              z = vt[j][i];
              vt[j][i1] = x * c + z * s;
              vt[j][i] = -x * s + z * c;
            }
            z = sqrt(f * f + h * h);
            w[i1] = z;
            if (z != 0.0) {
              c = f / z;
              s = h / z;
            }
            f = c * g + s * y;
            x = -s * g + c * y;
            for (j = 0; j < n; j++) {
              y = u[i1][j];
              z = u[i][j];
              u[i1][j] = y * c + z * s;
              u[i][j] = -y * s + z * c;
            }
          }
          rv1[l] = 0.0;
          rv1[k] = f;
          w[k] = x;
        }
      }
    }
  }
  free(rv1);
  return ierr;
}


x86 assembly (clang, -O0):
<svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
cmpq   $0x0,-0xa8(%rbp)
jne    11b0 <svd+0x80>
movl   $0xffffffff,-0x4(%rbp)
jmp    3e7d <svd+0x2d4d>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     2812 <svd+0x16e2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1991 <svd+0x861>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1269 <svd+0x139>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2db9(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121f <svd+0xef>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1289 <svd+0x159>
jp     1289 <svd+0x159>
jmp    1533 <svd+0x403>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    130b <svd+0x1db>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128f <svd+0x15f>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1365 <svd+0x235>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1377 <svd+0x247>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14ec <svd+0x3bc>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14e7 <svd+0x3b7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1469 <svd+0x339>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%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  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1413 <svd+0x2e3>
movsd  -0x68(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14d4 <svd+0x3a4>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    147e <svd+0x34e>
jmp    14d9 <svd+0x3a9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13f9 <svd+0x2c9>
jmp    14ec <svd+0x3bc>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    152e <svd+0x3fe>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14f2 <svd+0x3c2>
jmp    1533 <svd+0x403>
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    18d6 <svd+0x7a6>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15d2 <svd+0x4a2>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2a50(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1588 <svd+0x458>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15f2 <svd+0x4c2>
jp     15f2 <svd+0x4c2>
jmp    18d1 <svd+0x7a1>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1677 <svd+0x547>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%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 -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15fb <svd+0x4cb>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     16d4 <svd+0x5a4>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    16e6 <svd+0x5b6>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    179e <svd+0x66e>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    175a <svd+0x62a>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1887 <svd+0x757>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    181a <svd+0x6ea>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17c4 <svd+0x694>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1874 <svd+0x744>
movsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1823 <svd+0x6f3>
jmp    1879 <svd+0x749>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17a7 <svd+0x677>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18cc <svd+0x79c>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1890 <svd+0x760>
jmp    18d1 <svd+0x7a1>
jmp    18d6 <svd+0x7a6>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x270e(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x26f3(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1934 <svd+0x804>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1973 <svd+0x843>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x26b8(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x269d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c3 <svd+0x93>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1bd9 <svd+0xaa9>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b3a <svd+0xa0a>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19d5 <svd+0x8a5>
jp     19d5 <svd+0x8a5>
jmp    1b35 <svd+0xa05>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a42 <svd+0x912>
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 -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%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    19de <svd+0x8ae>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b30 <svd+0xa00>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1abe <svd+0x98e>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a68 <svd+0x938>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b1d <svd+0x9ed>
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ac7 <svd+0x997>
jmp    1b22 <svd+0x9f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a4b <svd+0x91b>
jmp    1b35 <svd+0xa05>
jmp    1b3a <svd+0xa0a>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b8d <svd+0xa5d>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b43 <svd+0xa13>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x246b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    199a <svd+0x86a>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1e5e <svd+0xd2e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1c5e <svd+0xb2e>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1c59 <svd+0xb29>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c27 <svd+0xaf7>
jmp    1c5e <svd+0xb2e>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c7e <svd+0xb4e>
jp     1c7e <svd+0xb4e>
jmp    1df1 <svd+0xcc1>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1da6 <svd+0xc76>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1da1 <svd+0xc71>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1d0b <svd+0xbdb>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%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  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1cb5 <svd+0xb85>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1d8e <svd+0xc5e>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d38 <svd+0xc08>
jmp    1d93 <svd+0xc63>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c98 <svd+0xb68>
jmp    1da6 <svd+0xc76>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1dec <svd+0xcbc>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%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    1dac <svd+0xc7c>
jmp    1e2e <svd+0xcfe>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1e29 <svd+0xcf9>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1df7 <svd+0xcc7>
jmp    1e2e <svd+0xcfe>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x21ca(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1be2 <svd+0xab2>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     280d <svd+0x16dd>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
jl     212f <svd+0xfff>
mov    -0x84(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2143(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jne    1ee2 <svd+0xdb2>
jp     1ee2 <svd+0xdb2>
jmp    212f <svd+0xfff>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x210a(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jne    2116 <svd+0xfe6>
jp     2116 <svd+0xfe6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x20ea(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     2111 <svd+0xfe1>
movsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movaps 0x2080(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jne    1fa5 <svd+0xe75>
jp     1fa5 <svd+0xe75>
jmp    2111 <svd+0xfe1>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    20fe <svd+0xfce>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2037 <svd+0xf07>
jmp    2103 <svd+0xfd3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f34 <svd+0xe04>
jmp    212f <svd+0xfff>
jmp    211b <svd+0xfeb>
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    1e8a <svd+0xd5a>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    21f3 <svd+0x10c3>
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    21ee <svd+0x10be>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    21e9 <svd+0x10b9>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%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    218e <svd+0x105e>
jmp    21ee <svd+0x10be>
jmp    27fa <svd+0x16ca>
cmpl   $0x1e,-0x44(%rbp)
jne    220b <svd+0x10db>
mov    -0x34(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    27fa <svd+0x16ca>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
addsd  -0x80(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
subsd  -0x60(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
addsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1d6e(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1d3d(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2356 <svd+0x1226>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    237d <svd+0x124d>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0xf0(%rbp),%xmm5
ff
addsd  %xmm5,%xmm4
divsd  %xmm4,%xmm3
subsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x1c38(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x1c2b(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     27b3 <svd+0x1683>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2600 <svd+0x14d0>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%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    2539 <svd+0x1409>
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2655 <svd+0x1525>
jp     2655 <svd+0x1525>
jmp    2673 <svd+0x1543>
movsd  -0x58(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    27a0 <svd+0x1670>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    26d9 <svd+0x15a9>
jmp    27a5 <svd+0x1675>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    23f3 <svd+0x12c3>
mov    -0xa8(%rbp),%rax
movslq -0x84(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    27f5 <svd+0x16c5>
jmp    1e81 <svd+0xd51>
jmp    27ff <svd+0x16cf>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1e67 <svd+0xd37>
jmp    3e68 <svd+0x2d38>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2fe7 <svd+0x1eb7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    28bf <svd+0x178f>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1763(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2875 <svd+0x1745>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    28df <svd+0x17af>
jp     28df <svd+0x17af>
jmp    2b89 <svd+0x1a59>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2961 <svd+0x1831>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%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 -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    28e5 <svd+0x17b5>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     29bb <svd+0x188b>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    29cd <svd+0x189d>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2b42 <svd+0x1a12>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2b3d <svd+0x1a0d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2abf <svd+0x198f>
mov    -0x18(%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 -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2a69 <svd+0x1939>
movsd  -0x68(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2b2a <svd+0x19fa>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2ad4 <svd+0x19a4>
jmp    2b2f <svd+0x19ff>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2a4f <svd+0x191f>
jmp    2b42 <svd+0x1a12>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2b84 <svd+0x1a54>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2b48 <svd+0x1a18>
jmp    2b89 <svd+0x1a59>
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2f2c <svd+0x1dfc>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2c28 <svd+0x1af8>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x13fa(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2bde <svd+0x1aae>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2c48 <svd+0x1b18>
jp     2c48 <svd+0x1b18>
jmp    2f27 <svd+0x1df7>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2ccd <svd+0x1b9d>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2c51 <svd+0x1b21>
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2d2a <svd+0x1bfa>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    2d3c <svd+0x1c0c>
movsd  -0x68(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2df4 <svd+0x1cc4>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2db0 <svd+0x1c80>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2edd <svd+0x1dad>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2e70 <svd+0x1d40>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2e1a <svd+0x1cea>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2eca <svd+0x1d9a>
movsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2e79 <svd+0x1d49>
jmp    2ecf <svd+0x1d9f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2dfd <svd+0x1ccd>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2f22 <svd+0x1df2>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2ee6 <svd+0x1db6>
jmp    2f27 <svd+0x1df7>
jmp    2f2c <svd+0x1dfc>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x10b8(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x109d(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    2f8a <svd+0x1e5a>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
jmp    2fc9 <svd+0x1e99>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1062(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1047(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2819 <svd+0x16e9>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     322f <svd+0x20ff>
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    3190 <svd+0x2060>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    302b <svd+0x1efb>
jp     302b <svd+0x1efb>
jmp    318b <svd+0x205b>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3098 <svd+0x1f68>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    3034 <svd+0x1f04>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3186 <svd+0x2056>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3114 <svd+0x1fe4>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    30be <svd+0x1f8e>
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3173 <svd+0x2043>
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    311d <svd+0x1fed>
jmp    3178 <svd+0x2048>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    30a1 <svd+0x1f71>
jmp    318b <svd+0x205b>
jmp    3190 <svd+0x2060>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    31e3 <svd+0x20b3>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    3199 <svd+0x2069>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0xe15(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    2ff0 <svd+0x1ec0>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     34b4 <svd+0x2384>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     32b4 <svd+0x2184>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    32af <svd+0x217f>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    327d <svd+0x214d>
jmp    32b4 <svd+0x2184>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    32d4 <svd+0x21a4>
jp     32d4 <svd+0x21a4>
jmp    3447 <svd+0x2317>
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     33fc <svd+0x22cc>
mov    -0x84(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    33f7 <svd+0x22c7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    3361 <svd+0x2231>
mov    -0x18(%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 -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    330b <svd+0x21db>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    33e4 <svd+0x22b4>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    338e <svd+0x225e>
jmp    33e9 <svd+0x22b9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    32ee <svd+0x21be>
jmp    33fc <svd+0x22cc>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    3442 <svd+0x2312>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%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    3402 <svd+0x22d2>
jmp    3484 <svd+0x2354>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    347f <svd+0x234f>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    344d <svd+0x231d>
jmp    3484 <svd+0x2354>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0xb74(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    3238 <svd+0x2108>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     3e63 <svd+0x2d33>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
jl     3785 <svd+0x2655>
mov    -0x84(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xaed(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jne    3538 <svd+0x2408>
jp     3538 <svd+0x2408>
jmp    3785 <svd+0x2655>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xab4(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jne    376c <svd+0x263c>
jp     376c <svd+0x263c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xa94(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     3767 <svd+0x2637>
movsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movaps 0xa2a(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jne    35fb <svd+0x24cb>
jp     35fb <svd+0x24cb>
jmp    3767 <svd+0x2637>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    3754 <svd+0x2624>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%rbp),%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%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    368d <svd+0x255d>
jmp    3759 <svd+0x2629>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    358a <svd+0x245a>
jmp    3785 <svd+0x2655>
jmp    3771 <svd+0x2641>
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    34e0 <svd+0x23b0>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    3849 <svd+0x2719>
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    3844 <svd+0x2714>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    383f <svd+0x270f>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    37e4 <svd+0x26b4>
jmp    3844 <svd+0x2714>
jmp    3e50 <svd+0x2d20>
cmpl   $0x1e,-0x44(%rbp)
jne    3861 <svd+0x2731>
mov    -0x34(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    3e50 <svd+0x2d20>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
addsd  -0x80(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
subsd  -0x60(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
addsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x718(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x6e7(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     39ac <svd+0x287c>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
jmp    39d3 <svd+0x28a3>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0x110(%rbp),%xmm4
ff
movsd  -0x138(%rbp),%xmm5
ff
addsd  %xmm5,%xmm4
divsd  %xmm4,%xmm3
subsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x5e2(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x5d5(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     3e09 <svd+0x2cd9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3c56 <svd+0x2b26>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    3b8f <svd+0x2a5f>
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3cab <svd+0x2b7b>
jp     3cab <svd+0x2b7b>
jmp    3cc9 <svd+0x2b99>
movsd  -0x58(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    3df6 <svd+0x2cc6>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%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    3d2f <svd+0x2bff>
jmp    3dfb <svd+0x2ccb>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    3a49 <svd+0x2919>
mov    -0xa8(%rbp),%rax
movslq -0x84(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    3e4b <svd+0x2d1b>
jmp    34d7 <svd+0x23a7>
jmp    3e55 <svd+0x2d25>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    34bd <svd+0x238d>
jmp    3e68 <svd+0x2d38>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r8,%r14
mov    %rcx,0x38(%rsp)
mov    %rdx,(%rsp)
mov    %esi,%ebp
mov    %edi,%r15d
movslq %esi,%rbx
lea    0x0(,%rbx,8),%rdi
call   1050 <malloc@plt>
test   %rax,%rax
je     1b58 <svd+0xa18>
mov    %rax,%rcx
mov    %ebp,%eax
sub    %r15d,%eax
mov    %rax,0x58(%rsp)
mov    %rcx,0x68(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbp,0xf0(%rsp)
mov    %r15,0x130(%rsp)
mov    %rbx,0x80(%rsp)
jle    1b62 <svd+0xa22>
test   %r15d,%r15d
mov    0x38(%rsp),%r11
jle    4f6b <svd+0x3e2b>
lea    -0x1(%r15),%edi
mov    %r15d,%r9d
mov    %ebp,%ebx
mov    %rbx,%rax
neg    %rax
mov    %rax,0x100(%rsp)
lea    -0x4(%rbx),%r14
xorpd  %xmm11,%xmm11
mov    $0x1,%r10d
mov    $0x6,%r12d
movapd 0x3e0d(%rip),%xmm8
movapd 0x3e14(%rip),%xmm9
movapd 0x3dfb(%rip),%xmm12
mov    %rcx,%rsi
mov    %r9,%rdx
mov    (%rsp),%r8
mov    %r8,%r13
mov    %rcx,%rax
mov    %rbx,%rbp
xorpd  %xmm10,%xmm10
xorpd  %xmm3,%xmm3
xorpd  %xmm1,%xmm1
mov    %r9,0x8(%rsp)
mov    %rbx,%rcx
mov    %rbx,0x30(%rsp)
xor    %ecx,%ecx
mov    %rdi,0xb0(%rsp)
jmp    1299 <svd+0x159>
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r11,%r15,8),%xmm0
andpd  %xmm12,%xmm0
mov    0x68(%rsp),%rax
movsd  (%rax,%r15,8),%xmm2
andpd  %xmm12,%xmm2
addsd  %xmm0,%xmm2
maxsd  %xmm2,%xmm10
add    $0x1,%r10
add    $0xffffffffffffffff,%rbp
add    $0x1,%r12
add    $0xffffffffffffffff,%r14
add    $0x8,%r13
add    $0xffffffffffffffff,%rdx
add    $0x8,%rsi
cmp    %r9,%rcx
je     27ae <svd+0x166e>
mov    %rcx,%r15
mulsd  %xmm1,%xmm3
add    $0x1,%rcx
movsd  %xmm3,(%rax,%r15,8)
xorpd  %xmm1,%xmm1
xorpd  %xmm13,%xmm13
cmp    0x80(%rsp),%r15
mov    %rdx,0x20(%rsp)
mov    %rcx,0x10(%rsp)
jge    18c0 <svd+0x780>
mov    %r14,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x70(%rsp)
mov    %rbx,%rax
sub    %r15,%rax
mov    %rax,0xc0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe8(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x78(%rsp)
lea    0x0(,%r15,8),%rcx
mov    (%r8,%r15,8),%rax
mov    %rcx,0xa0(%rsp)
add    %rcx,%rax
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1330 <svd+0x1f0>
xorpd  %xmm13,%xmm13
ucomisd %xmm13,%xmm1
jne    1359 <svd+0x219>
jnp    13d5 <svd+0x295>
mov    (%r8,%r15,8),%rax
xorpd  %xmm3,%xmm3
cmp    0x80(%rsp),%r15
jge    139f <svd+0x25f>
lea    (%rax,%r15,8),%rcx
xorpd  %xmm3,%xmm3
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1380 <svd+0x240>
mov    %rsi,0x48(%rsp)
mov    %r12,0xd0(%rsp)
movsd  (%rax,%r15,8),%xmm14
ucomisd %xmm11,%xmm3
mov    0xc0(%rsp),%rbx
mov    %r14,0x98(%rsp)
mov    %r10,%r12
jb     13df <svd+0x29f>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1454 <svd+0x314>
mov    0x10(%rsp),%rcx
jmp    18c0 <svd+0x780>
movapd %xmm3,%xmm0
movsd  %xmm10,0x50(%rsp)
movapd %xmm1,0x140(%rsp)
movsd  %xmm14,0x60(%rsp)
movsd  %xmm3,0xf8(%rsp)
call   1060 <sqrt@plt>
movsd  0xf8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm14
movapd 0x140(%rsp),%xmm1
movapd 0x3bd6(%rip),%xmm12
mov    0xb0(%rsp),%rdi
xorpd  %xmm11,%xmm11
movsd  0x50(%rsp),%xmm10
movapd 0x3bc9(%rip),%xmm9
movapd 0x3bb0(%rip),%xmm8
mov    (%rsp),%r8
xorpd  %xmm13,%xmm13
cmpnlesd %xmm14,%xmm13
movapd %xmm13,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm13
orpd   %xmm2,%xmm13
movapd %xmm14,%xmm0
subsd  %xmm13,%xmm0
mov    (%r8,%r15,8),%r14
movsd  %xmm0,(%r14,%r15,8)
cmp    %rdi,%r15
jae    16f0 <svd+0x5b0>
mov    0x10(%rsp),%rax
cmp    0x8(%rsp),%rax
jae    16f0 <svd+0x5b0>
mulsd  %xmm13,%xmm14
subsd  %xmm3,%xmm14
lea    (%r14,%r15,8),%rcx
mov    0x30(%rsp),%rax
lea    (%r14,%rax,8),%r9
mov    %rbx,%r10
and    $0xfffffffffffffffc,%r10
lea    (%r15,%r10,1),%r8
mov    0xd0(%rsp),%rax
lea    (%r14,%rax,8),%r11
mov    %r12,%rdi
jmp    14ef <svd+0x3af>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    0x8(%rsp),%rdi
je     16f0 <svd+0x5b0>
cmp    0x80(%rsp),%r15
jge    14e0 <svd+0x3a0>
mov    (%rsp),%rax
mov    (%rax,%rdi,8),%rax
add    0xa0(%rsp),%rax
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nop
movsd  (%rcx,%rdx,8),%xmm2
mulsd  (%rax,%rdx,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1510 <svd+0x3d0>
cmp    0x80(%rsp),%r15
jge    14e0 <svd+0x3a0>
divsd  %xmm14,%xmm0
mov    (%rsp),%rax
mov    (%rax,%rdi,8),%rdx
mov    %r15,%rax
cmp    $0x4,%rbx
jb     1670 <svd+0x530>
lea    (%rdx,%r15,8),%rax
cmp    %r9,%rax
jae    1569 <svd+0x429>
mov    0x30(%rsp),%rax
lea    (%rdx,%rax,8),%rsi
mov    %r15,%rax
cmp    %rsi,%rcx
jb     1670 <svd+0x530>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x4,0xe8(%rsp)
jae    1583 <svd+0x443>
xor    %esi,%esi
jmp    1613 <svd+0x4d3>
mov    0xd0(%rsp),%rax
lea    (%rdx,%rax,8),%rbx
mov    0x70(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%r11,%rsi,8),%xmm3
movupd -0x20(%r11,%rsi,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%rbx,%rsi,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%rbx,%rsi,8),%xmm3
movupd -0x10(%rbx,%rsi,8),%xmm6
movupd (%rbx,%rsi,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%rbx,%rsi,8)
movupd %xmm4,-0x20(%rbx,%rsi,8)
movupd -0x10(%r11,%rsi,8),%xmm3
movupd (%r11,%rsi,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%rbx,%rsi,8)
movupd %xmm4,(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    15a0 <svd+0x460>
testb  $0x1,0x78(%rsp)
je     1650 <svd+0x510>
add    %r15,%rsi
movupd (%r14,%rsi,8),%xmm3
movupd 0x10(%r14,%rsi,8),%xmm4
movupd (%rdx,%rsi,8),%xmm5
movupd 0x10(%rdx,%rsi,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rdx,%rsi,8)
movupd %xmm4,0x10(%rdx,%rsi,8)
mov    %r8,%rax
mov    0xc0(%rsp),%rbx
cmp    %r10,%rbx
je     14e0 <svd+0x3a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rbx
sub    %eax,%ebx
mov    %rax,%rsi
test   $0x1,%bl
je     1697 <svd+0x557>
movsd  (%r14,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
lea    0x1(%rax),%rsi
not    %rax
cmp    0x100(%rsp),%rax
mov    0xc0(%rsp),%rbx
je     14e0 <svd+0x3a0>
movsd  (%r14,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rsi,8),%xmm2
movsd  %xmm2,(%rdx,%rsi,8)
movsd  0x8(%r14,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  0x8(%rdx,%rsi,8),%xmm2
movsd  %xmm2,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,0x30(%rsp)
jne    16b0 <svd+0x570>
jmp    14e0 <svd+0x3a0>
nopl   0x0(%rax,%rax,1)
cmp    0x80(%rsp),%r15
jge    1749 <svd+0x609>
mov    %r15,%rax
cmp    $0x4,%rbx
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%rbx
mov    0x48(%rsp),%rsi
mov    0x20(%rsp),%rdx
jb     186a <svd+0x72a>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x4,0xe8(%rsp)
jae    178b <svd+0x64b>
xor    %ecx,%ecx
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
mov    %r12,%r10
mov    0xb0(%rsp),%r12
jmp    1808 <svd+0x6c8>
mov    0x38(%rsp),%r11
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
mov    0x30(%rsp),%rbx
mov    0x98(%rsp),%r14
mov    %r12,%r10
mov    0xb0(%rsp),%rdi
mov    0xd0(%rsp),%r12
mov    0x48(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    0x10(%rsp),%rcx
jmp    18c0 <svd+0x780>
mov    0xd0(%rsp),%rax
lea    (%r14,%rax,8),%rax
xor    %ecx,%ecx
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
mov    %r12,%r10
mov    0xb0(%rsp),%r12
mov    0x70(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x30(%rax,%rcx,8),%xmm2
movupd -0x20(%rax,%rcx,8),%xmm3
movupd -0x10(%rax,%rcx,8),%xmm4
movupd (%rax,%rcx,8),%xmm5
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,-0x30(%rax,%rcx,8)
movupd %xmm3,-0x20(%rax,%rcx,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm5
movupd %xmm4,-0x10(%rax,%rcx,8)
movupd %xmm5,(%rax,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    17c0 <svd+0x680>
mov    0xc0(%rsp),%rax
and    $0xfffffffffffffffc,%rax
testb  $0x1,0x78(%rsp)
je     1840 <svd+0x700>
add    %r15,%rcx
movupd (%r14,%rcx,8),%xmm2
movupd 0x10(%r14,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm3,0x10(%r14,%rcx,8)
cmp    %rax,0xc0(%rsp)
jne    1864 <svd+0x724>
mov    %r12,%rdi
mov    0x98(%rsp),%r14
mov    0xd0(%rsp),%r12
mov    0x10(%rsp),%rcx
jmp    18c0 <svd+0x780>
mov    %r10,%r12
add    %r15,%rax
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
mov    %r12,%r10
mov    0xb0(%rsp),%rdi
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1890 <svd+0x750>
mov    0x98(%rsp),%r14
mov    0xd0(%rsp),%r12
nopl   0x0(%rax)
mulsd  %xmm13,%xmm1
movsd  %xmm1,(%r11,%r15,8)
xorpd  %xmm1,%xmm1
xorpd  %xmm3,%xmm3
cmp    %rdi,%r15
jae    1250 <svd+0x110>
cmp    %r9,%rcx
jae    1250 <svd+0x110>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
xchg   %ax,%ax
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rdx
jne    18f0 <svd+0x7b0>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm3
jne    191d <svd+0x7dd>
jnp    123e <svd+0xfe>
xorpd  %xmm4,%xmm4
cmp    %r9,0x10(%rsp)
jae    1966 <svd+0x826>
xorpd  %xmm4,%xmm4
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rax
cmp    %rax,%rdx
jne    1940 <svd+0x800>
mov    0x10(%rsp),%rcx
mov    (%r8,%rcx,8),%rax
movsd  (%rax,%r15,8),%xmm5
ucomisd %xmm11,%xmm4
jb     1988 <svd+0x848>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    1a2a <svd+0x8ea>
movapd %xmm4,%xmm0
movsd  %xmm10,0x50(%rsp)
mov    %r10,%rbx
mov    %rsi,0x48(%rsp)
movsd  %xmm3,0xa0(%rsp)
movsd  %xmm4,0xc0(%rsp)
movsd  %xmm5,0xd0(%rsp)
call   1060 <sqrt@plt>
movsd  0xd0(%rsp),%xmm5
movsd  0xc0(%rsp),%xmm4
movsd  0xa0(%rsp),%xmm3
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rsi
movapd 0x3612(%rip),%xmm12
mov    0xb0(%rsp),%rdi
mov    %rbx,%r10
xorpd  %xmm11,%xmm11
movsd  0x50(%rsp),%xmm10
movapd 0x3602(%rip),%xmm9
movapd 0x35e9(%rip),%xmm8
mov    0x30(%rsp),%rbx
mov    0x8(%rsp),%r9
mov    (%rsp),%r8
mov    0x38(%rsp),%r11
xorpd  %xmm1,%xmm1
cmpnlesd %xmm5,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm5,%xmm0
subsd  %xmm1,%xmm0
mov    (%r8,%rcx,8),%rax
movsd  %xmm0,(%rax,%r15,8)
cmp    %r9,%rcx
jae    1a8d <svd+0x94d>
mulsd  %xmm1,%xmm5
subsd  %xmm4,%xmm5
mov    $0x1,%eax
nopl   0x0(%rax)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1a70 <svd+0x930>
mov    %r10,%rax
mov    0x10(%rsp),%rcx
cmp    0x80(%rsp),%rcx
jl     1aee <svd+0x9ae>
cmp    %r9,%rcx
jae    1250 <svd+0x110>
mov    $0x1,%eax
nopl   (%rax)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1ab0 <svd+0x970>
jmp    123e <svd+0xfe>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
cmp    %rbx,%rax
mov    0x10(%rsp),%rcx
je     1a9f <svd+0x95f>
cmp    %r9,%rcx
jae    1ae0 <svd+0x9a0>
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,8),%rdx
movsd  (%rdx,%rax,8),%xmm2
mulsd  (%rdx,%r15,8),%xmm2
mov    0x20(%rsp),%rdx
addsd  %xmm2,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1b00 <svd+0x9c0>
cmp    %r9,0x10(%rsp)
jae    1ae0 <svd+0x9a0>
mov    $0x1,%ecx
xchg   %ax,%ax
mov    0x0(%r13,%rcx,8),%rdx
movsd  (%rsi,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
mov    0x20(%rsp),%rdx
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1b30 <svd+0x9f0>
jmp    1ae0 <svd+0x9a0>
mov    $0xffffffff,%eax
jmp    4f81 <svd+0x3e41>
test   %ebp,%ebp
mov    0x38(%rsp),%r11
jle    4f6b <svd+0x3e2b>
lea    -0x1(%rbp),%r9d
mov    0x130(%rsp),%rax
movslq %eax,%rdi
mov    %ebp,%r12d
mov    %eax,%r13d
lea    (%rcx,%r12,8),%rax
mov    %rax,0x128(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x150(%rsp)
lea    -0x2(%r12),%rax
mov    %rax,0x178(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x140(%rsp)
lea    0x18(%rcx),%rax
mov    %rax,0x78(%rsp)
lea    -0x3(%r12),%rbx
lea    0x38(%rcx),%r10
lea    -0x5(%r12),%rbp
xorpd  %xmm11,%xmm11
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    $0x3,%esi
mov    $0xffffffffffffffff,%rdx
movapd 0x340d(%rip),%xmm8
movapd 0x3414(%rip),%xmm9
movapd 0x33fb(%rip),%xmm12
xorpd  %xmm10,%xmm10
xorpd  %xmm1,%xmm1
xorpd  %xmm13,%xmm13
mov    $0x7,%eax
xor    %r15d,%r15d
mov    %r12,0xb0(%rsp)
mov    %r13,0x30(%rsp)
mov    (%rsp),%r14
mov    %r9,0xd0(%rsp)
mov    %rdi,0x60(%rsp)
jmp    1cc7 <svd+0xb87>
mov    0x58(%rsp),%rbx
mov    0xa0(%rsp),%rax
mov    0x38(%rsp),%r11
mov    0x70(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r11,%r15,8),%xmm0
mov    0x68(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm2
andpd  %xmm12,%xmm0
andpd  %xmm12,%xmm2
addsd  %xmm0,%xmm2
maxsd  %xmm2,%xmm10
addq   $0x1,0x10(%rsp)
add    $0x8,%r14
add    $0xffffffffffffffff,%r13
addq   $0xffffffffffffffff,0xb0(%rsp)
addq   $0x8,0x78(%rsp)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rbp
add    $0x1,%rax
add    $0x8,%r10
mov    0x20(%rsp),%r15
cmp    %r12,%r15
je     2ab4 <svd+0x1974>
mulsd  %xmm13,%xmm1
mov    %r9,%r8
mov    %r11,%r9
lea    0x1(%r15),%r11
mov    %r11,0x20(%rsp)
mov    %r9,%r11
mov    %r8,%r9
movsd  %xmm1,(%rcx,%r15,8)
xorpd  %xmm3,%xmm3
xorpd  %xmm1,%xmm1
cmp    %rdi,%r15
jge    1f4c <svd+0xe0c>
mov    %rax,0xa0(%rsp)
xorpd  %xmm3,%xmm3
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%r13
jne    1d10 <svd+0xbd0>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm3
jne    1d3c <svd+0xbfc>
jnp    1f44 <svd+0xe04>
xorpd  %xmm5,%xmm5
cmp    %rdi,%r15
jge    1d75 <svd+0xc35>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rax
cmp    %rax,%r13
jne    1d50 <svd+0xc10>
mov    %rdx,0x48(%rsp)
mov    (%rsp),%rax
mov    (%rax,%r15,8),%rax
movsd  (%rax,%r15,8),%xmm4
ucomisd %xmm11,%xmm5
jb     1d9b <svd+0xc5b>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    1e2e <svd+0xcee>
movapd %xmm5,%xmm0
movsd  %xmm10,0x8(%rsp)
mov    %r10,0x98(%rsp)
mov    %rsi,0x70(%rsp)
movsd  %xmm3,0x50(%rsp)
movsd  %xmm4,0xc0(%rsp)
movsd  %xmm5,0x100(%rsp)
call   1060 <sqrt@plt>
movsd  0x100(%rsp),%xmm5
movsd  0xc0(%rsp),%xmm4
movsd  0x50(%rsp),%xmm3
movapd 0x320f(%rip),%xmm12
mov    0x70(%rsp),%rsi
xorpd  %xmm11,%xmm11
mov    0x98(%rsp),%r10
mov    0x60(%rsp),%rdi
mov    0xd0(%rsp),%r9
movsd  0x8(%rsp),%xmm10
movapd 0x31f0(%rip),%xmm9
movapd 0x31d7(%rip),%xmm8
mov    0x38(%rsp),%r11
xorpd  %xmm1,%xmm1
cmpnlesd %xmm4,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
mov    (%rsp),%rax
mov    (%rax,%r15,8),%rax
movsd  %xmm0,(%rax,%r15,8)
cmp    %r9,%r15
jae    1f10 <svd+0xdd0>
mov    0x20(%rsp),%rax
cmp    0x80(%rsp),%rax
jge    1f10 <svd+0xdd0>
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mov    0x10(%rsp),%rax
jmp    1e99 <svd+0xd59>
nopl   (%rax)
add    $0x1,%rax
cmp    %r12,%rax
je     1f10 <svd+0xdd0>
cmp    %rdi,%r15
jge    1e90 <svd+0xd50>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r14,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1eb0 <svd+0xd70>
cmp    %rdi,%r15
jge    1e90 <svd+0xd50>
divsd  %xmm4,%xmm0
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1ee0 <svd+0xda0>
jmp    1e90 <svd+0xd50>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %rdi,%r15
jge    1f3f <svd+0xdff>
xor    %eax,%eax
mov    0x48(%rsp),%rdx
nopl   0x0(%rax)
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    1f20 <svd+0xde0>
jmp    1f44 <svd+0xe04>
mov    0x48(%rsp),%rdx
mov    0xa0(%rsp),%rax
mulsd  %xmm1,%xmm3
movsd  %xmm3,(%r11,%r15,8)
xorpd  %xmm13,%xmm13
xorpd  %xmm1,%xmm1
cmp    %r9,%r15
jae    1c60 <svd+0xb20>
mov    0x20(%rsp),%rcx
cmp    0x80(%rsp),%rcx
jge    1c60 <svd+0xb20>
mov    %rsi,0x70(%rsp)
mov    %rax,0xa0(%rsp)
mov    0x150(%rsp),%rcx
sub    %r15,%rcx
mov    %rbp,%rsi
shr    $0x2,%rsi
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
lea    -0x4(%rcx),%rax
add    $0x1,%rsi
mov    %rbx,0x58(%rsp)
shr    %rbx
mov    %rax,0x118(%rsp)
shr    $0x2,%rax
and    $0xfffffffffffffffe,%rsi
mov    %ebp,%ecx
and    $0x3,%ecx
mov    %rcx,0xe8(%rsp)
add    $0x1,%rbx
add    $0x1,%rax
mov    %rax,0x120(%rsp)
mov    %r15,%rax
not    %rax
lea    (%rax,%r12,1),%r8
add    $0xfffffffffffffffe,%r8
mov    %r8,0x170(%rsp)
shr    %r8
and    $0xfffffffffffffffe,%rbx
mov    0x178(%rsp),%rcx
sub    %r15,%rcx
mov    %rcx,0xc0(%rsp)
add    %r12,%rax
mov    %rax,0x100(%rsp)
add    $0x1,%r8
mov    0x68(%rsp),%rax
lea    (%rax,%r15,8),%rax
add    $0x8,%rax
mov    %rax,0xf8(%rsp)
lea    0x0(,%r15,8),%rax
mov    (%rsp),%rcx
add    (%rcx,%r15,8),%rax
xorpd  %xmm1,%xmm1
mov    $0x1,%ecx
mov    0xb0(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r11
jne    2060 <svd+0xf20>
xorpd  %xmm13,%xmm13
ucomisd %xmm13,%xmm1
jne    2089 <svd+0xf49>
jnp    1c3e <svd+0xafe>
mov    %rsi,0x158(%rsp)
mov    %rdx,0x48(%rsp)
mov    (%rsp),%rax
mov    (%rax,%r15,8),%r9
xorpd  %xmm4,%xmm4
mov    0x20(%rsp),%rax
cmp    0x80(%rsp),%rax
mov    0xb0(%rsp),%rax
jge    20ef <svd+0xfaf>
lea    (%r9,%r15,8),%rcx
xorpd  %xmm4,%xmm4
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rdx
cmp    %rdx,%rax
jne    20d0 <svd+0xf90>
mov    0x20(%rsp),%rax
movsd  (%r9,%rax,8),%xmm3
ucomisd %xmm11,%xmm4
mov    0x38(%rsp),%r11
mov    %r10,0x98(%rsp)
mov    %rbp,0x160(%rsp)
jb     2127 <svd+0xfe7>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
mov    0x78(%rsp),%rbp
jmp    21a9 <svd+0x1069>
movapd %xmm4,%xmm0
movsd  %xmm10,0x8(%rsp)
movapd %xmm1,0x190(%rsp)
mov    %r8,%rbp
movapd %xmm3,0x180(%rsp)
movsd  %xmm4,0x168(%rsp)
call   1060 <sqrt@plt>
movsd  0x168(%rsp),%xmm4
movapd 0x180(%rsp),%xmm3
mov    %rbp,%r8
movapd 0x190(%rsp),%xmm1
movapd 0x2e84(%rip),%xmm12
xorpd  %xmm11,%xmm11
mov    0x78(%rsp),%rbp
mov    0x60(%rsp),%rdi
movsd  0x8(%rsp),%xmm10
movapd 0x2e75(%rip),%xmm9
movapd 0x2e5c(%rip),%xmm8
mov    0x38(%rsp),%r11
xorpd  %xmm13,%xmm13
cmpnlesd %xmm3,%xmm13
movapd %xmm13,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm13
orpd   %xmm2,%xmm13
movapd %xmm3,%xmm0
subsd  %xmm13,%xmm0
mov    (%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0x20(%rsp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmp    0x80(%rsp),%rcx
jge    2337 <svd+0x11f7>
mulsd  %xmm13,%xmm3
subsd  %xmm4,%xmm3
mov    0x10(%rsp),%rcx
cmpq   $0x2,0x100(%rsp)
jb     22cd <svd+0x118d>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,0xf8(%rsp)
jae    2237 <svd+0x10f7>
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
cmp    %rdx,0x128(%rsp)
ja     22cd <svd+0x118d>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x2,0x170(%rsp)
jae    2253 <svd+0x1113>
xor    %edx,%edx
mov    0x68(%rsp),%rsi
jmp    2299 <svd+0x1159>
mov    0x70(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
xor    %edx,%edx
mov    0x68(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rcx,%rdx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rbp,%rdx,8)
movupd (%rcx,%rdx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,0x0(%rbp,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rbx
jne    2270 <svd+0x1130>
mov    0x100(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
test   $0x1,%r8b
je     22be <svd+0x117e>
add    0x10(%rsp),%rdx
movupd (%rax,%rdx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%rsi,%rdx,8)
cmp    %rcx,0x100(%rsp)
je     2337 <svd+0x11f7>
add    0x10(%rsp),%rcx
mov    %r12d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
test   $0x1,%sil
je     22f2 <svd+0x11b2>
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
mov    0x68(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,0x150(%rsp)
mov    0x68(%rsp),%rsi
je     2337 <svd+0x11f7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    2310 <svd+0x11d0>
mov    %rbp,0x78(%rsp)
cmp    %rdi,0x20(%rsp)
mov    0x10(%rsp),%r8
jge    2638 <svd+0x14f8>
mov    0x100(%rsp),%r9
and    $0xfffffffffffffffc,%r9
lea    (%r8,%r9,1),%rcx
mov    %rcx,0x8(%rsp)
mov    0x48(%rsp),%r10
neg    %r10
lea    (%rax,%r8,8),%rdi
mov    %r8,%rdx
jmp    238f <svd+0x124f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    0x30(%rsp),%rdx
je     2638 <svd+0x14f8>
mov    0x20(%rsp),%rcx
cmp    0x80(%rsp),%rcx
jge    2380 <svd+0x1240>
mov    (%rsp),%rcx
mov    (%rcx,%rdx,8),%rbp
testb  $0x3,0x50(%rsp)
je     24b2 <svd+0x1372>
lea    0x0(,%r8,8),%rcx
add    %rbp,%rcx
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    0xe8(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm2
mulsd  (%rdi,%rbx,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    23d0 <svd+0x1290>
add    %r10,%rbx
cmpq   $0x3,0xc0(%rsp)
jb     2448 <svd+0x1308>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rbx,8),%xmm2
movsd  0x8(%rbp,%rbx,8),%xmm3
mulsd  (%rax,%rbx,8),%xmm2
mulsd  0x8(%rax,%rbx,8),%xmm3
addsd  %xmm0,%xmm2
movsd  0x10(%rbp,%rbx,8),%xmm4
mulsd  0x10(%rax,%rbx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rbp,%rbx,8),%xmm0
mulsd  0x18(%rax,%rbx,8),%xmm0
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm0
add    $0x4,%rbx
cmp    %rbx,%r12
jne    2400 <svd+0x12c0>
mov    0x20(%rsp),%rcx
cmp    0x80(%rsp),%rcx
jge    2380 <svd+0x1240>
mov    (%rsp),%rcx
mov    (%rcx,%rdx,8),%rbx
mov    %r8,%rcx
cmpq   $0x4,0x100(%rsp)
jb     25c0 <svd+0x1480>
lea    (%rbx,%r8,8),%rcx
cmp    %rcx,0x128(%rsp)
jbe    2498 <svd+0x1358>
lea    (%rbx,%r12,8),%rsi
mov    %r8,%rcx
cmp    %rsi,0xf8(%rsp)
jb     25c0 <svd+0x1480>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x4,0x118(%rsp)
jae    24cd <svd+0x138d>
xor    %ebp,%ebp
jmp    2563 <svd+0x1423>
xorpd  %xmm0,%xmm0
mov    %r8,%rbx
cmpq   $0x3,0xc0(%rsp)
jae    2400 <svd+0x12c0>
jmp    2448 <svd+0x1308>
mov    0xa0(%rsp),%rcx
lea    (%rbx,%rcx,8),%rcx
mov    0x158(%rsp),%rsi
xor    %ebp,%ebp
mov    0x98(%rsp),%r8
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r8,%rbp,8),%xmm3
movupd -0x20(%r8,%rbp,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%rcx,%rbp,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%rcx,%rbp,8),%xmm3
movupd -0x10(%rcx,%rbp,8),%xmm6
movupd (%rcx,%rbp,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%rcx,%rbp,8)
movupd %xmm4,-0x20(%rcx,%rbp,8)
movupd -0x10(%r8,%rbp,8),%xmm3
movupd (%r8,%rbp,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%rcx,%rbp,8)
movupd %xmm4,(%rcx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    24f0 <svd+0x13b0>
testb  $0x1,0x120(%rsp)
01
mov    0x10(%rsp),%r8
je     25ab <svd+0x146b>
add    %r8,%rbp
mov    0x68(%rsp),%rcx
movupd (%rcx,%rbp,8),%xmm3
movupd 0x10(%rcx,%rbp,8),%xmm4
movupd (%rbx,%rbp,8),%xmm5
movupd 0x10(%rbx,%rbp,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rbx,%rbp,8)
movupd %xmm4,0x10(%rbx,%rbp,8)
mov    0x8(%rsp),%rcx
cmp    %r9,0x100(%rsp)
je     2380 <svd+0x1240>
xchg   %ax,%ax
mov    %r12d,%ebp
sub    %ecx,%ebp
mov    %rcx,%rsi
test   $0x1,%bpl
mov    0x68(%rsp),%rbp
je     25eb <svd+0x14ab>
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rbx,%rcx,8),%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
lea    0x1(%rcx),%rsi
not    %rcx
cmp    0x140(%rsp),%rcx
je     2380 <svd+0x1240>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rbx,%rsi,8),%xmm2
movsd  %xmm2,(%rbx,%rsi,8)
movsd  0x8(%rbp,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  0x8(%rbx,%rsi,8),%xmm2
movsd  %xmm2,0x8(%rbx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    2600 <svd+0x14c0>
jmp    2380 <svd+0x1240>
mov    0x20(%rsp),%rcx
cmp    0x80(%rsp),%rcx
jge    2698 <svd+0x1558>
mov    %r8,%rdx
cmpq   $0x4,0x100(%rsp)
mov    0xd0(%rsp),%r9
mov    0x58(%rsp),%rbx
mov    0x98(%rsp),%r10
mov    0x160(%rsp),%rbp
mov    0x70(%rsp),%rsi
jb     2780 <svd+0x1640>
mov    %rsi,%rdi
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x4,0x118(%rsp)
jae    26c4 <svd+0x1584>
xor    %ecx,%ecx
jmp    2728 <svd+0x15e8>
mov    0xd0(%rsp),%r9
mov    0x60(%rsp),%rdi
mov    0x58(%rsp),%rbx
mov    0x98(%rsp),%r10
mov    0x160(%rsp),%rbp
mov    0x70(%rsp),%rsi
jmp    279c <svd+0x165c>
mov    0xa0(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0x158(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rcx,8),%xmm2
movupd -0x20(%rdx,%rcx,8),%xmm3
movupd -0x10(%rdx,%rcx,8),%xmm4
movupd (%rdx,%rcx,8),%xmm5
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,-0x30(%rdx,%rcx,8)
movupd %xmm3,-0x20(%rdx,%rcx,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm5
movupd %xmm4,-0x10(%rdx,%rcx,8)
movupd %xmm5,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    26e0 <svd+0x15a0>
mov    0x100(%rsp),%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x120(%rsp)
01
je     2761 <svd+0x1621>
add    0x10(%rsp),%rcx
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rax,%rcx,8)
movupd %xmm3,0x10(%rax,%rcx,8)
cmp    %rdx,0x100(%rsp)
mov    %rdi,%rsi
je     2797 <svd+0x1657>
add    0x10(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    2780 <svd+0x1640>
mov    0x60(%rsp),%rdi
mov    0x48(%rsp),%rdx
mov    0xa0(%rsp),%rax
jmp    1c60 <svd+0xb20>
mov    0x130(%rsp),%rax
test   %eax,%eax
jle    4f6b <svd+0x3e2b>
lea    -0x1(%r9),%rcx
mov    %rcx,0x100(%rsp)
mov    %r9,%rcx
neg    %rcx
mov    %rcx,0x20(%rsp)
xor    %r14d,%r14d
xorpd  %xmm0,%xmm0
mov    %r9,%rdi
mov    %eax,%r11d
mov    0x8(%rsp),%r10
jmp    2817 <svd+0x16d7>
nopl   0x0(%rax)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rsi,%rdi,8)
movsd  (%r8,%rdi,8),%xmm1
add    $0x1,%r14b
mov    %edi,%r11d
cmpq   $0x1,0x10(%rsp)
jle    3084 <svd+0x1f44>
mov    %rdi,%rax
movzbl %r14b,%r14d
and    $0x3,%r14d
movslq %r11d,%rdx
mov    %r9,%r13
sub    %rdx,%r13
mov    %rdx,%r12
not    %r12
add    $0xffffffffffffffff,%rdi
mov    %rax,0x10(%rsp)
cmp    0xb0(%rsp),%rax
jg     29e0 <svd+0x18a0>
ucomisd %xmm0,%xmm1
jne    2854 <svd+0x1714>
jnp    29e0 <svd+0x18a0>
cmp    0x130(%rsp),%r11d
jge    29e0 <svd+0x18a0>
mov    (%rsp),%rcx
mov    (%rcx,%rdx,8),%rsi
movsd  (%rsi,%rdi,8),%xmm2
divsd  %xmm2,%xmm2
divsd  %xmm1,%xmm2
mov    0x40(%rsp),%rax
mov    (%rax,%rdx,8),%rbx
movsd  %xmm2,(%rbx,%rdi,8)
lea    0x1(%rdx),%rbx
cmp    %r9,%rbx
je     28b6 <svd+0x1776>
xchg   %ax,%ax
mov    (%rcx,%rbx,8),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm2
divsd  (%rsi,%rdi,8),%xmm2
divsd  %xmm1,%xmm2
mov    (%rax,%rbx,8),%rbp
movsd  %xmm2,0x0(%rbp,%rdi,8)
add    $0x1,%rbx
cmp    %rbx,%r9
jne    2890 <svd+0x1750>
cmp    0x130(%rsp),%r11d
jge    29e0 <svd+0x18a0>
lea    0x1(%rdx),%r15
mov    %rdx,%rbp
jmp    28dd <svd+0x179d>
nopl   (%rax)
add    $0x1,%rbp
cmp    %r9,%rbp
je     29e0 <svd+0x18a0>
xorpd  %xmm1,%xmm1
mov    %rdx,%rbx
test   $0x1,%r13b
je     290c <svd+0x17cc>
mov    (%rsp),%rax
mov    (%rax,%rdx,8),%rbx
movsd  (%rbx,%rdi,8),%xmm1
mov    0x40(%rsp),%rax
mov    (%rax,%rdx,8),%rbx
mulsd  (%rbx,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
mov    %r15,%rbx
cmp    %rdx,0x100(%rsp)
mov    0x40(%rsp),%r8
mov    (%rsp),%r9
je     2957 <svd+0x1817>
nop
mov    (%r9,%rbx,8),%rsi
mov    0x8(%r9,%rbx,8),%rcx
movsd  (%rsi,%rdi,8),%xmm2
mov    (%r8,%rbx,8),%rsi
mov    0x8(%r8,%rbx,8),%rax
mulsd  (%rsi,%rbp,8),%xmm2
addsd  %xmm1,%xmm2
movsd  (%rcx,%rdi,8),%xmm1
mulsd  (%rax,%rbp,8),%xmm1
addsd  %xmm2,%xmm1
add    $0x2,%rbx
cmp    %rbx,%r10
jne    2920 <svd+0x17e0>
mov    %rdx,%rbx
test   $0x1,%r13b
je     297f <svd+0x183f>
mov    0x40(%rsp),%rax
mov    (%rax,%rdx,8),%rax
movsd  (%rax,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rbp,8),%xmm2
movsd  %xmm2,(%rax,%rbp,8)
mov    %r15,%rbx
cmp    0x20(%rsp),%r12
mov    0x40(%rsp),%rcx
mov    0x8(%rsp),%r9
je     28d0 <svd+0x1790>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rcx,%rbx,8),%rax
movsd  (%rax,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rbp,8),%xmm2
movsd  %xmm2,(%rax,%rbp,8)
mov    0x8(%rcx,%rbx,8),%rax
movsd  (%rax,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rbp,8),%xmm2
movsd  %xmm2,(%rax,%rbp,8)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    29a0 <svd+0x1860>
jmp    28d0 <svd+0x1790>
nopl   (%rax)
mov    0x40(%rsp),%rax
mov    (%rax,%rdi,8),%rsi
mov    0x130(%rsp),%rbp
cmp    %ebp,%r11d
mov    0x68(%rsp),%r8
jge    27f0 <svd+0x16b0>
add    %r9,%r12
test   $0x3,%r13b
je     2a39 <svd+0x18f9>
mov    %r14,%rax
mov    0x40(%rsp),%rbx
movq   $0x0,(%rsi,%rdx,8)
mov    (%rbx,%rdx,8),%rcx
movq   $0x0,(%rcx,%rdi,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    2a10 <svd+0x18d0>
cmp    $0x3,%r12
jae    2a50 <svd+0x1910>
jmp    27f0 <svd+0x16b0>
mov    0x40(%rsp),%rbx
cmp    $0x3,%r12
jb     27f0 <svd+0x16b0>
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rsi,%rdx,8)
mov    (%rbx,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,0x8(%rsi,%rdx,8)
mov    0x8(%rbx,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,0x10(%rsi,%rdx,8)
mov    0x10(%rbx,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,0x18(%rsi,%rdx,8)
mov    0x18(%rbx,%rdx,8),%rax
movq   $0x0,(%rax,%rdi,8)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    2a50 <svd+0x1910>
jmp    27f0 <svd+0x16b0>
mov    0xf0(%rsp),%rax
test   %eax,%eax
jle    4f6b <svd+0x3e2b>
mov    0x80(%rsp),%r15
mov    %r15,%rdx
neg    %rdx
lea    -0x4(%r15),%rcx
mov    %rcx,0xe8(%rsp)
xor    %edi,%edi
xorpd  %xmm0,%xmm0
mov    %r15,%r10
mov    %rdx,0x8(%rsp)
jmp    2b29 <svd+0x19e9>
xchg   %ax,%ax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rax,%r10,8)
movsd  0x0(%rbp,%r10,8),%xmm13
lea    -0x1(%r14),%eax
add    $0x1,%dil
cmpq   $0x1,0xa0(%rsp)
mov    0xd0(%rsp),%r9
mov    0x8(%rsp),%rdx
jle    36fc <svd+0x25bc>
mov    %r10,%rcx
movzbl %dil,%edi
and    $0x3,%edi
movslq %eax,%r14
mov    %r15,%r11
sub    %r14,%r11
mov    %r14,%rax
not    %rax
add    %r15,%rax
mov    %rax,0x20(%rsp)
add    $0xffffffffffffffff,%r10
mov    %rcx,0xa0(%rsp)
cmp    %r9,%rcx
jg     2fb0 <svd+0x1e70>
ucomisd %xmm0,%xmm13
jne    2b6c <svd+0x1a2c>
jnp    2fb0 <svd+0x1e70>
cmp    0xf0(%rsp),%r14d
jge    2fb0 <svd+0x1e70>
mov    (%rsp),%rax
mov    (%rax,%r10,8),%rsi
lea    (%rsi,%r14,8),%rbp
mov    0x40(%rsp),%rax
mov    (%rax,%r10,8),%rbx
cmp    $0x2,%r11
jae    2b9d <svd+0x1a5d>
mov    %r14,%r8
jmp    2c20 <svd+0x1ae0>
lea    (%rbx,%r14,8),%rax
lea    (%rbx,%r15,8),%rcx
lea    0x8(%rsi),%rdx
lea    (%rsi,%r15,8),%r8
cmp    %rdx,%rbx
setb   %r9b
cmp    %rcx,%rbp
setb   %cl
cmp    %r8,%rax
setb   %dl
test   %cl,%r9b
jne    2c18 <svd+0x1ad8>
and    %cl,%dl
jne    2c18 <svd+0x1ad8>
mov    %r11,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rcx,%r14,1),%r8
movapd %xmm13,%xmm2
unpcklpd %xmm13,%xmm2
movsd  (%rsi,%r14,8),%xmm3
unpcklpd %xmm3,%xmm3
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdx,8),%xmm4
divpd  %xmm3,%xmm4
divpd  %xmm2,%xmm4
movupd %xmm4,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    2bf0 <svd+0x1ab0>
cmp    %rcx,%r11
mov    0x8(%rsp),%rdx
jne    2c20 <svd+0x1ae0>
jmp    2c93 <svd+0x1b53>
mov    %r14,%r8
mov    0x8(%rsp),%rdx
mov    0xf0(%rsp),%rcx
sub    %r8d,%ecx
mov    %r8,%rax
test   $0x1,%cl
je     2c4d <svd+0x1b0d>
movsd  (%rsi,%r8,8),%xmm2
divsd  0x0(%rbp),%xmm2
divsd  %xmm13,%xmm2
movsd  %xmm2,(%rbx,%r8,8)
lea    0x1(%r8),%rax
not    %r8
cmp    %rdx,%r8
je     2c93 <svd+0x1b53>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rax,8),%xmm2
divsd  0x0(%rbp),%xmm2
divsd  %xmm13,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm2
divsd  0x0(%rbp),%xmm2
divsd  %xmm13,%xmm2
movsd  %xmm2,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    2c60 <svd+0x1b20>
cmp    0xf0(%rsp),%r14d
jge    2fb0 <svd+0x1e70>
mov    0xe8(%rsp),%rax
sub    %r14,%rax
shr    $0x2,%rax
lea    -0x4(%r11),%rcx
add    $0x1,%rax
mov    %rcx,0x50(%rsp)
shr    $0x2,%rcx
and    $0xfffffffffffffffe,%rax
mov    %rax,0x78(%rsp)
add    $0x1,%rcx
mov    %rcx,0xc0(%rsp)
mov    (%rsp),%rax
mov    (%rax,%r10,8),%rbx
mov    0x40(%rsp),%rax
mov    (%rax,%r10,8),%r8
lea    (%r8,%r14,8),%r9
lea    (%r8,%r15,8),%rax
mov    %rax,0x10(%rsp)
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb0(%rsp)
add    %r14,%rax
mov    %rax,0x100(%rsp)
mov    %r14,%rsi
jmp    2d2d <svd+0x1bed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rsi
cmp    %r15,%rsi
je     2fb0 <svd+0x1e70>
mov    0x40(%rsp),%rax
mov    (%rax,%rsi,8),%rbp
xorpd  %xmm1,%xmm1
test   $0x3,%r11b
je     2e20 <svd+0x1ce0>
mov    %rdi,%rcx
mov    %r14,%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm2
mulsd  0x0(%rbp,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    2d50 <svd+0x1c10>
cmpq   $0x3,0x20(%rsp)
jb     2dc8 <svd+0x1c88>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm2
movsd  0x8(%rbx,%rax,8),%xmm3
mulsd  0x0(%rbp,%rax,8),%xmm2
mulsd  0x8(%rbp,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%rbx,%rax,8),%xmm4
mulsd  0x10(%rbp,%rax,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rbx,%rax,8),%xmm1
mulsd  0x18(%rbp,%rax,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rax
cmp    %rax,%r15
jne    2d80 <svd+0x1c40>
mov    0x40(%rsp),%rax
mov    (%rax,%rsi,8),%r13
mov    %r14,%rbp
cmp    $0x4,%r11
jb     2f30 <svd+0x1df0>
lea    0x0(,%r14,8),%rax
add    %r13,%rax
cmp    0x10(%rsp),%rax
jae    2e07 <svd+0x1cc7>
lea    0x0(,%r15,8),%rax
add    %r13,%rax
mov    %r14,%rbp
cmp    %rax,%r9
jb     2f30 <svd+0x1df0>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x4,0x50(%rsp)
jae    2e31 <svd+0x1cf1>
xor    %eax,%eax
jmp    2ec5 <svd+0x1d85>
xchg   %ax,%ax
mov    %r14,%rax
cmpq   $0x3,0x20(%rsp)
jae    2d80 <svd+0x1c40>
jmp    2dc8 <svd+0x1c88>
lea    0x30(,%r14,8),%rbp
add    %r13,%rbp
mov    0x78(%rsp),%r15
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r9,%rax,8),%xmm3
movupd 0x10(%r9,%rax,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%rbp,%rax,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%rbp,%rax,8),%xmm3
movupd -0x10(%rbp,%rax,8),%xmm6
movupd 0x0(%rbp,%rax,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%rbp,%rax,8)
movupd %xmm4,-0x20(%rbp,%rax,8)
movupd 0x20(%r9,%rax,8),%xmm3
movupd 0x30(%r9,%rax,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%rbp,%rax,8)
movupd %xmm4,0x0(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r15
jne    2e50 <svd+0x1d10>
testb  $0x1,0xc0(%rsp)
01
mov    0x80(%rsp),%r15
je     2f13 <svd+0x1dd3>
add    %r14,%rax
movupd (%r8,%rax,8),%xmm3
movupd 0x10(%r8,%rax,8),%xmm4
movupd 0x0(%r13,%rax,8),%xmm5
movupd 0x10(%r13,%rax,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x0(%r13,%rax,8)
movupd %xmm4,0x10(%r13,%rax,8)
mov    0x100(%rsp),%rbp
cmp    0xb0(%rsp),%r11
je     2d20 <svd+0x1be0>
nopl   0x0(%rax)
mov    0xf0(%rsp),%rcx
sub    %ebp,%ecx
mov    %rbp,%rax
test   $0x1,%cl
je     2f5e <svd+0x1e1e>
movsd  (%r8,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rbp,8),%xmm2
movsd  %xmm2,0x0(%r13,%rbp,8)
lea    0x1(%rbp),%rax
not    %rbp
cmp    %rdx,%rbp
je     2d20 <svd+0x1be0>
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
movsd  0x8(%r8,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%r13,%rax,8),%xmm2
movsd  %xmm2,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    2f70 <svd+0x1e30>
jmp    2d20 <svd+0x1be0>
nop
mov    0x40(%rsp),%rax
mov    (%rax,%r10,8),%rax
cmp    0xf0(%rsp),%r14d
mov    0x68(%rsp),%rbp
jge    2af0 <svd+0x19b0>
test   $0x3,%r11b
je     300b <svd+0x1ecb>
mov    %rdi,%rsi
mov    %r14,%rcx
mov    0x40(%rsp),%rbx
nopl   (%rax)
mov    (%rbx,%rcx,8),%rdx
movq   $0x0,(%rdx,%r10,8)
movq   $0x0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2fe0 <svd+0x1ea0>
cmpq   $0x3,0x20(%rsp)
jae    3020 <svd+0x1ee0>
jmp    2af0 <svd+0x19b0>
mov    %r14,%rcx
mov    0x40(%rsp),%rbx
cmpq   $0x3,0x20(%rsp)
jb     2af0 <svd+0x19b0>
nop
mov    (%rbx,%rcx,8),%rdx
movq   $0x0,(%rdx,%r10,8)
movq   $0x0,(%rax,%rcx,8)
mov    0x8(%rbx,%rcx,8),%rdx
movq   $0x0,(%rdx,%r10,8)
movq   $0x0,0x8(%rax,%rcx,8)
mov    0x10(%rbx,%rcx,8),%rdx
movq   $0x0,(%rdx,%r10,8)
movq   $0x0,0x10(%rax,%rcx,8)
mov    0x18(%rbx,%rcx,8),%rdx
movq   $0x0,(%rdx,%r10,8)
movq   $0x0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    3020 <svd+0x1ee0>
jmp    2af0 <svd+0x19b0>
test   %ebp,%ebp
mov    0x38(%rsp),%r11
mov    0x80(%rsp),%rcx
jle    4f6b <svd+0x3e2b>
mov    0x20(%rsp),%rax
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,0xd0(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0xe8(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x78(%rsp)
mov    (%rsp),%rax
lea    (%rax,%r9,8),%r15
lea    0x5(%r9),%rax
mov    %rax,0xc0(%rsp)
mov    %rcx,%rax
sub    %r9,%rax
add    $0xfffffffffffffffd,%rax
mov    %rax,0x48(%rsp)
lea    0x1(%r9),%rax
mov    %rax,0x70(%rsp)
mov    %r9,%r12
not    %r12
add    %rcx,%r12
xor    %ebp,%ebp
xorpd  %xmm11,%xmm11
mov    0xb0(%rsp),%r14
mov    %r14,%r13
mov    %r9,0x20(%rsp)
movsd  %xmm10,0x50(%rsp)
jmp    3170 <svd+0x2030>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rax
mov    (%rax,%r13,8),%rax
movsd  (%rax,%r13,8),%xmm0
addsd  0x1eea(%rip),%xmm0
movsd  %xmm0,(%rax,%r13,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%r13
addq   $0x1,0x78(%rsp)
add    $0xfffffffffffffff8,%r15
addq   $0xffffffffffffffff,0xc0(%rsp)
addq   $0x1,0x48(%rsp)
addq   $0xffffffffffffffff,0x70(%rsp)
add    $0x1,%r12
cmp    %r9,%rbp
je     396a <svd+0x282a>
mov    0x20(%rsp),%rcx
mov    0xd0(%rsp),%rax
lea    (%rax,%rbp,1),%rdx
mov    %rcx,0xa0(%rsp)
lea    -0x1(%rcx),%rax
mov    %rax,0x20(%rsp)
movsd  (%r11,%r13,8),%xmm0
cmp    %r14,%r13
mov    %rdx,0x10(%rsp)
je     3560 <svd+0x2420>
lea    0x1(%r13),%r10
cmp    %r9,%r10
jge    3560 <svd+0x2420>
lea    -0x1(%rbp),%esi
mov    0xa0(%rsp),%rcx
test   $0x3,%bpl
je     31e9 <svd+0x20a9>
mov    %ebp,%edi
and    $0x3,%edi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rcx,8),%rbx
movq   $0x0,(%rbx,%r13,8)
add    $0x1,%rcx
cmp    %ecx,%edi
jne    31d0 <svd+0x2090>
sub    0x78(%rsp),%rcx
cmp    $0x3,%esi
mov    (%rsp),%rax
jb     323c <svd+0x20fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rax,%rcx,8),%rsi
movq   $0x0,(%rsi,%r13,8)
mov    0x8(%rax,%rcx,8),%rsi
movq   $0x0,(%rsi,%r13,8)
mov    0x10(%rax,%rcx,8),%rsi
movq   $0x0,(%rsi,%r13,8)
mov    0x18(%rax,%rcx,8),%rsi
movq   $0x0,(%rsi,%r13,8)
add    $0x4,%rcx
cmp    %ecx,%r9d
jne    3200 <svd+0x20c0>
ucomisd %xmm11,%xmm0
jne    3249 <svd+0x2109>
jnp    35e0 <svd+0x24a0>
cmp    %r9,%r10
jge    3569 <svd+0x2429>
mov    0x48(%rsp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    0xd0(%rsp),%rax
add    %rbp,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0xf8(%rsp)
shr    $0x2,%rax
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x150(%rsp)
add    $0x1,%rax
mov    %rax,0x120(%rsp)
mov    %rbp,%rcx
not    %rcx
add    %r9,%rcx
mov    (%rsp),%rax
mov    (%rax,%r13,8),%rsi
mov    %rcx,0x98(%rsp)
lea    (%rsi,%rcx,8),%rax
mov    %rax,0x60(%rsp)
mov    0x80(%rsp),%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x140(%rsp)
mov    0x10(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    0x20(%rsp),%rax
mov    %rcx,0x118(%rsp)
add    %rcx,%rax
mov    %rax,0x128(%rsp)
mov    0xc0(%rsp),%rax
lea    (%rsi,%rax,8),%r8
mov    0xa0(%rsp),%rcx
jmp    3311 <svd+0x21d1>
nop
add    $0x1,%rcx
cmp    0x130(%rsp),%ecx
je     3569 <svd+0x2429>
xorpd  %xmm1,%xmm1
mov    0x80(%rsp),%rdx
cmp    %rdx,%r10
jge    3357 <svd+0x2217>
mov    (%rsp),%rax
mov    (%rax,%rcx,8),%rdi
xorpd  %xmm1,%xmm1
mov    0xa0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm2
mulsd  (%rdi,%rbx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
cmp    %rdx,%rbx
jl     3340 <svd+0x2200>
cmp    %rdx,%r13
jge    3300 <svd+0x21c0>
divsd  (%rsi,%r13,8),%xmm1
divsd  %xmm0,%xmm1
mov    (%rsp),%rax
mov    (%rax,%rcx,8),%r14
mov    0x20(%rsp),%rbx
cmpq   $0x4,0x10(%rsp)
jb     34d0 <svd+0x2390>
mov    0x98(%rsp),%rax
lea    (%r14,%rax,8),%rdi
cmp    0x140(%rsp),%rdi
jae    33a9 <svd+0x2269>
lea    (%r14,%rdx,8),%rdi
mov    0x20(%rsp),%rbx
cmp    %rdi,0x60(%rsp)
jb     34d0 <svd+0x2390>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x4,0xf8(%rsp)
jae    33c3 <svd+0x2283>
xor    %edi,%edi
jmp    345b <svd+0x231b>
mov    0xc0(%rsp),%rax
lea    (%r14,%rax,8),%r9
mov    0x150(%rsp),%r11
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x30(%r8,%rdi,8),%xmm3
movupd -0x20(%r8,%rdi,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%r9,%rdi,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%r9,%rdi,8),%xmm3
movupd -0x10(%r9,%rdi,8),%xmm6
movupd (%r9,%rdi,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%r9,%rdi,8)
movupd %xmm4,-0x20(%r9,%rdi,8)
movupd -0x10(%r8,%rdi,8),%xmm3
movupd (%r8,%rdi,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%r9,%rdi,8)
movupd %xmm4,(%r9,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%r11
jne    33e0 <svd+0x22a0>
testb  $0x1,0x120(%rsp)
01
mov    0x38(%rsp),%r11
mov    0x8(%rsp),%r9
je     34a9 <svd+0x2369>
add    0x20(%rsp),%rdi
movupd (%rsi,%rdi,8),%xmm3
movupd 0x10(%rsi,%rdi,8),%xmm4
movupd (%r14,%rdi,8),%xmm5
movupd 0x10(%r14,%rdi,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%r14,%rdi,8)
movupd %xmm4,0x10(%r14,%rdi,8)
mov    0x128(%rsp),%rbx
mov    0x118(%rsp),%rax
cmp    %rax,0x10(%rsp)
je     3300 <svd+0x21c0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xf0(%rsp),%rax
sub    %ebx,%eax
mov    %rbx,%rdi
test   $0x1,%al
je     34fa <svd+0x23ba>
movsd  (%rsi,%rbx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r14,%rbx,8),%xmm2
movsd  %xmm2,(%r14,%rbx,8)
lea    0x1(%rbx),%rdi
not    %rbx
cmp    0xe8(%rsp),%rbx
mov    0x80(%rsp),%rax
je     3300 <svd+0x21c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r14,%rdi,8),%xmm2
movsd  %xmm2,(%r14,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%r14,%rdi,8),%xmm2
movsd  %xmm2,0x8(%r14,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    3520 <svd+0x23e0>
jmp    3300 <svd+0x21c0>
nopl   0x0(%rax,%rax,1)
ucomisd %xmm11,%xmm0
jne    3569 <svd+0x2429>
jnp    35e0 <svd+0x24a0>
cmp    0x80(%rsp),%r13
mov    0x30(%rsp),%rdi
mov    0xb0(%rsp),%r14
jge    3120 <svd+0x1fe0>
mov    (%rsp),%rax
mov    (%rax,%r13,8),%rcx
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%r8
cmp    $0x2,%r8
jb     36d5 <svd+0x2595>
mov    0xd0(%rsp),%rax
add    %rbp,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x2,%rax
jae    3658 <svd+0x2518>
xor    %eax,%eax
jmp    36a8 <svd+0x2568>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    0x80(%rsp),%r13
mov    0x30(%rsp),%rdi
mov    0xb0(%rsp),%r14
jge    3120 <svd+0x1fe0>
mov    0x58(%rsp),%rax
add    %ebp,%eax
lea    0x8(,%rax,8),%rdx
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rdi
mov    (%rsp),%rax
add    (%rax,%r13,8),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
xorpd  %xmm11,%xmm11
movsd  0x50(%rsp),%xmm10
movapd 0x19d5(%rip),%xmm9
movapd 0x19bc(%rip),%xmm8
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%r11
jmp    3120 <svd+0x1fe0>
mov    %r12,%rsi
shr    %rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x70(%rsp),%rax
lea    (%rcx,%rax,8),%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rbx,%rax,8),%xmm2
movupd (%rbx,%rax,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%rbx,%rax,8)
divpd  %xmm1,%xmm3
movupd %xmm3,(%rbx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rsi
jne    3680 <svd+0x2540>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
test   $0x1,%dl
je     36c7 <svd+0x2587>
add    0x20(%rsp),%rax
movupd (%rcx,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rax,8)
cmp    %rsi,%r8
je     3120 <svd+0x1fe0>
add    0x20(%rsp),%rsi
mov    0x80(%rsp),%rax
nopl   (%rax)
movsd  (%rcx,%rsi,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    36e0 <svd+0x25a0>
jmp    3120 <svd+0x1fe0>
cmpl   $0x0,0xf0(%rsp)
mov    (%rsp),%r9
mov    0x30(%rsp),%rdi
jle    4f6b <svd+0x3e2b>
mov    %r15,%rax
lea    -0x8(%r9),%r15
mov    0x60(%rsp),%rbp
lea    0x1(%rbp),%rbx
xor    %r10d,%r10d
xorpd  %xmm2,%xmm2
mov    0xd0(%rsp),%r14
mov    %rax,%r11
mov    0x38(%rsp),%r8
movsd  %xmm10,0x8(%rsp)
jmp    3785 <svd+0x2645>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r9,%r14,8),%rax
movsd  (%rax,%r14,8),%xmm0
addsd  0x18be(%rip),%xmm0
movsd  %xmm0,(%rax,%r14,8)
add    $0x1,%r10
add    $0xffffffffffffffff,%r11
add    $0xffffffffffffffff,%r14
add    $0xfffffffffffffff8,%r15
add    $0x1,%rbx
cmp    %r12,%r10
je     44f3 <svd+0x33b3>
movsd  (%r8,%r14,8),%xmm3
cmp    0xd0(%rsp),%r14
je     38e0 <svd+0x27a0>
lea    0x1(%r14),%r13
mov    0x80(%rsp),%rax
cmp    %rax,%r13
jge    38e0 <svd+0x27a0>
mov    %rax,%rdi
sub    %r10,%rdi
movabs $0x7fffffff8,%rax
lea    (%rax,%r10,8),%rdx
and    %rax,%rdx
add    $0x8,%rdx
shl    $0x3,%rdi
add    (%r9,%r14,8),%rdi
xor    %esi,%esi
mov    %r10,%rbp
mov    %r11,0x20(%rsp)
movsd  %xmm3,0x10(%rsp)
call   1040 <memset@plt>
movsd  0x10(%rsp),%xmm3
mov    0x20(%rsp),%r11
xorpd  %xmm2,%xmm2
mov    %rbp,%r10
mov    0x60(%rsp),%rbp
movsd  0x8(%rsp),%xmm10
movapd 0x1803(%rip),%xmm9
movapd 0x17ea(%rip),%xmm8
mov    0x30(%rsp),%rdi
mov    (%rsp),%r9
mov    0x38(%rsp),%r8
ucomisd %xmm2,%xmm3
jne    3830 <svd+0x26f0>
jnp    3930 <svd+0x27f0>
mov    (%r9,%r14,8),%rax
mov    %r11,%rcx
jmp    3851 <svd+0x2711>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    0xf0(%rsp),%ecx
je     38e8 <svd+0x27a8>
xorpd  %xmm0,%xmm0
cmp    %rbp,%r13
jge    388c <svd+0x274c>
xorpd  %xmm0,%xmm0
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r9,%rdx,8),%rsi
movsd  (%rsi,%r14,8),%xmm1
mulsd  (%rsi,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rbp,%rdx
jl     3870 <svd+0x2730>
cmp    %rbp,%r14
jge    3840 <svd+0x2700>
divsd  (%rax,%r14,8),%xmm0
divsd  %xmm3,%xmm0
mov    0x80(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rdx,8),%rsi
movsd  (%rsi,%r14,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    38b0 <svd+0x2770>
jmp    3840 <svd+0x2700>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm2,%xmm3
jne    38e8 <svd+0x27a8>
jnp    3930 <svd+0x27f0>
cmp    %rbp,%r14
jge    3750 <svd+0x2610>
mov    0x80(%rsp),%rax
nopl   0x0(%rax)
mov    (%r15,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r14,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    3900 <svd+0x27c0>
jmp    3750 <svd+0x2610>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x80(%rsp),%rax
cmp    %rbp,%r14
jge    3750 <svd+0x2610>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rcx
movq   $0x0,(%rcx,%r14,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    3950 <svd+0x2810>
jmp    3750 <svd+0x2610>
cmpl   $0x0,0x130(%rsp)
jle    4f6b <svd+0x3e2b>
lea    -0x1(%r9),%rax
mov    %rax,0xf8(%rsp)
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    %rax,0x78(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x140(%rsp)
mov    %r9d,%r13d
and    $0xfffffffe,%r13d
mov    %r9d,%esi
and    $0x3,%esi
mov    %r9d,%ebp
and    $0xfffffffc,%ebp
mov    %r9,%rax
shl    $0x20,%rax
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xorpd  %xmm11,%xmm11
mov    %rsi,0x120(%rsp)
mov    %rbp,0x118(%rsp)
mov    0xf0(%rsp),%r12
jmp    3a20 <svd+0x28e0>
nopl   (%rax)
mov    %r8d,%eax
mov    %rax,0x58(%rsp)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x60(%rsp)
test   %r8,%r8
jle    4f72 <svd+0x3e32>
mov    0xf8(%rsp),%r8
lea    -0x1(%r8),%rax
mov    %rax,0xf8(%rsp)
movl   $0x0,0x70(%rsp)
mov    %r8,0xc0(%rsp)
jmp    3a76 <svd+0x2936>
cs nopw 0x0(%rax,%rax,1)
unpcklpd %xmm13,%xmm3
addl   $0x1,0x70(%rsp)
mov    0x98(%rsp),%rax
movq   $0x0,(%r14,%rax,8)
movlpd %xmm3,(%r14,%r8,8)
movhpd %xmm3,(%r11,%r8,8)
mov    0x60(%rsp),%rbp
mov    %r8,%rbx
xchg   %ax,%ax
mov    %rbp,%r14
mov    %ebx,%r15d
test   %rbx,%rbx
js     3af0 <svd+0x29b0>
mov    0x68(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm10,%xmm0
ucomisd %xmm10,%xmm0
jne    3aa9 <svd+0x2969>
jnp    3af0 <svd+0x29b0>
movsd  -0x8(%r11,%rbx,8),%xmm0
add    $0xffffffffffffffff,%rbx
andpd  %xmm8,%xmm0
addsd  %xmm10,%xmm0
movabs $0xffffffff00000000,%rax
ff ff ff
lea    (%r14,%rax,1),%rbp
ucomisd %xmm10,%xmm0
jne    3a80 <svd+0x2940>
jp     3a80 <svd+0x2940>
sar    $0x20,%rbp
cmp    %r8,%rbp
jle    4171 <svd+0x3031>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r11,%r8,8),%xmm4
cmp    %r8,%r15
je     4410 <svd+0x32d0>
cmpl   $0x1e,0x70(%rsp)
je     3a00 <svd+0x28c0>
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,%r14
mov    %r14,%r15
sar    $0x20,%r15
sar    $0x1d,%r14
movsd  (%r11,%r14,1),%xmm13
mov    0xf8(%rsp),%rax
movsd  (%r11,%rax,8),%xmm3
mov    0x68(%rsp),%r14
movsd  (%r14,%rax,8),%xmm6
movsd  (%r14,%r8,8),%xmm5
movapd %xmm3,%xmm0
subsd  %xmm4,%xmm0
movapd %xmm4,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm6,%xmm0
subsd  %xmm5,%xmm0
addsd  %xmm5,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm0,%xmm6
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
addsd  0x1491(%rip),%xmm0
ucomisd %xmm11,%xmm0
jb     3ba0 <svd+0x2a60>
sqrtsd %xmm0,%xmm0
jmp    3c2a <svd+0x2aea>
nop
movapd %xmm13,0x20(%rsp)
movapd %xmm3,0xb0(%rsp)
movapd %xmm4,0x10(%rsp)
movsd  %xmm5,0xa0(%rsp)
movsd  %xmm6,0xd0(%rsp)
call   1060 <sqrt@plt>
movsd  0xd0(%rsp),%xmm6
movsd  0xa0(%rsp),%xmm5
movapd 0x10(%rsp),%xmm4
movapd 0xb0(%rsp),%xmm3
movapd 0x20(%rsp),%xmm13
mov    0xc0(%rsp),%r8
xorpd  %xmm11,%xmm11
movsd  0x50(%rsp),%xmm10
movapd 0x13fe(%rip),%xmm9
movapd 0x13e5(%rip),%xmm8
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%r11
mov    0x40(%rsp),%rbp
movapd %xmm13,%xmm1
subsd  %xmm4,%xmm1
addsd  %xmm13,%xmm4
mulsd  %xmm1,%xmm4
xorpd  %xmm1,%xmm1
cmplesd %xmm6,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
addsd  %xmm6,%xmm1
divsd  %xmm1,%xmm3
subsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
divsd  %xmm13,%xmm3
cmp    %r8,%r15
mov    %r15,0x98(%rsp)
jge    3a50 <svd+0x2910>
movsd  0x138f(%rip),%xmm0
movapd %xmm0,%xmm6
movapd %xmm0,%xmm14
jmp    3cfc <svd+0x2bbc>
nopl   0x0(%rax)
mulsd  %xmm15,%xmm14
mulsd  %xmm7,%xmm13
subsd  %xmm13,%xmm14
mulsd  %xmm15,%xmm12
movapd %xmm6,%xmm1
xorpd  %xmm9,%xmm1
unpcklpd %xmm12,%xmm12
mulpd  %xmm6,%xmm12
movapd %xmm6,%xmm2
shufpd $0x1,%xmm1,%xmm2
unpcklpd %xmm14,%xmm14
mulpd  %xmm2,%xmm14
movapd %xmm14,%xmm3
addpd  %xmm12,%xmm3
movapd %xmm3,%xmm13
unpckhpd %xmm3,%xmm13
movapd %xmm0,%xmm14
cmp    %r8,%r15
jge    3a55 <svd+0x2915>
mov    %r15,%rbx
movsd  0x8(%r14,%r15,8),%xmm5
movsd  0x8(%r11,%r15,8),%xmm12
mulsd  %xmm5,%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
movapd %xmm13,0x20(%rsp)
movapd %xmm12,0x10(%rsp)
jb     3d40 <svd+0x2c00>
sqrtsd %xmm0,%xmm0
jmp    3db0 <svd+0x2c70>
movapd %xmm14,0xa0(%rsp)
movapd %xmm6,0xd0(%rsp)
movapd %xmm3,0xb0(%rsp)
movsd  %xmm5,0x80(%rsp)
call   1060 <sqrt@plt>
movsd  0x80(%rsp),%xmm5
movapd 0xb0(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm6
movapd 0x10(%rsp),%xmm12
movapd 0xa0(%rsp),%xmm14
movapd 0x20(%rsp),%xmm13
xorpd  %xmm11,%xmm11
movapd 0x1265(%rip),%xmm9
mov    0x8(%rsp),%r9
movapd 0x1258(%rip),%xmm4
lea    0x1(%rbx),%r15
movsd  %xmm0,(%r14,%rbx,8)
unpcklpd %xmm3,%xmm6
unpcklpd %xmm0,%xmm0
movapd %xmm6,%xmm7
divpd  %xmm0,%xmm7
movapd %xmm7,%xmm0
shufpd $0x1,%xmm7,%xmm0
cmpq   $0x0,0x100(%rsp)
je     3ff0 <svd+0x2eb0>
xor    %eax,%eax
nopl   0x0(%rax)
mov    0x0(%rbp,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
movsd  (%rcx,%r15,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%rbx,8)
mov    0x8(%rbp,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
movsd  (%rcx,%r15,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%rbx,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    3df0 <svd+0x2cb0>
test   $0x1,%r9b
je     3e93 <svd+0x2d53>
mov    0x0(%rbp,%rax,8),%rax
movsd  (%rax,%rbx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm9,%xmm2
movsd  (%rax,%r15,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rax,%rbx,8)
mulsd  %xmm5,%xmm14
movapd %xmm14,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm7,%xmm15
unpckhpd %xmm7,%xmm15
movapd %xmm13,%xmm3
mulsd  %xmm15,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm12,%xmm2
mulsd  %xmm7,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
jb     3ef0 <svd+0x2db0>
sqrtsd %xmm0,%xmm0
jmp    3f74 <svd+0x2e34>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm14,0xa0(%rsp)
movapd %xmm7,0xb0(%rsp)
movapd %xmm15,0xd0(%rsp)
movapd %xmm2,0x80(%rsp)
movapd %xmm3,0x130(%rsp)
call   1060 <sqrt@plt>
movapd 0x130(%rsp),%xmm3
movapd 0x80(%rsp),%xmm2
movapd 0xd0(%rsp),%xmm15
movapd 0xb0(%rsp),%xmm7
movapd 0x10(%rsp),%xmm12
movapd 0xa0(%rsp),%xmm14
movapd 0x20(%rsp),%xmm13
xorpd  %xmm11,%xmm11
movapd 0x10a1(%rip),%xmm9
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%rdi
movapd 0x1079(%rip),%xmm8
movsd  0x50(%rsp),%xmm10
mov    0xc0(%rsp),%r8
movsd  %xmm0,(%r11,%rbx,8)
ucomisd %xmm11,%xmm0
movapd %xmm7,%xmm6
jne    3fa9 <svd+0x2e69>
jnp    3fb9 <svd+0x2e79>
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm2
movapd %xmm2,%xmm6
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
test   %r12d,%r12d
jle    3ca0 <svd+0x2b60>
mov    (%rsp),%rcx
mov    (%rcx,%rbx,8),%rax
mov    (%rcx,%r15,8),%rcx
cmp    $0x1,%r12d
jne    4010 <svd+0x2ed0>
xor    %edx,%edx
jmp    4120 <svd+0x2fe0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
test   $0x1,%r9b
jne    3e61 <svd+0x2d21>
jmp    3e93 <svd+0x2d53>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rdi,8),%rdx
cmp    %rdx,%rax
jae    4029 <svd+0x2ee9>
lea    (%rax,%rdi,8),%rdx
cmp    %rdx,%rcx
jae    4029 <svd+0x2ee9>
xor    %edx,%edx
jmp    4120 <svd+0x2fe0>
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
cmpq   $0x0,0xe8(%rsp)
je     4162 <svd+0x3022>
mov    0x140(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm2
movupd (%rcx,%rdx,8),%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rax,%rdx,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,(%rcx,%rdx,8)
movupd 0x10(%rax,%rdx,8),%xmm2
movupd 0x10(%rcx,%rdx,8),%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,0x10(%rax,%rdx,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,0x10(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    4050 <svd+0x2f10>
testb  $0x1,0x48(%rsp)
je     4105 <svd+0x2fc5>
movupd (%rax,%rdx,8),%xmm2
movupd (%rcx,%rdx,8),%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rax,%rdx,8)
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
movupd %xmm4,(%rcx,%rdx,8)
mov    0x78(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rdi,%rsi
je     3ca0 <svd+0x2b60>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
movsd  (%rcx,%rdx,8),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rax,%rdx,8)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    4120 <svd+0x2fe0>
jmp    3ca0 <svd+0x2b60>
xor    %edx,%edx
testb  $0x1,0x48(%rsp)
jne    40cd <svd+0x2f8d>
jmp    4105 <svd+0x2fc5>
movsd  0xea7(%rip),%xmm1
jmp    4190 <svd+0x3050>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rbp),%rax
cmp    %r8,%rbp
mov    %rax,%rbp
jge    3af0 <svd+0x29b0>
mov    0x68(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
unpckhpd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbp,8)
movapd %xmm2,%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm10,%xmm0
ucomisd %xmm10,%xmm0
jne    41ca <svd+0x308a>
jnp    3af0 <svd+0x29b0>
movsd  (%r11,%rbp,8),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
jb     4200 <svd+0x30c0>
sqrtsd %xmm0,%xmm0
jmp    4252 <svd+0x3112>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm2,0x20(%rsp)
movapd %xmm3,0x10(%rsp)
call   1060 <sqrt@plt>
movapd 0x10(%rsp),%xmm3
movapd 0x20(%rsp),%xmm2
mov    0xc0(%rsp),%r8
xorpd  %xmm11,%xmm11
movsd  0x50(%rsp),%xmm10
movapd 0xdd6(%rip),%xmm9
movapd 0xdbd(%rip),%xmm8
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%r11
movsd  %xmm0,(%r11,%rbp,8)
xorpd  %xmm9,%xmm2
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
movapd %xmm2,%xmm1
divpd  %xmm0,%xmm1
test   %r12d,%r12d
jle    4180 <svd+0x3040>
mov    (%rsp),%rcx
mov    (%rcx,%rbx,8),%rax
mov    (%rcx,%rbp,8),%rcx
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
cmp    $0x1,%r12d
jne    42a0 <svd+0x3160>
xor    %edx,%edx
jmp    43b0 <svd+0x3270>
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rdi,8),%rdx
cmp    %rdx,%rax
jae    42b9 <svd+0x3179>
lea    (%rax,%rdi,8),%rdx
cmp    %rdx,%rcx
jae    42b9 <svd+0x3179>
xor    %edx,%edx
jmp    43b0 <svd+0x3270>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x0,0xe8(%rsp)
je     43f2 <svd+0x32b2>
mov    0x140(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm3
movupd (%rcx,%rdx,8),%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm4,%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rax,%rdx,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm4
movupd %xmm4,(%rcx,%rdx,8)
movupd 0x10(%rax,%rdx,8),%xmm3
movupd 0x10(%rcx,%rdx,8),%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm4,%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,0x10(%rax,%rdx,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm4
movupd %xmm4,0x10(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    42e0 <svd+0x31a0>
testb  $0x1,0x48(%rsp)
je     4391 <svd+0x3251>
movupd (%rax,%rdx,8),%xmm3
movupd (%rcx,%rdx,8),%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm4,%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rax,%rdx,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm4
movupd %xmm4,(%rcx,%rdx,8)
mov    0x78(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rdi,%rsi
je     4180 <svd+0x3040>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm2
movsd  (%rcx,%rdx,8),%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rax,%rdx,8)
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    43b0 <svd+0x3270>
jmp    4180 <svd+0x3040>
xor    %edx,%edx
testb  $0x1,0x48(%rsp)
jne    435d <svd+0x321d>
jmp    4391 <svd+0x3251>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm4,%xmm11
jbe    3a08 <svd+0x28c8>
xorpd  %xmm9,%xmm4
movlpd %xmm4,(%r11,%r8,8)
cmpq   $0x3,0x100(%rsp)
mov    0x120(%rsp),%rsi
mov    0x118(%rsp),%rbp
jae    444a <svd+0x330a>
xor    %eax,%eax
mov    0x40(%rsp),%rdx
jmp    44bc <svd+0x337c>
xor    %eax,%eax
mov    0x40(%rsp),%rdx
movapd 0xbb7(%rip),%xmm1
nopl   0x0(%rax)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r8,8)
mov    0x8(%rdx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r8,8)
mov    0x10(%rdx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r8,8)
mov    0x18(%rdx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r8,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    4460 <svd+0x3320>
test   %rsi,%rsi
je     3a08 <svd+0x28c8>
lea    (%rdx,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,8),%rdx
movsd  (%rdx,%r8,8),%xmm0
xorpd  %xmm9,%xmm0
movlpd %xmm0,(%rdx,%r8,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    44d0 <svd+0x3390>
jmp    3a08 <svd+0x28c8>
cmpl   $0x0,0xf0(%rsp)
jle    4f6b <svd+0x3e2b>
mov    0x80(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x60(%rsp)
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x78(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0xe8(%rsp)
mov    %rcx,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xf8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x120(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rdx,%rcx
mov    %rdx,0x48(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x70(%rsp)
mov    %edi,%r15d
and    $0xfffffffe,%r15d
mov    %rsi,%rcx
mov    %rsi,0x118(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x128(%rsp)
shl    $0x20,%rax
mov    %rax,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xorpd  %xmm11,%xmm11
jmp    45d2 <svd+0x3492>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %esi,%eax
mov    %rax,0x58(%rsp)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x80(%rsp)
test   %rsi,%rsi
jle    4f72 <svd+0x3e32>
mov    0x60(%rsp),%rsi
lea    -0x1(%rsi),%rax
mov    %rax,0x60(%rsp)
movl   $0x0,0x98(%rsp)
mov    (%rsp),%rdx
mov    %rsi,0x50(%rsp)
jmp    4628 <svd+0x34e8>
cs nopw 0x0(%rax,%rax,1)
unpcklpd %xmm13,%xmm3
addl   $0x1,0x98(%rsp)
01
mov    0x140(%rsp),%rax
movq   $0x0,(%rbx,%rax,8)
movlpd %xmm3,(%rbx,%rsi,8)
movhpd %xmm3,(%r8,%rsi,8)
mov    0x80(%rsp),%rbx
mov    %rsi,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%r13
mov    %ebp,%r14d
test   %rbp,%rbp
js     46b0 <svd+0x3570>
mov    0x68(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm10,%xmm0
ucomisd %xmm10,%xmm0
jne    4669 <svd+0x3529>
jnp    46b0 <svd+0x3570>
movsd  -0x8(%r8,%rbp,8),%xmm0
add    $0xffffffffffffffff,%rbp
andpd  %xmm8,%xmm0
addsd  %xmm10,%xmm0
movabs $0xffffffff00000000,%rax
ff ff ff
lea    (%rax,%r13,1),%rbx
ucomisd %xmm10,%xmm0
jne    4640 <svd+0x3500>
jp     4640 <svd+0x3500>
sar    $0x20,%rbx
cmp    %rsi,%rbx
jle    4cf2 <svd+0x3bb2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8,%rsi,8),%xmm4
cmp    %rsi,%r14
je     4e60 <svd+0x3d20>
cmpl   $0x1e,0x98(%rsp)
1e
je     45b0 <svd+0x3470>
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,%r13
mov    %r13,%r14
sar    $0x20,%r14
sar    $0x1d,%r13
movsd  (%r8,%r13,1),%xmm13
mov    0x60(%rsp),%rax
movsd  (%r8,%rax,8),%xmm3
mov    0x68(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm6
movsd  (%rbx,%rsi,8),%xmm5
movapd %xmm3,%xmm0
subsd  %xmm4,%xmm0
movapd %xmm4,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm6,%xmm0
subsd  %xmm5,%xmm0
addsd  %xmm5,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm0,%xmm6
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
addsd  0x8d3(%rip),%xmm0
ucomisd %xmm11,%xmm0
jb     4760 <svd+0x3620>
sqrtsd %xmm0,%xmm0
jmp    47e6 <svd+0x36a6>
nopl   (%rax)
movapd %xmm13,0x20(%rsp)
movapd %xmm3,0xc0(%rsp)
movapd %xmm4,0x10(%rsp)
movsd  %xmm5,0xa0(%rsp)
movsd  %xmm6,0xb0(%rsp)
call   1060 <sqrt@plt>
movsd  0xb0(%rsp),%xmm6
movsd  0xa0(%rsp),%xmm5
movapd 0x10(%rsp),%xmm4
movapd 0xc0(%rsp),%xmm3
movapd 0x20(%rsp),%xmm13
mov    0x50(%rsp),%rsi
xorpd  %xmm11,%xmm11
movsd  0x8(%rsp),%xmm10
movapd 0x841(%rip),%xmm9
movapd 0x828(%rip),%xmm8
mov    0x30(%rsp),%rdi
mov    (%rsp),%rdx
mov    0x38(%rsp),%r8
mov    0x130(%rsp),%rbp
movapd %xmm13,%xmm1
subsd  %xmm4,%xmm1
addsd  %xmm13,%xmm4
mulsd  %xmm1,%xmm4
xorpd  %xmm1,%xmm1
cmplesd %xmm6,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
addsd  %xmm6,%xmm1
divsd  %xmm1,%xmm3
subsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
divsd  %xmm13,%xmm3
cmp    %rsi,%r14
mov    %r14,0x140(%rsp)
jge    4600 <svd+0x34c0>
movsd  0x7d0(%rip),%xmm0
movapd %xmm0,%xmm7
movapd %xmm0,%xmm14
jmp    48c4 <svd+0x3784>
nopl   0x0(%rax,%rax,1)
mulsd  %xmm6,%xmm14
mulsd  %xmm5,%xmm13
subsd  %xmm13,%xmm14
mulsd  %xmm6,%xmm12
movapd %xmm7,%xmm0
xorpd  %xmm9,%xmm0
unpcklpd %xmm12,%xmm12
mulpd  %xmm7,%xmm12
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
movapd %xmm7,%xmm2
shufpd $0x1,%xmm0,%xmm2
unpcklpd %xmm14,%xmm14
mulpd  %xmm2,%xmm14
movapd %xmm14,%xmm3
addpd  %xmm12,%xmm3
movapd %xmm3,%xmm13
unpckhpd %xmm3,%xmm13
movapd %xmm1,%xmm14
cmp    %rsi,%r14
jge    4605 <svd+0x34c5>
mov    %r14,%r13
add    $0x1,%r14
movsd  0x8(%rbx,%r13,8),%xmm8
movsd  0x8(%r8,%r13,8),%xmm12
mulsd  %xmm8,%xmm7
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
movapd %xmm13,0x20(%rsp)
movapd %xmm12,0x10(%rsp)
jb     4910 <svd+0x37d0>
sqrtsd %xmm0,%xmm0
jmp    4974 <svd+0x3834>
nopl   (%rax)
movapd %xmm14,0xa0(%rsp)
movapd %xmm7,0xb0(%rsp)
movsd  %xmm8,0x100(%rsp)
movapd %xmm3,0xc0(%rsp)
call   1060 <sqrt@plt>
movapd 0xc0(%rsp),%xmm3
movsd  0x100(%rsp),%xmm8
movapd 0xb0(%rsp),%xmm7
movapd 0x10(%rsp),%xmm12
movapd 0xa0(%rsp),%xmm14
movapd 0x20(%rsp),%xmm13
xorpd  %xmm11,%xmm11
movsd  %xmm0,(%rbx,%r13,8)
unpcklpd %xmm3,%xmm7
unpcklpd %xmm0,%xmm0
movapd %xmm7,%xmm5
divpd  %xmm0,%xmm5
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
mov    0x40(%rsp),%rcx
mov    (%rcx,%r13,8),%rax
mov    (%rcx,%r14,8),%rcx
cmpl   $0x2,0xf0(%rsp)
02
jae    49b0 <svd+0x3870>
xor    %edx,%edx
jmp    4ab0 <svd+0x3970>
lea    (%rcx,%r12,8),%rdx
cmp    %rdx,%rax
jae    49d0 <svd+0x3890>
lea    (%rax,%r12,8),%rdx
cmp    %rdx,%rcx
jae    49d0 <svd+0x3890>
xor    %edx,%edx
jmp    4ab0 <svd+0x3970>
nopl   0x0(%rax)
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
cmpq   $0x0,0xe8(%rsp)
je     4ce0 <svd+0x3ba0>
mov    0x70(%rsp),%rsi
xor    %edx,%edx
xchg   %ax,%ax
movupd (%rax,%rdx,8),%xmm1
movupd (%rcx,%rdx,8),%xmm2
movapd %xmm0,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%rax,%rdx,8)
mulpd  %xmm6,%xmm2
mulpd  %xmm0,%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
movupd 0x10(%rax,%rdx,8),%xmm1
movupd 0x10(%rcx,%rdx,8),%xmm2
movapd %xmm0,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,0x10(%rax,%rdx,8)
mulpd  %xmm6,%xmm2
mulpd  %xmm0,%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,0x10(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    49f0 <svd+0x38b0>
testb  $0x1,0x48(%rsp)
je     4aa1 <svd+0x3961>
movupd (%rax,%rdx,8),%xmm1
movupd (%rcx,%rdx,8),%xmm2
movapd %xmm0,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%rax,%rdx,8)
mulpd  %xmm6,%xmm2
mulpd  %xmm0,%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
mov    0x78(%rsp),%rsi
mov    %rsi,%rdx
cmp    %r12,%rsi
je     4aed <svd+0x39ad>
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
movsd  (%rcx,%rdx,8),%xmm1
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rdx,8)
mulsd  %xmm6,%xmm1
mulsd  %xmm5,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    4ab0 <svd+0x3970>
mulsd  %xmm8,%xmm14
movapd %xmm14,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm13,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm12,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
jb     4b40 <svd+0x3a00>
sqrtsd %xmm0,%xmm0
jmp    4bb4 <svd+0x3a74>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm14,0xa0(%rsp)
movapd %xmm6,0xc0(%rsp)
movapd %xmm5,0xb0(%rsp)
movapd %xmm2,0x100(%rsp)
movapd %xmm3,0xd0(%rsp)
call   1060 <sqrt@plt>
movapd 0xd0(%rsp),%xmm3
movapd 0x100(%rsp),%xmm2
movapd 0xb0(%rsp),%xmm5
movapd 0xc0(%rsp),%xmm6
movapd 0x10(%rsp),%xmm12
movapd 0xa0(%rsp),%xmm14
movapd 0x20(%rsp),%xmm13
xorpd  %xmm11,%xmm11
mov    0x38(%rsp),%r8
mov    (%rsp),%rdx
mov    0x30(%rsp),%rdi
movapd 0x435(%rip),%xmm8
movapd 0x43c(%rip),%xmm9
movsd  0x8(%rsp),%xmm10
movapd 0x42d(%rip),%xmm4
mov    0x50(%rsp),%rsi
movsd  %xmm0,(%r8,%r13,8)
ucomisd %xmm11,%xmm0
movapd %xmm5,%xmm7
jne    4bfb <svd+0x3abb>
jnp    4c0b <svd+0x3acb>
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm2
movapd %xmm2,%xmm7
test   %ebp,%ebp
jle    4860 <svd+0x3720>
movapd %xmm7,%xmm0
shufpd $0x1,%xmm7,%xmm0
xor    %eax,%eax
cmp    $0x1,%ebp
je     4c9e <svd+0x3b5e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
movsd  (%rcx,%r14,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%r13,8)
mov    0x8(%rdx,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
movsd  (%rcx,%r14,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%r13,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    4c30 <svd+0x3af0>
test   $0x1,%dil
je     4860 <svd+0x3720>
mov    (%rdx,%rax,8),%rax
movsd  (%rax,%r13,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm9,%xmm2
movsd  (%rax,%r14,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rax,%r13,8)
jmp    4860 <svd+0x3720>
xor    %edx,%edx
testb  $0x1,0x48(%rsp)
jne    4a6d <svd+0x392d>
jmp    4aa1 <svd+0x3961>
movsd  0x326(%rip),%xmm1
jmp    4d10 <svd+0x3bd0>
nopl   0x0(%rax)
lea    0x1(%rbx),%rax
cmp    %rsi,%rbx
mov    %rax,%rbx
jge    46b0 <svd+0x3570>
mov    0x68(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
unpckhpd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbx,8)
movapd %xmm2,%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm10,%xmm0
ucomisd %xmm10,%xmm0
jne    4d4a <svd+0x3c0a>
jnp    46b0 <svd+0x3570>
movsd  (%r8,%rbx,8),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
jb     4d80 <svd+0x3c40>
sqrtsd %xmm0,%xmm0
jmp    4dce <svd+0x3c8e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm2,0x20(%rsp)
movapd %xmm3,0x10(%rsp)
call   1060 <sqrt@plt>
movapd 0x10(%rsp),%xmm3
movapd 0x20(%rsp),%xmm2
mov    0x50(%rsp),%rsi
xorpd  %xmm11,%xmm11
movsd  0x8(%rsp),%xmm10
movapd 0x259(%rip),%xmm9
movapd 0x240(%rip),%xmm8
mov    0x30(%rsp),%rdi
mov    (%rsp),%rdx
mov    0x38(%rsp),%r8
movsd  %xmm0,(%r8,%rbx,8)
xorpd  %xmm9,%xmm2
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
movapd %xmm2,%xmm1
divpd  %xmm0,%xmm1
cmpl   $0x0,0x130(%rsp)
jle    4d00 <svd+0x3bc0>
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm2
movsd  (%rcx,%rbx,8),%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rcx,%rbp,8)
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%rbx,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    4e10 <svd+0x3cd0>
jmp    4d00 <svd+0x3bc0>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm4,%xmm11
jbe    45b7 <svd+0x3477>
xorpd  %xmm9,%xmm4
movlpd %xmm4,(%r8,%rsi,8)
mov    0x40(%rsp),%rax
mov    (%rax,%rsi,8),%rax
cmpl   $0x4,0xf0(%rsp)
04
jae    4e90 <svd+0x3d50>
xor    %ecx,%ecx
jmp    4f40 <svd+0x3e00>
cmpq   $0x0,0x120(%rsp)
je     4f5d <svd+0x3e1d>
mov    0x128(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%rax,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
movupd 0x20(%rax,%rcx,8),%xmm2
movupd 0x30(%rax,%rcx,8),%xmm3
xorpd  %xmm9,%xmm0
xorpd  %xmm9,%xmm1
movupd %xmm0,(%rax,%rcx,8)
movupd %xmm1,0x10(%rax,%rcx,8)
xorpd  %xmm9,%xmm2
xorpd  %xmm9,%xmm3
movupd %xmm2,0x20(%rax,%rcx,8)
movupd %xmm3,0x30(%rax,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    4eb0 <svd+0x3d70>
testb  $0x1,0x118(%rsp)
01
je     4f26 <svd+0x3de6>
movupd (%rax,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
xorpd  %xmm9,%xmm0
xorpd  %xmm9,%xmm1
movupd %xmm0,(%rax,%rcx,8)
movupd %xmm1,0x10(%rax,%rcx,8)
mov    0xf8(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r12,%rdx
je     45b7 <svd+0x3477>
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
xorpd  %xmm9,%xmm0
movlpd %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    4f40 <svd+0x3e00>
jmp    45b7 <svd+0x3477>
xor    %ecx,%ecx
testb  $0x1,0x118(%rsp)
01
jne    4f06 <svd+0x3dc6>
jmp    4f26 <svd+0x3de6>
xor    %eax,%eax
mov    %rax,0x58(%rsp)
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rax
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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