#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);
double *malloc(size_t);
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 = malloc((size_t)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++) {
            y = a[j][l1];
            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    $0xd0,%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,-0xb5(%rbp)
jle    11a3 <svd+0x43>
cmpl   $0x0,-0xc(%rbp)
setg   %al
mov    %al,-0xb5(%rbp)
mov    -0xb5(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18f0 <svd+0x790>
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    151d <svd+0x3bd>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    127d <svd+0x11d>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d9f(%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    1239 <svd+0xd9>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    129a <svd+0x13a>
jp     129a <svd+0x13a>
jmp    1518 <svd+0x3b8>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1319 <svd+0x1b9>
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    12a0 <svd+0x140>
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 0x1cc7(%rip),%xmm2
pand   %xmm2,%xmm1
movaps 0x1cac(%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    14d4 <svd+0x374>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14cf <svd+0x36f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1451 <svd+0x2f1>
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    13fb <svd+0x29b>
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    14bc <svd+0x35c>
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    1466 <svd+0x306>
jmp    14c1 <svd+0x361>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13e1 <svd+0x281>
jmp    14d4 <svd+0x374>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1513 <svd+0x3b3>
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    14da <svd+0x37a>
jmp    1518 <svd+0x3b8>
jmp    151d <svd+0x3bd>
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    186d <svd+0x70d>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    186d <svd+0x70d>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15b3 <svd+0x453>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1a69(%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    156f <svd+0x40f>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15d0 <svd+0x470>
jp     15d0 <svd+0x470>
jmp    1868 <svd+0x708>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    164f <svd+0x4ef>
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    15d6 <svd+0x476>
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 0x1991(%rip),%xmm2
pand   %xmm2,%xmm1
movaps 0x1976(%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    1747 <svd+0x5e7>
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    1706 <svd+0x5a6>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1824 <svd+0x6c4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17bd <svd+0x65d>
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    1767 <svd+0x607>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1811 <svd+0x6b1>
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    17c3 <svd+0x663>
jmp    1816 <svd+0x6b6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    174d <svd+0x5ed>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1863 <svd+0x703>
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    182a <svd+0x6ca>
jmp    1868 <svd+0x708>
jmp    186d <svd+0x70d>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x177f(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1767(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    18c8 <svd+0x768>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    18d5 <svd+0x775>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e3 <svd+0x83>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1b17 <svd+0x9b7>
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1ad4 <svd+0x974>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1931 <svd+0x7d1>
jp     1931 <svd+0x7d1>
jmp    1a7f <svd+0x91f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1995 <svd+0x835>
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    1937 <svd+0x7d7>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a7a <svd+0x91a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a0b <svd+0x8ab>
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    19b5 <svd+0x855>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a67 <svd+0x907>
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    1a11 <svd+0x8b1>
jmp    1a6c <svd+0x90c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    199b <svd+0x83b>
jmp    1a7f <svd+0x91f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1acf <svd+0x96f>
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    1a85 <svd+0x925>
jmp    1ad4 <svd+0x974>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x1534(%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    18f9 <svd+0x799>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b34 <svd+0x9d4>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1b40 <svd+0x9e0>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1d97 <svd+0xc37>
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     1bbc <svd+0xa5c>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bb7 <svd+0xa57>
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    1b85 <svd+0xa25>
jmp    1bbc <svd+0xa5c>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1bd9 <svd+0xa79>
jp     1bd9 <svd+0xa79>
jmp    1d2a <svd+0xbca>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ce2 <svd+0xb82>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c4f <svd+0xaef>
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    1bf9 <svd+0xa99>
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    1ccf <svd+0xb6f>
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    1c79 <svd+0xb19>
jmp    1cd4 <svd+0xb74>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bdf <svd+0xa7f>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d25 <svd+0xbc5>
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    1ce8 <svd+0xb88>
jmp    1d67 <svd+0xc07>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d62 <svd+0xc02>
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    1d30 <svd+0xbd0>
jmp    1d67 <svd+0xc07>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x12a1(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b49 <svd+0x9e9>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     2756 <svd+0x15f6>
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    1df2 <svd+0xc92>
lea    0x1248(%rip),%rdi
mov    $0x1e,%esi
call   1080 <csa_quit@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1eb6 <svd+0xd56>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x11ea(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jne    1e4f <svd+0xcef>
jp     1e4f <svd+0xcef>
movl   $0x0,-0x84(%rbp)
jmp    1eb6 <svd+0xd56>
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 0x118c(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0x40(%rbp),%xmm0
jne    1ea3 <svd+0xd43>
jp     1ea3 <svd+0xd43>
jmp    1eb6 <svd+0xd56>
jmp    1ea8 <svd+0xd48>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1df8 <svd+0xc98>
cmpl   $0x0,-0x84(%rbp)
je     20c8 <svd+0xf68>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x114d(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     20c3 <svd+0xf63>
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 0x10d4(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jne    1f4b <svd+0xdeb>
jp     1f4b <svd+0xdeb>
jmp    20c3 <svd+0xf63>
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  0x1095(%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    20b0 <svd+0xf50>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%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 -0xa4(%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    1fd1 <svd+0xe71>
jmp    20b5 <svd+0xf55>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ede <svd+0xd7e>
jmp    20c8 <svd+0xf68>
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     2695 <svd+0x1535>
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  0xe9c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xe7e(%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 0xdfa(%rip),%xmm6
pand   %xmm6,%xmm5
movaps 0xddf(%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  0xdd5(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xdc8(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2659 <svd+0x14f9>
mov    -0xb4(%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 -0xb4(%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    2485 <svd+0x1325>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%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 -0xb4(%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    23a6 <svd+0x1246>
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 -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    24d4 <svd+0x1374>
jp     24d4 <svd+0x1374>
jmp    24f8 <svd+0x1398>
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    2640 <svd+0x14e0>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%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 -0xb4(%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    2561 <svd+0x1401>
jmp    2645 <svd+0x14e5>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    2266 <svd+0x1106>
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    273e <svd+0x15de>
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    2739 <svd+0x15d9>
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    2734 <svd+0x15d4>
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    26d9 <svd+0x1579>
jmp    2739 <svd+0x15d9>
jmp    2743 <svd+0x15e3>
jmp    1dba <svd+0xc5a>
jmp    2748 <svd+0x15e8>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1da0 <svd+0xc40>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r8,%r12
mov    %rcx,%r13
mov    %edx,%r14d
mov    %esi,%ebx
mov    %rdi,%r15
test   %edx,%edx
setg   %al
test   %esi,%esi
setg   %cl
and    %al,%cl
movzbl %cl,%edi
call   1050 <assert@plt>
movslq %ebx,%rbp
lea    0x0(,%rbp,8),%rdi
call   1060 <malloc@plt>
lea    -0x1(%rbp),%ecx
movslq %r14d,%rdi
mov    %rcx,0xf8(%rsp)
mov    %ecx,%ecx
mov    %rcx,0xe0(%rsp)
mov    %ebx,%ecx
mov    %r14,0x50(%rsp)
mov    %r14d,%edx
mov    %rbp,0x28(%rsp)
test   %ebp,%ebp
mov    %r13,0x30(%rsp)
mov    %r15,0x88(%rsp)
mov    %rax,0x20(%rsp)
mov    %rcx,0x40(%rsp)
mov    %rdx,0x108(%rsp)
mov    %ebx,0xc0(%rsp)
mov    %rdi,0x60(%rsp)
jle    2074 <svd+0xf04>
lea    -0x2(%rcx),%r14
lea    0x18(%rax),%r8
lea    -0x3(%rcx),%r10
mov    %rax,%rbx
add    $0x38,%rbx
lea    -0x5(%rcx),%r9
xorpd  %xmm8,%xmm8
mov    $0x1,%ebp
mov    %rbp,0x18(%rsp)
movq   $0xffffffffffffffff,0x100(%rsp)
mov    $0x7,%ebp
mov    %rbp,0xd8(%rsp)
movapd 0x1dac(%rip),%xmm7
movapd 0x1db3(%rip),%xmm9
movapd 0x1d9a(%rip),%xmm10
mov    %rcx,0xb0(%rsp)
mov    %rdx,0x10(%rsp)
xor    %r11d,%r11d
mov    %r15,0x90(%rsp)
xorpd  %xmm12,%xmm12
xorpd  %xmm11,%xmm11
xorpd  %xmm4,%xmm4
mov    %r15,%rsi
mov    %rcx,%rbp
mov    $0x3,%ecx
mov    %r14,0x110(%rsp)
jmp    1344 <svd+0x1d4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x0(,%r15,8),%rdx
add    %r13,%rdx
movq   $0x0,0x0(%r13,%r15,8)
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
movsd  (%rdx),%xmm0
movsd  (%rax,%r15,8),%xmm1
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movsd  0xa8(%rsp),%xmm0
maxsd  %xmm1,%xmm0
movapd %xmm0,%xmm4
addq   $0x1,0x18(%rsp)
addq   $0x8,0x90(%rsp)
addq   $0xffffffffffffffff,0x10(%rsp)
addq   $0xffffffffffffffff,0xb0(%rsp)
add    $0x8,%r8
add    $0x1,%rcx
add    $0xffffffffffffffff,%r10
addq   $0xffffffffffffffff,0x100(%rsp)
add    $0xffffffffffffffff,%r9
addq   $0x1,0xd8(%rsp)
add    $0x8,%rbx
cmp    %rbp,%r11
je     1d4b <svd+0xbdb>
mov    %r11,%r15
mulsd  %xmm11,%xmm12
add    $0x1,%r11
movsd  %xmm12,(%rax,%r15,8)
cmp    %rdi,%r15
movsd  %xmm4,0xa8(%rsp)
jge    12b0 <svd+0x140>
mov    %rbx,0x38(%rsp)
mov    %r8,0x48(%rsp)
mov    %r11,0x8(%rsp)
mov    %rcx,0x80(%rsp)
mov    %r9,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x138(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x180(%rsp)
mov    %r10,%r13
shr    %r13
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    %r15,%rax
not    %rax
lea    (%rax,%rbp,1),%rcx
mov    %rcx,0x58(%rsp)
lea    (%rax,%rbp,1),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x140(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x148(%rsp)
mov    %r14,%rcx
sub    %r15,%rcx
mov    %rcx,0x128(%rsp)
add    %rbp,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x118(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,0x120(%rsp)
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    0x10(%rsp),%rbp
mov    0x90(%rsp),%rdx
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rbp
jne    1420 <svd+0x2b0>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm3
xorpd  %xmm0,%xmm0
mov    0x28(%rsp),%rbx
mov    0xb0(%rsp),%r8
jne    145e <svd+0x2ee>
jnp    1646 <svd+0x4d6>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    0x10(%rsp),%rbp
mov    0x90(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rax
cmp    %rax,%rbp
jne    1480 <svd+0x310>
mov    (%rsi,%r15,8),%rax
movsd  (%rax,%r15,8),%xmm5
ucomisd %xmm8,%xmm2
mov    %r9,0xd0(%rsp)
jb     14ca <svd+0x35a>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    154a <svd+0x3da>
movapd %xmm2,%xmm0
mov    %r10,%rbp
movsd  %xmm3,0x78(%rsp)
movapd %xmm5,0x160(%rsp)
movsd  %xmm2,0x150(%rsp)
call   1080 <sqrt@plt>
movsd  0x150(%rsp),%xmm2
movapd 0x160(%rsp),%xmm5
movsd  0x78(%rsp),%xmm3
xorpd  %xmm11,%xmm11
movapd 0x1aec(%rip),%xmm10
movapd 0x1af3(%rip),%xmm9
movapd 0x1adb(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    %rbp,%r10
mov    0xb0(%rsp),%r8
mov    0x110(%rsp),%r14
mov    0x60(%rsp),%rdi
mov    0x88(%rsp),%rsi
mov    0x90(%rsp),%rbp
movapd %xmm7,%xmm1
andnpd %xmm5,%xmm1
andpd  %xmm7,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm5,%xmm1
addsd  %xmm0,%xmm1
xorpd  %xmm9,%xmm0
mov    (%rsi,%r15,8),%rax
movsd  %xmm1,(%rax,%r15,8)
cmp    0xe0(%rsp),%r15
jae    160d <svd+0x49d>
cmp    %rbx,0x8(%rsp)
jge    160d <svd+0x49d>
mulsd  %xmm0,%xmm5
subsd  %xmm2,%xmm5
mov    0x18(%rsp),%rax
nop
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r9
jne    15b0 <svd+0x440>
divsd  %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp,%rcx,8),%rdx
movsd  (%rdx,%r15,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    15e0 <svd+0x470>
add    $0x1,%rax
cmp    0x40(%rsp),%rax
jne    15a0 <svd+0x430>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%rbp,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%r15,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1620 <svd+0x4b0>
mov    0xd0(%rsp),%r9
mulsd  %xmm0,%xmm3
mov    0x30(%rsp),%rax
lea    (%rax,%r15,8),%rcx
mov    %rcx,0x78(%rsp)
movsd  %xmm3,(%rax,%r15,8)
cmp    0xe0(%rsp),%r15
mov    0x80(%rsp),%rcx
jae    1740 <svd+0x5d0>
mov    0x8(%rsp),%r11
cmp    %rbx,%r11
jge    175b <svd+0x5eb>
lea    0x0(,%r15,8),%rax
add    (%rsi,%r15,8),%rax
xorpd  %xmm12,%xmm12
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x1,%rcx
cmp    %rcx,%r8
jne    16a0 <svd+0x530>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm12
jne    16c9 <svd+0x559>
jnp    1771 <svd+0x601>
mov    %r9,0xd0(%rsp)
mov    (%rsi,%r15,8),%rax
xorpd  %xmm1,%xmm1
mov    %rbx,%r14
cmp    %rbx,%r11
jge    1710 <svd+0x5a0>
lea    (%rax,%r15,8),%rcx
xorpd  %xmm1,%xmm1
mov    $0x1,%edx
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm12,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rdx
cmp    %rdx,%r8
jne    16f0 <svd+0x580>
mov    0x8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
ucomisd %xmm8,%xmm1
mov    %r10,0x130(%rsp)
jb     17a4 <svd+0x634>
xorps  %xmm11,%xmm11
sqrtsd %xmm1,%xmm11
jmp    181b <svd+0x6ab>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm12,%xmm12
mov    0x30(%rsp),%r13
mov    0x20(%rsp),%rax
mov    0x40(%rsp),%rbp
mov    0x8(%rsp),%r11
jmp    1790 <svd+0x620>
xorpd  %xmm12,%xmm12
mov    0x30(%rsp),%r13
mov    0x20(%rsp),%rax
mov    0x40(%rsp),%rbp
jmp    1790 <svd+0x620>
mov    0x30(%rsp),%r13
mov    0x20(%rsp),%rax
mov    0x40(%rsp),%rbp
mov    0x80(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
mov    0x78(%rsp),%rdx
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%rbx
jmp    12ce <svd+0x15e>
movapd %xmm1,%xmm0
movapd %xmm12,0x160(%rsp)
movapd %xmm2,0x150(%rsp)
movsd  %xmm1,0x178(%rsp)
call   1080 <sqrt@plt>
movsd  0x178(%rsp),%xmm1
movapd 0x150(%rsp),%xmm2
movapd 0x160(%rsp),%xmm12
mov    0x8(%rsp),%rcx
movapd 0x180d(%rip),%xmm10
movapd 0x1814(%rip),%xmm9
movapd 0x17fc(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x60(%rsp),%rdi
mov    0x88(%rsp),%rsi
movapd %xmm0,%xmm11
movapd %xmm7,%xmm0
andnpd %xmm2,%xmm0
andpd  %xmm7,%xmm11
orpd   %xmm0,%xmm11
movapd %xmm2,%xmm0
addsd  %xmm11,%xmm0
xorpd  %xmm9,%xmm11
mov    (%rsi,%r15,8),%r8
movsd  %xmm0,(%r8,%rcx,8)
cmp    %r14,%rcx
mov    0x20(%rsp),%rax
mov    0x40(%rsp),%rdx
jge    1938 <svd+0x7c8>
mulsd  %xmm11,%xmm2
subsd  %xmm1,%xmm2
mov    0x18(%rsp),%rcx
cmpq   $0x2,0x58(%rsp)
jb     190b <svd+0x79b>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x2,0x118(%rsp)
jae    1889 <svd+0x719>
xor    %edx,%edx
jmp    18c8 <svd+0x758>
mov    0x80(%rsp),%rax
lea    (%r8,%rax,8),%rcx
xor    %edx,%edx
mov    0x48(%rsp),%rax
nopl   0x0(%rax)
movupd -0x10(%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rax,%rdx,8)
movupd (%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r13
jne    18a0 <svd+0x730>
mov    0x58(%rsp),%rbp
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
testb  $0x1,0x120(%rsp)
01
je     18f7 <svd+0x787>
add    0x18(%rsp),%rdx
movupd (%r8,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
mov    0x20(%rsp),%rax
movupd %xmm1,(%rax,%rdx,8)
cmp    %rcx,%rbp
mov    0x20(%rsp),%rax
mov    0x40(%rsp),%rdx
je     1938 <svd+0x7c8>
add    0x18(%rsp),%rcx
mov    0x20(%rsp),%rax
mov    0x40(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rcx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1920 <svd+0x7b0>
cmp    %rdi,0x8(%rsp)
mov    %rdx,%rbp
mov    0x18(%rsp),%r13
mov    0x58(%rsp),%rbx
jge    1bb1 <svd+0xa41>
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x120(%rsp)
add    %r13,%rcx
mov    %rcx,0x118(%rsp)
mov    0x100(%rsp),%r10
neg    %r10
lea    (%r8,%r13,8),%rdi
mov    %r13,%r11
jmp    1992 <svd+0x822>
xchg   %ax,%ax
add    $0x1,%r11
cmp    0x108(%rsp),%r11
je     1bb1 <svd+0xa41>
cmp    %r14,0x8(%rsp)
jge    1980 <svd+0x810>
mov    (%rsi,%r11,8),%rdx
test   $0x3,%bl
je     1a7b <svd+0x90b>
lea    (%rdx,%r13,8),%rcx
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    0x180(%rsp),%r9
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%r9
jne    19c0 <svd+0x850>
add    %r10,%rbx
cmpq   $0x3,0x128(%rsp)
jb     1a3b <svd+0x8cb>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rbx,8),%xmm1
movsd  0x8(%rdx,%rbx,8),%xmm2
mulsd  (%r8,%rbx,8),%xmm1
mulsd  0x8(%r8,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rdx,%rbx,8),%xmm3
mulsd  0x10(%r8,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rdx,%rbx,8),%xmm0
mulsd  0x18(%r8,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    19f0 <svd+0x880>
mov    0x28(%rsp),%r14
cmp    %r14,0x8(%rsp)
mov    0x58(%rsp),%rbx
jge    1980 <svd+0x810>
mov    (%rsi,%r11,8),%rdx
mov    %r13,%rcx
cmp    $0x4,%rbx
jb     1b90 <svd+0xa20>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x140(%rsp)
jae    1a93 <svd+0x923>
xor    %ebx,%ebx
jmp    1b24 <svd+0x9b4>
xorpd  %xmm0,%xmm0
mov    %r13,%rbx
cmpq   $0x3,0x128(%rsp)
jae    19f0 <svd+0x880>
jmp    1a3b <svd+0x8cb>
mov    0xd8(%rsp),%rcx
lea    (%rdx,%rcx,8),%rcx
mov    0x138(%rsp),%rbp
xor    %ebx,%ebx
mov    0x38(%rsp),%r13
xchg   %ax,%ax
movupd -0x30(%r13,%rbx,8),%xmm2
movupd -0x20(%r13,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rcx,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rcx,%rbx,8),%xmm2
movupd -0x10(%rcx,%rbx,8),%xmm5
movupd (%rcx,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rcx,%rbx,8)
movupd %xmm3,-0x20(%rcx,%rbx,8)
movupd -0x10(%r13,%rbx,8),%xmm2
movupd 0x0(%r13,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd %xmm3,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1ab0 <svd+0x940>
testb  $0x1,0x148(%rsp)
01
mov    0x40(%rsp),%rbp
mov    0x18(%rsp),%r13
je     1b6c <svd+0x9fc>
add    %r13,%rbx
movupd (%rax,%rbx,8),%xmm2
movupd 0x10(%rax,%rbx,8),%xmm3
movupd (%rdx,%rbx,8),%xmm4
movupd 0x10(%rdx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rbx,8)
movupd %xmm3,0x10(%rdx,%rbx,8)
mov    0x118(%rsp),%rcx
mov    0x58(%rsp),%rbx
cmp    0x120(%rsp),%rbx
mov    0x28(%rsp),%r14
je     1980 <svd+0x810>
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1b90 <svd+0xa20>
jmp    1980 <svd+0x810>
mov    0x8(%rsp),%r11
cmp    %r14,%r11
jge    1bfe <svd+0xa8e>
mov    %r13,%rdx
cmp    $0x4,%rbx
mov    0x30(%rsp),%r13
mov    0x110(%rsp),%r14
mov    0x130(%rsp),%r10
mov    0x38(%rsp),%rbx
jb     1d06 <svd+0xb96>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x4,0x140(%rsp)
jae    1c3c <svd+0xacc>
xor    %ecx,%ecx
jmp    1ca8 <svd+0xb38>
mov    0x30(%rsp),%r13
mov    0x60(%rsp),%rdi
mov    0x110(%rsp),%r14
mov    0x48(%rsp),%r8
mov    0x130(%rsp),%r10
mov    0x38(%rsp),%rbx
mov    0xd0(%rsp),%r9
mov    0x80(%rsp),%rcx
mov    0x78(%rsp),%rdx
jmp    12ce <svd+0x15e>
mov    0xd8(%rsp),%rcx
lea    (%r8,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0x138(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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,%rdi
jne    1c60 <svd+0xaf0>
mov    0x58(%rsp),%rdi
mov    %rdi,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x148(%rsp)
01
je     1ce5 <svd+0xb75>
add    0x18(%rsp),%rcx
movupd (%r8,%rcx,8),%xmm1
movupd 0x10(%r8,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%r8,%rcx,8)
movupd %xmm2,0x10(%r8,%rcx,8)
cmp    %rdx,%rdi
jne    1d01 <svd+0xb91>
mov    0x60(%rsp),%rdi
mov    0xd0(%rsp),%r9
mov    0x80(%rsp),%rcx
jmp    1d37 <svd+0xbc7>
add    0x18(%rsp),%rdx
mov    0x80(%rsp),%rcx
xchg   %ax,%ax
movsd  (%r8,%rdx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%r8,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1d10 <svd+0xba0>
mov    0x60(%rsp),%rdi
mov    0xd0(%rsp),%r9
mov    0x8(%rsp),%r11
mov    0x78(%rsp),%rdx
mov    0x48(%rsp),%r8
jmp    12ce <svd+0x15e>
mov    0xc0(%rsp),%r8d
test   %r8d,%r8d
jle    207e <svd+0xf0e>
mov    0x28(%rsp),%rbp
mov    %rbp,%rax
neg    %rax
mov    %rax,0x8(%rsp)
xor    %r13d,%r13d
movabs $0x3ff0000000000000,%rsi
xorpd  %xmm0,%xmm0
mov    %rbp,%rdi
mov    %r8d,%r14d
jmp    1db4 <svd+0xc44>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rdi,8),%rax
mov    %rsi,(%rax,%rdi,8)
mov    0x20(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm11
add    $0x1,%r13b
mov    %edi,%r14d
cmp    $0x1,%rbx
jle    2085 <svd+0xf15>
mov    %rdi,%rbx
movzbl %r13b,%r13d
and    $0x3,%r13d
add    $0xffffffffffffffff,%rdi
cmp    0xe0(%rsp),%rbx
jg     1d90 <svd+0xc20>
mov    %rbx,0xb0(%rsp)
movslq %r14d,%r15
mov    %rbp,%r10
sub    %r15,%r10
mov    %r15,%r11
not    %r11
lea    (%r11,%rbp,1),%rax
mov    %rax,0x10(%rsp)
ucomisd %xmm0,%xmm11
jne    1dfa <svd+0xc8a>
jnp    1fb0 <svd+0xe40>
cmp    0xc0(%rsp),%r14d
jge    1fb0 <svd+0xe40>
movapd %xmm4,%xmm5
mov    0x88(%rsp),%rax
mov    (%rax,%rdi,8),%rax
movslq %r14d,%rcx
mov    %rcx,%rsi
xchg   %ax,%ax
movsd  (%rax,%rsi,8),%xmm1
divsd  (%rax,%rcx,8),%xmm1
divsd  %xmm11,%xmm1
mov    (%r12,%rsi,8),%rbx
movsd  %xmm1,(%rbx,%rdi,8)
mov    0x28(%rsp),%rbp
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1e20 <svd+0xcb0>
cmp    0xc0(%rsp),%r14d
movapd %xmm5,%xmm4
jge    1fb0 <svd+0xe40>
movslq %r14d,%r8
mov    0x88(%rsp),%rax
mov    (%rax,%rdi,8),%rsi
lea    0x1(%r8),%rax
mov    %rax,0x90(%rsp)
mov    %r8,%rax
jmp    1e94 <svd+0xd24>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rdx,%rax
mov    %rdx,%rbp
movapd %xmm5,%xmm4
je     1fb0 <svd+0xe40>
xorpd  %xmm1,%xmm1
test   $0x3,%r10b
je     1ed0 <svd+0xd60>
mov    %r13,%rcx
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rbx,8),%xmm2
mov    (%r12,%rbx,8),%r9
mulsd  (%r9,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    1eb0 <svd+0xd40>
jmp    1ed3 <svd+0xd63>
nop
mov    %r8,%rbx
cmpq   $0x3,0x10(%rsp)
mov    0x28(%rsp),%rbp
jb     1f37 <svd+0xdc7>
movsd  (%rsi,%rbx,8),%xmm2
movsd  0x8(%rsi,%rbx,8),%xmm3
mov    (%r12,%rbx,8),%rcx
mov    0x8(%r12,%rbx,8),%rdx
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rdx,%rax,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rsi,%rbx,8),%xmm2
mov    0x10(%r12,%rbx,8),%rcx
mulsd  (%rcx,%rax,8),%xmm2
movsd  0x18(%rsi,%rbx,8),%xmm1
mov    0x18(%r12,%rbx,8),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1ee0 <svd+0xd70>
mov    %r8,%rbx
test   $0x1,%r10b
je     1f5f <svd+0xdef>
mov    (%r12,%r8,8),%rcx
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0x90(%rsp),%rbx
cmp    0x8(%rsp),%r11
mov    0x28(%rsp),%rdx
je     1e80 <svd+0xd10>
nop
mov    (%r12,%rbx,8),%rcx
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0x8(%r12,%rbx,8),%rcx
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    1f70 <svd+0xe00>
jmp    1e80 <svd+0xd10>
nopl   (%rax)
mov    0xc0(%rsp),%r8d
cmp    %r8d,%r14d
movabs $0x3ff0000000000000,%rsi
mov    0xb0(%rsp),%rbx
jge    1d90 <svd+0xc20>
mov    (%r12,%rdi,8),%rax
test   $0x3,%r10b
je     1ffe <svd+0xe8e>
mov    %r13,%rcx
movq   $0x0,(%rax,%r15,8)
mov    (%r12,%r15,8),%rdx
movq   $0x0,(%rdx,%rdi,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rcx
jne    1fe0 <svd+0xe70>
cmpq   $0x3,0x10(%rsp)
jb     1d90 <svd+0xc20>
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rax,%r15,8)
mov    (%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rdi,8)
movq   $0x0,0x8(%rax,%r15,8)
mov    0x8(%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rdi,8)
movq   $0x0,0x10(%rax,%r15,8)
mov    0x10(%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rdi,8)
movq   $0x0,0x18(%rax,%r15,8)
mov    0x18(%r12,%r15,8),%rcx
movq   $0x0,(%rcx,%rdi,8)
add    $0x4,%r15
cmp    %r15,%rbp
jne    2010 <svd+0xea0>
jmp    1d90 <svd+0xc20>
mov    %ebx,%r8d
xorpd  %xmm4,%xmm4
mov    %r15,%rsi
mov    0x50(%rsp),%rcx
jmp    2097 <svd+0xf27>
mov    0x50(%rsp),%rcx
mov    0x88(%rsp),%rsi
mov    0x60(%rsp),%rdi
lea    -0x1(%rcx),%eax
cmp    %r8d,%ecx
cmovge 0xf8(%rsp),%eax
test   %eax,%eax
movsd  %xmm4,0xa8(%rsp)
js     23cb <svd+0x125b>
lea    0x1(%rax),%edx
mov    0xf8(%rsp),%rcx
sub    %edx,%ecx
mov    %rcx,0xf8(%rsp)
mov    %eax,%ebp
lea    (%rsi,%rbp,8),%r13
mov    0x50(%rsp),%rax
mov    %eax,%r15d
sub    %edx,%r15d
add    $0x1,%r15d
sub    %dl,%al
mov    %al,0x90(%rsp)
xor    %r9d,%r9d
xorpd  %xmm3,%xmm3
movsd  0xf28(%rip),%xmm5
mov    %rdx,0x8(%rsp)
mov    %edx,%r14d
jmp    2149 <svd+0xfd9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rbp,8),%rax
movsd  (%rax,%rbp,8),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%r9
add    $0xffffffff,%r14d
add    $0xffffffffffffffff,%rbp
add    $0xfffffffffffffff8,%r13
add    $0x1,%r15
addb   $0x1,0x90(%rsp)
01
cmp    0x8(%rsp),%r9
je     23cb <svd+0x125b>
mov    0x30(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm6
lea    0x1(%rbp),%eax
mov    %eax,0x10(%rsp)
cmp    0xe0(%rsp),%rbp
je     21e0 <svd+0x1070>
cmp    %r8d,0x10(%rsp)
jge    21e0 <svd+0x1070>
mov    0xf8(%rsp),%rax
add    %r9d,%eax
lea    0x8(,%rax,8),%rdx
mov    0x8(%rsp),%rax
sub    %r9d,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
add    (%rsi,%rbp,8),%rdi
xor    %esi,%esi
mov    %r14d,%ebx
mov    %r9,%r14
movsd  %xmm6,0xb0(%rsp)
call   1040 <memset@plt>
movsd  0xb0(%rsp),%xmm6
movsd  0xe68(%rip),%xmm5
xorpd  %xmm3,%xmm3
mov    %r14,%r9
mov    %ebx,%r14d
mov    0x60(%rsp),%rdi
mov    0xc0(%rsp),%r8d
movsd  0xa8(%rsp),%xmm4
mov    0x88(%rsp),%rsi
ucomisd %xmm3,%xmm6
jne    21ec <svd+0x107c>
jnp    23a0 <svd+0x1230>
mov    %r9,0xb0(%rsp)
cmp    %r8d,0x10(%rsp)
jge    2340 <svd+0x11d0>
movzbl 0x90(%rsp),%r8d
and    $0x3,%r8d
shl    $0x3,%r8
movslq %r14d,%r11
mov    %rdi,%r10
sub    %r11,%r10
mov    %r11,%rbx
not    %rbx
add    %rdi,%rbx
mov    (%rsi,%rbp,8),%r9
mov    %r11,%rcx
jmp    223f <svd+0x10cf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    0x28(%rsp),%rcx
jge    2340 <svd+0x11d0>
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%eax
cmp    0x50(%rsp),%eax
jge    22f9 <svd+0x1189>
xorpd  %xmm0,%xmm0
test   $0x3,%r10b
je     228e <svd+0x111e>
mov    %r8,%rdi
mov    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    $0xfffffffffffffff8,%rdi
jne    2270 <svd+0x1100>
jmp    2291 <svd+0x1121>
mov    %r11,%rax
cmp    $0x3,%rbx
mov    0x60(%rsp),%rdi
jb     22f9 <svd+0x1189>
nopl   0x0(%rax)
mov    (%rsi,%rax,8),%rdx
mov    0x8(%rsi,%rax,8),%rdi
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%rbp,8),%xmm2
mulsd  (%rdi,%rcx,8),%xmm2
mov    0x60(%rsp),%rdi
addsd  %xmm1,%xmm2
mov    0x10(%rsi,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
mov    0x18(%rsi,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm0
mulsd  (%rdx,%rcx,8),%xmm0
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x4,%rax
cmp    %rdi,%rax
jl     22a0 <svd+0x1130>
cmp    %rdi,%rbp
jge    2230 <svd+0x10c0>
divsd  (%r9,%rbp,8),%xmm0
divsd  %xmm6,%xmm0
xor    %eax,%eax
xchg   %ax,%ax
mov    0x0(%r13,%rax,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    2310 <svd+0x11a0>
jmp    2230 <svd+0x10c0>
cs nopw 0x0(%rax,%rax,1)
cmp    %rdi,%rbp
movsd  0xa8(%rsp),%xmm4
mov    0xc0(%rsp),%r8d
mov    0xb0(%rsp),%r9
jge    2110 <svd+0xfa0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
divsd  %xmm6,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    2370 <svd+0x1200>
jmp    2110 <svd+0xfa0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %rdi,%rbp
jge    2110 <svd+0xfa0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movq   $0x0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    23b0 <svd+0x1240>
jmp    2110 <svd+0xfa0>
test   %r8d,%r8d
mov    0x30(%rsp),%r14
mov    0x20(%rsp),%rdi
mov    0x108(%rsp),%rcx
mov    0x28(%rsp),%rbx
jle    2cb0 <svd+0x1b40>
lea    -0x1(%rbx),%rax
mov    %rax,0x38(%rsp)
mov    0x40(%rsp),%rax
lea    -0x1(%rax),%rdx
mov    %rdx,0x58(%rsp)
mov    %eax,%r15d
and    $0xfffffffe,%r15d
and    $0xfffffffe,%ecx
mov    %rcx,0x80(%rsp)
mov    %eax,%esi
and    $0x3,%esi
mov    %eax,%r8d
and    $0xfffffffc,%r8d
movapd 0xbd8(%rip),%xmm2
movapd 0xbdf(%rip),%xmm11
movsd  0xbe7(%rip),%xmm1
mov    %rsi,0x100(%rsp)
mov    %r8,0x48(%rsp)
jmp    2465 <svd+0x12f5>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
mov    0x28(%rsp),%rbx
add    $0xffffffffffffffff,%rbx
test   %rax,%rax
jle    2cb0 <svd+0x1b40>
mov    0x38(%rsp),%rcx
lea    -0x1(%rcx),%rax
mov    %rax,0x38(%rsp)
xor    %ebp,%ebp
mov    %rbx,0x28(%rsp)
mov    %rcx,%rbx
mov    %rcx,0x18(%rsp)
jmp    24dd <svd+0x136d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm4,%xmm2
movapd 0xb73(%rip),%xmm11
movsd  0xb7b(%rip),%xmm1
mov    0x20(%rsp),%rax
mov    0xd8(%rsp),%rcx
movq   $0x0,(%rax,%rcx,8)
movsd  %xmm3,(%rax,%rbx,8)
movsd  %xmm2,(%r14,%rbx,8)
movsd  0xa8(%rsp),%xmm4
movapd 0xb2a(%rip),%xmm2
mov    0x128(%rsp),%ebp
cmp    $0x1e,%ebp
jb     2515 <svd+0x13a5>
lea    0xb4f(%rip),%rdi
mov    $0x1e,%esi
call   1090 <csa_quit@plt>
movsd  0xb25(%rip),%xmm1
movapd 0xb0c(%rip),%xmm11
movapd 0xaf4(%rip),%xmm2
movsd  0xa8(%rsp),%xmm4
add    $0x1,%ebp
mov    %ebp,0x128(%rsp)
mov    0x28(%rsp),%rax
mov    %ebx,%r13d
mov    0x50(%rsp),%rbp
nopl   0x0(%rax)
lea    -0x1(%rax),%ecx
mov    0x20(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
andpd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
jne    2551 <svd+0x13e1>
jnp    26ef <svd+0x157f>
movsd  -0x10(%r14,%rax,8),%xmm0
andpd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
jne    2568 <svd+0x13f8>
jnp    2590 <svd+0x1420>
add    $0xffffffff,%r13d
add    $0xffffffffffffffff,%rax
jg     2530 <svd+0x13c0>
mov    $0xffffffff,%r13d
mov    $0xffffffffffffffff,%rax
jmp    2594 <svd+0x1424>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffffffffffffe,%rax
movslq %r13d,%rbx
cmp    %rbx,0x18(%rsp)
jge    25b0 <svd+0x1440>
mov    0x18(%rsp),%rbx
jmp    26ef <svd+0x157f>
nopl   0x0(%rax,%rax,1)
movslq %eax,%rbp
xorpd  %xmm5,%xmm5
movapd %xmm1,%xmm7
jmp    25ec <svd+0x147c>
nopl   (%rax)
lea    0x1(%rbx),%rax
cmp    0x18(%rsp),%rbx
mov    %rax,%rbx
movsd  0xa8(%rsp),%xmm4
movapd 0xa23(%rip),%xmm2
movapd 0xa2a(%rip),%xmm11
jge    26e0 <svd+0x1570>
mov    0x20(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mulsd  %xmm0,%xmm7
mulsd  %xmm0,%xmm5
movsd  %xmm5,(%rax,%rbx,8)
movapd %xmm7,%xmm0
andpd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
jne    261b <svd+0x14ab>
jnp    26e0 <svd+0x1570>
mov    0x30(%rsp),%r14
movsd  (%r14,%rbx,8),%xmm1
movsd  %xmm1,0x10(%rsp)
movapd %xmm7,%xmm0
movapd %xmm7,0x60(%rsp)
call   1070 <hypot@plt>
movsd  0x10(%rsp),%xmm5
movapd 0x60(%rsp),%xmm7
movsd  0x9d1(%rip),%xmm1
mov    0x108(%rsp),%rsi
mov    0x88(%rsp),%rdx
movsd  %xmm0,(%r14,%rbx,8)
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
mulsd  %xmm2,%xmm5
xorpd  0x997(%rip),%xmm7
mulsd  %xmm2,%xmm7
cmpl   $0x0,0x50(%rsp)
jle    25c0 <svd+0x1450>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  (%rcx,%rbx,8),%xmm4
movapd %xmm7,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
mulsd  %xmm5,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,(%rcx,%rbx,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2690 <svd+0x1520>
jmp    25c0 <svd+0x1450>
cs nopw 0x0(%rax,%rax,1)
mov    0x30(%rsp),%r14
mov    0x18(%rsp),%rbx
mov    0x50(%rsp),%rbp
movsd  (%r14,%rbx,8),%xmm3
mov    %r13d,%eax
cmp    %rax,%rbx
je     2bd0 <svd+0x1a60>
movslq %r13d,%r13
movsd  (%r14,%r13,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x38(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm4
mov    0x20(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm5
movsd  (%rax,%rbx,8),%xmm6
movapd %xmm6,0x60(%rsp)
movapd %xmm3,%xmm2
addsd  %xmm5,%xmm2
divsd  %xmm6,%xmm2
subsd  %xmm3,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
movsd  %xmm4,0x10(%rsp)
movapd %xmm4,%xmm0
divsd  %xmm6,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm6,%xmm2
divsd  %xmm4,%xmm2
subsd  %xmm2,%xmm0
mulsd  0x8ba(%rip),%xmm0
movapd %xmm0,0xe0(%rsp)
movapd %xmm3,0x90(%rsp)
call   1070 <hypot@plt>
movsd  0x8(%rsp),%xmm4
movapd 0x60(%rsp),%xmm3
movapd 0x90(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm4,%xmm2
subsd  %xmm1,%xmm2
movapd 0xe0(%rsp),%xmm5
movapd %xmm5,%xmm1
andpd  0x84d(%rip),%xmm1
andpd  0x835(%rip),%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm5,%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
subsd  %xmm3,%xmm1
divsd  %xmm4,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
cmp    %r13,%rbx
mov    %r13,0xd8(%rsp)
jle    2490 <svd+0x1320>
mov    %r13,%rax
movsd  0x816(%rip),%xmm9
movapd %xmm9,%xmm7
jmp    286e <svd+0x16fe>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  0x8(%rsp),%xmm10
mulsd  %xmm8,%xmm6
subsd  %xmm10,%xmm6
movsd  0xe0(%rsp),%xmm2
mulsd  %xmm8,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm9,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm6
mulsd  %xmm9,%xmm2
subsd  %xmm6,%xmm2
movapd %xmm2,%xmm4
cmp    %rbx,%rax
jge    24a5 <svd+0x1335>
movsd  %xmm9,0x10(%rsp)
movsd  %xmm4,0x8(%rsp)
movapd %xmm3,0x60(%rsp)
mov    %rax,%r13
mov    0x20(%rsp),%rbx
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0xe0(%rsp)
movsd  %xmm1,0xc0(%rsp)
mulsd  %xmm1,%xmm7
movapd %xmm7,0x90(%rsp)
movapd %xmm3,%xmm0
movapd %xmm7,%xmm1
call   1070 <hypot@plt>
movapd 0x60(%rsp),%xmm7
movsd  %xmm0,(%rbx,%r13,8)
unpcklpd 0x90(%rsp),%xmm7
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm7
movapd %xmm7,%xmm6
unpckhpd %xmm7,%xmm6
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
cmpq   $0x0,0x58(%rsp)
je     2ac0 <svd+0x1950>
xor    %eax,%eax
movapd 0x70b(%rip),%xmm5
mov    0x18(%rsp),%rbx
movsd  0x8(%rsp),%xmm9
movsd  0xe0(%rsp),%xmm8
movsd  0x10(%rsp),%xmm10
movsd  0xc0(%rsp),%xmm11
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm5,%xmm2
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
movapd %xmm6,%xmm2
shufpd $0x1,%xmm6,%xmm2
mulpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%r13,8)
mov    0x8(%r12,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm3
xorpd  %xmm5,%xmm3
movapd %xmm1,%xmm4
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%rcx,%r13,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    2930 <svd+0x17c0>
testb  $0x1,0x40(%rsp)
je     29d1 <svd+0x1861>
mov    (%r12,%rax,8),%rax
movupd (%rax,%r13,8),%xmm1
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm0
xorpd  0x652(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm2,%xmm0
movupd %xmm0,(%rax,%r13,8)
mulsd  %xmm11,%xmm10
movsd  %xmm10,0x10(%rsp)
movapd %xmm10,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm9
addsd  %xmm0,%xmm9
movapd %xmm8,%xmm1
movapd %xmm6,0x90(%rsp)
mulsd  %xmm6,%xmm1
movapd %xmm9,0xc0(%rsp)
movapd %xmm9,%xmm0
movapd %xmm1,0xb0(%rsp)
movapd %xmm7,0x60(%rsp)
call   1070 <hypot@plt>
movapd 0x60(%rsp),%xmm8
movsd  %xmm0,(%r14,%r13,8)
ucomisd 0x5f6(%rip),%xmm0
movapd %xmm8,%xmm9
jne    2a43 <svd+0x18d3>
jnp    2a60 <svd+0x18f0>
movapd 0xc0(%rsp),%xmm9
unpcklpd 0xb0(%rsp),%xmm9
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm9
lea    0x1(%r13),%rax
movapd %xmm9,%xmm7
unpckhpd %xmm9,%xmm7
test   %ebp,%ebp
mov    0x88(%rsp),%rsi
mov    0x80(%rsp),%rdi
movapd 0x587(%rip),%xmm11
movsd  0x58f(%rip),%xmm1
movsd  0x10(%rsp),%xmm6
movapd 0x90(%rsp),%xmm10
jle    2820 <svd+0x16b0>
cmp    $0x1,%ebp
jne    2b00 <svd+0x1990>
xor    %ecx,%ecx
jmp    2b7f <svd+0x1a0f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
mov    0x18(%rsp),%rbx
movsd  0x8(%rsp),%xmm9
movsd  0xe0(%rsp),%xmm8
movsd  0x10(%rsp),%xmm10
movsd  0xc0(%rsp),%xmm11
testb  $0x1,0x40(%rsp)
jne    29a4 <svd+0x1834>
jmp    29d1 <svd+0x1861>
nopl   0x0(%rax)
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rsi,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm11,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
movapd %xmm7,%xmm3
shufpd $0x1,%xmm7,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rdx,%r13,8)
mov    0x8(%rsi,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm11,%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm4,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,(%rdx,%r13,8)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    2b10 <svd+0x19a0>
testb  $0x1,0x108(%rsp)
01
je     2820 <svd+0x16b0>
mov    (%rsi,%rcx,8),%rcx
movupd (%rcx,%r13,8),%xmm0
movapd %xmm0,%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
mulpd  %xmm0,%xmm3
xorpd  0x45f(%rip),%xmm0
shufpd $0x1,%xmm0,%xmm2
mulpd  %xmm7,%xmm2
addpd  %xmm2,%xmm3
movupd %xmm3,(%rcx,%r13,8)
jmp    2820 <svd+0x16b0>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
mov    0x20(%rsp),%rdi
mov    0x100(%rsp),%rsi
mov    0x48(%rsp),%r8
movapd 0x41e(%rip),%xmm0
jbe    2450 <svd+0x12e0>
xorpd  %xmm0,%xmm3
movlpd %xmm3,(%r14,%rbx,8)
cmpq   $0x3,0x58(%rsp)
jae    2c10 <svd+0x1aa0>
xor    %eax,%eax
jmp    2c78 <svd+0x1b08>
xchg   %ax,%ax
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
mov    0x8(%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
mov    0x10(%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
mov    0x18(%r12,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
xorpd  %xmm11,%xmm0
movlpd %xmm0,(%rcx,%rbx,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    2c20 <svd+0x1ab0>
test   %rsi,%rsi
movapd 0x38d(%rip),%xmm3
je     2450 <svd+0x12e0>
lea    (%r12,%rax,8),%rax
xor    %ecx,%ecx
nop
mov    (%rax,%rcx,8),%rdx
movsd  (%rdx,%rbx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rdx,%rbx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    2c90 <svd+0x1b20>
jmp    2450 <svd+0x12e0>
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 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
%33 = load i32, i32* %8
%34 = icmp sgt i32 %33, 0
br i1 %34, label %35, label %38
35: ; preds = %5
%36 = load i32, i32* %7
%37 = icmp sgt i32 %36, 0
br label %38
38: ; preds = %35, %5
%39 = phi i1 [ false, %5 ], [ %37, %35 ]
%40 = zext i1 %39 to i32
%41 = call i32 @assert(i32 %40)
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = mul i64 %43, 8
%45 = call double* @malloc(i64 %44)
store double* %45, 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 %46
46: ; preds = %510, %38
%47 = load i32, i32* %12
%48 = load i32, i32* %7
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %513
50: ; preds = %46
%51 = load i32, i32* %12
%52 = add nsw i32 %51, 1
store i32 %52, i32* %15
%53 = load double, double* %22
%54 = load double, double* %19
%55 = fmul double %53, %54
%56 = load double*, double** %11
%57 = load i32, i32* %12
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %56, i64 %58
store double %55, double* %59
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
%60 = load i32, i32* %12
%61 = load i32, i32* %8
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %261
63: ; preds = %50
%64 = load i32, i32* %12
store i32 %64, i32* %14
br label %65
65: ; preds = %82, %63
%66 = load i32, i32* %14
%67 = load i32, i32* %8
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %85
69: ; preds = %65
%70 = load double**, double*** %6
%71 = load i32, i32* %14
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double*, double** %70, i64 %72
%74 = load double*, double** %73
%75 = load i32, i32* %12
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
%78 = load double, double* %77
%79 = call double @llvm.fabs.f64(double %78)
%80 = load double, double* %22
%81 = fadd double %80, %79
store double %81, double* %22
br label %82
82: ; preds = %69
%83 = load i32, i32* %14
%84 = add nsw i32 %83, 1
store i32 %84, i32* %14
br label %65
85: ; preds = %65
%86 = load double, double* %22
%87 = fcmp une double %86, 0.000000e+00
br i1 %87, label %88, label %260
88: ; preds = %85
%89 = load i32, i32* %12
store i32 %89, i32* %14
br label %90
90: ; preds = %126, %88
%91 = load i32, i32* %14
%92 = load i32, i32* %8
%93 = icmp slt i32 %91, %92
br i1 %93, label %94, label %129
94: ; preds = %90
%95 = load double, double* %22
%96 = load double**, double*** %6
%97 = load i32, i32* %14
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double*, double** %96, i64 %98
%100 = load double*, double** %99
%101 = load i32, i32* %12
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
%104 = load double, double* %103
%105 = fdiv double %104, %95
store double %105, double* %103
%106 = load double**, double*** %6
%107 = load i32, i32* %14
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double*, double** %106, i64 %108
%110 = load double*, double** %109
%111 = load i32, i32* %12
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %110, i64 %112
%114 = load double, double* %113
%115 = load double**, double*** %6
%116 = load i32, i32* %14
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double*, double** %115, i64 %117
%119 = load double*, double** %118
%120 = load i32, i32* %12
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %119, i64 %121
%123 = load double, double* %122
%124 = load double, double* %21
%125 = call double @llvm.fmuladd.f64(double %114, double %123, double %124)
store double %125, double* %21
br label %126
126: ; preds = %94
%127 = load i32, i32* %14
%128 = add nsw i32 %127, 1
store i32 %128, i32* %14
br label %90
129: ; preds = %90
%130 = load double**, double*** %6
%131 = load i32, i32* %12
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double*, double** %130, i64 %132
%134 = load double*, double** %133
%135 = load i32, i32* %12
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
%138 = load double, double* %137
store double %138, double* %18
%139 = load double, double* %21
%140 = call double @sqrt(double %139)
%141 = load double, double* %18
%142 = call double @llvm.copysign.f64(double %140, double %141)
%143 = fneg double %142
store double %143, double* %19
%144 = load double, double* %18
%145 = load double, double* %19
%146 = load double, double* %21
%147 = fneg double %146
%148 = call double @llvm.fmuladd.f64(double %144, double %145, double %147)
store double %148, double* %20
%149 = load double, double* %18
%150 = load double, double* %19
%151 = fsub double %149, %150
%152 = load double**, double*** %6
%153 = load i32, i32* %12
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds double*, double** %152, i64 %154
%156 = load double*, double** %155
%157 = load i32, i32* %12
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
store double %151, double* %159
%160 = load i32, i32* %12
%161 = load i32, i32* %7
%162 = sub nsw i32 %161, 1
%163 = icmp slt i32 %160, %162
br i1 %163, label %164, label %238
164: ; preds = %129
%165 = load i32, i32* %15
store i32 %165, i32* %13
br label %166
166: ; preds = %234, %164
%167 = load i32, i32* %13
%168 = load i32, i32* %7
%169 = icmp slt i32 %167, %168
br i1 %169, label %170, label %237
170: ; preds = %166
store double 0.000000e+00, double* %21
%171 = load i32, i32* %12
store i32 %171, i32* %14
br label %172
172: ; preds = %197, %170
%173 = load i32, i32* %14
%174 = load i32, i32* %8
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %200
176: ; preds = %172
%177 = load double**, double*** %6
%178 = load i32, i32* %14
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double*, double** %177, i64 %179
%181 = load double*, double** %180
%182 = load i32, i32* %12
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
%185 = load double, double* %184
%186 = load double**, double*** %6
%187 = load i32, i32* %14
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double*, double** %186, i64 %188
%190 = load double*, double** %189
%191 = load i32, i32* %13
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %190, i64 %192
%194 = load double, double* %193
%195 = load double, double* %21
%196 = call double @llvm.fmuladd.f64(double %185, double %194, double %195)
store double %196, double* %21
br label %197
197: ; preds = %176
%198 = load i32, i32* %14
%199 = add nsw i32 %198, 1
store i32 %199, i32* %14
br label %172
200: ; preds = %172
%201 = load double, double* %21
%202 = load double, double* %20
%203 = fdiv double %201, %202
store double %203, double* %18
%204 = load i32, i32* %12
store i32 %204, i32* %14
br label %205
205: ; preds = %230, %200
%206 = load i32, i32* %14
%207 = load i32, i32* %8
%208 = icmp slt i32 %206, %207
br i1 %208, label %209, label %233
209: ; preds = %205
%210 = load double, double* %18
%211 = load double**, double*** %6
%212 = load i32, i32* %14
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double*, double** %211, i64 %213
%215 = load double*, double** %214
%216 = load i32, i32* %12
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %215, i64 %217
%219 = load double, double* %218
%220 = load double**, double*** %6
%221 = load i32, i32* %14
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double*, double** %220, i64 %222
%224 = load double*, double** %223
%225 = load i32, i32* %13
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = call double @llvm.fmuladd.f64(double %210, double %219, double %228)
store double %229, double* %227
br label %230
230: ; preds = %209
%231 = load i32, i32* %14
%232 = add nsw i32 %231, 1
store i32 %232, i32* %14
br label %205
233: ; preds = %205
br label %234
234: ; preds = %233
%235 = load i32, i32* %13
%236 = add nsw i32 %235, 1
store i32 %236, i32* %13
br label %166
237: ; preds = %166
br label %238
238: ; preds = %237, %129
%239 = load i32, i32* %12
store i32 %239, i32* %14
br label %240
240: ; preds = %256, %238
%241 = load i32, i32* %14
%242 = load i32, i32* %8
%243 = icmp slt i32 %241, %242
br i1 %243, label %244, label %259
244: ; preds = %240
%245 = load double, double* %22
%246 = load double**, double*** %6
%247 = load i32, i32* %14
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double*, double** %246, i64 %248
%250 = load double*, double** %249
%251 = load i32, i32* %12
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = fmul double %254, %245
store double %255, double* %253
br label %256
256: ; preds = %244
%257 = load i32, i32* %14
%258 = add nsw i32 %257, 1
store i32 %258, i32* %14
br label %240
259: ; preds = %240
br label %260
260: ; preds = %259, %85
br label %261
261: ; preds = %260, %50
%262 = load double, double* %22
%263 = load double, double* %19
%264 = fmul double %262, %263
%265 = load double*, double** %9
%266 = load i32, i32* %12
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
store double %264, double* %268
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
%269 = load i32, i32* %12
%270 = load i32, i32* %8
%271 = icmp slt i32 %269, %270
br i1 %271, label %272, label %487
272: ; preds = %261
%273 = load i32, i32* %12
%274 = load i32, i32* %7
%275 = sub nsw i32 %274, 1
%276 = icmp slt i32 %273, %275
br i1 %276, label %277, label %487
277: ; preds = %272
%278 = load i32, i32* %15
store i32 %278, i32* %14
br label %279
279: ; preds = %296, %277
%280 = load i32, i32* %14
%281 = load i32, i32* %7
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %299
283: ; preds = %279
%284 = load double**, double*** %6
%285 = load i32, i32* %12
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double*, double** %284, i64 %286
%288 = load double*, double** %287
%289 = load i32, i32* %14
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
%293 = call double @llvm.fabs.f64(double %292)
%294 = load double, double* %22
%295 = fadd double %294, %293
store double %295, double* %22
br label %296
296: ; preds = %283
%297 = load i32, i32* %14
%298 = add nsw i32 %297, 1
store i32 %298, i32* %14
br label %279
299: ; preds = %279
%300 = load double, double* %22
%301 = fcmp une double %300, 0.000000e+00
br i1 %301, label %302, label %486
302: ; preds = %299
%303 = load i32, i32* %15
store i32 %303, i32* %14
br label %304
304: ; preds = %340, %302
%305 = load i32, i32* %14
%306 = load i32, i32* %7
%307 = icmp slt i32 %305, %306
br i1 %307, label %308, label %343
308: ; preds = %304
%309 = load double, double* %22
%310 = load double**, double*** %6
%311 = load i32, i32* %12
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double*, double** %310, i64 %312
%314 = load double*, double** %313
%315 = load i32, i32* %14
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %314, i64 %316
%318 = load double, double* %317
%319 = fdiv double %318, %309
store double %319, double* %317
%320 = load double**, double*** %6
%321 = load i32, i32* %12
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double*, double** %320, i64 %322
%324 = load double*, double** %323
%325 = load i32, i32* %14
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %324, i64 %326
%328 = load double, double* %327
%329 = load double**, double*** %6
%330 = load i32, i32* %12
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double*, double** %329, i64 %331
%333 = load double*, double** %332
%334 = load i32, i32* %14
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds double, double* %333, i64 %335
%337 = load double, double* %336
%338 = load double, double* %21
%339 = call double @llvm.fmuladd.f64(double %328, double %337, double %338)
store double %339, double* %21
br label %340
340: ; preds = %308
%341 = load i32, i32* %14
%342 = add nsw i32 %341, 1
store i32 %342, i32* %14
br label %304
343: ; preds = %304
%344 = load double**, double*** %6
%345 = load i32, i32* %12
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds double*, double** %344, i64 %346
%348 = load double*, double** %347
%349 = load i32, i32* %15
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %348, i64 %350
%352 = load double, double* %351
store double %352, double* %18
%353 = load double, double* %21
%354 = call double @sqrt(double %353)
%355 = load double, double* %18
%356 = call double @llvm.copysign.f64(double %354, double %355)
%357 = fneg double %356
store double %357, double* %19
%358 = load double, double* %18
%359 = load double, double* %19
%360 = load double, double* %21
%361 = fneg double %360
%362 = call double @llvm.fmuladd.f64(double %358, double %359, double %361)
store double %362, double* %20
%363 = load double, double* %18
%364 = load double, double* %19
%365 = fsub double %363, %364
%366 = load double**, double*** %6
%367 = load i32, i32* %12
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double*, double** %366, i64 %368
%370 = load double*, double** %369
%371 = load i32, i32* %15
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %370, i64 %372
store double %365, double* %373
%374 = load i32, i32* %15
store i32 %374, i32* %14
br label %375
375: ; preds = %395, %343
%376 = load i32, i32* %14
%377 = load i32, i32* %7
%378 = icmp slt i32 %376, %377
br i1 %378, label %379, label %398
379: ; preds = %375
%380 = load double**, double*** %6
%381 = load i32, i32* %12
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double*, double** %380, i64 %382
%384 = load double*, double** %383
%385 = load i32, i32* %14
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
%388 = load double, double* %387
%389 = load double, double* %20
%390 = fdiv double %388, %389
%391 = load double*, double** %11
%392 = load i32, i32* %14
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %391, i64 %393
store double %390, double* %394
br label %395
395: ; preds = %379
%396 = load i32, i32* %14
%397 = add nsw i32 %396, 1
store i32 %397, i32* %14
br label %375
398: ; preds = %375
%399 = load i32, i32* %15
store i32 %399, i32* %13
br label %400
400: ; preds = %461, %398
%401 = load i32, i32* %13
%402 = load i32, i32* %8
%403 = icmp slt i32 %401, %402
br i1 %403, label %404, label %464
404: ; preds = %400
store double 0.000000e+00, double* %21
%405 = load i32, i32* %15
store i32 %405, i32* %14
br label %406
406: ; preds = %431, %404
%407 = load i32, i32* %14
%408 = load i32, i32* %7
%409 = icmp slt i32 %407, %408
br i1 %409, label %410, label %434
410: ; preds = %406
%411 = load double**, double*** %6
%412 = load i32, i32* %13
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double*, double** %411, i64 %413
%415 = load double*, double** %414
%416 = load i32, i32* %14
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double, double* %415, i64 %417
%419 = load double, double* %418
%420 = load double**, double*** %6
%421 = load i32, i32* %12
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double*, double** %420, i64 %422
%424 = load double*, double** %423
%425 = load i32, i32* %14
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds double, double* %424, i64 %426
%428 = load double, double* %427
%429 = load double, double* %21
%430 = call double @llvm.fmuladd.f64(double %419, double %428, double %429)
store double %430, double* %21
br label %431
431: ; preds = %410
%432 = load i32, i32* %14
%433 = add nsw i32 %432, 1
store i32 %433, i32* %14
br label %406
434: ; preds = %406
%435 = load i32, i32* %15
store i32 %435, i32* %14
br label %436
436: ; preds = %457, %434
%437 = load i32, i32* %14
%438 = load i32, i32* %7
%439 = icmp slt i32 %437, %438
br i1 %439, label %440, label %460
440: ; preds = %436
%441 = load double, double* %21
%442 = load double*, double** %11
%443 = load i32, i32* %14
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %442, i64 %444
%446 = load double, double* %445
%447 = load double**, double*** %6
%448 = load i32, i32* %13
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double*, double** %447, i64 %449
%451 = load double*, double** %450
%452 = load i32, i32* %14
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %451, i64 %453
%455 = load double, double* %454
%456 = call double @llvm.fmuladd.f64(double %441, double %446, double %455)
store double %456, double* %454
br label %457
457: ; preds = %440
%458 = load i32, i32* %14
%459 = add nsw i32 %458, 1
store i32 %459, i32* %14
br label %436
460: ; preds = %436
br label %461
461: ; preds = %460
%462 = load i32, i32* %13
%463 = add nsw i32 %462, 1
store i32 %463, i32* %13
br label %400
464: ; preds = %400
%465 = load i32, i32* %15
store i32 %465, i32* %14
br label %466
466: ; preds = %482, %464
%467 = load i32, i32* %14
%468 = load i32, i32* %7
%469 = icmp slt i32 %467, %468
br i1 %469, label %470, label %485
470: ; preds = %466
%471 = load double, double* %22
%472 = load double**, double*** %6
%473 = load i32, i32* %12
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double*, double** %472, i64 %474
%476 = load double*, double** %475
%477 = load i32, i32* %14
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %476, i64 %478
%480 = load double, double* %479
%481 = fmul double %480, %471
store double %481, double* %479
br label %482
482: ; preds = %470
%483 = load i32, i32* %14
%484 = add nsw i32 %483, 1
store i32 %484, i32* %14
br label %466
485: ; preds = %466
br label %486
486: ; preds = %485, %299
br label %487
487: ; preds = %486, %272, %261
%488 = load double*, double** %9
%489 = load i32, i32* %12
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %488, i64 %490
%492 = load double, double* %491
%493 = call double @llvm.fabs.f64(double %492)
%494 = load double*, double** %11
%495 = load i32, i32* %12
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %494, i64 %496
%498 = load double, double* %497
%499 = call double @llvm.fabs.f64(double %498)
%500 = fadd double %493, %499
store double %500, double* %23
%501 = load double, double* %16
%502 = load double, double* %23
%503 = fcmp ogt double %501, %502
br i1 %503, label %504, label %506
504: ; preds = %487
%505 = load double, double* %16
br label %508
506: ; preds = %487
%507 = load double, double* %23
br label %508
508: ; preds = %506, %504
%509 = phi double [ %505, %504 ], [ %507, %506 ]
store double %509, double* %16
br label %510
510: ; preds = %508
%511 = load i32, i32* %12
%512 = add nsw i32 %511, 1
store i32 %512, i32* %12
br label %46
513: ; preds = %46
%514 = load i32, i32* %7
%515 = sub nsw i32 %514, 1
store i32 %515, i32* %12
br label %516
516: ; preds = %679, %513
%517 = load i32, i32* %12
%518 = icmp sge i32 %517, 0
br i1 %518, label %519, label %682
519: ; preds = %516
%520 = load i32, i32* %12
%521 = load i32, i32* %7
%522 = sub nsw i32 %521, 1
%523 = icmp slt i32 %520, %522
br i1 %523, label %524, label %664
524: ; preds = %519
%525 = load double, double* %19
%526 = fcmp une double %525, 0.000000e+00
br i1 %526, label %527, label %637
527: ; preds = %524
%528 = load i32, i32* %15
store i32 %528, i32* %13
br label %529
529: ; preds = %563, %527
%530 = load i32, i32* %13
%531 = load i32, i32* %7
%532 = icmp slt i32 %530, %531
br i1 %532, label %533, label %566
533: ; preds = %529
%534 = load double**, double*** %6
%535 = load i32, i32* %12
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double*, double** %534, i64 %536
%538 = load double*, double** %537
%539 = load i32, i32* %13
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %538, i64 %540
%542 = load double, double* %541
%543 = load double**, double*** %6
%544 = load i32, i32* %12
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double*, double** %543, i64 %545
%547 = load double*, double** %546
%548 = load i32, i32* %15
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds double, double* %547, i64 %549
%551 = load double, double* %550
%552 = fdiv double %542, %551
%553 = load double, double* %19
%554 = fdiv double %552, %553
%555 = load double**, double*** %10
%556 = load i32, i32* %13
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds double*, double** %555, i64 %557
%559 = load double*, double** %558
%560 = load i32, i32* %12
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds double, double* %559, i64 %561
store double %554, double* %562
br label %563
563: ; preds = %533
%564 = load i32, i32* %13
%565 = add nsw i32 %564, 1
store i32 %565, i32* %13
br label %529
566: ; preds = %529
%567 = load i32, i32* %15
store i32 %567, i32* %13
br label %568
568: ; preds = %633, %566
%569 = load i32, i32* %13
%570 = load i32, i32* %7
%571 = icmp slt i32 %569, %570
br i1 %571, label %572, label %636
572: ; preds = %568
store double 0.000000e+00, double* %21
%573 = load i32, i32* %15
store i32 %573, i32* %14
br label %574
574: ; preds = %599, %572
%575 = load i32, i32* %14
%576 = load i32, i32* %7
%577 = icmp slt i32 %575, %576
br i1 %577, label %578, label %602
578: ; preds = %574
%579 = load double**, double*** %6
%580 = load i32, i32* %12
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double*, double** %579, i64 %581
%583 = load double*, double** %582
%584 = load i32, i32* %14
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %583, i64 %585
%587 = load double, double* %586
%588 = load double**, double*** %10
%589 = load i32, i32* %14
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds double*, double** %588, i64 %590
%592 = load double*, double** %591
%593 = load i32, i32* %13
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds double, double* %592, i64 %594
%596 = load double, double* %595
%597 = load double, double* %21
%598 = call double @llvm.fmuladd.f64(double %587, double %596, double %597)
store double %598, double* %21
br label %599
599: ; preds = %578
%600 = load i32, i32* %14
%601 = add nsw i32 %600, 1
store i32 %601, i32* %14
br label %574
602: ; preds = %574
%603 = load i32, i32* %15
store i32 %603, i32* %14
br label %604
604: ; preds = %629, %602
%605 = load i32, i32* %14
%606 = load i32, i32* %7
%607 = icmp slt i32 %605, %606
br i1 %607, label %608, label %632
608: ; preds = %604
%609 = load double, double* %21
%610 = load double**, double*** %10
%611 = load i32, i32* %14
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double*, double** %610, i64 %612
%614 = load double*, double** %613
%615 = load i32, i32* %12
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds double, double* %614, i64 %616
%618 = load double, double* %617
%619 = load double**, double*** %10
%620 = load i32, i32* %14
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double*, double** %619, i64 %621
%623 = load double*, double** %622
%624 = load i32, i32* %13
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double, double* %623, i64 %625
%627 = load double, double* %626
%628 = call double @llvm.fmuladd.f64(double %609, double %618, double %627)
store double %628, double* %626
br label %629
629: ; preds = %608
%630 = load i32, i32* %14
%631 = add nsw i32 %630, 1
store i32 %631, i32* %14
br label %604
632: ; preds = %604
br label %633
633: ; preds = %632
%634 = load i32, i32* %13
%635 = add nsw i32 %634, 1
store i32 %635, i32* %13
br label %568
636: ; preds = %568
br label %637
637: ; preds = %636, %524
%638 = load i32, i32* %15
store i32 %638, i32* %13
br label %639
639: ; preds = %660, %637
%640 = load i32, i32* %13
%641 = load i32, i32* %7
%642 = icmp slt i32 %640, %641
br i1 %642, label %643, label %663
643: ; preds = %639
%644 = load double**, double*** %10
%645 = load i32, i32* %12
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds double*, double** %644, i64 %646
%648 = load double*, double** %647
%649 = load i32, i32* %13
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %648, i64 %650
store double 0.000000e+00, double* %651
%652 = load double**, double*** %10
%653 = load i32, i32* %13
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double*, double** %652, i64 %654
%656 = load double*, double** %655
%657 = load i32, i32* %12
%658 = sext i32 %657 to i64
%659 = getelementptr inbounds double, double* %656, i64 %658
store double 0.000000e+00, double* %659
br label %660
660: ; preds = %643
%661 = load i32, i32* %13
%662 = add nsw i32 %661, 1
store i32 %662, i32* %13
br label %639
663: ; preds = %639
br label %664
664: ; preds = %663, %519
%665 = load double**, double*** %10
%666 = load i32, i32* %12
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds double*, double** %665, i64 %667
%669 = load double*, double** %668
%670 = load i32, i32* %12
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %669, i64 %671
store double 1.000000e+00, double* %672
%673 = load double*, double** %11
%674 = load i32, i32* %12
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double, double* %673, i64 %675
%677 = load double, double* %676
store double %677, double* %19
%678 = load i32, i32* %12
store i32 %678, i32* %15
br label %679
679: ; preds = %664
%680 = load i32, i32* %12
%681 = add nsw i32 %680, -1
store i32 %681, i32* %12
br label %516
682: ; preds = %516
%683 = load i32, i32* %8
%684 = load i32, i32* %7
%685 = icmp slt i32 %683, %684
br i1 %685, label %686, label %689
686: ; preds = %682
%687 = load i32, i32* %8
%688 = sub nsw i32 %687, 1
br label %692
689: ; preds = %682
%690 = load i32, i32* %7
%691 = sub nsw i32 %690, 1
br label %692
692: ; preds = %689, %686
%693 = phi i32 [ %688, %686 ], [ %691, %689 ]
store i32 %693, i32* %12
br label %694
694: ; preds = %866, %692
%695 = load i32, i32* %12
%696 = icmp sge i32 %695, 0
br i1 %696, label %697, label %869
697: ; preds = %694
%698 = load i32, i32* %12
%699 = add nsw i32 %698, 1
store i32 %699, i32* %15
%700 = load double*, double** %9
%701 = load i32, i32* %12
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds double, double* %700, i64 %702
%704 = load double, double* %703
store double %704, double* %19
%705 = load i32, i32* %12
%706 = load i32, i32* %7
%707 = sub nsw i32 %706, 1
%708 = icmp ne i32 %705, %707
br i1 %708, label %709, label %728
709: ; preds = %697
%710 = load i32, i32* %15
store i32 %710, i32* %13
br label %711
711: ; preds = %724, %709
%712 = load i32, i32* %13
%713 = load i32, i32* %7
%714 = icmp slt i32 %712, %713
br i1 %714, label %715, label %727
715: ; preds = %711
%716 = load double**, double*** %6
%717 = load i32, i32* %12
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds double*, double** %716, i64 %718
%720 = load double*, double** %719
%721 = load i32, i32* %13
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %720, i64 %722
store double 0.000000e+00, double* %723
br label %724
724: ; preds = %715
%725 = load i32, i32* %13
%726 = add nsw i32 %725, 1
store i32 %726, i32* %13
br label %711
727: ; preds = %711
br label %728
728: ; preds = %727, %697
%729 = load double, double* %19
%730 = fcmp une double %729, 0.000000e+00
br i1 %730, label %731, label %836
731: ; preds = %728
%732 = load i32, i32* %15
store i32 %732, i32* %13
br label %733
733: ; preds = %811, %731
%734 = load i32, i32* %13
%735 = load i32, i32* %7
%736 = icmp slt i32 %734, %735
br i1 %736, label %737, label %814
737: ; preds = %733
store double 0.000000e+00, double* %21
%738 = load i32, i32* %15
store i32 %738, i32* %14
br label %739
739: ; preds = %764, %737
%740 = load i32, i32* %14
%741 = load i32, i32* %8
%742 = icmp slt i32 %740, %741
br i1 %742, label %743, label %767
743: ; preds = %739
%744 = load double**, double*** %6
%745 = load i32, i32* %14
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double*, double** %744, i64 %746
%748 = load double*, double** %747
%749 = load i32, i32* %12
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds double, double* %748, i64 %750
%752 = load double, double* %751
%753 = load double**, double*** %6
%754 = load i32, i32* %14
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds double*, double** %753, i64 %755
%757 = load double*, double** %756
%758 = load i32, i32* %13
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %757, i64 %759
%761 = load double, double* %760
%762 = load double, double* %21
%763 = call double @llvm.fmuladd.f64(double %752, double %761, double %762)
store double %763, double* %21
br label %764
764: ; preds = %743
%765 = load i32, i32* %14
%766 = add nsw i32 %765, 1
store i32 %766, i32* %14
br label %739
767: ; preds = %739
%768 = load double, double* %21
%769 = load double**, double*** %6
%770 = load i32, i32* %12
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds double*, double** %769, i64 %771
%773 = load double*, double** %772
%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 = fdiv double %768, %777
%779 = load double, double* %19
%780 = fdiv double %778, %779
store double %780, double* %18
%781 = load i32, i32* %12
store i32 %781, i32* %14
br label %782
782: ; preds = %807, %767
%783 = load i32, i32* %14
%784 = load i32, i32* %8
%785 = icmp slt i32 %783, %784
br i1 %785, label %786, label %810
786: ; preds = %782
%787 = load double, double* %18
%788 = load double**, double*** %6
%789 = load i32, i32* %14
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds double*, double** %788, i64 %790
%792 = load double*, double** %791
%793 = load i32, i32* %12
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %792, i64 %794
%796 = load double, double* %795
%797 = load double**, double*** %6
%798 = load i32, i32* %14
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double*, double** %797, i64 %799
%801 = load double*, double** %800
%802 = load i32, i32* %13
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds double, double* %801, i64 %803
%805 = load double, double* %804
%806 = call double @llvm.fmuladd.f64(double %787, double %796, double %805)
store double %806, double* %804
br label %807
807: ; preds = %786
%808 = load i32, i32* %14
%809 = add nsw i32 %808, 1
store i32 %809, i32* %14
br label %782
810: ; preds = %782
br label %811
811: ; preds = %810
%812 = load i32, i32* %13
%813 = add nsw i32 %812, 1
store i32 %813, i32* %13
br label %733
814: ; preds = %733
%815 = load i32, i32* %12
store i32 %815, i32* %13
br label %816
816: ; preds = %832, %814
%817 = load i32, i32* %13
%818 = load i32, i32* %8
%819 = icmp slt i32 %817, %818
br i1 %819, label %820, label %835
820: ; preds = %816
%821 = load double, double* %19
%822 = load double**, double*** %6
%823 = load i32, i32* %13
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds double*, double** %822, i64 %824
%826 = load double*, double** %825
%827 = load i32, i32* %12
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds double, double* %826, i64 %828
%830 = load double, double* %829
%831 = fdiv double %830, %821
store double %831, double* %829
br label %832
832: ; preds = %820
%833 = load i32, i32* %13
%834 = add nsw i32 %833, 1
store i32 %834, i32* %13
br label %816
835: ; preds = %816
br label %855
836: ; preds = %728
%837 = load i32, i32* %12
store i32 %837, i32* %13
br label %838
838: ; preds = %851, %836
%839 = load i32, i32* %13
%840 = load i32, i32* %8
%841 = icmp slt i32 %839, %840
br i1 %841, label %842, label %854
842: ; preds = %838
%843 = load double**, double*** %6
%844 = load i32, i32* %13
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds double*, double** %843, i64 %845
%847 = load double*, double** %846
%848 = load i32, i32* %12
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds double, double* %847, i64 %849
store double 0.000000e+00, double* %850
br label %851
851: ; preds = %842
%852 = load i32, i32* %13
%853 = add nsw i32 %852, 1
store i32 %853, i32* %13
br label %838
854: ; preds = %838
br label %855
855: ; preds = %854, %835
%856 = load double**, double*** %6
%857 = load i32, i32* %12
%858 = sext i32 %857 to i64
%859 = getelementptr inbounds double*, double** %856, i64 %858
%860 = load double*, double** %859
%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 = fadd double %864, 1.000000e+00
store double %865, double* %863
br label %866
866: ; preds = %855
%867 = load i32, i32* %12
%868 = add nsw i32 %867, -1
store i32 %868, i32* %12
br label %694
869: ; preds = %694
%870 = load i32, i32* %7
%871 = sub nsw i32 %870, 1
store i32 %871, i32* %14
br label %872
872: ; preds = %1370, %869
%873 = load i32, i32* %14
%874 = icmp sge i32 %873, 0
br i1 %874, label %875, label %1373
875: ; preds = %872
%876 = load i32, i32* %14
%877 = sub nsw i32 %876, 1
store i32 %877, i32* %24
store i32 0, i32* %25
br label %878
878: ; preds = %875, %1368
store i32 1, i32* %26
store i32 -1, i32* %30
%879 = load i32, i32* %25
%880 = add nsw i32 %879, 1
store i32 %880, i32* %25
%881 = load i32, i32* %25
%882 = icmp sgt i32 %881, 30
br i1 %882, label %883, label %885
883: ; preds = %878
%884 = call i32 @csa_quit(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i32 30)
br label %885
885: ; preds = %883, %878
%886 = load i32, i32* %14
store i32 %886, i32* %15
br label %887
887: ; preds = %920, %885
%888 = load i32, i32* %15
%889 = icmp sge i32 %888, 0
br i1 %889, label %890, label %923
890: ; preds = %887
%891 = load double*, double** %11
%892 = load i32, i32* %15
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds double, double* %891, i64 %893
%895 = load double, double* %894
%896 = call double @llvm.fabs.f64(double %895)
%897 = load double, double* %16
%898 = fadd double %896, %897
store double %898, double* %31
%899 = load double, double* %31
%900 = load double, double* %16
%901 = fcmp oeq double %899, %900
br i1 %901, label %902, label %903
902: ; preds = %890
store i32 0, i32* %26
br label %923
903: ; preds = %890
%904 = load i32, i32* %15
%905 = sub nsw i32 %904, 1
store i32 %905, i32* %30
%906 = load double*, double** %9
%907 = load i32, i32* %15
%908 = sub nsw i32 %907, 1
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds double, double* %906, i64 %909
%911 = load double, double* %910
%912 = call double @llvm.fabs.f64(double %911)
%913 = load double, double* %16
%914 = fadd double %912, %913
store double %914, double* %31
%915 = load double, double* %31
%916 = load double, double* %16
%917 = fcmp oeq double %915, %916
br i1 %917, label %918, label %919
918: ; preds = %903
br label %923
919: ; preds = %903
br label %920
920: ; preds = %919
%921 = load i32, i32* %15
%922 = add nsw i32 %921, -1
store i32 %922, i32* %15
br label %887
923: ; preds = %918, %902, %887
%924 = load i32, i32* %26
%925 = icmp ne i32 %924, 0
br i1 %925, label %926, label %1041
926: ; preds = %923
store double 0.000000e+00, double* %17
store double 1.000000e+00, double* %21
%927 = load i32, i32* %15
store i32 %927, i32* %12
br label %928
928: ; preds = %1037, %926
%929 = load i32, i32* %12
%930 = load i32, i32* %14
%931 = icmp sle i32 %929, %930
br i1 %931, label %932, label %1040
932: ; preds = %928
%933 = load double, double* %21
%934 = load double*, double** %11
%935 = load i32, i32* %12
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds double, double* %934, i64 %936
%938 = load double, double* %937
%939 = fmul double %933, %938
store double %939, double* %18
%940 = load double, double* %17
%941 = load double*, double** %11
%942 = load i32, i32* %12
%943 = sext i32 %942 to i64
%944 = getelementptr inbounds double, double* %941, i64 %943
%945 = load double, double* %944
%946 = fmul double %940, %945
%947 = load double*, double** %11
%948 = load i32, i32* %12
%949 = sext i32 %948 to i64
%950 = getelementptr inbounds double, double* %947, i64 %949
store double %946, double* %950
%951 = load double, double* %18
%952 = call double @llvm.fabs.f64(double %951)
%953 = load double, double* %16
%954 = fadd double %952, %953
%955 = load double, double* %16
%956 = fcmp oeq double %954, %955
br i1 %956, label %957, label %958
957: ; preds = %932
br label %1040
958: ; preds = %932
%959 = load double*, double** %9
%960 = load i32, i32* %12
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds double, double* %959, i64 %961
%963 = load double, double* %962
store double %963, double* %19
%964 = load double, double* %18
%965 = load double, double* %19
%966 = call double @hypot(double %964, double %965)
store double %966, double* %20
%967 = load double, double* %20
%968 = load double*, double** %9
%969 = load i32, i32* %12
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds double, double* %968, i64 %970
store double %967, double* %971
%972 = load double, double* %20
%973 = fdiv double 1.000000e+00, %972
store double %973, double* %20
%974 = load double, double* %19
%975 = load double, double* %20
%976 = fmul double %974, %975
store double %976, double* %17
%977 = load double, double* %18
%978 = fneg double %977
%979 = load double, double* %20
%980 = fmul double %978, %979
store double %980, double* %21
store i32 0, i32* %13
br label %981
981: ; preds = %1033, %958
%982 = load i32, i32* %13
%983 = load i32, i32* %8
%984 = icmp slt i32 %982, %983
br i1 %984, label %985, label %1036
985: ; preds = %981
%986 = load double**, double*** %6
%987 = load i32, i32* %13
%988 = sext i32 %987 to i64
%989 = getelementptr inbounds double*, double** %986, i64 %988
%990 = load double*, double** %989
%991 = load i32, i32* %30
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds double, double* %990, i64 %992
%994 = load double, double* %993
store double %994, double* %28
%995 = load double**, double*** %6
%996 = load i32, i32* %13
%997 = sext i32 %996 to i64
%998 = getelementptr inbounds double*, double** %995, i64 %997
%999 = load double*, double** %998
%1000 = load i32, i32* %12
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds double, double* %999, i64 %1001
%1003 = load double, double* %1002
store double %1003, double* %29
%1004 = load double, double* %28
%1005 = load double, double* %17
%1006 = load double, double* %29
%1007 = load double, double* %21
%1008 = fmul double %1006, %1007
%1009 = call double @llvm.fmuladd.f64(double %1004, double %1005, double %1008)
%1010 = load double**, double*** %6
%1011 = load i32, i32* %13
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double*, double** %1010, i64 %1012
%1014 = load double*, double** %1013
%1015 = load i32, i32* %30
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double, double* %1014, i64 %1016
store double %1009, double* %1017
%1018 = load double, double* %29
%1019 = load double, double* %17
%1020 = load double, double* %28
%1021 = load double, double* %21
%1022 = fmul double %1020, %1021
%1023 = fneg double %1022
%1024 = call double @llvm.fmuladd.f64(double %1018, double %1019, double %1023)
%1025 = load double**, double*** %6
%1026 = load i32, i32* %13
%1027 = sext i32 %1026 to i64
%1028 = getelementptr inbounds double*, double** %1025, i64 %1027
%1029 = load double*, double** %1028
%1030 = load i32, i32* %12
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds double, double* %1029, i64 %1031
store double %1024, double* %1032
br label %1033
1033: ; preds = %985
%1034 = load i32, i32* %13
%1035 = add nsw i32 %1034, 1
store i32 %1035, i32* %13
br label %981
1036: ; preds = %981
br label %1037
1037: ; preds = %1036
%1038 = load i32, i32* %12
%1039 = add nsw i32 %1038, 1
store i32 %1039, i32* %12
br label %928
1040: ; preds = %957, %928
br label %1041
1041: ; preds = %1040, %923
%1042 = load double*, double** %9
%1043 = load i32, i32* %14
%1044 = sext i32 %1043 to i64
%1045 = getelementptr inbounds double, double* %1042, i64 %1044
%1046 = load double, double* %1045
store double %1046, double* %29
%1047 = load i32, i32* %15
%1048 = load i32, i32* %14
%1049 = icmp ne i32 %1047, %1048
br i1 %1049, label %1050, label %1330
1050: ; preds = %1041
%1051 = load double*, double** %9
%1052 = load i32, i32* %15
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds double, double* %1051, i64 %1053
%1055 = load double, double* %1054
store double %1055, double* %27
%1056 = load double*, double** %9
%1057 = load i32, i32* %24
%1058 = sext i32 %1057 to i64
%1059 = getelementptr inbounds double, double* %1056, i64 %1058
%1060 = load double, double* %1059
store double %1060, double* %28
%1061 = load double*, double** %11
%1062 = load i32, i32* %24
%1063 = sext i32 %1062 to i64
%1064 = getelementptr inbounds double, double* %1061, i64 %1063
%1065 = load double, double* %1064
store double %1065, double* %19
%1066 = load double*, double** %11
%1067 = load i32, i32* %14
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds double, double* %1066, i64 %1068
%1070 = load double, double* %1069
store double %1070, double* %20
%1071 = load double, double* %19
%1072 = load double, double* %29
%1073 = fadd double %1071, %1072
%1074 = load double, double* %20
%1075 = fdiv double %1073, %1074
%1076 = load double, double* %19
%1077 = load double, double* %29
%1078 = fsub double %1076, %1077
%1079 = load double, double* %28
%1080 = fdiv double %1078, %1079
%1081 = load double, double* %28
%1082 = load double, double* %20
%1083 = fdiv double %1081, %1082
%1084 = call double @llvm.fmuladd.f64(double %1075, double %1080, double %1083)
%1085 = load double, double* %20
%1086 = load double, double* %28
%1087 = fdiv double %1085, %1086
%1088 = fsub double %1084, %1087
%1089 = fmul double 5.000000e-01, %1088
store double %1089, double* %18
%1090 = load double, double* %18
%1091 = call double @hypot(double %1090, double 1.000000e+00)
store double %1091, double* %19
%1092 = load double, double* %27
%1093 = load double, double* %29
%1094 = load double, double* %27
%1095 = fdiv double %1093, %1094
%1096 = load double, double* %29
%1097 = fneg double %1095
%1098 = call double @llvm.fmuladd.f64(double %1097, double %1096, double %1092)
%1099 = load double, double* %20
%1100 = load double, double* %27
%1101 = fdiv double %1099, %1100
%1102 = load double, double* %28
%1103 = load double, double* %18
%1104 = load double, double* %19
%1105 = load double, double* %18
%1106 = call double @llvm.copysign.f64(double %1104, double %1105)
%1107 = fadd double %1103, %1106
%1108 = fdiv double %1102, %1107
%1109 = load double, double* %20
%1110 = fsub double %1108, %1109
%1111 = call double @llvm.fmuladd.f64(double %1101, double %1110, double %1098)
store double %1111, double* %18
store double 1.000000e+00, double* %17
store double 1.000000e+00, double* %21
%1112 = load i32, i32* %15
store i32 %1112, i32* %32
br label %1113
1113: ; preds = %1312, %1050
%1114 = load i32, i32* %32
%1115 = load i32, i32* %14
%1116 = icmp slt i32 %1114, %1115
br i1 %1116, label %1117, label %1315
1117: ; preds = %1113
%1118 = load i32, i32* %32
%1119 = add nsw i32 %1118, 1
store i32 %1119, i32* %12
%1120 = load double*, double** %11
%1121 = load i32, i32* %12
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds double, double* %1120, i64 %1122
%1124 = load double, double* %1123
store double %1124, double* %19
%1125 = load double*, double** %9
%1126 = load i32, i32* %12
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds double, double* %1125, i64 %1127
%1129 = load double, double* %1128
store double %1129, double* %28
%1130 = load double, double* %21
%1131 = load double, double* %19
%1132 = fmul double %1130, %1131
store double %1132, double* %20
%1133 = load double, double* %17
%1134 = load double, double* %19
%1135 = fmul double %1133, %1134
store double %1135, double* %19
%1136 = load double, double* %18
%1137 = load double, double* %20
%1138 = call double @hypot(double %1136, double %1137)
store double %1138, double* %29
%1139 = load double, double* %29
%1140 = load double*, double** %11
%1141 = load i32, i32* %32
%1142 = sext i32 %1141 to i64
%1143 = getelementptr inbounds double, double* %1140, i64 %1142
store double %1139, double* %1143
%1144 = load double, double* %18
%1145 = load double, double* %29
%1146 = fdiv double %1144, %1145
store double %1146, double* %17
%1147 = load double, double* %20
%1148 = load double, double* %29
%1149 = fdiv double %1147, %1148
store double %1149, double* %21
%1150 = load double, double* %27
%1151 = load double, double* %17
%1152 = load double, double* %19
%1153 = load double, double* %21
%1154 = fmul double %1152, %1153
%1155 = call double @llvm.fmuladd.f64(double %1150, double %1151, double %1154)
store double %1155, double* %18
%1156 = load double, double* %19
%1157 = load double, double* %17
%1158 = load double, double* %27
%1159 = load double, double* %21
%1160 = fmul double %1158, %1159
%1161 = fneg double %1160
%1162 = call double @llvm.fmuladd.f64(double %1156, double %1157, double %1161)
store double %1162, double* %19
%1163 = load double, double* %28
%1164 = load double, double* %21
%1165 = fmul double %1163, %1164
store double %1165, double* %20
%1166 = load double, double* %17
%1167 = load double, double* %28
%1168 = fmul double %1167, %1166
store double %1168, double* %28
store i32 0, i32* %13
br label %1169
1169: ; preds = %1221, %1117
%1170 = load i32, i32* %13
%1171 = load i32, i32* %7
%1172 = icmp slt i32 %1170, %1171
br i1 %1172, label %1173, label %1224
1173: ; preds = %1169
%1174 = load double**, double*** %10
%1175 = load i32, i32* %13
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds double*, double** %1174, i64 %1176
%1178 = load double*, double** %1177
%1179 = load i32, i32* %32
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds double, double* %1178, i64 %1180
%1182 = load double, double* %1181
store double %1182, double* %27
%1183 = load double**, double*** %10
%1184 = load i32, i32* %13
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds double*, double** %1183, i64 %1185
%1187 = load double*, double** %1186
%1188 = load i32, i32* %12
%1189 = sext i32 %1188 to i64
%1190 = getelementptr inbounds double, double* %1187, i64 %1189
%1191 = load double, double* %1190
store double %1191, double* %29
%1192 = load double, double* %27
%1193 = load double, double* %17
%1194 = load double, double* %29
%1195 = load double, double* %21
%1196 = fmul double %1194, %1195
%1197 = call double @llvm.fmuladd.f64(double %1192, double %1193, double %1196)
%1198 = load double**, double*** %10
%1199 = load i32, i32* %13
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds double*, double** %1198, i64 %1200
%1202 = load double*, double** %1201
%1203 = load i32, i32* %32
%1204 = sext i32 %1203 to i64
%1205 = getelementptr inbounds double, double* %1202, i64 %1204
store double %1197, double* %1205
%1206 = load double, double* %29
%1207 = load double, double* %17
%1208 = load double, double* %27
%1209 = load double, double* %21
%1210 = fmul double %1208, %1209
%1211 = fneg double %1210
%1212 = call double @llvm.fmuladd.f64(double %1206, double %1207, double %1211)
%1213 = load double**, double*** %10
%1214 = load i32, i32* %13
%1215 = sext i32 %1214 to i64
%1216 = getelementptr inbounds double*, double** %1213, i64 %1215
%1217 = load double*, double** %1216
%1218 = load i32, i32* %12
%1219 = sext i32 %1218 to i64
%1220 = getelementptr inbounds double, double* %1217, i64 %1219
store double %1212, double* %1220
br label %1221
1221: ; preds = %1173
%1222 = load i32, i32* %13
%1223 = add nsw i32 %1222, 1
store i32 %1223, i32* %13
br label %1169
1224: ; preds = %1169
%1225 = load double, double* %18
%1226 = load double, double* %20
%1227 = call double @hypot(double %1225, double %1226)
store double %1227, double* %29
%1228 = load double, double* %29
%1229 = load double*, double** %9
%1230 = load i32, i32* %32
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds double, double* %1229, i64 %1231
store double %1228, double* %1232
%1233 = load double, double* %29
%1234 = fcmp une double %1233, 0.000000e+00
br i1 %1234, label %1235, label %1242
1235: ; preds = %1224
%1236 = load double, double* %18
%1237 = load double, double* %29
%1238 = fdiv double %1236, %1237
store double %1238, double* %17
%1239 = load double, double* %20
%1240 = load double, double* %29
%1241 = fdiv double %1239, %1240
store double %1241, double* %21
br label %1242
1242: ; preds = %1235, %1224
%1243 = load double, double* %17
%1244 = load double, double* %19
%1245 = load double, double* %21
%1246 = load double, double* %28
%1247 = fmul double %1245, %1246
%1248 = call double @llvm.fmuladd.f64(double %1243, double %1244, double %1247)
store double %1248, double* %18
%1249 = load double, double* %17
%1250 = load double, double* %28
%1251 = load double, double* %21
%1252 = load double, double* %19
%1253 = fmul double %1251, %1252
%1254 = fneg double %1253
%1255 = call double @llvm.fmuladd.f64(double %1249, double %1250, double %1254)
store double %1255, double* %27
store i32 0, i32* %13
br label %1256
1256: ; preds = %1308, %1242
%1257 = load i32, i32* %13
%1258 = load i32, i32* %8
%1259 = icmp slt i32 %1257, %1258
br i1 %1259, label %1260, label %1311
1260: ; preds = %1256
%1261 = load double**, double*** %6
%1262 = load i32, i32* %13
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds double*, double** %1261, i64 %1263
%1265 = load double*, double** %1264
%1266 = load i32, i32* %32
%1267 = sext i32 %1266 to i64
%1268 = getelementptr inbounds double, double* %1265, i64 %1267
%1269 = load double, double* %1268
store double %1269, double* %28
%1270 = load double**, double*** %6
%1271 = load i32, i32* %13
%1272 = sext i32 %1271 to i64
%1273 = getelementptr inbounds double*, double** %1270, i64 %1272
%1274 = load double*, double** %1273
%1275 = load i32, i32* %12
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds double, double* %1274, i64 %1276
%1278 = load double, double* %1277
store double %1278, double* %29
%1279 = load double, double* %28
%1280 = load double, double* %17
%1281 = load double, double* %29
%1282 = load double, double* %21
%1283 = fmul double %1281, %1282
%1284 = call double @llvm.fmuladd.f64(double %1279, double %1280, double %1283)
%1285 = load double**, double*** %6
%1286 = load i32, i32* %13
%1287 = sext i32 %1286 to i64
%1288 = getelementptr inbounds double*, double** %1285, i64 %1287
%1289 = load double*, double** %1288
%1290 = load i32, i32* %32
%1291 = sext i32 %1290 to i64
%1292 = getelementptr inbounds double, double* %1289, i64 %1291
store double %1284, double* %1292
%1293 = load double, double* %29
%1294 = load double, double* %17
%1295 = load double, double* %28
%1296 = load double, double* %21
%1297 = fmul double %1295, %1296
%1298 = fneg double %1297
%1299 = call double @llvm.fmuladd.f64(double %1293, double %1294, double %1298)
%1300 = load double**, double*** %6
%1301 = load i32, i32* %13
%1302 = sext i32 %1301 to i64
%1303 = getelementptr inbounds double*, double** %1300, i64 %1302
%1304 = load double*, double** %1303
%1305 = load i32, i32* %12
%1306 = sext i32 %1305 to i64
%1307 = getelementptr inbounds double, double* %1304, i64 %1306
store double %1299, double* %1307
br label %1308
1308: ; preds = %1260
%1309 = load i32, i32* %13
%1310 = add nsw i32 %1309, 1
store i32 %1310, i32* %13
br label %1256
1311: ; preds = %1256
br label %1312
1312: ; preds = %1311
%1313 = load i32, i32* %32
%1314 = add nsw i32 %1313, 1
store i32 %1314, i32* %32
br label %1113
1315: ; preds = %1113
%1316 = load double*, double** %11
%1317 = load i32, i32* %15
%1318 = sext i32 %1317 to i64
%1319 = getelementptr inbounds double, double* %1316, i64 %1318
store double 0.000000e+00, double* %1319
%1320 = load double, double* %18
%1321 = load double*, double** %11
%1322 = load i32, i32* %14
%1323 = sext i32 %1322 to i64
%1324 = getelementptr inbounds double, double* %1321, i64 %1323
store double %1320, double* %1324
%1325 = load double, double* %27
%1326 = load double*, double** %9
%1327 = load i32, i32* %14
%1328 = sext i32 %1327 to i64
%1329 = getelementptr inbounds double, double* %1326, i64 %1328
store double %1325, double* %1329
br label %1368
1330: ; preds = %1041
%1331 = load double, double* %29
%1332 = fcmp olt double %1331, 0.000000e+00
br i1 %1332, label %1333, label %1367
1333: ; preds = %1330
%1334 = load double, double* %29
%1335 = fneg double %1334
%1336 = load double*, double** %9
%1337 = load i32, i32* %14
%1338 = sext i32 %1337 to i64
%1339 = getelementptr inbounds double, double* %1336, i64 %1338
store double %1335, double* %1339
store i32 0, i32* %13
br label %1340
1340: ; preds = %1363, %1333
%1341 = load i32, i32* %13
%1342 = load i32, i32* %7
%1343 = icmp slt i32 %1341, %1342
br i1 %1343, label %1344, label %1366
1344: ; preds = %1340
%1345 = load double**, double*** %10
%1346 = load i32, i32* %13
%1347 = sext i32 %1346 to i64
%1348 = getelementptr inbounds double*, double** %1345, i64 %1347
%1349 = load double*, double** %1348
%1350 = load i32, i32* %14
%1351 = sext i32 %1350 to i64
%1352 = getelementptr inbounds double, double* %1349, i64 %1351
%1353 = load double, double* %1352
%1354 = fneg double %1353
%1355 = load double**, double*** %10
%1356 = load i32, i32* %13
%1357 = sext i32 %1356 to i64
%1358 = getelementptr inbounds double*, double** %1355, i64 %1357
%1359 = load double*, double** %1358
%1360 = load i32, i32* %14
%1361 = sext i32 %1360 to i64
%1362 = getelementptr inbounds double, double* %1359, i64 %1361
store double %1354, double* %1362
br label %1363
1363: ; preds = %1344
%1364 = load i32, i32* %13
%1365 = add nsw i32 %1364, 1
store i32 %1365, i32* %13
br label %1340
1366: ; preds = %1340
br label %1367
1367: ; preds = %1366, %1330
br label %1369
1368: ; preds = %1315
br label %878
1369: ; preds = %1367
br label %1370
1370: ; preds = %1369
%1371 = load i32, i32* %14
%1372 = add nsw i32 %1371, -1
store i32 %1372, i32* %14
br label %872
1373: ; preds = %872
%1374 = load double*, double** %11
%1375 = call i32 @free(double* %1374)
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 = sext i32 %1 to i64
%12 = shl nsw i64 %11, 3
%13 = tail call double* @malloc(i64 %12)
%14 = add i32 %1, -1
br i1 %7, label %15, label %665
15: ; preds = %5
%16 = sext i32 %2 to i64
%17 = zext i32 %14 to i64
%18 = zext i32 %1 to i64
%19 = zext i32 %2 to i64
%20 = add nsw i64 %18, -2
br label %21
21: ; preds = %15, %456
%22 = phi i64 [ 1, %15 ], [ %467, %456 ]
%23 = phi i64 [ 0, %15 ], [ %51, %456 ]
%24 = phi double [ 0.000000e+00, %15 ], [ %459, %456 ]
%25 = phi double [ 0.000000e+00, %15 ], [ %458, %456 ]
%26 = phi double [ 0.000000e+00, %15 ], [ %466, %456 ]
%27 = xor i64 %23, -1
%28 = add nsw i64 %27, %18
%29 = add i64 %28, -4
%30 = lshr i64 %29, 2
%31 = add nuw nsw i64 %30, 1
%32 = xor i64 %23, -1
%33 = add nsw i64 %32, %18
%34 = add i64 %33, -4
%35 = lshr i64 %34, 2
%36 = add nuw nsw i64 %35, 1
%37 = xor i64 %23, -1
%38 = add nsw i64 %37, %18
%39 = sub i64 %20, %23
%40 = xor i64 %23, -1
%41 = add nsw i64 %40, %18
%42 = add i64 %41, -2
%43 = lshr i64 %42, 1
%44 = add nuw i64 %43, 1
%45 = xor i64 %23, -1
%46 = add nsw i64 %45, %18
%47 = xor i64 %23, -1
%48 = add nsw i64 %47, %18
%49 = xor i64 %23, -1
%50 = add nsw i64 %49, %18
%51 = add nuw nsw i64 %23, 1
%52 = fmul double %25, %24
%53 = getelementptr inbounds double, double* %13, i64 %23
store double %52, double* %53
%54 = icmp slt i64 %23, %16
br i1 %54, label %57, label %55
55: ; preds = %21
%56 = getelementptr inbounds double, double* %3, i64 %23
store double 0.000000e+00, double* %56
br label %456
57: ; preds = %21, %57
%58 = phi i64 [ %66, %57 ], [ %23, %21 ]
%59 = phi double [ %65, %57 ], [ 0.000000e+00, %21 ]
%60 = getelementptr inbounds double*, double** %0, i64 %58
%61 = load double*, double** %60
%62 = getelementptr inbounds double, double* %61, i64 %23
%63 = load double, double* %62
%64 = tail call double @llvm.fabs.f64(double %63)
%65 = fadd double %59, %64
%66 = add nuw nsw i64 %58, 1
%67 = icmp eq i64 %66, %19
br i1 %67, label %68, label %57
68: ; preds = %57
%69 = fcmp une double %65, 0.000000e+00
br i1 %69, label %70, label %137
70: ; preds = %68, %70
%71 = phi i64 [ %79, %70 ], [ %23, %68 ]
%72 = phi double [ %78, %70 ], [ 0.000000e+00, %68 ]
%73 = getelementptr inbounds double*, double** %0, i64 %71
%74 = load double*, double** %73
%75 = getelementptr inbounds double, double* %74, i64 %23
%76 = load double, double* %75
%77 = fdiv double %76, %65
store double %77, double* %75
%78 = tail call double @llvm.fmuladd.f64(double %77, double %77, double %72)
%79 = add nuw nsw i64 %71, 1
%80 = icmp eq i64 %79, %19
br i1 %80, label %81, label %70
81: ; preds = %70
%82 = getelementptr inbounds double*, double** %0, i64 %23
%83 = load double*, double** %82
%84 = getelementptr inbounds double, double* %83, i64 %23
%85 = load double, double* %84
%86 = tail call double @sqrt(double %78)
%87 = tail call double @llvm.copysign.f64(double %86, double %85)
%88 = fneg double %87
%89 = fneg double %78
%90 = tail call double @llvm.fmuladd.f64(double %85, double %88, double %89)
%91 = fadd double %85, %87
%92 = load double*, double** %82
%93 = getelementptr inbounds double, double* %92, i64 %23
store double %91, double* %93
%94 = icmp ult i64 %23, %17
%95 = icmp slt i64 %51, %11
%96 = select i1 %94, i1 %95, i1 false
br i1 %96, label %97, label %127
97: ; preds = %81, %124
%98 = phi i64 [ %125, %124 ], [ %22, %81 ]
br label %99
99: ; preds = %97, %99
%100 = phi i64 [ %23, %97 ], [ %109, %99 ]
%101 = phi double [ 0.000000e+00, %97 ], [ %108, %99 ]
%102 = getelementptr inbounds double*, double** %0, i64 %100
%103 = load double*, double** %102
%104 = getelementptr inbounds double, double* %103, i64 %23
%105 = load double, double* %104
%106 = getelementptr inbounds double, double* %103, i64 %98
%107 = load double, double* %106
%108 = tail call double @llvm.fmuladd.f64(double %105, double %107, double %101)
%109 = add nuw nsw i64 %100, 1
%110 = icmp eq i64 %109, %19
br i1 %110, label %111, label %99
111: ; preds = %99
%112 = fdiv double %108, %90
br label %113
113: ; preds = %111, %113
%114 = phi i64 [ %23, %111 ], [ %122, %113 ]
%115 = getelementptr inbounds double*, double** %0, i64 %114
%116 = load double*, double** %115
%117 = getelementptr inbounds double, double* %116, i64 %23
%118 = load double, double* %117
%119 = getelementptr inbounds double, double* %116, i64 %98
%120 = load double, double* %119
%121 = tail call double @llvm.fmuladd.f64(double %112, double %118, double %120)
store double %121, double* %119
%122 = add nuw nsw i64 %114, 1
%123 = icmp eq i64 %122, %19
br i1 %123, label %124, label %113
124: ; preds = %113
%125 = add nuw nsw i64 %98, 1
%126 = icmp eq i64 %125, %18
br i1 %126, label %127, label %97
127: ; preds = %124, %81
br label %128
128: ; preds = %127, %128
%129 = phi i64 [ %135, %128 ], [ %23, %127 ]
%130 = getelementptr inbounds double*, double** %0, i64 %129
%131 = load double*, double** %130
%132 = getelementptr inbounds double, double* %131, i64 %23
%133 = load double, double* %132
%134 = fmul double %65, %133
store double %134, double* %132
%135 = add nuw nsw i64 %129, 1
%136 = icmp eq i64 %135, %19
br i1 %136, label %137, label %128
137: ; preds = %128, %68
%138 = phi double [ 0.000000e+00, %68 ], [ %88, %128 ]
%139 = fmul double %65, %138
%140 = getelementptr inbounds double, double* %3, i64 %23
store double %139, double* %140
%141 = icmp ult i64 %23, %17
br i1 %141, label %142, label %456
142: ; preds = %137
%143 = icmp slt i64 %51, %11
br i1 %143, label %144, label %456
144: ; preds = %142
%145 = getelementptr inbounds double*, double** %0, i64 %23
%146 = load double*, double** %145
br label %147
147: ; preds = %144, %147
%148 = phi i64 [ %22, %144 ], [ %154, %147 ]
%149 = phi double [ 0.000000e+00, %144 ], [ %153, %147 ]
%150 = getelementptr inbounds double, double* %146, i64 %148
%151 = load double, double* %150
%152 = tail call double @llvm.fabs.f64(double %151)
%153 = fadd double %149, %152
%154 = add nuw nsw i64 %148, 1
%155 = icmp eq i64 %154, %18
br i1 %155, label %156, label %147
156: ; preds = %147
%157 = fcmp une double %153, 0.000000e+00
br i1 %157, label %158, label %456
158: ; preds = %156
%159 = getelementptr inbounds double*, double** %0, i64 %23
%160 = load double*, double** %159
br i1 %143, label %161, label %170
161: ; preds = %158, %161
%162 = phi i64 [ %168, %161 ], [ %22, %158 ]
%163 = phi double [ %167, %161 ], [ 0.000000e+00, %158 ]
%164 = getelementptr inbounds double, double* %160, i64 %162
%165 = load double, double* %164
%166 = fdiv double %165, %153
store double %166, double* %164
%167 = tail call double @llvm.fmuladd.f64(double %166, double %166, double %163)
%168 = add nuw nsw i64 %162, 1
%169 = icmp eq i64 %168, %18
br i1 %169, label %170, label %161
170: ; preds = %161, %158
%171 = phi double [ 0.000000e+00, %158 ], [ %167, %161 ]
%172 = getelementptr inbounds double*, double** %0, i64 %23
%173 = getelementptr inbounds double, double* %160, i64 %51
%174 = load double, double* %173
%175 = tail call double @sqrt(double %171)
%176 = tail call double @llvm.copysign.f64(double %175, double %174)
%177 = fneg double %176
%178 = fneg double %171
%179 = tail call double @llvm.fmuladd.f64(double %174, double %177, double %178)
%180 = fadd double %174, %176
%181 = load double*, double** %172
%182 = getelementptr inbounds double, double* %181, i64 %51
store double %180, double* %182
br i1 %143, label %183, label %230
183: ; preds = %170
%184 = icmp ult i64 %46, 2
br i1 %184, label %228, label %185
185: ; preds = %183
%186 = and i64 %46, -2
%187 = add i64 %22, %186
%188 = insertelement <2 x double> poison, double %179, i64 0
%189 = shufflevector <2 x double> %188, <2 x double> poison, <2 x i32> zeroinitializer
%190 = and i64 %44, 1
%191 = icmp ult i64 %42, 2
br i1 %191, label %215, label %192
192: ; preds = %185
%193 = and i64 %44, -2
br label %194
194: ; preds = %194, %192
%195 = phi i64 [ 0, %192 ], [ %212, %194 ]
%196 = phi i64 [ 0, %192 ], [ %213, %194 ]
%197 = add i64 %22, %195
%198 = getelementptr inbounds double, double* %181, i64 %197
%199 = bitcast double* %198 to <2 x double>*
%200 = load <2 x double>, <2 x double>* %199
%201 = fdiv <2 x double> %200, %189
%202 = getelementptr inbounds double, double* %13, i64 %197
%203 = bitcast double* %202 to <2 x double>*
store <2 x double> %201, <2 x double>* %203
%204 = or i64 %195, 2
%205 = add i64 %22, %204
%206 = getelementptr inbounds double, double* %181, i64 %205
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = fdiv <2 x double> %208, %189
%210 = getelementptr inbounds double, double* %13, i64 %205
%211 = bitcast double* %210 to <2 x double>*
store <2 x double> %209, <2 x double>* %211
%212 = add nuw i64 %195, 4
%213 = add nuw i64 %196, 2
%214 = icmp eq i64 %213, %193
br i1 %214, label %215, label %194
215: ; preds = %194, %185
%216 = phi i64 [ 0, %185 ], [ %212, %194 ]
%217 = icmp eq i64 %190, 0
br i1 %217, label %226, label %218
218: ; preds = %215
%219 = add i64 %22, %216
%220 = getelementptr inbounds double, double* %181, i64 %219
%221 = bitcast double* %220 to <2 x double>*
%222 = load <2 x double>, <2 x double>* %221
%223 = fdiv <2 x double> %222, %189
%224 = getelementptr inbounds double, double* %13, i64 %219
%225 = bitcast double* %224 to <2 x double>*
store <2 x double> %223, <2 x double>* %225
br label %226
226: ; preds = %215, %218
%227 = icmp eq i64 %46, %186
br i1 %227, label %230, label %228
228: ; preds = %183, %226
%229 = phi i64 [ %22, %183 ], [ %187, %226 ]
br label %244
230: ; preds = %244, %226, %170
%231 = icmp slt i64 %51, %16
br i1 %231, label %232, label %252
232: ; preds = %230
%233 = and i64 %38, 3
%234 = icmp eq i64 %233, 0
%235 = icmp ult i64 %39, 3
%236 = icmp ult i64 %48, 4
%237 = and i64 %48, -4
%238 = add i64 %22, %237
%239 = and i64 %36, 1
%240 = icmp ult i64 %34, 4
%241 = and i64 %36, 9223372036854775806
%242 = icmp eq i64 %239, 0
%243 = icmp eq i64 %48, %237
br label %314
244: ; preds = %228, %244
%245 = phi i64 [ %250, %244 ], [ %229, %228 ]
%246 = getelementptr inbounds double, double* %181, i64 %245
%247 = load double, double* %246
%248 = fdiv double %247, %179
%249 = getelementptr inbounds double, double* %13, i64 %245
store double %248, double* %249
%250 = add nuw nsw i64 %245, 1
%251 = icmp eq i64 %250, %18
br i1 %251, label %230, label %244
252: ; preds = %446, %230
br i1 %143, label %253, label %456
253: ; preds = %252
%254 = icmp ult i64 %50, 4
br i1 %254, label %312, label %255
255: ; preds = %253
%256 = and i64 %50, -4
%257 = add i64 %22, %256
%258 = insertelement <2 x double> poison, double %153, i64 0
%259 = shufflevector <2 x double> %258, <2 x double> poison, <2 x i32> zeroinitializer
%260 = insertelement <2 x double> poison, double %153, i64 0
%261 = shufflevector <2 x double> %260, <2 x double> poison, <2 x i32> zeroinitializer
%262 = and i64 %31, 1
%263 = icmp ult i64 %29, 4
br i1 %263, label %295, label %264
264: ; preds = %255
%265 = and i64 %31, 9223372036854775806
br label %266
266: ; preds = %266, %264
%267 = phi i64 [ 0, %264 ], [ %292, %266 ]
%268 = phi i64 [ 0, %264 ], [ %293, %266 ]
%269 = add i64 %22, %267
%270 = getelementptr inbounds double, double* %181, i64 %269
%271 = bitcast double* %270 to <2 x double>*
%272 = load <2 x double>, <2 x double>* %271
%273 = getelementptr inbounds double, double* %270, i64 2
%274 = bitcast double* %273 to <2 x double>*
%275 = load <2 x double>, <2 x double>* %274
%276 = fmul <2 x double> %259, %272
%277 = fmul <2 x double> %261, %275
%278 = bitcast double* %270 to <2 x double>*
store <2 x double> %276, <2 x double>* %278
%279 = bitcast double* %273 to <2 x double>*
store <2 x double> %277, <2 x double>* %279
%280 = or i64 %267, 4
%281 = add i64 %22, %280
%282 = getelementptr inbounds double, double* %181, i64 %281
%283 = bitcast double* %282 to <2 x double>*
%284 = load <2 x double>, <2 x double>* %283
%285 = getelementptr inbounds double, double* %282, i64 2
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = fmul <2 x double> %259, %284
%289 = fmul <2 x double> %261, %287
%290 = bitcast double* %282 to <2 x double>*
store <2 x double> %288, <2 x double>* %290
%291 = bitcast double* %285 to <2 x double>*
store <2 x double> %289, <2 x double>* %291
%292 = add nuw i64 %267, 8
%293 = add i64 %268, 2
%294 = icmp eq i64 %293, %265
br i1 %294, label %295, label %266
295: ; preds = %266, %255
%296 = phi i64 [ 0, %255 ], [ %292, %266 ]
%297 = icmp eq i64 %262, 0
br i1 %297, label %310, label %298
298: ; preds = %295
%299 = add i64 %22, %296
%300 = getelementptr inbounds double, double* %181, i64 %299
%301 = bitcast double* %300 to <2 x double>*
%302 = load <2 x double>, <2 x double>* %301
%303 = getelementptr inbounds double, double* %300, i64 2
%304 = bitcast double* %303 to <2 x double>*
%305 = load <2 x double>, <2 x double>* %304
%306 = fmul <2 x double> %259, %302
%307 = fmul <2 x double> %261, %305
%308 = bitcast double* %300 to <2 x double>*
store <2 x double> %306, <2 x double>* %308
%309 = bitcast double* %303 to <2 x double>*
store <2 x double> %307, <2 x double>* %309
br label %310
310: ; preds = %295, %298
%311 = icmp eq i64 %50, %256
br i1 %311, label %456, label %312
312: ; preds = %253, %310
%313 = phi i64 [ %22, %253 ], [ %257, %310 ]
br label %449
314: ; preds = %232, %446
%315 = phi i64 [ %447, %446 ], [ %22, %232 ]
br i1 %143, label %316, label %446
316: ; preds = %314
%317 = getelementptr inbounds double*, double** %0, i64 %315
%318 = load double*, double** %317
br i1 %234, label %331, label %319
319: ; preds = %316, %319
%320 = phi i64 [ %328, %319 ], [ %22, %316 ]
%321 = phi double [ %327, %319 ], [ 0.000000e+00, %316 ]
%322 = phi i64 [ %329, %319 ], [ 0, %316 ]
%323 = getelementptr inbounds double, double* %318, i64 %320
%324 = load double, double* %323
%325 = getelementptr inbounds double, double* %181, i64 %320
%326 = load double, double* %325
%327 = tail call double @llvm.fmuladd.f64(double %324, double %326, double %321)
%328 = add nuw nsw i64 %320, 1
%329 = add i64 %322, 1
%330 = icmp eq i64 %329, %233
br i1 %330, label %331, label %319
331: ; preds = %319, %316
%332 = phi double [ undef, %316 ], [ %327, %319 ]
%333 = phi i64 [ %22, %316 ], [ %328, %319 ]
%334 = phi double [ 0.000000e+00, %316 ], [ %327, %319 ]
br i1 %235, label %335, label %409
335: ; preds = %409, %331
%336 = phi double [ %332, %331 ], [ %434, %409 ]
br i1 %143, label %337, label %446
337: ; preds = %335
%338 = getelementptr inbounds double*, double** %0, i64 %315
%339 = load double*, double** %338
br i1 %236, label %407, label %340
340: ; preds = %337
%341 = insertelement <2 x double> poison, double %336, i64 0
%342 = shufflevector <2 x double> %341, <2 x double> poison, <2 x i32> zeroinitializer
%343 = insertelement <2 x double> poison, double %336, i64 0
%344 = shufflevector <2 x double> %343, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %240, label %386, label %345
345: ; preds = %340, %345
%346 = phi i64 [ %383, %345 ], [ 0, %340 ]
%347 = phi i64 [ %384, %345 ], [ 0, %340 ]
%348 = add i64 %22, %346
%349 = getelementptr inbounds double, double* %13, i64 %348
%350 = bitcast double* %349 to <2 x double>*
%351 = load <2 x double>, <2 x double>* %350
%352 = getelementptr inbounds double, double* %349, i64 2
%353 = bitcast double* %352 to <2 x double>*
%354 = load <2 x double>, <2 x double>* %353
%355 = getelementptr inbounds double, double* %339, i64 %348
%356 = bitcast double* %355 to <2 x double>*
%357 = load <2 x double>, <2 x double>* %356
%358 = getelementptr inbounds double, double* %355, i64 2
%359 = bitcast double* %358 to <2 x double>*
%360 = load <2 x double>, <2 x double>* %359
%361 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %342, <2 x double> %351, <2 x double> %357)
%362 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %344, <2 x double> %354, <2 x double> %360)
%363 = bitcast double* %355 to <2 x double>*
store <2 x double> %361, <2 x double>* %363
%364 = bitcast double* %358 to <2 x double>*
store <2 x double> %362, <2 x double>* %364
%365 = or i64 %346, 4
%366 = add i64 %22, %365
%367 = getelementptr inbounds double, double* %13, i64 %366
%368 = bitcast double* %367 to <2 x double>*
%369 = load <2 x double>, <2 x double>* %368
%370 = getelementptr inbounds double, double* %367, i64 2
%371 = bitcast double* %370 to <2 x double>*
%372 = load <2 x double>, <2 x double>* %371
%373 = getelementptr inbounds double, double* %339, i64 %366
%374 = bitcast double* %373 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374
%376 = getelementptr inbounds double, double* %373, i64 2
%377 = bitcast double* %376 to <2 x double>*
%378 = load <2 x double>, <2 x double>* %377
%379 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %342, <2 x double> %369, <2 x double> %375)
%380 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %344, <2 x double> %372, <2 x double> %378)
%381 = bitcast double* %373 to <2 x double>*
store <2 x double> %379, <2 x double>* %381
%382 = bitcast double* %376 to <2 x double>*
store <2 x double> %380, <2 x double>* %382
%383 = add nuw i64 %346, 8
%384 = add i64 %347, 2
%385 = icmp eq i64 %384, %241
br i1 %385, label %386, label %345
386: ; preds = %345, %340
%387 = phi i64 [ 0, %340 ], [ %383, %345 ]
br i1 %242, label %406, label %388
388: ; preds = %386
%389 = add i64 %22, %387
%390 = getelementptr inbounds double, double* %13, i64 %389
%391 = bitcast double* %390 to <2 x double>*
%392 = load <2 x double>, <2 x double>* %391
%393 = getelementptr inbounds double, double* %390, i64 2
%394 = bitcast double* %393 to <2 x double>*
%395 = load <2 x double>, <2 x double>* %394
%396 = getelementptr inbounds double, double* %339, i64 %389
%397 = bitcast double* %396 to <2 x double>*
%398 = load <2 x double>, <2 x double>* %397
%399 = getelementptr inbounds double, double* %396, i64 2
%400 = bitcast double* %399 to <2 x double>*
%401 = load <2 x double>, <2 x double>* %400
%402 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %342, <2 x double> %392, <2 x double> %398)
%403 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %344, <2 x double> %395, <2 x double> %401)
%404 = bitcast double* %396 to <2 x double>*
store <2 x double> %402, <2 x double>* %404
%405 = bitcast double* %399 to <2 x double>*
store <2 x double> %403, <2 x double>* %405
br label %406
406: ; preds = %386, %388
br i1 %243, label %446, label %407
407: ; preds = %337, %406
%408 = phi i64 [ %22, %337 ], [ %238, %406 ]
br label %437
409: ; preds = %331, %409
%410 = phi i64 [ %435, %409 ], [ %333, %331 ]
%411 = phi double [ %434, %409 ], [ %334, %331 ]
%412 = getelementptr inbounds double, double* %318, i64 %410
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %181, i64 %410
%415 = load double, double* %414
%416 = tail call double @llvm.fmuladd.f64(double %413, double %415, double %411)
%417 = add nuw nsw i64 %410, 1
%418 = getelementptr inbounds double, double* %318, i64 %417
%419 = load double, double* %418
%420 = getelementptr inbounds double, double* %181, i64 %417
%421 = load double, double* %420
%422 = tail call double @llvm.fmuladd.f64(double %419, double %421, double %416)
%423 = add nuw nsw i64 %410, 2
%424 = getelementptr inbounds double, double* %318, i64 %423
%425 = load double, double* %424
%426 = getelementptr inbounds double, double* %181, i64 %423
%427 = load double, double* %426
%428 = tail call double @llvm.fmuladd.f64(double %425, double %427, double %422)
%429 = add nuw nsw i64 %410, 3
%430 = getelementptr inbounds double, double* %318, i64 %429
%431 = load double, double* %430
%432 = getelementptr inbounds double, double* %181, i64 %429
%433 = load double, double* %432
%434 = tail call double @llvm.fmuladd.f64(double %431, double %433, double %428)
%435 = add nuw nsw i64 %410, 4
%436 = icmp eq i64 %435, %18
br i1 %436, label %335, label %409
437: ; preds = %407, %437
%438 = phi i64 [ %444, %437 ], [ %408, %407 ]
%439 = getelementptr inbounds double, double* %13, i64 %438
%440 = load double, double* %439
%441 = getelementptr inbounds double, double* %339, i64 %438
%442 = load double, double* %441
%443 = tail call double @llvm.fmuladd.f64(double %336, double %440, double %442)
store double %443, double* %441
%444 = add nuw nsw i64 %438, 1
%445 = icmp eq i64 %444, %18
br i1 %445, label %446, label %437
446: ; preds = %437, %406, %314, %335
%447 = add nuw nsw i64 %315, 1
%448 = icmp eq i64 %447, %19
br i1 %448, label %252, label %314
449: ; preds = %312, %449
%450 = phi i64 [ %454, %449 ], [ %313, %312 ]
%451 = getelementptr inbounds double, double* %181, i64 %450
%452 = load double, double* %451
%453 = fmul double %153, %452
store double %453, double* %451
%454 = add nuw nsw i64 %450, 1
%455 = icmp eq i64 %454, %18
br i1 %455, label %456, label %449
456: ; preds = %449, %310, %142, %252, %55, %156, %137
%457 = phi double* [ %140, %156 ], [ %140, %137 ], [ %56, %55 ], [ %140, %252 ], [ %140, %142 ], [ %140, %310 ], [ %140, %449 ]
%458 = phi double [ 0.000000e+00, %156 ], [ 0.000000e+00, %137 ], [ 0.000000e+00, %55 ], [ %177, %252 ], [ 0.000000e+00, %142 ], [ %177, %310 ], [ %177, %449 ]
%459 = phi double [ %153, %156 ], [ 0.000000e+00, %137 ], [ 0.000000e+00, %55 ], [ %153, %252 ], [ 0.000000e+00, %142 ], [ %153, %310 ], [ %153, %449 ]
%460 = load double, double* %457
%461 = tail call double @llvm.fabs.f64(double %460)
%462 = load double, double* %53
%463 = tail call double @llvm.fabs.f64(double %462)
%464 = fadd double %461, %463
%465 = fcmp ogt double %26, %464
%466 = select i1 %465, double %26, double %464
%467 = add nuw nsw i64 %22, 1
%468 = icmp eq i64 %51, %18
br i1 %468, label %469, label %21
469: ; preds = %456
br i1 %7, label %470, label %665
470: ; preds = %469
%471 = zext i32 %14 to i64
%472 = sub nsw i64 0, %11
br label %473
473: ; preds = %470, %657
%474 = phi i64 [ %11, %470 ], [ %488, %657 ]
%475 = phi double [ %458, %470 ], [ %662, %657 ]
%476 = phi i32 [ %1, %470 ], [ %664, %657 ]
%477 = sext i32 %476 to i64
%478 = sub nsw i64 %11, %477
%479 = xor i64 %477, -1
%480 = add nsw i64 %479, %11
%481 = sext i32 %476 to i64
%482 = sub nsw i64 %11, %481
%483 = xor i64 %481, -1
%484 = sext i32 %476 to i64
%485 = sub nsw i64 %11, %484
%486 = xor i64 %484, -1
%487 = add nsw i64 %486, %11
%488 = add nsw i64 %474, -1
%489 = icmp sgt i64 %474, %471
br i1 %489, label %657, label %490
490: ; preds = %473
%491 = fcmp une double %475, 0.000000e+00
br i1 %491, label %492, label %613
492: ; preds = %490
%493 = icmp slt i32 %476, %1
br i1 %493, label %494, label %613
494: ; preds = %492
%495 = getelementptr inbounds double*, double** %0, i64 %488
%496 = load double*, double** %495
%497 = sext i32 %476 to i64
%498 = getelementptr inbounds double, double* %496, i64 %497
br label %512
499: ; preds = %512
br i1 %493, label %500, label %613
500: ; preds = %499
%501 = getelementptr inbounds double*, double** %0, i64 %488
%502 = sext i32 %476 to i64
%503 = load double*, double** %501
%504 = and i64 %485, 3
%505 = icmp eq i64 %504, 0
%506 = icmp ult i64 %487, 3
%507 = and i64 %482, 1
%508 = icmp eq i64 %507, 0
%509 = getelementptr inbounds double*, double** %4, i64 %502
%510 = add nsw i64 %502, 1
%511 = icmp eq i64 %483, %472
br label %524
512: ; preds = %494, %512
%513 = phi i64 [ %497, %494 ], [ %522, %512 ]
%514 = getelementptr inbounds double, double* %496, i64 %513
%515 = load double, double* %514
%516 = load double, double* %498
%517 = fdiv double %515, %516
%518 = fdiv double %517, %475
%519 = getelementptr inbounds double*, double** %4, i64 %513
%520 = load double*, double** %519
%521 = getelementptr inbounds double, double* %520, i64 %488
store double %518, double* %521
%522 = add nsw i64 %513, 1
%523 = icmp eq i64 %522, %11
br i1 %523, label %499, label %512
524: ; preds = %610, %500
%525 = phi i64 [ %502, %500 ], [ %611, %610 ]
br i1 %505, label %540, label %526
526: ; preds = %524, %526
%527 = phi i64 [ %537, %526 ], [ %502, %524 ]
%528 = phi double [ %536, %526 ], [ 0.000000e+00, %524 ]
%529 = phi i64 [ %538, %526 ], [ 0, %524 ]
%530 = getelementptr inbounds double, double* %503, i64 %527
%531 = load double, double* %530
%532 = getelementptr inbounds double*, double** %4, i64 %527
%533 = load double*, double** %532
%534 = getelementptr inbounds double, double* %533, i64 %525
%535 = load double, double* %534
%536 = tail call double @llvm.fmuladd.f64(double %531, double %535, double %528)
%537 = add nsw i64 %527, 1
%538 = add i64 %529, 1
%539 = icmp eq i64 %538, %504
br i1 %539, label %540, label %526
540: ; preds = %526, %524
%541 = phi double [ undef, %524 ], [ %536, %526 ]
%542 = phi i64 [ %502, %524 ], [ %537, %526 ]
%543 = phi double [ 0.000000e+00, %524 ], [ %536, %526 ]
br i1 %506, label %580, label %544
544: ; preds = %540, %544
%545 = phi i64 [ %578, %544 ], [ %542, %540 ]
%546 = phi double [ %577, %544 ], [ %543, %540 ]
%547 = getelementptr inbounds double, double* %503, i64 %545
%548 = load double, double* %547
%549 = getelementptr inbounds double*, double** %4, i64 %545
%550 = load double*, double** %549
%551 = getelementptr inbounds double, double* %550, i64 %525
%552 = load double, double* %551
%553 = tail call double @llvm.fmuladd.f64(double %548, double %552, double %546)
%554 = add nsw i64 %545, 1
%555 = getelementptr inbounds double, double* %503, i64 %554
%556 = load double, double* %555
%557 = getelementptr inbounds double*, double** %4, i64 %554
%558 = load double*, double** %557
%559 = getelementptr inbounds double, double* %558, i64 %525
%560 = load double, double* %559
%561 = tail call double @llvm.fmuladd.f64(double %556, double %560, double %553)
%562 = add nsw i64 %545, 2
%563 = getelementptr inbounds double, double* %503, i64 %562
%564 = load double, double* %563
%565 = getelementptr inbounds double*, double** %4, i64 %562
%566 = load double*, double** %565
%567 = getelementptr inbounds double, double* %566, i64 %525
%568 = load double, double* %567
%569 = tail call double @llvm.fmuladd.f64(double %564, double %568, double %561)
%570 = add nsw i64 %545, 3
%571 = getelementptr inbounds double, double* %503, i64 %570
%572 = load double, double* %571
%573 = getelementptr inbounds double*, double** %4, i64 %570
%574 = load double*, double** %573
%575 = getelementptr inbounds double, double* %574, i64 %525
%576 = load double, double* %575
%577 = tail call double @llvm.fmuladd.f64(double %572, double %576, double %569)
%578 = add nsw i64 %545, 4
%579 = icmp eq i64 %578, %11
br i1 %579, label %580, label %544
580: ; preds = %544, %540
%581 = phi double [ %541, %540 ], [ %577, %544 ]
br i1 %508, label %589, label %582
582: ; preds = %580
%583 = load double*, double** %509
%584 = getelementptr inbounds double, double* %583, i64 %488
%585 = load double, double* %584
%586 = getelementptr inbounds double, double* %583, i64 %525
%587 = load double, double* %586
%588 = tail call double @llvm.fmuladd.f64(double %581, double %585, double %587)
store double %588, double* %586
br label %589
589: ; preds = %582, %580
%590 = phi i64 [ %502, %580 ], [ %510, %582 ]
br i1 %511, label %610, label %591
591: ; preds = %589, %591
%592 = phi i64 [ %608, %591 ], [ %590, %589 ]
%593 = getelementptr inbounds double*, double** %4, i64 %592
%594 = load double*, double** %593
%595 = getelementptr inbounds double, double* %594, i64 %488
%596 = load double, double* %595
%597 = getelementptr inbounds double, double* %594, i64 %525
%598 = load double, double* %597
%599 = tail call double @llvm.fmuladd.f64(double %581, double %596, double %598)
store double %599, double* %597
%600 = add nsw i64 %592, 1
%601 = getelementptr inbounds double*, double** %4, i64 %600
%602 = load double*, double** %601
%603 = getelementptr inbounds double, double* %602, i64 %488
%604 = load double, double* %603
%605 = getelementptr inbounds double, double* %602, i64 %525
%606 = load double, double* %605
%607 = tail call double @llvm.fmuladd.f64(double %581, double %604, double %606)
store double %607, double* %605
%608 = add nsw i64 %592, 2
%609 = icmp eq i64 %608, %11
br i1 %609, label %610, label %591
610: ; preds = %591, %589
%611 = add nsw i64 %525, 1
%612 = icmp eq i64 %611, %11
br i1 %612, label %613, label %524
613: ; preds = %610, %492, %499, %490
%614 = icmp slt i32 %476, %1
br i1 %614, label %615, label %657
615: ; preds = %613
%616 = getelementptr inbounds double*, double** %4, i64 %488
%617 = load double*, double** %616
%618 = sext i32 %476 to i64
%619 = and i64 %478, 3
%620 = icmp eq i64 %619, 0
br i1 %620, label %631, label %621
621: ; preds = %615, %621
%622 = phi i64 [ %628, %621 ], [ %618, %615 ]
%623 = phi i64 [ %629, %621 ], [ 0, %615 ]
%624 = getelementptr inbounds double, double* %617, i64 %622
store double 0.000000e+00, double* %624
%625 = getelementptr inbounds double*, double** %4, i64 %622
%626 = load double*, double** %625
%627 = getelementptr inbounds double, double* %626, i64 %488
store double 0.000000e+00, double* %627
%628 = add nsw i64 %622, 1
%629 = add i64 %623, 1
%630 = icmp eq i64 %629, %619
br i1 %630, label %631, label %621
631: ; preds = %621, %615
%632 = phi i64 [ %618, %615 ], [ %628, %621 ]
%633 = icmp ult i64 %480, 3
br i1 %633, label %657, label %634
634: ; preds = %631, %634
%635 = phi i64 [ %655, %634 ], [ %632, %631 ]
%636 = getelementptr inbounds double, double* %617, i64 %635
store double 0.000000e+00, double* %636
%637 = getelementptr inbounds double*, double** %4, i64 %635
%638 = load double*, double** %637
%639 = getelementptr inbounds double, double* %638, i64 %488
store double 0.000000e+00, double* %639
%640 = add nsw i64 %635, 1
%641 = getelementptr inbounds double, double* %617, i64 %640
store double 0.000000e+00, double* %641
%642 = getelementptr inbounds double*, double** %4, i64 %640
%643 = load double*, double** %642
%644 = getelementptr inbounds double, double* %643, i64 %488
store double 0.000000e+00, double* %644
%645 = add nsw i64 %635, 2
%646 = getelementptr inbounds double, double* %617, i64 %645
store double 0.000000e+00, double* %646
%647 = getelementptr inbounds double*, double** %4, i64 %645
%648 = load double*, double** %647
%649 = getelementptr inbounds double, double* %648, i64 %488
store double 0.000000e+00, double* %649
%650 = add nsw i64 %635, 3
%651 = getelementptr inbounds double, double* %617, i64 %650
store double 0.000000e+00, double* %651
%652 = getelementptr inbounds double*, double** %4, i64 %650
%653 = load double*, double** %652
%654 = getelementptr inbounds double, double* %653, i64 %488
store double 0.000000e+00, double* %654
%655 = add nsw i64 %635, 4
%656 = icmp eq i64 %655, %11
br i1 %656, label %657, label %634
657: ; preds = %631, %634, %613, %473
%658 = getelementptr inbounds double*, double** %4, i64 %488
%659 = load double*, double** %658
%660 = getelementptr inbounds double, double* %659, i64 %488
store double 1.000000e+00, double* %660
%661 = getelementptr inbounds double, double* %13, i64 %488
%662 = load double, double* %661
%663 = icmp sgt i64 %474, 1
%664 = trunc i64 %488 to i32
br i1 %663, label %473, label %665
665: ; preds = %657, %5, %469
%666 = phi double [ %466, %469 ], [ 0.000000e+00, %5 ], [ %466, %657 ]
%667 = icmp slt i32 %2, %1
%668 = add nsw i32 %2, -1
%669 = select i1 %667, i32 %668, i32 %14
%670 = icmp sgt i32 %669, -1
br i1 %670, label %671, label %679
671: ; preds = %665
%672 = add nuw i32 %669, 1
%673 = sub i32 %14, %672
%674 = zext i32 %669 to i64
%675 = sext i32 %2 to i64
%676 = zext i32 %669 to i64
%677 = zext i32 %14 to i64
%678 = zext i32 %672 to i64
br label %697
679: ; preds = %838, %665
br i1 %7, label %680, label %1170
680: ; preds = %679
%681 = add nsw i64 %11, -1
%682 = zext i32 %2 to i64
%683 = zext i32 %1 to i64
%684 = add nsw i64 %683, -1
%685 = and i64 %683, 1
%686 = icmp eq i64 %684, 0
%687 = and i64 %683, 4294967294
%688 = icmp eq i64 %685, 0
%689 = and i64 %682, 1
%690 = icmp eq i32 %2, 1
%691 = and i64 %682, 4294967294
%692 = icmp eq i64 %689, 0
%693 = and i64 %683, 3
%694 = icmp ult i64 %684, 3
%695 = and i64 %683, 4294967292
%696 = icmp eq i64 %693, 0
br label %849
697: ; preds = %671, %838
%698 = phi i64 [ %676, %671 ], [ %847, %838 ]
%699 = phi i64 [ 0, %671 ], [ %845, %838 ]
%700 = phi i64 [ %674, %671 ], [ %844, %838 ]
%701 = phi i32 [ %672, %671 ], [ %846, %838 ]
%702 = sext i32 %701 to i64
%703 = sub nsw i64 %675, %702
%704 = xor i64 %702, -1
%705 = add nsw i64 %704, %675
%706 = sext i32 %701 to i64
%707 = getelementptr inbounds double, double* %3, i64 %698
%708 = load double, double* %707
%709 = icmp ne i64 %698, %677
%710 = trunc i64 %698 to i32
%711 = add i32 %710, 1
%712 = icmp slt i32 %711, %1
%713 = select i1 %709, i1 %712, i1 false
br i1 %713, label %714, label %727
714: ; preds = %697
%715 = trunc i64 %699 to i32
%716 = add i32 %673, %715
%717 = zext i32 %716 to i64
%718 = shl nuw nsw i64 %717, 3
%719 = add nuw nsw i64 %718, 8
%720 = trunc i64 %699 to i32
%721 = sub i32 %672, %720
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double*, double** %0, i64 %698
%724 = load double*, double** %723
%725 = getelementptr double, double* %724, i64 %722
%726 = bitcast double* %725 to i8*
br label %727
727: ; preds = %714, %697
%728 = fcmp une double %708, 0.000000e+00
br i1 %728, label %731, label %729
729: ; preds = %727
%730 = icmp slt i64 %698, %675
br i1 %730, label %830, label %838
731: ; preds = %727
br i1 %712, label %732, label %741
732: ; preds = %731
%733 = icmp slt i32 %711, %2
%734 = getelementptr inbounds double*, double** %0, i64 %698
%735 = load double*, double** %734
%736 = getelementptr inbounds double, double* %735, i64 %698
%737 = icmp slt i64 %698, %675
%738 = and i64 %703, 3
%739 = icmp eq i64 %738, 0
%740 = icmp ult i64 %705, 3
br label %743
741: ; preds = %817, %731
%742 = icmp slt i64 %698, %675
br i1 %742, label %820, label %838
743: ; preds = %732, %817
%744 = phi i64 [ %706, %732 ], [ %818, %817 ]
br i1 %733, label %745, label %800
745: ; preds = %743
br i1 %739, label %760, label %746
746: ; preds = %745, %746
%747 = phi i64 [ %757, %746 ], [ %706, %745 ]
%748 = phi double [ %756, %746 ], [ 0.000000e+00, %745 ]
%749 = phi i64 [ %758, %746 ], [ 0, %745 ]
%750 = getelementptr inbounds double*, double** %0, i64 %747
%751 = load double*, double** %750
%752 = getelementptr inbounds double, double* %751, i64 %698
%753 = load double, double* %752
%754 = getelementptr inbounds double, double* %751, i64 %744
%755 = load double, double* %754
%756 = tail call double @llvm.fmuladd.f64(double %753, double %755, double %748)
%757 = add nsw i64 %747, 1
%758 = add i64 %749, 1
%759 = icmp eq i64 %758, %738
br i1 %759, label %760, label %746
760: ; preds = %746, %745
%761 = phi i64 [ %706, %745 ], [ %757, %746 ]
%762 = phi double [ 0.000000e+00, %745 ], [ %756, %746 ]
%763 = phi double [ undef, %745 ], [ %756, %746 ]
br i1 %740, label %800, label %764
764: ; preds = %760, %764
%765 = phi i64 [ %798, %764 ], [ %761, %760 ]
%766 = phi double [ %797, %764 ], [ %762, %760 ]
%767 = getelementptr inbounds double*, double** %0, i64 %765
%768 = load double*, double** %767
%769 = getelementptr inbounds double, double* %768, i64 %698
%770 = load double, double* %769
%771 = getelementptr inbounds double, double* %768, i64 %744
%772 = load double, double* %771
%773 = tail call double @llvm.fmuladd.f64(double %770, double %772, double %766)
%774 = add nsw i64 %765, 1
%775 = getelementptr inbounds double*, double** %0, i64 %774
%776 = load double*, double** %775
%777 = getelementptr inbounds double, double* %776, i64 %698
%778 = load double, double* %777
%779 = getelementptr inbounds double, double* %776, i64 %744
%780 = load double, double* %779
%781 = tail call double @llvm.fmuladd.f64(double %778, double %780, double %773)
%782 = add nsw i64 %765, 2
%783 = getelementptr inbounds double*, double** %0, i64 %782
%784 = load double*, double** %783
%785 = getelementptr inbounds double, double* %784, i64 %698
%786 = load double, double* %785
%787 = getelementptr inbounds double, double* %784, i64 %744
%788 = load double, double* %787
%789 = tail call double @llvm.fmuladd.f64(double %786, double %788, double %781)
%790 = add nsw i64 %765, 3
%791 = getelementptr inbounds double*, double** %0, i64 %790
%792 = load double*, double** %791
%793 = getelementptr inbounds double, double* %792, i64 %698
%794 = load double, double* %793
%795 = getelementptr inbounds double, double* %792, i64 %744
%796 = load double, double* %795
%797 = tail call double @llvm.fmuladd.f64(double %794, double %796, double %789)
%798 = add nsw i64 %765, 4
%799 = icmp slt i64 %798, %675
br i1 %799, label %764, label %800
800: ; preds = %760, %764, %743
%801 = phi double [ 0.000000e+00, %743 ], [ %763, %760 ], [ %797, %764 ]
%802 = load double, double* %736
%803 = fdiv double %801, %802
%804 = fdiv double %803, %708
br i1 %737, label %805, label %817
805: ; preds = %800, %805
%806 = phi i64 [ %814, %805 ], [ %700, %800 ]
%807 = getelementptr inbounds double*, double** %0, i64 %806
%808 = load double*, double** %807
%809 = getelementptr inbounds double, double* %808, i64 %698
%810 = load double, double* %809
%811 = getelementptr inbounds double, double* %808, i64 %744
%812 = load double, double* %811
%813 = tail call double @llvm.fmuladd.f64(double %804, double %810, double %812)
store double %813, double* %811
%814 = add nsw i64 %806, 1
%815 = trunc i64 %814 to i32
%816 = icmp eq i32 %815, %2
br i1 %816, label %817, label %805
817: ; preds = %805, %800
%818 = add nsw i64 %744, 1
%819 = icmp slt i64 %818, %11
br i1 %819, label %743, label %741
820: ; preds = %741, %820
%821 = phi i64 [ %827, %820 ], [ %700, %741 ]
%822 = getelementptr inbounds double*, double** %0, i64 %821
%823 = load double*, double** %822
%824 = getelementptr inbounds double, double* %823, i64 %698
%825 = load double, double* %824
%826 = fdiv double %825, %708
store double %826, double* %824
%827 = add nsw i64 %821, 1
%828 = trunc i64 %827 to i32
%829 = icmp eq i32 %828, %2
br i1 %829, label %838, label %820
830: ; preds = %729, %830
%831 = phi i64 [ %835, %830 ], [ %700, %729 ]
%832 = getelementptr inbounds double*, double** %0, i64 %831
%833 = load double*, double** %832
%834 = getelementptr inbounds double, double* %833, i64 %698
store double 0.000000e+00, double* %834
%835 = add nsw i64 %831, 1
%836 = trunc i64 %835 to i32
%837 = icmp eq i32 %836, %2
br i1 %837, label %838, label %830
838: ; preds = %830, %820, %729, %741
%839 = getelementptr inbounds double*, double** %0, i64 %698
%840 = load double*, double** %839
%841 = getelementptr inbounds double, double* %840, i64 %698
%842 = load double, double* %841
%843 = fadd double %842, 1.000000e+00
store double %843, double* %841
%844 = add nsw i64 %700, -1
%845 = add nuw nsw i64 %699, 1
%846 = add i32 %701, -1
%847 = add nsw i64 %698, -1
%848 = icmp eq i64 %845, %678
br i1 %848, label %679, label %697
849: ; preds = %680, %1168
%850 = phi i64 [ %681, %680 ], [ %851, %1168 ]
%851 = add nsw i64 %850, -1
%852 = getelementptr inbounds double, double* %3, i64 %850
%853 = getelementptr inbounds double, double* %3, i64 %851
%854 = getelementptr inbounds double, double* %13, i64 %851
%855 = getelementptr inbounds double, double* %13, i64 %850
br label %856
856: ; preds = %1151, %849
%857 = phi i32 [ 0, %849 ], [ %858, %1151 ]
%858 = add nuw nsw i32 %857, 1
%859 = icmp ugt i32 %857, 29
br i1 %859, label %860, label %862
860: ; preds = %856
%861 = tail call i32 @csa_quit(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i32 30)
br label %862
862: ; preds = %856, %860
br label %863
863: ; preds = %862, %878
%864 = phi i64 [ %872, %878 ], [ %850, %862 ]
%865 = and i64 %864, 4294967295
%866 = getelementptr inbounds double, double* %13, i64 %865
%867 = load double, double* %866
%868 = tail call double @llvm.fabs.f64(double %867)
%869 = fadd double %666, %868
%870 = fcmp oeq double %869, %666
br i1 %870, label %927, label %871
871: ; preds = %863
%872 = add nsw i64 %864, -1
%873 = getelementptr inbounds double, double* %3, i64 %872
%874 = load double, double* %873
%875 = tail call double @llvm.fabs.f64(double %874)
%876 = fadd double %666, %875
%877 = fcmp oeq double %876, %666
br i1 %877, label %880, label %878
878: ; preds = %871
%879 = icmp sgt i64 %864, 0
br i1 %879, label %863, label %882
880: ; preds = %871
%881 = trunc i64 %864 to i32
br label %882
882: ; preds = %878, %880
%883 = phi i64 [ %872, %880 ], [ -1, %878 ]
%884 = phi i32 [ %881, %880 ], [ -1, %878 ]
%885 = sext i32 %884 to i64
%886 = icmp slt i64 %850, %885
br i1 %886, label %929, label %887
887: ; preds = %882
%888 = shl i64 %883, 32
%889 = ashr exact i64 %888, 32
br label %890
890: ; preds = %887, %924
%891 = phi i64 [ %885, %887 ], [ %925, %924 ]
%892 = phi double [ 1.000000e+00, %887 ], [ %908, %924 ]
%893 = phi double [ 0.000000e+00, %887 ], [ %906, %924 ]
%894 = getelementptr inbounds double, double* %13, i64 %891
%895 = load double, double* %894
%896 = fmul double %892, %895
%897 = fmul double %893, %895
store double %897, double* %894
%898 = tail call double @llvm.fabs.f64(double %896)
%899 = fadd double %666, %898
%900 = fcmp oeq double %899, %666
br i1 %900, label %929, label %901
901: ; preds = %890
%902 = getelementptr inbounds double, double* %3, i64 %891
%903 = load double, double* %902
%904 = tail call double @hypot(double %896, double %903)
store double %904, double* %902
%905 = fdiv double 1.000000e+00, %904
%906 = fmul double %903, %905
%907 = fneg double %896
%908 = fmul double %905, %907
br i1 %6, label %909, label %924
909: ; preds = %901, %909
%910 = phi i64 [ %922, %909 ], [ 0, %901 ]
%911 = getelementptr inbounds double*, double** %0, i64 %910
%912 = load double*, double** %911
%913 = getelementptr inbounds double, double* %912, i64 %889
%914 = load double, double* %913
%915 = getelementptr inbounds double, double* %912, i64 %891
%916 = load double, double* %915
%917 = fmul double %908, %916
%918 = tail call double @llvm.fmuladd.f64(double %914, double %906, double %917)
store double %918, double* %913
%919 = fneg double %914
%920 = fmul double %908, %919
%921 = tail call double @llvm.fmuladd.f64(double %916, double %906, double %920)
store double %921, double* %915
%922 = add nuw nsw i64 %910, 1
%923 = icmp eq i64 %922, %682
br i1 %923, label %924, label %909
924: ; preds = %909, %901
%925 = add nsw i64 %891, 1
%926 = icmp slt i64 %891, %850
br i1 %926, label %890, label %929
927: ; preds = %863
%928 = trunc i64 %864 to i32
br label %929
929: ; preds = %890, %924, %927, %882
%930 = phi i32 [ %884, %882 ], [ %928, %927 ], [ %884, %924 ], [ %884, %890 ]
%931 = load double, double* %852
%932 = zext i32 %930 to i64
%933 = icmp eq i64 %850, %932
br i1 %933, label %1118, label %934
934: ; preds = %929
%935 = sext i32 %930 to i64
%936 = getelementptr inbounds double, double* %3, i64 %935
%937 = load double, double* %936
%938 = load double, double* %853
%939 = load double, double* %854
%940 = load double, double* %855
%941 = fadd double %931, %939
%942 = fdiv double %941, %940
%943 = fsub double %939, %931
%944 = fdiv double %943, %938
%945 = fdiv double %938, %940
%946 = tail call double @llvm.fmuladd.f64(double %942, double %944, double %945)
%947 = fdiv double %940, %938
%948 = fsub double %946, %947
%949 = fmul double %948, 5.000000e-01
%950 = tail call double @hypot(double %949, double 1.000000e+00)
%951 = fneg double %931
%952 = fdiv double %951, %937
%953 = tail call double @llvm.fmuladd.f64(double %952, double %931, double %937)
%954 = fdiv double %940, %937
%955 = tail call double @llvm.copysign.f64(double %950, double %949)
%956 = fadd double %949, %955
%957 = fdiv double %938, %956
%958 = fsub double %957, %940
%959 = tail call double @llvm.fmuladd.f64(double %954, double %958, double %953)
%960 = icmp sgt i64 %850, %935
br i1 %960, label %980, label %1151
961: ; preds = %1087, %1081
%962 = phi i64 [ 0, %1081 ], [ %1115, %1087 ]
br i1 %692, label %978, label %963
963: ; preds = %961
%964 = getelementptr inbounds double*, double** %0, i64 %962
%965 = load double*, double** %964
%966 = getelementptr inbounds double, double* %965, i64 %981
%967 = bitcast double* %966 to <2 x double>*
%968 = load <2 x double>, <2 x double>* %967
%969 = extractelement <2 x double> %968, i64 0
%970 = fneg double %969
%971 = shufflevector <2 x double> %1073, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%972 = insertelement <2 x double> %968, double %970, i64 0
%973 = fmul <2 x double> %971, %972
%974 = shufflevector <2 x double> %973, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%975 = shufflevector <2 x double> %1073, <2 x double> undef, <2 x i32> zeroinitializer
%976 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %968, <2 x double> %975, <2 x double> %974)
%977 = bitcast double* %966 to <2 x double>*
store <2 x double> %976, <2 x double>* %977
br label %978
978: ; preds = %963, %961, %1072
%979 = icmp slt i64 %986, %850
br i1 %979, label %980, label %1151
980: ; preds = %934, %978
%981 = phi i64 [ %986, %978 ], [ %935, %934 ]
%982 = phi double [ %1080, %978 ], [ %937, %934 ]
%983 = phi double [ %1074, %978 ], [ 1.000000e+00, %934 ]
%984 = phi double [ %1077, %978 ], [ %959, %934 ]
%985 = phi double [ %1076, %978 ], [ 1.000000e+00, %934 ]
%986 = add nsw i64 %981, 1
%987 = getelementptr inbounds double, double* %13, i64 %986
%988 = load double, double* %987
%989 = getelementptr inbounds double, double* %3, i64 %986
%990 = load double, double* %989
%991 = fmul double %983, %988
%992 = fmul double %985, %988
%993 = tail call double @hypot(double %984, double %991)
%994 = getelementptr inbounds double, double* %13, i64 %981
store double %993, double* %994
%995 = insertelement <2 x double> poison, double %984, i64 0
%996 = insertelement <2 x double> %995, double %991, i64 1
%997 = insertelement <2 x double> poison, double %993, i64 0
%998 = shufflevector <2 x double> %997, <2 x double> poison, <2 x i32> zeroinitializer
%999 = fdiv <2 x double> %996, %998
%1000 = extractelement <2 x double> %999, i64 1
%1001 = fmul double %992, %1000
%1002 = extractelement <2 x double> %999, i64 0
%1003 = tail call double @llvm.fmuladd.f64(double %982, double %1002, double %1001)
%1004 = fneg double %982
%1005 = fmul double %1000, %1004
%1006 = tail call double @llvm.fmuladd.f64(double %992, double %1002, double %1005)
%1007 = fmul double %990, %1000
%1008 = fmul double %990, %1002
br i1 %686, label %1045, label %1009
1009: ; preds = %980
%1010 = shufflevector <2 x double> %999, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1011 = shufflevector <2 x double> %999, <2 x double> undef, <2 x i32> zeroinitializer
%1012 = shufflevector <2 x double> %999, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1013 = shufflevector <2 x double> %999, <2 x double> undef, <2 x i32> zeroinitializer
br label %1014
1014: ; preds = %1014, %1009
%1015 = phi i64 [ 0, %1009 ], [ %1042, %1014 ]
%1016 = phi i64 [ 0, %1009 ], [ %1043, %1014 ]
%1017 = getelementptr inbounds double*, double** %4, i64 %1015
%1018 = load double*, double** %1017
%1019 = getelementptr inbounds double, double* %1018, i64 %981
%1020 = bitcast double* %1019 to <2 x double>*
%1021 = load <2 x double>, <2 x double>* %1020
%1022 = extractelement <2 x double> %1021, i64 0
%1023 = fneg double %1022
%1024 = insertelement <2 x double> %1021, double %1023, i64 0
%1025 = fmul <2 x double> %1010, %1024
%1026 = shufflevector <2 x double> %1025, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1027 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1021, <2 x double> %1011, <2 x double> %1026)
%1028 = bitcast double* %1019 to <2 x double>*
store <2 x double> %1027, <2 x double>* %1028
%1029 = or i64 %1015, 1
%1030 = getelementptr inbounds double*, double** %4, i64 %1029
%1031 = load double*, double** %1030
%1032 = getelementptr inbounds double, double* %1031, i64 %981
%1033 = bitcast double* %1032 to <2 x double>*
%1034 = load <2 x double>, <2 x double>* %1033
%1035 = extractelement <2 x double> %1034, i64 0
%1036 = fneg double %1035
%1037 = insertelement <2 x double> %1034, double %1036, i64 0
%1038 = fmul <2 x double> %1012, %1037
%1039 = shufflevector <2 x double> %1038, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1040 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1034, <2 x double> %1013, <2 x double> %1039)
%1041 = bitcast double* %1032 to <2 x double>*
store <2 x double> %1040, <2 x double>* %1041
%1042 = add nuw nsw i64 %1015, 2
%1043 = add i64 %1016, 2
%1044 = icmp eq i64 %1043, %687
br i1 %1044, label %1045, label %1014
1045: ; preds = %1014, %980
%1046 = phi i64 [ 0, %980 ], [ %1042, %1014 ]
br i1 %688, label %1062, label %1047
1047: ; preds = %1045
%1048 = getelementptr inbounds double*, double** %4, i64 %1046
%1049 = load double*, double** %1048
%1050 = getelementptr inbounds double, double* %1049, i64 %981
%1051 = bitcast double* %1050 to <2 x double>*
%1052 = load <2 x double>, <2 x double>* %1051
%1053 = extractelement <2 x double> %1052, i64 0
%1054 = fneg double %1053
%1055 = shufflevector <2 x double> %999, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1056 = insertelement <2 x double> %1052, double %1054, i64 0
%1057 = fmul <2 x double> %1055, %1056
%1058 = shufflevector <2 x double> %1057, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1059 = shufflevector <2 x double> %999, <2 x double> undef, <2 x i32> zeroinitializer
%1060 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1052, <2 x double> %1059, <2 x double> %1058)
%1061 = bitcast double* %1050 to <2 x double>*
store <2 x double> %1060, <2 x double>* %1061
br label %1062
1062: ; preds = %1045, %1047
%1063 = tail call double @hypot(double %1003, double %1007)
%1064 = getelementptr inbounds double, double* %3, i64 %981
store double %1063, double* %1064
%1065 = fcmp une double %1063, 0.000000e+00
br i1 %1065, label %1066, label %1072
1066: ; preds = %1062
%1067 = insertelement <2 x double> poison, double %1003, i64 0
%1068 = insertelement <2 x double> %1067, double %1007, i64 1
%1069 = insertelement <2 x double> poison, double %1063, i64 0
%1070 = shufflevector <2 x double> %1069, <2 x double> poison, <2 x i32> zeroinitializer
%1071 = fdiv <2 x double> %1068, %1070
br label %1072
1072: ; preds = %1066, %1062
%1073 = phi <2 x double> [ %1071, %1066 ], [ %999, %1062 ]
%1074 = extractelement <2 x double> %1073, i64 1
%1075 = fmul double %1008, %1074
%1076 = extractelement <2 x double> %1073, i64 0
%1077 = tail call double @llvm.fmuladd.f64(double %1076, double %1006, double %1075)
%1078 = fneg double %1074
%1079 = fmul double %1006, %1078
%1080 = tail call double @llvm.fmuladd.f64(double %1076, double %1008, double %1079)
br i1 %6, label %1081, label %978
1081: ; preds = %1072
br i1 %690, label %961, label %1082
1082: ; preds = %1081
%1083 = shufflevector <2 x double> %1073, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1084 = shufflevector <2 x double> %1073, <2 x double> undef, <2 x i32> zeroinitializer
%1085 = shufflevector <2 x double> %1073, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%1086 = shufflevector <2 x double> %1073, <2 x double> undef, <2 x i32> zeroinitializer
br label %1087
1087: ; preds = %1087, %1082
%1088 = phi i64 [ 0, %1082 ], [ %1115, %1087 ]
%1089 = phi i64 [ 0, %1082 ], [ %1116, %1087 ]
%1090 = getelementptr inbounds double*, double** %0, i64 %1088
%1091 = load double*, double** %1090
%1092 = getelementptr inbounds double, double* %1091, i64 %981
%1093 = bitcast double* %1092 to <2 x double>*
%1094 = load <2 x double>, <2 x double>* %1093
%1095 = extractelement <2 x double> %1094, i64 0
%1096 = fneg double %1095
%1097 = insertelement <2 x double> %1094, double %1096, i64 0
%1098 = fmul <2 x double> %1083, %1097
%1099 = shufflevector <2 x double> %1098, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1094, <2 x double> %1084, <2 x double> %1099)
%1101 = bitcast double* %1092 to <2 x double>*
store <2 x double> %1100, <2 x double>* %1101
%1102 = or i64 %1088, 1
%1103 = getelementptr inbounds double*, double** %0, i64 %1102
%1104 = load double*, double** %1103
%1105 = getelementptr inbounds double, double* %1104, i64 %981
%1106 = bitcast double* %1105 to <2 x double>*
%1107 = load <2 x double>, <2 x double>* %1106
%1108 = extractelement <2 x double> %1107, i64 0
%1109 = fneg double %1108
%1110 = insertelement <2 x double> %1107, double %1109, i64 0
%1111 = fmul <2 x double> %1085, %1110
%1112 = shufflevector <2 x double> %1111, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%1113 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1107, <2 x double> %1086, <2 x double> %1112)
%1114 = bitcast double* %1105 to <2 x double>*
store <2 x double> %1113, <2 x double>* %1114
%1115 = add nuw nsw i64 %1088, 2
%1116 = add i64 %1089, 2
%1117 = icmp eq i64 %1116, %691
br i1 %1117, label %961, label %1087
1118: ; preds = %929
%1119 = fcmp olt double %931, 0.000000e+00
br i1 %1119, label %1120, label %1168
1120: ; preds = %1118
%1121 = fneg double %931
store double %1121, double* %852
br i1 %694, label %1155, label %1122
1122: ; preds = %1120, %1122
%1123 = phi i64 [ %1148, %1122 ], [ 0, %1120 ]
%1124 = phi i64 [ %1149, %1122 ], [ 0, %1120 ]
%1125 = getelementptr inbounds double*, double** %4, i64 %1123
%1126 = load double*, double** %1125
%1127 = getelementptr inbounds double, double* %1126, i64 %850
%1128 = load double, double* %1127
%1129 = fneg double %1128
store double %1129, double* %1127
%1130 = or i64 %1123, 1
%1131 = getelementptr inbounds double*, double** %4, i64 %1130
%1132 = load double*, double** %1131
%1133 = getelementptr inbounds double, double* %1132, i64 %850
%1134 = load double, double* %1133
%1135 = fneg double %1134
store double %1135, double* %1133
%1136 = or i64 %1123, 2
%1137 = getelementptr inbounds double*, double** %4, i64 %1136
%1138 = load double*, double** %1137
%1139 = getelementptr inbounds double, double* %1138, i64 %850
%1140 = load double, double* %1139
%1141 = fneg double %1140
store double %1141, double* %1139
%1142 = or i64 %1123, 3
%1143 = getelementptr inbounds double*, double** %4, i64 %1142
%1144 = load double*, double** %1143
%1145 = getelementptr inbounds double, double* %1144, i64 %850
%1146 = load double, double* %1145
%1147 = fneg double %1146
store double %1147, double* %1145
%1148 = add nuw nsw i64 %1123, 4
%1149 = add i64 %1124, 4
%1150 = icmp eq i64 %1149, %695
br i1 %1150, label %1155, label %1122
1151: ; preds = %978, %934
%1152 = phi double [ %959, %934 ], [ %1077, %978 ]
%1153 = phi double [ %937, %934 ], [ %1080, %978 ]
%1154 = getelementptr inbounds double, double* %13, i64 %935
store double 0.000000e+00, double* %1154
store double %1152, double* %855
store double %1153, double* %852
br label %856
1155: ; preds = %1122, %1120
%1156 = phi i64 [ 0, %1120 ], [ %1148, %1122 ]
br i1 %696, label %1168, label %1157
1157: ; preds = %1155, %1157
%1158 = phi i64 [ %1165, %1157 ], [ %1156, %1155 ]
%1159 = phi i64 [ %1166, %1157 ], [ 0, %1155 ]
%1160 = getelementptr inbounds double*, double** %4, i64 %1158
%1161 = load double*, double** %1160
%1162 = getelementptr inbounds double, double* %1161, i64 %850
%1163 = load double, double* %1162
%1164 = fneg double %1163
store double %1164, double* %1162
%1165 = add nuw nsw i64 %1158, 1
%1166 = add i64 %1159, 1
%1167 = icmp eq i64 %1166, %693
br i1 %1167, label %1168, label %1157
1168: ; preds = %1155, %1157, %1118
%1169 = icmp sgt i64 %850, 0
br i1 %1169, label %849, label %1170
1170: ; preds = %1168, %679
%1171 = tail call i32 @free(double* %13)
ret void
}