#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 */
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *);
double pythag(double, double);
double sqrt(double);
int /*<<< orphan*/ svd_errm();
void dsvdcmp0(double **a, int m, int n, double *w, double **v) {
  int flag, i, its, j, jj, k, l, nm;
  double anorm, c, f, g, h, s, scale, x, y, z, *rv1;
  if (!(rv1 = (double *)malloc(n * sizeof(double))))
    svd_errm();
  g = scale = anorm = 0.0;
  for (i = 0; i < n; i++) {
    l = i + 1;
    rv1[i] = scale * g;
    g = s = scale = 0.0;
    if (i < m) {
      for (k = i; k < m; k++)
        scale += fabs(a[k][i]);
      if (scale) {
        for (k = i; k < m; k++) {
          a[k][i] /= scale;
          s += a[k][i] * a[k][i];
        }
        f = a[i][i];
        g = -((f) > 0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        a[i][i] = f - g;
        for (j = l; j < n; j++) {
          for (s = 0.0, 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 = s = scale = 0.0;
    if (i < m && i != n - 1) {
      for (k = l; k < n; k++)
        scale += fabs(a[i][k]);
      if (scale) {
        for (k = l; k < n; k++) {
          a[i][k] /= scale;
          s += a[i][k] * a[i][k];
        }
        f = a[i][l];
        g = -((f) > 0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        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++) {
          for (s = 0.0, 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;
      }
    }
    anorm = ((anorm) > ((fabs(w[i]) + fabs(rv1[i])))
                 ? (anorm)
                 : ((fabs(w[i]) + fabs(rv1[i]))));
  }
  for (i = n - 1; i >= 0; i--) {
    if (i < n - 1) {
      if (g) {
        for (j = l; j < n; j++)
          v[j][i] = (a[i][j] / a[i][l]) / g;
        for (j = l; j < n; j++) {
          for (s = 0.0, 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] = v[j][i] = 0.0;
    }
    v[i][i] = 1.0;
    g = rv1[i];
    l = i;
  }
  for (i = ((m - 1) < (n - 1) ? (m - 1) : (n - 1)); i >= 0; i--) {
    l = i + 1;
    g = w[i];
    for (j = l; j < n; j++)
      a[i][j] = 0.0;
    if (g) {
      g = 1.0 / g;
      for (j = l; j < n; j++) {
        for (s = 0.0, 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--) {
    for (its = 0; its < 30; its++) {
      flag = 1;
      for (l = k; l > 0; l--) {
        nm = l - 1;
        if ((double)(fabs(rv1[l]) + anorm) == anorm) {
          flag = 0;
          break;
        }
        if ((double)(fabs(w[nm]) + anorm) == anorm)
          break;
      }
      if (flag) {
        c = 0.0;
        s = 1.0;
        for (i = l; i <= k; i++) {
          f = s * rv1[i];
          rv1[i] = c * rv1[i];
          if ((double)(fabs(f) + anorm) == anorm)
            break;
          g = w[i];
          h = pythag(f, g);
          w[i] = h;
          h = 1.0 / h;
          c = g * h;
          s = -f * h;
          for (j = 0; j < m; j++) {
            y = a[j][nm];
            z = a[j][i];
            a[j][nm] = y * c + z * s;
            a[j][i] = z * c - y * s;
          }
        }
      }
      z = w[k];
      if (l == k) {
        if (z < 0.0) {
          w[k] = -z;
          for (j = 0; j < n; j++)
            v[j][k] = -v[j][k];
        }
        break;
      }
      if (its >= 30) {
        printf("dsvdcmp0: no convergence in 30 iterations\n");
      }
      x = w[l];
      nm = k - 1;
      y = w[nm];
      g = rv1[nm];
      h = rv1[k];
      f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
      g = pythag(f, 1.0);
      f = ((x - z) * (x + z) +
           h * ((y / (f + ((f) > 0 ? fabs(g) : -fabs(g)))) - h)) /
          x;
      c = s = 1.0;
      for (j = l; j <= nm; j++) {
        i = j + 1;
        g = rv1[i];
        y = w[i];
        h = s * g;
        g = c * g;
        z = pythag(f, h);
        rv1[j] = z;
        c = f / z;
        s = h / z;
        f = x * c + g * s;
        g = g * c - x * s;
        h = y * s;
        y *= c;
        for (jj = 0; jj < n; jj++) {
          x = v[jj][j];
          z = v[jj][i];
          v[jj][j] = x * c + z * s;
          v[jj][i] = z * c - x * s;
        }
        z = pythag(f, h);
        w[j] = z;
        if (z) {
          z = 1.0 / z;
          c = f * z;
          s = h * z;
        }
        f = c * g + s * y;
        x = c * y - s * g;
        for (jj = 0; jj < m; jj++) {
          y = a[jj][j];
          z = a[jj][i];
          a[jj][j] = y * c + z * s;
          a[jj][i] = z * c - y * s;
        }
      }
      rv1[l] = 0.0;
      rv1[k] = f;
      w[k] = x;
    }
  }
  free(rv1);
}


x86 assembly (clang, -O0):
<dsvdcmp0>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x98(%rbp)
cmp    $0x0,%rax
jne    11a4 <dsvdcmp0+0x44>
mov    $0x0,%al
call   1070 <svd_errm@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1980 <dsvdcmp0+0x820>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1531 <dsvdcmp0+0x3d1>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1260 <dsvdcmp0+0x100>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1dbc(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    121c <dsvdcmp0+0xbc>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    127d <dsvdcmp0+0x11d>
jp     127d <dsvdcmp0+0x11d>
jmp    152c <dsvdcmp0+0x3cc>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12fc <dsvdcmp0+0x19c>
movsd  -0x78(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1283 <dsvdcmp0+0x123>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    134a <dsvdcmp0+0x1ea>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movaps 0x1cc7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    137e <dsvdcmp0+0x21e>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movaps 0x1ca5(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14e8 <dsvdcmp0+0x388>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    146a <dsvdcmp0+0x30a>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1414 <dsvdcmp0+0x2b4>
movsd  -0x70(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14d5 <dsvdcmp0+0x375>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%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    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    147f <dsvdcmp0+0x31f>
jmp    14da <dsvdcmp0+0x37a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13fa <dsvdcmp0+0x29a>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1527 <dsvdcmp0+0x3c7>
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14ee <dsvdcmp0+0x38e>
jmp    152c <dsvdcmp0+0x3cc>
jmp    1531 <dsvdcmp0+0x3d1>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18ce <dsvdcmp0+0x76e>
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     18ce <dsvdcmp0+0x76e>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15c7 <dsvdcmp0+0x467>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1a55(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1583 <dsvdcmp0+0x423>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15e4 <dsvdcmp0+0x484>
jp     15e4 <dsvdcmp0+0x484>
jmp    18c9 <dsvdcmp0+0x769>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1663 <dsvdcmp0+0x503>
movsd  -0x78(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15ea <dsvdcmp0+0x48a>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16b1 <dsvdcmp0+0x551>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movaps 0x1960(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    16e5 <dsvdcmp0+0x585>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movaps 0x193e(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    17a5 <dsvdcmp0+0x645>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1761 <dsvdcmp0+0x601>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1885 <dsvdcmp0+0x725>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    181b <dsvdcmp0+0x6bb>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17c5 <dsvdcmp0+0x665>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1872 <dsvdcmp0+0x712>
movsd  -0x70(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1821 <dsvdcmp0+0x6c1>
jmp    1877 <dsvdcmp0+0x717>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17ab <dsvdcmp0+0x64b>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    18c4 <dsvdcmp0+0x764>
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    188b <dsvdcmp0+0x72b>
jmp    18c9 <dsvdcmp0+0x769>
jmp    18ce <dsvdcmp0+0x76e>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1719(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x16fe(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1926 <dsvdcmp0+0x7c6>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1965 <dsvdcmp0+0x805>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x16c6(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x16ab(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c3 <dsvdcmp0+0x63>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1baa <dsvdcmp0+0xa4a>
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b64 <dsvdcmp0+0xa04>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19c1 <dsvdcmp0+0x861>
jp     19c1 <dsvdcmp0+0x861>
jmp    1b0f <dsvdcmp0+0x9af>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a25 <dsvdcmp0+0x8c5>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19c7 <dsvdcmp0+0x867>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b0a <dsvdcmp0+0x9aa>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a9b <dsvdcmp0+0x93b>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a45 <dsvdcmp0+0x8e5>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1af7 <dsvdcmp0+0x997>
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x38(%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    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1aa1 <dsvdcmp0+0x941>
jmp    1afc <dsvdcmp0+0x99c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a2b <dsvdcmp0+0x8cb>
jmp    1b0f <dsvdcmp0+0x9af>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b5f <dsvdcmp0+0x9ff>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%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    1b15 <dsvdcmp0+0x9b5>
jmp    1b64 <dsvdcmp0+0xa04>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  0x1494(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1989 <dsvdcmp0+0x829>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1bcf <dsvdcmp0+0xa6f>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1bdb <dsvdcmp0+0xa7b>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1e2a <dsvdcmp0+0xcca>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c41 <dsvdcmp0+0xae1>
mov    -0x8(%rbp),%rax
movslq -0x28(%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    1c0f <dsvdcmp0+0xaaf>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c5e <dsvdcmp0+0xafe>
jp     1c5e <dsvdcmp0+0xafe>
jmp    1dbd <dsvdcmp0+0xc5d>
movsd  0x13aa(%rip),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d79 <dsvdcmp0+0xc19>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ce6 <dsvdcmp0+0xb86>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c90 <dsvdcmp0+0xb30>
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d66 <dsvdcmp0+0xc06>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%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    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d10 <dsvdcmp0+0xbb0>
jmp    1d6b <dsvdcmp0+0xc0b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c76 <dsvdcmp0+0xb16>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1db8 <dsvdcmp0+0xc58>
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d7f <dsvdcmp0+0xc1f>
jmp    1dfa <dsvdcmp0+0xc9a>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1df5 <dsvdcmp0+0xc95>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1dc3 <dsvdcmp0+0xc63>
jmp    1dfa <dsvdcmp0+0xc9a>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  0x11fe(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1be4 <dsvdcmp0+0xa84>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     2813 <dsvdcmp0+0x16b3>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x1e,-0x2c(%rbp)
jge    2800 <dsvdcmp0+0x16a0>
movl   $0x1,-0x24(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jle    1ef1 <dsvdcmp0+0xd91>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x117b(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x48(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jne    1eab <dsvdcmp0+0xd4b>
jp     1eab <dsvdcmp0+0xd4b>
movl   $0x0,-0x24(%rbp)
jmp    1ef1 <dsvdcmp0+0xd91>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1141(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x48(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jne    1ede <dsvdcmp0+0xd7e>
jp     1ede <dsvdcmp0+0xd7e>
jmp    1ef1 <dsvdcmp0+0xd91>
jmp    1ee3 <dsvdcmp0+0xd83>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e5b <dsvdcmp0+0xcfb>
cmpl   $0x0,-0x24(%rbp)
je     2103 <dsvdcmp0+0xfa3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x1105(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     20fe <dsvdcmp0+0xf9e>
movsd  -0x70(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movaps 0x1093(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x48(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jne    1f8c <dsvdcmp0+0xe2c>
jp     1f8c <dsvdcmp0+0xe2c>
jmp    20fe <dsvdcmp0+0xf9e>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
call   1050 <pythag@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x1044(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    20eb <dsvdcmp0+0xf8b>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%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 -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2012 <dsvdcmp0+0xeb2>
jmp    20f0 <dsvdcmp0+0xf90>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1f16 <dsvdcmp0+0xdb6>
jmp    2103 <dsvdcmp0+0xfa3>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    21cd <dsvdcmp0+0x106d>
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    21c8 <dsvdcmp0+0x1068>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    21c3 <dsvdcmp0+0x1063>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%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 -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2168 <dsvdcmp0+0x1008>
jmp    21c8 <dsvdcmp0+0x1068>
jmp    2800 <dsvdcmp0+0x16a0>
cmpl   $0x1e,-0x2c(%rbp)
jl     21e3 <dsvdcmp0+0x1083>
lea    0xe42(%rip),%rdi
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
addsd  -0x90(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm3
addsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd93(%rip),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xd68(%rip),%xmm1
call   1050 <pythag@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2335 <dsvdcmp0+0x11d5>
movsd  -0x60(%rbp),%xmm0
movaps 0xcdc(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    2364 <dsvdcmp0+0x1204>
movsd  -0x60(%rbp),%xmm0
movaps 0xcbf(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0xc8(%rbp),%xmm3
ff
movsd  -0xc0(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm5
ff
addsd  %xmm5,%xmm4
divsd  %xmm4,%xmm3
subsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xc51(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xc44(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     27b8 <dsvdcmp0+0x1658>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1050 <pythag@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%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  -0x88(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    25de <dsvdcmp0+0x147e>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%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 -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    250e <dsvdcmp0+0x13ae>
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1050 <pythag@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    262a <dsvdcmp0+0x14ca>
jp     262a <dsvdcmp0+0x14ca>
jmp    2666 <dsvdcmp0+0x1506>
movsd  0x9de(%rip),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    27a5 <dsvdcmp0+0x1645>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%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 -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    26cc <dsvdcmp0+0x156c>
jmp    27aa <dsvdcmp0+0x164a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    23d7 <dsvdcmp0+0x1277>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e44 <dsvdcmp0+0xce4>
jmp    2805 <dsvdcmp0+0x16a5>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1e33 <dsvdcmp0+0xcd3>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dsvdcmp0>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r8,0xa8(%rsp)
mov    %rcx,0x40(%rsp)
mov    %edx,%ebp
mov    %esi,%r14d
mov    %rdi,%r13
lea    0x0(,%rbp,8),%edi
call   1060 <malloc@plt>
mov    %rax,0x10(%rsp)
test   %rax,%rax
jne    11a3 <dsvdcmp0+0x43>
xor    %eax,%eax
call   1070 <svd_errm@plt>
lea    -0x1(%rbp),%ebx
movslq %r14d,%rsi
mov    %rbp,%rcx
mov    %ecx,%r15d
mov    %ebx,%eax
mov    %rax,0xa0(%rsp)
mov    %r14,0xd0(%rsp)
mov    %r14d,%r12d
mov    %rbp,0x38(%rsp)
test   %ecx,%ecx
mov    %rsi,0x50(%rsp)
mov    %r12,0x138(%rsp)
jle    2170 <dsvdcmp0+0x1010>
mov    %rbx,0x108(%rsp)
mov    0x10(%rsp),%r11
lea    (%r11,%r15,8),%rax
mov    %rax,0x110(%rsp)
lea    -0x1(%r15),%rax
mov    %rax,0x118(%rsp)
lea    -0x2(%r15),%rax
mov    %rax,0x180(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xb0(%rsp)
lea    0x18(%r11),%rax
mov    %rax,0x30(%rsp)
lea    -0x3(%r15),%rbx
lea    0x38(%r11),%r9
lea    -0x5(%r15),%rax
mov    %rax,0x70(%rsp)
xorpd  %xmm8,%xmm8
mov    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    $0x3,%edx
mov    $0xffffffffffffffff,%rcx
mov    $0x7,%eax
mov    %rax,0xc8(%rsp)
xor    %r8d,%r8d
movapd 0x1d96(%rip),%xmm7
movapd 0x1d9d(%rip),%xmm9
movapd 0x1d84(%rip),%xmm10
mov    %r15,0x48(%rsp)
mov    %r12,%rdi
xorpd  %xmm12,%xmm12
xorpd  %xmm11,%xmm11
xorpd  %xmm2,%xmm2
mov    %r13,%rbp
mov    0x40(%rsp),%r10
jmp    1319 <dsvdcmp0+0x1b9>
nopl   0x0(%rax)
lea    (%r10,%r14,8),%rax
movq   $0x0,(%r10,%r14,8)
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
movsd  (%rax),%xmm0
mov    0x10(%rsp),%r11
movsd  (%r11,%r14,8),%xmm1
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
maxsd  %xmm1,%xmm2
addq   $0x1,0x20(%rsp)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rdi
addq   $0xffffffffffffffff,0x48(%rsp)
addq   $0x8,0x30(%rsp)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
add    $0xffffffffffffffff,%rcx
addq   $0xffffffffffffffff,0x70(%rsp)
addq   $0x1,0xc8(%rsp)
add    $0x8,%r9
cmp    %r15,%r8
je     1e07 <dsvdcmp0+0xca7>
mov    %r8,%r14
mulsd  %xmm11,%xmm12
add    $0x1,%r8
movsd  %xmm12,(%r11,%r14,8)
cmp    %rsi,%r14
jge    12a0 <dsvdcmp0+0x140>
mov    %r11,%rax
mov    %rcx,0x60(%rsp)
mov    0x70(%rsp),%rcx
mov    %rcx,%r11
shr    $0x2,%r11
add    $0x1,%r11
and    $0xfffffffffffffffe,%r11
and    $0x3,%ecx
mov    %rcx,0xf0(%rsp)
mov    %rbx,0x88(%rsp)
shr    %rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0xe0(%rsp)
mov    0x118(%rsp),%rbx
sub    %r14,%rbx
mov    %rbx,%rcx
mov    %rbx,0x100(%rsp)
lea    -0x4(%rbx),%rcx
mov    %rcx,0x120(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x128(%rsp)
mov    0x180(%rsp),%rcx
sub    %r14,%rcx
mov    %rcx,0xf8(%rsp)
mov    %r14,%rcx
not    %rcx
lea    (%rcx,%r15,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    %r15,%rcx
mov    %rcx,0x68(%rsp)
mov    %rbx,0x170(%rsp)
mov    %rbx,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,0x178(%rsp)
mov    0x20(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    %rax,0x130(%rsp)
xorpd  %xmm4,%xmm4
xor    %eax,%eax
mov    %rbp,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rax
cmp    %rax,%rdi
jne    1410 <dsvdcmp0+0x2b0>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm4
xorpd  %xmm0,%xmm0
movsd  %xmm2,0x18(%rsp)
jne    1447 <dsvdcmp0+0x2e7>
jnp    1635 <dsvdcmp0+0x4d5>
xorpd  %xmm6,%xmm6
xor    %eax,%eax
mov    %rbp,%rbx
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rcx,%r14,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%rax
cmp    %rax,%rdi
jne    1450 <dsvdcmp0+0x2f0>
mov    0x0(%r13,%r14,8),%rax
movsd  (%rax,%r14,8),%xmm5
ucomisd %xmm8,%xmm6
mov    %rdx,0x98(%rsp)
jb     149b <dsvdcmp0+0x33b>
xorps  %xmm0,%xmm0
sqrtsd %xmm6,%xmm0
jmp    1538 <dsvdcmp0+0x3d8>
movapd %xmm6,%xmm0
mov    %r9,%rbx
mov    %rdi,0x80(%rsp)
mov    %r8,0x8(%rsp)
mov    %r11,0xd8(%rsp)
movsd  %xmm4,0x90(%rsp)
movsd  %xmm5,0x150(%rsp)
movsd  %xmm6,0x140(%rsp)
call   1080 <sqrt@plt>
movsd  0x140(%rsp),%xmm6
movsd  0x150(%rsp),%xmm5
movsd  0x90(%rsp),%xmm4
mov    0xd8(%rsp),%r11
xorpd  %xmm11,%xmm11
mov    0x8(%rsp),%r8
mov    0x80(%rsp),%rdi
movapd 0x1aeb(%rip),%xmm10
movapd 0x1af2(%rip),%xmm9
movapd 0x1ada(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    %rbx,%r9
mov    0x50(%rsp),%rsi
mov    0x40(%rsp),%r10
mov    %rbp,%rdx
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
orpd   %xmm9,%xmm0
xorpd  %xmm2,%xmm2
cmpltsd %xmm5,%xmm2
movapd %xmm2,%xmm3
andnpd %xmm0,%xmm3
andpd  %xmm1,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm2,%xmm0
xorpd  %xmm9,%xmm0
addsd  %xmm5,%xmm2
mov    0x0(%r13,%r14,8),%rax
movsd  %xmm2,(%rax,%r14,8)
cmp    %r15,%r8
jae    15fe <dsvdcmp0+0x49e>
mulsd  %xmm0,%xmm5
subsd  %xmm6,%xmm5
mov    0x20(%rsp),%rax
nop
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    15a0 <dsvdcmp0+0x440>
divsd  %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    15d0 <dsvdcmp0+0x470>
mov    %rbp,%rdx
add    $0x1,%rax
cmp    %r15,%rax
jne    1590 <dsvdcmp0+0x430>
xor    %eax,%eax
movsd  0x18(%rsp),%xmm2
cs nopw 0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%r14,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1610 <dsvdcmp0+0x4b0>
mov    0x98(%rsp),%rdx
mulsd  %xmm0,%xmm4
lea    (%r10,%r14,8),%rax
movsd  %xmm4,(%r10,%r14,8)
cmp    0xa0(%rsp),%r14
mov    0x88(%rsp),%rbx
je     1760 <dsvdcmp0+0x600>
cmp    %r15,%r8
jae    1760 <dsvdcmp0+0x600>
mov    %rax,0x90(%rsp)
mov    %r8,0x8(%rsp)
mov    %rdi,0x80(%rsp)
lea    0x0(,%r14,8),%rax
add    0x0(%r13,%r14,8),%rax
xorpd  %xmm12,%xmm12
mov    $0x1,%ecx
mov    0x48(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x1,%rcx
cmp    %rcx,%r8
jne    16a0 <dsvdcmp0+0x540>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm12
mov    0x80(%rsp),%rdi
jne    16d1 <dsvdcmp0+0x571>
jnp    176f <dsvdcmp0+0x60f>
mov    %rdx,0x98(%rsp)
mov    0x0(%r13,%r14,8),%rdi
xorpd  %xmm5,%xmm5
mov    0x8(%rsp),%r8
cmp    %r15,%r8
mov    0x48(%rsp),%rax
jae    1720 <dsvdcmp0+0x5c0>
lea    (%rdi,%r14,8),%rcx
xorpd  %xmm5,%xmm5
mov    $0x1,%edx
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm12,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1700 <dsvdcmp0+0x5a0>
movsd  (%rdi,%r8,8),%xmm4
ucomisd %xmm8,%xmm5
mov    %r9,0xe8(%rsp)
mov    %r11,0xd8(%rsp)
jb     1779 <dsvdcmp0+0x619>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
mov    0x68(%rsp),%r9
mov    0x30(%rsp),%rbx
jmp    17ed <dsvdcmp0+0x68d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm12,%xmm12
mov    0x60(%rsp),%rcx
jmp    12b6 <dsvdcmp0+0x156>
mov    0x60(%rsp),%rcx
jmp    1ce2 <dsvdcmp0+0xb82>
movapd %xmm5,%xmm0
movapd %xmm12,0x150(%rsp)
movapd %xmm4,0x140(%rsp)
movsd  %xmm5,0x168(%rsp)
call   1080 <sqrt@plt>
movsd  0x168(%rsp),%xmm5
movapd 0x140(%rsp),%xmm4
movapd 0x150(%rsp),%xmm12
mov    0x8(%rsp),%r8
movapd 0x1838(%rip),%xmm10
movapd 0x183f(%rip),%xmm9
movapd 0x1827(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    0x30(%rsp),%rbx
mov    0x50(%rsp),%rsi
mov    0x68(%rsp),%r9
mov    0xe0(%rsp),%rdi
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
orpd   %xmm9,%xmm0
xorpd  %xmm2,%xmm2
cmpltsd %xmm4,%xmm2
movapd %xmm2,%xmm3
andnpd %xmm0,%xmm3
andpd  %xmm1,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm2,%xmm11
xorpd  %xmm9,%xmm11
addsd  %xmm4,%xmm2
mov    0x0(%r13,%r14,8),%rax
movsd  %xmm2,(%rax,%r8,8)
cmp    %r15,%r8
movsd  0x18(%rsp),%xmm2
jae    1977 <dsvdcmp0+0x817>
mulsd  %xmm11,%xmm4
subsd  %xmm5,%xmm4
mov    0x20(%rsp),%rcx
cmp    $0x2,%r9
jb     1910 <dsvdcmp0+0x7b0>
lea    (%rax,%r15,8),%rcx
cmp    %rcx,0x130(%rsp)
jae    1880 <dsvdcmp0+0x720>
mov    0x20(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
cmp    0x110(%rsp),%rdx
jb     1910 <dsvdcmp0+0x7b0>
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmpq   $0x2,0x170(%rsp)
jae    1897 <dsvdcmp0+0x737>
xor    %edx,%edx
jmp    18d8 <dsvdcmp0+0x778>
mov    0x98(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rbx,%rdx,8)
movupd (%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rdi
jne    18b0 <dsvdcmp0+0x750>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
testb  $0x1,0x178(%rsp)
01
je     1906 <dsvdcmp0+0x7a6>
add    0x20(%rsp),%rdx
movupd (%rax,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
mov    0x10(%rsp),%rsi
movupd %xmm1,(%rsi,%rdx,8)
mov    0x50(%rsp),%rsi
cmp    %rcx,%r9
je     1977 <dsvdcmp0+0x817>
add    0x20(%rsp),%rcx
mov    %r15d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
test   $0x1,%sil
je     1935 <dsvdcmp0+0x7d5>
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
mov    0x10(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,0x118(%rsp)
mov    0x10(%rsp),%rcx
mov    0x50(%rsp),%rsi
je     1977 <dsvdcmp0+0x817>
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r15
jne    1950 <dsvdcmp0+0x7f0>
mov    %rbx,0x30(%rsp)
cmp    %rsi,%r8
mov    0x20(%rsp),%r8
jge    1c5c <dsvdcmp0+0xafc>
mov    0x68(%rsp),%r9
and    $0xfffffffffffffffc,%r9
lea    (%r8,%r9,1),%rcx
mov    %rcx,0xe0(%rsp)
mov    0x60(%rsp),%r10
neg    %r10
lea    (%rax,%r8,8),%rdi
mov    %r8,%r11
jmp    19bd <dsvdcmp0+0x85d>
add    $0x1,%r11
cmp    %r12,%r11
je     1c5c <dsvdcmp0+0xafc>
cmp    %r15,0x8(%rsp)
jae    19b0 <dsvdcmp0+0x850>
mov    0x0(%r13,%r11,8),%rcx
testb  $0x3,0x100(%rsp)
03
je     1ac9 <dsvdcmp0+0x969>
lea    (%rcx,%r8,8),%rdx
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    0xf0(%rsp),%rsi
nopl   0x0(%rax)
movsd  (%rdx,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    19f0 <dsvdcmp0+0x890>
add    %r10,%rbx
cmpq   $0x3,0xf8(%rsp)
jb     1a67 <dsvdcmp0+0x907>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rbx,8),%xmm1
movsd  0x8(%rcx,%rbx,8),%xmm2
mulsd  (%rax,%rbx,8),%xmm1
mulsd  0x8(%rax,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rcx,%rbx,8),%xmm3
mulsd  0x10(%rax,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rcx,%rbx,8),%xmm0
mulsd  0x18(%rax,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1a20 <dsvdcmp0+0x8c0>
cmp    %r15,0x8(%rsp)
movsd  0x18(%rsp),%xmm2
jae    19b0 <dsvdcmp0+0x850>
mov    0x0(%r13,%r11,8),%rcx
mov    %r8,%rdx
cmpq   $0x4,0x68(%rsp)
jb     1be0 <dsvdcmp0+0xa80>
lea    (%rcx,%r8,8),%rdx
cmp    0x110(%rsp),%rdx
jae    1aaf <dsvdcmp0+0x94f>
lea    (%rcx,%r15,8),%rsi
mov    %r8,%rdx
cmp    %rsi,0x130(%rsp)
jb     1be0 <dsvdcmp0+0xa80>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x120(%rsp)
jae    1ae1 <dsvdcmp0+0x981>
xor    %ebx,%ebx
jmp    1b73 <dsvdcmp0+0xa13>
xorpd  %xmm0,%xmm0
mov    %r8,%rbx
cmpq   $0x3,0xf8(%rsp)
jae    1a20 <dsvdcmp0+0x8c0>
jmp    1a67 <dsvdcmp0+0x907>
mov    0xc8(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
mov    0xd8(%rsp),%rdx
xor    %ebx,%ebx
mov    0xe8(%rsp),%r8
nop
movupd -0x30(%r8,%rbx,8),%xmm2
movupd -0x20(%r8,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rsi,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rsi,%rbx,8),%xmm2
movupd -0x10(%rsi,%rbx,8),%xmm5
movupd (%rsi,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rsi,%rbx,8)
movupd %xmm3,-0x20(%rsi,%rbx,8)
movupd -0x10(%r8,%rbx,8),%xmm2
movupd (%r8,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rsi,%rbx,8)
movupd %xmm3,(%rsi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1b00 <dsvdcmp0+0x9a0>
testb  $0x1,0x128(%rsp)
01
mov    0x20(%rsp),%r8
je     1bbb <dsvdcmp0+0xa5b>
add    %r8,%rbx
mov    0x10(%rsp),%rdx
movupd (%rdx,%rbx,8),%xmm2
movupd 0x10(%rdx,%rbx,8),%xmm3
movupd (%rcx,%rbx,8),%xmm4
movupd 0x10(%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rbx,8)
movupd %xmm3,0x10(%rcx,%rbx,8)
mov    0xe0(%rsp),%rdx
cmp    %r9,0x68(%rsp)
movsd  0x18(%rsp),%xmm2
je     19b0 <dsvdcmp0+0x850>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15d,%ebx
sub    %edx,%ebx
mov    %rdx,%rsi
test   $0x1,%bl
je     1c09 <dsvdcmp0+0xaa9>
mov    0x10(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0xb0(%rsp),%rdx
je     19b0 <dsvdcmp0+0x850>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
movsd  0x8(%rdx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r15
jne    1c20 <dsvdcmp0+0xac0>
jmp    19b0 <dsvdcmp0+0x850>
cmp    %r15,0x8(%rsp)
jae    1cb3 <dsvdcmp0+0xb53>
mov    %r8,%rdx
mov    0x68(%rsp),%rsi
cmp    $0x4,%rsi
mov    0x40(%rsp),%r10
mov    0x88(%rsp),%rbx
mov    0xe8(%rsp),%r9
mov    0x8(%rsp),%r8
jb     1dbc <dsvdcmp0+0xc5c>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x4,0x120(%rsp)
jae    1cf4 <dsvdcmp0+0xb94>
xor    %ecx,%ecx
mov    0x80(%rsp),%rdi
jmp    1d68 <dsvdcmp0+0xc08>
mov    0x40(%rsp),%r10
mov    0x50(%rsp),%rsi
mov    0x88(%rsp),%rbx
mov    0xe8(%rsp),%r9
mov    0x98(%rsp),%rdx
mov    0x60(%rsp),%rcx
mov    0x80(%rsp),%rdi
mov    0x8(%rsp),%r8
mov    0x90(%rsp),%rax
jmp    12b6 <dsvdcmp0+0x156>
mov    0xc8(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0x80(%rsp),%rdi
mov    0xd8(%rsp),%rbx
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,%rbx
jne    1d20 <dsvdcmp0+0xbc0>
mov    %rsi,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x128(%rsp)
01
je     1d9c <dsvdcmp0+0xc3c>
add    0x20(%rsp),%rcx
movupd (%rax,%rcx,8),%xmm1
movupd 0x10(%rax,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rax,%rcx,8)
movupd %xmm2,0x10(%rax,%rcx,8)
cmp    %rdx,%rsi
mov    0x88(%rsp),%rbx
jne    1db1 <dsvdcmp0+0xc51>
movsd  0x18(%rsp),%xmm2
jmp    1de8 <dsvdcmp0+0xc88>
add    0x20(%rsp),%rdx
movsd  0x18(%rsp),%xmm2
mov    0x80(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1dd0 <dsvdcmp0+0xc70>
mov    0x50(%rsp),%rsi
mov    0x98(%rsp),%rdx
mov    0x60(%rsp),%rcx
mov    0x90(%rsp),%rax
jmp    12b6 <dsvdcmp0+0x156>
mov    0x38(%rsp),%rax
test   %eax,%eax
jle    217b <dsvdcmp0+0x101b>
xor    %r9d,%r9d
movabs $0x3ff0000000000000,%rbp
xorpd  %xmm0,%xmm0
mov    %r15,%rsi
mov    0xa8(%rsp),%rdi
movapd %xmm2,%xmm4
jmp    1e5e <dsvdcmp0+0xcfe>
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rsi,8),%rax
mov    %rbp,(%rax,%rsi,8)
movsd  (%r11,%rsi,8),%xmm11
add    $0x1,%r9b
mov    %esi,%eax
cmp    $0x1,%rbx
jle    2154 <dsvdcmp0+0xff4>
mov    %rsi,%rbx
movzbl %r9b,%r9d
and    $0x3,%r9d
add    $0xffffffffffffffff,%rsi
cmp    0xa0(%rsp),%rbx
jg     1e40 <dsvdcmp0+0xce0>
mov    %rbx,0x18(%rsp)
mov    %eax,0x70(%rsp)
movslq %eax,%r12
mov    %r15,%r14
sub    %r12,%r14
mov    %r12,%rax
not    %rax
mov    %rax,0x20(%rsp)
add    %r15,%rax
mov    %rax,0x8(%rsp)
ucomisd %xmm0,%xmm11
jne    1ea9 <dsvdcmp0+0xd49>
jnp    2090 <dsvdcmp0+0xf30>
mov    0x70(%rsp),%eax
cmp    0x38(%rsp),%eax
jge    2090 <dsvdcmp0+0xf30>
mov    0x0(%r13,%rsi,8),%rax
mov    0x70(%rsp),%ebp
movslq %ebp,%rcx
mov    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
divsd  (%rax,%rcx,8),%xmm1
divsd  %xmm11,%xmm1
mov    (%rdi,%rdx,8),%rbx
movsd  %xmm1,(%rbx,%rsi,8)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1ed0 <dsvdcmp0+0xd70>
cmp    0x38(%rsp),%ebp
jge    2090 <dsvdcmp0+0xf30>
movslq 0x70(%rsp),%r8
mov    0x0(%r13,%rsi,8),%rdx
lea    0x1(%r8),%rax
mov    %rax,0x48(%rsp)
mov    %r8,%rcx
jmp    1f31 <dsvdcmp0+0xdd1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
cmp    %r15,%rcx
movapd %xmm4,%xmm2
je     2090 <dsvdcmp0+0xf30>
xorpd  %xmm1,%xmm1
test   $0x3,%r14b
je     2070 <dsvdcmp0+0xf10>
mov    %r9,%rax
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rbx,8),%xmm2
mov    0xa8(%rsp),%rdi
mov    (%rdi,%rbx,8),%r10
mulsd  (%r10,%rcx,8),%xmm2
mov    0xa8(%rsp),%rdi
addsd  %xmm2,%xmm1
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1f50 <dsvdcmp0+0xdf0>
cmpq   $0x3,0x8(%rsp)
jb     1fe8 <dsvdcmp0+0xe88>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rbx,8),%xmm2
movsd  0x8(%rdx,%rbx,8),%xmm3
mov    (%rdi,%rbx,8),%rax
mov    0x8(%rdi,%rbx,8),%rbp
mulsd  (%rax,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rcx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rdx,%rbx,8),%xmm2
mov    0x10(%rdi,%rbx,8),%rax
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x18(%rdx,%rbx,8),%xmm1
mov    0x18(%rdi,%rbx,8),%rax
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1f90 <dsvdcmp0+0xe30>
mov    %r8,%rbx
test   $0x1,%r14b
je     200d <dsvdcmp0+0xead>
mov    (%rdi,%r8,8),%rax
movsd  (%rax,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    0x48(%rsp),%rbx
mov    0x20(%rsp),%rax
cmp    0xb0(%rsp),%rax
mov    0x10(%rsp),%r11
je     1f20 <dsvdcmp0+0xdc0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%rbx,8),%rax
movsd  (%rax,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    0x8(%rdi,%rbx,8),%rax
movsd  (%rax,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
add    $0x2,%rbx
cmp    %rbx,%r15
jne    2030 <dsvdcmp0+0xed0>
jmp    1f20 <dsvdcmp0+0xdc0>
nopl   (%rax)
mov    %r8,%rbx
cmpq   $0x3,0x8(%rsp)
jae    1f90 <dsvdcmp0+0xe30>
jmp    1fe8 <dsvdcmp0+0xe88>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x70(%rsp),%eax
cmp    0x38(%rsp),%eax
movabs $0x3ff0000000000000,%rbp
mov    0x18(%rsp),%rbx
jge    1e40 <dsvdcmp0+0xce0>
mov    (%rdi,%rsi,8),%rcx
test   $0x3,%r14b
je     20de <dsvdcmp0+0xf7e>
mov    %r9,%rax
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%r12,8),%rdx
movq   $0x0,(%rdx,%rsi,8)
movq   $0x0,(%rcx,%r12,8)
add    $0x1,%r12
add    $0xffffffffffffffff,%rax
jne    20c0 <dsvdcmp0+0xf60>
cmpq   $0x3,0x8(%rsp)
jb     1e40 <dsvdcmp0+0xce0>
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%r12,8),%rax
movq   $0x0,(%rax,%rsi,8)
movq   $0x0,(%rcx,%r12,8)
mov    0x8(%rdi,%r12,8),%rax
movq   $0x0,(%rax,%rsi,8)
movq   $0x0,0x8(%rcx,%r12,8)
mov    0x10(%rdi,%r12,8),%rax
movq   $0x0,(%rax,%rsi,8)
movq   $0x0,0x10(%rcx,%r12,8)
mov    0x18(%rdi,%r12,8),%rax
movq   $0x0,(%rax,%rsi,8)
movq   $0x0,0x18(%rcx,%r12,8)
add    $0x4,%r12
cmp    %r12,%r15
jne    20f0 <dsvdcmp0+0xf90>
jmp    1e40 <dsvdcmp0+0xce0>
mov    0x40(%rsp),%r10
mov    0x138(%rsp),%r12
mov    0x108(%rsp),%rbx
mov    0x50(%rsp),%rsi
jmp    2183 <dsvdcmp0+0x1023>
xorpd  %xmm2,%xmm2
mov    0x40(%rsp),%r10
jmp    2183 <dsvdcmp0+0x1023>
mov    0x108(%rsp),%rbx
mov    0xd0(%rsp),%rax
add    $0xffffffff,%eax
cmp    %ebx,%eax
cmovl  %eax,%ebx
test   %ebx,%ebx
movsd  %xmm2,0x18(%rsp)
js     2461 <dsvdcmp0+0x1301>
lea    0x1(%rbx),%ecx
mov    0x38(%rsp),%rax
mov    %eax,%edx
sub    %ebx,%edx
add    $0xfffffffe,%edx
mov    %rdx,0x30(%rsp)
cltq
mov    %rax,0x8(%rsp)
mov    %ebx,%ebp
xor    $0x3,%bl
add    0xd0(%rsp),%bl
xor    %edi,%edi
xorpd  %xmm4,%xmm4
movsd  0xe4a(%rip),%xmm5
mov    %rcx,0x20(%rsp)
mov    %ecx,%edx
jmp    220c <dsvdcmp0+0x10ac>
nop
mov    0x0(%r13,%rbp,8),%rax
movsd  (%rax,%rbp,8),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0xffffffffffffffff,%rbp
add    $0x1,%rdi
add    $0xffffffff,%edx
add    $0x1,%bl
cmp    0x20(%rsp),%rdi
je     2461 <dsvdcmp0+0x1301>
movzbl %bl,%ebx
and    $0x3,%ebx
movsd  (%r10,%rbp,8),%xmm1
lea    0x1(%rbp),%r14d
cmp    0x38(%rsp),%r14d
jge    23d0 <dsvdcmp0+0x1270>
mov    0x30(%rsp),%rax
add    %edi,%eax
mov    %edx,0x70(%rsp)
lea    0x8(,%rax,8),%rdx
mov    0x20(%rsp),%rax
sub    %edi,%eax
mov    %rdi,0xb0(%rsp)
movslq %eax,%rdi
shl    $0x3,%rdi
add    0x0(%r13,%rbp,8),%rdi
xor    %esi,%esi
movsd  %xmm1,0x48(%rsp)
call   1040 <memset@plt>
movsd  0x48(%rsp),%xmm1
mov    0x70(%rsp),%edx
movsd  0xdac(%rip),%xmm5
xorpd  %xmm4,%xmm4
mov    0xb0(%rsp),%rdi
mov    0x50(%rsp),%rsi
movsd  0x18(%rsp),%xmm2
mov    0x40(%rsp),%r10
ucomisd %xmm4,%xmm1
jne    229c <dsvdcmp0+0x113c>
jnp    23f0 <dsvdcmp0+0x1290>
movslq %edx,%r11
mov    %rsi,%r9
sub    %r11,%r9
mov    %r11,%rdx
not    %rdx
add    %rsi,%rdx
movapd %xmm5,%xmm0
divsd  %xmm1,%xmm0
mov    0x0(%r13,%rbp,8),%r8
mov    %r11,%rdi
jmp    22cf <dsvdcmp0+0x116f>
add    $0x1,%rdi
cmp    0x8(%rsp),%rdi
jge    2420 <dsvdcmp0+0x12c0>
xorpd  %xmm1,%xmm1
cmp    0xd0(%rsp),%r14d
jge    238a <dsvdcmp0+0x122a>
xorpd  %xmm1,%xmm1
test   $0x3,%r9b
je     231f <dsvdcmp0+0x11bf>
mov    %rbx,%rsi
mov    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    2300 <dsvdcmp0+0x11a0>
jmp    2322 <dsvdcmp0+0x11c2>
mov    %r11,%rax
cmp    $0x3,%rdx
mov    0x50(%rsp),%rsi
jb     238a <dsvdcmp0+0x122a>
nopl   (%rax)
mov    0x0(%r13,%rax,8),%rcx
mov    0x8(%r13,%rax,8),%rsi
movsd  (%rcx,%rbp,8),%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
movsd  (%rsi,%rbp,8),%xmm3
mulsd  (%rsi,%rdi,8),%xmm3
mov    0x50(%rsp),%rsi
addsd  %xmm2,%xmm3
mov    0x10(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
mov    0x18(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rax
cmp    %rsi,%rax
jl     2330 <dsvdcmp0+0x11d0>
cmp    %rsi,%rbp
jge    22c0 <dsvdcmp0+0x1160>
divsd  (%r8,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
mov    %rbp,%rax
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rdi,8),%xmm2
movsd  %xmm2,(%rcx,%rdi,8)
add    $0x1,%rax
cmp    %rsi,%rax
jl     23a0 <dsvdcmp0+0x1240>
jmp    22c0 <dsvdcmp0+0x1160>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm4,%xmm1
jne    23d8 <dsvdcmp0+0x1278>
jnp    23f0 <dsvdcmp0+0x1290>
movapd %xmm5,%xmm0
divsd  %xmm1,%xmm0
jmp    2432 <dsvdcmp0+0x12d2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rax
cmp    %rsi,%rbp
jge    21e0 <dsvdcmp0+0x1080>
nopl   0x0(%rax)
mov    0x0(%r13,%rax,8),%rcx
movq   $0x0,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %rsi,%rax
jl     2400 <dsvdcmp0+0x12a0>
jmp    21e0 <dsvdcmp0+0x1080>
nopl   0x0(%rax,%rax,1)
movsd  0x18(%rsp),%xmm2
mov    0xb0(%rsp),%rdi
mov    0x70(%rsp),%edx
mov    %rbp,%rax
cmp    %rsi,%rbp
jge    21e0 <dsvdcmp0+0x1080>
xchg   %ax,%ax
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %rsi,%rax
jl     2440 <dsvdcmp0+0x12e0>
jmp    21e0 <dsvdcmp0+0x1080>
cmpl   $0x0,0x38(%rsp)
mov    0x10(%rsp),%rdi
mov    0xa0(%rsp),%rsi
jle    2bc0 <dsvdcmp0+0x1a60>
lea    -0x1(%r15),%rcx
mov    %r15d,%ebp
and    $0x3,%ebp
mov    %r15d,%r8d
and    $0xfffffffc,%r8d
lea    (%rdi,%rsi,8),%rax
mov    %rax,0xc8(%rsp)
mov    0x38(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x88(%rsp)
movapd 0xb4b(%rip),%xmm1
mov    %rcx,0x68(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rbp,0x60(%rsp)
mov    %r8,0xf0(%rsp)
jmp    24ea <dsvdcmp0+0x138a>
xchg   %ax,%ax
mov    0x30(%rsp),%rax
mov    %eax,%r9d
addq   $0xffffffffffffffff,0x88(%rsp)
test   %rdx,%rdx
je     2bc0 <dsvdcmp0+0x1a60>
mov    0x30(%rsp),%rdx
lea    -0x1(%rdx),%rax
mov    %rax,0x30(%rsp)
xor    %ecx,%ecx
mov    %rdx,0x48(%rsp)
jmp    2566 <dsvdcmp0+0x1406>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%r10
mov    0x10(%rsp),%rdi
mov    0xf8(%rsp),%rax
movq   $0x0,(%rdi,%rax,8)
movsd  %xmm5,(%rdi,%rdx,8)
movsd  %xmm3,(%r10,%rdx,8)
mov    0x100(%rsp),%ecx
add    $0x1,%ecx
mov    0x30(%rsp),%rax
mov    %eax,%r9d
cmp    $0x1e,%ecx
mov    0xa0(%rsp),%rsi
movsd  0x18(%rsp),%xmm2
movapd 0xaa0(%rip),%xmm1
je     24d0 <dsvdcmp0+0x1370>
mov    %ecx,0x100(%rsp)
mov    0x88(%rsp),%r14
test   %rdx,%rdx
mov    0xc8(%rsp),%rcx
je     25e0 <dsvdcmp0+0x1480>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%r14,8),%xmm0
andpd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm2,%xmm0
jne    25a6 <dsvdcmp0+0x1446>
jnp    25f0 <dsvdcmp0+0x1490>
lea    (%rsi,%r14,1),%rax
add    $0xffffffffffffffff,%rax
mov    %eax,%eax
movsd  (%r10,%rax,8),%xmm0
andpd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm2,%xmm0
jne    25c6 <dsvdcmp0+0x1466>
jnp    2610 <dsvdcmp0+0x14b0>
add    $0xffffffffffffffff,%r14
lea    (%r14,%r15,1),%eax
cmp    $0x2,%eax
jge    2590 <dsvdcmp0+0x1430>
xor    %r14d,%r14d
xor    %r9d,%r9d
jmp    261c <dsvdcmp0+0x14bc>
nopl   0x0(%rax,%rax,1)
xor    %r14d,%r14d
jmp    261c <dsvdcmp0+0x14bc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x38(%rsp),%rax
lea    (%rax,%r14,1),%r9d
add    %esi,%r14d
movsd  0xa1c(%rip),%xmm0
jmp    276a <dsvdcmp0+0x160a>
nopl   0x0(%rax)
mov    0x38(%rsp),%rax
lea    (%rax,%r14,1),%r9d
add    %esi,%r14d
movsd  0x9fc(%rip),%xmm0
movslq %r14d,%rbx
cmp    %rbx,%rdx
jl     276a <dsvdcmp0+0x160a>
mov    %r9d,0x20(%rsp)
movslq %r9d,%rbp
xorpd  %xmm5,%xmm5
movapd %xmm0,%xmm4
jmp    2673 <dsvdcmp0+0x1513>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rbx),%rax
mov    0x48(%rsp),%rdx
cmp    %rdx,%rbx
mov    %rax,%rbx
movsd  0x18(%rsp),%xmm2
movapd 0x993(%rip),%xmm1
jge    2750 <dsvdcmp0+0x15f0>
mov    0x10(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm5
movsd  %xmm5,(%rax,%rbx,8)
movapd %xmm4,%xmm0
andpd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm2,%xmm0
jne    26a2 <dsvdcmp0+0x1542>
jnp    2750 <dsvdcmp0+0x15f0>
movsd  (%r10,%rbx,8),%xmm1
movsd  %xmm1,0x8(%rsp)
movapd %xmm4,%xmm0
movapd %xmm4,0x50(%rsp)
call   1050 <pythag@plt>
movsd  0x8(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
mov    0x40(%rsp),%r10
movsd  %xmm0,(%r10,%rbx,8)
movsd  0x944(%rip),%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm5
xorpd  0x924(%rip),%xmm4
mulsd  %xmm1,%xmm4
cmpl   $0x0,0xd0(%rsp)
jle    2650 <dsvdcmp0+0x14f0>
xor    %eax,%eax
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  (%rcx,%rbx,8),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
mulsd  %xmm5,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    2700 <dsvdcmp0+0x15a0>
jmp    2650 <dsvdcmp0+0x14f0>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
mov    0xa0(%rsp),%rsi
movsd  0x8bb(%rip),%xmm0
mov    0x20(%rsp),%r9d
movsd  (%r10,%rdx,8),%xmm3
mov    %r14d,%eax
cmp    %rax,%rdx
je     2ad0 <dsvdcmp0+0x1970>
movslq %r14d,%r14
movsd  (%r10,%r14,8),%xmm1
movaps %xmm1,0x20(%rsp)
mov    0x30(%rsp),%rax
movsd  (%r10,%rax,8),%xmm6
movsd  (%rdi,%rax,8),%xmm5
movsd  (%rdi,%rdx,8),%xmm4
movapd %xmm0,%xmm1
movapd %xmm6,%xmm0
subsd  %xmm3,%xmm0
movapd %xmm3,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm6,0xb0(%rsp)
mulsd  %xmm0,%xmm2
movapd %xmm5,%xmm0
movsd  %xmm4,0x50(%rsp)
subsd  %xmm4,%xmm5
addsd  %xmm4,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm4,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm6,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
movapd %xmm3,0x70(%rsp)
call   1050 <pythag@plt>
movapd 0xb0(%rsp),%xmm5
movapd 0x20(%rsp),%xmm3
mov    0x48(%rsp),%rdx
movapd %xmm3,%xmm1
movapd 0x70(%rsp),%xmm2
subsd  %xmm2,%xmm1
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm2,%xmm4
movapd %xmm0,%xmm1
andpd  0x7cb(%rip),%xmm1
orpd   0x7d3(%rip),%xmm0
xorpd  %xmm2,%xmm2
movsd  0x8(%rsp),%xmm6
cmpltsd %xmm6,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
addsd  %xmm6,%xmm2
divsd  %xmm2,%xmm5
movsd  0x50(%rsp),%xmm0
subsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
divsd  %xmm3,%xmm5
cmp    %r14,%rdx
mov    %r14,0xf8(%rsp)
jle    2510 <dsvdcmp0+0x13b0>
movsd  0x791(%rip),%xmm4
movapd %xmm4,%xmm1
mov    0x40(%rsp),%r10
jmp    28d9 <dsvdcmp0+0x1779>
nopw   0x0(%rax,%rax,1)
movsd  0x50(%rsp),%xmm6
movapd %xmm6,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm4,%xmm5
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm2
movapd %xmm4,%xmm3
mulsd  %xmm6,%xmm3
subsd  %xmm2,%xmm3
cmp    %rdx,%r14
jge    2515 <dsvdcmp0+0x13b5>
movapd %xmm5,0xb0(%rsp)
movapd %xmm3,0x20(%rsp)
mov    %r13,%r12
mov    %r14,%rbp
add    $0x1,%r14
mov    %r14d,%ebx
mov    0x10(%rsp),%r13
movsd  0x0(%r13,%rbx,8),%xmm0
movsd  (%r10,%rbx,8),%xmm2
movsd  %xmm2,0x50(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x70(%rsp)
mulsd  %xmm0,%xmm4
movsd  %xmm4,0x8(%rsp)
movapd %xmm5,%xmm0
call   1050 <pythag@plt>
movapd 0x20(%rsp),%xmm5
movsd  %xmm0,0x0(%r13,%rbp,8)
movapd 0xb0(%rsp),%xmm6
unpcklpd 0x70(%rsp),%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
movsd  0x8(%rsp),%xmm7
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
movsd  0x50(%rsp),%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm5,%xmm2
mulsd  %xmm6,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm7,%xmm3
mulsd  %xmm6,%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%rsp)
movapd %xmm4,%xmm2
mulsd  %xmm6,%xmm2
movsd  %xmm2,0x50(%rsp)
xor    %eax,%eax
mov    0xa8(%rsp),%rdx
nopl   0x0(%rax)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm7
movsd  (%rcx,%rbx,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm6,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rcx,%rbp,8)
mulsd  %xmm6,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    29b0 <dsvdcmp0+0x1850>
movapd %xmm5,%xmm0
movapd %xmm5,0x20(%rsp)
movapd %xmm6,0xb0(%rsp)
movapd %xmm1,0x70(%rsp)
call   1050 <pythag@plt>
movapd 0xb0(%rsp),%xmm4
mov    0x40(%rsp),%r10
movsd  %xmm0,(%r10,%rbp,8)
ucomisd 0x5fd(%rip),%xmm0
mov    %r12,%r13
jne    2a32 <dsvdcmp0+0x18d2>
jnp    2a52 <dsvdcmp0+0x18f2>
movsd  0x5e6(%rip),%xmm4
divsd  %xmm0,%xmm4
movapd 0x20(%rsp),%xmm0
unpcklpd 0x70(%rsp),%xmm0
unpcklpd %xmm4,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
cmpl   $0x0,0xd0(%rsp)
mov    0x138(%rsp),%r12
mov    0x48(%rsp),%rdx
jle    28a0 <dsvdcmp0+0x1740>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%rbp,8),%xmm0
movsd  (%rcx,%rbx,8),%xmm5
movapd %xmm1,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
mulsd  %xmm4,%xmm5
subsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%rbx,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    2a80 <dsvdcmp0+0x1920>
jmp    28a0 <dsvdcmp0+0x1740>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
jbe    24d8 <dsvdcmp0+0x1378>
xorpd  0x52a(%rip),%xmm3
movlpd %xmm3,(%r10,%rdx,8)
cmpq   $0x3,0x68(%rsp)
mov    0x60(%rsp),%rbp
mov    0xf0(%rsp),%r8
jae    2b05 <dsvdcmp0+0x19a5>
xor    %eax,%eax
jmp    2b74 <dsvdcmp0+0x1a14>
xor    %eax,%eax
mov    0xa8(%rsp),%rbx
movapd 0x4f9(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rcx,%rdx,8)
mov    0x8(%rbx,%rax,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rcx,%rdx,8)
mov    0x10(%rbx,%rax,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rcx,%rdx,8)
mov    0x18(%rbx,%rax,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rcx,%rdx,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    2b20 <dsvdcmp0+0x19c0>
test   %rbp,%rbp
je     24d8 <dsvdcmp0+0x1378>
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
movapd 0x47d(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rcx,8),%rbx
movsd  (%rbx,%rdx,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rbx,%rdx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    2ba0 <dsvdcmp0+0x1a40>
jmp    24d8 <dsvdcmp0+0x1378>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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