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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
double copysign(double, double);
int /*<<< orphan*/ csa_quit(char *, int);
double fabs(double);
int /*<<< orphan*/ free(double *);
double hypot(double, double);
scalar_t__ malloc(int);
double sqrt(double);
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 = (double *)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
call   1040 <assert@plt>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
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     2758 <svd+0x15f8>
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    1df4 <svd+0xc94>
lea    0x1246(%rip),%rdi
mov    $0x1e,%esi
call   1080 <csa_quit@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1eb8 <svd+0xd58>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x11e8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jne    1e51 <svd+0xcf1>
jp     1e51 <svd+0xcf1>
movl   $0x0,-0x84(%rbp)
jmp    1eb8 <svd+0xd58>
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 0x118a(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jne    1ea5 <svd+0xd45>
jp     1ea5 <svd+0xd45>
jmp    1eb8 <svd+0xd58>
jmp    1eaa <svd+0xd4a>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1dfa <svd+0xc9a>
cmpl   $0x0,-0x84(%rbp)
je     20ca <svd+0xf6a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x114b(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     20c5 <svd+0xf65>
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 0x10d2(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jne    1f4d <svd+0xded>
jp     1f4d <svd+0xded>
jmp    20c5 <svd+0xf65>
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  0x1093(%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    20b2 <svd+0xf52>
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)
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,-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    1fd3 <svd+0xe73>
jmp    20b7 <svd+0xf57>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ee0 <svd+0xd80>
jmp    20ca <svd+0xf6a>
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     2697 <svd+0x1537>
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  0xe9a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xe7c(%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 0xdf8(%rip),%xmm6
pand   %xmm6,%xmm5
movaps 0xddd(%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  0xdd3(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xdc6(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    265b <svd+0x14fb>
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    2487 <svd+0x1327>
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    23a8 <svd+0x1248>
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    24d6 <svd+0x1376>
jp     24d6 <svd+0x1376>
jmp    24fa <svd+0x139a>
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    2642 <svd+0x14e2>
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    2563 <svd+0x1403>
jmp    2647 <svd+0x14e7>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    2268 <svd+0x1108>
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    2740 <svd+0x15e0>
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    273b <svd+0x15db>
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    2736 <svd+0x15d6>
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    26db <svd+0x157b>
jmp    273b <svd+0x15db>
jmp    2745 <svd+0x15e5>
jmp    1dbc <svd+0xc5c>
jmp    274a <svd+0x15ea>
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,%rbx
mov    %rcx,%r14
mov    %edx,%r15d
mov    %esi,%r12d
mov    %rdi,%rbp
test   %edx,%edx
setg   %al
test   %esi,%esi
setg   %cl
and    %al,%cl
movzbl %cl,%edi
call   1050 <assert@plt>
lea    0x0(,%r12,8),%edi
call   1060 <malloc@plt>
mov    %r12,%r8
lea    -0x1(%r12),%ecx
movslq %r15d,%rdx
mov    %rdx,0x70(%rsp)
mov    %rcx,0xf8(%rsp)
mov    %ecx,%ecx
mov    %rcx,0xe0(%rsp)
mov    %r8d,%r12d
mov    %r15,0xa0(%rsp)
mov    %r15d,%ecx
test   %r8d,%r8d
mov    %r14,0xb8(%rsp)
mov    %rbp,0x10(%rsp)
mov    %rax,0x20(%rsp)
mov    %r12,0x18(%rsp)
mov    %rcx,0xc8(%rsp)
mov    %r8,0x90(%rsp)
jle    218e <svd+0x101e>
lea    (%rax,%r12,8),%rdx
mov    %rdx,0x150(%rsp)
lea    -0x1(%r12),%rdx
mov    %rdx,0x160(%rsp)
lea    -0x2(%r12),%rdx
mov    %rdx,0x180(%rsp)
mov    %r12,%rdx
neg    %rdx
mov    %rdx,0x28(%rsp)
lea    0x18(%rax),%r10
lea    -0x3(%r12),%r9
lea    0x38(%rax),%r11
lea    -0x5(%r12),%r15
xorpd  %xmm8,%xmm8
mov    $0x1,%edx
mov    %rdx,0x8(%rsp)
mov    $0x3,%edx
mov    $0xffffffffffffffff,%r13
movapd 0x1d88(%rip),%xmm9
movapd 0x1d8f(%rip),%xmm10
movapd 0x1d76(%rip),%xmm11
mov    %r12,0x60(%rsp)
mov    %rcx,0xd0(%rsp)
mov    $0x7,%ecx
xorpd  %xmm13,%xmm13
xorpd  %xmm12,%xmm12
xorpd  %xmm7,%xmm7
mov    %rbp,0x38(%rsp)
xor    %ebp,%ebp
jmp    1331 <svd+0x1c1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r14,%rsi,8),%rdi
movq   $0x0,(%r14,%rsi,8)
xorpd  %xmm12,%xmm12
xorpd  %xmm13,%xmm13
movsd  (%rdi),%xmm0
movsd  (%rax,%rsi,8),%xmm1
andpd  %xmm11,%xmm0
andpd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
maxsd  %xmm1,%xmm7
addq   $0x1,0x8(%rsp)
addq   $0x8,0x38(%rsp)
addq   $0xffffffffffffffff,0xd0(%rsp)
addq   $0xffffffffffffffff,0x60(%rsp)
add    $0x8,%r10
add    $0x1,%rdx
add    $0xffffffffffffffff,%r9
add    $0xffffffffffffffff,%r13
add    $0xffffffffffffffff,%r15
add    $0x1,%rcx
add    $0x8,%r11
cmp    %r12,%rbp
je     1e7c <svd+0xd0c>
mov    %rbp,%rsi
mulsd  %xmm12,%xmm13
add    $0x1,%rbp
movsd  %xmm13,(%rax,%rsi,8)
cmp    0x70(%rsp),%rsi
jge    12c0 <svd+0x150>
mov    %rbp,0x30(%rsp)
mov    %rcx,0x58(%rsp)
mov    %r13,0x88(%rsp)
mov    %r15,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x158(%rsp)
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0x100(%rsp)
mov    %r9,%r13
shr    %r13
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    0x160(%rsp),%rdi
sub    %rsi,%rdi
mov    %rdi,%rcx
mov    %rdi,0xc0(%rsp)
lea    -0x4(%rdi),%rcx
mov    %rcx,0x168(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x170(%rsp)
mov    0x180(%rsp),%rcx
sub    %rsi,%rcx
mov    %rcx,0x108(%rsp)
mov    %rsi,%rcx
not    %rcx
lea    (%rcx,%r12,1),%rdi
add    $0xfffffffffffffffe,%rdi
add    %r12,%rcx
mov    %rcx,0x50(%rsp)
mov    %rdi,0x128(%rsp)
mov    %rdi,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,0xb0(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    %rax,0x178(%rsp)
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    0xd0(%rsp),%rbp
mov    0x38(%rsp),%rdi
nopl   0x0(%rax)
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%rsi,8),%xmm0
andpd  %xmm9,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rbp
jne    1430 <svd+0x2c0>
xorpd  %xmm12,%xmm12
ucomisd %xmm12,%xmm3
xorpd  %xmm0,%xmm0
mov    0x60(%rsp),%r12
jne    1466 <svd+0x2f6>
jnp    1660 <svd+0x4f0>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
nopl   0x0(%rax)
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%rsi,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rax
cmp    %rax,%rbp
jne    1470 <svd+0x300>
mov    0x10(%rsp),%rax
mov    (%rax,%rsi,8),%rax
movsd  (%rax,%rsi,8),%xmm4
ucomisd %xmm8,%xmm2
mov    %rdx,0x40(%rsp)
jb     14b9 <svd+0x349>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    156f <svd+0x3ff>
movapd %xmm2,%xmm0
movsd  %xmm7,0x48(%rsp)
mov    %rsi,0x110(%rsp)
mov    %r10,%r12
mov    %r9,%rbp
mov    %r11,0xa8(%rsp)
movsd  %xmm3,0xf0(%rsp)
movapd %xmm4,0x130(%rsp)
movsd  %xmm2,0x120(%rsp)
call   1080 <sqrt@plt>
movsd  0x120(%rsp),%xmm2
movapd 0x130(%rsp),%xmm4
movsd  0xf0(%rsp),%xmm3
xorpd  %xmm12,%xmm12
movapd 0x1ade(%rip),%xmm11
movapd 0x1ae5(%rip),%xmm10
movapd 0x1acc(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    0xa8(%rsp),%r11
mov    %rbp,%r9
mov    %r12,%r10
mov    0x110(%rsp),%rsi
mov    0x38(%rsp),%rdi
mov    0xd0(%rsp),%rbp
mov    0x60(%rsp),%r12
mov    0x90(%rsp),%r8
movsd  0x48(%rsp),%xmm7
movapd %xmm9,%xmm1
andnpd %xmm4,%xmm1
andpd  %xmm9,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm4,%xmm1
addsd  %xmm0,%xmm1
xorpd  %xmm10,%xmm0
mov    0x10(%rsp),%rax
mov    (%rax,%rsi,8),%rax
movsd  %xmm1,(%rax,%rsi,8)
cmp    0xe0(%rsp),%rsi
jae    163b <svd+0x4cb>
mov    0x30(%rsp),%rax
cmp    0x18(%rsp),%rax
jae    163b <svd+0x4cb>
mulsd  %xmm0,%xmm4
subsd  %xmm2,%xmm4
mov    0x8(%rsp),%rax
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rcx,8),%rdx
movsd  (%rdx,%rsi,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    15e0 <svd+0x470>
divsd  %xmm4,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,8),%rdx
movsd  (%rdx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1610 <svd+0x4a0>
add    $0x1,%rax
cmp    0x18(%rsp),%rax
jne    15d0 <svd+0x460>
xor    %eax,%eax
nopl   (%rax)
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1640 <svd+0x4d0>
mov    0x40(%rsp),%rdx
mulsd  %xmm0,%xmm3
lea    (%r14,%rsi,8),%rdi
movsd  %xmm3,(%r14,%rsi,8)
cmp    0xe0(%rsp),%rsi
mov    0x58(%rsp),%rcx
jae    1760 <svd+0x5f0>
mov    0x30(%rsp),%rbp
cmp    0x18(%rsp),%rbp
jae    1781 <svd+0x611>
lea    0x0(,%rsi,8),%rax
mov    0x10(%rsp),%rcx
add    (%rcx,%rsi,8),%rax
xorpd  %xmm13,%xmm13
mov    $0x1,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm9,%xmm0
addsd  %xmm0,%xmm13
add    $0x1,%rcx
cmp    %rcx,%r12
jne    16b0 <svd+0x540>
xorpd  %xmm12,%xmm12
ucomisd %xmm12,%xmm13
jne    16da <svd+0x56a>
jnp    179d <svd+0x62d>
mov    %rdx,0x40(%rsp)
mov    0x10(%rsp),%rax
mov    (%rax,%rsi,8),%rax
xorpd  %xmm1,%xmm1
cmp    0x18(%rsp),%rbp
jae    1720 <svd+0x5b0>
lea    (%rax,%rsi,8),%rcx
xorpd  %xmm1,%xmm1
mov    $0x1,%edx
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm13,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1700 <svd+0x590>
movsd  (%rax,%rbp,8),%xmm2
ucomisd %xmm8,%xmm1
mov    %r9,0x148(%rsp)
mov    %r11,0xa8(%rsp)
mov    %r15,0x140(%rsp)
mov    %rdi,0xf0(%rsp)
jb     17b9 <svd+0x649>
xorps  %xmm12,%xmm12
sqrtsd %xmm1,%xmm12
jmp    1837 <svd+0x6c7>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm13,%xmm13
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%r12
mov    0x88(%rsp),%r13
mov    0x30(%rsp),%rbp
jmp    12d6 <svd+0x166>
xorpd  %xmm13,%xmm13
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%r12
mov    0x88(%rsp),%r13
jmp    12d6 <svd+0x166>
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%r12
mov    0x88(%rsp),%r13
mov    0x58(%rsp),%rcx
jmp    12d6 <svd+0x166>
movapd %xmm1,%xmm0
movsd  %xmm7,0x48(%rsp)
mov    %rsi,%r15
mov    %r10,%r12
movapd %xmm13,0x110(%rsp)
movapd %xmm2,0x130(%rsp)
movsd  %xmm1,0x120(%rsp)
call   1080 <sqrt@plt>
movsd  0x120(%rsp),%xmm1
movapd 0x130(%rsp),%xmm2
movapd 0x110(%rsp),%xmm13
movapd 0x17f1(%rip),%xmm11
movapd 0x17f8(%rip),%xmm10
movapd 0x17df(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    %r12,%r10
mov    %r15,%rsi
movsd  0x48(%rsp),%xmm7
movapd %xmm0,%xmm12
mov    0x70(%rsp),%r9
mov    0x8(%rsp),%r15
movapd %xmm9,%xmm0
andnpd %xmm2,%xmm0
andpd  %xmm9,%xmm12
orpd   %xmm0,%xmm12
movapd %xmm2,%xmm0
addsd  %xmm12,%xmm0
xorpd  %xmm10,%xmm12
mov    0x10(%rsp),%rax
mov    %rsi,0x110(%rsp)
mov    (%rax,%rsi,8),%r8
movsd  %xmm0,(%r8,%rbp,8)
mov    0x18(%rsp),%r12
cmp    %r12,%rbp
mov    0x20(%rsp),%rax
jae    19c9 <svd+0x859>
mulsd  %xmm12,%xmm2
subsd  %xmm1,%xmm2
mov    %r15,%rcx
mov    0x50(%rsp),%rsi
cmp    $0x2,%rsi
jb     195a <svd+0x7ea>
mov    0x18(%rsp),%rax
lea    (%r8,%rax,8),%rcx
cmp    %rcx,0x178(%rsp)
jae    18cf <svd+0x75f>
lea    (%r8,%r15,8),%rdx
mov    %r15,%rcx
cmp    0x150(%rsp),%rdx
jb     195a <svd+0x7ea>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x2,0x128(%rsp)
mov    0x20(%rsp),%rax
jae    18eb <svd+0x77b>
xor    %edx,%edx
jmp    192a <svd+0x7ba>
mov    0x40(%rsp),%rcx
lea    (%r8,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r10,%rdx,8)
movupd (%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r10,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r13
jne    1900 <svd+0x790>
mov    %rsi,%rcx
and    $0xfffffffffffffffe,%rcx
testb  $0x1,0xb0(%rsp)
01
je     194d <svd+0x7dd>
add    %r15,%rdx
movupd (%r8,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rdx,8)
cmp    %rcx,%rsi
mov    0x18(%rsp),%r12
je     19c9 <svd+0x859>
add    %r15,%rcx
mov    0x18(%rsp),%rsi
sub    %ecx,%esi
mov    %rcx,%rdx
test   $0x1,%sil
je     1982 <svd+0x812>
movsd  (%r8,%rcx,8),%xmm0
divsd  %xmm2,%xmm0
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,0x160(%rsp)
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%r12
je     19c9 <svd+0x859>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r8,%rdx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x8(%r8,%rdx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    19a0 <svd+0x830>
mov    %r10,0xb0(%rsp)
mov    %rbp,%r10
cmp    %r9,%rbp
mov    0x10(%rsp),%rbp
mov    0x88(%rsp),%r13
jge    1cd7 <svd+0xb67>
mov    0x50(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x128(%rsp)
add    %r15,%rcx
mov    %rcx,0x130(%rsp)
mov    %r13,%rcx
neg    %rcx
mov    %rcx,0x48(%rsp)
lea    (%r8,%r15,8),%rdi
mov    %r15,%r11
jmp    1a32 <svd+0x8c2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    0xc8(%rsp),%r11
je     1cd7 <svd+0xb67>
cmp    %r12,%r10
jae    1a20 <svd+0x8b0>
mov    0x0(%rbp,%r11,8),%rdx
testb  $0x3,0xc0(%rsp)
03
je     1b38 <svd+0x9c8>
lea    (%rdx,%r15,8),%rsi
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x100(%rsp),%r9
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm1
mulsd  (%rdi,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r9
jne    1a60 <svd+0x8f0>
add    0x48(%rsp),%rcx
cmpq   $0x3,0x108(%rsp)
jb     1adb <svd+0x96b>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm1
movsd  0x8(%rdx,%rcx,8),%xmm2
mulsd  (%r8,%rcx,8),%xmm1
mulsd  0x8(%r8,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rdx,%rcx,8),%xmm3
mulsd  0x10(%r8,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rdx,%rcx,8),%xmm0
mulsd  0x18(%r8,%rcx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %rcx,%r12
jne    1a90 <svd+0x920>
cmp    %r12,%r10
jae    1a20 <svd+0x8b0>
mov    0x0(%rbp,%r11,8),%rdx
mov    %r15,%rcx
cmpq   $0x4,0x50(%rsp)
jb     1c60 <svd+0xaf0>
lea    (%rdx,%r15,8),%rcx
cmp    0x150(%rsp),%rcx
jae    1b1b <svd+0x9ab>
lea    (%rdx,%r12,8),%rsi
mov    %r15,%rcx
cmp    %rsi,0x178(%rsp)
jb     1c60 <svd+0xaf0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x168(%rsp)
jae    1b50 <svd+0x9e0>
mov    %r15,%r13
xor    %ecx,%ecx
jmp    1be3 <svd+0xa73>
xorpd  %xmm0,%xmm0
mov    %r15,%rcx
cmpq   $0x3,0x108(%rsp)
jae    1a90 <svd+0x920>
jmp    1adb <svd+0x96b>
mov    %r15,%r13
mov    0x58(%rsp),%rcx
lea    (%rdx,%rcx,8),%rsi
mov    0x158(%rsp),%rbp
xor    %ecx,%ecx
mov    0xa8(%rsp),%r15
xchg   %ax,%ax
movupd -0x30(%r15,%rcx,8),%xmm2
movupd -0x20(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rsi,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rsi,%rcx,8),%xmm2
movupd -0x10(%rsi,%rcx,8),%xmm5
movupd (%rsi,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rsi,%rcx,8)
movupd %xmm3,-0x20(%rsi,%rcx,8)
movupd -0x10(%r15,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rsi,%rcx,8)
movupd %xmm3,(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1b70 <svd+0xa00>
testb  $0x1,0x170(%rsp)
01
mov    0x10(%rsp),%rbp
mov    %r13,%r15
mov    0x30(%rsp),%r10
je     1c2e <svd+0xabe>
add    %r15,%rcx
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
movupd (%rdx,%rcx,8),%xmm4
movupd 0x10(%rdx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rcx,8)
movupd %xmm3,0x10(%rdx,%rcx,8)
mov    0x130(%rsp),%rcx
mov    0x128(%rsp),%rsi
cmp    %rsi,0x50(%rsp)
mov    0x88(%rsp),%r13
je     1a20 <svd+0x8b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12d,%ebp
sub    %ecx,%ebp
mov    %rcx,%rsi
test   $0x1,%bpl
je     1c85 <svd+0xb15>
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
lea    0x1(%rcx),%rsi
not    %rcx
cmp    0x28(%rsp),%rcx
mov    0x10(%rsp),%rbp
mov    0x30(%rsp),%r10
je     1a20 <svd+0x8b0>
nopl   (%rax)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rsi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    1ca0 <svd+0xb30>
jmp    1a20 <svd+0x8b0>
cmp    %r12,%r10
mov    0x58(%rsp),%rcx
mov    %r15,0x8(%rsp)
jae    1d34 <svd+0xbc4>
mov    %r15,%rdx
cmpq   $0x4,0x50(%rsp)
mov    0x148(%rsp),%r9
mov    0xa8(%rsp),%r11
mov    0x140(%rsp),%r15
mov    0xf0(%rsp),%rdi
mov    %r10,%rbp
jb     1e40 <svd+0xcd0>
movapd %xmm13,%xmm0
unpcklpd %xmm13,%xmm0
cmpq   $0x4,0x168(%rsp)
jae    1d79 <svd+0xc09>
xor    %ecx,%ecx
jmp    1dd8 <svd+0xc68>
mov    0x90(%rsp),%r8
mov    0x148(%rsp),%r9
mov    0xa8(%rsp),%r11
mov    0x140(%rsp),%r15
mov    0x40(%rsp),%rdx
mov    0x110(%rsp),%rsi
mov    0xf0(%rsp),%rdi
mov    %r10,%rbp
mov    0xb0(%rsp),%r10
jmp    12d6 <svd+0x166>
lea    (%r8,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0x158(%rsp),%rsi
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,%rsi
jne    1d90 <svd+0xc20>
mov    0x50(%rsp),%rsi
mov    %rsi,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x170(%rsp)
01
je     1e15 <svd+0xca5>
add    0x8(%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,%rsi
jne    1e2e <svd+0xcbe>
mov    0x90(%rsp),%r8
mov    0x40(%rsp),%rdx
mov    0x58(%rsp),%rcx
jmp    1e67 <svd+0xcf7>
add    0x8(%rsp),%rdx
mov    0x58(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%rdx,8),%xmm0
mulsd  %xmm13,%xmm0
movsd  %xmm0,(%r8,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1e40 <svd+0xcd0>
mov    0x90(%rsp),%r8
mov    0x40(%rsp),%rdx
mov    0x110(%rsp),%rsi
mov    0xb0(%rsp),%r10
jmp    12d6 <svd+0x166>
test   %r8d,%r8d
jle    2192 <svd+0x1022>
mov    %r12,%rdx
xor    %r13d,%r13d
movabs $0x3ff0000000000000,%r9
xorpd  %xmm0,%xmm0
mov    %r8d,%r11d
mov    0x10(%rsp),%rdi
jmp    1ed4 <svd+0xd64>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%r12,8),%rax
mov    %r9,(%rax,%r12,8)
mov    0x20(%rsp),%rax
movsd  (%rax,%r12,8),%xmm12
add    $0x1,%r13b
mov    %r12d,%r11d
cmp    $0x1,%rbp
jle    2184 <svd+0x1014>
mov    %r12,%rbp
movzbl %r13b,%r13d
and    $0x3,%r13d
add    $0xffffffffffffffff,%r12
cmp    0xe0(%rsp),%rbp
mov    0x18(%rsp),%rax
jg     1eb0 <svd+0xd40>
mov    %rbp,0xd0(%rsp)
movslq %r11d,%r15
mov    %rax,%r14
sub    %r15,%r14
mov    %r15,%r10
not    %r10
add    %r10,%rax
mov    %rax,0x8(%rsp)
ucomisd %xmm0,%xmm12
jne    1f1e <svd+0xdae>
jnp    20c0 <svd+0xf50>
cmp    0x90(%rsp),%r11d
jge    20c0 <svd+0xf50>
mov    (%rdi,%r12,8),%rax
movslq %r11d,%rcx
mov    %rcx,%rsi
mov    0x18(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm1
divsd  (%rax,%rcx,8),%xmm1
divsd  %xmm12,%xmm1
mov    (%rbx,%rsi,8),%rbp
movsd  %xmm1,0x0(%rbp,%r12,8)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1f40 <svd+0xdd0>
cmp    0x90(%rsp),%r11d
mov    0x10(%rsp),%rdi
jge    20c0 <svd+0xf50>
movslq %r11d,%r8
mov    (%rdi,%r12,8),%rsi
lea    0x1(%r8),%rax
mov    %rax,0x60(%rsp)
mov    %r8,%rcx
jmp    1fa2 <svd+0xe32>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rdx,%rcx
mov    0x10(%rsp),%rdi
je     20c0 <svd+0xf50>
xorpd  %xmm1,%xmm1
test   $0x3,%r14b
je     1fe0 <svd+0xe70>
mov    %r13,%rax
mov    %r8,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rbp,8),%xmm2
mov    (%rbx,%rbp,8),%r9
mulsd  (%r9,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbp
add    $0xffffffffffffffff,%rax
jne    1fc0 <svd+0xe50>
jmp    1fe3 <svd+0xe73>
nop
mov    %r8,%rbp
cmpq   $0x3,0x8(%rsp)
mov    0x18(%rsp),%rdx
jb     2047 <svd+0xed7>
movsd  (%rsi,%rbp,8),%xmm2
movsd  0x8(%rsi,%rbp,8),%xmm3
mov    (%rbx,%rbp,8),%rax
mov    0x8(%rbx,%rbp,8),%rdi
mulsd  (%rax,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rdi,%rcx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rsi,%rbp,8),%xmm2
mov    0x10(%rbx,%rbp,8),%rax
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x18(%rsi,%rbp,8),%xmm1
mov    0x18(%rbx,%rbp,8),%rax
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    1ff0 <svd+0xe80>
mov    %r8,%rbp
test   $0x1,%r14b
je     206d <svd+0xefd>
mov    (%rbx,%r8,8),%rax
movsd  (%rax,%r12,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    0x60(%rsp),%rbp
cmp    0x28(%rsp),%r10
mov    0x18(%rsp),%rdx
je     1f90 <svd+0xe20>
nopl   (%rax)
mov    (%rbx,%rbp,8),%rax
movsd  (%rax,%r12,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    0x8(%rbx,%rbp,8),%rax
movsd  (%rax,%r12,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    2080 <svd+0xf10>
jmp    1f90 <svd+0xe20>
nop
mov    0x90(%rsp),%r8
cmp    %r8d,%r11d
movabs $0x3ff0000000000000,%r9
mov    0xd0(%rsp),%rbp
jge    1eb0 <svd+0xd40>
mov    (%rbx,%r12,8),%rcx
test   $0x3,%r14b
je     210e <svd+0xf9e>
mov    %r13,%rax
movq   $0x0,(%rcx,%r15,8)
mov    (%rbx,%r15,8),%rsi
movq   $0x0,(%rsi,%r12,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rax
jne    20f0 <svd+0xf80>
cmpq   $0x3,0x8(%rsp)
mov    0x18(%rsp),%rdx
jb     1eb0 <svd+0xd40>
nop
movq   $0x0,(%rcx,%r15,8)
mov    (%rbx,%r15,8),%rax
movq   $0x0,(%rax,%r12,8)
movq   $0x0,0x8(%rcx,%r15,8)
mov    0x8(%rbx,%r15,8),%rax
movq   $0x0,(%rax,%r12,8)
movq   $0x0,0x10(%rcx,%r15,8)
mov    0x10(%rbx,%r15,8),%rax
movq   $0x0,(%rax,%r12,8)
movq   $0x0,0x18(%rcx,%r15,8)
mov    0x18(%rbx,%r15,8),%rax
movq   $0x0,(%rax,%r12,8)
add    $0x4,%r15
cmp    %r15,%rdx
jne    2120 <svd+0xfb0>
jmp    1eb0 <svd+0xd40>
mov    0xb8(%rsp),%r14
jmp    2192 <svd+0x1022>
xorpd  %xmm7,%xmm7
mov    0xa0(%rsp),%rcx
lea    -0x1(%rcx),%eax
cmp    %r8d,%ecx
cmovge 0xf8(%rsp),%eax
test   %eax,%eax
movsd  %xmm7,0x48(%rsp)
js     24ca <svd+0x135a>
lea    0x1(%rax),%edx
mov    0xf8(%rsp),%rcx
sub    %edx,%ecx
mov    %rcx,0xf8(%rsp)
movslq %r8d,%rcx
mov    %rcx,0x28(%rsp)
mov    %eax,%ebp
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%r15
mov    0xa0(%rsp),%rax
mov    %eax,%r13d
sub    %edx,%r13d
add    $0x1,%r13d
sub    %dl,%al
mov    %al,0x38(%rsp)
xor    %esi,%esi
xorpd  %xmm3,%xmm3
movsd  0xe1c(%rip),%xmm4
mov    %rdx,0xd0(%rsp)
mov    %edx,%r12d
jmp    225e <svd+0x10ee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    (%rax,%rbp,8),%rax
movsd  (%rax,%rbp,8),%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rsi
add    $0xffffffff,%r12d
add    $0xffffffffffffffff,%rbp
add    $0xfffffffffffffff8,%r15
add    $0x1,%r13
addb   $0x1,0x38(%rsp)
cmp    0xd0(%rsp),%rsi
je     24ca <svd+0x135a>
movsd  (%r14,%rbp,8),%xmm5
lea    0x1(%rbp),%eax
mov    %eax,0x8(%rsp)
cmp    0xe0(%rsp),%rbp
je     22e5 <svd+0x1175>
cmp    %r8d,0x8(%rsp)
jge    22e5 <svd+0x1175>
mov    0xf8(%rsp),%rax
add    %esi,%eax
lea    0x8(,%rax,8),%rdx
mov    0xd0(%rsp),%rax
sub    %esi,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    0x10(%rsp),%rax
add    (%rax,%rbp,8),%rdi
mov    %r12d,0x60(%rsp)
mov    %rsi,%r12
xor    %esi,%esi
movsd  %xmm5,0x30(%rsp)
call   1040 <memset@plt>
movsd  0x30(%rsp),%xmm5
movsd  0xd55(%rip),%xmm4
xorpd  %xmm3,%xmm3
mov    %r12,%rsi
mov    0x60(%rsp),%r12d
mov    0x90(%rsp),%r8
movsd  0x48(%rsp),%xmm7
ucomisd %xmm3,%xmm5
jne    22f1 <svd+0x1181>
jnp    24a0 <svd+0x1330>
mov    %rsi,0x30(%rsp)
cmp    %r8d,0x8(%rsp)
mov    0x70(%rsp),%rdi
jge    2460 <svd+0x12f0>
movzbl 0x38(%rsp),%eax
and    $0x3,%eax
shl    $0x3,%rax
mov    %rax,0x60(%rsp)
movslq %r12d,%r11
mov    %rdi,%r10
sub    %r11,%r10
mov    %r11,%rsi
not    %rsi
add    %rdi,%rsi
mov    0x10(%rsp),%rax
mov    (%rax,%rbp,8),%r9
mov    %r11,%rcx
jmp    234f <svd+0x11df>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    0x28(%rsp),%rcx
jge    2460 <svd+0x12f0>
xorpd  %xmm0,%xmm0
mov    0x8(%rsp),%eax
cmp    0xa0(%rsp),%eax
jge    2419 <svd+0x12a9>
xorpd  %xmm0,%xmm0
test   $0x3,%r10b
je     239e <svd+0x122e>
mov    0x60(%rsp),%rdx
mov    %r11,%rax
mov    0x10(%rsp),%r8
nopl   0x0(%rax,%rax,1)
mov    (%r8,%rax,8),%rdi
movsd  (%rdi,%rbp,8),%xmm1
mulsd  (%rdi,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    $0xfffffffffffffff8,%rdx
jne    2380 <svd+0x1210>
jmp    23a6 <svd+0x1236>
mov    %r11,%rax
mov    0x10(%rsp),%r8
cmp    $0x3,%rsi
mov    0x70(%rsp),%rdi
jb     2419 <svd+0x12a9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r8,%rax,8),%rdx
mov    0x8(%r8,%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    0x70(%rsp),%rdi
addsd  %xmm1,%xmm2
mov    0x10(%r8,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
mov    0x18(%r8,%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     23c0 <svd+0x1250>
cmp    %rdi,%rbp
jge    2340 <svd+0x11d0>
divsd  (%r9,%rbp,8),%xmm0
divsd  %xmm5,%xmm0
xor    %eax,%eax
xchg   %ax,%ax
mov    (%r15,%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,%r13d
jne    2430 <svd+0x12c0>
jmp    2340 <svd+0x11d0>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rdi,%rbp
mov    0x90(%rsp),%r8
mov    0x30(%rsp),%rsi
jge    2220 <svd+0x10b0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%r13d
jne    2480 <svd+0x1310>
jmp    2220 <svd+0x10b0>
cmp    0x70(%rsp),%rbp
jge    2220 <svd+0x10b0>
xor    %eax,%eax
nopl   (%rax)
mov    (%r15,%rax,8),%rcx
movq   $0x0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%r13d
jne    24b0 <svd+0x1340>
jmp    2220 <svd+0x10b0>
test   %r8d,%r8d
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%r13
jle    2d90 <svd+0x1c20>
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %eax,%r15d
and    $0xfffffffe,%r15d
mov    0xc8(%rsp),%r12
and    $0xfffffffe,%r12d
mov    %r12,0x58(%rsp)
mov    %eax,%r12d
and    $0x3,%r12d
mov    %eax,%esi
and    $0xfffffffc,%esi
movapd 0xaee(%rip),%xmm1
movsd  0xb06(%rip),%xmm4
mov    %rax,0x100(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rcx,0x40(%rsp)
mov    %r12,0x108(%rsp)
mov    %rsi,0xc0(%rsp)
jmp    2552 <svd+0x13e2>
xchg   %ax,%ax
addq   $0xffffffffffffffff,0x100(%rsp)
test   %rdi,%rdi
jle    2d90 <svd+0x1c20>
mov    0x40(%rsp),%rdi
lea    -0x1(%rdi),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rdi,0x38(%rsp)
jmp    25c1 <svd+0x1451>
nopl   0x0(%rax)
movapd %xmm4,%xmm7
mov    0x20(%rsp),%r13
mov    0x50(%rsp),%rax
movq   $0x0,0x0(%r13,%rax,8)
movsd  %xmm3,0x0(%r13,%rdi,8)
movsd  %xmm7,(%r14,%rdi,8)
movsd  0x48(%rsp),%xmm7
mov    0x108(%rsp),%r12
mov    0xc0(%rsp),%rsi
movapd 0xa4e(%rip),%xmm1
movsd  0xa66(%rip),%xmm4
mov    0x88(%rsp),%eax
cmp    $0x1e,%eax
jb     2608 <svd+0x1498>
lea    0xa6b(%rip),%rdi
mov    $0x1e,%esi
mov    %eax,%r14d
call   1090 <csa_quit@plt>
mov    %r14d,%eax
mov    0xb8(%rsp),%r14
mov    0x38(%rsp),%rdi
movsd  0xa2e(%rip),%xmm4
movapd 0xa06(%rip),%xmm1
mov    0xc0(%rsp),%rsi
movsd  0x48(%rsp),%xmm7
add    $0x1,%eax
mov    %eax,0x88(%rsp)
mov    0x100(%rsp),%rax
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%ecx
movsd  0x0(%r13,%rcx,8),%xmm0
andpd  %xmm1,%xmm0
addsd  %xmm7,%xmm0
ucomisd %xmm7,%xmm0
jne    263a <svd+0x14ca>
jnp    2670 <svd+0x1500>
movsd  -0x10(%r14,%rax,8),%xmm0
andpd  %xmm1,%xmm0
addsd  %xmm7,%xmm0
ucomisd %xmm7,%xmm0
jne    2651 <svd+0x14e1>
jnp    2680 <svd+0x1510>
add    $0xffffffffffffffff,%rax
jg     2620 <svd+0x14b0>
mov    $0xffffffff,%ecx
mov    $0xffffffffffffffff,%rax
jmp    2687 <svd+0x1517>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffff,%eax
mov    %eax,%ecx
jmp    27f1 <svd+0x1681>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%ecx
add    $0xfffffffffffffffe,%rax
mov    %ecx,0x28(%rsp)
movslq %ecx,%r13
cmp    %r13,%rdi
jl     27e8 <svd+0x1678>
movslq %eax,%r14
xorpd  %xmm6,%xmm6
movapd %xmm4,%xmm5
jmp    26e3 <svd+0x1573>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r13),%rax
mov    0x38(%rsp),%rdi
cmp    %rdi,%r13
mov    %rax,%r13
movsd  0x48(%rsp),%xmm7
mov    0x108(%rsp),%r12
mov    0xc0(%rsp),%rsi
movapd 0x923(%rip),%xmm1
jge    27e0 <svd+0x1670>
mov    0x20(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm6
movsd  %xmm6,(%rax,%r13,8)
movapd %xmm5,%xmm0
andpd  %xmm1,%xmm0
addsd  %xmm7,%xmm0
ucomisd %xmm7,%xmm0
jne    2714 <svd+0x15a4>
jnp    27e0 <svd+0x1670>
mov    0xb8(%rsp),%r12
movsd  (%r12,%r13,8),%xmm1
movsd  %xmm1,0x8(%rsp)
movapd %xmm5,%xmm0
movapd %xmm5,0x70(%rsp)
call   1070 <hypot@plt>
movsd  0x8(%rsp),%xmm6
movapd 0x70(%rsp),%xmm5
movsd  0x8d5(%rip),%xmm4
movsd  %xmm0,(%r12,%r13,8)
mov    0xc8(%rsp),%rdx
mov    0xa0(%rsp),%rax
mov    0x10(%rsp),%rbp
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm6
xorpd  0x896(%rip),%xmm5
mulsd  %xmm1,%xmm5
test   %eax,%eax
jle    26b0 <svd+0x1540>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm0
movsd  (%rcx,%r13,8),%xmm1
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%r14,8)
mulsd  %xmm6,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%r13,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    2790 <svd+0x1620>
jmp    26b0 <svd+0x1540>
nopl   0x0(%rax,%rax,1)
mov    0xb8(%rsp),%r14
mov    0x20(%rsp),%r13
mov    0x28(%rsp),%ecx
movsd  (%r14,%rdi,8),%xmm2
mov    %ecx,%eax
cmp    %rax,%rdi
je     2cc0 <svd+0x1b50>
movslq %ecx,%r12
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x40(%rsp),%rax
movsd  (%r14,%rax,8),%xmm3
movsd  0x0(%r13,%rax,8),%xmm5
movsd  0x0(%r13,%rdi,8),%xmm6
movapd %xmm6,0x70(%rsp)
movapd %xmm2,%xmm1
addsd  %xmm5,%xmm1
divsd  %xmm6,%xmm1
subsd  %xmm2,%xmm5
divsd  %xmm3,%xmm5
mulsd  %xmm1,%xmm5
movsd  %xmm3,0x8(%rsp)
movapd %xmm3,%xmm0
divsd  %xmm6,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm6,%xmm1
divsd  %xmm3,%xmm1
subsd  %xmm1,%xmm0
mulsd  0x7ba(%rip),%xmm0
movapd %xmm0,0x60(%rsp)
movapd %xmm4,%xmm1
movapd %xmm2,0xe0(%rsp)
call   1070 <hypot@plt>
movsd  0x28(%rsp),%xmm4
movapd 0x70(%rsp),%xmm3
mov    0x38(%rsp),%rdi
movapd 0xe0(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm4,%xmm2
subsd  %xmm1,%xmm2
movapd 0x60(%rsp),%xmm5
movapd %xmm5,%xmm1
andpd  0x74a(%rip),%xmm1
andpd  0x732(%rip),%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm5,%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
subsd  %xmm3,%xmm1
divsd  %xmm4,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
cmp    %r12,%rdi
mov    %r12,0x50(%rsp)
jle    2570 <svd+0x1400>
mov    %r12,%rax
movsd  0x716(%rip),%xmm9
movapd %xmm9,%xmm1
jmp    2968 <svd+0x17f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  0x28(%rsp),%xmm10
mulsd  %xmm8,%xmm11
subsd  %xmm10,%xmm11
mulsd  %xmm8,%xmm7
movapd %xmm7,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm9,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm11
mulsd  %xmm9,%xmm7
subsd  %xmm11,%xmm7
movapd %xmm7,%xmm4
cmp    %rdi,%rax
jge    2574 <svd+0x1404>
movsd  %xmm9,0x8(%rsp)
movsd  %xmm4,0x28(%rsp)
movapd %xmm3,0x70(%rsp)
mov    %rax,%r13
mov    0x20(%rsp),%r12
movsd  0x8(%r12,%rax,8),%xmm2
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  %xmm2,0x90(%rsp)
mulsd  %xmm2,%xmm1
movapd %xmm1,0xe0(%rsp)
movapd %xmm3,%xmm0
call   1070 <hypot@plt>
movapd 0x70(%rsp),%xmm7
movsd  %xmm0,(%r12,%r13,8)
unpcklpd 0xe0(%rsp),%xmm7
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm7
movapd %xmm7,%xmm6
unpckhpd %xmm7,%xmm6
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
cmpq   $0x0,0x30(%rsp)
je     2bb0 <svd+0x1a40>
xor    %eax,%eax
mov    0xc8(%rsp),%r12
movapd 0x60f(%rip),%xmm5
movsd  0x28(%rsp),%xmm9
movsd  0x60(%rsp),%xmm8
movsd  0x8(%rsp),%xmm10
movsd  0x90(%rsp),%xmm11
mov    (%rbx,%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(%rbx,%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    2a20 <svd+0x18b0>
testb  $0x1,0x18(%rsp)
je     2ac1 <svd+0x1951>
mov    (%rbx,%rax,8),%rax
movupd (%rax,%r13,8),%xmm1
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm0
xorpd  0x562(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm2,%xmm0
movupd %xmm0,(%rax,%r13,8)
mulsd  %xmm11,%xmm10
movsd  %xmm10,0x8(%rsp)
movapd %xmm10,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm9
addsd  %xmm0,%xmm9
movapd %xmm8,%xmm1
movapd %xmm6,0xe0(%rsp)
mulsd  %xmm6,%xmm1
movapd %xmm9,0x90(%rsp)
movapd %xmm9,%xmm0
movapd %xmm1,0xd0(%rsp)
movapd %xmm7,0x70(%rsp)
call   1070 <hypot@plt>
movapd 0x70(%rsp),%xmm8
movsd  %xmm0,(%r14,%r13,8)
ucomisd 0x506(%rip),%xmm0
movapd %xmm8,%xmm9
jne    2b33 <svd+0x19c3>
jnp    2b50 <svd+0x19e0>
movapd 0x90(%rsp),%xmm9
unpcklpd 0xd0(%rsp),%xmm9
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm9
lea    0x1(%r13),%rax
movapd %xmm9,%xmm1
unpckhpd %xmm9,%xmm1
cmpl   $0x0,0xa0(%rsp)
mov    0x58(%rsp),%rsi
movapd 0x49d(%rip),%xmm6
mov    0x38(%rsp),%rdi
movsd  0x60(%rsp),%xmm7
movsd  0x8(%rsp),%xmm11
movapd 0xe0(%rsp),%xmm10
jle    2920 <svd+0x17b0>
cmpl   $0x1,0xa0(%rsp)
01
jne    2bf0 <svd+0x1a80>
xor    %ecx,%ecx
jmp    2c6e <svd+0x1afe>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0xc8(%rsp),%r12
movsd  0x28(%rsp),%xmm9
movsd  0x60(%rsp),%xmm8
movsd  0x8(%rsp),%xmm10
movsd  0x90(%rsp),%xmm11
testb  $0x1,0x18(%rsp)
jne    2a94 <svd+0x1924>
jmp    2ac1 <svd+0x1951>
nopl   0x0(%rax)
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    0x0(%rbp,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm6,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
movapd %xmm1,%xmm3
shufpd $0x1,%xmm1,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rdx,%r13,8)
mov    0x8(%rbp,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm6,%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,%rsi
jne    2c00 <svd+0x1a90>
test   $0x1,%r12b
je     2920 <svd+0x17b0>
mov    0x0(%rbp,%rcx,8),%rcx
movupd (%rcx,%r13,8),%xmm0
movapd %xmm0,%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
mulpd  %xmm0,%xmm3
xorpd  0x373(%rip),%xmm0
shufpd $0x1,%xmm0,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm2,%xmm3
movupd %xmm3,(%rcx,%r13,8)
jmp    2920 <svd+0x17b0>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
movapd 0x340(%rip),%xmm0
jbe    2540 <svd+0x13d0>
xorpd  %xmm0,%xmm2
movlpd %xmm2,(%r14,%rdi,8)
cmpq   $0x3,0x30(%rsp)
jae    2cf0 <svd+0x1b80>
xor    %eax,%eax
jmp    2d54 <svd+0x1be4>
nopl   0x0(%rax)
xor    %eax,%eax
movapd 0x316(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%rdi,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rcx,%rdi,8)
mov    0x8(%rbx,%rax,8),%rcx
movsd  (%rcx,%rdi,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rcx,%rdi,8)
mov    0x10(%rbx,%rax,8),%rcx
movsd  (%rcx,%rdi,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rcx,%rdi,8)
mov    0x18(%rbx,%rax,8),%rcx
movsd  (%rcx,%rdi,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rcx,%rdi,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    2d00 <svd+0x1b90>
test   %r12,%r12
movapd 0x2b1(%rip),%xmm2
je     2540 <svd+0x13d0>
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,8),%rdx
movsd  (%rdx,%rdi,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rdx,%rdi,8)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    2d70 <svd+0x1c00>
jmp    2540 <svd+0x13d0>
mov    %r13,%rdi
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 @assert(i32 %42)
%44 = load i32, i32* %7
%45 = sext i32 %44 to i64
%46 = mul i64 %45, 8
%47 = trunc i64 %46 to i32
%48 = call i64 @malloc(i32 %47)
%49 = inttoptr i64 %48 to double*
store double* %49, 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 %50
50: ; preds = %514, %40
%51 = load i32, i32* %12
%52 = load i32, i32* %7
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %517
54: ; preds = %50
%55 = load i32, i32* %12
%56 = add nsw i32 %55, 1
store i32 %56, i32* %15
%57 = load double, double* %22
%58 = load double, double* %19
%59 = fmul double %57, %58
%60 = load double*, double** %11
%61 = load i32, i32* %12
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %60, i64 %62
store double %59, double* %63
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
%64 = load i32, i32* %12
%65 = load i32, i32* %8
%66 = icmp slt i32 %64, %65
br i1 %66, label %67, label %265
67: ; preds = %54
%68 = load i32, i32* %12
store i32 %68, i32* %14
br label %69
69: ; preds = %86, %67
%70 = load i32, i32* %14
%71 = load i32, i32* %8
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %89
73: ; preds = %69
%74 = load double**, double*** %6
%75 = load i32, i32* %14
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double*, double** %74, i64 %76
%78 = load double*, double** %77
%79 = load i32, i32* %12
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %78, i64 %80
%82 = load double, double* %81
%83 = call double @llvm.fabs.f64(double %82)
%84 = load double, double* %22
%85 = fadd double %84, %83
store double %85, double* %22
br label %86
86: ; preds = %73
%87 = load i32, i32* %14
%88 = add nsw i32 %87, 1
store i32 %88, i32* %14
br label %69
89: ; preds = %69
%90 = load double, double* %22
%91 = fcmp une double %90, 0.000000e+00
br i1 %91, label %92, label %264
92: ; preds = %89
%93 = load i32, i32* %12
store i32 %93, i32* %14
br label %94
94: ; preds = %130, %92
%95 = load i32, i32* %14
%96 = load i32, i32* %8
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %133
98: ; preds = %94
%99 = load double, double* %22
%100 = load double**, double*** %6
%101 = load i32, i32* %14
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double*, double** %100, i64 %102
%104 = load double*, double** %103
%105 = load i32, i32* %12
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load double, double* %107
%109 = fdiv double %108, %99
store double %109, double* %107
%110 = load double**, double*** %6
%111 = load i32, i32* %14
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double*, double** %110, i64 %112
%114 = load double*, double** %113
%115 = load i32, i32* %12
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %114, i64 %116
%118 = load double, double* %117
%119 = load double**, double*** %6
%120 = load i32, i32* %14
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double*, double** %119, i64 %121
%123 = load double*, double** %122
%124 = load i32, i32* %12
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
%127 = load double, double* %126
%128 = load double, double* %21
%129 = call double @llvm.fmuladd.f64(double %118, double %127, double %128)
store double %129, double* %21
br label %130
130: ; preds = %98
%131 = load i32, i32* %14
%132 = add nsw i32 %131, 1
store i32 %132, i32* %14
br label %94
133: ; preds = %94
%134 = load double**, double*** %6
%135 = load i32, i32* %12
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double*, double** %134, i64 %136
%138 = load double*, double** %137
%139 = load i32, i32* %12
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %138, i64 %140
%142 = load double, double* %141
store double %142, double* %18
%143 = load double, double* %21
%144 = call double @sqrt(double %143)
%145 = load double, double* %18
%146 = call double @llvm.copysign.f64(double %144, double %145)
%147 = fneg double %146
store double %147, double* %19
%148 = load double, double* %18
%149 = load double, double* %19
%150 = load double, double* %21
%151 = fneg double %150
%152 = call double @llvm.fmuladd.f64(double %148, double %149, double %151)
store double %152, double* %20
%153 = load double, double* %18
%154 = load double, double* %19
%155 = fsub double %153, %154
%156 = load double**, double*** %6
%157 = load i32, i32* %12
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double*, double** %156, i64 %158
%160 = load double*, double** %159
%161 = load i32, i32* %12
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
store double %155, double* %163
%164 = load i32, i32* %12
%165 = load i32, i32* %7
%166 = sub nsw i32 %165, 1
%167 = icmp slt i32 %164, %166
br i1 %167, label %168, label %242
168: ; preds = %133
%169 = load i32, i32* %15
store i32 %169, i32* %13
br label %170
170: ; preds = %238, %168
%171 = load i32, i32* %13
%172 = load i32, i32* %7
%173 = icmp slt i32 %171, %172
br i1 %173, label %174, label %241
174: ; preds = %170
store double 0.000000e+00, double* %21
%175 = load i32, i32* %12
store i32 %175, i32* %14
br label %176
176: ; preds = %201, %174
%177 = load i32, i32* %14
%178 = load i32, i32* %8
%179 = icmp slt i32 %177, %178
br i1 %179, label %180, label %204
180: ; preds = %176
%181 = load double**, double*** %6
%182 = load i32, i32* %14
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double*, double** %181, i64 %183
%185 = load double*, double** %184
%186 = load i32, i32* %12
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %185, i64 %187
%189 = load double, double* %188
%190 = load double**, double*** %6
%191 = load i32, i32* %14
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double*, double** %190, i64 %192
%194 = load double*, double** %193
%195 = load i32, i32* %13
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
%198 = load double, double* %197
%199 = load double, double* %21
%200 = call double @llvm.fmuladd.f64(double %189, double %198, double %199)
store double %200, double* %21
br label %201
201: ; preds = %180
%202 = load i32, i32* %14
%203 = add nsw i32 %202, 1
store i32 %203, i32* %14
br label %176
204: ; preds = %176
%205 = load double, double* %21
%206 = load double, double* %20
%207 = fdiv double %205, %206
store double %207, double* %18
%208 = load i32, i32* %12
store i32 %208, i32* %14
br label %209
209: ; preds = %234, %204
%210 = load i32, i32* %14
%211 = load i32, i32* %8
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %237
213: ; preds = %209
%214 = load double, double* %18
%215 = load double**, double*** %6
%216 = load i32, i32* %14
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double*, double** %215, i64 %217
%219 = load double*, double** %218
%220 = load i32, i32* %12
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
%223 = load double, double* %222
%224 = load double**, double*** %6
%225 = load i32, i32* %14
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double*, double** %224, i64 %226
%228 = load double*, double** %227
%229 = load i32, i32* %13
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %228, i64 %230
%232 = load double, double* %231
%233 = call double @llvm.fmuladd.f64(double %214, double %223, double %232)
store double %233, double* %231
br label %234
234: ; preds = %213
%235 = load i32, i32* %14
%236 = add nsw i32 %235, 1
store i32 %236, i32* %14
br label %209
237: ; preds = %209
br label %238
238: ; preds = %237
%239 = load i32, i32* %13
%240 = add nsw i32 %239, 1
store i32 %240, i32* %13
br label %170
241: ; preds = %170
br label %242
242: ; preds = %241, %133
%243 = load i32, i32* %12
store i32 %243, i32* %14
br label %244
244: ; preds = %260, %242
%245 = load i32, i32* %14
%246 = load i32, i32* %8
%247 = icmp slt i32 %245, %246
br i1 %247, label %248, label %263
248: ; preds = %244
%249 = load double, double* %22
%250 = load double**, double*** %6
%251 = load i32, i32* %14
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double*, double** %250, i64 %252
%254 = load double*, double** %253
%255 = load i32, i32* %12
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
%258 = load double, double* %257
%259 = fmul double %258, %249
store double %259, double* %257
br label %260
260: ; preds = %248
%261 = load i32, i32* %14
%262 = add nsw i32 %261, 1
store i32 %262, i32* %14
br label %244
263: ; preds = %244
br label %264
264: ; preds = %263, %89
br label %265
265: ; preds = %264, %54
%266 = load double, double* %22
%267 = load double, double* %19
%268 = fmul double %266, %267
%269 = load double*, double** %9
%270 = load i32, i32* %12
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double, double* %269, i64 %271
store double %268, double* %272
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
%273 = load i32, i32* %12
%274 = load i32, i32* %8
%275 = icmp slt i32 %273, %274
br i1 %275, label %276, label %491
276: ; preds = %265
%277 = load i32, i32* %12
%278 = load i32, i32* %7
%279 = sub nsw i32 %278, 1
%280 = icmp slt i32 %277, %279
br i1 %280, label %281, label %491
281: ; preds = %276
%282 = load i32, i32* %15
store i32 %282, i32* %14
br label %283
283: ; preds = %300, %281
%284 = load i32, i32* %14
%285 = load i32, i32* %7
%286 = icmp slt i32 %284, %285
br i1 %286, label %287, label %303
287: ; preds = %283
%288 = load double**, double*** %6
%289 = load i32, i32* %12
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double*, double** %288, i64 %290
%292 = load double*, double** %291
%293 = load i32, i32* %14
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %292, i64 %294
%296 = load double, double* %295
%297 = call double @llvm.fabs.f64(double %296)
%298 = load double, double* %22
%299 = fadd double %298, %297
store double %299, double* %22
br label %300
300: ; preds = %287
%301 = load i32, i32* %14
%302 = add nsw i32 %301, 1
store i32 %302, i32* %14
br label %283
303: ; preds = %283
%304 = load double, double* %22
%305 = fcmp une double %304, 0.000000e+00
br i1 %305, label %306, label %490
306: ; preds = %303
%307 = load i32, i32* %15
store i32 %307, i32* %14
br label %308
308: ; preds = %344, %306
%309 = load i32, i32* %14
%310 = load i32, i32* %7
%311 = icmp slt i32 %309, %310
br i1 %311, label %312, label %347
312: ; preds = %308
%313 = load double, double* %22
%314 = load double**, double*** %6
%315 = load i32, i32* %12
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double*, double** %314, i64 %316
%318 = load double*, double** %317
%319 = load i32, i32* %14
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %318, i64 %320
%322 = load double, double* %321
%323 = fdiv double %322, %313
store double %323, double* %321
%324 = load double**, double*** %6
%325 = load i32, i32* %12
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double*, double** %324, i64 %326
%328 = load double*, double** %327
%329 = load i32, i32* %14
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = load double**, double*** %6
%334 = load i32, i32* %12
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds double*, double** %333, i64 %335
%337 = load double*, double** %336
%338 = load i32, i32* %14
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %337, i64 %339
%341 = load double, double* %340
%342 = load double, double* %21
%343 = call double @llvm.fmuladd.f64(double %332, double %341, double %342)
store double %343, double* %21
br label %344
344: ; preds = %312
%345 = load i32, i32* %14
%346 = add nsw i32 %345, 1
store i32 %346, i32* %14
br label %308
347: ; preds = %308
%348 = load double**, double*** %6
%349 = load i32, i32* %12
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double*, double** %348, i64 %350
%352 = load double*, double** %351
%353 = load i32, i32* %15
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %352, i64 %354
%356 = load double, double* %355
store double %356, double* %18
%357 = load double, double* %21
%358 = call double @sqrt(double %357)
%359 = load double, double* %18
%360 = call double @llvm.copysign.f64(double %358, double %359)
%361 = fneg double %360
store double %361, double* %19
%362 = load double, double* %18
%363 = load double, double* %19
%364 = load double, double* %21
%365 = fneg double %364
%366 = call double @llvm.fmuladd.f64(double %362, double %363, double %365)
store double %366, double* %20
%367 = load double, double* %18
%368 = load double, double* %19
%369 = fsub double %367, %368
%370 = load double**, double*** %6
%371 = load i32, i32* %12
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double*, double** %370, i64 %372
%374 = load double*, double** %373
%375 = load i32, i32* %15
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %374, i64 %376
store double %369, double* %377
%378 = load i32, i32* %15
store i32 %378, i32* %14
br label %379
379: ; preds = %399, %347
%380 = load i32, i32* %14
%381 = load i32, i32* %7
%382 = icmp slt i32 %380, %381
br i1 %382, label %383, label %402
383: ; preds = %379
%384 = load double**, double*** %6
%385 = load i32, i32* %12
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double*, double** %384, i64 %386
%388 = load double*, double** %387
%389 = load i32, i32* %14
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %388, i64 %390
%392 = load double, double* %391
%393 = load double, double* %20
%394 = fdiv double %392, %393
%395 = load double*, double** %11
%396 = load i32, i32* %14
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %395, i64 %397
store double %394, double* %398
br label %399
399: ; preds = %383
%400 = load i32, i32* %14
%401 = add nsw i32 %400, 1
store i32 %401, i32* %14
br label %379
402: ; preds = %379
%403 = load i32, i32* %15
store i32 %403, i32* %13
br label %404
404: ; preds = %465, %402
%405 = load i32, i32* %13
%406 = load i32, i32* %8
%407 = icmp slt i32 %405, %406
br i1 %407, label %408, label %468
408: ; preds = %404
store double 0.000000e+00, double* %21
%409 = load i32, i32* %15
store i32 %409, i32* %14
br label %410
410: ; preds = %435, %408
%411 = load i32, i32* %14
%412 = load i32, i32* %7
%413 = icmp slt i32 %411, %412
br i1 %413, label %414, label %438
414: ; preds = %410
%415 = load double**, double*** %6
%416 = load i32, i32* %13
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double*, double** %415, i64 %417
%419 = load double*, double** %418
%420 = load i32, i32* %14
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double, double* %419, i64 %421
%423 = load double, double* %422
%424 = load double**, double*** %6
%425 = load i32, i32* %12
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds double*, double** %424, i64 %426
%428 = load double*, double** %427
%429 = load i32, i32* %14
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %428, i64 %430
%432 = load double, double* %431
%433 = load double, double* %21
%434 = call double @llvm.fmuladd.f64(double %423, double %432, double %433)
store double %434, double* %21
br label %435
435: ; preds = %414
%436 = load i32, i32* %14
%437 = add nsw i32 %436, 1
store i32 %437, i32* %14
br label %410
438: ; preds = %410
%439 = load i32, i32* %15
store i32 %439, i32* %14
br label %440
440: ; preds = %461, %438
%441 = load i32, i32* %14
%442 = load i32, i32* %7
%443 = icmp slt i32 %441, %442
br i1 %443, label %444, label %464
444: ; preds = %440
%445 = load double, double* %21
%446 = load double*, double** %11
%447 = load i32, i32* %14
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds double, double* %446, i64 %448
%450 = load double, double* %449
%451 = load double**, double*** %6
%452 = load i32, i32* %13
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double*, double** %451, i64 %453
%455 = load double*, double** %454
%456 = load i32, i32* %14
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds double, double* %455, i64 %457
%459 = load double, double* %458
%460 = call double @llvm.fmuladd.f64(double %445, double %450, double %459)
store double %460, double* %458
br label %461
461: ; preds = %444
%462 = load i32, i32* %14
%463 = add nsw i32 %462, 1
store i32 %463, i32* %14
br label %440
464: ; preds = %440
br label %465
465: ; preds = %464
%466 = load i32, i32* %13
%467 = add nsw i32 %466, 1
store i32 %467, i32* %13
br label %404
468: ; preds = %404
%469 = load i32, i32* %15
store i32 %469, i32* %14
br label %470
470: ; preds = %486, %468
%471 = load i32, i32* %14
%472 = load i32, i32* %7
%473 = icmp slt i32 %471, %472
br i1 %473, label %474, label %489
474: ; preds = %470
%475 = load double, double* %22
%476 = load double**, double*** %6
%477 = load i32, i32* %12
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double*, double** %476, i64 %478
%480 = load double*, double** %479
%481 = load i32, i32* %14
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %480, i64 %482
%484 = load double, double* %483
%485 = fmul double %484, %475
store double %485, double* %483
br label %486
486: ; preds = %474
%487 = load i32, i32* %14
%488 = add nsw i32 %487, 1
store i32 %488, i32* %14
br label %470
489: ; preds = %470
br label %490
490: ; preds = %489, %303
br label %491
491: ; preds = %490, %276, %265
%492 = load double*, double** %9
%493 = load i32, i32* %12
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %492, i64 %494
%496 = load double, double* %495
%497 = call double @llvm.fabs.f64(double %496)
%498 = load double*, double** %11
%499 = load i32, i32* %12
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
%502 = load double, double* %501
%503 = call double @llvm.fabs.f64(double %502)
%504 = fadd double %497, %503
store double %504, double* %23
%505 = load double, double* %16
%506 = load double, double* %23
%507 = fcmp ogt double %505, %506
br i1 %507, label %508, label %510
508: ; preds = %491
%509 = load double, double* %16
br label %512
510: ; preds = %491
%511 = load double, double* %23
br label %512
512: ; preds = %510, %508
%513 = phi double [ %509, %508 ], [ %511, %510 ]
store double %513, double* %16
br label %514
514: ; preds = %512
%515 = load i32, i32* %12
%516 = add nsw i32 %515, 1
store i32 %516, i32* %12
br label %50
517: ; preds = %50
%518 = load i32, i32* %7
%519 = sub nsw i32 %518, 1
store i32 %519, i32* %12
br label %520
520: ; preds = %683, %517
%521 = load i32, i32* %12
%522 = icmp sge i32 %521, 0
br i1 %522, label %523, label %686
523: ; preds = %520
%524 = load i32, i32* %12
%525 = load i32, i32* %7
%526 = sub nsw i32 %525, 1
%527 = icmp slt i32 %524, %526
br i1 %527, label %528, label %668
528: ; preds = %523
%529 = load double, double* %19
%530 = fcmp une double %529, 0.000000e+00
br i1 %530, label %531, label %641
531: ; preds = %528
%532 = load i32, i32* %15
store i32 %532, i32* %13
br label %533
533: ; preds = %567, %531
%534 = load i32, i32* %13
%535 = load i32, i32* %7
%536 = icmp slt i32 %534, %535
br i1 %536, label %537, label %570
537: ; preds = %533
%538 = load double**, double*** %6
%539 = load i32, i32* %12
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double*, double** %538, i64 %540
%542 = load double*, double** %541
%543 = load i32, i32* %13
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds double, double* %542, i64 %544
%546 = load double, double* %545
%547 = load double**, double*** %6
%548 = load i32, i32* %12
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds double*, double** %547, i64 %549
%551 = load double*, double** %550
%552 = load i32, i32* %15
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %551, i64 %553
%555 = load double, double* %554
%556 = fdiv double %546, %555
%557 = load double, double* %19
%558 = fdiv double %556, %557
%559 = load double**, double*** %10
%560 = load i32, i32* %13
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds double*, double** %559, i64 %561
%563 = load double*, double** %562
%564 = load i32, i32* %12
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %563, i64 %565
store double %558, double* %566
br label %567
567: ; preds = %537
%568 = load i32, i32* %13
%569 = add nsw i32 %568, 1
store i32 %569, i32* %13
br label %533
570: ; preds = %533
%571 = load i32, i32* %15
store i32 %571, i32* %13
br label %572
572: ; preds = %637, %570
%573 = load i32, i32* %13
%574 = load i32, i32* %7
%575 = icmp slt i32 %573, %574
br i1 %575, label %576, label %640
576: ; preds = %572
store double 0.000000e+00, double* %21
%577 = load i32, i32* %15
store i32 %577, i32* %14
br label %578
578: ; preds = %603, %576
%579 = load i32, i32* %14
%580 = load i32, i32* %7
%581 = icmp slt i32 %579, %580
br i1 %581, label %582, label %606
582: ; preds = %578
%583 = load double**, double*** %6
%584 = load i32, i32* %12
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double*, double** %583, i64 %585
%587 = load double*, double** %586
%588 = load i32, i32* %14
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds double, double* %587, i64 %589
%591 = load double, double* %590
%592 = load double**, double*** %10
%593 = load i32, i32* %14
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds double*, double** %592, i64 %594
%596 = load double*, double** %595
%597 = load i32, i32* %13
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %596, i64 %598
%600 = load double, double* %599
%601 = load double, double* %21
%602 = call double @llvm.fmuladd.f64(double %591, double %600, double %601)
store double %602, double* %21
br label %603
603: ; preds = %582
%604 = load i32, i32* %14
%605 = add nsw i32 %604, 1
store i32 %605, i32* %14
br label %578
606: ; preds = %578
%607 = load i32, i32* %15
store i32 %607, i32* %14
br label %608
608: ; preds = %633, %606
%609 = load i32, i32* %14
%610 = load i32, i32* %7
%611 = icmp slt i32 %609, %610
br i1 %611, label %612, label %636
612: ; preds = %608
%613 = load double, double* %21
%614 = load double**, double*** %10
%615 = load i32, i32* %14
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds double*, double** %614, i64 %616
%618 = load double*, double** %617
%619 = load i32, i32* %12
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds double, double* %618, i64 %620
%622 = load double, double* %621
%623 = load double**, double*** %10
%624 = load i32, i32* %14
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double*, double** %623, i64 %625
%627 = load double*, double** %626
%628 = load i32, i32* %13
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds double, double* %627, i64 %629
%631 = load double, double* %630
%632 = call double @llvm.fmuladd.f64(double %613, double %622, double %631)
store double %632, double* %630
br label %633
633: ; preds = %612
%634 = load i32, i32* %14
%635 = add nsw i32 %634, 1
store i32 %635, i32* %14
br label %608
636: ; preds = %608
br label %637
637: ; preds = %636
%638 = load i32, i32* %13
%639 = add nsw i32 %638, 1
store i32 %639, i32* %13
br label %572
640: ; preds = %572
br label %641
641: ; preds = %640, %528
%642 = load i32, i32* %15
store i32 %642, i32* %13
br label %643
643: ; preds = %664, %641
%644 = load i32, i32* %13
%645 = load i32, i32* %7
%646 = icmp slt i32 %644, %645
br i1 %646, label %647, label %667
647: ; preds = %643
%648 = load double**, double*** %10
%649 = load i32, i32* %12
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double*, double** %648, i64 %650
%652 = load double*, double** %651
%653 = load i32, i32* %13
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %652, i64 %654
store double 0.000000e+00, double* %655
%656 = load double**, double*** %10
%657 = load i32, i32* %13
%658 = sext i32 %657 to i64
%659 = getelementptr inbounds double*, double** %656, i64 %658
%660 = load double*, double** %659
%661 = load i32, i32* %12
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds double, double* %660, i64 %662
store double 0.000000e+00, double* %663
br label %664
664: ; preds = %647
%665 = load i32, i32* %13
%666 = add nsw i32 %665, 1
store i32 %666, i32* %13
br label %643
667: ; preds = %643
br label %668
668: ; preds = %667, %523
%669 = load double**, double*** %10
%670 = load i32, i32* %12
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double*, double** %669, i64 %671
%673 = load double*, double** %672
%674 = load i32, i32* %12
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double, double* %673, i64 %675
store double 1.000000e+00, double* %676
%677 = load double*, double** %11
%678 = load i32, i32* %12
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %677, i64 %679
%681 = load double, double* %680
store double %681, double* %19
%682 = load i32, i32* %12
store i32 %682, i32* %15
br label %683
683: ; preds = %668
%684 = load i32, i32* %12
%685 = add nsw i32 %684, -1
store i32 %685, i32* %12
br label %520
686: ; preds = %520
%687 = load i32, i32* %8
%688 = load i32, i32* %7
%689 = icmp slt i32 %687, %688
br i1 %689, label %690, label %693
690: ; preds = %686
%691 = load i32, i32* %8
%692 = sub nsw i32 %691, 1
br label %696
693: ; preds = %686
%694 = load i32, i32* %7
%695 = sub nsw i32 %694, 1
br label %696
696: ; preds = %693, %690
%697 = phi i32 [ %692, %690 ], [ %695, %693 ]
store i32 %697, i32* %12
br label %698
698: ; preds = %870, %696
%699 = load i32, i32* %12
%700 = icmp sge i32 %699, 0
br i1 %700, label %701, label %873
701: ; preds = %698
%702 = load i32, i32* %12
%703 = add nsw i32 %702, 1
store i32 %703, i32* %15
%704 = load double*, double** %9
%705 = load i32, i32* %12
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds double, double* %704, i64 %706
%708 = load double, double* %707
store double %708, double* %19
%709 = load i32, i32* %12
%710 = load i32, i32* %7
%711 = sub nsw i32 %710, 1
%712 = icmp ne i32 %709, %711
br i1 %712, label %713, label %732
713: ; preds = %701
%714 = load i32, i32* %15
store i32 %714, i32* %13
br label %715
715: ; preds = %728, %713
%716 = load i32, i32* %13
%717 = load i32, i32* %7
%718 = icmp slt i32 %716, %717
br i1 %718, label %719, label %731
719: ; preds = %715
%720 = load double**, double*** %6
%721 = load i32, i32* %12
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double*, double** %720, i64 %722
%724 = load double*, double** %723
%725 = load i32, i32* %13
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds double, double* %724, i64 %726
store double 0.000000e+00, double* %727
br label %728
728: ; preds = %719
%729 = load i32, i32* %13
%730 = add nsw i32 %729, 1
store i32 %730, i32* %13
br label %715
731: ; preds = %715
br label %732
732: ; preds = %731, %701
%733 = load double, double* %19
%734 = fcmp une double %733, 0.000000e+00
br i1 %734, label %735, label %840
735: ; preds = %732
%736 = load i32, i32* %15
store i32 %736, i32* %13
br label %737
737: ; preds = %815, %735
%738 = load i32, i32* %13
%739 = load i32, i32* %7
%740 = icmp slt i32 %738, %739
br i1 %740, label %741, label %818
741: ; preds = %737
store double 0.000000e+00, double* %21
%742 = load i32, i32* %15
store i32 %742, i32* %14
br label %743
743: ; preds = %768, %741
%744 = load i32, i32* %14
%745 = load i32, i32* %8
%746 = icmp slt i32 %744, %745
br i1 %746, label %747, label %771
747: ; preds = %743
%748 = load double**, double*** %6
%749 = load i32, i32* %14
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds double*, double** %748, i64 %750
%752 = load double*, double** %751
%753 = load i32, i32* %12
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds double, double* %752, i64 %754
%756 = load double, double* %755
%757 = load double**, double*** %6
%758 = load i32, i32* %14
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double*, double** %757, i64 %759
%761 = load double*, double** %760
%762 = load i32, i32* %13
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds double, double* %761, i64 %763
%765 = load double, double* %764
%766 = load double, double* %21
%767 = call double @llvm.fmuladd.f64(double %756, double %765, double %766)
store double %767, double* %21
br label %768
768: ; preds = %747
%769 = load i32, i32* %14
%770 = add nsw i32 %769, 1
store i32 %770, i32* %14
br label %743
771: ; preds = %743
%772 = load double, double* %21
%773 = load double**, double*** %6
%774 = load i32, i32* %12
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds double*, double** %773, i64 %775
%777 = load double*, double** %776
%778 = load i32, i32* %12
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds double, double* %777, i64 %779
%781 = load double, double* %780
%782 = fdiv double %772, %781
%783 = load double, double* %19
%784 = fdiv double %782, %783
store double %784, double* %18
%785 = load i32, i32* %12
store i32 %785, i32* %14
br label %786
786: ; preds = %811, %771
%787 = load i32, i32* %14
%788 = load i32, i32* %8
%789 = icmp slt i32 %787, %788
br i1 %789, label %790, label %814
790: ; preds = %786
%791 = load double, double* %18
%792 = load double**, double*** %6
%793 = load i32, i32* %14
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double*, double** %792, i64 %794
%796 = load double*, double** %795
%797 = load i32, i32* %12
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %796, i64 %798
%800 = load double, double* %799
%801 = load double**, double*** %6
%802 = load i32, i32* %14
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds double*, double** %801, i64 %803
%805 = load double*, double** %804
%806 = load i32, i32* %13
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds double, double* %805, i64 %807
%809 = load double, double* %808
%810 = call double @llvm.fmuladd.f64(double %791, double %800, double %809)
store double %810, double* %808
br label %811
811: ; preds = %790
%812 = load i32, i32* %14
%813 = add nsw i32 %812, 1
store i32 %813, i32* %14
br label %786
814: ; preds = %786
br label %815
815: ; preds = %814
%816 = load i32, i32* %13
%817 = add nsw i32 %816, 1
store i32 %817, i32* %13
br label %737
818: ; preds = %737
%819 = load i32, i32* %12
store i32 %819, i32* %13
br label %820
820: ; preds = %836, %818
%821 = load i32, i32* %13
%822 = load i32, i32* %8
%823 = icmp slt i32 %821, %822
br i1 %823, label %824, label %839
824: ; preds = %820
%825 = load double, double* %19
%826 = load double**, double*** %6
%827 = load i32, i32* %13
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds double*, double** %826, i64 %828
%830 = load double*, double** %829
%831 = load i32, i32* %12
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds double, double* %830, i64 %832
%834 = load double, double* %833
%835 = fdiv double %834, %825
store double %835, double* %833
br label %836
836: ; preds = %824
%837 = load i32, i32* %13
%838 = add nsw i32 %837, 1
store i32 %838, i32* %13
br label %820
839: ; preds = %820
br label %859
840: ; preds = %732
%841 = load i32, i32* %12
store i32 %841, i32* %13
br label %842
842: ; preds = %855, %840
%843 = load i32, i32* %13
%844 = load i32, i32* %8
%845 = icmp slt i32 %843, %844
br i1 %845, label %846, label %858
846: ; preds = %842
%847 = load double**, double*** %6
%848 = load i32, i32* %13
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds double*, double** %847, i64 %849
%851 = load double*, double** %850
%852 = load i32, i32* %12
%853 = sext i32 %852 to i64
%854 = getelementptr inbounds double, double* %851, i64 %853
store double 0.000000e+00, double* %854
br label %855
855: ; preds = %846
%856 = load i32, i32* %13
%857 = add nsw i32 %856, 1
store i32 %857, i32* %13
br label %842
858: ; preds = %842
br label %859
859: ; preds = %858, %839
%860 = load double**, double*** %6
%861 = load i32, i32* %12
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds double*, double** %860, i64 %862
%864 = load double*, double** %863
%865 = load i32, i32* %12
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds double, double* %864, i64 %866
%868 = load double, double* %867
%869 = fadd double %868, 1.000000e+00
store double %869, double* %867
br label %870
870: ; preds = %859
%871 = load i32, i32* %12
%872 = add nsw i32 %871, -1
store i32 %872, i32* %12
br label %698
873: ; preds = %698
%874 = load i32, i32* %7
%875 = sub nsw i32 %874, 1
store i32 %875, i32* %14
br label %876
876: ; preds = %1374, %873
%877 = load i32, i32* %14
%878 = icmp sge i32 %877, 0
br i1 %878, label %879, label %1377
879: ; preds = %876
%880 = load i32, i32* %14
%881 = sub nsw i32 %880, 1
store i32 %881, i32* %24
store i32 0, i32* %25
br label %882
882: ; preds = %879, %1372
store i32 1, i32* %26
store i32 -1, i32* %30
%883 = load i32, i32* %25
%884 = add nsw i32 %883, 1
store i32 %884, i32* %25
%885 = load i32, i32* %25
%886 = icmp sgt i32 %885, 30
br i1 %886, label %887, label %889
887: ; preds = %882
%888 = call i32 @csa_quit(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i32 30)
br label %889
889: ; preds = %887, %882
%890 = load i32, i32* %14
store i32 %890, i32* %15
br label %891
891: ; preds = %924, %889
%892 = load i32, i32* %15
%893 = icmp sge i32 %892, 0
br i1 %893, label %894, label %927
894: ; preds = %891
%895 = load double*, double** %11
%896 = load i32, i32* %15
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds double, double* %895, i64 %897
%899 = load double, double* %898
%900 = call double @llvm.fabs.f64(double %899)
%901 = load double, double* %16
%902 = fadd double %900, %901
store double %902, double* %31
%903 = load double, double* %31
%904 = load double, double* %16
%905 = fcmp oeq double %903, %904
br i1 %905, label %906, label %907
906: ; preds = %894
store i32 0, i32* %26
br label %927
907: ; preds = %894
%908 = load i32, i32* %15
%909 = sub nsw i32 %908, 1
store i32 %909, i32* %30
%910 = load double*, double** %9
%911 = load i32, i32* %15
%912 = sub nsw i32 %911, 1
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds double, double* %910, i64 %913
%915 = load double, double* %914
%916 = call double @llvm.fabs.f64(double %915)
%917 = load double, double* %16
%918 = fadd double %916, %917
store double %918, double* %31
%919 = load double, double* %31
%920 = load double, double* %16
%921 = fcmp oeq double %919, %920
br i1 %921, label %922, label %923
922: ; preds = %907
br label %927
923: ; preds = %907
br label %924
924: ; preds = %923
%925 = load i32, i32* %15
%926 = add nsw i32 %925, -1
store i32 %926, i32* %15
br label %891
927: ; preds = %922, %906, %891
%928 = load i32, i32* %26
%929 = icmp ne i32 %928, 0
br i1 %929, label %930, label %1045
930: ; preds = %927
store double 0.000000e+00, double* %17
store double 1.000000e+00, double* %21
%931 = load i32, i32* %15
store i32 %931, i32* %12
br label %932
932: ; preds = %1041, %930
%933 = load i32, i32* %12
%934 = load i32, i32* %14
%935 = icmp sle i32 %933, %934
br i1 %935, label %936, label %1044
936: ; preds = %932
%937 = load double, double* %21
%938 = load double*, double** %11
%939 = load i32, i32* %12
%940 = sext i32 %939 to i64
%941 = getelementptr inbounds double, double* %938, i64 %940
%942 = load double, double* %941
%943 = fmul double %937, %942
store double %943, double* %18
%944 = load double, double* %17
%945 = load double*, double** %11
%946 = load i32, i32* %12
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double, double* %945, i64 %947
%949 = load double, double* %948
%950 = fmul double %944, %949
%951 = load double*, double** %11
%952 = load i32, i32* %12
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds double, double* %951, i64 %953
store double %950, double* %954
%955 = load double, double* %18
%956 = call double @llvm.fabs.f64(double %955)
%957 = load double, double* %16
%958 = fadd double %956, %957
%959 = load double, double* %16
%960 = fcmp oeq double %958, %959
br i1 %960, label %961, label %962
961: ; preds = %936
br label %1044
962: ; preds = %936
%963 = load double*, double** %9
%964 = load i32, i32* %12
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds double, double* %963, i64 %965
%967 = load double, double* %966
store double %967, double* %19
%968 = load double, double* %18
%969 = load double, double* %19
%970 = call double @hypot(double %968, double %969)
store double %970, double* %20
%971 = load double, double* %20
%972 = load double*, double** %9
%973 = load i32, i32* %12
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds double, double* %972, i64 %974
store double %971, double* %975
%976 = load double, double* %20
%977 = fdiv double 1.000000e+00, %976
store double %977, double* %20
%978 = load double, double* %19
%979 = load double, double* %20
%980 = fmul double %978, %979
store double %980, double* %17
%981 = load double, double* %18
%982 = fneg double %981
%983 = load double, double* %20
%984 = fmul double %982, %983
store double %984, double* %21
store i32 0, i32* %13
br label %985
985: ; preds = %1037, %962
%986 = load i32, i32* %13
%987 = load i32, i32* %8
%988 = icmp slt i32 %986, %987
br i1 %988, label %989, label %1040
989: ; preds = %985
%990 = load double**, double*** %6
%991 = load i32, i32* %13
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds double*, double** %990, i64 %992
%994 = load double*, double** %993
%995 = load i32, i32* %30
%996 = sext i32 %995 to i64
%997 = getelementptr inbounds double, double* %994, i64 %996
%998 = load double, double* %997
store double %998, double* %32
%999 = load double**, double*** %6
%1000 = load i32, i32* %13
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds double*, double** %999, i64 %1001
%1003 = load double*, double** %1002
%1004 = load i32, i32* %12
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds double, double* %1003, i64 %1005
%1007 = load double, double* %1006
store double %1007, double* %33
%1008 = load double, double* %32
%1009 = load double, double* %17
%1010 = load double, double* %33
%1011 = load double, double* %21
%1012 = fmul double %1010, %1011
%1013 = call double @llvm.fmuladd.f64(double %1008, double %1009, double %1012)
%1014 = load double**, double*** %6
%1015 = load i32, i32* %13
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double*, double** %1014, i64 %1016
%1018 = load double*, double** %1017
%1019 = load i32, i32* %30
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds double, double* %1018, i64 %1020
store double %1013, double* %1021
%1022 = load double, double* %33
%1023 = load double, double* %17
%1024 = load double, double* %32
%1025 = load double, double* %21
%1026 = fmul double %1024, %1025
%1027 = fneg double %1026
%1028 = call double @llvm.fmuladd.f64(double %1022, double %1023, double %1027)
%1029 = load double**, double*** %6
%1030 = load i32, i32* %13
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds double*, double** %1029, i64 %1031
%1033 = load double*, double** %1032
%1034 = load i32, i32* %12
%1035 = sext i32 %1034 to i64
%1036 = getelementptr inbounds double, double* %1033, i64 %1035
store double %1028, double* %1036
br label %1037
1037: ; preds = %989
%1038 = load i32, i32* %13
%1039 = add nsw i32 %1038, 1
store i32 %1039, i32* %13
br label %985
1040: ; preds = %985
br label %1041
1041: ; preds = %1040
%1042 = load i32, i32* %12
%1043 = add nsw i32 %1042, 1
store i32 %1043, i32* %12
br label %932
1044: ; preds = %961, %932
br label %1045
1045: ; preds = %1044, %927
%1046 = load double*, double** %9
%1047 = load i32, i32* %14
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds double, double* %1046, i64 %1048
%1050 = load double, double* %1049
store double %1050, double* %29
%1051 = load i32, i32* %15
%1052 = load i32, i32* %14
%1053 = icmp ne i32 %1051, %1052
br i1 %1053, label %1054, label %1334
1054: ; preds = %1045
%1055 = load double*, double** %9
%1056 = load i32, i32* %15
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds double, double* %1055, i64 %1057
%1059 = load double, double* %1058
store double %1059, double* %27
%1060 = load double*, double** %9
%1061 = load i32, i32* %24
%1062 = sext i32 %1061 to i64
%1063 = getelementptr inbounds double, double* %1060, i64 %1062
%1064 = load double, double* %1063
store double %1064, double* %28
%1065 = load double*, double** %11
%1066 = load i32, i32* %24
%1067 = sext i32 %1066 to i64
%1068 = getelementptr inbounds double, double* %1065, i64 %1067
%1069 = load double, double* %1068
store double %1069, double* %19
%1070 = load double*, double** %11
%1071 = load i32, i32* %14
%1072 = sext i32 %1071 to i64
%1073 = getelementptr inbounds double, double* %1070, i64 %1072
%1074 = load double, double* %1073
store double %1074, double* %20
%1075 = load double, double* %19
%1076 = load double, double* %29
%1077 = fadd double %1075, %1076
%1078 = load double, double* %20
%1079 = fdiv double %1077, %1078
%1080 = load double, double* %19
%1081 = load double, double* %29
%1082 = fsub double %1080, %1081
%1083 = load double, double* %28
%1084 = fdiv double %1082, %1083
%1085 = load double, double* %28
%1086 = load double, double* %20
%1087 = fdiv double %1085, %1086
%1088 = call double @llvm.fmuladd.f64(double %1079, double %1084, double %1087)
%1089 = load double, double* %20
%1090 = load double, double* %28
%1091 = fdiv double %1089, %1090
%1092 = fsub double %1088, %1091
%1093 = fmul double 5.000000e-01, %1092
store double %1093, double* %18
%1094 = load double, double* %18
%1095 = call double @hypot(double %1094, double 1.000000e+00)
store double %1095, double* %19
%1096 = load double, double* %27
%1097 = load double, double* %29
%1098 = load double, double* %27
%1099 = fdiv double %1097, %1098
%1100 = load double, double* %29
%1101 = fneg double %1099
%1102 = call double @llvm.fmuladd.f64(double %1101, double %1100, double %1096)
%1103 = load double, double* %20
%1104 = load double, double* %27
%1105 = fdiv double %1103, %1104
%1106 = load double, double* %28
%1107 = load double, double* %18
%1108 = load double, double* %19
%1109 = load double, double* %18
%1110 = call double @llvm.copysign.f64(double %1108, double %1109)
%1111 = fadd double %1107, %1110
%1112 = fdiv double %1106, %1111
%1113 = load double, double* %20
%1114 = fsub double %1112, %1113
%1115 = call double @llvm.fmuladd.f64(double %1105, double %1114, double %1102)
store double %1115, double* %18
store double 1.000000e+00, double* %17
store double 1.000000e+00, double* %21
%1116 = load i32, i32* %15
store i32 %1116, i32* %34
br label %1117
1117: ; preds = %1316, %1054
%1118 = load i32, i32* %34
%1119 = load i32, i32* %14
%1120 = icmp slt i32 %1118, %1119
br i1 %1120, label %1121, label %1319
1121: ; preds = %1117
%1122 = load i32, i32* %34
%1123 = add nsw i32 %1122, 1
store i32 %1123, i32* %12
%1124 = load double*, double** %11
%1125 = load i32, i32* %12
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds double, double* %1124, i64 %1126
%1128 = load double, double* %1127
store double %1128, double* %19
%1129 = load double*, double** %9
%1130 = load i32, i32* %12
%1131 = sext i32 %1130 to i64
%1132 = getelementptr inbounds double, double* %1129, i64 %1131
%1133 = load double, double* %1132
store double %1133, double* %28
%1134 = load double, double* %21
%1135 = load double, double* %19
%1136 = fmul double %1134, %1135
store double %1136, double* %20
%1137 = load double, double* %17
%1138 = load double, double* %19
%1139 = fmul double %1137, %1138
store double %1139, double* %19
%1140 = load double, double* %18
%1141 = load double, double* %20
%1142 = call double @hypot(double %1140, double %1141)
store double %1142, double* %29
%1143 = load double, double* %29
%1144 = load double*, double** %11
%1145 = load i32, i32* %34
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds double, double* %1144, i64 %1146
store double %1143, double* %1147
%1148 = load double, double* %18
%1149 = load double, double* %29
%1150 = fdiv double %1148, %1149
store double %1150, double* %17
%1151 = load double, double* %20
%1152 = load double, double* %29
%1153 = fdiv double %1151, %1152
store double %1153, double* %21
%1154 = load double, double* %27
%1155 = load double, double* %17
%1156 = load double, double* %19
%1157 = load double, double* %21
%1158 = fmul double %1156, %1157
%1159 = call double @llvm.fmuladd.f64(double %1154, double %1155, double %1158)
store double %1159, double* %18
%1160 = load double, double* %19
%1161 = load double, double* %17
%1162 = load double, double* %27
%1163 = load double, double* %21
%1164 = fmul double %1162, %1163
%1165 = fneg double %1164
%1166 = call double @llvm.fmuladd.f64(double %1160, double %1161, double %1165)
store double %1166, double* %19
%1167 = load double, double* %28
%1168 = load double, double* %21
%1169 = fmul double %1167, %1168
store double %1169, double* %20
%1170 = load double, double* %17
%1171 = load double, double* %28
%1172 = fmul double %1171, %1170
store double %1172, double* %28
store i32 0, i32* %13
br label %1173
1173: ; preds = %1225, %1121
%1174 = load i32, i32* %13
%1175 = load i32, i32* %7
%1176 = icmp slt i32 %1174, %1175
br i1 %1176, label %1177, label %1228
1177: ; preds = %1173
%1178 = load double**, double*** %10
%1179 = load i32, i32* %13
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds double*, double** %1178, i64 %1180
%1182 = load double*, double** %1181
%1183 = load i32, i32* %34
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds double, double* %1182, i64 %1184
%1186 = load double, double* %1185
store double %1186, double* %27
%1187 = load double**, double*** %10
%1188 = load i32, i32* %13
%1189 = sext i32 %1188 to i64
%1190 = getelementptr inbounds double*, double** %1187, i64 %1189
%1191 = load double*, double** %1190
%1192 = load i32, i32* %12
%1193 = sext i32 %1192 to i64
%1194 = getelementptr inbounds double, double* %1191, i64 %1193
%1195 = load double, double* %1194
store double %1195, double* %29
%1196 = load double, double* %27
%1197 = load double, double* %17
%1198 = load double, double* %29
%1199 = load double, double* %21
%1200 = fmul double %1198, %1199
%1201 = call double @llvm.fmuladd.f64(double %1196, double %1197, double %1200)
%1202 = load double**, double*** %10
%1203 = load i32, i32* %13
%1204 = sext i32 %1203 to i64
%1205 = getelementptr inbounds double*, double** %1202, i64 %1204
%1206 = load double*, double** %1205
%1207 = load i32, i32* %34
%1208 = sext i32 %1207 to i64
%1209 = getelementptr inbounds double, double* %1206, i64 %1208
store double %1201, double* %1209
%1210 = load double, double* %29
%1211 = load double, double* %17
%1212 = load double, double* %27
%1213 = load double, double* %21
%1214 = fmul double %1212, %1213
%1215 = fneg double %1214
%1216 = call double @llvm.fmuladd.f64(double %1210, double %1211, double %1215)
%1217 = load double**, double*** %10
%1218 = load i32, i32* %13
%1219 = sext i32 %1218 to i64
%1220 = getelementptr inbounds double*, double** %1217, i64 %1219
%1221 = load double*, double** %1220
%1222 = load i32, i32* %12
%1223 = sext i32 %1222 to i64
%1224 = getelementptr inbounds double, double* %1221, i64 %1223
store double %1216, double* %1224
br label %1225
1225: ; preds = %1177
%1226 = load i32, i32* %13
%1227 = add nsw i32 %1226, 1
store i32 %1227, i32* %13
br label %1173
1228: ; preds = %1173
%1229 = load double, double* %18
%1230 = load double, double* %20
%1231 = call double @hypot(double %1229, double %1230)
store double %1231, double* %29
%1232 = load double, double* %29
%1233 = load double*, double** %9
%1234 = load i32, i32* %34
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds double, double* %1233, i64 %1235
store double %1232, double* %1236
%1237 = load double, double* %29
%1238 = fcmp une double %1237, 0.000000e+00
br i1 %1238, label %1239, label %1246
1239: ; preds = %1228
%1240 = load double, double* %18
%1241 = load double, double* %29
%1242 = fdiv double %1240, %1241
store double %1242, double* %17
%1243 = load double, double* %20
%1244 = load double, double* %29
%1245 = fdiv double %1243, %1244
store double %1245, double* %21
br label %1246
1246: ; preds = %1239, %1228
%1247 = load double, double* %17
%1248 = load double, double* %19
%1249 = load double, double* %21
%1250 = load double, double* %28
%1251 = fmul double %1249, %1250
%1252 = call double @llvm.fmuladd.f64(double %1247, double %1248, double %1251)
store double %1252, double* %18
%1253 = load double, double* %17
%1254 = load double, double* %28
%1255 = load double, double* %21
%1256 = load double, double* %19
%1257 = fmul double %1255, %1256
%1258 = fneg double %1257
%1259 = call double @llvm.fmuladd.f64(double %1253, double %1254, double %1258)
store double %1259, double* %27
store i32 0, i32* %13
br label %1260
1260: ; preds = %1312, %1246
%1261 = load i32, i32* %13
%1262 = load i32, i32* %8
%1263 = icmp slt i32 %1261, %1262
br i1 %1263, label %1264, label %1315
1264: ; preds = %1260
%1265 = load double**, double*** %6
%1266 = load i32, i32* %13
%1267 = sext i32 %1266 to i64
%1268 = getelementptr inbounds double*, double** %1265, i64 %1267
%1269 = load double*, double** %1268
%1270 = load i32, i32* %34
%1271 = sext i32 %1270 to i64
%1272 = getelementptr inbounds double, double* %1269, i64 %1271
%1273 = load double, double* %1272
store double %1273, double* %28
%1274 = load double**, double*** %6
%1275 = load i32, i32* %13
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds double*, double** %1274, i64 %1276
%1278 = load double*, double** %1277
%1279 = load i32, i32* %12
%1280 = sext i32 %1279 to i64
%1281 = getelementptr inbounds double, double* %1278, i64 %1280
%1282 = load double, double* %1281
store double %1282, double* %29
%1283 = load double, double* %28
%1284 = load double, double* %17
%1285 = load double, double* %29
%1286 = load double, double* %21
%1287 = fmul double %1285, %1286
%1288 = call double @llvm.fmuladd.f64(double %1283, double %1284, double %1287)
%1289 = load double**, double*** %6
%1290 = load i32, i32* %13
%1291 = sext i32 %1290 to i64
%1292 = getelementptr inbounds double*, double** %1289, i64 %1291
%1293 = load double*, double** %1292
%1294 = load i32, i32* %34
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds double, double* %1293, i64 %1295
store double %1288, double* %1296
%1297 = load double, double* %29
%1298 = load double, double* %17
%1299 = load double, double* %28
%1300 = load double, double* %21
%1301 = fmul double %1299, %1300
%1302 = fneg double %1301
%1303 = call double @llvm.fmuladd.f64(double %1297, double %1298, double %1302)
%1304 = load double**, double*** %6
%1305 = load i32, i32* %13
%1306 = sext i32 %1305 to i64
%1307 = getelementptr inbounds double*, double** %1304, i64 %1306
%1308 = load double*, double** %1307
%1309 = load i32, i32* %12
%1310 = sext i32 %1309 to i64
%1311 = getelementptr inbounds double, double* %1308, i64 %1310
store double %1303, double* %1311
br label %1312
1312: ; preds = %1264
%1313 = load i32, i32* %13
%1314 = add nsw i32 %1313, 1
store i32 %1314, i32* %13
br label %1260
1315: ; preds = %1260
br label %1316
1316: ; preds = %1315
%1317 = load i32, i32* %34
%1318 = add nsw i32 %1317, 1
store i32 %1318, i32* %34
br label %1117
1319: ; preds = %1117
%1320 = load double*, double** %11
%1321 = load i32, i32* %15
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds double, double* %1320, i64 %1322
store double 0.000000e+00, double* %1323
%1324 = load double, double* %18
%1325 = load double*, double** %11
%1326 = load i32, i32* %14
%1327 = sext i32 %1326 to i64
%1328 = getelementptr inbounds double, double* %1325, i64 %1327
store double %1324, double* %1328
%1329 = load double, double* %27
%1330 = load double*, double** %9
%1331 = load i32, i32* %14
%1332 = sext i32 %1331 to i64
%1333 = getelementptr inbounds double, double* %1330, i64 %1332
store double %1329, double* %1333
br label %1372
1334: ; preds = %1045
%1335 = load double, double* %29
%1336 = fcmp olt double %1335, 0.000000e+00
br i1 %1336, label %1337, label %1371
1337: ; preds = %1334
%1338 = load double, double* %29
%1339 = fneg double %1338
%1340 = load double*, double** %9
%1341 = load i32, i32* %14
%1342 = sext i32 %1341 to i64
%1343 = getelementptr inbounds double, double* %1340, i64 %1342
store double %1339, double* %1343
store i32 0, i32* %13
br label %1344
1344: ; preds = %1367, %1337
%1345 = load i32, i32* %13
%1346 = load i32, i32* %7
%1347 = icmp slt i32 %1345, %1346
br i1 %1347, label %1348, label %1370
1348: ; preds = %1344
%1349 = load double**, double*** %10
%1350 = load i32, i32* %13
%1351 = sext i32 %1350 to i64
%1352 = getelementptr inbounds double*, double** %1349, i64 %1351
%1353 = load double*, double** %1352
%1354 = load i32, i32* %14
%1355 = sext i32 %1354 to i64
%1356 = getelementptr inbounds double, double* %1353, i64 %1355
%1357 = load double, double* %1356
%1358 = fneg double %1357
%1359 = load double**, double*** %10
%1360 = load i32, i32* %13
%1361 = sext i32 %1360 to i64
%1362 = getelementptr inbounds double*, double** %1359, i64 %1361
%1363 = load double*, double** %1362
%1364 = load i32, i32* %14
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds double, double* %1363, i64 %1365
store double %1358, double* %1366
br label %1367
1367: ; preds = %1348
%1368 = load i32, i32* %13
%1369 = add nsw i32 %1368, 1
store i32 %1369, i32* %13
br label %1344
1370: ; preds = %1344
br label %1371
1371: ; preds = %1370, %1334
br label %1373
1372: ; preds = %1319
br label %882
1373: ; preds = %1371
br label %1374
1374: ; preds = %1373
%1375 = load i32, i32* %14
%1376 = add nsw i32 %1375, -1
store i32 %1376, i32* %14
br label %876
1377: ; preds = %876
%1378 = load double*, double** %11
%1379 = call i32 @free(double* %1378)
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 @assert(i32 %9)
%11 = shl i32 %1, 3
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to double*
%14 = add i32 %1, -1
br i1 %7, label %15, label %719
15: ; preds = %5
%16 = sext i32 %2 to i64
%17 = zext i32 %14 to i64
%18 = zext i32 %1 to i64
%19 = zext i32 %1 to i64
%20 = zext i32 %2 to i64
%21 = getelementptr double, double* %13, i64 %19
%22 = getelementptr double, double* %13, i64 %19
%23 = add nsw i64 %19, -1
%24 = add nsw i64 %19, -2
%25 = sub nsw i64 0, %19
br label %26
26: ; preds = %15, %509
%27 = phi i64 [ 1, %15 ], [ %520, %509 ]
%28 = phi i64 [ 0, %15 ], [ %55, %509 ]
%29 = phi double [ 0.000000e+00, %15 ], [ %512, %509 ]
%30 = phi double [ 0.000000e+00, %15 ], [ %511, %509 ]
%31 = phi double [ 0.000000e+00, %15 ], [ %519, %509 ]
%32 = sub i64 %23, %28
%33 = add i64 %32, -4
%34 = lshr i64 %33, 2
%35 = add nuw nsw i64 %34, 1
%36 = sub i64 %23, %28
%37 = add i64 %36, -4
%38 = lshr i64 %37, 2
%39 = add nuw nsw i64 %38, 1
%40 = sub i64 %23, %28
%41 = sub i64 %24, %28
%42 = xor i64 %28, -1
%43 = add nsw i64 %42, %19
%44 = add i64 %43, -2
%45 = lshr i64 %44, 1
%46 = add nuw i64 %45, 1
%47 = xor i64 %28, -1
%48 = add nsw i64 %47, %19
%49 = getelementptr double, double* %13, i64 %27
%50 = xor i64 %28, -1
%51 = add nsw i64 %50, %19
%52 = getelementptr double, double* %13, i64 %27
%53 = xor i64 %28, -1
%54 = add nsw i64 %53, %19
%55 = add nuw nsw i64 %28, 1
%56 = fmul double %30, %29
%57 = getelementptr inbounds double, double* %13, i64 %28
store double %56, double* %57
%58 = icmp slt i64 %28, %16
br i1 %58, label %61, label %59
59: ; preds = %26
%60 = getelementptr inbounds double, double* %3, i64 %28
store double 0.000000e+00, double* %60
br label %509
61: ; preds = %26, %61
%62 = phi i64 [ %70, %61 ], [ %28, %26 ]
%63 = phi double [ %69, %61 ], [ 0.000000e+00, %26 ]
%64 = getelementptr inbounds double*, double** %0, i64 %62
%65 = load double*, double** %64
%66 = getelementptr inbounds double, double* %65, i64 %28
%67 = load double, double* %66
%68 = tail call double @llvm.fabs.f64(double %67)
%69 = fadd double %63, %68
%70 = add nuw nsw i64 %62, 1
%71 = icmp eq i64 %70, %20
br i1 %71, label %72, label %61
72: ; preds = %61
%73 = fcmp une double %69, 0.000000e+00
br i1 %73, label %74, label %141
74: ; preds = %72, %74
%75 = phi i64 [ %83, %74 ], [ %28, %72 ]
%76 = phi double [ %82, %74 ], [ 0.000000e+00, %72 ]
%77 = getelementptr inbounds double*, double** %0, i64 %75
%78 = load double*, double** %77
%79 = getelementptr inbounds double, double* %78, i64 %28
%80 = load double, double* %79
%81 = fdiv double %80, %69
store double %81, double* %79
%82 = tail call double @llvm.fmuladd.f64(double %81, double %81, double %76)
%83 = add nuw nsw i64 %75, 1
%84 = icmp eq i64 %83, %20
br i1 %84, label %85, label %74
85: ; preds = %74
%86 = getelementptr inbounds double*, double** %0, i64 %28
%87 = load double*, double** %86
%88 = getelementptr inbounds double, double* %87, i64 %28
%89 = load double, double* %88
%90 = tail call double @sqrt(double %82)
%91 = tail call double @llvm.copysign.f64(double %90, double %89)
%92 = fneg double %91
%93 = fneg double %82
%94 = tail call double @llvm.fmuladd.f64(double %89, double %92, double %93)
%95 = fadd double %89, %91
%96 = load double*, double** %86
%97 = getelementptr inbounds double, double* %96, i64 %28
store double %95, double* %97
%98 = icmp ult i64 %28, %17
%99 = icmp ult i64 %55, %18
%100 = select i1 %98, i1 %99, i1 false
br i1 %100, label %101, label %131
101: ; preds = %85, %128
%102 = phi i64 [ %129, %128 ], [ %27, %85 ]
br label %103
103: ; preds = %101, %103
%104 = phi i64 [ %28, %101 ], [ %113, %103 ]
%105 = phi double [ 0.000000e+00, %101 ], [ %112, %103 ]
%106 = getelementptr inbounds double*, double** %0, i64 %104
%107 = load double*, double** %106
%108 = getelementptr inbounds double, double* %107, i64 %28
%109 = load double, double* %108
%110 = getelementptr inbounds double, double* %107, i64 %102
%111 = load double, double* %110
%112 = tail call double @llvm.fmuladd.f64(double %109, double %111, double %105)
%113 = add nuw nsw i64 %104, 1
%114 = icmp eq i64 %113, %20
br i1 %114, label %115, label %103
115: ; preds = %103
%116 = fdiv double %112, %94
br label %117
117: ; preds = %115, %117
%118 = phi i64 [ %28, %115 ], [ %126, %117 ]
%119 = getelementptr inbounds double*, double** %0, i64 %118
%120 = load double*, double** %119
%121 = getelementptr inbounds double, double* %120, i64 %28
%122 = load double, double* %121
%123 = getelementptr inbounds double, double* %120, i64 %102
%124 = load double, double* %123
%125 = tail call double @llvm.fmuladd.f64(double %116, double %122, double %124)
store double %125, double* %123
%126 = add nuw nsw i64 %118, 1
%127 = icmp eq i64 %126, %20
br i1 %127, label %128, label %117
128: ; preds = %117
%129 = add nuw nsw i64 %102, 1
%130 = icmp eq i64 %129, %19
br i1 %130, label %131, label %101
131: ; preds = %128, %85
br label %132
132: ; preds = %131, %132
%133 = phi i64 [ %139, %132 ], [ %28, %131 ]
%134 = getelementptr inbounds double*, double** %0, i64 %133
%135 = load double*, double** %134
%136 = getelementptr inbounds double, double* %135, i64 %28
%137 = load double, double* %136
%138 = fmul double %69, %137
store double %138, double* %136
%139 = add nuw nsw i64 %133, 1
%140 = icmp eq i64 %139, %20
br i1 %140, label %141, label %132
141: ; preds = %132, %72
%142 = phi double [ 0.000000e+00, %72 ], [ %92, %132 ]
%143 = fmul double %69, %142
%144 = getelementptr inbounds double, double* %3, i64 %28
store double %143, double* %144
%145 = icmp ult i64 %28, %17
br i1 %145, label %146, label %509
146: ; preds = %141
%147 = icmp ult i64 %55, %18
br i1 %147, label %148, label %509
148: ; preds = %146
%149 = getelementptr inbounds double*, double** %0, i64 %28
%150 = load double*, double** %149
br label %151
151: ; preds = %148, %151
%152 = phi i64 [ %27, %148 ], [ %158, %151 ]
%153 = phi double [ 0.000000e+00, %148 ], [ %157, %151 ]
%154 = getelementptr inbounds double, double* %150, i64 %152
%155 = load double, double* %154
%156 = tail call double @llvm.fabs.f64(double %155)
%157 = fadd double %153, %156
%158 = add nuw nsw i64 %152, 1
%159 = icmp eq i64 %158, %19
br i1 %159, label %160, label %151
160: ; preds = %151
%161 = fcmp une double %157, 0.000000e+00
br i1 %161, label %162, label %509
162: ; preds = %160
%163 = getelementptr inbounds double*, double** %0, i64 %28
%164 = load double*, double** %163
br i1 %147, label %165, label %174
165: ; preds = %162, %165
%166 = phi i64 [ %172, %165 ], [ %27, %162 ]
%167 = phi double [ %171, %165 ], [ 0.000000e+00, %162 ]
%168 = getelementptr inbounds double, double* %164, i64 %166
%169 = load double, double* %168
%170 = fdiv double %169, %157
store double %170, double* %168
%171 = tail call double @llvm.fmuladd.f64(double %170, double %170, double %167)
%172 = add nuw nsw i64 %166, 1
%173 = icmp eq i64 %172, %19
br i1 %173, label %174, label %165
174: ; preds = %165, %162
%175 = phi double [ 0.000000e+00, %162 ], [ %171, %165 ]
%176 = getelementptr inbounds double*, double** %0, i64 %28
%177 = getelementptr inbounds double, double* %164, i64 %55
%178 = load double, double* %177
%179 = tail call double @sqrt(double %175)
%180 = tail call double @llvm.copysign.f64(double %179, double %178)
%181 = fneg double %180
%182 = fneg double %175
%183 = tail call double @llvm.fmuladd.f64(double %178, double %181, double %182)
%184 = fadd double %178, %180
%185 = load double*, double** %176
%186 = getelementptr inbounds double, double* %185, i64 %55
store double %184, double* %186
br i1 %147, label %187, label %252
187: ; preds = %174
%188 = icmp ult i64 %48, 2
br i1 %188, label %238, label %189
189: ; preds = %187
%190 = getelementptr double, double* %185, i64 %27
%191 = getelementptr double, double* %185, i64 %19
%192 = icmp ult double* %49, %191
%193 = icmp ult double* %190, %22
%194 = and i1 %192, %193
br i1 %194, label %238, label %195
195: ; preds = %189
%196 = and i64 %48, -2
%197 = add i64 %27, %196
%198 = insertelement <2 x double> poison, double %183, i64 0
%199 = shufflevector <2 x double> %198, <2 x double> poison, <2 x i32> zeroinitializer
%200 = and i64 %46, 1
%201 = icmp ult i64 %44, 2
br i1 %201, label %225, label %202
202: ; preds = %195
%203 = and i64 %46, -2
br label %204
204: ; preds = %204, %202
%205 = phi i64 [ 0, %202 ], [ %222, %204 ]
%206 = phi i64 [ 0, %202 ], [ %223, %204 ]
%207 = add i64 %27, %205
%208 = getelementptr inbounds double, double* %185, i64 %207
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = fdiv <2 x double> %210, %199
%212 = getelementptr inbounds double, double* %13, i64 %207
%213 = bitcast double* %212 to <2 x double>*
store <2 x double> %211, <2 x double>* %213
%214 = or i64 %205, 2
%215 = add i64 %27, %214
%216 = getelementptr inbounds double, double* %185, i64 %215
%217 = bitcast double* %216 to <2 x double>*
%218 = load <2 x double>, <2 x double>* %217
%219 = fdiv <2 x double> %218, %199
%220 = getelementptr inbounds double, double* %13, i64 %215
%221 = bitcast double* %220 to <2 x double>*
store <2 x double> %219, <2 x double>* %221
%222 = add nuw i64 %205, 4
%223 = add nuw i64 %206, 2
%224 = icmp eq i64 %223, %203
br i1 %224, label %225, label %204
225: ; preds = %204, %195
%226 = phi i64 [ 0, %195 ], [ %222, %204 ]
%227 = icmp eq i64 %200, 0
br i1 %227, label %236, label %228
228: ; preds = %225
%229 = add i64 %27, %226
%230 = getelementptr inbounds double, double* %185, i64 %229
%231 = bitcast double* %230 to <2 x double>*
%232 = load <2 x double>, <2 x double>* %231
%233 = fdiv <2 x double> %232, %199
%234 = getelementptr inbounds double, double* %13, i64 %229
%235 = bitcast double* %234 to <2 x double>*
store <2 x double> %233, <2 x double>* %235
br label %236
236: ; preds = %225, %228
%237 = icmp eq i64 %48, %196
br i1 %237, label %252, label %238
238: ; preds = %189, %187, %236
%239 = phi i64 [ %27, %189 ], [ %27, %187 ], [ %197, %236 ]
%240 = sub i64 %19, %239
%241 = and i64 %240, 1
%242 = icmp eq i64 %241, 0
br i1 %242, label %249, label %243
243: ; preds = %238
%244 = getelementptr inbounds double, double* %185, i64 %239
%245 = load double, double* %244
%246 = fdiv double %245, %183
%247 = getelementptr inbounds double, double* %13, i64 %239
store double %246, double* %247
%248 = add nuw nsw i64 %239, 1
br label %249
249: ; preds = %243, %238
%250 = phi i64 [ %239, %238 ], [ %248, %243 ]
%251 = icmp eq i64 %23, %239
br i1 %251, label %252, label %266
252: ; preds = %249, %266, %236, %174
%253 = icmp slt i64 %55, %16
br i1 %253, label %254, label %279
254: ; preds = %252
%255 = and i64 %40, 3
%256 = icmp eq i64 %255, 0
%257 = icmp ult i64 %41, 3
%258 = icmp ult i64 %51, 4
%259 = and i64 %51, -4
%260 = add i64 %27, %259
%261 = and i64 %39, 1
%262 = icmp ult i64 %37, 4
%263 = and i64 %39, 9223372036854775806
%264 = icmp eq i64 %261, 0
%265 = icmp eq i64 %51, %259
br label %341
266: ; preds = %249, %266
%267 = phi i64 [ %277, %266 ], [ %250, %249 ]
%268 = getelementptr inbounds double, double* %185, i64 %267
%269 = load double, double* %268
%270 = fdiv double %269, %183
%271 = getelementptr inbounds double, double* %13, i64 %267
store double %270, double* %271
%272 = add nuw nsw i64 %267, 1
%273 = getelementptr inbounds double, double* %185, i64 %272
%274 = load double, double* %273
%275 = fdiv double %274, %183
%276 = getelementptr inbounds double, double* %13, i64 %272
store double %275, double* %276
%277 = add nuw nsw i64 %267, 2
%278 = icmp eq i64 %277, %19
br i1 %278, label %252, label %266
279: ; preds = %499, %252
br i1 %147, label %280, label %509
280: ; preds = %279
%281 = icmp ult i64 %54, 4
br i1 %281, label %339, label %282
282: ; preds = %280
%283 = and i64 %54, -4
%284 = add i64 %27, %283
%285 = insertelement <2 x double> poison, double %157, i64 0
%286 = shufflevector <2 x double> %285, <2 x double> poison, <2 x i32> zeroinitializer
%287 = insertelement <2 x double> poison, double %157, i64 0
%288 = shufflevector <2 x double> %287, <2 x double> poison, <2 x i32> zeroinitializer
%289 = and i64 %35, 1
%290 = icmp ult i64 %33, 4
br i1 %290, label %322, label %291
291: ; preds = %282
%292 = and i64 %35, 9223372036854775806
br label %293
293: ; preds = %293, %291
%294 = phi i64 [ 0, %291 ], [ %319, %293 ]
%295 = phi i64 [ 0, %291 ], [ %320, %293 ]
%296 = add i64 %27, %294
%297 = getelementptr inbounds double, double* %185, i64 %296
%298 = bitcast double* %297 to <2 x double>*
%299 = load <2 x double>, <2 x double>* %298
%300 = getelementptr inbounds double, double* %297, i64 2
%301 = bitcast double* %300 to <2 x double>*
%302 = load <2 x double>, <2 x double>* %301
%303 = fmul <2 x double> %286, %299
%304 = fmul <2 x double> %288, %302
%305 = bitcast double* %297 to <2 x double>*
store <2 x double> %303, <2 x double>* %305
%306 = bitcast double* %300 to <2 x double>*
store <2 x double> %304, <2 x double>* %306
%307 = or i64 %294, 4
%308 = add i64 %27, %307
%309 = getelementptr inbounds double, double* %185, i64 %308
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = getelementptr inbounds double, double* %309, i64 2
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = fmul <2 x double> %286, %311
%316 = fmul <2 x double> %288, %314
%317 = bitcast double* %309 to <2 x double>*
store <2 x double> %315, <2 x double>* %317
%318 = bitcast double* %312 to <2 x double>*
store <2 x double> %316, <2 x double>* %318
%319 = add nuw i64 %294, 8
%320 = add i64 %295, 2
%321 = icmp eq i64 %320, %292
br i1 %321, label %322, label %293
322: ; preds = %293, %282
%323 = phi i64 [ 0, %282 ], [ %319, %293 ]
%324 = icmp eq i64 %289, 0
br i1 %324, label %337, label %325
325: ; preds = %322
%326 = add i64 %27, %323
%327 = getelementptr inbounds double, double* %185, i64 %326
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = getelementptr inbounds double, double* %327, i64 2
%331 = bitcast double* %330 to <2 x double>*
%332 = load <2 x double>, <2 x double>* %331
%333 = fmul <2 x double> %286, %329
%334 = fmul <2 x double> %288, %332
%335 = bitcast double* %327 to <2 x double>*
store <2 x double> %333, <2 x double>* %335
%336 = bitcast double* %330 to <2 x double>*
store <2 x double> %334, <2 x double>* %336
br label %337
337: ; preds = %322, %325
%338 = icmp eq i64 %54, %283
br i1 %338, label %509, label %339
339: ; preds = %280, %337
%340 = phi i64 [ %27, %280 ], [ %284, %337 ]
br label %502
341: ; preds = %254, %499
%342 = phi i64 [ %500, %499 ], [ %27, %254 ]
br i1 %147, label %343, label %499
343: ; preds = %341
%344 = getelementptr inbounds double*, double** %0, i64 %342
%345 = load double*, double** %344
br i1 %256, label %358, label %346
346: ; preds = %343, %346
%347 = phi i64 [ %355, %346 ], [ %27, %343 ]
%348 = phi double [ %354, %346 ], [ 0.000000e+00, %343 ]
%349 = phi i64 [ %356, %346 ], [ 0, %343 ]
%350 = getelementptr inbounds double, double* %345, i64 %347
%351 = load double, double* %350
%352 = getelementptr inbounds double, double* %185, i64 %347
%353 = load double, double* %352
%354 = tail call double @llvm.fmuladd.f64(double %351, double %353, double %348)
%355 = add nuw nsw i64 %347, 1
%356 = add i64 %349, 1
%357 = icmp eq i64 %356, %255
br i1 %357, label %358, label %346
358: ; preds = %346, %343
%359 = phi double [ undef, %343 ], [ %354, %346 ]
%360 = phi i64 [ %27, %343 ], [ %355, %346 ]
%361 = phi double [ 0.000000e+00, %343 ], [ %354, %346 ]
br i1 %257, label %362, label %456
362: ; preds = %456, %358
%363 = phi double [ %359, %358 ], [ %481, %456 ]
br i1 %147, label %364, label %499
364: ; preds = %362
%365 = getelementptr inbounds double*, double** %0, i64 %342
%366 = load double*, double** %365
br i1 %258, label %440, label %367
367: ; preds = %364
%368 = getelementptr double, double* %366, i64 %27
%369 = getelementptr double, double* %366, i64 %19
%370 = icmp ult double* %368, %21
%371 = icmp ult double* %52, %369
%372 = and i1 %370, %371
br i1 %372, label %440, label %373
373: ; preds = %367
%374 = insertelement <2 x double> poison, double %363, i64 0
%375 = shufflevector <2 x double> %374, <2 x double> poison, <2 x i32> zeroinitializer
%376 = insertelement <2 x double> poison, double %363, i64 0
%377 = shufflevector <2 x double> %376, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %262, label %419, label %378
378: ; preds = %373, %378
%379 = phi i64 [ %416, %378 ], [ 0, %373 ]
%380 = phi i64 [ %417, %378 ], [ 0, %373 ]
%381 = add i64 %27, %379
%382 = getelementptr inbounds double, double* %13, i64 %381
%383 = bitcast double* %382 to <2 x double>*
%384 = load <2 x double>, <2 x double>* %383
%385 = getelementptr inbounds double, double* %382, i64 2
%386 = bitcast double* %385 to <2 x double>*
%387 = load <2 x double>, <2 x double>* %386
%388 = getelementptr inbounds double, double* %366, i64 %381
%389 = bitcast double* %388 to <2 x double>*
%390 = load <2 x double>, <2 x double>* %389
%391 = getelementptr inbounds double, double* %388, i64 2
%392 = bitcast double* %391 to <2 x double>*
%393 = load <2 x double>, <2 x double>* %392
%394 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %375, <2 x double> %384, <2 x double> %390)
%395 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %377, <2 x double> %387, <2 x double> %393)
%396 = bitcast double* %388 to <2 x double>*
store <2 x double> %394, <2 x double>* %396
%397 = bitcast double* %391 to <2 x double>*
store <2 x double> %395, <2 x double>* %397
%398 = or i64 %379, 4
%399 = add i64 %27, %398
%400 = getelementptr inbounds double, double* %13, i64 %399
%401 = bitcast double* %400 to <2 x double>*
%402 = load <2 x double>, <2 x double>* %401
%403 = getelementptr inbounds double, double* %400, i64 2
%404 = bitcast double* %403 to <2 x double>*
%405 = load <2 x double>, <2 x double>* %404
%406 = getelementptr inbounds double, double* %366, i64 %399
%407 = bitcast double* %406 to <2 x double>*
%408 = load <2 x double>, <2 x double>* %407
%409 = getelementptr inbounds double, double* %406, i64 2
%410 = bitcast double* %409 to <2 x double>*
%411 = load <2 x double>, <2 x double>* %410
%412 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %375, <2 x double> %402, <2 x double> %408)
%413 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %377, <2 x double> %405, <2 x double> %411)
%414 = bitcast double* %406 to <2 x double>*
store <2 x double> %412, <2 x double>* %414
%415 = bitcast double* %409 to <2 x double>*
store <2 x double> %413, <2 x double>* %415
%416 = add nuw i64 %379, 8
%417 = add i64 %380, 2
%418 = icmp eq i64 %417, %263
br i1 %418, label %419, label %378
419: ; preds = %378, %373
%420 = phi i64 [ 0, %373 ], [ %416, %378 ]
br i1 %264, label %439, label %421
421: ; preds = %419
%422 = add i64 %27, %420
%423 = getelementptr inbounds double, double* %13, i64 %422
%424 = bitcast double* %423 to <2 x double>*
%425 = load <2 x double>, <2 x double>* %424
%426 = getelementptr inbounds double, double* %423, i64 2
%427 = bitcast double* %426 to <2 x double>*
%428 = load <2 x double>, <2 x double>* %427
%429 = getelementptr inbounds double, double* %366, i64 %422
%430 = bitcast double* %429 to <2 x double>*
%431 = load <2 x double>, <2 x double>* %430
%432 = getelementptr inbounds double, double* %429, i64 2
%433 = bitcast double* %432 to <2 x double>*
%434 = load <2 x double>, <2 x double>* %433
%435 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %375, <2 x double> %425, <2 x double> %431)
%436 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %377, <2 x double> %428, <2 x double> %434)
%437 = bitcast double* %429 to <2 x double>*
store <2 x double> %435, <2 x double>* %437
%438 = bitcast double* %432 to <2 x double>*
store <2 x double> %436, <2 x double>* %438
br label %439
439: ; preds = %419, %421
br i1 %265, label %499, label %440
440: ; preds = %367, %364, %439
%441 = phi i64 [ %27, %367 ], [ %27, %364 ], [ %260, %439 ]
%442 = sub i64 %19, %441
%443 = xor i64 %441, -1
%444 = and i64 %442, 1
%445 = icmp eq i64 %444, 0
br i1 %445, label %453, label %446
446: ; preds = %440
%447 = getelementptr inbounds double, double* %13, i64 %441
%448 = load double, double* %447
%449 = getelementptr inbounds double, double* %366, i64 %441
%450 = load double, double* %449
%451 = tail call double @llvm.fmuladd.f64(double %363, double %448, double %450)
store double %451, double* %449
%452 = add nuw nsw i64 %441, 1
br label %453
453: ; preds = %446, %440
%454 = phi i64 [ %441, %440 ], [ %452, %446 ]
%455 = icmp eq i64 %443, %25
br i1 %455, label %499, label %484
456: ; preds = %358, %456
%457 = phi i64 [ %482, %456 ], [ %360, %358 ]
%458 = phi double [ %481, %456 ], [ %361, %358 ]
%459 = getelementptr inbounds double, double* %345, i64 %457
%460 = load double, double* %459
%461 = getelementptr inbounds double, double* %185, i64 %457
%462 = load double, double* %461
%463 = tail call double @llvm.fmuladd.f64(double %460, double %462, double %458)
%464 = add nuw nsw i64 %457, 1
%465 = getelementptr inbounds double, double* %345, i64 %464
%466 = load double, double* %465
%467 = getelementptr inbounds double, double* %185, i64 %464
%468 = load double, double* %467
%469 = tail call double @llvm.fmuladd.f64(double %466, double %468, double %463)
%470 = add nuw nsw i64 %457, 2
%471 = getelementptr inbounds double, double* %345, i64 %470
%472 = load double, double* %471
%473 = getelementptr inbounds double, double* %185, i64 %470
%474 = load double, double* %473
%475 = tail call double @llvm.fmuladd.f64(double %472, double %474, double %469)
%476 = add nuw nsw i64 %457, 3
%477 = getelementptr inbounds double, double* %345, i64 %476
%478 = load double, double* %477
%479 = getelementptr inbounds double, double* %185, i64 %476
%480 = load double, double* %479
%481 = tail call double @llvm.fmuladd.f64(double %478, double %480, double %475)
%482 = add nuw nsw i64 %457, 4
%483 = icmp eq i64 %482, %19
br i1 %483, label %362, label %456
484: ; preds = %453, %484
%485 = phi i64 [ %497, %484 ], [ %454, %453 ]
%486 = getelementptr inbounds double, double* %13, i64 %485
%487 = load double, double* %486
%488 = getelementptr inbounds double, double* %366, i64 %485
%489 = load double, double* %488
%490 = tail call double @llvm.fmuladd.f64(double %363, double %487, double %489)
store double %490, double* %488
%491 = add nuw nsw i64 %485, 1
%492 = getelementptr inbounds double, double* %13, i64 %491
%493 = load double, double* %492
%494 = getelementptr inbounds double, double* %366, i64 %491
%495 = load double, double* %494
%496 = tail call double @llvm.fmuladd.f64(double %363, double %493, double %495)
store double %496, double* %494
%497 = add nuw nsw i64 %485, 2
%498 = icmp eq i64 %497, %19
br i1 %498, label %499, label %484
499: ; preds = %453, %484, %439, %341, %362
%500 = add nuw nsw i64 %342, 1
%501 = icmp eq i64 %500, %20
br i1 %501, label %279, label %341
502: ; preds = %339, %502
%503 = phi i64 [ %507, %502 ], [ %340, %339 ]
%504 = getelementptr inbounds double, double* %185, i64 %503
%505 = load double, double* %504
%506 = fmul double %157, %505
store double %506, double* %504
%507 = add nuw nsw i64 %503, 1
%508 = icmp eq i64 %507, %19
br i1 %508, label %509, label %502
509: ; preds = %502, %337, %146, %279, %59, %160, %141
%510 = phi double* [ %144, %160 ], [ %144, %141 ], [ %60, %59 ], [ %144, %279 ], [ %144, %146 ], [ %144, %337 ], [ %144, %502 ]
%511 = phi double [ 0.000000e+00, %160 ], [ 0.000000e+00, %141 ], [ 0.000000e+00, %59 ], [ %181, %279 ], [ 0.000000e+00, %146 ], [ %181, %337 ], [ %181, %502 ]
%512 = phi double [ %157, %160 ], [ 0.000000e+00, %141 ], [ 0.000000e+00, %59 ], [ %157, %279 ], [ 0.000000e+00, %146 ], [ %157, %337 ], [ %157, %502 ]
%513 = load double, double* %510
%514 = tail call double @llvm.fabs.f64(double %513)
%515 = load double, double* %57
%516 = tail call double @llvm.fabs.f64(double %515)
%517 = fadd double %514, %516
%518 = fcmp ogt double %31, %517
%519 = select i1 %518, double %31, double %517
%520 = add nuw nsw i64 %27, 1
%521 = icmp eq i64 %55, %19
br i1 %521, label %522, label %26
522: ; preds = %509
br i1 %7, label %523, label %719
523: ; preds = %522
%524 = zext i32 %1 to i64
%525 = zext i32 %14 to i64
%526 = sub nsw i64 0, %19
br label %527
527: ; preds = %523, %711
%528 = phi i64 [ %524, %523 ], [ %542, %711 ]
%529 = phi i32 [ %1, %523 ], [ %718, %711 ]
%530 = phi double [ %511, %523 ], [ %716, %711 ]
%531 = sext i32 %529 to i64
%532 = sub nsw i64 %19, %531
%533 = xor i64 %531, -1
%534 = add nsw i64 %533, %19
%535 = sext i32 %529 to i64
%536 = sub nsw i64 %19, %535
%537 = xor i64 %535, -1
%538 = sext i32 %529 to i64
%539 = sub nsw i64 %19, %538
%540 = xor i64 %538, -1
%541 = add nsw i64 %540, %19
%542 = add nsw i64 %528, -1
%543 = icmp sgt i64 %528, %525
br i1 %543, label %711, label %544
544: ; preds = %527
%545 = fcmp une double %530, 0.000000e+00
br i1 %545, label %546, label %667
546: ; preds = %544
%547 = icmp slt i32 %529, %1
br i1 %547, label %548, label %667
548: ; preds = %546
%549 = getelementptr inbounds double*, double** %0, i64 %542
%550 = load double*, double** %549
%551 = sext i32 %529 to i64
%552 = getelementptr inbounds double, double* %550, i64 %551
br label %566
553: ; preds = %566
br i1 %547, label %554, label %667
554: ; preds = %553
%555 = getelementptr inbounds double*, double** %0, i64 %542
%556 = sext i32 %529 to i64
%557 = load double*, double** %555
%558 = and i64 %539, 3
%559 = icmp eq i64 %558, 0
%560 = icmp ult i64 %541, 3
%561 = and i64 %536, 1
%562 = icmp eq i64 %561, 0
%563 = getelementptr inbounds double*, double** %4, i64 %556
%564 = add nsw i64 %556, 1
%565 = icmp eq i64 %537, %526
br label %578
566: ; preds = %548, %566
%567 = phi i64 [ %551, %548 ], [ %576, %566 ]
%568 = getelementptr inbounds double, double* %550, i64 %567
%569 = load double, double* %568
%570 = load double, double* %552
%571 = fdiv double %569, %570
%572 = fdiv double %571, %530
%573 = getelementptr inbounds double*, double** %4, i64 %567
%574 = load double*, double** %573
%575 = getelementptr inbounds double, double* %574, i64 %542
store double %572, double* %575
%576 = add nsw i64 %567, 1
%577 = icmp eq i64 %576, %524
br i1 %577, label %553, label %566
578: ; preds = %664, %554
%579 = phi i64 [ %556, %554 ], [ %665, %664 ]
br i1 %559, label %594, label %580
580: ; preds = %578, %580
%581 = phi i64 [ %591, %580 ], [ %556, %578 ]
%582 = phi double [ %590, %580 ], [ 0.000000e+00, %578 ]
%583 = phi i64 [ %592, %580 ], [ 0, %578 ]
%584 = getelementptr inbounds double, double* %557, i64 %581
%585 = load double, double* %584
%586 = getelementptr inbounds double*, double** %4, i64 %581
%587 = load double*, double** %586
%588 = getelementptr inbounds double, double* %587, i64 %579
%589 = load double, double* %588
%590 = tail call double @llvm.fmuladd.f64(double %585, double %589, double %582)
%591 = add nsw i64 %581, 1
%592 = add i64 %583, 1
%593 = icmp eq i64 %592, %558
br i1 %593, label %594, label %580
594: ; preds = %580, %578
%595 = phi double [ undef, %578 ], [ %590, %580 ]
%596 = phi i64 [ %556, %578 ], [ %591, %580 ]
%597 = phi double [ 0.000000e+00, %578 ], [ %590, %580 ]
br i1 %560, label %634, label %598
598: ; preds = %594, %598
%599 = phi i64 [ %632, %598 ], [ %596, %594 ]
%600 = phi double [ %631, %598 ], [ %597, %594 ]
%601 = getelementptr inbounds double, double* %557, i64 %599
%602 = load double, double* %601
%603 = getelementptr inbounds double*, double** %4, i64 %599
%604 = load double*, double** %603
%605 = getelementptr inbounds double, double* %604, i64 %579
%606 = load double, double* %605
%607 = tail call double @llvm.fmuladd.f64(double %602, double %606, double %600)
%608 = add nsw i64 %599, 1
%609 = getelementptr inbounds double, double* %557, i64 %608
%610 = load double, double* %609
%611 = getelementptr inbounds double*, double** %4, i64 %608
%612 = load double*, double** %611
%613 = getelementptr inbounds double, double* %612, i64 %579
%614 = load double, double* %613
%615 = tail call double @llvm.fmuladd.f64(double %610, double %614, double %607)
%616 = add nsw i64 %599, 2
%617 = getelementptr inbounds double, double* %557, i64 %616
%618 = load double, double* %617
%619 = getelementptr inbounds double*, double** %4, i64 %616
%620 = load double*, double** %619
%621 = getelementptr inbounds double, double* %620, i64 %579
%622 = load double, double* %621
%623 = tail call double @llvm.fmuladd.f64(double %618, double %622, double %615)
%624 = add nsw i64 %599, 3
%625 = getelementptr inbounds double, double* %557, i64 %624
%626 = load double, double* %625
%627 = getelementptr inbounds double*, double** %4, i64 %624
%628 = load double*, double** %627
%629 = getelementptr inbounds double, double* %628, i64 %579
%630 = load double, double* %629
%631 = tail call double @llvm.fmuladd.f64(double %626, double %630, double %623)
%632 = add nsw i64 %599, 4
%633 = icmp eq i64 %632, %524
br i1 %633, label %634, label %598
634: ; preds = %598, %594
%635 = phi double [ %595, %594 ], [ %631, %598 ]
br i1 %562, label %643, label %636
636: ; preds = %634
%637 = load double*, double** %563
%638 = getelementptr inbounds double, double* %637, i64 %542
%639 = load double, double* %638
%640 = getelementptr inbounds double, double* %637, i64 %579
%641 = load double, double* %640
%642 = tail call double @llvm.fmuladd.f64(double %635, double %639, double %641)
store double %642, double* %640
br label %643
643: ; preds = %636, %634
%644 = phi i64 [ %556, %634 ], [ %564, %636 ]
br i1 %565, label %664, label %645
645: ; preds = %643, %645
%646 = phi i64 [ %662, %645 ], [ %644, %643 ]
%647 = getelementptr inbounds double*, double** %4, i64 %646
%648 = load double*, double** %647
%649 = getelementptr inbounds double, double* %648, i64 %542
%650 = load double, double* %649
%651 = getelementptr inbounds double, double* %648, i64 %579
%652 = load double, double* %651
%653 = tail call double @llvm.fmuladd.f64(double %635, double %650, double %652)
store double %653, double* %651
%654 = add nsw i64 %646, 1
%655 = getelementptr inbounds double*, double** %4, i64 %654
%656 = load double*, double** %655
%657 = getelementptr inbounds double, double* %656, i64 %542
%658 = load double, double* %657
%659 = getelementptr inbounds double, double* %656, i64 %579
%660 = load double, double* %659
%661 = tail call double @llvm.fmuladd.f64(double %635, double %658, double %660)
store double %661, double* %659
%662 = add nsw i64 %646, 2
%663 = icmp eq i64 %662, %524
br i1 %663, label %664, label %645
664: ; preds = %645, %643
%665 = add nsw i64 %579, 1
%666 = icmp eq i64 %665, %524
br i1 %666, label %667, label %578
667: ; preds = %664, %546, %553, %544
%668 = icmp slt i32 %529, %1
br i1 %668, label %669, label %711
669: ; preds = %667
%670 = getelementptr inbounds double*, double** %4, i64 %542
%671 = load double*, double** %670
%672 = sext i32 %529 to i64
%673 = and i64 %532, 3
%674 = icmp eq i64 %673, 0
br i1 %674, label %685, label %675
675: ; preds = %669, %675
%676 = phi i64 [ %682, %675 ], [ %672, %669 ]
%677 = phi i64 [ %683, %675 ], [ 0, %669 ]
%678 = getelementptr inbounds double, double* %671, i64 %676
store double 0.000000e+00, double* %678
%679 = getelementptr inbounds double*, double** %4, i64 %676
%680 = load double*, double** %679
%681 = getelementptr inbounds double, double* %680, i64 %542
store double 0.000000e+00, double* %681
%682 = add nsw i64 %676, 1
%683 = add i64 %677, 1
%684 = icmp eq i64 %683, %673
br i1 %684, label %685, label %675
685: ; preds = %675, %669
%686 = phi i64 [ %672, %669 ], [ %682, %675 ]
%687 = icmp ult i64 %534, 3
br i1 %687, label %711, label %688
688: ; preds = %685, %688
%689 = phi i64 [ %709, %688 ], [ %686, %685 ]
%690 = getelementptr inbounds double, double* %671, i64 %689
store double 0.000000e+00, double* %690
%691 = getelementptr inbounds double*, double** %4, i64 %689
%692 = load double*, double** %691
%693 = getelementptr inbounds double, double* %692, i64 %542
store double 0.000000e+00, double* %693
%694 = add nsw i64 %689, 1
%695 = getelementptr inbounds double, double* %671, i64 %694
store double 0.000000e+00, double* %695
%696 = getelementptr inbounds double*, double** %4, i64 %694
%697 = load double*, double** %696
%698 = getelementptr inbounds double, double* %697, i64 %542
store double 0.000000e+00, double* %698
%699 = add nsw i64 %689, 2
%700 = getelementptr inbounds double, double* %671, i64 %699
store double 0.000000e+00, double* %700
%701 = getelementptr inbounds double*, double** %4, i64 %699
%702 = load double*, double** %701
%703 = getelementptr inbounds double, double* %702, i64 %542
store double 0.000000e+00, double* %703
%704 = add nsw i64 %689, 3
%705 = getelementptr inbounds double, double* %671, i64 %704
store double 0.000000e+00, double* %705
%706 = getelementptr inbounds double*, double** %4, i64 %704
%707 = load double*, double** %706
%708 = getelementptr inbounds double, double* %707, i64 %542
store double 0.000000e+00, double* %708
%709 = add nsw i64 %689, 4
%710 = icmp eq i64 %709, %524
br i1 %710, label %711, label %688
711: ; preds = %685, %688, %667, %527
%712 = getelementptr inbounds double*, double** %4, i64 %542
%713 = load double*, double** %712
%714 = getelementptr inbounds double, double* %713, i64 %542
store double 1.000000e+00, double* %714
%715 = getelementptr inbounds double, double* %13, i64 %542
%716 = load double, double* %715
%717 = icmp sgt i64 %528, 1
%718 = trunc i64 %542 to i32
br i1 %717, label %527, label %719
719: ; preds = %711, %5, %522
%720 = phi double [ %519, %522 ], [ 0.000000e+00, %5 ], [ %519, %711 ]
%721 = icmp slt i32 %2, %1
%722 = add nsw i32 %2, -1
%723 = select i1 %721, i32 %722, i32 %14
%724 = icmp sgt i32 %723, -1
br i1 %724, label %725, label %734
725: ; preds = %719
%726 = add nuw i32 %723, 1
%727 = sub i32 %14, %726
%728 = zext i32 %723 to i64
%729 = sext i32 %2 to i64
%730 = sext i32 %1 to i64
%731 = zext i32 %723 to i64
%732 = zext i32 %14 to i64
%733 = zext i32 %726 to i64
br label %751
734: ; preds = %892, %719
br i1 %7, label %735, label %1224
735: ; preds = %734
%736 = zext i32 %1 to i64
%737 = add nsw i64 %736, -1
%738 = zext i32 %2 to i64
%739 = and i64 %736, 1
%740 = icmp eq i64 %737, 0
%741 = and i64 %736, 4294967294
%742 = icmp eq i64 %739, 0
%743 = and i64 %738, 1
%744 = icmp eq i32 %2, 1
%745 = and i64 %738, 4294967294
%746 = icmp eq i64 %743, 0
%747 = and i64 %736, 3
%748 = icmp ult i64 %737, 3
%749 = and i64 %736, 4294967292
%750 = icmp eq i64 %747, 0
br label %903
751: ; preds = %725, %892
%752 = phi i64 [ %731, %725 ], [ %901, %892 ]
%753 = phi i64 [ 0, %725 ], [ %899, %892 ]
%754 = phi i64 [ %728, %725 ], [ %898, %892 ]
%755 = phi i32 [ %726, %725 ], [ %900, %892 ]
%756 = sext i32 %755 to i64
%757 = sub nsw i64 %729, %756
%758 = xor i64 %756, -1
%759 = add nsw i64 %758, %729
%760 = sext i32 %755 to i64
%761 = getelementptr inbounds double, double* %3, i64 %752
%762 = load double, double* %761
%763 = icmp ne i64 %752, %732
%764 = trunc i64 %752 to i32
%765 = add i32 %764, 1
%766 = icmp slt i32 %765, %1
%767 = select i1 %763, i1 %766, i1 false
br i1 %767, label %768, label %781
768: ; preds = %751
%769 = trunc i64 %753 to i32
%770 = add i32 %727, %769
%771 = zext i32 %770 to i64
%772 = shl nuw nsw i64 %771, 3
%773 = add nuw nsw i64 %772, 8
%774 = trunc i64 %753 to i32
%775 = sub i32 %726, %774
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds double*, double** %0, i64 %752
%778 = load double*, double** %777
%779 = getelementptr double, double* %778, i64 %776
%780 = bitcast double* %779 to i8*
br label %781
781: ; preds = %768, %751
%782 = fcmp une double %762, 0.000000e+00
br i1 %782, label %785, label %783
783: ; preds = %781
%784 = icmp slt i64 %752, %729
br i1 %784, label %884, label %892
785: ; preds = %781
br i1 %766, label %786, label %795
786: ; preds = %785
%787 = icmp slt i32 %765, %2
%788 = getelementptr inbounds double*, double** %0, i64 %752
%789 = load double*, double** %788
%790 = getelementptr inbounds double, double* %789, i64 %752
%791 = icmp slt i64 %752, %729
%792 = and i64 %757, 3
%793 = icmp eq i64 %792, 0
%794 = icmp ult i64 %759, 3
br label %797
795: ; preds = %871, %785
%796 = icmp slt i64 %752, %729
br i1 %796, label %874, label %892
797: ; preds = %786, %871
%798 = phi i64 [ %760, %786 ], [ %872, %871 ]
br i1 %787, label %799, label %854
799: ; preds = %797
br i1 %793, label %814, label %800
800: ; preds = %799, %800
%801 = phi i64 [ %811, %800 ], [ %760, %799 ]
%802 = phi double [ %810, %800 ], [ 0.000000e+00, %799 ]
%803 = phi i64 [ %812, %800 ], [ 0, %799 ]
%804 = getelementptr inbounds double*, double** %0, i64 %801
%805 = load double*, double** %804
%806 = getelementptr inbounds double, double* %805, i64 %752
%807 = load double, double* %806
%808 = getelementptr inbounds double, double* %805, i64 %798
%809 = load double, double* %808
%810 = tail call double @llvm.fmuladd.f64(double %807, double %809, double %802)
%811 = add nsw i64 %801, 1
%812 = add i64 %803, 1
%813 = icmp eq i64 %812, %792
br i1 %813, label %814, label %800
814: ; preds = %800, %799
%815 = phi i64 [ %760, %799 ], [ %811, %800 ]
%816 = phi double [ 0.000000e+00, %799 ], [ %810, %800 ]
%817 = phi double [ undef, %799 ], [ %810, %800 ]
br i1 %794, label %854, label %818
818: ; preds = %814, %818
%819 = phi i64 [ %852, %818 ], [ %815, %814 ]
%820 = phi double [ %851, %818 ], [ %816, %814 ]
%821 = getelementptr inbounds double*, double** %0, i64 %819
%822 = load double*, double** %821
%823 = getelementptr inbounds double, double* %822, i64 %752
%824 = load double, double* %823
%825 = getelementptr inbounds double, double* %822, i64 %798
%826 = load double, double* %825
%827 = tail call double @llvm.fmuladd.f64(double %824, double %826, double %820)
%828 = add nsw i64 %819, 1
%829 = getelementptr inbounds double*, double** %0, i64 %828
%830 = load double*, double** %829
%831 = getelementptr inbounds double, double* %830, i64 %752
%832 = load double, double* %831
%833 = getelementptr inbounds double, double* %830, i64 %798
%834 = load double, double* %833
%835 = tail call double @llvm.fmuladd.f64(double %832, double %834, double %827)
%836 = add nsw i64 %819, 2
%837 = getelementptr inbounds double*, double** %0, i64 %836
%838 = load double*, double** %837
%839 = getelementptr inbounds double, double* %838, i64 %752
%840 = load double, double* %839
%841 = getelementptr inbounds double, double* %838, i64 %798
%842 = load double, double* %841
%843 = tail call double @llvm.fmuladd.f64(double %840, double %842, double %835)
%844 = add nsw i64 %819, 3
%845 = getelementptr inbounds double*, double** %0, i64 %844
%846 = load double*, double** %845
%847 = getelementptr inbounds double, double* %846, i64 %752
%848 = load double, double* %847
%849 = getelementptr inbounds double, double* %846, i64 %798
%850 = load double, double* %849
%851 = tail call double @llvm.fmuladd.f64(double %848, double %850, double %843)
%852 = add nsw i64 %819, 4
%853 = icmp slt i64 %852, %729
br i1 %853, label %818, label %854
854: ; preds = %814, %818, %797
%855 = phi double [ 0.000000e+00, %797 ], [ %817, %814 ], [ %851, %818 ]
%856 = load double, double* %790
%857 = fdiv double %855, %856
%858 = fdiv double %857, %762
br i1 %791, label %859, label %871
859: ; preds = %854, %859
%860 = phi i64 [ %868, %859 ], [ %754, %854 ]
%861 = getelementptr inbounds double*, double** %0, i64 %860
%862 = load double*, double** %861
%863 = getelementptr inbounds double, double* %862, i64 %752
%864 = load double, double* %863
%865 = getelementptr inbounds double, double* %862, i64 %798
%866 = load double, double* %865
%867 = tail call double @llvm.fmuladd.f64(double %858, double %864, double %866)
store double %867, double* %865
%868 = add nsw i64 %860, 1
%869 = trunc i64 %868 to i32
%870 = icmp eq i32 %869, %2
br i1 %870, label %871, label %859
871: ; preds = %859, %854
%872 = add nsw i64 %798, 1
%873 = icmp slt i64 %872, %730
br i1 %873, label %797, label %795
874: ; preds = %795, %874
%875 = phi i64 [ %881, %874 ], [ %754, %795 ]
%876 = getelementptr inbounds double*, double** %0, i64 %875
%877 = load double*, double** %876
%878 = getelementptr inbounds double, double* %877, i64 %752
%879 = load double, double* %878
%880 = fdiv double %879, %762
store double %880, double* %878
%881 = add nsw i64 %875, 1
%882 = trunc i64 %881 to i32
%883 = icmp eq i32 %882, %2
br i1 %883, label %892, label %874
884: ; preds = %783, %884
%885 = phi i64 [ %889, %884 ], [ %754, %783 ]
%886 = getelementptr inbounds double*, double** %0, i64 %885
%887 = load double*, double** %886
%888 = getelementptr inbounds double, double* %887, i64 %752
store double 0.000000e+00, double* %888
%889 = add nsw i64 %885, 1
%890 = trunc i64 %889 to i32
%891 = icmp eq i32 %890, %2
br i1 %891, label %892, label %884
892: ; preds = %884, %874, %783, %795
%893 = getelementptr inbounds double*, double** %0, i64 %752
%894 = load double*, double** %893
%895 = getelementptr inbounds double, double* %894, i64 %752
%896 = load double, double* %895
%897 = fadd double %896, 1.000000e+00
store double %897, double* %895
%898 = add nsw i64 %754, -1
%899 = add nuw nsw i64 %753, 1
%900 = add i32 %755, -1
%901 = add nsw i64 %752, -1
%902 = icmp eq i64 %899, %733
br i1 %902, label %734, label %751
903: ; preds = %735, %1222
%904 = phi i64 [ %737, %735 ], [ %905, %1222 ]
%905 = add nsw i64 %904, -1
%906 = getelementptr inbounds double, double* %3, i64 %904
%907 = getelementptr inbounds double, double* %3, i64 %905
%908 = getelementptr inbounds double, double* %13, i64 %905
%909 = getelementptr inbounds double, double* %13, i64 %904
br label %910
910: ; preds = %1205, %903
%911 = phi i32 [ 0, %903 ], [ %912, %1205 ]
%912 = add nuw nsw i32 %911, 1
%913 = icmp ugt i32 %911, 29
br i1 %913, label %914, label %916
914: ; preds = %910
%915 = tail call i32 @csa_quit(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i32 30)
br label %916
916: ; preds = %910, %914
br label %917
917: ; preds = %916, %932
%918 = phi i64 [ %926, %932 ], [ %904, %916 ]
%919 = and i64 %918, 4294967295
%920 = getelementptr inbounds double, double* %13, i64 %919
%921 = load double, double* %920
%922 = tail call double @llvm.fabs.f64(double %921)
%923 = fadd double %720, %922
%924 = fcmp oeq double %923, %720
br i1 %924, label %981, label %925
925: ; preds = %917
%926 = add nsw i64 %918, -1
%927 = getelementptr inbounds double, double* %3, i64 %926
%928 = load double, double* %927
%929 = tail call double @llvm.fabs.f64(double %928)
%930 = fadd double %720, %929
%931 = fcmp oeq double %930, %720
br i1 %931, label %934, label %932
932: ; preds = %925
%933 = icmp sgt i64 %918, 0
br i1 %933, label %917, label %936
934: ; preds = %925
%935 = trunc i64 %918 to i32
br label %936
936: ; preds = %932, %934
%937 = phi i64 [ %926, %934 ], [ -1, %932 ]
%938 = phi i32 [ %935, %934 ], [ -1, %932 ]
%939 = sext i32 %938 to i64
%940 = icmp slt i64 %904, %939
br i1 %940, label %983, label %941
941: ; preds = %936
%942 = shl i64 %937, 32
%943 = ashr exact i64 %942, 32
br label %944
944: ; preds = %941, %978
%945 = phi i64 [ %939, %941 ], [ %979, %978 ]
%946 = phi double [ 1.000000e+00, %941 ], [ %962, %978 ]
%947 = phi double [ 0.000000e+00, %941 ], [ %960, %978 ]
%948 = getelementptr inbounds double, double* %13, i64 %945
%949 = load double, double* %948
%950 = fmul double %946, %949
%951 = fmul double %947, %949
store double %951, double* %948
%952 = tail call double @llvm.fabs.f64(double %950)
%953 = fadd double %720, %952
%954 = fcmp oeq double %953, %720
br i1 %954, label %983, label %955
955: ; preds = %944
%956 = getelementptr inbounds double, double* %3, i64 %945
%957 = load double, double* %956
%958 = tail call double @hypot(double %950, double %957)
store double %958, double* %956
%959 = fdiv double 1.000000e+00, %958
%960 = fmul double %957, %959
%961 = fneg double %950
%962 = fmul double %959, %961
br i1 %6, label %963, label %978
963: ; preds = %955, %963
%964 = phi i64 [ %976, %963 ], [ 0, %955 ]
%965 = getelementptr inbounds double*, double** %0, i64 %964
%966 = load double*, double** %965
%967 = getelementptr inbounds double, double* %966, i64 %943
%968 = load double, double* %967
%969 = getelementptr inbounds double, double* %966, i64 %945
%970 = load double, double* %969
%971 = fmul double %962, %970
%972 = tail call double @llvm.fmuladd.f64(double %968, double %960, double %971)
store double %972, double* %967
%973 = fneg double %968
%974 = fmul double %962, %973
%975 = tail call double @llvm.fmuladd.f64(double %970, double %960, double %974)
store double %975, double* %969
%976 = add nuw nsw i64 %964, 1
%977 = icmp eq i64 %976, %738
br i1 %977, label %978, label %963
978: ; preds = %963, %955
%979 = add nsw i64 %945, 1
%980 = icmp slt i64 %945, %904
br i1 %980, label %944, label %983
981: ; preds = %917
%982 = trunc i64 %918 to i32
br label %983
983: ; preds = %944, %978, %981, %936
%984 = phi i32 [ %938, %936 ], [ %982, %981 ], [ %938, %978 ], [ %938, %944 ]
%985 = load double, double* %906
%986 = zext i32 %984 to i64
%987 = icmp eq i64 %904, %986
br i1 %987, label %1172, label %988
988: ; preds = %983
%989 = sext i32 %984 to i64
%990 = getelementptr inbounds double, double* %3, i64 %989
%991 = load double, double* %990
%992 = load double, double* %907
%993 = load double, double* %908
%994 = load double, double* %909
%995 = fadd double %985, %993
%996 = fdiv double %995, %994
%997 = fsub double %993, %985
%998 = fdiv double %997, %992
%999 = fdiv double %992, %994
%1000 = tail call double @llvm.fmuladd.f64(double %996, double %998, double %999)
%1001 = fdiv double %994, %992
%1002 = fsub double %1000, %1001
%1003 = fmul double %1002, 5.000000e-01
%1004 = tail call double @hypot(double %1003, double 1.000000e+00)
%1005 = fneg double %985
%1006 = fdiv double %1005, %991
%1007 = tail call double @llvm.fmuladd.f64(double %1006, double %985, double %991)
%1008 = fdiv double %994, %991
%1009 = tail call double @llvm.copysign.f64(double %1004, double %1003)
%1010 = fadd double %1003, %1009
%1011 = fdiv double %992, %1010
%1012 = fsub double %1011, %994
%1013 = tail call double @llvm.fmuladd.f64(double %1008, double %1012, double %1007)
%1014 = icmp sgt i64 %904, %989
br i1 %1014, label %1034, label %1205
1015: ; preds = %1141, %1135
%1016 = phi i64 [ 0, %1135 ], [ %1169, %1141 ]
br i1 %746, label %1032, label %1017
1017: ; preds = %1015
%1018 = getelementptr inbounds double*, double** %0, i64 %1016
%1019 = load double*, double** %1018
%1020 = getelementptr inbounds double, double* %1019, i64 %1035
%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 = shufflevector <2 x double> %1127, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1026 = insertelement <2 x double> %1022, double %1024, i64 0
%1027 = fmul <2 x double> %1025, %1026
%1028 = shufflevector <2 x double> %1027, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1029 = shufflevector <2 x double> %1127, <2 x double> undef, <2 x i32> zeroinitializer
%1030 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1022, <2 x double> %1029, <2 x double> %1028)
%1031 = bitcast double* %1020 to <2 x double>*
store <2 x double> %1030, <2 x double>* %1031
br label %1032
1032: ; preds = %1017, %1015, %1126
%1033 = icmp slt i64 %1040, %904
br i1 %1033, label %1034, label %1205
1034: ; preds = %988, %1032
%1035 = phi i64 [ %1040, %1032 ], [ %989, %988 ]
%1036 = phi double [ %1134, %1032 ], [ %991, %988 ]
%1037 = phi double [ %1128, %1032 ], [ 1.000000e+00, %988 ]
%1038 = phi double [ %1131, %1032 ], [ %1013, %988 ]
%1039 = phi double [ %1130, %1032 ], [ 1.000000e+00, %988 ]
%1040 = add nsw i64 %1035, 1
%1041 = getelementptr inbounds double, double* %13, i64 %1040
%1042 = load double, double* %1041
%1043 = getelementptr inbounds double, double* %3, i64 %1040
%1044 = load double, double* %1043
%1045 = fmul double %1037, %1042
%1046 = fmul double %1039, %1042
%1047 = tail call double @hypot(double %1038, double %1045)
%1048 = getelementptr inbounds double, double* %13, i64 %1035
store double %1047, double* %1048
%1049 = insertelement <2 x double> poison, double %1038, i64 0
%1050 = insertelement <2 x double> %1049, double %1045, i64 1
%1051 = insertelement <2 x double> poison, double %1047, i64 0
%1052 = shufflevector <2 x double> %1051, <2 x double> poison, <2 x i32> zeroinitializer
%1053 = fdiv <2 x double> %1050, %1052
%1054 = extractelement <2 x double> %1053, i64 1
%1055 = fmul double %1046, %1054
%1056 = extractelement <2 x double> %1053, i64 0
%1057 = tail call double @llvm.fmuladd.f64(double %1036, double %1056, double %1055)
%1058 = fneg double %1036
%1059 = fmul double %1054, %1058
%1060 = tail call double @llvm.fmuladd.f64(double %1046, double %1056, double %1059)
%1061 = fmul double %1044, %1054
%1062 = fmul double %1044, %1056
br i1 %740, label %1099, label %1063
1063: ; preds = %1034
%1064 = shufflevector <2 x double> %1053, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1065 = shufflevector <2 x double> %1053, <2 x double> undef, <2 x i32> zeroinitializer
%1066 = shufflevector <2 x double> %1053, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1067 = shufflevector <2 x double> %1053, <2 x double> undef, <2 x i32> zeroinitializer
br label %1068
1068: ; preds = %1068, %1063
%1069 = phi i64 [ 0, %1063 ], [ %1096, %1068 ]
%1070 = phi i64 [ 0, %1063 ], [ %1097, %1068 ]
%1071 = getelementptr inbounds double*, double** %4, i64 %1069
%1072 = load double*, double** %1071
%1073 = getelementptr inbounds double, double* %1072, i64 %1035
%1074 = bitcast double* %1073 to <2 x double>*
%1075 = load <2 x double>, <2 x double>* %1074
%1076 = extractelement <2 x double> %1075, i64 0
%1077 = fneg double %1076
%1078 = insertelement <2 x double> %1075, double %1077, i64 0
%1079 = fmul <2 x double> %1064, %1078
%1080 = shufflevector <2 x double> %1079, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1081 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1075, <2 x double> %1065, <2 x double> %1080)
%1082 = bitcast double* %1073 to <2 x double>*
store <2 x double> %1081, <2 x double>* %1082
%1083 = or i64 %1069, 1
%1084 = getelementptr inbounds double*, double** %4, i64 %1083
%1085 = load double*, double** %1084
%1086 = getelementptr inbounds double, double* %1085, i64 %1035
%1087 = bitcast double* %1086 to <2 x double>*
%1088 = load <2 x double>, <2 x double>* %1087
%1089 = extractelement <2 x double> %1088, i64 0
%1090 = fneg double %1089
%1091 = insertelement <2 x double> %1088, double %1090, i64 0
%1092 = fmul <2 x double> %1066, %1091
%1093 = shufflevector <2 x double> %1092, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1094 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1088, <2 x double> %1067, <2 x double> %1093)
%1095 = bitcast double* %1086 to <2 x double>*
store <2 x double> %1094, <2 x double>* %1095
%1096 = add nuw nsw i64 %1069, 2
%1097 = add i64 %1070, 2
%1098 = icmp eq i64 %1097, %741
br i1 %1098, label %1099, label %1068
1099: ; preds = %1068, %1034
%1100 = phi i64 [ 0, %1034 ], [ %1096, %1068 ]
br i1 %742, label %1116, label %1101
1101: ; preds = %1099
%1102 = getelementptr inbounds double*, double** %4, i64 %1100
%1103 = load double*, double** %1102
%1104 = getelementptr inbounds double, double* %1103, i64 %1035
%1105 = bitcast double* %1104 to <2 x double>*
%1106 = load <2 x double>, <2 x double>* %1105
%1107 = extractelement <2 x double> %1106, i64 0
%1108 = fneg double %1107
%1109 = shufflevector <2 x double> %1053, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1110 = insertelement <2 x double> %1106, double %1108, i64 0
%1111 = fmul <2 x double> %1109, %1110
%1112 = shufflevector <2 x double> %1111, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1113 = shufflevector <2 x double> %1053, <2 x double> undef, <2 x i32> zeroinitializer
%1114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1106, <2 x double> %1113, <2 x double> %1112)
%1115 = bitcast double* %1104 to <2 x double>*
store <2 x double> %1114, <2 x double>* %1115
br label %1116
1116: ; preds = %1099, %1101
%1117 = tail call double @hypot(double %1057, double %1061)
%1118 = getelementptr inbounds double, double* %3, i64 %1035
store double %1117, double* %1118
%1119 = fcmp une double %1117, 0.000000e+00
br i1 %1119, label %1120, label %1126
1120: ; preds = %1116
%1121 = insertelement <2 x double> poison, double %1057, i64 0
%1122 = insertelement <2 x double> %1121, double %1061, i64 1
%1123 = insertelement <2 x double> poison, double %1117, i64 0
%1124 = shufflevector <2 x double> %1123, <2 x double> poison, <2 x i32> zeroinitializer
%1125 = fdiv <2 x double> %1122, %1124
br label %1126
1126: ; preds = %1120, %1116
%1127 = phi <2 x double> [ %1125, %1120 ], [ %1053, %1116 ]
%1128 = extractelement <2 x double> %1127, i64 1
%1129 = fmul double %1062, %1128
%1130 = extractelement <2 x double> %1127, i64 0
%1131 = tail call double @llvm.fmuladd.f64(double %1130, double %1060, double %1129)
%1132 = fneg double %1128
%1133 = fmul double %1060, %1132
%1134 = tail call double @llvm.fmuladd.f64(double %1130, double %1062, double %1133)
br i1 %6, label %1135, label %1032
1135: ; preds = %1126
br i1 %744, label %1015, label %1136
1136: ; preds = %1135
%1137 = shufflevector <2 x double> %1127, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1138 = shufflevector <2 x double> %1127, <2 x double> undef, <2 x i32> zeroinitializer
%1139 = shufflevector <2 x double> %1127, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1140 = shufflevector <2 x double> %1127, <2 x double> undef, <2 x i32> zeroinitializer
br label %1141
1141: ; preds = %1141, %1136
%1142 = phi i64 [ 0, %1136 ], [ %1169, %1141 ]
%1143 = phi i64 [ 0, %1136 ], [ %1170, %1141 ]
%1144 = getelementptr inbounds double*, double** %0, i64 %1142
%1145 = load double*, double** %1144
%1146 = getelementptr inbounds double, double* %1145, i64 %1035
%1147 = bitcast double* %1146 to <2 x double>*
%1148 = load <2 x double>, <2 x double>* %1147
%1149 = extractelement <2 x double> %1148, i64 0
%1150 = fneg double %1149
%1151 = insertelement <2 x double> %1148, double %1150, i64 0
%1152 = fmul <2 x double> %1137, %1151
%1153 = shufflevector <2 x double> %1152, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1154 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1148, <2 x double> %1138, <2 x double> %1153)
%1155 = bitcast double* %1146 to <2 x double>*
store <2 x double> %1154, <2 x double>* %1155
%1156 = or i64 %1142, 1
%1157 = getelementptr inbounds double*, double** %0, i64 %1156
%1158 = load double*, double** %1157
%1159 = getelementptr inbounds double, double* %1158, i64 %1035
%1160 = bitcast double* %1159 to <2 x double>*
%1161 = load <2 x double>, <2 x double>* %1160
%1162 = extractelement <2 x double> %1161, i64 0
%1163 = fneg double %1162
%1164 = insertelement <2 x double> %1161, double %1163, i64 0
%1165 = fmul <2 x double> %1139, %1164
%1166 = shufflevector <2 x double> %1165, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1167 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1161, <2 x double> %1140, <2 x double> %1166)
%1168 = bitcast double* %1159 to <2 x double>*
store <2 x double> %1167, <2 x double>* %1168
%1169 = add nuw nsw i64 %1142, 2
%1170 = add i64 %1143, 2
%1171 = icmp eq i64 %1170, %745
br i1 %1171, label %1015, label %1141
1172: ; preds = %983
%1173 = fcmp olt double %985, 0.000000e+00
br i1 %1173, label %1174, label %1222
1174: ; preds = %1172
%1175 = fneg double %985
store double %1175, double* %906
br i1 %748, label %1209, label %1176
1176: ; preds = %1174, %1176
%1177 = phi i64 [ %1202, %1176 ], [ 0, %1174 ]
%1178 = phi i64 [ %1203, %1176 ], [ 0, %1174 ]
%1179 = getelementptr inbounds double*, double** %4, i64 %1177
%1180 = load double*, double** %1179
%1181 = getelementptr inbounds double, double* %1180, i64 %904
%1182 = load double, double* %1181
%1183 = fneg double %1182
store double %1183, double* %1181
%1184 = or i64 %1177, 1
%1185 = getelementptr inbounds double*, double** %4, i64 %1184
%1186 = load double*, double** %1185
%1187 = getelementptr inbounds double, double* %1186, i64 %904
%1188 = load double, double* %1187
%1189 = fneg double %1188
store double %1189, double* %1187
%1190 = or i64 %1177, 2
%1191 = getelementptr inbounds double*, double** %4, i64 %1190
%1192 = load double*, double** %1191
%1193 = getelementptr inbounds double, double* %1192, i64 %904
%1194 = load double, double* %1193
%1195 = fneg double %1194
store double %1195, double* %1193
%1196 = or i64 %1177, 3
%1197 = getelementptr inbounds double*, double** %4, i64 %1196
%1198 = load double*, double** %1197
%1199 = getelementptr inbounds double, double* %1198, i64 %904
%1200 = load double, double* %1199
%1201 = fneg double %1200
store double %1201, double* %1199
%1202 = add nuw nsw i64 %1177, 4
%1203 = add i64 %1178, 4
%1204 = icmp eq i64 %1203, %749
br i1 %1204, label %1209, label %1176
1205: ; preds = %1032, %988
%1206 = phi double [ %1013, %988 ], [ %1131, %1032 ]
%1207 = phi double [ %991, %988 ], [ %1134, %1032 ]
%1208 = getelementptr inbounds double, double* %13, i64 %989
store double 0.000000e+00, double* %1208
store double %1206, double* %909
store double %1207, double* %906
br label %910
1209: ; preds = %1176, %1174
%1210 = phi i64 [ 0, %1174 ], [ %1202, %1176 ]
br i1 %750, label %1222, label %1211
1211: ; preds = %1209, %1211
%1212 = phi i64 [ %1219, %1211 ], [ %1210, %1209 ]
%1213 = phi i64 [ %1220, %1211 ], [ 0, %1209 ]
%1214 = getelementptr inbounds double*, double** %4, i64 %1212
%1215 = load double*, double** %1214
%1216 = getelementptr inbounds double, double* %1215, i64 %904
%1217 = load double, double* %1216
%1218 = fneg double %1217
store double %1218, double* %1216
%1219 = add nuw nsw i64 %1212, 1
%1220 = add i64 %1213, 1
%1221 = icmp eq i64 %1220, %747
br i1 %1221, label %1222, label %1211
1222: ; preds = %1209, %1211, %1172
%1223 = icmp sgt i64 %904, 0
br i1 %1223, label %903, label %1224
1224: ; preds = %1222, %734
%1225 = tail call i32 @free(double* %13)
ret void
}