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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ anorm;

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
int dsvdinv(double *a, double *b, int m) {
  int flag, i, its, j, jj, k, l, nm, rank;
  double *vmat, *wmat, *w, *rv1, *tmp, c, f, h, s, x, y, z, anorm, g, scale, at,
      bt, ct, maxarg1, maxarg2, thresh, wmax, tol, tanorm;
  anorm = g = scale = 0.0;
  tanorm = tol = sizeof(anorm) > 4 ? 1.0e-9 : 1.0e-6;
  rv1 = (double *)malloc(m * sizeof(double));
  tmp = (double *)malloc(m * sizeof(double));
  vmat = (double *)malloc(m * m * sizeof(double));
  wmat = (double *)malloc(m * sizeof(double));
  l = nm = 0;
  for (i = 0; i < m; i++) {
    l = i + 1;
    rv1[i] = scale * g;
    g = s = scale = 0.0;
    for (k = i; k < m; k++)
      scale += fabs(a[k * m + i]);
    if (scale) {
      for (k = i; k < m; k++) {
        a[k * m + i] /= scale;
        s += a[k * m + i] * a[k * m + i];
      }
      f = a[i * m + i];
      g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
      h = f * g - s;
      a[i * m + i] = f - g;
      for (j = l; j < m; j++) {
        s = 0.0;
        for (k = i; k < m; k++)
          s += a[k * m + i] * a[k * m + j];
        f = s / h;
        for (k = i; k < m; k++)
          a[k * m + j] += f * a[k * m + i];
      }
      for (k = i; k < m; k++)
        a[k * m + i] *= scale;
    }
    wmat[i] = scale * g;
    g = s = scale = 0.0;
    if (l != m) {
      for (k = l; k < m; k++)
        scale += fabs(a[i * m + k]);
      if (scale) {
        for (k = l; k < m; k++) {
          a[i * m + k] /= scale;
          s += a[i * m + k] * a[i * m + k];
        }
        f = a[i * m + l];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        a[i * m + l] = f - g;
        for (k = l; k < m; k++)
          rv1[k] = a[i * m + k] / h;
        for (j = l; j < m; j++) {
          s = 0.0;
          for (k = l; k < m; k++)
            s += a[j * m + k] * a[i * m + k];
          for (k = l; k < m; k++)
            a[j * m + k] += s * rv1[k];
        }
        for (k = l; k < m; k++)
          a[i * m + k] *= scale;
      }
    }
    anorm = (maxarg1 = (anorm), maxarg2 = ((fabs(wmat[i]) + fabs(rv1[i]))),
             (maxarg1) > (maxarg2) ? (maxarg1) : (maxarg2));
    tanorm = tol * anorm;
  }
  for (i = m; i--;) {
    if (i < m - 1) {
      if (g) {
        for (j = l; j < m; j++)
          vmat[j * m + i] = (a[i * m + j] / a[i * m + l]) / g;
        for (j = l; j < m; j++) {
          s = 0.0;
          for (k = l; k < m; k++)
            s += a[i * m + k] * vmat[k * m + j];
          for (k = l; k < m; k++)
            vmat[k * m + j] += s * vmat[k * m + i];
        }
      }
      for (j = l; j < m; j++)
        vmat[i * m + j] = vmat[j * m + i] = 0.0;
    }
    vmat[i * m + i] = 1.0;
    g = rv1[i];
    l = i;
  }
  for (i = m; i--;) {
    l = i + 1;
    g = wmat[i];
    for (j = l; j < m; j++)
      a[i * m + j] = 0.0;
    if (g) {
      g = 1.0 / g;
      for (j = l; j < m; j++) {
        s = 0.0;
        for (k = l; k < m; k++)
          s += a[k * m + i] * a[k * m + j];
        f = (s / a[i * m + i]) * g;
        for (k = i; k < m; k++)
          a[k * m + j] += f * a[k * m + i];
      }
      for (j = i; j < m; j++)
        a[j * m + i] *= g;
    } else
      for (j = i; j < m; j++)
        a[j * m + i] = 0.0;
    ++a[i * m + i];
  }
  for (k = m; k--;) {
    for (its = 0; its < 30; its++) {
      flag = 1;
      for (l = k + 1; l--;) {
        nm = l - 1;
        if (fabs(rv1[l]) <= tanorm || !l) {
          flag = 0;
          break;
        }
        if (fabs(wmat[nm]) <= tanorm)
          break;
      }
      if (flag) {
        c = 0.0;
        s = 1.0;
        for (i = l; i <= k; i++) {
          f = s * rv1[i];
          rv1[i] = c * rv1[i];
          if (fabs(f) <= tanorm)
            break;
          g = wmat[i];
          h = ((at = fabs(f)) > (bt = fabs(g))
                   ? (ct = bt / at, at * sqrt(1.0 + ct * ct))
                   : (bt ? (ct = at / bt, bt * sqrt(1.0 + ct * ct)) : 0.0));
          wmat[i] = h;
          h = 1.0 / h;
          c = g * h;
          s = -f * h;
          for (j = 0; j < m; j++) {
            y = a[j * m + nm];
            z = a[j * m + i];
            a[j * m + nm] = y * c + z * s;
            a[j * m + i] = z * c - y * s;
          }
        }
      }
      z = wmat[k];
      if (l == k) {
        if (z < 0.0) {
          wmat[k] = -z;
          for (j = 0; j < m; j++)
            vmat[j * m + k] = -vmat[j * m + k];
        }
        break;
      }
      if (its == 29)
        return 0;
      x = wmat[l];
      nm = k - 1;
      y = wmat[nm];
      g = rv1[nm];
      h = rv1[k];
      f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
      g = ((at = fabs(f)) > (bt = fabs(1.0))
               ? (ct = bt / at, at * sqrt(1.0 + ct * ct))
               : (bt ? (ct = at / bt, bt * sqrt(1.0 + ct * ct)) : 0.0));
      f = ((x - z) * (x + z) +
           h * ((y / (f + ((f) >= 0.0 ? fabs(g) : -fabs(g)))) - h)) /
          x;
      c = s = 1.0;
      for (j = l; j <= nm; j++) {
        i = j + 1;
        g = rv1[i];
        y = wmat[i];
        h = s * g;
        g = c * g;
        z = ((at = fabs(f)) > (bt = fabs(h))
                 ? (ct = bt / at, at * sqrt(1.0 + ct * ct))
                 : (bt ? (ct = at / bt, bt * sqrt(1.0 + ct * ct)) : 0.0));
        rv1[j] = z;
        c = f / z;
        s = h / z;
        f = x * c + g * s;
        g = g * c - x * s;
        h = y * s;
        y *= c;
        for (jj = 0; jj < m; jj++) {
          x = vmat[jj * m + j];
          z = vmat[jj * m + i];
          vmat[jj * m + j] = x * c + z * s;
          vmat[jj * m + i] = z * c - x * s;
        }
        z = ((at = fabs(f)) > (bt = fabs(h))
                 ? (ct = bt / at, at * sqrt(1.0 + ct * ct))
                 : (bt ? (ct = at / bt, bt * sqrt(1.0 + ct * ct)) : 0.0));
        wmat[j] = z;
        if (z) {
          z = 1.0 / z;
          c = f * z;
          s = h * z;
        }
        f = c * g + s * y;
        x = c * y - s * g;
        for (jj = 0; jj < m; jj++) {
          y = a[jj * m + j];
          z = a[jj * m + i];
          a[jj * m + j] = y * c + z * s;
          a[jj * m + i] = z * c - y * s;
        }
      }
      rv1[l] = 0.0;
      rv1[k] = f;
      wmat[k] = x;
    }
  }
  wmax = 0.0;
  w = wmat;
  for (j = m; j--; w++)
    if (*w > wmax)
      wmax = *w;
  thresh = tol * wmax;
  rank = 0;
  w = wmat;
  for (j = m; j--; w++)
    if (*w <= thresh)
      *w = 0.0;
    else {
      rank++;
      *w = 1.0 / *w;
    }
  for (j = 0; j < m; j++)
    for (i = 0; i < m; i++) {
      s = 0.0;
      for (k = 0; k < m; k++)
        s += vmat[k + j * m] * a[k + i * m] * wmat[k];
      b[j + i * m] = s;
    }
  free(tmp);
  free(rv1);
  free(vmat);
  free(wmat);
  return rank;
}


x86 assembly (clang, -O0):
<dsvdinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x2e91(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0x2e81(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a24 <dsvdinv+0x8f4>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1291 <dsvdinv+0x161>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2db1(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1246 <dsvdinv+0x116>
movsd  -0xb8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12b1 <dsvdinv+0x181>
jp     12b1 <dsvdinv+0x181>
jmp    1594 <dsvdinv+0x464>
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133c <dsvdinv+0x20c>
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b7 <dsvdinv+0x187>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     138e <dsvdinv+0x25e>
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movaps 0x2ca3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    13c5 <dsvdinv+0x295>
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movaps 0x2c7e(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    154c <dsvdinv+0x41c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14c9 <dsvdinv+0x399>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    146b <dsvdinv+0x33b>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1539 <dsvdinv+0x409>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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    14e1 <dsvdinv+0x3b1>
jmp    153e <dsvdinv+0x40e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    144e <dsvdinv+0x31e>
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    158f <dsvdinv+0x45f>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1552 <dsvdinv+0x422>
jmp    1594 <dsvdinv+0x464>
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1967 <dsvdinv+0x837>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    162f <dsvdinv+0x4ff>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2a13(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15e4 <dsvdinv+0x4b4>
movsd  -0xb8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    164f <dsvdinv+0x51f>
jp     164f <dsvdinv+0x51f>
jmp    1962 <dsvdinv+0x832>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16da <dsvdinv+0x5aa>
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1655 <dsvdinv+0x525>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     172c <dsvdinv+0x5fc>
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movaps 0x2905(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1763 <dsvdinv+0x633>
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movaps 0x28e0(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    182e <dsvdinv+0x6fe>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17ec <dsvdinv+0x6bc>
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    191a <dsvdinv+0x7ea>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18af <dsvdinv+0x77f>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1851 <dsvdinv+0x721>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1907 <dsvdinv+0x7d7>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%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    18b5 <dsvdinv+0x785>
jmp    190c <dsvdinv+0x7dc>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1834 <dsvdinv+0x704>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    195d <dsvdinv+0x82d>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1920 <dsvdinv+0x7f0>
jmp    1962 <dsvdinv+0x832>
jmp    1967 <dsvdinv+0x837>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2695(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x267d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    19de <dsvdinv+0x8ae>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
jmp    19ee <dsvdinv+0x8be>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ed <dsvdinv+0xbd>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
je     1c68 <dsvdinv+0xb38>
mov    -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1c2a <dsvdinv+0xafa>
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a6f <dsvdinv+0x93f>
jp     1a6f <dsvdinv+0x93f>
jmp    1bd3 <dsvdinv+0xaa3>
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ad9 <dsvdinv+0x9a9>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0xb0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a75 <dsvdinv+0x945>
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bce <dsvdinv+0xa9e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b5a <dsvdinv+0xa2a>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1afc <dsvdinv+0x9cc>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bbb <dsvdinv+0xa8b>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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    1b60 <dsvdinv+0xa30>
jmp    1bc0 <dsvdinv+0xa90>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1adf <dsvdinv+0x9af>
jmp    1bd3 <dsvdinv+0xaa3>
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c25 <dsvdinv+0xaf5>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1bd9 <dsvdinv+0xaa9>
jmp    1c2a <dsvdinv+0xafa>
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x23c5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x24(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1a2a <dsvdinv+0x8fa>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
je     1edc <dsvdinv+0xdac>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1cd9 <dsvdinv+0xba9>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ca6 <dsvdinv+0xb76>
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1cf9 <dsvdinv+0xbc9>
jp     1cf9 <dsvdinv+0xbc9>
jmp    1e76 <dsvdinv+0xd46>
movsd  0x2307(%rip),%xmm0
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e2e <dsvdinv+0xcfe>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1d92 <dsvdinv+0xc62>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d34 <dsvdinv+0xc04>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e1b <dsvdinv+0xceb>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%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    1dc3 <dsvdinv+0xc93>
jmp    1e20 <dsvdinv+0xcf0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d17 <dsvdinv+0xbe7>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e71 <dsvdinv+0xd41>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e34 <dsvdinv+0xd04>
jmp    1eb4 <dsvdinv+0xd84>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1eaf <dsvdinv+0xd7f>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e7c <dsvdinv+0xd4c>
jmp    1eb4 <dsvdinv+0xd84>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x213b(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c6e <dsvdinv+0xb3e>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
cmp    $0x0,%eax
je     2e41 <dsvdinv+0x1d11>
movl   $0x0,-0x28(%rbp)
cmpl   $0x1e,-0x28(%rbp)
jge    2e3c <dsvdinv+0x1d0c>
movl   $0x1,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x38(%rbp)
cmp    $0x0,%eax
je     1fa8 <dsvdinv+0xe78>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x20d8(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    1f68 <dsvdinv+0xe38>
cmpl   $0x0,-0x38(%rbp)
jne    1f74 <dsvdinv+0xe44>
movl   $0x0,-0x20(%rbp)
jmp    1fa8 <dsvdinv+0xe78>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x2098(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1fa3 <dsvdinv+0xe73>
jmp    1fa8 <dsvdinv+0xe78>
jmp    1f17 <dsvdinv+0xde7>
cmpl   $0x0,-0x20(%rbp)
je     230e <dsvdinv+0x11de>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x2046(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     2309 <dsvdinv+0x11d9>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm1
movaps 0x1fff(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     203c <dsvdinv+0xf0c>
jmp    2309 <dsvdinv+0x11d9>
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movaps 0x1fc3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movaps 0x1fa8(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  %xmm1,-0xc8(%rbp)
ff
ucomisd %xmm1,%xmm0
jbe    20f7 <dsvdinv+0xfc7>
movsd  -0xc8(%rbp),%xmm0
ff
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x1f36(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x128(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    21a0 <dsvdinv+0x1070>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2117 <dsvdinv+0xfe7>
jp     2117 <dsvdinv+0xfe7>
jmp    2180 <dsvdinv+0x1050>
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x1ead(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    2190 <dsvdinv+0x1060>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    2190 <dsvdinv+0x1060>
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x1e41(%rip),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    22f6 <dsvdinv+0x11c6>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2213 <dsvdinv+0x10e3>
jmp    22fb <dsvdinv+0x11cb>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1fd0 <dsvdinv+0xea0>
jmp    230e <dsvdinv+0x11de>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    23da <dsvdinv+0x12aa>
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    23d5 <dsvdinv+0x12a5>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    23d0 <dsvdinv+0x12a0>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2373 <dsvdinv+0x1243>
jmp    23d5 <dsvdinv+0x12a5>
jmp    2e3c <dsvdinv+0x1d0c>
cmpl   $0x1d,-0x28(%rbp)
jne    23f0 <dsvdinv+0x12c0>
movl   $0x0,-0x4(%rbp)
jmp    305e <dsvdinv+0x1f2e>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
addsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
subsd  -0x80(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
addsd  -0x80(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1b78(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movaps 0x1b66(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x1b3a(%rip),%xmm1
movsd  %xmm1,-0xc8(%rbp)
ff
ucomisd %xmm1,%xmm0
jbe    2549 <dsvdinv+0x1419>
movsd  -0xc8(%rbp),%xmm0
ff
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x1ae4(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x148(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    25f2 <dsvdinv+0x14c2>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2569 <dsvdinv+0x1439>
jp     2569 <dsvdinv+0x1439>
jmp    25d2 <dsvdinv+0x14a2>
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x1a5b(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    25e2 <dsvdinv+0x14b2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    25e2 <dsvdinv+0x14b2>
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     268e <dsvdinv+0x155e>
movsd  -0xb0(%rbp),%xmm0
ff
movaps 0x19a3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
jmp    26c0 <dsvdinv+0x1590>
movsd  -0xb0(%rbp),%xmm0
ff
movaps 0x1983(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x178(%rbp),%xmm2
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm3
ff
movsd  -0x160(%rbp),%xmm4
ff
movsd  -0x188(%rbp),%xmm5
ff
addsd  %xmm5,%xmm4
divsd  %xmm4,%xmm3
subsd  -0x80(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  0x18ea(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x18da(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     2df7 <dsvdinv+0x1cc7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movaps 0x1872(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movaps 0x185a(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  %xmm1,-0xc8(%rbp)
ff
ucomisd %xmm1,%xmm0
jbe    2845 <dsvdinv+0x1715>
movsd  -0xc8(%rbp),%xmm0
ff
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x17e8(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x198(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
jmp    28ee <dsvdinv+0x17be>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2865 <dsvdinv+0x1735>
jp     2865 <dsvdinv+0x1735>
jmp    28ce <dsvdinv+0x179e>
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x175f(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x1a8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
jmp    28de <dsvdinv+0x17ae>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
jmp    28de <dsvdinv+0x17ae>
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2abc <dsvdinv+0x198c>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    29d9 <dsvdinv+0x18a9>
movsd  -0x78(%rbp),%xmm0
movaps 0x1558(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movaps 0x1540(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  %xmm1,-0xc8(%rbp)
ff
ucomisd %xmm1,%xmm0
jbe    2b5f <dsvdinv+0x1a2f>
movsd  -0xc8(%rbp),%xmm0
ff
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x14ce(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x1b8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
jmp    2c08 <dsvdinv+0x1ad8>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2b7f <dsvdinv+0x1a4f>
jp     2b7f <dsvdinv+0x1a4f>
jmp    2be8 <dsvdinv+0x1ab8>
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x1445(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x1c8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
jmp    2bf8 <dsvdinv+0x1ac8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
jmp    2bf8 <dsvdinv+0x1ac8>
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2c4d <dsvdinv+0x1b1d>
jp     2c4d <dsvdinv+0x1b1d>
jmp    2c8c <dsvdinv+0x1b5c>
movsd  0x13b3(%rip),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2de4 <dsvdinv+0x1cb4>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2d01 <dsvdinv+0x1bd1>
jmp    2de9 <dsvdinv+0x1cb9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2739 <dsvdinv+0x1609>
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1efd <dsvdinv+0xdcd>
jmp    1ee2 <dsvdinv+0xdb2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x0,%eax
je     2eaa <dsvdinv+0x1d7a>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xf0(%rbp),%xmm0
ff
jbe    2e94 <dsvdinv+0x1d64>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    2e99 <dsvdinv+0x1d69>
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
jmp    2e5a <dsvdinv+0x1d2a>
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x0,%eax
je     2f4c <dsvdinv+0x1e1c>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2f15 <dsvdinv+0x1de5>
mov    -0x58(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    2f36 <dsvdinv+0x1e06>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x58(%rbp),%rax
movsd  0x10de(%rip),%xmm0
divsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    2f3b <dsvdinv+0x1e0b>
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
jmp    2ed7 <dsvdinv+0x1da7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    3034 <dsvdinv+0x1f04>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    3021 <dsvdinv+0x1ef1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2ff3 <dsvdinv+0x1ec3>
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2f84 <dsvdinv+0x1e54>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    2f66 <dsvdinv+0x1e36>
jmp    3026 <dsvdinv+0x1ef6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2f53 <dsvdinv+0x1e23>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dsvdinv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    %edx,%ebx
mov    %rsi,0x1d0(%rsp)
mov    %rdi,%r13
lea    0x0(,%rbx,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x1c8(%rsp)
mov    %ebp,%edi
imul   %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r8
movl   $0x0,0x34(%rsp)
test   %ebx,%ebx
mov    %rbx,0x98(%rsp)
mov    %r13,0x10(%rsp)
mov    %r12,0x90(%rsp)
mov    %rax,0x68(%rsp)
jle    1ed5 <dsvdinv+0xd95>
mov    %ebx,%r15d
lea    0x1(%r15),%rax
mov    %rax,0x1e0(%rsp)
lea    0x0(,%r15,8),%rbx
lea    0x8(,%r15,8),%r9
lea    (%r12,%r15,8),%rax
mov    %rax,0x198(%rsp)
lea    0x8(%r13),%rdi
lea    -0x1(%r15),%rax
mov    %rax,0x138(%rsp)
lea    -0x2(%r15),%rax
mov    %rax,0x190(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x148(%rsp)
lea    0x18(%r12),%rsi
lea    -0x3(%r15),%r10
lea    0x0(,%r15,8),%rax
add    %r13,%rax
mov    %rax,0x118(%rsp)
lea    0x38(%r13,%r15,8),%rdx
lea    0x38(%r12),%rax
mov    %rax,0x120(%rsp)
lea    -0x5(%r15),%rcx
xorpd  %xmm8,%xmm8
movapd 0x2dbb(%rip),%xmm7
movapd 0x2dc2(%rip),%xmm10
movapd 0x2da9(%rip),%xmm11
xorpd  %xmm13,%xmm13
xorpd  %xmm12,%xmm12
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xe8(%rsp)
mov    $0x1,%eax
xor    %r11d,%r11d
mov    %r13,%rbp
mov    %r13,%r14
mov    %rdi,0x178(%rsp)
mov    %rdi,%r13
mov    %rdi,0xf0(%rsp)
mov    %r15,%rdi
mov    %r9,0x20(%rsp)
jmp    1346 <dsvdinv+0x206>
nopl   0x0(%rax)
mov    0x70(%rsp),%rsi
mov    0xa0(%rsp),%rdx
movsd  (%r8,%r11,8),%xmm0
movsd  (%r12,%r11,8),%xmm1
andpd  %xmm11,%xmm0
andpd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe8(%rsp),%xmm0
maxsd  %xmm1,%xmm0
movsd  %xmm0,0xe8(%rsp)
mov    0x8(%rsp),%rax
add    $0x1,%rax
add    %rcx,%r14
add    $0xffffffffffffffff,%rdi
add    %rcx,0xf0(%rsp)
add    $0x8,%rsi
mov    0x88(%rsp),%r10
add    $0xffffffffffffffff,%r10
add    %rbx,%r13
add    %rbx,0x118(%rsp)
add    %rcx,%rdx
addq   $0x8,0x120(%rsp)
mov    0x38(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
add    %rbx,%rbp
mov    0x28(%rsp),%r11
cmp    %r15,%r11
je     1e9f <dsvdinv+0xd5f>
mov    %rdx,0xa0(%rsp)
mov    %rsi,0x70(%rsp)
mov    %rbp,0x40(%rsp)
mulsd  %xmm12,%xmm13
mov    %rcx,0x38(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x140(%rsp)
mov    %r10,%rcx
shr    %rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x110(%rsp)
mov    0x138(%rsp),%rdx
sub    %r11,%rdx
mov    %rdx,%rcx
mov    %rdx,0xd0(%rsp)
lea    -0x4(%rdx),%rcx
mov    0x20(%rsp),%rdx
mov    %rcx,0x180(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x150(%rsp)
mov    %r11,%rcx
not    %rcx
lea    (%rcx,%r15,1),%r9
add    $0xfffffffffffffffe,%r9
add    %r15,%rcx
mov    %rcx,0x50(%rsp)
mov    %r9,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,0x170(%rsp)
mov    %rax,0x8(%rsp)
lea    (%r12,%rax,8),%rax
mov    %rax,0x80(%rsp)
mov    %rdx,%rsi
mov    %rdx,%rax
imul   %r11,%rax
mov    %rax,0xc8(%rsp)
mov    0x178(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xb8(%rsp)
mov    %r11,%rax
imul   %r15,%rax
mov    %rax,%rcx
mov    %rax,0xc0(%rsp)
add    %r15,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x108(%rsp)
lea    0x2(%r11),%rax
imul   %r15,%rax
mov    %rax,0x60(%rsp)
movsd  %xmm13,(%r12,%r11,8)
xorpd  %xmm3,%xmm3
lea    0x1(%r11),%rax
mov    %rax,0x28(%rsp)
mov    %rdi,%rax
mov    %r14,%rcx
nopl   (%rax)
movsd  (%rcx),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm3
add    %rbx,%rcx
add    $0xffffffffffffffff,%rax
jne    1470 <dsvdinv+0x330>
xorpd  %xmm12,%xmm12
ucomisd %xmm12,%xmm3
xorpd  %xmm0,%xmm0
mov    %rsi,%rcx
mov    %r10,0x88(%rsp)
jne    14a6 <dsvdinv+0x366>
jnp    167a <dsvdinv+0x53a>
xorpd  %xmm5,%xmm5
mov    %rdi,%rax
mov    %r14,%rcx
movsd  (%rcx),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    %rbx,%rcx
add    $0xffffffffffffffff,%rax
jne    14b0 <dsvdinv+0x370>
mov    %r11d,%eax
imul   0x98(%rsp),%eax
movslq %eax,%rbp
add    %r11,%rbp
mov    0x10(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm4
ucomisd %xmm8,%xmm5
jb     1500 <dsvdinv+0x3c0>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    1592 <dsvdinv+0x452>
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm0
mov    %rdi,0x100(%rsp)
mov    %r11,0x18(%rsp)
mov    %r9,0x168(%rsp)
movsd  %xmm3,0x160(%rsp)
movsd  %xmm4,0x1b0(%rsp)
movsd  %xmm5,0x1a0(%rsp)
call   1060 <sqrt@plt>
movsd  0x1a0(%rsp),%xmm5
movsd  0x1b0(%rsp),%xmm4
movsd  0x160(%rsp),%xmm3
mov    0x168(%rsp),%r9
mov    0x18(%rsp),%r11
xorpd  %xmm12,%xmm12
mov    0x100(%rsp),%rdi
movapd 0x2a99(%rip),%xmm11
movapd 0x2aa0(%rip),%xmm10
movapd 0x2a88(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x68(%rsp),%r8
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
orpd   %xmm10,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm4,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,%xmm0
xorpd  %xmm10,%xmm0
addsd  %xmm4,%xmm2
mov    0x10(%rsp),%rax
movsd  %xmm2,(%rax,%rbp,8)
cmp    %r15,0x28(%rsp)
jae    165a <dsvdinv+0x51a>
mulsd  %xmm0,%xmm4
subsd  %xmm5,%xmm4
mov    0xf0(%rsp),%rax
mov    0x8(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    %rdi,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%r14,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm1
add    %rbx,%rsi
add    $0xffffffffffffffff,%rdx
jne    1600 <dsvdinv+0x4c0>
divsd  %xmm4,%xmm1
mov    %rdi,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rsi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %rbx,%rsi
add    $0xffffffffffffffff,%rdx
jne    1630 <dsvdinv+0x4f0>
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r15,%rcx
jne    15f0 <dsvdinv+0x4b0>
mov    %rdi,%rax
mov    %r14,%rcx
movsd  (%rcx),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx)
add    %rbx,%rcx
add    $0xffffffffffffffff,%rax
jne    1660 <dsvdinv+0x520>
mov    0x20(%rsp),%rcx
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%r8,%r11,8)
cmp    %r15,0x28(%rsp)
mov    0x40(%rsp),%rbp
xorpd  %xmm13,%xmm13
je     12b0 <dsvdinv+0x170>
mov    0x70(%rsp),%rsi
mov    0xa0(%rsp),%rdx
jae    12bd <dsvdinv+0x17d>
xorpd  %xmm13,%xmm13
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm13
add    $0x1,%rax
cmp    %rax,%rdi
jne    16c0 <dsvdinv+0x580>
xorpd  %xmm12,%xmm12
ucomisd %xmm12,%xmm13
jne    16ea <dsvdinv+0x5aa>
jnp    12bd <dsvdinv+0x17d>
xorpd  %xmm4,%xmm4
cmp    %r15,0x28(%rsp)
jae    1722 <dsvdinv+0x5e2>
xorpd  %xmm4,%xmm4
mov    $0x1,%eax
xchg   %ax,%ax
movsd  (%r14,%rax,8),%xmm0
divsd  %xmm13,%xmm0
movsd  %xmm0,(%r14,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rax
cmp    %rax,%rdi
jne    1700 <dsvdinv+0x5c0>
mov    0x28(%rsp),%rax
mov    0xc0(%rsp),%r10
lea    (%r10,%rax,1),%rcx
mov    0x10(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm3
ucomisd %xmm8,%xmm4
mov    %r11,0x18(%rsp)
mov    %rcx,0x160(%rsp)
jb     1767 <dsvdinv+0x627>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
mov    0x20(%rsp),%rcx
mov    0x70(%rsp),%rsi
jmp    1800 <dsvdinv+0x6c0>
movapd %xmm4,%xmm0
mov    %rdi,0x100(%rsp)
movapd %xmm13,0x1b0(%rsp)
mov    %r9,0x168(%rsp)
movapd %xmm3,0x1a0(%rsp)
movsd  %xmm4,0x1d8(%rsp)
call   1060 <sqrt@plt>
movsd  0x1d8(%rsp),%xmm4
movapd 0x1a0(%rsp),%xmm3
mov    0x168(%rsp),%r9
movapd 0x1b0(%rsp),%xmm13
mov    0x18(%rsp),%r11
mov    0x100(%rsp),%rdi
mov    0x40(%rsp),%rbp
movapd 0x2835(%rip),%xmm11
movapd 0x283c(%rip),%xmm10
movapd 0x2824(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x70(%rsp),%rsi
mov    0x20(%rsp),%rcx
mov    0x68(%rsp),%r8
mov    0x110(%rsp),%rdx
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
orpd   %xmm10,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm3,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,%xmm12
xorpd  %xmm10,%xmm12
addsd  %xmm3,%xmm2
mov    0x10(%rsp),%rax
mov    0x160(%rsp),%r10
movsd  %xmm2,(%rax,%r10,8)
cmp    %r15,0x28(%rsp)
jae    12b5 <dsvdinv+0x175>
mulsd  %xmm12,%xmm3
subsd  %xmm4,%xmm3
mov    0x8(%rsp),%rax
cmpq   $0x2,0x50(%rsp)
mov    0x118(%rsp),%r10
jb     194a <dsvdinv+0x80a>
mov    0x108(%rsp),%rax
cmp    %rax,0x80(%rsp)
jae    18a5 <dsvdinv+0x765>
mov    0x8(%rsp),%rax
mov    0xb8(%rsp),%rbp
cmp    0x198(%rsp),%rbp
jb     194a <dsvdinv+0x80a>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
xor    %ecx,%ecx
cmp    $0x2,%r9
jb     18e8 <dsvdinv+0x7a8>
mov    0xf0(%rsp),%rax
nopl   (%rax)
movupd (%rax,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rsi,%rcx,8)
movupd 0x10(%rax,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    18c0 <dsvdinv+0x780>
mov    0x50(%rsp),%rbp
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
testb  $0x1,0x170(%rsp)
01
mov    0xa0(%rsp),%rdx
je     193c <dsvdinv+0x7fc>
add    0x8(%rsp),%rcx
mov    0xc0(%rsp),%rdx
add    %rcx,%rdx
mov    0x10(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm1
mov    0x70(%rsp),%rsi
mov    0xa0(%rsp),%rdx
mov    0x18(%rsp),%r11
divpd  %xmm0,%xmm1
movupd %xmm1,(%r12,%rcx,8)
cmp    %rax,%rbp
je     19cc <dsvdinv+0x88c>
add    0x8(%rsp),%rax
mov    0xa0(%rsp),%r11
mov    %r15d,%edx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     1982 <dsvdinv+0x842>
mov    0xc0(%rsp),%rcx
add    %rax,%rcx
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%rax,8)
lea    0x1(%rax),%rcx
cmp    %rax,0x138(%rsp)
mov    %r11,%rdx
mov    0x18(%rsp),%r11
mov    0x70(%rsp),%rsi
je     19cc <dsvdinv+0x88c>
nopl   0x0(%rax)
movsd  -0x8(%r13,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  0x0(%r13,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    19a0 <dsvdinv+0x860>
cmp    %r15,0x28(%rsp)
mov    %r10,0x118(%rsp)
jae    1d09 <dsvdinv+0xbc9>
mov    %rdi,0x100(%rsp)
mov    0x8(%rsp),%rcx
mov    0xc0(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x110(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x108(%rsp)
mov    0x50(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb8(%rsp)
add    %rcx,%rax
mov    %rax,0x170(%rsp)
mov    %rdx,%rdi
mov    %r10,%rsi
xor    %r11d,%r11d
mov    0x190(%rsp),%r9
jmp    1a57 <dsvdinv+0x917>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%r11
add    %rbx,%rsi
add    %rbx,%rdi
cmp    %r15,%rcx
je     1d18 <dsvdinv+0xbd8>
mov    %rcx,%r10
imul   %r15,%r10
xorpd  %xmm1,%xmm1
mov    0x8(%rsp),%rbp
mov    %rbp,%rax
testb  $0x1,0xd0(%rsp)
01
je     1aa0 <dsvdinv+0x960>
lea    (%r10,%rbp,1),%rax
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
mov    0x110(%rsp),%rax
mulsd  (%rdx,%rax,8),%xmm0
addsd  %xmm8,%xmm0
mov    0x108(%rsp),%rax
movapd %xmm0,%xmm1
cmp    0x18(%rsp),%r9
je     1ade <dsvdinv+0x99e>
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm2
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  -0x8(%r13,%rax,8),%xmm2
mulsd  0x0(%r13,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%r15
jne    1ab0 <dsvdinv+0x970>
mov    %rbp,%rdx
cmpq   $0x4,0x50(%rsp)
jb     1c80 <dsvdinv+0xb40>
mov    %r11,%rax
imul   %r15,%rax
mov    0x1e0(%rsp),%rdx
add    %rax,%rdx
mov    0x10(%rsp),%rbp
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
mov    0x90(%rsp),%r12
add    0xc8(%rsp),%rdx
cmp    0x198(%rsp),%rdx
jae    1b4a <dsvdinv+0xa0a>
add    0x60(%rsp),%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    0x8(%rsp),%rdx
cmp    %rax,0x80(%rsp)
jb     1c80 <dsvdinv+0xb40>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x180(%rsp)
mov    0x120(%rsp),%rax
jae    1b75 <dsvdinv+0xa35>
xor    %r8d,%r8d
mov    0xb8(%rsp),%rbp
jmp    1c0b <dsvdinv+0xacb>
mov    0x140(%rsp),%r9
xor    %r8d,%r8d
mov    0xb8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rax,%r8,8),%xmm2
movupd -0x20(%rax,%r8,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdi,%r8,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rdi,%r8,8),%xmm2
movupd -0x10(%rdi,%r8,8),%xmm5
movupd (%rdi,%r8,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rdi,%r8,8)
movupd %xmm3,-0x20(%rdi,%r8,8)
movupd -0x10(%rax,%r8,8),%xmm2
movupd (%rax,%r8,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rdi,%r8,8)
movupd %xmm3,(%rdi,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r9
jne    1b90 <dsvdinv+0xa50>
testb  $0x1,0x150(%rsp)
01
mov    0x190(%rsp),%r9
je     1c61 <dsvdinv+0xb21>
add    0x8(%rsp),%r8
movupd (%r12,%r8,8),%xmm2
movupd 0x10(%r12,%r8,8),%xmm3
add    %r10,%r8
mov    0x10(%rsp),%rax
movupd (%rax,%r8,8),%xmm4
movupd 0x10(%rax,%r8,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rax,%r8,8)
movupd %xmm3,0x10(%rax,%r8,8)
mov    0x170(%rsp),%rdx
cmp    %rbp,0x50(%rsp)
mov    0x68(%rsp),%r8
je     1a40 <dsvdinv+0x900>
nopl   0x0(%rax)
mov    %r15d,%ebp
sub    %edx,%ebp
mov    %rdx,%rax
test   $0x1,%bpl
mov    0x90(%rsp),%r12
je     1cb8 <dsvdinv+0xb78>
add    %rdx,%r10
movsd  (%r12,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x10(%rsp),%rax
addsd  (%rax,%r10,8),%xmm1
movsd  %xmm1,(%rax,%r10,8)
lea    0x1(%rdx),%rax
not    %rdx
cmp    0x148(%rsp),%rdx
je     1a40 <dsvdinv+0x900>
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rsi,%rax,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    1cd0 <dsvdinv+0xb90>
jmp    1a40 <dsvdinv+0x900>
mov    0x40(%rsp),%rbp
mov    0x20(%rsp),%rcx
jmp    12bd <dsvdinv+0x17d>
cmp    %r15,0x28(%rsp)
mov    0x20(%rsp),%rcx
mov    0x70(%rsp),%rsi
mov    0x100(%rsp),%rdi
mov    0x18(%rsp),%r11
jae    1d7b <dsvdinv+0xc3b>
mov    0x8(%rsp),%rax
cmpq   $0x4,0x50(%rsp)
mov    0xa0(%rsp),%rdx
mov    0x40(%rsp),%rbp
jb     1e80 <dsvdinv+0xd40>
mov    %rbp,%r9
movapd %xmm13,%xmm0
unpcklpd %xmm13,%xmm0
cmpq   $0x4,0x180(%rsp)
jae    1d8d <dsvdinv+0xc4d>
xor    %eax,%eax
mov    0xb8(%rsp),%rbp
jmp    1e00 <dsvdinv+0xcc0>
mov    0xa0(%rsp),%rdx
mov    0x40(%rsp),%rbp
jmp    12bd <dsvdinv+0x17d>
xor    %eax,%eax
mov    0xf0(%rsp),%r11
mov    0x140(%rsp),%rdi
mov    0xb8(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movupd (%r11,%rax,8),%xmm1
movupd 0x10(%r11,%rax,8),%xmm2
movupd 0x20(%r11,%rax,8),%xmm3
movupd 0x30(%r11,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%r11,%rax,8)
movupd %xmm2,0x10(%r11,%rax,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x20(%r11,%rax,8)
movupd %xmm4,0x30(%r11,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1db0 <dsvdinv+0xc70>
testb  $0x1,0x150(%rsp)
01
je     1e51 <dsvdinv+0xd11>
add    0x8(%rsp),%rax
add    0xc0(%rsp),%rax
mov    %rsi,%rdi
mov    %rdx,%rsi
mov    %rcx,%rdx
mov    0x10(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
movupd 0x10(%rcx,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rcx,%rax,8)
movupd %xmm2,0x10(%rcx,%rax,8)
mov    %rdx,%rcx
mov    %rsi,%rdx
mov    %rdi,%rsi
mov    0x40(%rsp),%r9
cmp    %rbp,0x50(%rsp)
mov    0x100(%rsp),%rdi
mov    0x18(%rsp),%r11
jne    1e6d <dsvdinv+0xd2d>
mov    %r9,%rbp
jmp    12bd <dsvdinv+0x17d>
add    0x8(%rsp),%rbp
mov    %rbp,%rax
mov    %r9,%rbp
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm13,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1e80 <dsvdinv+0xd40>
jmp    12bd <dsvdinv+0x17d>
movsd  0xe8(%rsp),%xmm0
mulsd  0x2150(%rip),%xmm0
movsd  %xmm0,0xe8(%rsp)
mov    0x98(%rsp),%rbx
mov    %ebx,%eax
mov    %ebx,0x38(%rsp)
mov    0x10(%rsp),%r13
test   %ebx,%ebx
jne    1efb <dsvdinv+0xdbb>
jmp    35dc <dsvdinv+0x249c>
movsd  0x2123(%rip),%xmm0
movsd  %xmm0,0xe8(%rsp)
xorpd  %xmm12,%xmm12
movl   $0x0,0x38(%rsp)
test   %ebx,%ebx
je     35dc <dsvdinv+0x249c>
mov    %rbx,%r15
movslq %ebx,%rsi
mov    %rsi,%rax
neg    %rax
mov    %rax,0x120(%rsp)
lea    -0x1(%rsi),%rax
lea    0x0(,%rsi,8),%r9
mov    %rax,0x70(%rsp)
imul   %rsi,%rax
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
mov    %r9,%r11
neg    %r11
lea    (%rsi,%rsi,1),%r13
mov    %rsi,%r14
shl    $0x4,%r14
mov    0x48(%rsp),%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,0xa0(%rsp)
lea    (%rcx,%rax,8),%r10
add    $0x8,%r10
mov    $0xfffffffffffffff8,%rbp
xorpd  %xmm0,%xmm0
mov    %rsi,0x8(%rsp)
mov    %rsi,%rdi
mov    %r9,0x28(%rsp)
mov    %r11,0xf0(%rsp)
jmp    1fd0 <dsvdinv+0xe90>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdi
mov    %edi,%eax
imul   %r15d,%eax
cltq
add    %rdi,%rax
mov    0x48(%rsp),%rcx
movabs $0x3ff0000000000000,%rsi
mov    %rsi,(%rcx,%rax,8)
movsd  (%r12,%rdi,8),%xmm12
addq   $0xffffffffffffffff,0x70(%rsp)
add    %r11,%rdx
addq   $0xfffffffffffffff8,0xa0(%rsp)
add    $0xfffffffffffffff8,%rbp
add    %r11,%r10
mov    %edi,%eax
mov    %edi,0x38(%rsp)
test   %edi,%edi
je     2382 <dsvdinv+0x1242>
mov    %rdi,%rax
lea    -0x1(%rdi),%rcx
mov    %rcx,0x20(%rsp)
cmp    0x8(%rsp),%rdi
jge    1f80 <dsvdinv+0xe40>
mov    %rbp,0x60(%rsp)
ucomisd %xmm0,%xmm12
jne    1ff5 <dsvdinv+0xeb5>
jnp    2290 <dsvdinv+0x1150>
mov    0x38(%rsp),%eax
cmp    0x98(%rsp),%eax
jge    2290 <dsvdinv+0x1150>
mov    0x20(%rsp),%rbp
mov    0x8(%rsp),%rdi
imul   %rdi,%rbp
movslq 0x38(%rsp),%rsi
add    %rsi,%rbp
mov    %rdi,%rcx
imul   %rsi,%rcx
mov    0x70(%rsp),%rax
mov    %rcx,0xd0(%rsp)
add    %rcx,%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rsi,0x18(%rsp)
mov    %rsi,%rcx
mov    0x10(%rsp),%rsi
mov    0x28(%rsp),%rbx
xchg   %ax,%ax
movsd  (%rdx,%rcx,8),%xmm1
divsd  (%rsi,%rbp,8),%xmm1
divsd  %xmm12,%xmm1
movsd  %xmm1,(%rax)
add    $0x1,%rcx
add    %rbx,%rax
cmp    %rcx,%rdi
jne    2050 <dsvdinv+0xf10>
mov    %rbp,0xc8(%rsp)
mov    0x38(%rsp),%eax
cmp    0x98(%rsp),%eax
jge    2290 <dsvdinv+0x1150>
mov    0x8(%rsp),%rax
mov    %rax,%rbp
mov    0x18(%rsp),%r11
sub    %r11,%rbp
mov    %r11,%rcx
not    %rcx
add    %rax,%rcx
mov    %rcx,0x50(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rax
mov    0xd0(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x80(%rsp)
mov    0x48(%rsp),%r15
lea    (%r15,%r11,8),%r8
mov    %r10,0x88(%rsp)
jmp    210a <dsvdinv+0xfca>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    $0x8,%r15
add    $0x8,%r8
cmp    0x8(%rsp),%r11
mov    0x90(%rsp),%r12
mov    %r10,%rbp
mov    0x88(%rsp),%r10
je     2290 <dsvdinv+0x1150>
xorpd  %xmm2,%xmm2
mov    0x18(%rsp),%rbx
mov    %rbx,%r9
test   $0x1,%bpl
je     2150 <dsvdinv+0x1010>
mov    0x10(%rsp),%rax
mov    0xc8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0xd0(%rsp),%rax
add    %r11,%rax
mov    0x48(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x40(%rsp),%r9
movapd %xmm1,%xmm2
cmpq   $0x0,0x50(%rsp)
mov    0x8(%rsp),%rdi
je     21af <dsvdinv+0x106f>
mov    %rdi,%rax
imul   %r9,%rax
lea    (%r15,%rax,8),%rax
lea    0x1(%r9),%rcx
imul   %rdi,%rcx
lea    (%r15,%rcx,8),%rcx
mov    %rbx,%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%r9,8),%xmm3
mulsd  (%rax,%rsi,8),%xmm3
movsd  0x8(%rdx,%r9,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%r9
add    %r13,%rsi
movapd %xmm1,%xmm2
cmp    %r9,%rdi
jne    2180 <dsvdinv+0x1040>
mov    %rbx,%rdi
mov    %rbp,%r10
test   $0x1,%bpl
je     21eb <dsvdinv+0x10ab>
mov    0xd0(%rsp),%rax
add    %r11,%rax
mov    0x48(%rsp),%rcx
mov    0x80(%rsp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0x40(%rsp),%rdi
cmpq   $0x0,0x50(%rsp)
je     20e0 <dsvdinv+0xfa0>
mov    0x8(%rsp),%rbp
mov    %rbp,%rbx
sub    %rdi,%rbx
mov    %rbp,%rax
imul   %rdi,%rax
lea    (%r11,%rax,1),%rcx
mov    0x48(%rsp),%r9
lea    (%r9,%rcx,8),%rsi
add    0x70(%rsp),%rax
lea    (%r9,%rax,8),%rax
lea    0x1(%rdi),%rcx
imul   %rbp,%rcx
lea    (%r8,%rcx,8),%rcx
lea    0x10(,%rdi,8),%rdi
imul   %rbp,%rdi
add    0xa0(%rsp),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rbp,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rbp,1),%xmm2
movsd  %xmm2,(%rsi,%rbp,1)
movsd  (%rdi,%rbp,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rbp,1),%xmm2
movsd  %xmm2,(%rcx,%rbp,1)
add    %r14,%rbp
add    $0xfffffffffffffffe,%rbx
jne    2250 <dsvdinv+0x1110>
jmp    20e0 <dsvdinv+0xfa0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x98(%rsp),%rax
mov    %rax,%r15
cmp    %eax,0x38(%rsp)
mov    0x68(%rsp),%r8
mov    0x28(%rsp),%r9
mov    0xf0(%rsp),%r11
mov    0x60(%rsp),%rbp
jge    1f80 <dsvdinv+0xe40>
mov    0x38(%rsp),%ecx
movslq %ecx,%rax
mov    %r15d,%esi
sub    %ecx,%esi
mov    %rax,%rcx
test   $0x1,%sil
je     2308 <dsvdinv+0x11c8>
mov    0x20(%rsp),%rbx
mov    %rbx,%rcx
mov    0x8(%rsp),%rdi
imul   %rdi,%rcx
mov    %rax,%rsi
imul   %rdi,%rsi
add    %rbx,%rsi
mov    0x48(%rsp),%rdi
movq   $0x0,(%rdi,%rsi,8)
add    %rax,%rcx
movq   $0x0,(%rdi,%rcx,8)
lea    0x1(%rax),%rcx
not    %rax
cmp    0x120(%rsp),%rax
mov    0x8(%rsp),%rbx
je     1f80 <dsvdinv+0xe40>
lea    0x10(,%rcx,8),%rax
imul   %rbx,%rax
mov    0x48(%rsp),%rdi
add    %rdi,%rax
lea    0x8(,%rcx,8),%rsi
imul   %rbx,%rsi
add    %rdi,%rsi
mov    %rbp,%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rsi,%rdi,1)
movq   $0x0,-0x8(%r10,%rcx,8)
movq   $0x0,(%rax,%rdi,1)
movq   $0x0,(%r10,%rcx,8)
add    $0x2,%rcx
add    %r14,%rdi
cmp    %rcx,%rbx
jne    2350 <dsvdinv+0x1210>
jmp    1f80 <dsvdinv+0xe40>
mov    %r15,%r12
test   %r12d,%r12d
je     35c2 <dsvdinv+0x2482>
mov    %r12d,%eax
imul   %r12d,%eax
mov    %eax,0x150(%rsp)
mov    %r12d,%eax
not    %eax
mov    %eax,0x180(%rsp)
lea    -0x1(%r12),%eax
mov    %eax,0xb8(%rsp)
cltq
mov    %rax,0x50(%rsp)
add    $0x1,%rax
mov    0x8(%rsp),%rdx
imul   %rdx,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
add    $0xfffffffffffffff8,%rbx
mov    %r9,%rsi
xor    $0xfffffffffffffff8,%rsi
mov    %rsi,0xf0(%rsp)
mov    %rdx,%r11
shl    $0x5,%r11
lea    -0x1(%rdx),%rsi
mov    %rsi,0x70(%rsp)
lea    -0x8(%rcx),%rsi
mov    %rsi,0xd0(%rsp)
lea    (%rcx,%rax,8),%rax
mov    %rax,0x20(%rsp)
xor    %r15d,%r15d
movb   $0x1,0x60(%rsp)
movq   $0xfffffffffffffff8,0x80(%rsp)
xorpd  %xmm3,%xmm3
mov    %rcx,0xc8(%rsp)
mov    %r11,0x120(%rsp)
jmp    24bb <dsvdinv+0x137b>
cs nopw 0x0(%rax,%rax,1)
mov    0x88(%rsp),%rdx
mov    %edx,%eax
imul   %r12d,%eax
cltq
add    %rdx,%rax
movsd  0x0(%r13,%rax,8),%xmm0
addsd  0x1ba6(%rip),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
addq   $0xffffffffffffffff,0x50(%rsp)
mov    0xf0(%rsp),%rax
add    %rax,%rbx
addb   $0x1,0x60(%rsp)
addq   $0xfffffffffffffff8,0x80(%rsp)
addq   $0xffffffffffffffff,0x70(%rsp)
addq   $0xfffffffffffffff8,0xc8(%rsp)
addq   $0xfffffffffffffff8,0xd0(%rsp)
add    %rax,0x20(%rsp)
mov    0x38(%rsp),%r15
cmp    %r12d,%r15d
mov    0x90(%rsp),%r10
je     287d <dsvdinv+0x173d>
mov    %rdx,%r13
lea    0x1(%r15),%eax
mov    %rax,0x38(%rsp)
lea    -0x1(%rdx),%rax
mov    %rax,0x88(%rsp)
movsd  -0x8(%r8,%rdx,8),%xmm1
mov    0x8(%rsp),%rbp
cmp    %rbp,%rdx
jge    26d0 <dsvdinv+0x1590>
lea    -0x1(%r15),%eax
lea    0x8(,%rax,8),%rdx
mov    %r15d,%eax
imul   0x180(%rsp),%eax
add    0x150(%rsp),%eax
cltq
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
movsd  %xmm1,0x18(%rsp)
call   1040 <memset@plt>
movsd  0x18(%rsp),%xmm1
xorpd  %xmm3,%xmm3
mov    0x120(%rsp),%r11
mov    0x28(%rsp),%r9
mov    0x68(%rsp),%r8
ucomisd %xmm3,%xmm1
jne    2546 <dsvdinv+0x1406>
jnp    27a0 <dsvdinv+0x1660>
movsd  0x1aba(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    0x88(%rsp),%rcx
mov    %ecx,%eax
imul   %r12d,%eax
movslq %eax,%rdx
add    %rcx,%rdx
mov    %r13,%rax
imul   %rbp,%rax
mov    %rax,0x18(%rsp)
add    %rcx,%rax
mov    %rax,0xa0(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rdi
mov    0xc8(%rsp),%r11
mov    %r13,%rsi
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    %r13,%rbp
test   $0x1,%r15b
je     25d5 <dsvdinv+0x1495>
mov    0x10(%rsp),%rcx
mov    0xa0(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm1
mov    0x18(%rsp),%rax
add    %rsi,%rax
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm3,%xmm1
mov    0x40(%rsp),%rbp
cmp    $0x1,%r15d
je     2658 <dsvdinv+0x1518>
mov    0x98(%rsp),%rax
mov    %eax,%ecx
sub    %ebp,%ecx
mov    0x8(%rsp),%r10
mov    %rdx,%r9
mov    %r10,%rdx
imul   %rbp,%rdx
lea    (%rsi,%rdx,1),%rax
mov    0x10(%rsp),%r8
lea    (%r8,%rax,8),%rax
add    0x70(%rsp),%rdx
lea    (%r8,%rdx,8),%r8
mov    %r9,%rdx
lea    0x10(,%rbp,8),%r9
imul   %r10,%r9
lea    (%r11,%r9,1),%r12
add    0xd0(%rsp),%r9
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%r10,1),%xmm2
mulsd  (%rax,%r10,1),%xmm2
addsd  %xmm1,%xmm2
movsd  (%r9,%r10,1),%xmm1
mulsd  (%r12,%r10,1),%xmm1
addsd  %xmm2,%xmm1
add    %r14,%r10
add    $0xfffffffe,%ecx
jne    2630 <dsvdinv+0x14f0>
mov    0x10(%rsp),%rax
divsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
xor    %eax,%eax
mov    0x50(%rsp),%rcx
mov    0x8(%rsp),%rbp
mov    0x28(%rsp),%r9
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rax,1),%xmm2
movsd  %xmm2,(%rdi,%rax,1)
add    $0x1,%rcx
add    %r9,%rax
cmp    %rbp,%rcx
jl     2680 <dsvdinv+0x1540>
add    $0x1,%rsi
add    $0x8,%r11
add    $0x8,%rdi
mov    0x98(%rsp),%r12
cmp    %r12d,%esi
mov    0x68(%rsp),%r8
jne    25a0 <dsvdinv+0x1460>
mov    0x120(%rsp),%r11
jmp    26e8 <dsvdinv+0x15a8>
nopl   0x0(%rax,%rax,1)
ucomisd %xmm3,%xmm1
jne    26dc <dsvdinv+0x159c>
jnp    27a0 <dsvdinv+0x1660>
movsd  0x1924(%rip),%xmm0
divsd  %xmm1,%xmm0
cmp    %rbp,%r13
mov    0x10(%rsp),%r13
jg     2440 <dsvdinv+0x1300>
mov    0x50(%rsp),%rdx
test   $0x1,%r15b
jne    272d <dsvdinv+0x15ed>
mov    0x50(%rsp),%rcx
mov    %rcx,%rax
imul   0x8(%rsp),%rax
add    0x88(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
lea    0x1(%rcx),%rdx
test   %r15d,%r15d
je     2440 <dsvdinv+0x1300>
mov    %r12d,%eax
sub    %edx,%eax
lea    0x8(,%rdx,8),%rcx
mov    0x8(%rsp),%rsi
imul   %rsi,%rcx
add    %r13,%rcx
lea    0x10(,%rdx,8),%rdx
imul   %rsi,%rdx
add    %r13,%rdx
mov    0x80(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rsi,1)
movsd  (%rdx,%rsi,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rsi,1)
add    %r14,%rsi
add    $0xfffffffe,%eax
jne    2770 <dsvdinv+0x1630>
jmp    2440 <dsvdinv+0x1300>
nopl   0x0(%rax)
cmp    %rbp,%r13
mov    0x10(%rsp),%r13
jg     2440 <dsvdinv+0x1300>
mov    0x50(%rsp),%rsi
testb  $0x3,0x38(%rsp)
je     27ea <dsvdinv+0x16aa>
movzbl 0x60(%rsp),%eax
and    $0x3,%eax
neg    %eax
mov    %rbx,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movq   $0x0,(%rdx)
add    $0xffffffffffffffff,%rcx
add    %r9,%rdx
cmp    %ecx,%eax
jne    27d0 <dsvdinv+0x1690>
mov    0x50(%rsp),%rsi
sub    %rcx,%rsi
cmp    $0x3,%r15d
jb     2440 <dsvdinv+0x1300>
mov    %r12d,%eax
sub    %esi,%eax
lea    0x20(,%rsi,8),%rcx
mov    0x8(%rsp),%rbp
imul   %rbp,%rcx
add    %r13,%rcx
lea    0x18(,%rsi,8),%rdx
imul   %rbp,%rdx
add    %r13,%rdx
lea    0x8(,%rsi,8),%rdi
imul   %rbp,%rdi
add    %r13,%rdi
lea    0x10(,%rsi,8),%rsi
imul   %rbp,%rsi
add    %r13,%rsi
mov    0x80(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   $0x0,(%rdi,%rbp,1)
movq   $0x0,(%rsi,%rbp,1)
movq   $0x0,(%rdx,%rbp,1)
movq   $0x0,(%rcx,%rbp,1)
add    %r11,%rbp
add    $0xfffffffc,%eax
jne    2850 <dsvdinv+0x1710>
jmp    2440 <dsvdinv+0x1300>
test   %r12d,%r12d
je     35d1 <dsvdinv+0x2491>
movabs $0xffffffff00000000,%rax
ff ff ff
mov    %r12d,%ecx
lea    -0x1(%rcx),%rdx
mov    %rdx,0x88(%rsp)
mov    %rcx,0x40(%rsp)
mov    %ecx,%esi
and    $0xfffffffe,%esi
mov    0x8(%rsp),%rcx
mov    %rcx,%rdx
imul   %rax,%rdx
mov    %rdx,0x148(%rsp)
lea    (%r8,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rsp)
lea    (%r10,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
mov    $0x1,%eax
sub    %r12d,%eax
mov    %rax,0xc8(%rsp)
mov    0x48(%rsp),%rax
lea    (%r14,%rax,1),%rdx
add    $0xfffffffffffffff8,%rdx
lea    -0x8(%rax,%rcx,8),%rax
movapd 0x170f(%rip),%xmm7
xorpd  %xmm8,%xmm8
movapd 0x1711(%rip),%xmm10
movapd 0x16f8(%rip),%xmm11
mov    0xb8(%rsp),%edi
mov    %edi,0x138(%rsp)
mov    %rcx,%rbx
mov    %rsi,0x60(%rsp)
mov    %rax,0x108(%rsp)
mov    %rdx,0x178(%rsp)
lea    -0x1(%rbx),%rax
mov    %rax,0x118(%rsp)
mov    %rbx,0xc0(%rsp)
lea    -0x2(%rbx),%rax
mov    %rax,0x80(%rsp)
movl   $0x0,0x140(%rsp)
jmp    29a6 <dsvdinv+0x1866>
nopl   0x0(%rax,%rax,1)
movapd %xmm13,%xmm14
mov    0x90(%rsp),%r10
mov    0x38(%rsp),%rax
movq   $0x0,(%rax,%rdi,8)
mov    0x118(%rsp),%rax
movsd  %xmm12,(%r10,%rax,8)
movsd  %xmm14,(%r8,%rax,8)
addl   $0x1,0x140(%rsp)
01
mov    0x138(%rsp),%eax
mov    0x148(%rsp),%r13
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rdi
mov    %r13,%r12
mov    %eax,%ebp
mov    0x38(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
movsd  0xe8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    2a40 <dsvdinv+0x1900>
cmp    %edi,0xc8(%rsp)
je     2a40 <dsvdinv+0x1900>
mov    0x20(%rsp),%rax
movsd  -0x8(%rax,%rdi,8),%xmm0
andpd  %xmm7,%xmm0
lea    -0x1(%rdi),%rcx
movabs $0x100000000,%rax
lea    (%r12,%rax,1),%r13
lea    -0x1(%rbp),%eax
movsd  0xe8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     29c0 <dsvdinv+0x1880>
movabs $0x100000000,%rcx
sub    %r13,%rcx
sar    $0x20,%rcx
cmp    0xc0(%rsp),%rcx
jle    2b50 <dsvdinv+0x1a10>
mov    0x118(%rsp),%rbx
movsd  (%r8,%rbx,8),%xmm2
test   %edi,%edi
je     34a0 <dsvdinv+0x2360>
cmpl   $0x1d,0x140(%rsp)
1d
mov    0x10(%rsp),%r15
je     35bb <dsvdinv+0x247b>
mov    0x20(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm13
mov    0xc0(%rsp),%rcx
movsd  -0x10(%r8,%rcx,8),%xmm12
mov    0x90(%rsp),%rax
movsd  -0x10(%rax,%rcx,8),%xmm4
movsd  (%rax,%rbx,8),%xmm3
movapd %xmm12,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm2,%xmm1
addsd  %xmm12,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm3,%xmm0
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm3,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm12,%xmm0
divsd  %xmm0,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm7,%xmm5
ucomisd 0x1527(%rip),%xmm5
jbe    2b20 <dsvdinv+0x19e0>
movsd  0x151d(%rip),%xmm1
movapd %xmm1,%xmm0
divsd  %xmm5,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     2d30 <dsvdinv+0x1bf0>
sqrtsd %xmm0,%xmm0
mulsd  %xmm0,%xmm5
jmp    2e59 <dsvdinv+0x1d19>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  0x14d8(%rip),%xmm0
ucomisd %xmm8,%xmm0
jb     2dd0 <dsvdinv+0x1c90>
xorps  %xmm5,%xmm5
sqrtsd %xmm0,%xmm5
jmp    2e59 <dsvdinv+0x1d19>
nopw   0x0(%rax,%rax,1)
neg    %r13
sar    $0x20,%r13
movslq %ebp,%rbx
shl    $0x3,%rbx
movslq %eax,%r15
xorpd  %xmm5,%xmm5
movsd  0x149b(%rip),%xmm4
mov    %rdi,0x110(%rsp)
jmp    2b96 <dsvdinv+0x1a56>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x8,%rbx
cmp    0xc0(%rsp),%r13
jge    2a40 <dsvdinv+0x1900>
movsd  (%r10,%r13,8),%xmm0
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm5
movsd  %xmm5,(%r10,%r13,8)
movapd %xmm4,%xmm1
andpd  %xmm7,%xmm1
movsd  0xe8(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jae    2a40 <dsvdinv+0x1900>
movsd  (%r8,%r13,8),%xmm5
movapd %xmm5,%xmm0
andpd  %xmm7,%xmm0
ucomisd %xmm0,%xmm1
jbe    2c00 <dsvdinv+0x1ac0>
divsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm0
addsd  0x141f(%rip),%xmm0
movapd %xmm1,%xmm2
ucomisd %xmm8,%xmm0
jb     2c2f <dsvdinv+0x1aef>
sqrtsd %xmm0,%xmm0
jmp    2c9c <dsvdinv+0x1b5c>
nopl   (%rax)
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm5
jne    2c10 <dsvdinv+0x1ad0>
jnp    2ca0 <dsvdinv+0x1b60>
movapd %xmm0,%xmm2
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm1
addsd  0x13e4(%rip),%xmm1
movapd %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jae    2bf4 <dsvdinv+0x1ab4>
movapd %xmm4,0x50(%rsp)
movapd %xmm5,0x70(%rsp)
movsd  %xmm2,0xd0(%rsp)
call   1060 <sqrt@plt>
movsd  0xd0(%rsp),%xmm2
movapd 0x70(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
mov    0x90(%rsp),%r10
mov    0x110(%rsp),%rdi
movapd 0x1399(%rip),%xmm11
movapd 0x13a0(%rip),%xmm10
xorpd  %xmm8,%xmm8
movapd 0x1383(%rip),%xmm7
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0x68(%rsp),%r8
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r8,%r13,8)
movsd  0x135a(%rip),%xmm0
divsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm5
xorpd  0x1362(%rip),%xmm4
mulsd  %xmm0,%xmm4
cmpl   $0x0,0x98(%rsp)
jle    2b80 <dsvdinv+0x1a40>
mov    0x40(%rsp),%rax
mov    0x10(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%r15,8),%xmm0
movsd  (%rcx,%rbx,1),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
mulsd  %xmm5,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rbx,1)
add    %r9,%rcx
add    $0xffffffffffffffff,%rax
jne    2ce0 <dsvdinv+0x1ba0>
jmp    2b80 <dsvdinv+0x1a40>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdi,%rbx
movapd %xmm12,0x50(%rsp)
movsd  %xmm13,0x70(%rsp)
movapd %xmm2,0xd0(%rsp)
movsd  %xmm3,0x18(%rsp)
movapd %xmm4,0xa0(%rsp)
movapd %xmm5,0xf0(%rsp)
call   1060 <sqrt@plt>
movapd 0xf0(%rsp),%xmm5
movapd 0xa0(%rsp),%xmm4
movsd  0x18(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm2
movsd  0x70(%rsp),%xmm13
movapd 0x50(%rsp),%xmm12
mov    %rbx,%rdi
movapd 0x126e(%rip),%xmm11
movapd 0x1275(%rip),%xmm10
xorpd  %xmm8,%xmm8
movapd 0x1258(%rip),%xmm7
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0x68(%rsp),%r8
mulsd  %xmm0,%xmm5
jmp    2e59 <dsvdinv+0x1d19>
mov    %rdi,%rbx
movapd %xmm12,0x50(%rsp)
movsd  %xmm13,0x70(%rsp)
movapd %xmm2,0xd0(%rsp)
movsd  %xmm3,0x18(%rsp)
movapd %xmm4,0xa0(%rsp)
call   1060 <sqrt@plt>
movapd 0xa0(%rsp),%xmm4
movsd  0x18(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm2
movsd  0x70(%rsp),%xmm13
movapd 0x50(%rsp),%xmm12
mov    %rbx,%rdi
movapd 0x11e0(%rip),%xmm11
movapd 0x11e7(%rip),%xmm10
xorpd  %xmm8,%xmm8
movapd 0x11ca(%rip),%xmm7
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0x68(%rsp),%r8
movapd %xmm0,%xmm5
movapd %xmm13,%xmm0
subsd  %xmm2,%xmm0
addsd  %xmm13,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm5,%xmm0
andpd  %xmm7,%xmm0
orpd   0x11a5(%rip),%xmm5
xorpd  %xmm1,%xmm1
cmpnlesd %xmm4,%xmm1
andpd  %xmm1,%xmm5
andnpd %xmm0,%xmm1
orpd   %xmm5,%xmm1
addsd  %xmm4,%xmm1
divsd  %xmm1,%xmm12
subsd  %xmm3,%xmm12
mulsd  %xmm3,%xmm12
addsd  %xmm2,%xmm12
divsd  %xmm13,%xmm12
movabs $0xffffffff00000000,%rdx
ff ff ff
sub    %r12,%rdx
sar    $0x20,%rdx
cmp    0x80(%rsp),%rdx
jg     2970 <dsvdinv+0x1830>
movslq %ebp,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,1),%r10
mov    0x48(%rsp),%rcx
lea    (%rcx,%r10,8),%rbx
mov    %r15,%rbp
lea    (%rcx,%rax,8),%r13
lea    (%r15,%r10,8),%r12
lea    (%r15,%rax,8),%r15
movsd  0x110f(%rip),%xmm15
movapd %xmm15,%xmm6
mov    0x90(%rsp),%r10
jmp    2f7a <dsvdinv+0x1e3a>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rax
mulsd  %xmm13,%xmm5
mulsd  %xmm12,%xmm15
subsd  %xmm5,%xmm15
mulsd  %xmm12,%xmm14
movapd %xmm14,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm0,%xmm12
mulsd  %xmm15,%xmm12
addsd  %xmm1,%xmm12
mulsd  %xmm6,%xmm15
mulsd  %xmm0,%xmm14
subsd  %xmm15,%xmm14
add    $0x8,%rbx
add    $0x8,%r13
add    $0x8,%r12
add    $0x8,%r15
movapd %xmm14,%xmm13
movapd %xmm0,%xmm15
cmp    0x80(%rsp),%rdx
mov    %rax,%rdx
jge    297d <dsvdinv+0x183d>
movsd  0x8(%r10,%rdx,8),%xmm9
movsd  0x8(%r8,%rdx,8),%xmm14
mulsd  %xmm9,%xmm6
movapd %xmm12,%xmm1
andpd  %xmm11,%xmm1
movapd %xmm6,%xmm0
andpd  %xmm11,%xmm0
ucomisd %xmm0,%xmm1
jbe    2fd0 <dsvdinv+0x1e90>
divsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm0
addsd  0x1052(%rip),%xmm0
movapd %xmm1,%xmm2
ucomisd %xmm8,%xmm0
jb     2fff <dsvdinv+0x1ebf>
sqrtsd %xmm0,%xmm0
jmp    30c6 <dsvdinv+0x1f86>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm6
jne    2fe0 <dsvdinv+0x1ea0>
jnp    30ca <dsvdinv+0x1f8a>
movapd %xmm0,%xmm2
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm1
addsd  0x1014(%rip),%xmm1
movapd %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jae    2fc1 <dsvdinv+0x1e81>
mov    %rdi,%rbp
movapd %xmm12,0x50(%rsp)
movsd  %xmm13,0x70(%rsp)
mov    %rdx,0xd0(%rsp)
movsd  %xmm14,0x18(%rsp)
movsd  %xmm15,0xa0(%rsp)
movapd %xmm6,0xf0(%rsp)
movsd  %xmm9,0x120(%rsp)
movapd %xmm2,0x150(%rsp)
call   1060 <sqrt@plt>
movapd 0x150(%rsp),%xmm2
movsd  0x120(%rsp),%xmm9
movapd 0xf0(%rsp),%xmm6
movsd  0xa0(%rsp),%xmm15
movsd  0x18(%rsp),%xmm14
mov    0xd0(%rsp),%rdx
movsd  0x70(%rsp),%xmm13
movapd 0x50(%rsp),%xmm12
mov    0x90(%rsp),%r10
mov    %rbp,%rdi
movapd 0xf6f(%rip),%xmm11
movapd 0xf76(%rip),%xmm10
xorpd  %xmm8,%xmm8
movapd 0xf59(%rip),%xmm7
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0x68(%rsp),%r8
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r10,%rdx,8)
unpcklpd %xmm6,%xmm12
unpcklpd %xmm2,%xmm2
divpd  %xmm2,%xmm12
movapd %xmm12,%xmm5
unpckhpd %xmm12,%xmm5
cmpl   $0x0,0x98(%rsp)
jle    31c5 <dsvdinv+0x2085>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x0,0x88(%rsp)
je     3370 <dsvdinv+0x2230>
xor    %ecx,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%r13,%rcx,1),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm10,%xmm2
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
movapd %xmm5,%xmm2
shufpd $0x1,%xmm5,%xmm2
mulpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,0x0(%r13,%rcx,1)
movupd (%rbx,%rcx,1),%xmm1
movapd %xmm1,%xmm3
xorpd  %xmm10,%xmm3
movapd %xmm1,%xmm4
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%rbx,%rcx,1)
add    $0x2,%rax
add    %r14,%rcx
cmp    %rax,%rsi
jne    3120 <dsvdinv+0x1fe0>
testb  $0x1,0x40(%rsp)
je     31c5 <dsvdinv+0x2085>
imul   0x8(%rsp),%rax
add    %rdx,%rax
mov    0x48(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm0
xorpd  0xe6d(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm2,%xmm0
movupd %xmm0,(%rcx,%rax,8)
mulsd  %xmm9,%xmm15
movapd %xmm15,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm13,%xmm2
mulsd  %xmm12,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm14,%xmm3
mulsd  %xmm5,%xmm3
movapd %xmm2,%xmm4
andpd  %xmm11,%xmm4
movapd %xmm3,%xmm0
andpd  %xmm11,%xmm0
ucomisd %xmm0,%xmm4
jbe    3230 <dsvdinv+0x20f0>
divsd  %xmm4,%xmm0
mulsd  %xmm0,%xmm0
addsd  0xdf6(%rip),%xmm0
ucomisd %xmm8,%xmm0
jb     3260 <dsvdinv+0x2120>
sqrtsd %xmm0,%xmm0
jmp    3337 <dsvdinv+0x21f7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomisd %xmm8,%xmm3
jne    323d <dsvdinv+0x20fd>
jnp    3382 <dsvdinv+0x2242>
movapd %xmm0,%xmm1
divsd  %xmm0,%xmm4
mulsd  %xmm4,%xmm4
addsd  0xdb7(%rip),%xmm4
movapd %xmm4,%xmm0
movapd %xmm1,%xmm4
ucomisd %xmm8,%xmm0
jae    3219 <dsvdinv+0x20d9>
mov    %rdi,%rbp
movapd %xmm12,0x50(%rsp)
movsd  %xmm13,0x70(%rsp)
mov    %rdx,0xd0(%rsp)
movsd  %xmm14,0x18(%rsp)
movsd  %xmm15,0xa0(%rsp)
movapd %xmm5,0xf0(%rsp)
movapd %xmm2,0x120(%rsp)
movapd %xmm3,0x150(%rsp)
movapd %xmm4,0x180(%rsp)
call   1060 <sqrt@plt>
movapd 0x180(%rsp),%xmm4
movapd 0x150(%rsp),%xmm3
movapd 0x120(%rsp),%xmm2
movapd 0xf0(%rsp),%xmm5
movsd  0xa0(%rsp),%xmm15
movsd  0x18(%rsp),%xmm14
mov    0xd0(%rsp),%rdx
movsd  0x70(%rsp),%xmm13
movapd 0x50(%rsp),%xmm12
mov    0x90(%rsp),%r10
mov    %rbp,%rdi
movapd 0xcfe(%rip),%xmm11
movapd 0xd05(%rip),%xmm10
xorpd  %xmm8,%xmm8
movapd 0xce8(%rip),%xmm7
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0x68(%rsp),%r8
mulsd  %xmm0,%xmm4
movsd  %xmm4,(%r8,%rdx,8)
ucomisd %xmm8,%xmm4
movapd %xmm12,%xmm0
jne    334f <dsvdinv+0x220f>
jnp    3390 <dsvdinv+0x2250>
movsd  0xcb1(%rip),%xmm0
divsd  %xmm4,%xmm0
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
mulpd  %xmm2,%xmm0
jmp    3390 <dsvdinv+0x2250>
nopl   0x0(%rax)
xor    %eax,%eax
testb  $0x1,0x40(%rsp)
jne    3190 <dsvdinv+0x2050>
jmp    31c5 <dsvdinv+0x2085>
movq   $0x0,(%r8,%rdx,8)
movapd %xmm12,%xmm0
nop
movapd %xmm0,%xmm6
unpckhpd %xmm0,%xmm6
cmpl   $0x0,0x98(%rsp)
jle    2f10 <dsvdinv+0x1dd0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x88(%rsp)
je     3440 <dsvdinv+0x2300>
movapd %xmm5,%xmm9
xor    %ecx,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rcx,1),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm10,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
movapd %xmm6,%xmm3
shufpd $0x1,%xmm6,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%r15,%rcx,1)
movupd (%r12,%rcx,1),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm10,%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm4,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,(%r12,%rcx,1)
add    $0x2,%rax
add    %r14,%rcx
cmp    %rax,%rsi
jne    33d0 <dsvdinv+0x2290>
jmp    3447 <dsvdinv+0x2307>
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm9
xor    %eax,%eax
testb  $0x1,0x40(%rsp)
movapd %xmm9,%xmm5
je     2f10 <dsvdinv+0x1dd0>
imul   0x8(%rsp),%rax
add    %rdx,%rax
mov    0x10(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm2
movapd %xmm2,%xmm3
mulpd  %xmm2,%xmm1
xorpd  0xba6(%rip),%xmm2
shufpd $0x1,%xmm2,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%rax,8)
jmp    2f10 <dsvdinv+0x1dd0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm2,%xmm8
mov    0x98(%rsp),%rbp
mov    0x10(%rsp),%r13
mov    0x178(%rsp),%rdx
jbe    3560 <dsvdinv+0x2420>
xorpd  0xb58(%rip),%xmm2
movlpd %xmm2,(%r8,%rbx,8)
test   %ebp,%ebp
jle    3560 <dsvdinv+0x2420>
cmpq   $0x0,0x88(%rsp)
je     35ac <dsvdinv+0x246c>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x108(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,1),%xmm0
xorpd  %xmm10,%xmm0
movlpd %xmm0,(%rdi,%rcx,1)
movsd  (%rdx,%rcx,1),%xmm0
xorpd  %xmm10,%xmm0
movlpd %xmm0,(%rdx,%rcx,1)
add    $0x2,%rax
add    %r14,%rcx
cmp    %rax,%rsi
jne    3500 <dsvdinv+0x23c0>
testb  $0x1,0x40(%rsp)
je     3560 <dsvdinv+0x2420>
imul   0x8(%rsp),%rax
add    %rbx,%rax
mov    0x48(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0xad4(%rip),%xmm0
movlpd %xmm0,(%rcx,%rax,8)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movabs $0x100000000,%rax
add    %rax,0x148(%rsp)
addq   $0xfffffffffffffff8,0x20(%rsp)
addq   $0xfffffffffffffff8,0x38(%rsp)
addq   $0x1,0xc8(%rsp)
addl   $0xffffffff,0x138(%rsp)
ff
add    $0xfffffffffffffff8,%rdx
mov    0x108(%rsp),%rax
add    $0xfffffffffffffff8,%rax
test   %ebx,%ebx
jne    292e <dsvdinv+0x17ee>
jmp    373c <dsvdinv+0x25fc>
xor    %eax,%eax
testb  $0x1,0x40(%rsp)
jne    3531 <dsvdinv+0x23f1>
jmp    3560 <dsvdinv+0x2420>
xor    %eax,%eax
jmp    372a <dsvdinv+0x25ea>
movl   $0x0,0x34(%rsp)
mov    0x10(%rsp),%r13
jmp    35d9 <dsvdinv+0x2499>
movl   $0x0,0x34(%rsp)
mov    %r12,%rbx
test   %ebx,%ebx
mov    0x1d0(%rsp),%r15
jle    36f7 <dsvdinv+0x25b7>
mov    %rbx,%r12
mov    %r12d,%r14d
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
mov    0x48(%rsp),%rdx
add    $0x8,%rdx
lea    0x0(,%r14,8),%r10
lea    0x8(%r13),%rax
mov    %rax,0x10(%rsp)
xor    %r11d,%r11d
jmp    3630 <dsvdinv+0x24f0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %r10,%rdx
cmp    %r14,%r11
je     36f7 <dsvdinv+0x25b7>
mov    %r11,%r9
imul   %r14,%r9
mov    0x10(%rsp),%rdi
xor    %ebp,%ebp
jmp    3655 <dsvdinv+0x2515>
add    %r11,%rsi
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%rbp
add    %r10,%rdi
cmp    %r14,%rbp
je     3620 <dsvdinv+0x24e0>
cmp    $0x1,%r12d
jne    3670 <dsvdinv+0x2530>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    36b8 <dsvdinv+0x2578>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbx,8),%xmm2
movsd  (%rdx,%rbx,8),%xmm0
mulsd  -0x8(%rdi,%rbx,8),%xmm2
mulsd  (%r8,%rbx,8),%xmm2
mulsd  (%rdi,%rbx,8),%xmm0
mulsd  0x8(%r8,%rbx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rbx
movapd %xmm0,%xmm1
cmp    %rbx,%rcx
jne    3680 <dsvdinv+0x2540>
mov    %rbp,%rsi
imul   %r14,%rsi
test   $0x1,%r14b
je     3640 <dsvdinv+0x2500>
lea    (%rbx,%r9,1),%rax
mov    0x48(%rsp),%r8
movsd  (%r8,%rax,8),%xmm1
mov    0x68(%rsp),%r8
lea    (%rbx,%rsi,1),%rax
mulsd  0x0(%r13,%rax,8),%xmm1
mulsd  (%r8,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    3640 <dsvdinv+0x2500>
mov    0x1c8(%rsp),%rdi
mov    %r8,%rbx
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x34(%rsp),%eax
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   $0x3,%bpl
je     376e <dsvdinv+0x262e>
mov    %ebp,%ecx
and    $0x3,%ecx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    %r8,%rax
movapd %xmm0,%xmm1
movsd  (%rax),%xmm0
maxsd  %xmm1,%xmm0
add    $0x8,%rax
add    $0x1,%rdx
cmp    %edx,%ecx
jne    3750 <dsvdinv+0x2610>
mov    %ebp,%ecx
sub    %edx,%ecx
jmp    3777 <dsvdinv+0x2637>
xorpd  %xmm0,%xmm0
mov    %ebp,%ecx
mov    %r8,%rax
cmpl   $0x3,0xb8(%rsp)
03
jb     37b4 <dsvdinv+0x2674>
mov    %ecx,%ecx
xor    %edx,%edx
movsd  (%rax,%rdx,8),%xmm1
maxsd  %xmm0,%xmm1
movsd  0x8(%rax,%rdx,8),%xmm0
maxsd  %xmm1,%xmm0
movsd  0x10(%rax,%rdx,8),%xmm1
maxsd  %xmm0,%xmm1
movsd  0x18(%rax,%rdx,8),%xmm0
maxsd  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %edx,%ecx
jne    3785 <dsvdinv+0x2645>
test   %ebp,%ebp
je     3827 <dsvdinv+0x26e7>
mulsd  0x840(%rip),%xmm0
cmpl   $0x0,0xb8(%rsp)
je     383d <dsvdinv+0x26fd>
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
xor    %edx,%edx
movsd  0x82f(%rip),%xmm1
mov    %r8,%rax
jmp    37ec <dsvdinv+0x26ac>
movsd  %xmm2,0x8(%rax)
add    $0x10,%rax
add    $0xfffffffe,%ecx
je     3837 <dsvdinv+0x26f7>
movsd  (%rax),%xmm4
xorpd  %xmm2,%xmm2
ucomisd %xmm4,%xmm0
jae    3807 <dsvdinv+0x26c7>
add    $0x1,%edx
movapd %xmm1,%xmm3
divsd  %xmm4,%xmm3
jmp    380b <dsvdinv+0x26cb>
xorpd  %xmm3,%xmm3
movsd  %xmm3,(%rax)
movsd  0x8(%rax),%xmm3
ucomisd %xmm3,%xmm0
jae    37de <dsvdinv+0x269e>
add    $0x1,%edx
movapd %xmm1,%xmm2
divsd  %xmm3,%xmm2
jmp    37de <dsvdinv+0x269e>
movl   $0x0,0x34(%rsp)
mov    %rbp,%rbx
jmp    35dc <dsvdinv+0x249c>
mov    %edx,0x34(%rsp)
jmp    3848 <dsvdinv+0x2708>
movl   $0x0,0x34(%rsp)
mov    %r8,%rax
test   $0x1,%bpl
mov    %rbp,%rbx
je     35dc <dsvdinv+0x249c>
movsd  (%rax),%xmm2
xorpd  %xmm1,%xmm1
ucomisd %xmm2,%xmm0
mov    0x34(%rsp),%ecx
jae    3876 <dsvdinv+0x2736>
add    $0x1,%ecx
movsd  0x796(%rip),%xmm1
divsd  %xmm2,%xmm1
mov    %ecx,0x34(%rsp)
movsd  %xmm1,(%rax)
jmp    35dc <dsvdinv+0x249c>

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

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