int svd(int m, int n, int withu, int withv, double eps, double tol, double *a,
        double *q, double *u, double *v, double *vt) {
  int i, j, k, l, l1, iter, retval;
  double c, f, g, h, s, x, y, z;
  double *e;
  e = (double *)calloc(n, sizeof(double));
  retval = 0;
  for (i = 0; i < m; i++) {
    for (j = 0; j < n; j++)
      u[i * n + j] = a[i * n + j];
  }
  g = x = 0.0;
  for (i = 0; i < n; i++) {
    e[i] = g;
    s = 0.0;
    l = i + 1;
    for (j = i; j < m; j++)
      s += (u[j * n + i] * u[j * n + i]);
    if (s < tol)
      g = 0.0;
    else {
      f = u[i * n + i];
      g = (f < 0) ? sqrt(s) : -sqrt(s);
      h = f * g - s;
      u[i * n + i] = f - g;
      for (j = l; j < n; j++) {
        s = 0.0;
        for (k = i; k < m; k++)
          s += (u[k * n + i] * u[k * n + j]);
        f = s / h;
        for (k = i; k < m; k++)
          u[k * n + j] += (f * u[k * n + i]);
      }
    }
    q[i] = g;
    s = 0.0;
    for (j = l; j < n; j++)
      s += (u[i * n + j] * u[i * n + j]);
    if (s < tol)
      g = 0.0;
    else {
      f = u[i * n + i + 1];
      g = (f < 0) ? sqrt(s) : -sqrt(s);
      h = f * g - s;
      u[i * n + i + 1] = f - g;
      for (j = l; j < n; j++)
        e[j] = u[i * n + j] / h;
      for (j = l; j < m; j++) {
        s = 0.0;
        for (k = l; k < n; k++)
          s += (u[j * n + k] * u[i * n + k]);
        for (k = l; k < n; k++)
          u[j * n + k] += (s * e[k]);
      }
    }
    y = fabs(q[i]) + fabs(e[i]);
    if (y > x)
      x = y;
  }
  if (withv) {
    for (i = n - 1; i >= 0; i--) {
      if (g != 0.0) {
        h = u[i * n + i + 1] * g;
        for (j = l; j < n; j++)
          v[j * n + i] = u[i * n + j] / h;
        for (j = l; j < n; j++) {
          s = 0.0;
          for (k = l; k < n; k++)
            s += (u[i * n + k] * v[k * n + j]);
          for (k = l; k < n; k++)
            v[k * n + j] += (s * v[k * n + i]);
        }
      }
      for (j = l; j < n; j++)
        v[i * n + j] = v[j * n + i] = 0.0;
      v[i * n + i] = 1.0;
      g = e[i];
      l = i;
    }
  }
  if (withu) {
    for (i = n; i < m; i++) {
      for (j = n; j < m; j++)
        u[i * n + j] = 0.0;
      u[i * n + i] = 1.0;
    }
  }
  if (withu) {
    for (i = n - 1; i >= 0; i--) {
      l = i + 1;
      g = q[i];
      for (j = l; j < m; j++)
        u[i * n + j] = 0.0;
      if (g != 0.0) {
        h = u[i * n + i] * g;
        for (j = l; j < m; j++) {
          s = 0.0;
          for (k = l; k < m; k++)
            s += (u[k * n + i] * u[k * n + j]);
          f = s / h;
          for (k = i; k < m; k++)
            u[k * n + j] += (f * u[k * n + i]);
        }
        for (j = i; j < m; j++)
          u[j * n + i] /= g;
      } else {
        for (j = i; j < m; j++)
          u[j * n + i] = 0.0;
      }
      u[i * n + i] += 1.0;
    }
  }
  eps *= x;
  for (k = n - 1; k >= 0; k--) {
    iter = 0;
  test_f_splitting:
    for (l = k; l >= 0; l--) {
      if (fabs(e[l]) <= eps)
        goto test_f_convergence;
      if (fabs(q[l - 1]) <= eps)
        goto cancellation;
    }
  cancellation:
    c = 0.0;
    s = 1.0;
    l1 = l - 1;
    for (i = l; i <= k; i++) {
      f = s * e[i];
      e[i] *= c;
      if (fabs(f) <= eps)
        goto test_f_convergence;
      g = q[i];
      h = q[i] = sqrt(f * f + g * g);
      c = g / h;
      s = -f / h;
      if (withu) {
        for (j = 0; j < m; j++) {
          y = u[j * n + l1];
          z = u[j * n + i];
          u[j * n + l1] = y * c + z * s;
          u[j * n + i] = -y * s + z * c;
        }
      }
    }
  test_f_convergence:
    z = q[k];
    if (l == k)
      goto convergence;
    iter++;
    if (iter > 30) {
      retval = k;
      break;
    }
    x = q[l];
    y = q[k - 1];
    g = e[k - 1];
    h = e[k];
    f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2 * h * y);
    g = sqrt(f * f + 1.0);
    f = ((x - z) * (x + z) + h * (y / ((f < 0) ? (f - g) : (f + g)) - h)) / x;
    c = s = 1.0;
    for (i = l + 1; i <= k; i++) {
      g = e[i];
      y = q[i];
      h = s * g;
      g *= c;
      e[i - 1] = z = sqrt(f * f + h * h);
      c = f / z;
      s = h / z;
      f = x * c + g * s;
      g = -x * s + g * c;
      h = y * s;
      y *= c;
      if (withv) {
        for (j = 0; j < n; j++) {
          x = v[j * n + i - 1];
          z = v[j * n + i];
          v[j * n + i - 1] = x * c + z * s;
          v[j * n + i] = -x * s + z * c;
        }
      }
      q[i - 1] = z = sqrt(f * f + h * h);
      c = f / z;
      s = h / z;
      f = c * g + s * y;
      x = -s * g + c * y;
      if (withu) {
        for (j = 0; j < m; j++) {
          y = u[j * n + i - 1];
          z = u[j * n + i];
          u[j * n + i - 1] = y * c + z * s;
          u[j * n + i] = -y * s + z * c;
        }
      }
    }
    e[l] = 0.0;
    e[k] = f;
    q[k] = x;
    goto test_f_splitting;
  convergence:
    if (z < 0.0) {
      q[k] = -z;
      if (withv) {
        for (j = 0; j < n; j++)
          v[j * n + k] = -v[j * n + k];
      }
    }
  }
  free(e);
  matrix_transpose(m, n, v, vt);
  return retval;
}


x86 assembly (clang, -O0):
<svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movslq -0x8(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1204 <svd+0xc4>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f1 <svd+0xb1>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11ab <svd+0x6b>
jmp    11f6 <svd+0xb6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1198 <svd+0x58>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    179f <svd+0x65f>
movsd  -0x68(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12ab <svd+0x16b>
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1253 <svd+0x113>
movsd  -0x78(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12cc <svd+0x18c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1492 <svd+0x352>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    130c <svd+0x1cc>
movsd  -0x78(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1335 <svd+0x1f5>
movsd  -0x78(%rbp),%xmm0
call   1060 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    148d <svd+0x34d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    140d <svd+0x2cd>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b5 <svd+0x275>
movsd  -0x78(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    147a <svd+0x33a>
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1422 <svd+0x2e2>
jmp    147f <svd+0x33f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    139b <svd+0x25b>
jmp    1492 <svd+0x352>
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    150a <svd+0x3ca>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14b2 <svd+0x372>
movsd  -0x78(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    152b <svd+0x3eb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    172d <svd+0x5ed>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    156e <svd+0x42e>
movsd  -0x78(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1597 <svd+0x457>
movsd  -0x78(%rbp),%xmm0
call   1060 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1645 <svd+0x505>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1600 <svd+0x4c0>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1728 <svd+0x5e8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16bd <svd+0x57d>
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1665 <svd+0x525>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1715 <svd+0x5d5>
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16c3 <svd+0x583>
jmp    171a <svd+0x5da>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    164b <svd+0x50b>
jmp    172d <svd+0x5ed>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x18bf(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x18a4(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x80(%rbp),%xmm0
jbe    178c <svd+0x64c>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
jmp    1791 <svd+0x651>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121b <svd+0xdb>
cmpl   $0x0,-0x10(%rbp)
je     19d9 <svd+0x899>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     19d4 <svd+0x894>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17d9 <svd+0x699>
jp     17d9 <svd+0x699>
jmp    193b <svd+0x7fb>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    184d <svd+0x70d>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1802 <svd+0x6c2>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1936 <svd+0x7f6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18c5 <svd+0x785>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    186d <svd+0x72d>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1923 <svd+0x7e3>
movsd  -0x78(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18cb <svd+0x78b>
jmp    1928 <svd+0x7e8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1853 <svd+0x713>
jmp    193b <svd+0x7fb>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    198d <svd+0x84d>
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1941 <svd+0x801>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x166a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    17b2 <svd+0x672>
jmp    19d9 <svd+0x899>
cmpl   $0x0,-0xc(%rbp)
je     1a5f <svd+0x91f>
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a5a <svd+0x91a>
mov    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a2e <svd+0x8ee>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19fb <svd+0x8bb>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x15c9(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19e9 <svd+0x8a9>
jmp    1a5f <svd+0x91f>
cmpl   $0x0,-0xc(%rbp)
je     1cc2 <svd+0xb82>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1cbd <svd+0xb7d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ad0 <svd+0x990>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a9d <svd+0x95d>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1aed <svd+0x9ad>
jp     1aed <svd+0x9ad>
jmp    1c4e <svd+0xb0e>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c05 <svd+0xac5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b85 <svd+0xa45>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b2d <svd+0x9ed>
movsd  -0x78(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1bf2 <svd+0xab2>
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b9a <svd+0xa5a>
jmp    1bf7 <svd+0xab7>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b13 <svd+0x9d3>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c49 <svd+0xb09>
movsd  -0x68(%rbp),%xmm1
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c0b <svd+0xacb>
jmp    1c8c <svd+0xb4c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c87 <svd+0xb47>
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c54 <svd+0xb14>
jmp    1c8c <svd+0xb4c>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x136b(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1a72 <svd+0x932>
jmp    1cc2 <svd+0xb82>
movsd  -0x80(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     2680 <svd+0x1540>
movl   $0x0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1d6e <svd+0xc2e>
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x12ee(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1d2a <svd+0xbea>
jmp    1f80 <svd+0xe40>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x12bd(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1d5b <svd+0xc1b>
jmp    1d73 <svd+0xc33>
jmp    1d60 <svd+0xc20>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1cf1 <svd+0xbb1>
jmp    1d73 <svd+0xc33>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x128d(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1f7b <svd+0xe3b>
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm1
movaps 0x121d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1dfb <svd+0xcbb>
jmp    1f80 <svd+0xe40>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     1f68 <svd+0xe28>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f63 <svd+0xe23>
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e86 <svd+0xd46>
jmp    1f68 <svd+0xe28>
jmp    1f6d <svd+0xe2d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d97 <svd+0xc57>
jmp    1f80 <svd+0xe40>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jne    1fa6 <svd+0xe66>
jmp    25b8 <svd+0x1478>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x1e,-0x48(%rbp)
jle    1fc4 <svd+0xe84>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    2680 <svd+0x1540>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
addsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
subsd  -0x70(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
addsd  -0x70(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xfb1(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xf7d(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    210d <svd+0xfcd>
movsd  -0x60(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    211f <svd+0xfdf>
movsd  -0x60(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0xd0(%rbp),%xmm4
ff
divsd  %xmm4,%xmm3
subsd  -0x70(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xea2(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xe95(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     2579 <svd+0x1439>
mov    -0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x98(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x10(%rbp)
je     23af <svd+0x126f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    23aa <svd+0x126a>
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    22d0 <svd+0x1190>
jmp    23af <svd+0x126f>
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     2566 <svd+0x1426>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2561 <svd+0x1421>
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    247e <svd+0x133e>
jmp    2566 <svd+0x1426>
jmp    256b <svd+0x142b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2189 <svd+0x1049>
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ceb <svd+0xbab>
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    266d <svd+0x152d>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x10(%rbp)
je     2668 <svd+0x1528>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2663 <svd+0x1523>
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2606 <svd+0x14c6>
jmp    2668 <svd+0x1528>
jmp    266d <svd+0x152d>
jmp    2672 <svd+0x1532>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1cda <svd+0xb9a>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rdx
mov    0x20(%rbp),%rcx
mov    $0x0,%al
call   1050 <matrix_transpose@plt>
mov    -0x4c(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
mov    %r9,0x50(%rsp)
mov    %r8,0x40(%rsp)
movsd  %xmm1,0x118(%rsp)
movsd  %xmm0,0x140(%rsp)
mov    %ecx,0x9c(%rsp)
mov    %edx,0x148(%rsp)
mov    %esi,%ebx
mov    %edi,%ebp
movslq %esi,%rdi
mov    $0x8,%esi
mov    %rdi,0x30(%rsp)
call   1050 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    %rbx,%rax
mov    %ebp,%ecx
mov    %rcx,0xe8(%rsp)
mov    %rbp,0xe0(%rsp)
test   %ebp,%ebp
mov    %rbx,0x18(%rsp)
jle    1434 <svd+0x2e4>
mov    0x30(%rsp),%rcx
mov    %ecx,%r15d
mov    %r15d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x80(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xc0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r12d
and    $0x3,%r12d
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x10(%rsp)
mov    %r15d,%r14d
and    $0x3,%r14d
mov    0x210(%rsp),%r8
lea    0x70(%r8),%rdx
lea    0x0(,%rcx,8),%r13
mov    0x40(%rsp),%rdi
lea    0x70(%rdi),%rsi
lea    0x10(%r8),%rcx
lea    0x10(%rdi),%r10
mov    %r12,0x20(%rsp)
shl    $0x5,%r12
xor    %r9d,%r9d
mov    %r14,0x60(%rsp)
jmp    1274 <svd+0x124>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r13,%rdx
add    %r13,%rsi
add    %r13,%rcx
add    %r13,%r10
add    %r13,%r8
add    %r13,%rdi
cmp    0xe8(%rsp),%r9
je     1434 <svd+0x2e4>
test   %eax,%eax
jle    1250 <svd+0x100>
cmp    $0x4,%eax
jae    1290 <svd+0x140>
xor    %r11d,%r11d
jmp    13b0 <svd+0x260>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9,%rax
imul   0x30(%rsp),%rax
lea    (%rax,%r15,1),%rbp
mov    0x210(%rsp),%r14
lea    (%r14,%rax,8),%r11
mov    0x40(%rsp),%r14
lea    (%r14,%rbp,8),%rbx
cmp    %rbx,%r11
jae    12de <svd+0x18e>
mov    0x210(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
lea    (%r14,%rax,8),%rax
cmp    %rbp,%rax
jae    12de <svd+0x18e>
xor    %r11d,%r11d
mov    0x18(%rsp),%rax
mov    0x60(%rsp),%r14
jmp    13b0 <svd+0x260>
cmpq   $0xc,0xc0(%rsp)
mov    0x60(%rsp),%r14
jae    12f2 <svd+0x1a2>
xor    %ebp,%ebp
jmp    135c <svd+0x20c>
mov    0x10(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x70(%rsi,%rbp,8),%xmm0
movups -0x60(%rsi,%rbp,8),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,8)
movups %xmm1,-0x60(%rdx,%rbp,8)
movups -0x50(%rsi,%rbp,8),%xmm0
movups -0x40(%rsi,%rbp,8),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,8)
movups %xmm1,-0x40(%rdx,%rbp,8)
movups -0x30(%rsi,%rbp,8),%xmm0
movups -0x20(%rsi,%rbp,8),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,8)
movups %xmm1,-0x20(%rdx,%rbp,8)
movupd -0x10(%rsi,%rbp,8),%xmm0
movupd (%rsi,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm1,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1300 <svd+0x1b0>
cmpq   $0x0,0x20(%rsp)
je     1390 <svd+0x240>
lea    (%rcx,%rbp,8),%rbx
lea    (%r10,%rbp,8),%rbp
xor    %eax,%eax
xchg   %ax,%ax
movupd -0x10(%rbp,%rax,1),%xmm0
movupd 0x0(%rbp,%rax,1),%xmm1
movupd %xmm0,-0x10(%rbx,%rax,1)
movupd %xmm1,(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r12
jne    1370 <svd+0x220>
mov    0x80(%rsp),%rax
mov    %rax,%r11
cmp    %r15,%rax
mov    0x18(%rsp),%rax
je     1250 <svd+0x100>
nopl   0x0(%rax)
mov    %r11,%rbx
not    %rbx
add    %r15,%rbx
test   %r14,%r14
je     13e6 <svd+0x296>
mov    %r14,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%r11,8),%xmm0
movsd  %xmm0,(%r8,%r11,8)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbp
jne    13d0 <svd+0x280>
cmp    $0x3,%rbx
jb     1250 <svd+0x100>
movsd  (%rdi,%r11,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%r11,8)
movsd  0x8(%rdi,%r11,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%r11,8)
movsd  0x10(%rdi,%r11,8),%xmm0
movsd  %xmm0,(%rcx,%r11,8)
movsd  0x18(%rdi,%r11,8),%xmm0
movsd  %xmm0,0x8(%rcx,%r11,8)
add    $0x4,%r11
cmp    %r11,%r15
jne    13f0 <svd+0x2a0>
jmp    1250 <svd+0x100>
test   %eax,%eax
mov    0x50(%rsp),%r8
jle    21f2 <svd+0x10a2>
movslq 0xe0(%rsp),%rcx
mov    %rcx,0x78(%rsp)
mov    %eax,%ebp
lea    -0x2(%rbp),%rax
mov    %rax,0xc0(%rsp)
mov    0x30(%rsp),%r11
lea    0x0(,%r11,8),%rbx
lea    0x8(,%r11,8),%rax
mov    %rax,0x130(%rsp)
mov    0x210(%rsp),%r10
lea    0x8(%r10),%r9
mov    0x58(%rsp),%rdi
lea    0x18(%rdi),%rdx
lea    -0x3(%rbp),%rax
mov    %rax,0xa0(%rsp)
lea    (%r10,%r11,8),%rax
mov    %rax,0xf8(%rsp)
lea    (%r10,%r11,8),%rax
add    $0x38,%rax
mov    %rax,0xb8(%rsp)
mov    %rdi,%r13
add    $0x38,%r13
lea    -0x5(%rbp),%rax
mov    %rax,0x150(%rsp)
xorpd  %xmm9,%xmm9
mov    $0x1,%ecx
movapd 0x2b34(%rip),%xmm10
movapd 0x2b1b(%rip),%xmm11
mov    %r10,%r15
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
mov    %rbp,%rsi
mov    0xe8(%rsp),%rax
mov    %rax,0xa8(%rsp)
xor    %r14d,%r14d
mov    %r10,%r12
movsd  0x118(%rsp),%xmm8
jmp    15bd <svd+0x46d>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%r8
mov    0x210(%rsp),%r10
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%rdx
mov    0x80(%rsp),%r14
movsd  (%r8,%r14,8),%xmm0
movsd  (%rdi,%r14,8),%xmm4
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm4
addsd  %xmm0,%xmm4
maxsd  %xmm12,%xmm4
add    $0x1,%rcx
mov    0x130(%rsp),%rax
add    %rax,%r12
addq   $0xffffffffffffffff,0xa8(%rsp)
add    %rax,%r9
mov    0x20(%rsp),%rsi
add    $0xffffffffffffffff,%rsi
add    $0x8,%rdx
addq   $0xffffffffffffffff,0xa0(%rsp)
add    %rbx,%r15
add    %rbx,0xf8(%rsp)
add    %rax,0xb8(%rsp)
add    $0x8,%r13
addq   $0xffffffffffffffff,0x150(%rsp)
mov    0x40(%rsp),%r14
cmp    %rbp,%r14
je     1ce4 <svd+0xb94>
mov    %rsi,0x20(%rsp)
mov    %rcx,0x60(%rsp)
movapd %xmm4,%xmm12
movsd  %xmm1,(%rdi,%r14,8)
xorpd  %xmm5,%xmm5
mov    0x78(%rsp),%rsi
cmp    %rsi,%r14
jge    1605 <svd+0x4b5>
xorpd  %xmm5,%xmm5
mov    0xa8(%rsp),%rax
mov    %r12,%rcx
nop
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    %rbx,%rcx
add    $0xffffffffffffffff,%rax
jne    15f0 <svd+0x4a0>
lea    0x1(%r14),%rax
xorpd  %xmm3,%xmm3
ucomisd %xmm5,%xmm8
xorpd  %xmm1,%xmm1
mov    0x60(%rsp),%rcx
mov    %rax,0x40(%rsp)
mov    %r9,0x8(%rsp)
mov    %rdx,0x38(%rsp)
ja     17ec <svd+0x69c>
mov    %r14d,%eax
imul   0x18(%rsp),%eax
cltq
add    %r14,%rax
movsd  (%r10,%rax,8),%xmm4
ucomisd %xmm9,%xmm5
mov    %rax,0x80(%rsp)
jb     1660 <svd+0x510>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    16e0 <svd+0x590>
xchg   %ax,%ax
movapd %xmm5,%xmm0
movsd  %xmm12,0x10(%rsp)
movsd  %xmm4,0x28(%rsp)
movsd  %xmm5,0x100(%rsp)
call   1070 <sqrt@plt>
movsd  0x100(%rsp),%xmm5
movsd  0x28(%rsp),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x10(%rsp),%xmm12
movapd 0x295e(%rip),%xmm11
movapd 0x2965(%rip),%xmm10
mov    0x60(%rsp),%rcx
xorpd  %xmm9,%xmm9
mov    0x38(%rsp),%rdx
mov    0x78(%rsp),%rsi
movsd  0x118(%rsp),%xmm8
mov    0x30(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
mov    0x40(%rsp),%rax
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm11,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
mov    0x80(%rsp),%r9
movsd  %xmm0,(%r10,%r9,8)
cmp    %r11,%rax
jge    17c0 <svd+0x670>
mov    %r14,%r8
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mov    0x8(%rsp),%rax
mov    0xa8(%rsp),%r9
jmp    1754 <svd+0x604>
nopl   (%rax)
add    $0x1,%rcx
add    $0x8,%rax
cmp    %rbp,%rcx
mov    %r14,%rsi
je     17d0 <svd+0x680>
mov    %rsi,%r14
cmp    %rsi,%r8
jge    1740 <svd+0x5f0>
xorpd  %xmm0,%xmm0
mov    %r9,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm0
add    %rbx,%rsi
add    $0xffffffffffffffff,%rdx
jne    1770 <svd+0x620>
cmp    %r14,%r8
jge    1740 <svd+0x5f0>
divsd  %xmm4,%xmm0
mov    %r9,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rsi,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %rbx,%rsi
add    $0xffffffffffffffff,%rdx
jne    17a0 <svd+0x650>
jmp    1740 <svd+0x5f0>
nop
mov    0x8(%rsp),%r9
jmp    17ec <svd+0x69c>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%rdx
mov    0x60(%rsp),%rcx
mov    0x40(%rsp),%rax
mov    %r8,%r14
mov    0x50(%rsp),%r8
movsd  %xmm1,(%r8,%r14,8)
cmp    %r11,%rax
mov    0x20(%rsp),%rsi
jge    1827 <svd+0x6d7>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rsi
jne    1810 <svd+0x6c0>
xorpd  %xmm1,%xmm1
ucomisd %xmm3,%xmm8
ja     153f <svd+0x3ef>
mov    %r14d,%eax
imul   0x18(%rsp),%eax
mov    0x40(%rsp),%rsi
add    %esi,%eax
cltq
movsd  (%r10,%rax,8),%xmm4
ucomisd %xmm9,%xmm3
mov    %rax,0x80(%rsp)
jb     1870 <svd+0x720>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
mov    0x40(%rsp),%rax
mov    0x78(%rsp),%r9
jmp    18e7 <svd+0x797>
nop
movapd %xmm3,%xmm0
movsd  %xmm12,0x10(%rsp)
movsd  %xmm3,0x28(%rsp)
movapd %xmm4,0x100(%rsp)
call   1070 <sqrt@plt>
movapd 0x100(%rsp),%xmm4
movsd  0x28(%rsp),%xmm3
movsd  0x10(%rsp),%xmm12
movapd 0x2752(%rip),%xmm11
movapd 0x2759(%rip),%xmm10
mov    0x60(%rsp),%rcx
xorpd  %xmm9,%xmm9
mov    0x78(%rsp),%r9
movsd  0x118(%rsp),%xmm8
mov    0x30(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x40(%rsp),%rax
mov    %r14,%rdx
not    %rdx
lea    (%rdx,%rbp,1),%r8
mov    %r14,%rsi
imul   %r11,%rsi
mov    %rsi,0x10(%rsp)
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm11,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
mov    0x80(%rsp),%rsi
movsd  %xmm0,(%r10,%rsi,8)
cmp    %r11,%rax
jge    1a28 <svd+0x8d8>
mulsd  %xmm1,%xmm4
subsd  %xmm3,%xmm4
mov    %rcx,%rax
cmp    $0x2,%r8
jb     1a10 <svd+0x8c0>
lea    (%rdx,%rbp,1),%rsi
add    $0xfffffffffffffffe,%rsi
mov    %rsi,%rax
shr    %rax
add    $0x1,%rax
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmp    $0x2,%rsi
mov    %rax,0x80(%rsp)
mov    %r8,%r9
jae    197f <svd+0x82f>
xor    %esi,%esi
jmp    19ca <svd+0x87a>
mov    0xa0(%rsp),%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %esi,%esi
mov    0x8(%rsp),%rcx
mov    0x38(%rsp),%r8
xchg   %ax,%ax
movupd (%rcx,%rsi,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%r8,%rsi,8)
movupd 0x10(%rcx,%rsi,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%r8,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rax
jne    19a0 <svd+0x850>
mov    %r9,%r8
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
testb  $0x1,0x80(%rsp)
01
je     19fa <svd+0x8aa>
add    0x60(%rsp),%rsi
mov    0x10(%rsp),%rcx
add    %rsi,%rcx
movupd (%r10,%rcx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%rdi,%rsi,8)
cmp    %rax,%r8
mov    0x60(%rsp),%rcx
mov    0x78(%rsp),%r9
je     1a28 <svd+0x8d8>
add    %rcx,%rax
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1a10 <svd+0x8c0>
cmp    %r9,0x40(%rsp)
jge    1cd0 <svd+0xb80>
mov    %r14,0x80(%rsp)
mov    0x150(%rsp),%rax
shr    $0x2,%rax
add    $0x1,%rax
add    %rbp,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x100(%rsp)
shr    $0x2,%rdx
and    $0xfffffffffffffffe,%rax
mov    %rax,0xb0(%rsp)
add    $0x1,%rdx
mov    %rdx,0xf0(%rsp)
add    %rcx,0x10(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x28(%rsp)
mov    %r8,%r14
and    $0xfffffffffffffffc,%r8
mov    %r8,0x120(%rsp)
lea    (%rcx,%r8,1),%rax
mov    %rax,0xd8(%rsp)
mov    0xb8(%rsp),%rdx
mov    0xf8(%rsp),%r10
mov    %rcx,%r8
jmp    1ad8 <svd+0x988>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
add    %rbx,%r10
add    %rbx,%rdx
cmp    0xe8(%rsp),%r8
je     1520 <svd+0x3d0>
cmp    %r11,0x40(%rsp)
jge    1ac0 <svd+0x970>
mov    %r8,%r9
imul   %r11,%r9
xorpd  %xmm2,%xmm2
mov    %rcx,%rax
test   $0x1,%r14b
je     1b26 <svd+0x9d6>
mov    0x60(%rsp),%rax
lea    (%rax,%r9,1),%rcx
mov    0x210(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rsp),%rcx
mov    0x10(%rsp),%rsi
mulsd  (%rax,%rsi,8),%xmm0
addsd  %xmm9,%xmm0
mov    0x28(%rsp),%rax
movapd %xmm0,%xmm2
mov    0x80(%rsp),%rsi
cmp    %rsi,0xc0(%rsp)
je     1b6f <svd+0xa1f>
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rax,8),%xmm3
movsd  0x8(%r10,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm3
mulsd  0x8(%r15,%rax,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm2
cmp    %rax,%rbp
jne    1b40 <svd+0x9f0>
cmp    %r11,0x40(%rsp)
jge    1ac0 <svd+0x970>
mov    %rcx,%rax
cmp    $0x4,%r14
jb     1ca0 <svd+0xb50>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x4,0x100(%rsp)
jae    1ba2 <svd+0xa52>
xor    %r11d,%r11d
jmp    1c2c <svd+0xadc>
mov    0xb0(%rsp),%rdi
xor    %r11d,%r11d
nopl   (%rax)
movupd -0x30(%r13,%r11,8),%xmm3
movupd -0x20(%r13,%r11,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%rdx,%r11,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%rdx,%r11,8),%xmm3
movupd -0x10(%rdx,%r11,8),%xmm6
movupd (%rdx,%r11,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%rdx,%r11,8)
movupd %xmm4,-0x20(%rdx,%r11,8)
movupd -0x10(%r13,%r11,8),%xmm3
movupd 0x0(%r13,%r11,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%rdx,%r11,8)
movupd %xmm4,(%rdx,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%rdi
jne    1bb0 <svd+0xa60>
testb  $0x1,0xf0(%rsp)
01
je     1c80 <svd+0xb30>
add    %rcx,%r11
mov    0x58(%rsp),%rax
movupd (%rax,%r11,8),%xmm3
movupd 0x10(%rax,%r11,8),%xmm4
add    %r9,%r11
mov    0x210(%rsp),%rax
movupd (%rax,%r11,8),%xmm5
movupd 0x10(%rax,%r11,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rax,%r11,8)
movupd %xmm4,0x10(%rax,%r11,8)
mov    0xd8(%rsp),%rax
cmp    0x120(%rsp),%r14
mov    0x58(%rsp),%rdi
mov    0x30(%rsp),%r11
je     1ac0 <svd+0x970>
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%r10,%rax,8),%xmm2
movsd  %xmm2,(%r10,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1ca0 <svd+0xb50>
jmp    1ac0 <svd+0x970>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x50(%rsp),%r8
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%rdx
jmp    153f <svd+0x3ef>
mov    0x18(%rsp),%rax
test   %eax,%eax
setle  %r15b
cmpl   $0x0,0x9c(%rsp)
sete   0xf8(%rsp)
je     221b <svd+0x10cb>
test   %eax,%eax
jle    221b <svd+0x10cb>
mov    %r15b,0xb0(%rsp)
mov    %r11,%r9
neg    %r9
lea    -0x1(%r11),%rdx
lea    (%r11,%r11,1),%r8
mov    %rdx,%rax
imul   %r11,%rax
lea    (%r10,%rax,8),%rsi
add    $0x8,%rsi
neg    %rbx
mov    %r11,%r12
shl    $0x4,%r12
mov    0x218(%rsp),%rcx
lea    -0x8(%rcx),%rbp
mov    %rbp,0x78(%rsp)
lea    (%rcx,%rax,8),%r10
add    $0x8,%r10
mov    $0xfffffffffffffff8,%r14
xorpd  %xmm0,%xmm0
mov    %rdx,0xa0(%rsp)
mov    %rdx,0xa8(%rsp)
mov    %rcx,0xd8(%rsp)
mov    %r11,%r15
mov    %r9,0x28(%rsp)
jmp    1de4 <svd+0xc94>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15d,%eax
imul   0x18(%rsp),%eax
cltq
add    %r15,%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r9,%rax,8)
movsd  (%rdi,%r15,8),%xmm1
addq   $0xfffffffffffffff8,0xd8(%rsp)
add    %rbx,%rsi
addq   $0xffffffffffffffff,0xa8(%rsp)
addq   $0xfffffffffffffff8,0x78(%rsp)
add    $0xfffffffffffffff8,%r14
add    %rbx,%r10
cmpq   $0x1,0x8(%rsp)
mov    0x28(%rsp),%r9
jle    222a <svd+0x10da>
mov    %r14,0x120(%rsp)
mov    %r10,0xf0(%rsp)
movslq %r15d,%r13
mov    %r11,%r14
sub    %r13,%r14
mov    %r13,%rax
mov    %r13,0x38(%rsp)
not    %r13
mov    %r15,0x8(%rsp)
lea    -0x1(%r15),%rax
mov    %rax,0x100(%rsp)
ucomisd %xmm0,%xmm1
mov    %r14,0x80(%rsp)
jne    1e2d <svd+0xcdd>
jnp    2120 <svd+0xfd0>
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
jge    2120 <svd+0xfd0>
mov    0x100(%rsp),%r10
mov    %r10,%rdx
imul   %r11,%rdx
mov    %r10d,%eax
imul   0x18(%rsp),%eax
mov    0x8(%rsp),%rbp
add    %ebp,%eax
cltq
mov    0x210(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm1
movslq %ebp,%rbp
test   $0x1,%r14b
je     1e9a <svd+0xd4a>
lea    (%rdx,%rbp,1),%rax
movsd  (%rcx,%rax,8),%xmm2
divsd  %xmm1,%xmm2
mov    %rbp,%rax
imul   %r11,%rax
add    %r10,%rax
mov    0x218(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
add    $0x1,%rbp
mov    %rdx,0xb8(%rsp)
cmp    %r9,%r13
je     1ef9 <svd+0xda9>
mov    %r11,%rax
imul   %rbp,%rax
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
lea    0x1(%rbp),%rcx
imul   %r11,%rcx
lea    (%rdx,%rcx,8),%rcx
mov    0xa0(%rsp),%rdx
xchg   %ax,%ax
movsd  -0x8(%rsi,%rbp,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rdx,8)
movsd  (%rsi,%rbp,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rdx,8)
add    $0x2,%rbp
add    %r8,%rdx
cmp    %rbp,%r11
jne    1ed0 <svd+0xd80>
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
jge    2120 <svd+0xfd0>
mov    0x218(%rsp),%r10
mov    0x38(%rsp),%rax
lea    (%r10,%rax,8),%rax
mov    %rax,0x60(%rsp)
movslq 0x8(%rsp),%r15
add    %r15,0xb8(%rsp)
mov    %r15,%rcx
imul   %r11,%rcx
lea    0x1(%r15),%rax
mov    %rax,0x10(%rsp)
mov    0x100(%rsp),%rax
mov    %rcx,0x20(%rsp)
add    %rcx,%rax
mov    %rax,0x150(%rsp)
mov    %r15,0x40(%rsp)
mov    %r13,0xc0(%rsp)
jmp    1fa1 <svd+0xe51>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
add    $0x8,%r10
addq   $0x8,0x60(%rsp)
mov    0x30(%rsp),%r11
cmp    %r11,%r15
mov    0x58(%rsp),%rdi
mov    0xc0(%rsp),%r13
mov    0x80(%rsp),%r14
je     2120 <svd+0xfd0>
xorpd  %xmm2,%xmm2
mov    0x40(%rsp),%rbp
test   $0x1,%r14b
je     1fe7 <svd+0xe97>
mov    0x210(%rsp),%rax
mov    0xb8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rsp),%rax
add    %r15,%rax
mov    0x218(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rsp),%rbp
movapd %xmm1,%xmm2
cmp    %r9,%r13
je     203d <svd+0xeed>
mov    %r11,%rax
imul   %rbp,%rax
lea    (%r10,%rax,8),%rax
lea    0x1(%rbp),%rcx
imul   %r11,%rcx
lea    (%r10,%rcx,8),%rcx
mov    0x38(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rbp,8),%xmm3
mulsd  (%rax,%rdx,8),%xmm3
movsd  (%rsi,%rbp,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rbp
add    %r8,%rdx
movapd %xmm1,%xmm2
cmp    %rbp,%r11
jne    2010 <svd+0xec0>
mov    0x40(%rsp),%rcx
test   $0x1,%r14b
je     2078 <svd+0xf28>
mov    0x20(%rsp),%rax
add    %r15,%rax
mov    0x218(%rsp),%rcx
mov    0x150(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0x10(%rsp),%rcx
cmp    %r9,%r13
je     1f70 <svd+0xe20>
mov    0x30(%rsp),%r9
mov    %r9,%rbp
sub    %rcx,%rbp
mov    %r9,%rdx
imul   %rcx,%rdx
lea    (%r15,%rdx,1),%rax
mov    0x218(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
add    0xa8(%rsp),%rdx
lea    (%rdi,%rdx,8),%r13
lea    0x1(%rcx),%rdx
imul   %r9,%rdx
mov    0x60(%rsp),%rdi
lea    (%rdi,%rdx,8),%r11
lea    0x10(,%rcx,8),%r14
imul   %r9,%r14
mov    0x28(%rsp),%r9
add    0x78(%rsp),%r14
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,1),%xmm2
movsd  %xmm2,(%rax,%rcx,1)
movsd  (%r14,%rcx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r11,%rcx,1),%xmm2
movsd  %xmm2,(%r11,%rcx,1)
add    %r12,%rcx
add    $0xfffffffffffffffe,%rbp
jne    20e0 <svd+0xf90>
jmp    1f70 <svd+0xe20>
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
cmp    0x18(%rsp),%eax
mov    0x218(%rsp),%r9
mov    0xf0(%rsp),%r10
mov    0x120(%rsp),%r14
mov    0x100(%rsp),%r15
jge    1d90 <svd+0xc40>
movslq 0x8(%rsp),%rbp
testb  $0x1,0x80(%rsp)
01
je     2186 <svd+0x1036>
mov    %r15,%rax
imul   %r11,%rax
mov    %rbp,%rcx
imul   %r11,%rcx
add    %r15,%rcx
movq   $0x0,(%r9,%rcx,8)
add    %rbp,%rax
movq   $0x0,(%r9,%rax,8)
add    $0x1,%rbp
cmp    0x28(%rsp),%r13
je     1d90 <svd+0xc40>
lea    0x10(,%rbp,8),%rax
imul   %r11,%rax
add    %r9,%rax
lea    0x8(,%rbp,8),%rcx
imul   %r11,%rcx
add    %r9,%rcx
mov    %r14,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   $0x0,(%rcx,%rdx,1)
movq   $0x0,-0x8(%r10,%rbp,8)
movq   $0x0,(%rax,%rdx,1)
movq   $0x0,(%r10,%rbp,8)
add    $0x2,%rbp
add    %r12,%rdx
cmp    %rbp,%r11
jne    21c0 <svd+0x1070>
jmp    1d90 <svd+0xc40>
cmpl   $0x0,0x9c(%rsp)
sete   0xf8(%rsp)
xorpd  %xmm4,%xmm4
mov    $0x1,%r15b
mov    0x58(%rsp),%rdi
mov    0x210(%rsp),%r10
mov    0x30(%rsp),%r11
cmpl   $0x0,0x148(%rsp)
jne    224d <svd+0x10fd>
jmp    2415 <svd+0x12c5>
mov    0x50(%rsp),%r8
mov    0x210(%rsp),%r10
mov    0xb0(%rsp),%r15b
cmpl   $0x0,0x148(%rsp)
je     2415 <svd+0x12c5>
mov    0xe0(%rsp),%rax
mov    %eax,%esi
mov    0x18(%rsp),%rax
mov    %eax,%ecx
not    %ecx
mov    %rcx,0x28(%rsp)
sub    %eax,%esi
movapd %xmm4,0x130(%rsp)
jle    240c <svd+0x12bc>
lea    0x1(%rax),%ecx
xor    %ebp,%ebp
mov    0x28(%rsp),%rax
movabs $0x3ff0000000000000,%r12
mov    %r11,%r14
add    0xe0(%rsp),%eax
lea    0x8(,%rax,8),%rdx
je     23c0 <svd+0x1270>
mov    %r15b,0xb0(%rsp)
lea    0x1(%r11),%rax
imul   %r11,%rax
mov    %rax,0x60(%rsp)
mov    %r11,%rax
shl    $0x4,%rax
add    $0x10,%rax
mov    %rax,0x80(%rsp)
lea    0x2(%r11),%rax
imul   %r11,%rax
mov    %rax,0xc0(%rsp)
mov    0x18(%rsp),%r14
lea    0x2(%r14),%r12d
imul   %r14d,%r12d
mov    %rdx,0x40(%rsp)
lea    (%r14,%r14,1),%eax
mov    %eax,0x20(%rsp)
mov    %ecx,0x38(%rsp)
imul   %ecx,%r14d
mov    %rsi,0x8(%rsp)
and    $0xfffffffe,%esi
mov    %rsi,0x10(%rsp)
xor    %ebp,%ebp
mov    %r10,%r15
mov    0x40(%rsp),%r13
movabs $0x3ff0000000000000,%rbx
nopl   (%rax)
movslq %r14d,%r14
lea    (%r10,%r14,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1040 <memset@plt>
mov    0x60(%rsp),%rax
mov    %rbx,(%r15,%rax,8)
movslq %r12d,%r12
mov    0x210(%rsp),%rax
lea    (%rax,%r12,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1040 <memset@plt>
mov    0x210(%rsp),%r10
mov    0xc0(%rsp),%rax
mov    %rbx,0x8(%r15,%rax,8)
add    $0x2,%rbp
add    0x80(%rsp),%r15
mov    0x20(%rsp),%eax
add    %eax,%r12d
add    %eax,%r14d
cmp    %ebp,0x10(%rsp)
jne    2320 <svd+0x11d0>
mov    0x30(%rsp),%r11
lea    (%r11,%rbp,1),%r14
mov    0x50(%rsp),%r8
mov    0x58(%rsp),%rdi
movapd 0x130(%rsp),%xmm4
mov    0xb0(%rsp),%r15b
movabs $0x3ff0000000000000,%r12
mov    0x8(%rsp),%rsi
mov    0x38(%rsp),%ecx
mov    0x40(%rsp),%rdx
test   $0x1,%sil
mov    0x18(%rsp),%rax
je     240c <svd+0x12bc>
add    %ebp,%ecx
imul   %eax,%ecx
movslq %ecx,%rax
lea    (%r10,%rax,8),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movapd 0x130(%rsp),%xmm4
mov    0x30(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
mov    %r14,%rax
imul   %r11,%rax
add    %r14,%rax
mov    %r12,(%r10,%rax,8)
test   %r15b,%r15b
je     3003 <svd+0x1eb3>
mov    0x220(%rsp),%rbx
mov    0x18(%rsp),%rcx
test   %ecx,%ecx
jle    2fc9 <svd+0x1e79>
mulsd  0x140(%rsp),%xmm4
cmpl   $0x0,0x148(%rsp)
sete   %al
movabs $0xffffffff00000000,%r9
ff ff ff
mov    0xe0(%rsp),%r14
test   %r14d,%r14d
setle  %bl
or     %al,%bl
mov    %bl,0x38(%rsp)
mov    %ecx,%esi
mov    0xe8(%rsp),%rax
lea    -0x1(%rax),%rbx
lea    (%r10,%rax,8),%rbp
mov    %rbp,0x1c0(%rsp)
lea    0x1(%rax),%rbp
mov    %rbp,0x1b8(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x140(%rsp)
mov    %rsi,0xd8(%rsp)
and    $0xfffffffe,%esi
mov    %rsi,0x180(%rsp)
mov    %r11,%r13
shl    $0x20,%r13
lea    (%r9,%r13,1),%rax
mov    %rax,0x178(%rsp)
lea    -0x1(%r11),%rax
mov    %rax,0xf0(%rsp)
lea    -0x1(%rcx),%r15d
movabs $0xfffffffe00000000,%rax
ff ff ff
add    %r13,%rax
mov    %rax,0x170(%rsp)
mov    %r11,%rbp
shl    $0x21,%rbp
mov    %r11,%rdx
shl    $0x4,%rdx
movapd 0x1b22(%rip),%xmm1
xorpd  %xmm8,%xmm8
shr    $0x20,%rbx
mov    %rbx,0x118(%rsp)
lea    (%rcx,%r14,1),%eax
add    $0xfffffffe,%eax
mov    %rax,0x1a8(%rsp)
lea    -0x10(%r8,%r11,8),%rax
mov    %rax,0x120(%rsp)
lea    0x0(,%r11,8),%r14
mov    0x218(%rsp),%rax
lea    0x8(%rax),%rcx
mov    %rcx,0x1a0(%rsp)
lea    0x8(%r10),%rcx
mov    %rcx,0x198(%rsp)
mov    %rdx,0x160(%rsp)
add    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
lea    (%rax,%r11,8),%rsi
add    $0xfffffffffffffff8,%rsi
xor    %eax,%eax
mov    %rax,0x168(%rsp)
mov    %r15,0x1b0(%rsp)
mov    %r15d,%eax
mov    %r15d,0x12c(%rsp)
mov    %r11,%rbx
movapd %xmm4,0x130(%rsp)
mov    %rbp,0xb8(%rsp)
mov    %rsi,0x188(%rsp)
mov    %rdx,0x190(%rsp)
mov    %rbx,0xa0(%rsp)
lea    -0x1(%rbx),%rax
mov    %rax,0xa8(%rsp)
movl   $0x0,0x9c(%rsp)
jmp    2604 <svd+0x14b4>
nopl   0x0(%rax)
unpcklpd %xmm9,%xmm12
addl   $0x1,0x9c(%rsp)
01
mov    0x1c8(%rsp),%rax
movq   $0x0,(%rdi,%rax,8)
movlpd %xmm12,(%rdi,%rbx,8)
movhpd %xmm12,(%r8,%rbx,8)
movapd 0x130(%rsp),%xmm4
movabs $0xffffffff00000000,%r9
ff ff ff
movapd 0x1a0c(%rip),%xmm1
mov    0x12c(%rsp),%eax
mov    0x170(%rsp),%rcx
mov    0x168(%rsp),%rdx
mov    0x178(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,%r12
mov    %rcx,%rbx
mov    %rax,0x80(%rsp)
mov    0xf0(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x10(%rsp)
add    %rdx,%rax
js     269b <svd+0x154b>
mov    %eax,%eax
movsd  (%rdi,%rax,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm4
jae    2820 <svd+0x16d0>
mov    0x120(%rsp),%rax
mov    0x10(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm1,%xmm0
lea    (%r12,%r9,1),%rsi
lea    -0x1(%rcx),%rdx
lea    (%rbx,%r9,1),%rcx
mov    0x80(%rsp),%rax
add    $0xffffffff,%eax
ucomisd %xmm0,%xmm4
jb     2630 <svd+0x14e0>
mov    %r12,%rbp
sar    $0x20,%rbp
cmp    0xa0(%rsp),%rbp
jge    2820 <svd+0x16d0>
movapd %xmm1,%xmm2
sar    $0x20,%rbx
movslq 0x80(%rsp),%r15
shl    $0x3,%r15
movsd  0x1954(%rip),%xmm1
jmp    26f7 <svd+0x15a7>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%r15
cmp    0xa0(%rsp),%rbp
movapd 0x130(%rsp),%xmm4
movapd 0x191f(%rip),%xmm2
jge    2820 <svd+0x16d0>
movsd  (%rdi,%rbp,8),%xmm0
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
unpckhpd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
movapd %xmm3,%xmm0
andpd  %xmm2,%xmm0
ucomisd %xmm0,%xmm4
jae    2820 <svd+0x16d0>
movsd  (%r8,%rbp,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     2750 <svd+0x1600>
sqrtsd %xmm0,%xmm0
jmp    2793 <svd+0x1643>
nopw   0x0(%rax,%rax,1)
movapd %xmm3,0x40(%rsp)
movapd %xmm2,0x60(%rsp)
call   1070 <sqrt@plt>
movapd 0x60(%rsp),%xmm2
movapd 0x40(%rsp),%xmm3
xorpd  %xmm8,%xmm8
movabs $0xffffffff00000000,%r9
ff ff ff
mov    0x30(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
movsd  %xmm0,(%r8,%rbp,8)
xorpd  0x185f(%rip),%xmm3
unpcklpd %xmm2,%xmm3
unpcklpd %xmm0,%xmm0
movapd %xmm3,%xmm1
divpd  %xmm0,%xmm1
cmpb   $0x0,0x38(%rsp)
jne    26d0 <svd+0x1580>
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mov    0xe8(%rsp),%rax
mov    %r10,%rcx
nop
movsd  (%rcx,%rbx,8),%xmm2
movsd  (%rcx,%r15,1),%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rcx,%rbx,8)
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%r15,1)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    27d0 <svd+0x1680>
jmp    26d0 <svd+0x1580>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa8(%rsp),%rbx
movsd  (%r8,%rbx,8),%xmm3
mov    0xf0(%rsp),%rax
mov    0x10(%rsp),%rcx
add    %ecx,%eax
cmp    %rbx,%rax
movapd 0x17b8(%rip),%xmm2
je     2eb0 <svd+0x1d60>
cmpl   $0x1e,0x9c(%rsp)
1e
je     2fbc <svd+0x1e6c>
mov    %r12,%rbp
sar    $0x20,%rbp
sar    $0x1d,%r12
movsd  (%r8,%r12,1),%xmm9
mov    0xa0(%rsp),%rax
movsd  -0x10(%r8,%rax,8),%xmm12
movsd  -0x10(%rdi,%rax,8),%xmm5
movsd  (%rdi,%rbx,8),%xmm4
movapd %xmm12,%xmm0
subsd  %xmm3,%xmm0
movapd %xmm3,%xmm1
addsd  %xmm12,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm5,%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm4,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm12,%xmm0
divsd  %xmm0,%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
addsd  0x174e(%rip),%xmm0
ucomisd %xmm8,%xmm0
jb     28e0 <svd+0x1790>
sqrtsd %xmm0,%xmm0
jmp    2947 <svd+0x17f7>
nop
movapd %xmm12,0x60(%rsp)
movapd %xmm9,0x40(%rsp)
movapd %xmm3,0xc0(%rsp)
movsd  %xmm4,0x20(%rsp)
movsd  %xmm5,0x8(%rsp)
call   1070 <sqrt@plt>
movsd  0x8(%rsp),%xmm5
movsd  0x20(%rsp),%xmm4
movapd 0xc0(%rsp),%xmm3
movapd 0x40(%rsp),%xmm9
movapd 0x60(%rsp),%xmm12
xorpd  %xmm8,%xmm8
mov    0x30(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
movapd %xmm9,%xmm1
subsd  %xmm3,%xmm1
addsd  %xmm9,%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm0,%xmm1
xorpd  0x169b(%rip),%xmm1
movapd %xmm5,%xmm2
cmpltsd %xmm8,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
addsd  %xmm5,%xmm2
divsd  %xmm2,%xmm12
subsd  %xmm4,%xmm12
mulsd  %xmm4,%xmm12
addsd  %xmm3,%xmm12
divsd  %xmm9,%xmm12
cmp    %rbx,%rbp
mov    %rbp,0x1c8(%rsp)
jge    25c0 <svd+0x1470>
lea    0x1(%rbp),%rax
mov    %rax,0x1d0(%rsp)
mov    0x1b8(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x148(%rsp)
mov    0x1b0(%rsp),%rax
mov    0x10(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xb0(%rsp)
add    0x1a8(%rsp),%rcx
mov    %rcx,0x10(%rsp)
movslq 0x80(%rsp),%rcx
mov    %rcx,%r12
shl    $0x20,%r12
mov    0x1a0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x8(%rsp)
mov    0x198(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x78(%rsp)
add    $0x1,%rcx
mov    %rcx,0x28(%rsp)
mov    %rbp,%r9
xor    %r15d,%r15d
movsd  0x15eb(%rip),%xmm0
movapd %xmm0,%xmm6
movapd %xmm0,%xmm11
jmp    2ada <svd+0x198a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  %xmm12,%xmm11
mulsd  %xmm7,%xmm9
subsd  %xmm9,%xmm11
mulsd  %xmm12,%xmm10
movapd %xmm6,%xmm1
xorpd  0x1590(%rip),%xmm1
unpcklpd %xmm10,%xmm10
mulpd  %xmm6,%xmm10
movapd %xmm6,%xmm2
shufpd $0x1,%xmm1,%xmm2
unpcklpd %xmm11,%xmm11
mulpd  %xmm2,%xmm11
movapd %xmm11,%xmm12
addpd  %xmm10,%xmm12
add    $0x1,%r15
movapd %xmm12,%xmm9
unpckhpd %xmm12,%xmm9
movabs $0x100000000,%rax
add    %rax,%r12
addq   $0x8,0x8(%rsp)
addq   $0x8,0x78(%rsp)
addq   $0x1,0x28(%rsp)
movapd %xmm0,%xmm11
mov    0xa8(%rsp),%rbx
cmp    %rbx,%r9
jge    25c5 <svd+0x1475>
mov    %r9,%rbx
movsd  0x8(%rdi,%r9,8),%xmm4
movsd  0x8(%r8,%r9,8),%xmm10
movapd %xmm6,%xmm7
mulsd  %xmm4,%xmm7
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm12,%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
movapd %xmm9,0x40(%rsp)
movapd %xmm10,0x80(%rsp)
jb     2b30 <svd+0x19e0>
sqrtsd %xmm0,%xmm0
jmp    2b90 <svd+0x1a40>
nopw   0x0(%rax,%rax,1)
movapd %xmm12,0x60(%rsp)
movapd %xmm11,0xc0(%rsp)
movsd  %xmm7,0x20(%rsp)
movsd  %xmm4,0x150(%rsp)
call   1070 <sqrt@plt>
movsd  0x150(%rsp),%xmm4
movsd  0x20(%rsp),%xmm7
movapd 0x80(%rsp),%xmm10
movapd 0xc0(%rsp),%xmm11
movapd 0x40(%rsp),%xmm9
movapd 0x60(%rsp),%xmm12
xorpd  %xmm8,%xmm8
mov    0x58(%rsp),%rdi
mov    0x218(%rsp),%rbp
movsd  %xmm0,(%rdi,%rbx,8)
divsd  %xmm0,%xmm12
divsd  %xmm0,%xmm7
cmpb   $0x0,0xf8(%rsp)
jne    2c09 <svd+0x1ab9>
mov    0xd8(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    %r12,%rdx
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  0x0(%rbp,%rsi,1),%xmm0
movsd  (%rcx),%xmm1
movapd %xmm7,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm12,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rsi,1)
mulsd  %xmm12,%xmm1
mulsd  %xmm7,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx)
add    %r13,%rdx
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    2bc0 <svd+0x1a70>
mulsd  %xmm4,%xmm11
movapd %xmm11,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm9,%xmm2
mulsd  %xmm12,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm10,%xmm6
mulsd  %xmm7,%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     2c50 <svd+0x1b00>
sqrtsd %xmm0,%xmm0
jmp    2cc2 <svd+0x1b72>
nop
movapd %xmm12,0x60(%rsp)
movapd %xmm11,0xc0(%rsp)
movsd  %xmm7,0x20(%rsp)
movapd %xmm6,0x150(%rsp)
movapd %xmm2,0x100(%rsp)
call   1070 <sqrt@plt>
movapd 0x100(%rsp),%xmm2
movapd 0x150(%rsp),%xmm6
movsd  0x20(%rsp),%xmm7
movapd 0x80(%rsp),%xmm10
movapd 0xc0(%rsp),%xmm11
movapd 0x40(%rsp),%xmm9
movapd 0x60(%rsp),%xmm12
xorpd  %xmm8,%xmm8
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
mov    0x210(%rsp),%r10
mov    0x30(%rsp),%r11
mov    0xb8(%rsp),%rbp
lea    0x1(%rbx),%r9
movsd  %xmm0,(%r8,%rbx,8)
unpcklpd %xmm2,%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
cmpb   $0x0,0x38(%rsp)
jne    2a50 <svd+0x1900>
cmpl   $0x2,0xe0(%rsp)
02
jae    2d90 <svd+0x1c40>
xor    %esi,%esi
mov    %r11,%rcx
imul   %rsi,%rcx
add    %ecx,%ebx
shl    $0x20,%rbx
add    0x28(%rsp),%rcx
lea    (%r10,%rcx,8),%rcx
mov    0xe8(%rsp),%rdx
sub    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rsi
sar    $0x1d,%rsi
movsd  (%r10,%rsi,1),%xmm1
movsd  (%rcx),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r10,%rsi,1)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx)
add    %r13,%rbx
add    %r14,%rcx
add    $0xffffffffffffffff,%rdx
jne    2d40 <svd+0x1bf0>
jmp    2a50 <svd+0x1900>
nopl   0x0(%rax)
cmpl   $0x1,0x18(%rsp)
jne    2d13 <svd+0x1bc3>
mov    0xb0(%rsp),%rax
lea    (%rax,%r15,1),%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%r15,1),%edx
cmp    %ecx,%edx
jl     2d13 <svd+0x1bc3>
mov    $0x0,%esi
cmpq   $0x0,0x118(%rsp)
jne    2d15 <svd+0x1bc5>
mov    0xb0(%rsp),%rax
lea    (%rax,%r15,1),%ecx
mov    0x148(%rsp),%rax
lea    (%rax,%r15,1),%rdx
movslq %ecx,%rcx
lea    (%r10,%rcx,8),%rsi
lea    (%r10,%rdx,8),%rdx
cmp    %rdx,%rsi
jae    2e19 <svd+0x1cc9>
mov    0x1d0(%rsp),%rax
lea    (%rax,%r15,1),%rdx
mov    0x1c0(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
lea    (%r10,%rdx,8),%rdx
cmp    %rcx,%rdx
jb     2d13 <svd+0x1bc3>
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
mov    0x140(%rsp),%rcx
mov    0x78(%rsp),%rdx
mov    %r12,%rax
mov    0x160(%rsp),%r8
nopl   0x0(%rax)
mov    %rax,%rsi
sar    $0x1d,%rsi
movupd (%r10,%rsi,1),%xmm2
movupd (%rdx),%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r10,%rsi,1)
mulpd  %xmm0,%xmm3
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm3
movupd %xmm3,(%rdx)
add    %rbp,%rax
add    %r8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    2e40 <svd+0x1cf0>
mov    0x140(%rsp),%rax
mov    %rax,%rsi
cmp    0xe8(%rsp),%rax
mov    0x50(%rsp),%r8
je     2a50 <svd+0x1900>
jmp    2d15 <svd+0x1bc5>
nopw   0x0(%rax,%rax,1)
ucomisd %xmm3,%xmm8
movapd 0x130(%rsp),%xmm4
movapd 0x114a(%rip),%xmm1
mov    0x190(%rsp),%rdx
mov    0x188(%rsp),%rsi
jbe    2f80 <svd+0x1e30>
xorpd  0x111c(%rip),%xmm3
movlpd %xmm3,(%r8,%rbx,8)
cmpb   $0x0,0xf8(%rsp)
jne    2f80 <svd+0x1e30>
cmpl   $0x1,0x18(%rsp)
jne    2f03 <svd+0x1db3>
xor    %eax,%eax
jmp    2f48 <svd+0x1df8>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x180(%rsp),%r15
mov    0x160(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,1),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rsi,%rcx,1)
movsd  (%rdx,%rcx,1),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rdx,%rcx,1)
add    $0x2,%rax
add    %r12,%rcx
cmp    %rax,%r15
jne    2f20 <svd+0x1dd0>
testb  $0x1,0xd8(%rsp)
01
je     2f80 <svd+0x1e30>
imul   %r11,%rax
add    %rbx,%rax
mov    0x218(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0x1092(%rip),%xmm0
movlpd %xmm0,(%rcx,%rax,8)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %r9,0x178(%rsp)
addq   $0xffffffffffffffff,0x168(%rsp)
add    %r9,0x170(%rsp)
addl   $0xffffffff,0x12c(%rsp)
ff
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rsi
cmpq   $0x1,0xa0(%rsp)
jg     258b <svd+0x143b>
xor    %ebp,%ebp
jmp    2fbf <svd+0x1e6f>
mov    %rbx,%rbp
mov    0x220(%rsp),%rbx
jmp    2fcb <svd+0x1e7b>
xor    %ebp,%ebp
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0x218(%rsp),%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1060 <matrix_transpose@plt>
mov    %ebp,%eax
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x18(%rsp),%rax
mov    %eax,%ecx
imul   %eax,%ecx
mov    %ecx,0x38(%rsp)
mov    0xe0(%rsp),%rcx
mov    0x28(%rsp),%rdx
add    %ecx,%edx
mov    %rdx,0x78(%rsp)
movslq %ecx,%rbp
mov    %eax,%eax
mov    %rax,0xc0(%rsp)
mov    %r11,%rax
imul   %r11,%rax
lea    (%r10,%rax,8),%rbx
add    $0xfffffffffffffff8,%rbx
lea    0x0(,%r11,8),%r14
mov    %r14,%rcx
xor    $0xfffffffffffffff8,%rcx
mov    %rcx,0x20(%rsp)
lea    0x1(%rbp),%rcx
mov    %rcx,0x10(%rsp)
lea    0x1(%r11),%rcx
imul   %r11,%rcx
lea    (%r10,%rcx,8),%rdx
mov    %rdx,0x60(%rsp)
lea    (%r10,%rcx,8),%r12
add    $0xfffffffffffffff8,%r12
lea    (%r10,%rax,8),%rax
mov    %rax,0x80(%rsp)
xor    %esi,%esi
xorpd  %xmm3,%xmm3
movsd  0xf8f(%rip),%xmm5
mov    %r11,%r13
jmp    30e7 <svd+0x1f97>
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%eax
imul   0x18(%rsp),%eax
cltq
add    %r13,%rax
movsd  (%r10,%rax,8),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,(%r10,%rax,8)
add    $0x1,%rsi
mov    0x20(%rsp),%rax
add    %rax,%rbx
add    %rax,0x60(%rsp)
add    %rax,%r12
add    %rax,0x80(%rsp)
cmp    0xc0(%rsp),%rsi
je     2415 <svd+0x12c5>
mov    %r13,%r15
add    $0xffffffffffffffff,%r13
movsd  -0x8(%r8,%r15,8),%xmm6
cmp    %rbp,%r15
mov    %rsi,0x40(%rsp)
jge    3210 <svd+0x20c0>
mov    0x78(%rsp),%rax
add    %esi,%eax
lea    0x8(,%rax,8),%rdx
mov    0x28(%rsp),%rax
imul   %esi,%eax
add    0x38(%rsp),%eax
cltq
lea    (%r10,%rax,8),%rdi
xor    %esi,%esi
movsd  %xmm6,0x8(%rsp)
call   1040 <memset@plt>
movsd  0x8(%rsp),%xmm6
movsd  0xee1(%rip),%xmm5
xorpd  %xmm3,%xmm3
mov    0x30(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
ucomisd %xmm3,%xmm6
jne    3166 <svd+0x2016>
jnp    3260 <svd+0x2110>
mov    %r13d,%eax
imul   0x18(%rsp),%eax
cltq
add    %r13,%rax
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
mov    0x80(%rsp),%rax
mov    0x60(%rsp),%rcx
mov    %r15,%r9
nopl   (%rax)
xorpd  %xmm1,%xmm1
xor    %esi,%esi
mov    %r15,%rdx
nopl   0x0(%rax)
movsd  (%r12,%rsi,1),%xmm2
mulsd  (%rcx,%rsi,1),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdx
add    %r14,%rsi
cmp    %rbp,%rdx
jl     31a0 <svd+0x2050>
divsd  %xmm0,%xmm1
xor    %esi,%esi
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rsi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    $0x1,%rdx
add    %r14,%rsi
cmp    %rbp,%rdx
jl     31d0 <svd+0x2080>
add    $0x1,%r9
add    $0x8,%rcx
add    $0x8,%rax
cmp    %rbp,%r9
jl     3190 <svd+0x2040>
jmp    3218 <svd+0x20c8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomisd %xmm3,%xmm6
jne    3218 <svd+0x20c8>
jnp    3260 <svd+0x2110>
mov    0x10(%rsp),%rax
mov    %rbx,%rcx
cmp    %rbp,%r15
movapd 0x130(%rsp),%xmm4
mov    0x40(%rsp),%rsi
jg     30a0 <svd+0x1f50>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
divsd  %xmm6,%xmm0
movsd  %xmm0,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r15
jne    3240 <svd+0x20f0>
jmp    30a0 <svd+0x1f50>
nopl   (%rax)
mov    0x10(%rsp),%rax
mov    %rbx,%rcx
cmp    %rbp,%r15
movapd 0x130(%rsp),%xmm4
mov    0x40(%rsp),%rsi
jg     30a0 <svd+0x1f50>
nop
movq   $0x0,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r15
jne    3280 <svd+0x2130>
jmp    30a0 <svd+0x1f50>

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

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