void svd(double **a, int n, int m, double *w, double **v) {
  double *rv1;
  int i, j, k, l = -1;
  double tst1, c, f, g, h, s, scale;
  assert(m > 0 && n > 0);
  rv1 = malloc(n * sizeof(double));
  g = 0.0;
  scale = 0.0;
  tst1 = 0.0;
  for (i = 0; i < n; i++) {
    l = i + 1;
    rv1[i] = scale * g;
    g = 0.0;
    s = 0.0;
    scale = 0.0;
    if (i < m) {
      for (k = i; k < m; k++)
        scale += fabs(a[k][i]);
      if (scale != 0.0) {
        for (k = i; k < m; k++) {
          a[k][i] /= scale;
          s += a[k][i] * a[k][i];
        }
        f = a[i][i];
        g = -copysign(sqrt(s), f);
        h = f * g - s;
        a[i][i] = f - g;
        if (i < n - 1) {
          for (j = l; j < n; j++) {
            s = 0.0;
            for (k = i; k < m; k++)
              s += a[k][i] * a[k][j];
            f = s / h;
            for (k = i; k < m; k++)
              a[k][j] += f * a[k][i];
          }
        }
        for (k = i; k < m; k++)
          a[k][i] *= scale;
      }
    }
    w[i] = scale * g;
    g = 0.0;
    s = 0.0;
    scale = 0.0;
    if (i < m && i < n - 1) {
      for (k = l; k < n; k++)
        scale += fabs(a[i][k]);
      if (scale != 0.0) {
        for (k = l; k < n; k++) {
          a[i][k] /= scale;
          s += a[i][k] * a[i][k];
        }
        f = a[i][l];
        g = -copysign(sqrt(s), f);
        h = f * g - s;
        a[i][l] = f - g;
        for (k = l; k < n; k++)
          rv1[k] = a[i][k] / h;
        for (j = l; j < m; j++) {
          s = 0.0;
          for (k = l; k < n; k++)
            s += a[j][k] * a[i][k];
          for (k = l; k < n; k++)
            a[j][k] += s * rv1[k];
        }
        for (k = l; k < n; k++)
          a[i][k] *= scale;
      }
    }
    {
      double tmp = fabs(w[i]) + fabs(rv1[i]);
      tst1 = (tst1 > tmp) ? tst1 : tmp;
    }
  }
  for (i = n - 1; i >= 0; i--) {
    if (i < n - 1) {
      if (g != 0.0) {
        for (j = l; j < n; j++)
          v[j][i] = (a[i][j] / a[i][l]) / g;
        for (j = l; j < n; j++) {
          s = 0.0;
          for (k = l; k < n; k++)
            s += a[i][k] * v[k][j];
          for (k = l; k < n; k++)
            v[k][j] += s * v[k][i];
        }
      }
      for (j = l; j < n; j++) {
        v[i][j] = 0.0;
        v[j][i] = 0.0;
      }
    }
    v[i][i] = 1.0;
    g = rv1[i];
    l = i;
  }
  for (i = (m < n) ? m - 1 : n - 1; i >= 0; i--) {
    l = i + 1;
    g = w[i];
    if (i != n - 1)
      for (j = l; j < n; j++)
        a[i][j] = 0.0;
    if (g != 0.0) {
      for (j = l; j < n; j++) {
        s = 0.0;
        for (k = l; k < m; k++)
          s += a[k][i] * a[k][j];
        f = (s / a[i][i]) / g;
        for (k = i; k < m; k++)
          a[k][j] += f * a[k][i];
      }
      for (j = i; j < m; j++)
        a[j][i] /= g;
    } else
      for (j = i; j < m; j++)
        a[j][i] = 0.0;
    a[i][i] += 1.0;
  }
  for (k = n - 1; k >= 0; k--) {
    int k1 = k - 1;
    int its = 0;
    while (1) {
      int docancellation = 1;
      double x, y, z;
      int l1 = -1;
      its++;
      if (its > 30)
        csa_quit("svd(): no convergence in %d iterations", 30);
      for (l = k; l >= 0; l--) {
        double tst2 = fabs(rv1[l]) + tst1;
        if (tst2 == tst1) {
          docancellation = 0;
          break;
        }
        l1 = l - 1;
        tst2 = fabs(w[l - 1]) + tst1;
        if (tst2 == tst1)
          break;
      }
      if (docancellation) {
        c = 0.0;
        s = 1.0;
        for (i = l; i <= k; i++) {
          f = s * rv1[i];
          rv1[i] = c * rv1[i];
          if ((fabs(f) + tst1) == tst1)
            break;
          g = w[i];
          h = hypot(f, g);
          w[i] = h;
          h = 1.0 / h;
          c = g * h;
          s = -f * h;
          for (j = 0; j < m; j++) {
            double y = a[j][l1];
            double z = a[j][i];
            a[j][l1] = y * c + z * s;
            a[j][i] = z * c - y * s;
          }
        }
      }
      z = w[k];
      if (l != k) {
        int i1;
        x = w[l];
        y = w[k1];
        g = rv1[k1];
        h = rv1[k];
        f = 0.5 * (((g + z) / h) * ((g - z) / y) + y / h - h / y);
        g = hypot(f, 1.0);
        f = x - (z / x) * z + (h / x) * (y / (f + copysign(g, f)) - h);
        c = 1.0;
        s = 1.0;
        for (i1 = l; i1 < k; i1++) {
          i = i1 + 1;
          g = rv1[i];
          y = w[i];
          h = s * g;
          g = c * g;
          z = hypot(f, h);
          rv1[i1] = z;
          c = f / z;
          s = h / z;
          f = x * c + g * s;
          g = g * c - x * s;
          h = y * s;
          y *= c;
          for (j = 0; j < n; j++) {
            x = v[j][i1];
            z = v[j][i];
            v[j][i1] = x * c + z * s;
            v[j][i] = z * c - x * s;
          }
          z = hypot(f, h);
          w[i1] = z;
          if (z != 0.0) {
            c = f / z;
            s = h / z;
          }
          f = c * g + s * y;
          x = c * y - s * g;
          for (j = 0; j < m; j++) {
            y = a[j][i1];
            z = a[j][i];
            a[j][i1] = y * c + z * s;
            a[j][i] = z * c - y * s;
          }
        }
        rv1[l] = 0.0;
        rv1[k] = f;
        w[k] = x;
      } else {
        if (z < 0.0) {
          w[k] = -z;
          for (j = 0; j < n; j++)
            v[j][k] = -v[j][k];
        }
        break;
      }
    }
  }
  free(rv1);
}


x86 assembly (clang, -O0):
<svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0xffffffff,-0x38(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0xc5(%rbp)
jle    11a3 <svd+0x43>
cmpl   $0x0,-0xc(%rbp)
setg   %al
mov    %al,-0xc5(%rbp)
mov    -0xc5(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18f2 <svd+0x792>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    151f <svd+0x3bf>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    127f <svd+0x11f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d9d(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    123b <svd+0xdb>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    129c <svd+0x13c>
jp     129c <svd+0x13c>
jmp    151a <svd+0x3ba>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    131b <svd+0x1bb>
movsd  -0x70(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a2 <svd+0x142>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
call   1070 <sqrt@plt>
movsd  -0x50(%rbp),%xmm1
movaps 0x1cc5(%rip),%xmm2
pand   %xmm2,%xmm1
movaps 0x1caa(%rip),%xmm2
pand   %xmm2,%xmm0
por    %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14d6 <svd+0x376>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14d1 <svd+0x371>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1453 <svd+0x2f3>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13fd <svd+0x29d>
movsd  -0x68(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14be <svd+0x35e>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1468 <svd+0x308>
jmp    14c3 <svd+0x363>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13e3 <svd+0x283>
jmp    14d6 <svd+0x376>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1515 <svd+0x3b5>
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14dc <svd+0x37c>
jmp    151a <svd+0x3ba>
jmp    151f <svd+0x3bf>
movsd  -0x70(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    186f <svd+0x70f>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    186f <svd+0x70f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15b5 <svd+0x455>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1a67(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1571 <svd+0x411>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15d2 <svd+0x472>
jp     15d2 <svd+0x472>
jmp    186a <svd+0x70a>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1651 <svd+0x4f1>
movsd  -0x70(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15d8 <svd+0x478>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
call   1070 <sqrt@plt>
movsd  -0x50(%rbp),%xmm1
movaps 0x198f(%rip),%xmm2
pand   %xmm2,%xmm1
movaps 0x1974(%rip),%xmm2
pand   %xmm2,%xmm0
por    %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1749 <svd+0x5e9>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1708 <svd+0x5a8>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1826 <svd+0x6c6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17bf <svd+0x65f>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1769 <svd+0x609>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1813 <svd+0x6b3>
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17c5 <svd+0x665>
jmp    1818 <svd+0x6b8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    174f <svd+0x5ef>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1865 <svd+0x705>
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    182c <svd+0x6cc>
jmp    186a <svd+0x70a>
jmp    186f <svd+0x70f>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x177d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1765(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    18ca <svd+0x76a>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    18d7 <svd+0x777>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e5 <svd+0x85>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1b19 <svd+0x9b9>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1ad6 <svd+0x976>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1933 <svd+0x7d3>
jp     1933 <svd+0x7d3>
jmp    1a81 <svd+0x921>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1997 <svd+0x837>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1939 <svd+0x7d9>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a7c <svd+0x91c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a0d <svd+0x8ad>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19b7 <svd+0x857>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a69 <svd+0x909>
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a13 <svd+0x8b3>
jmp    1a6e <svd+0x90e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    199d <svd+0x83d>
jmp    1a81 <svd+0x921>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ad1 <svd+0x971>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a87 <svd+0x927>
jmp    1ad6 <svd+0x976>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x1532(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    18fb <svd+0x79b>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b36 <svd+0x9d6>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1b42 <svd+0x9e2>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1d99 <svd+0xc39>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1bbe <svd+0xa5e>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bb9 <svd+0xa59>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b87 <svd+0xa27>
jmp    1bbe <svd+0xa5e>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1bdb <svd+0xa7b>
jp     1bdb <svd+0xa7b>
jmp    1d2c <svd+0xbcc>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ce4 <svd+0xb84>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c51 <svd+0xaf1>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bfb <svd+0xa9b>
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1cd1 <svd+0xb71>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c7b <svd+0xb1b>
jmp    1cd6 <svd+0xb76>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1be1 <svd+0xa81>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d27 <svd+0xbc7>
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1cea <svd+0xb8a>
jmp    1d69 <svd+0xc09>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d64 <svd+0xc04>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d32 <svd+0xbd2>
jmp    1d69 <svd+0xc09>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x129f(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b4b <svd+0x9eb>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     275a <svd+0x15fa>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
movl   $0x1,-0x84(%rbp)
movl   $0xffffffff,-0xa4(%rbp)
ff ff ff
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
cmpl   $0x1e,-0x80(%rbp)
jle    1df6 <svd+0xc96>
lea    0x1246(%rip),%rdi
mov    $0x1e,%esi
mov    $0x0,%al
call   1080 <csa_quit@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1eba <svd+0xd5a>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x11e6(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jne    1e53 <svd+0xcf3>
jp     1e53 <svd+0xcf3>
movl   $0x0,-0x84(%rbp)
jmp    1eba <svd+0xd5a>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1188(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jne    1ea7 <svd+0xd47>
jp     1ea7 <svd+0xd47>
jmp    1eba <svd+0xd5a>
jmp    1eac <svd+0xd4c>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1dfc <svd+0xc9c>
cmpl   $0x0,-0x84(%rbp)
je     20cc <svd+0xf6c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x1149(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     20c7 <svd+0xf67>
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movaps 0x10d0(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jne    1f4f <svd+0xdef>
jp     1f4f <svd+0xdef>
jmp    20c7 <svd+0xf67>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x1091(%rip),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    20b4 <svd+0xf54>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1fd5 <svd+0xe75>
jmp    20b9 <svd+0xf59>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ee2 <svd+0xd82>
jmp    20cc <svd+0xf6c>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     2699 <svd+0x1539>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
addsd  -0xa0(%rbp),%xmm1
ff
divsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
subsd  -0xa0(%rbp),%xmm2
ff
divsd  -0x98(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x60(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
subsd  %xmm0,%xmm1
movsd  0xe98(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xe7a(%rip),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
divsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm4
movsd  -0x50(%rbp),%xmm5
movaps 0xdf6(%rip),%xmm6
pand   %xmm6,%xmm5
movaps 0xddb(%rip),%xmm6
pand   %xmm6,%xmm4
por    %xmm5,%xmm4
addsd  %xmm4,%xmm3
divsd  %xmm3,%xmm2
subsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xdd1(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xdc4(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    265d <svd+0x14fd>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2489 <svd+0x1329>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    23aa <svd+0x124a>
movsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    24d8 <svd+0x1378>
jp     24d8 <svd+0x1378>
jmp    24fc <svd+0x139c>
movsd  -0x50(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2644 <svd+0x14e4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2565 <svd+0x1405>
jmp    2649 <svd+0x14e9>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    226a <svd+0x110a>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2742 <svd+0x15e2>
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    273d <svd+0x15dd>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2738 <svd+0x15d8>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    26dd <svd+0x157d>
jmp    273d <svd+0x15dd>
jmp    2747 <svd+0x15e7>
jmp    1dbc <svd+0xc5c>
jmp    274c <svd+0x15ec>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1da2 <svd+0xc42>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r8,%r12
mov    %rcx,%r13
mov    %edx,%r14d
mov    %esi,%ebx
mov    %rdi,%r15
test   %edx,%edx
setg   %al
test   %esi,%esi
setg   %cl
and    %al,%cl
movzbl %cl,%edi
xor    %eax,%eax
call   1050 <assert@plt>
movslq %ebx,%rbp
lea    0x0(,%rbp,8),%rdi
call   1060 <malloc@plt>
mov    %ebx,%edi
lea    -0x1(%rbp),%ecx
movslq %r14d,%rdx
mov    %rdx,0xa0(%rsp)
mov    %rcx,0x110(%rsp)
mov    %ecx,%ecx
mov    %rcx,0x38(%rsp)
mov    %ebx,%ecx
mov    %r14,0x68(%rsp)
mov    %r14d,%ebx
mov    %rbp,0x10(%rsp)
test   %ebp,%ebp
mov    %r13,0x28(%rsp)
mov    %r15,0x98(%rsp)
mov    %rax,0x8(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rbx,0x120(%rsp)
mov    %edi,0xe0(%rsp)
jle    2094 <svd+0xf24>
mov    %r13,%r14
lea    -0x2(%rcx),%rdx
mov    %rdx,0x180(%rsp)
lea    0x18(%rax),%r13
lea    -0x3(%rcx),%r9
mov    %rax,%rdi
add    $0x38,%rdi
lea    -0x5(%rcx),%r10
xorpd  %xmm8,%xmm8
mov    $0x1,%esi
mov    %rsi,0x18(%rsp)
mov    $0x7,%esi
mov    %rsi,0xf8(%rsp)
xor    %r8d,%r8d
movapd 0x1da6(%rip),%xmm7
movapd 0x1dad(%rip),%xmm9
movapd 0x1d94(%rip),%xmm10
mov    %rcx,0xc0(%rsp)
mov    %rbx,(%rsp)
mov    $0x3,%r11d
mov    %r15,%rbx
xorpd  %xmm12,%xmm12
xorpd  %xmm11,%xmm11
xorpd  %xmm4,%xmm4
mov    %r15,%rsi
mov    %rcx,%rbp
mov    $0xffffffffffffffff,%rcx
jmp    1331 <svd+0x1c1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r14,%r15,8),%rdx
movq   $0x0,(%r14,%r15,8)
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
movsd  (%rdx),%xmm0
movsd  (%rax,%r15,8),%xmm1
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movsd  0xb8(%rsp),%xmm0
maxsd  %xmm1,%xmm0
movapd %xmm0,%xmm4
addq   $0x1,0x18(%rsp)
add    $0x8,%rbx
addq   $0xffffffffffffffff,(%rsp)
addq   $0xffffffffffffffff,0xc0(%rsp)
add    $0x8,%r13
add    $0x1,%r11
add    $0xffffffffffffffff,%r9
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%r10
addq   $0x1,0xf8(%rsp)
add    $0x8,%rdi
cmp    %rbp,%r8
je     1d69 <svd+0xbf9>
mov    %r8,%r15
mulsd  %xmm11,%xmm12
add    $0x1,%r8
movsd  %xmm12,(%rax,%r15,8)
cmp    0xa0(%rsp),%r15
movsd  %xmm4,0xb8(%rsp)
jge    12b0 <svd+0x140>
mov    %rdi,0x80(%rsp)
mov    %r8,0x40(%rsp)
mov    %r13,0x78(%rsp)
mov    %rcx,0x90(%rsp)
mov    %r10,%r8
shr    $0x2,%r8
add    $0x1,%r8
and    $0xfffffffffffffffe,%r8
mov    %r10d,%edi
and    $0x3,%edi
mov    %r9,%r13
shr    %r13
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    %r15,%rax
not    %rax
lea    (%rax,%rbp,1),%rcx
mov    %rcx,0x50(%rsp)
lea    (%rax,%rbp,1),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x150(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x158(%rsp)
mov    0x180(%rsp),%rcx
sub    %r15,%rcx
mov    %rcx,0x138(%rsp)
add    %rbp,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x128(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,0x130(%rsp)
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    (%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rbp
jne    1410 <svd+0x2a0>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm3
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%r14
mov    0xc0(%rsp),%rbp
mov    %rbx,0x20(%rsp)
jne    1453 <svd+0x2e3>
jnp    165d <svd+0x4ed>
mov    %rdi,0x88(%rsp)
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    %rbx,%rdi
mov    (%rsp),%rbx
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rax
cmp    %rax,%rbx
jne    1470 <svd+0x300>
mov    (%rsi,%r15,8),%rax
movsd  (%rax,%r15,8),%xmm5
ucomisd %xmm8,%xmm2
mov    %r11,0xd8(%rsp)
mov    %r8,0x118(%rsp)
jb     14c2 <svd+0x352>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    154f <svd+0x3df>
movapd %xmm2,%xmm0
mov    %r9,0x108(%rsp)
mov    %r10,0x100(%rsp)
movsd  %xmm3,0x70(%rsp)
movapd %xmm5,0x140(%rsp)
movsd  %xmm2,0x160(%rsp)
call   1080 <sqrt@plt>
movsd  0x160(%rsp),%xmm2
movapd 0x140(%rsp),%xmm5
movsd  0x70(%rsp),%xmm3
xorpd  %xmm11,%xmm11
movapd 0x1ae7(%rip),%xmm10
movapd 0x1aee(%rip),%xmm9
movapd 0x1ad6(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x100(%rsp),%r10
mov    0x108(%rsp),%r9
mov    0xc0(%rsp),%rbp
mov    0x98(%rsp),%rsi
mov    0x20(%rsp),%rbx
mov    0x88(%rsp),%rdi
movapd %xmm7,%xmm1
andnpd %xmm5,%xmm1
andpd  %xmm7,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm5,%xmm1
addsd  %xmm0,%xmm1
xorpd  %xmm9,%xmm0
mov    (%rsi,%r15,8),%rax
movsd  %xmm1,(%rax,%r15,8)
cmp    0x38(%rsp),%r15
jae    161c <svd+0x4ac>
cmp    %r14,0x40(%rsp)
jge    161c <svd+0x4ac>
mulsd  %xmm0,%xmm5
subsd  %xmm2,%xmm5
mov    0x18(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    (%rsp),%r8
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r8
jne    15c0 <svd+0x450>
divsd  %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    15f0 <svd+0x480>
add    $0x1,%rax
cmp    0x30(%rsp),%rax
jne    15b0 <svd+0x440>
xor    %eax,%eax
mov    (%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%r15,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1630 <svd+0x4c0>
mov    0xd8(%rsp),%r11
mov    0x118(%rsp),%r8
mulsd  %xmm0,%xmm3
mov    0x28(%rsp),%rax
lea    (%rax,%r15,8),%rcx
mov    %rcx,0x70(%rsp)
movsd  %xmm3,(%rax,%r15,8)
cmp    0x38(%rsp),%r15
mov    0x90(%rsp),%rcx
jae    1760 <svd+0x5f0>
cmp    %r14,0x40(%rsp)
jge    1760 <svd+0x5f0>
lea    0x0(,%r15,8),%rax
add    (%rsi,%r15,8),%rax
xorpd  %xmm12,%xmm12
mov    $0x1,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    16b0 <svd+0x540>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm12
jne    16d9 <svd+0x569>
jnp    1790 <svd+0x620>
mov    %r11,0xd8(%rsp)
mov    (%rsi,%r15,8),%rax
xorpd  %xmm1,%xmm1
cmp    %r14,0x40(%rsp)
jge    1720 <svd+0x5b0>
lea    (%rax,%r15,8),%rcx
xorpd  %xmm1,%xmm1
mov    $0x1,%edx
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm12,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1700 <svd+0x590>
mov    0x40(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
ucomisd %xmm8,%xmm1
mov    %r9,0x108(%rsp)
mov    %r10,0x100(%rsp)
mov    %r8,0x118(%rsp)
mov    %rdi,0x88(%rsp)
jb     17a9 <svd+0x639>
xorps  %xmm11,%xmm11
sqrtsd %xmm1,%xmm11
jmp    181b <svd+0x6ab>
nop
xorpd  %xmm12,%xmm12
mov    0x28(%rsp),%r14
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rbp
mov    0x78(%rsp),%r13
mov    0x40(%rsp),%r8
mov    0x70(%rsp),%rdx
mov    0x80(%rsp),%rdi
jmp    12c6 <svd+0x156>
mov    0x28(%rsp),%r14
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rbp
mov    0x90(%rsp),%rcx
jmp    1774 <svd+0x604>
movapd %xmm1,%xmm0
movapd %xmm12,0x140(%rsp)
movapd %xmm2,0x160(%rsp)
movsd  %xmm1,0x178(%rsp)
call   1080 <sqrt@plt>
movsd  0x178(%rsp),%xmm1
movapd 0x160(%rsp),%xmm2
movapd 0x140(%rsp),%xmm12
mov    0x40(%rsp),%rcx
movapd 0x1808(%rip),%xmm10
movapd 0x180f(%rip),%xmm9
movapd 0x17f7(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x98(%rsp),%rsi
movapd %xmm0,%xmm11
mov    0xa0(%rsp),%r10
movapd %xmm7,%xmm0
andnpd %xmm2,%xmm0
andpd  %xmm7,%xmm11
orpd   %xmm0,%xmm11
movapd %xmm2,%xmm0
addsd  %xmm11,%xmm0
xorpd  %xmm9,%xmm11
mov    (%rsi,%r15,8),%r8
movsd  %xmm0,(%r8,%rcx,8)
mov    %rcx,%rdi
cmp    %r14,%rcx
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rdx
jge    1948 <svd+0x7d8>
mulsd  %xmm11,%xmm2
subsd  %xmm1,%xmm2
mov    0x18(%rsp),%rcx
cmpq   $0x2,0x50(%rsp)
jb     191b <svd+0x7ab>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x2,0x128(%rsp)
jae    1894 <svd+0x724>
xor    %edx,%edx
jmp    18d8 <svd+0x768>
mov    0xd8(%rsp),%rax
lea    (%r8,%rax,8),%rcx
xor    %edx,%edx
mov    0x78(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rax,%rdx,8)
movupd (%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r13
jne    18b0 <svd+0x740>
mov    0x50(%rsp),%rbp
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
testb  $0x1,0x130(%rsp)
01
je     1907 <svd+0x797>
add    0x18(%rsp),%rdx
movupd (%r8,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
mov    0x8(%rsp),%rax
movupd %xmm1,(%rax,%rdx,8)
cmp    %rcx,%rbp
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rdx
je     1948 <svd+0x7d8>
add    0x18(%rsp),%rcx
mov    0x8(%rsp),%rax
mov    0x30(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rcx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1930 <svd+0x7c0>
mov    %rdi,%rcx
mov    %rdi,%r9
cmp    %r10,%rdi
mov    %rdx,%rbp
mov    0x18(%rsp),%r13
jge    1bf1 <svd+0xa81>
mov    0x50(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x128(%rsp)
add    %r13,%rcx
mov    %rcx,0x140(%rsp)
mov    0x90(%rsp),%rcx
neg    %rcx
mov    %rcx,0x130(%rsp)
lea    (%r8,%r13,8),%rdi
mov    %r13,%r11
jmp    19b2 <svd+0x842>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    0x120(%rsp),%r11
je     1bf1 <svd+0xa81>
cmp    %r14,%r9
jge    19a0 <svd+0x830>
mov    (%rsi,%r11,8),%rdx
testb  $0x3,0x50(%rsp)
je     1a9b <svd+0x92b>
lea    (%rdx,%r13,8),%rcx
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    0x88(%rsp),%r10
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%r10
jne    19e0 <svd+0x870>
add    0x130(%rsp),%rbx
cmpq   $0x3,0x138(%rsp)
jb     1a5b <svd+0x8eb>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,8),%xmm1
movsd  0x8(%rdx,%rbx,8),%xmm2
mulsd  (%r8,%rbx,8),%xmm1
mulsd  0x8(%r8,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rdx,%rbx,8),%xmm3
mulsd  0x10(%r8,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rdx,%rbx,8),%xmm0
mulsd  0x18(%r8,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1a10 <svd+0x8a0>
mov    0x10(%rsp),%r14
cmp    %r14,%r9
mov    0x20(%rsp),%rbx
jge    19a0 <svd+0x830>
mov    (%rsi,%r11,8),%rdx
mov    %r13,%rcx
cmpq   $0x4,0x50(%rsp)
jb     1bd0 <svd+0xa60>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x150(%rsp)
jae    1ab3 <svd+0x943>
xor    %ebx,%ebx
jmp    1b54 <svd+0x9e4>
xorpd  %xmm0,%xmm0
mov    %r13,%rbx
cmpq   $0x3,0x138(%rsp)
jae    1a10 <svd+0x8a0>
jmp    1a5b <svd+0x8eb>
mov    0xf8(%rsp),%rcx
lea    (%rdx,%rcx,8),%rcx
mov    0x118(%rsp),%rbp
xor    %ebx,%ebx
mov    0x80(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r13,%rbx,8),%xmm2
movupd -0x20(%r13,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rcx,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rcx,%rbx,8),%xmm2
movupd -0x10(%rcx,%rbx,8),%xmm5
movupd (%rcx,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rcx,%rbx,8)
movupd %xmm3,-0x20(%rcx,%rbx,8)
movupd -0x10(%r13,%rbx,8),%xmm2
movupd 0x0(%r13,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd %xmm3,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1ae0 <svd+0x970>
testb  $0x1,0x158(%rsp)
01
mov    0x30(%rsp),%rbp
mov    0x18(%rsp),%r13
je     1b9c <svd+0xa2c>
add    %r13,%rbx
movupd (%rax,%rbx,8),%xmm2
movupd 0x10(%rax,%rbx,8),%xmm3
movupd (%rdx,%rbx,8),%xmm4
movupd 0x10(%rdx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rbx,8)
movupd %xmm3,0x10(%rdx,%rbx,8)
mov    0x140(%rsp),%rcx
mov    0x128(%rsp),%rbx
cmp    %rbx,0x50(%rsp)
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%rbx
je     19a0 <svd+0x830>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1bd0 <svd+0xa60>
jmp    19a0 <svd+0x830>
cmp    %r14,%r9
jge    1c46 <svd+0xad6>
mov    %r13,%rdx
cmpq   $0x4,0x50(%rsp)
mov    0x28(%rsp),%r14
mov    0x78(%rsp),%r13
mov    0x108(%rsp),%r9
mov    0x80(%rsp),%rdi
mov    0x100(%rsp),%r10
jb     1d30 <svd+0xbc0>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x4,0x150(%rsp)
jae    1c6d <svd+0xafd>
mov    %r13,%r11
xor    %ecx,%ecx
jmp    1cd8 <svd+0xb68>
mov    0x28(%rsp),%r14
mov    0x78(%rsp),%r13
mov    0x108(%rsp),%r9
mov    0x80(%rsp),%rdi
mov    0x100(%rsp),%r10
jmp    1d4a <svd+0xbda>
mov    %r13,%r11
mov    0xf8(%rsp),%rcx
lea    (%r8,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0x118(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rcx,8),%xmm1
movupd -0x20(%rdx,%rcx,8),%xmm2
movupd -0x10(%rdx,%rcx,8),%xmm3
movupd (%rdx,%rcx,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%rdx,%rcx,8)
movupd %xmm2,-0x20(%rdx,%rcx,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,-0x10(%rdx,%rcx,8)
movupd %xmm4,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r13
jne    1c90 <svd+0xb20>
mov    0x50(%rsp),%r13
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x158(%rsp)
01
je     1d15 <svd+0xba5>
add    0x18(%rsp),%rcx
movupd (%r8,%rcx,8),%xmm1
movupd 0x10(%r8,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%r8,%rcx,8)
movupd %xmm2,0x10(%r8,%rcx,8)
cmp    %rdx,%r13
mov    %r11,%r13
je     1d4a <svd+0xbda>
add    0x18(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8,%rdx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%r8,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1d30 <svd+0xbc0>
mov    0xd8(%rsp),%r11
mov    0x90(%rsp),%rcx
mov    0x40(%rsp),%r8
mov    0x70(%rsp),%rdx
jmp    12c6 <svd+0x156>
mov    0xe0(%rsp),%edi
test   %edi,%edi
jle    209b <svd+0xf2b>
mov    0x10(%rsp),%rbp
mov    %rbp,%rax
neg    %rax
mov    %rax,0x50(%rsp)
xor    %r13d,%r13d
movabs $0x3ff0000000000000,%r8
xorpd  %xmm0,%xmm0
mov    %rbp,%rsi
mov    %edi,%r14d
jmp    1dd4 <svd+0xc64>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rsi,8),%rax
mov    %r8,(%rax,%rsi,8)
mov    0x8(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm11
add    $0x1,%r13b
mov    %esi,%r14d
cmp    $0x1,%rbx
jle    20a2 <svd+0xf32>
mov    %rsi,%rbx
movzbl %r13b,%r13d
and    $0x3,%r13d
add    $0xffffffffffffffff,%rsi
cmp    0x38(%rsp),%rbx
jg     1db0 <svd+0xc40>
mov    %rbx,0x40(%rsp)
movslq %r14d,%r15
mov    %rbp,%r10
sub    %r15,%r10
mov    %r15,%r11
not    %r11
lea    (%r11,%rbp,1),%rax
mov    %rax,(%rsp)
ucomisd %xmm0,%xmm11
jne    1e13 <svd+0xca3>
jnp    1fd0 <svd+0xe60>
cmp    0xe0(%rsp),%r14d
jge    1fd0 <svd+0xe60>
movapd %xmm4,%xmm5
mov    0x98(%rsp),%rax
mov    (%rax,%rsi,8),%rax
movslq %r14d,%rcx
mov    %rcx,%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdi,8),%xmm1
divsd  (%rax,%rcx,8),%xmm1
divsd  %xmm11,%xmm1
mov    (%r12,%rdi,8),%rbx
movsd  %xmm1,(%rbx,%rsi,8)
mov    0x10(%rsp),%rbp
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1e40 <svd+0xcd0>
cmp    0xe0(%rsp),%r14d
movapd %xmm5,%xmm4
jge    1fd0 <svd+0xe60>
movslq %r14d,%r8
mov    0x98(%rsp),%rax
mov    (%rax,%rsi,8),%rdi
lea    0x1(%r8),%rax
mov    %rax,0xc0(%rsp)
mov    %r8,%rax
jmp    1eb4 <svd+0xd44>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rdx,%rax
mov    %rdx,%rbp
movapd %xmm5,%xmm4
je     1fd0 <svd+0xe60>
xorpd  %xmm1,%xmm1
test   $0x3,%r10b
je     1ef0 <svd+0xd80>
mov    %r13,%rcx
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rbx,8),%xmm2
mov    (%r12,%rbx,8),%r9
mulsd  (%r9,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    1ed0 <svd+0xd60>
jmp    1ef3 <svd+0xd83>
nop
mov    %r8,%rbx
cmpq   $0x3,(%rsp)
mov    0x10(%rsp),%rbp
jb     1f57 <svd+0xde7>
nop
movsd  (%rdi,%rbx,8),%xmm2
movsd  0x8(%rdi,%rbx,8),%xmm3
mov    (%r12,%rbx,8),%rcx
mov    0x8(%r12,%rbx,8),%rdx
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rdx,%rax,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rdi,%rbx,8),%xmm2
mov    0x10(%r12,%rbx,8),%rcx
mulsd  (%rcx,%rax,8),%xmm2
movsd  0x18(%rdi,%rbx,8),%xmm1
mov    0x18(%r12,%rbx,8),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1f00 <svd+0xd90>
mov    %r8,%rbx
test   $0x1,%r10b
je     1f7f <svd+0xe0f>
mov    (%r12,%r8,8),%rcx
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0xc0(%rsp),%rbx
cmp    0x50(%rsp),%r11
mov    0x10(%rsp),%rdx
je     1ea0 <svd+0xd30>
nop
mov    (%r12,%rbx,8),%rcx
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0x8(%r12,%rbx,8),%rcx
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    1f90 <svd+0xe20>
jmp    1ea0 <svd+0xd30>
nopl   (%rax)
mov    0xe0(%rsp),%edi
cmp    %edi,%r14d
movabs $0x3ff0000000000000,%r8
mov    0x40(%rsp),%rbx
jge    1db0 <svd+0xc40>
mov    (%r12,%rsi,8),%rax
test   $0x3,%r10b
je     201e <svd+0xeae>
mov    %r13,%rcx
nopl   0x0(%rax)
movq   $0x0,(%rax,%r15,8)
mov    (%r12,%r15,8),%rdx
movq   $0x0,(%rdx,%rsi,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rcx
jne    2000 <svd+0xe90>
cmpq   $0x3,(%rsp)
jb     1db0 <svd+0xc40>
nopl   0x0(%rax)
movq   $0x0,(%rax,%r15,8)
mov    (%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rsi,8)
movq   $0x0,0x8(%rax,%r15,8)
mov    0x8(%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rsi,8)
movq   $0x0,0x10(%rax,%r15,8)
mov    0x10(%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rsi,8)
movq   $0x0,0x18(%rax,%r15,8)
mov    0x18(%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rsi,8)
add    $0x4,%r15
cmp    %r15,%rbp
jne    2030 <svd+0xec0>
jmp    1db0 <svd+0xc40>
xorpd  %xmm4,%xmm4
mov    %r15,%rsi
mov    0x68(%rsp),%rcx
jmp    20af <svd+0xf3f>
mov    0x68(%rsp),%rcx
mov    0x98(%rsp),%rsi
lea    -0x1(%rcx),%eax
cmp    %edi,%ecx
cmovge 0x110(%rsp),%eax
test   %eax,%eax
movsd  %xmm4,0xb8(%rsp)
js     23bb <svd+0x124b>
lea    0x1(%rax),%edx
mov    0x110(%rsp),%rcx
sub    %edx,%ecx
mov    %rcx,0x110(%rsp)
mov    %eax,%ebp
lea    (%rsi,%rbp,8),%r13
mov    0x68(%rsp),%rax
mov    %eax,%r15d
sub    %edx,%r15d
add    $0x1,%r15d
sub    %dl,%al
mov    %al,0xc0(%rsp)
xor    %r8d,%r8d
xorpd  %xmm3,%xmm3
movsd  0xf11(%rip),%xmm5
mov    %rdx,0x50(%rsp)
mov    %edx,%r14d
jmp    2159 <svd+0xfe9>
nopl   0x0(%rax)
mov    (%rsi,%rbp,8),%rax
movsd  (%rax,%rbp,8),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%r8
add    $0xffffffff,%r14d
add    $0xffffffffffffffff,%rbp
add    $0xfffffffffffffff8,%r13
add    $0x1,%r15
addb   $0x1,0xc0(%rsp)
01
cmp    0x50(%rsp),%r8
je     23bb <svd+0x124b>
mov    0x28(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm6
lea    0x1(%rbp),%eax
mov    %eax,(%rsp)
cmp    0x38(%rsp),%rbp
je     21de <svd+0x106e>
cmp    %edi,(%rsp)
jge    21de <svd+0x106e>
mov    0x110(%rsp),%rax
add    %r8d,%eax
lea    0x8(,%rax,8),%rdx
mov    0x50(%rsp),%rax
sub    %r8d,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
add    (%rsi,%rbp,8),%rdi
xor    %esi,%esi
mov    %r14d,%ebx
mov    %r8,%r14
movsd  %xmm6,0x40(%rsp)
call   1040 <memset@plt>
movsd  0x40(%rsp),%xmm6
movsd  0xe64(%rip),%xmm5
xorpd  %xmm3,%xmm3
mov    %r14,%r8
mov    %ebx,%r14d
mov    0xe0(%rsp),%edi
movsd  0xb8(%rsp),%xmm4
mov    0x98(%rsp),%rsi
ucomisd %xmm3,%xmm6
jne    21ea <svd+0x107a>
jnp    2390 <svd+0x1220>
mov    %r8,0x40(%rsp)
cmp    %edi,(%rsp)
mov    0xa0(%rsp),%rdi
jge    2340 <svd+0x11d0>
movzbl 0xc0(%rsp),%r8d
and    $0x3,%r8d
shl    $0x3,%r8
movslq %r14d,%r11
mov    %rdi,%r10
sub    %r11,%r10
mov    %r11,%rbx
not    %rbx
add    %rdi,%rbx
mov    (%rsi,%rbp,8),%r9
mov    %r11,%rcx
jmp    223f <svd+0x10cf>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    0x10(%rsp),%rcx
jge    2340 <svd+0x11d0>
xorpd  %xmm0,%xmm0
mov    (%rsp),%eax
cmp    0x68(%rsp),%eax
jge    22ec <svd+0x117c>
xorpd  %xmm0,%xmm0
test   $0x3,%r10b
je     227e <svd+0x110e>
mov    %r8,%rdi
mov    %r11,%rax
mov    (%rsi,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    $0xfffffffffffffff8,%rdi
jne    2260 <svd+0x10f0>
jmp    2281 <svd+0x1111>
mov    %r11,%rax
cmp    $0x3,%rbx
mov    0xa0(%rsp),%rdi
jb     22ec <svd+0x117c>
nop
mov    (%rsi,%rax,8),%rdx
mov    0x8(%rsi,%rax,8),%rdi
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%rbp,8),%xmm2
mulsd  (%rdi,%rcx,8),%xmm2
mov    0xa0(%rsp),%rdi
addsd  %xmm1,%xmm2
mov    0x10(%rsi,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
mov    0x18(%rsi,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm0
mulsd  (%rdx,%rcx,8),%xmm0
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x4,%rax
cmp    %rdi,%rax
jl     2290 <svd+0x1120>
cmp    %rdi,%rbp
jge    2230 <svd+0x10c0>
divsd  (%r9,%rbp,8),%xmm0
divsd  %xmm6,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    2310 <svd+0x11a0>
jmp    2230 <svd+0x10c0>
cs nopw 0x0(%rax,%rax,1)
cmp    %rdi,%rbp
movsd  0xb8(%rsp),%xmm4
mov    0xe0(%rsp),%edi
mov    0x40(%rsp),%r8
jge    2120 <svd+0xfb0>
xor    %eax,%eax
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
divsd  %xmm6,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    2360 <svd+0x11f0>
jmp    2120 <svd+0xfb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    0xa0(%rsp),%rbp
jge    2120 <svd+0xfb0>
xor    %eax,%eax
mov    0x0(%r13,%rax,8),%rcx
movq   $0x0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    23a0 <svd+0x1230>
jmp    2120 <svd+0xfb0>
test   %edi,%edi
mov    0x28(%rsp),%r14
mov    0x8(%rsp),%rdi
mov    0x120(%rsp),%rcx
mov    0x10(%rsp),%rbx
jle    2c90 <svd+0x1b20>
lea    -0x1(%rbx),%rax
mov    %rax,0x88(%rsp)
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%rdx
mov    %rdx,0x18(%rsp)
mov    %eax,%r15d
and    $0xfffffffe,%r15d
and    $0xfffffffe,%ecx
mov    %rcx,0x90(%rsp)
mov    %eax,%esi
and    $0x3,%esi
mov    %eax,%r8d
and    $0xfffffffc,%r8d
movapd 0xbe6(%rip),%xmm2
movapd 0xbed(%rip),%xmm11
movsd  0xbf5(%rip),%xmm1
mov    %rsi,0x80(%rsp)
mov    %r8,0x78(%rsp)
jmp    2455 <svd+0x12e5>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rax
mov    0x10(%rsp),%rbx
add    $0xffffffffffffffff,%rbx
test   %rax,%rax
jle    2c90 <svd+0x1b20>
mov    0x88(%rsp),%rcx
lea    -0x1(%rcx),%rax
mov    %rax,0x88(%rsp)
xor    %ebp,%ebp
mov    %rbx,0x10(%rsp)
mov    %rcx,%rbx
mov    %rcx,0x20(%rsp)
jmp    24cd <svd+0x135d>
nopw   0x0(%rax,%rax,1)
movapd %xmm4,%xmm2
movapd 0xb83(%rip),%xmm11
movsd  0xb8b(%rip),%xmm1
mov    0x8(%rsp),%rax
mov    0xf8(%rsp),%rcx
movq   $0x0,(%rax,%rcx,8)
movsd  %xmm3,(%rax,%rbx,8)
movsd  %xmm2,(%r14,%rbx,8)
movsd  0xb8(%rsp),%xmm4
movapd 0xb3a(%rip),%xmm2
mov    0x138(%rsp),%ebp
cmp    $0x1e,%ebp
jb     2507 <svd+0x1397>
lea    0xb5f(%rip),%rdi
mov    $0x1e,%esi
xor    %eax,%eax
call   1090 <csa_quit@plt>
movsd  0xb33(%rip),%xmm1
movapd 0xb1a(%rip),%xmm11
movapd 0xb02(%rip),%xmm2
movsd  0xb8(%rsp),%xmm4
add    $0x1,%ebp
mov    %ebp,0x138(%rsp)
mov    0x10(%rsp),%rax
mov    %ebx,%r13d
mov    0x68(%rsp),%rbp
xchg   %ax,%ax
lea    -0x1(%rax),%ecx
mov    0x8(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
andpd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
jne    2541 <svd+0x13d1>
jnp    26df <svd+0x156f>
movsd  -0x10(%r14,%rax,8),%xmm0
andpd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
jne    2558 <svd+0x13e8>
jnp    2580 <svd+0x1410>
add    $0xffffffff,%r13d
add    $0xffffffffffffffff,%rax
jg     2520 <svd+0x13b0>
mov    $0xffffffff,%r13d
mov    $0xffffffffffffffff,%rax
jmp    2584 <svd+0x1414>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffffffffffffe,%rax
movslq %r13d,%rbx
cmp    %rbx,0x20(%rsp)
jge    25a0 <svd+0x1430>
mov    0x20(%rsp),%rbx
jmp    26df <svd+0x156f>
nopl   0x0(%rax,%rax,1)
movslq %eax,%rbp
xorpd  %xmm5,%xmm5
movapd %xmm1,%xmm7
jmp    25dc <svd+0x146c>
nopl   (%rax)
lea    0x1(%rbx),%rax
cmp    0x20(%rsp),%rbx
mov    %rax,%rbx
movsd  0xb8(%rsp),%xmm4
movapd 0xa33(%rip),%xmm2
movapd 0xa3a(%rip),%xmm11
jge    26d0 <svd+0x1560>
mov    0x8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mulsd  %xmm0,%xmm7
mulsd  %xmm0,%xmm5
movsd  %xmm5,(%rax,%rbx,8)
movapd %xmm7,%xmm0
andpd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
jne    260b <svd+0x149b>
jnp    26d0 <svd+0x1560>
mov    0x28(%rsp),%r14
movsd  (%r14,%rbx,8),%xmm1
movsd  %xmm1,(%rsp)
movapd %xmm7,%xmm0
movapd %xmm7,0xa0(%rsp)
call   1070 <hypot@plt>
movsd  (%rsp),%xmm5
movapd 0xa0(%rsp),%xmm7
movsd  0x9dd(%rip),%xmm1
mov    0x120(%rsp),%rsi
mov    0x98(%rsp),%rdx
movsd  %xmm0,(%r14,%rbx,8)
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
mulsd  %xmm2,%xmm5
xorpd  0x9a3(%rip),%xmm7
mulsd  %xmm2,%xmm7
cmpl   $0x0,0x68(%rsp)
jle    25b0 <svd+0x1440>
xor    %eax,%eax
xchg   %ax,%ax
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  (%rcx,%rbx,8),%xmm4
movapd %xmm7,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
mulsd  %xmm5,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,(%rcx,%rbx,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2680 <svd+0x1510>
jmp    25b0 <svd+0x1440>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%r14
mov    0x20(%rsp),%rbx
mov    0x68(%rsp),%rbp
movsd  (%r14,%rbx,8),%xmm3
mov    %r13d,%eax
cmp    %rax,%rbx
je     2bb0 <svd+0x1a40>
movslq %r13d,%r13
movsd  (%r14,%r13,8),%xmm0
movsd  %xmm0,0x38(%rsp)
mov    0x88(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm4
mov    0x8(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm5
movsd  (%rax,%rbx,8),%xmm6
movapd %xmm6,0xa0(%rsp)
movapd %xmm3,%xmm2
addsd  %xmm5,%xmm2
divsd  %xmm6,%xmm2
subsd  %xmm3,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
movsd  %xmm4,(%rsp)
movapd %xmm4,%xmm0
divsd  %xmm6,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm6,%xmm2
divsd  %xmm4,%xmm2
subsd  %xmm2,%xmm0
mulsd  0x8c5(%rip),%xmm0
movapd %xmm0,0xe0(%rsp)
movapd %xmm3,0x50(%rsp)
call   1070 <hypot@plt>
movsd  0x38(%rsp),%xmm4
movapd 0xa0(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm4,%xmm2
subsd  %xmm1,%xmm2
movapd 0xe0(%rsp),%xmm5
movapd %xmm5,%xmm1
andpd  0x85b(%rip),%xmm1
andpd  0x843(%rip),%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm5,%xmm0
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
subsd  %xmm3,%xmm1
divsd  %xmm4,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
cmp    %r13,%rbx
mov    %r13,0xf8(%rsp)
jle    2480 <svd+0x1310>
mov    %r13,%rax
movsd  0x825(%rip),%xmm9
movapd %xmm9,%xmm7
jmp    285e <svd+0x16ee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mulsd  0x38(%rsp),%xmm10
mulsd  %xmm8,%xmm6
subsd  %xmm10,%xmm6
movsd  0xe0(%rsp),%xmm2
mulsd  %xmm8,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm9,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm6
mulsd  %xmm9,%xmm2
subsd  %xmm6,%xmm2
movapd %xmm2,%xmm4
cmp    %rbx,%rax
jge    2495 <svd+0x1325>
movsd  %xmm9,(%rsp)
movsd  %xmm4,0x38(%rsp)
movapd %xmm3,0xa0(%rsp)
mov    %rax,%r13
mov    0x8(%rsp),%rbx
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0xe0(%rsp)
movsd  %xmm1,0xc0(%rsp)
mulsd  %xmm1,%xmm7
movapd %xmm7,0x50(%rsp)
movapd %xmm3,%xmm0
movapd %xmm7,%xmm1
call   1070 <hypot@plt>
movapd 0xa0(%rsp),%xmm7
movsd  %xmm0,(%rbx,%r13,8)
unpcklpd 0x50(%rsp),%xmm7
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm7
movapd %xmm7,%xmm6
unpckhpd %xmm7,%xmm6
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
cmpq   $0x0,0x18(%rsp)
je     2aa0 <svd+0x1930>
xor    %eax,%eax
movapd 0x71c(%rip),%xmm5
mov    0x20(%rsp),%rbx
movsd  0x38(%rsp),%xmm9
movsd  0xe0(%rsp),%xmm8
movsd  (%rsp),%xmm10
movsd  0xc0(%rsp),%xmm11
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm5,%xmm2
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
movapd %xmm6,%xmm2
shufpd $0x1,%xmm6,%xmm2
mulpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%r13,8)
mov    0x8(%r12,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm3
xorpd  %xmm5,%xmm3
movapd %xmm1,%xmm4
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%rcx,%r13,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    2920 <svd+0x17b0>
testb  $0x1,0x30(%rsp)
je     29c1 <svd+0x1851>
mov    (%r12,%rax,8),%rax
movupd (%rax,%r13,8),%xmm1
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm0
xorpd  0x662(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm2,%xmm0
movupd %xmm0,(%rax,%r13,8)
mulsd  %xmm11,%xmm10
movsd  %xmm10,(%rsp)
movapd %xmm10,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm9
addsd  %xmm0,%xmm9
movapd %xmm8,%xmm1
movapd %xmm6,0x50(%rsp)
mulsd  %xmm6,%xmm1
movapd %xmm9,0xc0(%rsp)
movapd %xmm9,%xmm0
movapd %xmm1,0x40(%rsp)
movapd %xmm7,0xa0(%rsp)
call   1070 <hypot@plt>
movapd 0xa0(%rsp),%xmm8
movsd  %xmm0,(%r14,%r13,8)
ucomisd 0x607(%rip),%xmm0
movapd %xmm8,%xmm9
jne    2a32 <svd+0x18c2>
jnp    2a4c <svd+0x18dc>
movapd 0xc0(%rsp),%xmm9
unpcklpd 0x40(%rsp),%xmm9
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm9
lea    0x1(%r13),%rax
movapd %xmm9,%xmm7
unpckhpd %xmm9,%xmm7
test   %ebp,%ebp
mov    0x98(%rsp),%rsi
mov    0x90(%rsp),%rdi
movapd 0x59b(%rip),%xmm11
movsd  0x5a3(%rip),%xmm1
movsd  (%rsp),%xmm6
movapd 0x50(%rsp),%xmm10
jle    2810 <svd+0x16a0>
cmp    $0x1,%ebp
jne    2ae0 <svd+0x1970>
xor    %ecx,%ecx
jmp    2b5f <svd+0x19ef>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x20(%rsp),%rbx
movsd  0x38(%rsp),%xmm9
movsd  0xe0(%rsp),%xmm8
movsd  (%rsp),%xmm10
movsd  0xc0(%rsp),%xmm11
testb  $0x1,0x30(%rsp)
jne    2994 <svd+0x1824>
jmp    29c1 <svd+0x1851>
nopl   0x0(%rax,%rax,1)
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rsi,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm11,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
movapd %xmm7,%xmm3
shufpd $0x1,%xmm7,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rdx,%r13,8)
mov    0x8(%rsi,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm11,%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm4,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,(%rdx,%r13,8)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    2af0 <svd+0x1980>
testb  $0x1,0x120(%rsp)
01
je     2810 <svd+0x16a0>
mov    (%rsi,%rcx,8),%rcx
movupd (%rcx,%r13,8),%xmm0
movapd %xmm0,%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
mulpd  %xmm0,%xmm3
xorpd  0x47f(%rip),%xmm0
shufpd $0x1,%xmm0,%xmm2
mulpd  %xmm7,%xmm2
addpd  %xmm2,%xmm3
movupd %xmm3,(%rcx,%r13,8)
jmp    2810 <svd+0x16a0>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
mov    0x8(%rsp),%rdi
mov    0x80(%rsp),%rsi
mov    0x78(%rsp),%r8
movapd 0x43e(%rip),%xmm0
jbe    2440 <svd+0x12d0>
xorpd  %xmm0,%xmm3
movlpd %xmm3,(%r14,%rbx,8)
cmpq   $0x3,0x18(%rsp)
jae    2bf0 <svd+0x1a80>
xor    %eax,%eax
jmp    2c58 <svd+0x1ae8>
xchg   %ax,%ax
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
mov    0x8(%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
mov    0x10(%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
mov    0x18(%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    2c00 <svd+0x1a90>
test   %rsi,%rsi
movapd 0x3ad(%rip),%xmm3
je     2440 <svd+0x12d0>
lea    (%r12,%rax,8),%rax
xor    %ecx,%ecx
nop
mov    (%rax,%rcx,8),%rdx
movsd  (%rdx,%rbx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rdx,%rbx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    2c70 <svd+0x1b00>
jmp    2440 <svd+0x12d0>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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