#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);
double radius(double, double);
double sqrt(double);
void svd(int m, int n, double **a, double **p, double *d, double **q) {
  int flag, i, its, j, jj, k, l, nm, nm1 = n - 1, mm1 = m - 1;
  double c, f, h, s, x, y, z;
  double anorm = 0, g = 0, scale = 0;
  double *r = (double *)malloc(sizeof(double) * n);
  for (i = 0; i < m; i++)
    for (j = 0; j < n; j++)
      p[i][j] = a[i][j];
  for (i = 0; i < n; i++) {
    l = i + 1;
    r[i] = scale * g;
    g = s = scale = 0.0;
    if (i < m) {
      for (k = i; k < m; k++)
        scale += fabs(p[k][i]);
      if (scale) {
        for (k = i; k < m; k++) {
          p[k][i] /= scale;
          s += p[k][i] * p[k][i];
        }
        f = p[i][i];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        p[i][i] = f - g;
        if (i != nm1) {
          for (j = l; j < n; j++) {
            for (s = 0.0, k = i; k < m; k++)
              s += p[k][i] * p[k][j];
            f = s / h;
            for (k = i; k < m; k++)
              p[k][j] += f * p[k][i];
          }
        }
        for (k = i; k < m; k++)
          p[k][i] *= scale;
      }
    }
    d[i] = scale * g;
    g = s = scale = 0.0;
    if (i < m && i != nm1) {
      for (k = l; k < n; k++)
        scale += fabs(p[i][k]);
      if (scale) {
        for (k = l; k < n; k++) {
          p[i][k] /= scale;
          s += p[i][k] * p[i][k];
        }
        f = p[i][l];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        p[i][l] = f - g;
        for (k = l; k < n; k++)
          r[k] = p[i][k] / h;
        if (i != mm1) {
          for (j = l; j < m; j++) {
            for (s = 0.0, k = l; k < n; k++)
              s += p[j][k] * p[i][k];
            for (k = l; k < n; k++)
              p[j][k] += s * r[k];
          }
        }
        for (k = l; k < n; k++)
          p[i][k] *= scale;
      }
    }
    anorm = ((anorm) >= (fabs(d[i]) + fabs(r[i])) ? (anorm)
                                                  : (fabs(d[i]) + fabs(r[i])));
  }
  for (i = n - 1; i >= 0; i--) {
    if (i < nm1) {
      if (g) {
        for (j = l; j < n; j++)
          q[j][i] = (p[i][j] / p[i][l]) / g;
        for (j = l; j < n; j++) {
          for (s = 0.0, k = l; k < n; k++)
            s += p[i][k] * q[k][j];
          for (k = l; k < n; k++)
            q[k][j] += s * q[k][i];
        }
      }
      for (j = l; j < n; j++)
        q[i][j] = q[j][i] = 0.0;
    }
    q[i][i] = 1.0;
    g = r[i];
    l = i;
  }
  for (i = n - 1; i >= 0; i--) {
    l = i + 1;
    g = d[i];
    if (i < nm1)
      for (j = l; j < n; j++)
        p[i][j] = 0.0;
    if (g) {
      g = 1.0 / g;
      if (i != nm1) {
        for (j = l; j < n; j++) {
          for (s = 0.0, k = l; k < m; k++)
            s += p[k][i] * p[k][j];
          f = (s / p[i][i]) * g;
          for (k = i; k < m; k++)
            p[k][j] += f * p[k][i];
        }
      }
      for (j = i; j < m; j++)
        p[j][i] *= g;
    } else
      for (j = i; j < m; j++)
        p[j][i] = 0.0;
    ++p[i][i];
  }
  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 (fabs(r[l]) + anorm == anorm) {
          flag = 0;
          break;
        }
        if (fabs(d[nm]) + anorm == anorm)
          break;
      }
      if (flag) {
        c = 0.0;
        s = 1.0;
        for (i = l; i <= k; i++) {
          f = s * r[i];
          if (fabs(f) + anorm != anorm) {
            g = d[i];
            h = radius(f, g);
            d[i] = h;
            h = 1.0 / h;
            c = g * h;
            s = (-f * h);
            for (j = 0; j < m; j++) {
              y = p[j][nm];
              z = p[j][i];
              p[j][nm] = y * c + z * s;
              p[j][i] = z * c - y * s;
            }
          }
        }
      }
      z = d[k];
      if (l == k) {
        if (z < 0.0) {
          d[k] = -z;
          for (j = 0; j < n; j++)
            q[j][k] = (-q[j][k]);
        }
        break;
      }
      if (its == 30) {
        return;
      }
      x = d[l];
      nm = k - 1;
      y = d[nm];
      g = r[nm];
      h = r[k];
      f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
      g = radius(f, 1.0);
      f = ((x - z) * (x + z) +
           h * ((y / (f + ((f) >= 0.0 ? fabs(g) : -fabs(g)))) - h)) /
          x;
      c = s = 1.0;
      for (j = l; j <= nm; j++) {
        i = j + 1;
        g = r[i];
        y = d[i];
        h = s * g;
        g = c * g;
        z = radius(f, h);
        r[j] = z;
        c = f / z;
        s = h / z;
        f = x * c + g * s;
        g = g * c - x * s;
        h = y * s;
        y = y * c;
        for (jj = 0; jj < n; jj++) {
          x = q[jj][j];
          z = q[jj][i];
          q[jj][j] = x * c + z * s;
          q[jj][i] = z * c - x * s;
        }
        z = radius(f, h);
        d[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 = p[jj][j];
          z = p[jj][i];
          p[jj][j] = y * c + z * s;
          p[jj][i] = z * c - y * s;
        }
      }
      r[l] = 0.0;
      r[k] = f;
      d[k] = x;
    }
  }
  free(r);
}


x86 assembly (clang, -O0):
<svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    121b <svd+0xdb>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1208 <svd+0xc8>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11c4 <svd+0x84>
jmp    120d <svd+0xcd>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11b1 <svd+0x71>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a4d <svd+0x90d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15c5 <svd+0x485>
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12d1 <svd+0x191>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d51(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1287 <svd+0x147>
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12f1 <svd+0x1b1>
jp     12f1 <svd+0x1b1>
jmp    15c0 <svd+0x480>
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1373 <svd+0x233>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12f7 <svd+0x1b7>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     13c1 <svd+0x281>
movsd  -0x70(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps 0x1c50(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    13f5 <svd+0x2b5>
movsd  -0x70(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps 0x1c2e(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
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  -0x60(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1579 <svd+0x439>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1574 <svd+0x434>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14f6 <svd+0x3b6>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14a0 <svd+0x360>
movsd  -0x70(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1561 <svd+0x421>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    150b <svd+0x3cb>
jmp    1566 <svd+0x426>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1486 <svd+0x346>
jmp    1579 <svd+0x439>
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15bb <svd+0x47b>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    157f <svd+0x43f>
jmp    15c0 <svd+0x480>
jmp    15c5 <svd+0x485>
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1992 <svd+0x852>
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1992 <svd+0x852>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1668 <svd+0x528>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x19ba(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    161e <svd+0x4de>
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1688 <svd+0x548>
jp     1688 <svd+0x548>
jmp    198d <svd+0x84d>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    170a <svd+0x5ca>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    168e <svd+0x54e>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1758 <svd+0x618>
movsd  -0x70(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps 0x18b9(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    178c <svd+0x64c>
movsd  -0x70(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps 0x1897(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
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  -0x60(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1855 <svd+0x715>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1811 <svd+0x6d1>
mov    -0x30(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     1946 <svd+0x806>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1941 <svd+0x801>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18d7 <svd+0x797>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1881 <svd+0x741>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    192e <svd+0x7ee>
movsd  -0x70(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18dd <svd+0x79d>
jmp    1933 <svd+0x7f3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1867 <svd+0x727>
jmp    1946 <svd+0x806>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1988 <svd+0x848>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    194c <svd+0x80c>
jmp    198d <svd+0x84d>
jmp    1992 <svd+0x852>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1652(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x1637(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jb     19f0 <svd+0x8b0>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1a2f <svd+0x8ef>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x15fc(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x15e1(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1222 <svd+0xe2>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1c7b <svd+0xb3b>
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1c32 <svd+0xaf2>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a8c <svd+0x94c>
jp     1a8c <svd+0x94c>
jmp    1bdd <svd+0xa9d>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1af3 <svd+0x9b3>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a92 <svd+0x952>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1bd8 <svd+0xa98>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b69 <svd+0xa29>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b13 <svd+0x9d3>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1bc5 <svd+0xa85>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b6f <svd+0xa2f>
jmp    1bca <svd+0xa8a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1af9 <svd+0x9b9>
jmp    1bdd <svd+0xa9d>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c2d <svd+0xaed>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1be3 <svd+0xaa3>
jmp    1c32 <svd+0xaf2>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  0x13c6(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1a56 <svd+0x916>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1efe <svd+0xdbe>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1cf5 <svd+0xbb5>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1cf0 <svd+0xbb0>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cbe <svd+0xb7e>
jmp    1cf5 <svd+0xbb5>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d15 <svd+0xbd5>
jp     1d15 <svd+0xbd5>
jmp    1e91 <svd+0xd51>
movsd  0x12f3(%rip),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1e4a <svd+0xd0a>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1e45 <svd+0xd05>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1daf <svd+0xc6f>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1d59 <svd+0xc19>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e32 <svd+0xcf2>
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x40(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1ddc <svd+0xc9c>
jmp    1e37 <svd+0xcf7>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d3f <svd+0xbff>
jmp    1e4a <svd+0xd0a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e8c <svd+0xd4c>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e50 <svd+0xd10>
jmp    1ece <svd+0xd8e>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ec9 <svd+0xd89>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e97 <svd+0xd57>
jmp    1ece <svd+0xd8e>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  0x112a(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1c84 <svd+0xb44>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     28d5 <svd+0x1795>
movl   $0x0,-0x34(%rbp)
cmpl   $0x1e,-0x34(%rbp)
jge    28c2 <svd+0x1782>
movl   $0x1,-0x2c(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1fd1 <svd+0xe91>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x10a7(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jne    1f85 <svd+0xe45>
jp     1f85 <svd+0xe45>
movl   $0x0,-0x2c(%rbp)
jmp    1fd1 <svd+0xe91>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1067(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jne    1fbe <svd+0xe7e>
jp     1fbe <svd+0xe7e>
jmp    1fd1 <svd+0xe91>
jmp    1fc3 <svd+0xe83>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1f2f <svd+0xdef>
cmpl   $0x0,-0x2c(%rbp)
je     21c9 <svd+0x1089>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x1025(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     21c4 <svd+0x1084>
movsd  -0x70(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0xfd8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jne    204d <svd+0xf0d>
jp     204d <svd+0xf0d>
jmp    21b1 <svd+0x1071>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
call   1040 <radius@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xf7d(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    21ac <svd+0x106c>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%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    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    20dc <svd+0xf9c>
jmp    21b1 <svd+0x1071>
jmp    21b6 <svd+0x1076>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ff6 <svd+0xeb6>
jmp    21c9 <svd+0x1089>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    2293 <svd+0x1153>
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    228e <svd+0x114e>
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2289 <svd+0x1149>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    222e <svd+0x10ee>
jmp    228e <svd+0x114e>
jmp    28c2 <svd+0x1782>
cmpl   $0x1e,-0x34(%rbp)
jne    22a2 <svd+0x1162>
jmp    28e1 <svd+0x17a1>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
addsd  -0x88(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
subsd  -0x68(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm3
ff
addsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xcd4(%rip),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xcac(%rip),%xmm1
call   1040 <radius@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     23f4 <svd+0x12b4>
movsd  -0x98(%rbp),%xmm0
ff
movaps 0xc1d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    2426 <svd+0x12e6>
movsd  -0x98(%rbp),%xmm0
ff
movaps 0xbfd(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0xf0(%rbp),%xmm5
ff
addsd  %xmm5,%xmm4
divsd  %xmm4,%xmm3
subsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xb8f(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xb82(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     287a <svd+0x173a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1040 <radius@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x78(%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,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    26a9 <svd+0x1569>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x78(%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    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    25d9 <svd+0x1499>
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1040 <radius@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    26f5 <svd+0x15b5>
jp     26f5 <svd+0x15b5>
jmp    2731 <svd+0x15f1>
movsd  0x913(%rip),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2867 <svd+0x1727>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%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    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2797 <svd+0x1657>
jmp    286c <svd+0x172c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2499 <svd+0x1359>
mov    -0xa8(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f18 <svd+0xdd8>
jmp    28c7 <svd+0x1787>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1f07 <svd+0xdc7>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,%r15
mov    %r8,0x38(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,0x10(%rsp)
mov    %esi,%ebp
mov    %edi,%ebx
lea    0x0(,%rbp,8),%edi
call   1060 <malloc@plt>
mov    %rax,%rsi
mov    %ebx,%eax
mov    %rax,0xc8(%rsp)
mov    %ebp,%r12d
mov    %rbx,0x108(%rsp)
test   %ebx,%ebx
mov    %rbp,0x60(%rsp)
jle    1366 <svd+0x216>
mov    %r12d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r8
mov    %r8,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%r10
mov    %r12d,%r14d
and    $0x3,%r14d
mov    %r9,%r13
shl    $0x5,%r13
xor    %ecx,%ecx
jmp    11f2 <svd+0xa2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    0xc8(%rsp),%rcx
je     1366 <svd+0x216>
test   %ebp,%ebp
jle    11e0 <svd+0x90>
mov    0x10(%rsp),%rax
mov    (%rax,%rcx,8),%rdx
mov    0x28(%rsp),%rax
mov    (%rax,%rcx,8),%rax
cmp    $0x4,%ebp
jb     1223 <svd+0xd3>
lea    (%rdx,%r12,8),%rdi
cmp    %rdi,%rax
jae    129c <svd+0x14c>
lea    (%rax,%r12,8),%rdi
cmp    %rdi,%rdx
jae    129c <svd+0x14c>
xor    %ebx,%ebx
mov    %rbx,%rbp
not    %rbp
add    %r12,%rbp
test   %r14,%r14
je     1254 <svd+0x104>
mov    %r14,%rdi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdi
jne    1240 <svd+0xf0>
cmp    $0x3,%rbp
mov    0x60(%rsp),%rbp
jb     11e0 <svd+0x90>
nop
movsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x8(%rdx,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rbx,8)
movsd  0x10(%rdx,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rbx,8)
movsd  0x18(%rdx,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    1260 <svd+0x110>
jmp    11e0 <svd+0x90>
cmp    $0xc,%r8
jae    12a6 <svd+0x156>
xor    %ebx,%ebx
jmp    130c <svd+0x1bc>
mov    %r10,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rbx,8),%xmm0
movups 0x10(%rdx,%rbx,8),%xmm1
movups %xmm0,(%rax,%rbx,8)
movups %xmm1,0x10(%rax,%rbx,8)
movups 0x20(%rdx,%rbx,8),%xmm0
movups 0x30(%rdx,%rbx,8),%xmm1
movups %xmm0,0x20(%rax,%rbx,8)
movups %xmm1,0x30(%rax,%rbx,8)
movups 0x40(%rdx,%rbx,8),%xmm0
movups 0x50(%rdx,%rbx,8),%xmm1
movups %xmm0,0x40(%rax,%rbx,8)
movups %xmm1,0x50(%rax,%rbx,8)
movupd 0x60(%rdx,%rbx,8),%xmm0
movupd 0x70(%rdx,%rbx,8),%xmm1
movupd %xmm0,0x60(%rax,%rbx,8)
movupd %xmm1,0x70(%rax,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rbp
jne    12b0 <svd+0x160>
test   %r9,%r9
je     1350 <svd+0x200>
lea    (%rax,%rbx,8),%rbp
add    $0x10,%rbp
lea    (%rdx,%rbx,8),%rdi
add    $0x10,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rdi,%rbx,1),%xmm0
movupd (%rdi,%rbx,1),%xmm1
movupd %xmm0,-0x10(%rbp,%rbx,1)
movupd %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r13
jne    1330 <svd+0x1e0>
mov    %r11,%rbx
cmp    %r12,%r11
mov    0x60(%rsp),%rbp
je     11e0 <svd+0x90>
jmp    1225 <svd+0xd5>
test   %ebp,%ebp
mov    0x38(%rsp),%r9
mov    0x28(%rsp),%r13
jle    2bfb <svd+0x1aab>
lea    -0x1(%rbp),%eax
mov    0x108(%rsp),%rdx
lea    -0x1(%rdx),%ecx
movslq %edx,%r11
mov    %eax,%r8d
mov    %ecx,%eax
mov    %rax,0x178(%rsp)
lea    (%rsi,%r12,8),%rax
mov    %rax,0x120(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0xf8(%rsp)
lea    -0x2(%r12),%rax
mov    %rax,0x188(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x8(%rsp)
lea    0x18(%rsi),%rbx
lea    -0x3(%r12),%rdx
lea    0x38(%rsi),%rcx
lea    -0x5(%r12),%r14
xorpd  %xmm8,%xmm8
mov    $0x1,%eax
mov    %rax,0x50(%rsp)
mov    $0x3,%eax
mov    %rax,0xe0(%rsp)
movq   $0xffffffffffffffff,0xc0(%rsp)
mov    $0x7,%eax
mov    %rax,0x88(%rsp)
movapd 0x1bea(%rip),%xmm7
movapd 0x1be1(%rip),%xmm9
xorpd  %xmm12,%xmm12
xorpd  %xmm11,%xmm11
xorpd  %xmm10,%xmm10
mov    %r12,0xe8(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    %r14,%rax
xor    %r14d,%r14d
mov    %rsi,0x30(%rsp)
mov    %r11,0x78(%rsp)
mov    %r8,0xb0(%rsp)
jmp    1518 <svd+0x3c8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r9,%r14,8),%rsi
movq   $0x0,(%r9,%r14,8)
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
movsd  (%rsi),%xmm0
mov    0x30(%rsp),%rsi
movsd  (%rsi,%r14,8),%xmm1
andpd  %xmm9,%xmm0
andpd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm3
cmplesd %xmm10,%xmm3
movapd %xmm3,%xmm0
andnpd %xmm1,%xmm0
andpd  %xmm10,%xmm3
orpd   %xmm0,%xmm3
addq   $0x1,0x50(%rsp)
add    $0x8,%r13
addq   $0xffffffffffffffff,0x90(%rsp)
addq   $0xffffffffffffffff,0xe8(%rsp)
add    $0x8,%rbx
addq   $0x1,0xe0(%rsp)
add    $0xffffffffffffffff,%rdx
addq   $0xffffffffffffffff,0xc0(%rsp)
add    $0xffffffffffffffff,%rax
addq   $0x1,0x88(%rsp)
add    $0x8,%rcx
movapd %xmm3,%xmm10
mov    0x10(%rsp),%r14
cmp    %r12,%r14
je     1fdf <svd+0xe8f>
mulsd  %xmm11,%xmm12
lea    0x1(%r14),%r10
mov    %r10,0x10(%rsp)
movsd  %xmm12,(%rsi,%r14,8)
cmp    %r11,%r14
jge    1470 <svd+0x320>
mov    %rcx,0x40(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
mov    %rax,0x48(%rsp)
and    $0x3,%eax
mov    %rax,0x190(%rsp)
mov    %rdx,%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xd8(%rsp)
mov    0xf8(%rsp),%rcx
sub    %r14,%rcx
mov    %rcx,%rax
mov    %rcx,0x110(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,0x128(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x130(%rsp)
mov    0x188(%rsp),%rax
sub    %r14,%rax
mov    %rax,0x100(%rsp)
mov    %r14,%r10
not    %r10
lea    (%r10,%r12,1),%rax
add    $0xfffffffffffffffe,%rax
add    %r12,%r10
mov    %rax,0x180(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,0xf0(%rsp)
mov    0x50(%rsp),%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x138(%rsp)
xorpd  %xmm4,%xmm4
xor    %eax,%eax
mov    0x90(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rax
cmp    %rax,%rsi
jne    1600 <svd+0x4b0>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm4
xorpd  %xmm0,%xmm0
jne    1632 <svd+0x4e2>
jnp    1846 <svd+0x6f6>
xorpd  %xmm6,%xmm6
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%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,%rsi
jne    1640 <svd+0x4f0>
mov    0x28(%rsp),%rcx
mov    (%rcx,%r14,8),%rax
movsd  (%rax,%r14,8),%xmm5
ucomisd %xmm8,%xmm6
mov    %rdx,0xb8(%rsp)
jb     1690 <svd+0x540>
xorps  %xmm0,%xmm0
sqrtsd %xmm6,%xmm0
jmp    1749 <svd+0x5f9>
movapd %xmm6,%xmm0
mov    %rbx,0xa8(%rsp)
mov    %r9,%rbx
movapd %xmm10,0x160(%rsp)
mov    %rdi,0xd0(%rsp)
mov    %r10,%rbp
movsd  %xmm4,0x80(%rsp)
movsd  %xmm5,0x150(%rsp)
movsd  %xmm6,0x140(%rsp)
call   1070 <sqrt@plt>
movsd  0x140(%rsp),%xmm6
movsd  0x150(%rsp),%xmm5
movsd  0x80(%rsp),%xmm4
mov    %rbp,%r10
mov    0xd0(%rsp),%rdi
xorpd  %xmm11,%xmm11
movapd 0x160(%rsp),%xmm10
mov    0x90(%rsp),%rsi
movapd 0x18e6(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    0xb0(%rsp),%r8
mov    0x78(%rsp),%r11
mov    %rbx,%r9
mov    0xa8(%rsp),%rbx
mov    0x60(%rsp),%rbp
movapd 0x18bc(%rip),%xmm7
mov    0x28(%rsp),%rcx
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
movapd 0x18b7(%rip),%xmm3
orpd   %xmm3,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm5,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,%xmm0
xorpd  %xmm3,%xmm0
addsd  %xmm5,%xmm2
mov    (%rcx,%r14,8),%rax
movsd  %xmm2,(%rax,%r14,8)
cmp    %r8,%r14
je     181b <svd+0x6cb>
cmp    %r12,0x10(%rsp)
jae    181b <svd+0x6cb>
mulsd  %xmm0,%xmm5
subsd  %xmm6,%xmm5
mov    0x50(%rsp),%rax
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    17c0 <svd+0x670>
divsd  %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%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,%rsi
jne    17f0 <svd+0x6a0>
add    $0x1,%rax
cmp    %r12,%rax
jne    17b0 <svd+0x660>
xor    %eax,%eax
nopl   (%rax)
mov    0x0(%r13,%rax,8),%rcx
movsd  (%rcx,%r14,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%r14,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1820 <svd+0x6d0>
mov    0xb8(%rsp),%rdx
mulsd  %xmm0,%xmm4
lea    (%r9,%r14,8),%rsi
movsd  %xmm4,(%r9,%r14,8)
cmp    %r8,%r14
mov    0x40(%rsp),%rcx
mov    0x48(%rsp),%rax
je     1481 <svd+0x331>
cmp    %r12,0x10(%rsp)
jae    1481 <svd+0x331>
mov    %rsi,0x80(%rsp)
lea    0x0(,%r14,8),%rax
mov    0x28(%rsp),%rcx
add    (%rcx,%r14,8),%rax
xorpd  %xmm12,%xmm12
mov    $0x1,%ecx
mov    0xe8(%rsp),%rsi
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    18a0 <svd+0x750>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm12
jne    18c9 <svd+0x779>
jnp    1ec6 <svd+0xd76>
mov    %rdx,0xb8(%rsp)
mov    0x28(%rsp),%r11
mov    (%r11,%r14,8),%rax
xorpd  %xmm5,%xmm5
cmp    %r12,0x10(%rsp)
jae    1920 <svd+0x7d0>
lea    (%rax,%r14,8),%rcx
xorpd  %xmm5,%xmm5
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm12,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1900 <svd+0x7b0>
mov    0x10(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm4
ucomisd %xmm8,%xmm5
mov    %rbx,0xa8(%rsp)
mov    %rdi,0xd0(%rsp)
jb     194a <svd+0x7fa>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    19c0 <svd+0x870>
movapd %xmm5,%xmm0
movapd %xmm10,0x160(%rsp)
mov    %r10,%rbp
movapd %xmm12,0x150(%rsp)
movapd %xmm4,0x140(%rsp)
movsd  %xmm5,0x170(%rsp)
call   1070 <sqrt@plt>
movsd  0x170(%rsp),%xmm5
movapd 0x140(%rsp),%xmm4
movapd 0x150(%rsp),%xmm12
mov    %rbp,%r10
movapd 0x160(%rsp),%xmm10
movapd 0x1652(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x1645(%rip),%xmm7
mov    0x28(%rsp),%r11
mov    0x50(%rsp),%r8
mov    0xd8(%rsp),%rdi
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
movapd 0x1633(%rip),%xmm3
orpd   %xmm3,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm4,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,%xmm11
xorpd  %xmm3,%xmm11
addsd  %xmm4,%xmm2
mov    (%r11,%r14,8),%rax
mov    0x10(%rsp),%rcx
movsd  %xmm2,(%rax,%rcx,8)
cmp    %r12,%rcx
jae    1b47 <svd+0x9f7>
mulsd  %xmm11,%xmm4
subsd  %xmm5,%xmm4
mov    %r8,%rcx
cmp    $0x2,%r10
jb     1ae7 <svd+0x997>
lea    (%rax,%r12,8),%rcx
cmp    %rcx,0x138(%rsp)
jae    1a54 <svd+0x904>
lea    (%rax,%r8,8),%rdx
mov    %r8,%rcx
cmp    0x120(%rsp),%rdx
jb     1ae7 <svd+0x997>
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmpq   $0x2,0x180(%rsp)
jae    1a6b <svd+0x91b>
xor    %edx,%edx
jmp    1ab8 <svd+0x968>
mov    0xe0(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
xor    %edx,%edx
mov    0xa8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rsi,%rdx,8)
movupd (%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1a90 <svd+0x940>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
testb  $0x1,0xf0(%rsp)
01
je     1adf <svd+0x98f>
add    %r8,%rdx
movupd (%rax,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
mov    0x30(%rsp),%rsi
movupd %xmm1,(%rsi,%rdx,8)
cmp    %rcx,%r10
je     1b47 <svd+0x9f7>
add    %r8,%rcx
mov    %r12d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
test   $0x1,%sil
je     1b0c <svd+0x9bc>
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
mov    0x30(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,0xf8(%rsp)
mov    0x30(%rsp),%rcx
je     1b47 <svd+0x9f7>
nopl   0x0(%rax,%rax,1)
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,%r12
jne    1b20 <svd+0x9d0>
cmp    0x178(%rsp),%r14
je     1e4d <svd+0xcfd>
mov    0x10(%rsp),%rcx
cmp    0x78(%rsp),%rcx
jge    1e4d <svd+0xcfd>
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0xd8(%rsp)
add    %r8,%rcx
mov    %rcx,0xf0(%rsp)
mov    0xc0(%rsp),%r9
neg    %r9
lea    (%rax,%r8,8),%rdi
mov    %r8,%rdx
jmp    1bb2 <svd+0xa62>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
cmp    0xc8(%rsp),%rdx
je     1e4d <svd+0xcfd>
cmp    %r12,0x10(%rsp)
jae    1ba0 <svd+0xa50>
mov    (%r11,%rdx,8),%rcx
testb  $0x3,0x110(%rsp)
03
je     1cb0 <svd+0xb60>
lea    (%rcx,%r8,8),%rsi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
mov    0x190(%rsp),%rbx
nopl   (%rax)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  (%rdi,%rbp,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1be0 <svd+0xa90>
add    %r9,%rbp
cmpq   $0x3,0x100(%rsp)
jb     1c57 <svd+0xb07>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rbp,8),%xmm1
movsd  0x8(%rcx,%rbp,8),%xmm2
mulsd  (%rax,%rbp,8),%xmm1
mulsd  0x8(%rax,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rcx,%rbp,8),%xmm3
mulsd  0x10(%rax,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rcx,%rbp,8),%xmm0
mulsd  0x18(%rax,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%r12
jne    1c10 <svd+0xac0>
cmp    %r12,0x10(%rsp)
jae    1ba0 <svd+0xa50>
mov    (%r11,%rdx,8),%rcx
mov    %r8,%rbp
cmp    $0x4,%r10
jb     1dd0 <svd+0xc80>
lea    (%rcx,%r8,8),%rsi
cmp    0x120(%rsp),%rsi
jae    1c96 <svd+0xb46>
lea    (%rcx,%r12,8),%rsi
mov    %r8,%rbp
cmp    %rsi,0x138(%rsp)
jb     1dd0 <svd+0xc80>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x128(%rsp)
jae    1cc8 <svd+0xb78>
xor    %ebp,%ebp
jmp    1d63 <svd+0xc13>
xorpd  %xmm0,%xmm0
mov    %r8,%rbp
cmpq   $0x3,0x100(%rsp)
jae    1c10 <svd+0xac0>
jmp    1c57 <svd+0xb07>
mov    0x88(%rsp),%rsi
lea    (%rcx,%rsi,8),%rbx
mov    0xd0(%rsp),%rsi
xor    %ebp,%ebp
mov    0x40(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%r8,%rbp,8),%xmm2
movupd -0x20(%r8,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rbx,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rbx,%rbp,8),%xmm2
movupd -0x10(%rbx,%rbp,8),%xmm5
movupd (%rbx,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rbx,%rbp,8)
movupd %xmm3,-0x20(%rbx,%rbp,8)
movupd -0x10(%r8,%rbp,8),%xmm2
movupd (%r8,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rbx,%rbp,8)
movupd %xmm3,(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1cf0 <svd+0xba0>
testb  $0x1,0x130(%rsp)
01
mov    0x50(%rsp),%r8
je     1dab <svd+0xc5b>
add    %r8,%rbp
mov    0x30(%rsp),%rsi
movupd (%rsi,%rbp,8),%xmm2
movupd 0x10(%rsi,%rbp,8),%xmm3
movupd (%rcx,%rbp,8),%xmm4
movupd 0x10(%rcx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rbp,8)
movupd %xmm3,0x10(%rcx,%rbp,8)
mov    0xf0(%rsp),%rbp
cmp    0xd8(%rsp),%r10
je     1ba0 <svd+0xa50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12d,%ebx
sub    %ebp,%ebx
mov    %rbp,%rsi
test   $0x1,%bl
je     1df9 <svd+0xca9>
mov    0x30(%rsp),%rsi
movsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
lea    0x1(%rbp),%rsi
not    %rbp
cmp    0x8(%rsp),%rbp
je     1ba0 <svd+0xa50>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
movsd  0x8(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    1e10 <svd+0xcc0>
jmp    1ba0 <svd+0xa50>
cmp    %r12,0x10(%rsp)
jae    1e9f <svd+0xd4f>
mov    %r8,%rdx
cmp    $0x4,%r10
mov    0x60(%rsp),%rbp
mov    0x38(%rsp),%r9
mov    0xb0(%rsp),%r8
mov    0xa8(%rsp),%rbx
mov    0x80(%rsp),%rsi
jb     1fa2 <svd+0xe52>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x4,0x128(%rsp)
jae    1edd <svd+0xd8d>
xor    %ecx,%ecx
jmp    1f48 <svd+0xdf8>
mov    0x60(%rsp),%rbp
mov    0x38(%rsp),%r9
mov    0x78(%rsp),%r11
mov    0xb0(%rsp),%r8
mov    0xa8(%rsp),%rbx
mov    0xb8(%rsp),%rdx
mov    0x40(%rsp),%rcx
mov    0x48(%rsp),%rax
mov    0x80(%rsp),%rsi
jmp    1486 <svd+0x336>
mov    0x88(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0xd0(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%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,%rsi
jne    1f00 <svd+0xdb0>
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x130(%rsp)
01
je     1f7c <svd+0xe2c>
add    0x50(%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,%r10
mov    0x80(%rsp),%rsi
jne    1f9d <svd+0xe4d>
mov    0x78(%rsp),%r11
mov    0xb8(%rsp),%rdx
mov    0x40(%rsp),%rcx
jmp    1fd5 <svd+0xe85>
add    0x50(%rsp),%rdx
mov    0x40(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1fb0 <svd+0xe60>
mov    0x78(%rsp),%r11
mov    0xb8(%rsp),%rdx
mov    0x48(%rsp),%rax
jmp    1486 <svd+0x336>
test   %ebp,%ebp
jle    2bfb <svd+0x1aab>
xor    %r10d,%r10d
movabs $0x3ff0000000000000,%rbx
xorpd  %xmm0,%xmm0
mov    %r12,%rdx
mov    %ebp,%r11d
jmp    2024 <svd+0xed4>
mov    (%r15,%rdx,8),%rax
mov    %rbx,(%rax,%rdx,8)
mov    0x30(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm11
add    $0x1,%r10b
mov    %edx,%r11d
cmp    $0x1,%rbp
jle    22f4 <svd+0x11a4>
mov    %rdx,%rbp
movzbl %r10b,%r10d
and    $0x3,%r10d
add    $0xffffffffffffffff,%rdx
cmp    %r8,%rbp
jg     2000 <svd+0xeb0>
mov    %rbp,0x90(%rsp)
movslq %r11d,%rdi
mov    %r12,%r13
sub    %rdi,%r13
mov    %rdi,%r14
not    %r14
lea    (%r14,%r12,1),%rax
mov    %rax,0x10(%rsp)
ucomisd %xmm0,%xmm11
jne    2065 <svd+0xf15>
jnp    2220 <svd+0x10d0>
cmp    0x60(%rsp),%r11d
jge    2220 <svd+0x10d0>
mov    0x28(%rsp),%rax
mov    (%rax,%rdx,8),%rcx
movslq %r11d,%rbp
mov    %rbp,%rsi
nop
movsd  (%rcx,%rsi,8),%xmm1
divsd  (%rcx,%rbp,8),%xmm1
divsd  %xmm11,%xmm1
mov    (%r15,%rsi,8),%rbx
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    2080 <svd+0xf30>
cmp    0x60(%rsp),%r11d
mov    0x38(%rsp),%r9
jge    2220 <svd+0x10d0>
movslq %r11d,%r8
mov    0x28(%rsp),%rax
mov    (%rax,%rdx,8),%rsi
lea    0x1(%r8),%rax
mov    %rax,0x50(%rsp)
mov    %r8,%rcx
jmp    20e2 <svd+0xf92>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r12,%rcx
mov    0x38(%rsp),%r9
je     2220 <svd+0x10d0>
movapd %xmm3,%xmm4
xorpd  %xmm1,%xmm1
test   $0x3,%r13b
je     2200 <svd+0x10b0>
mov    %r10,%rbp
mov    %r8,%rbx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm2
mov    (%r15,%rbx,8),%r9
mulsd  (%r9,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jne    2100 <svd+0xfb0>
cmpq   $0x3,0x10(%rsp)
jb     2188 <svd+0x1038>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rbx,8),%xmm2
movsd  0x8(%rsi,%rbx,8),%xmm3
mov    (%r15,%rbx,8),%rbp
mov    0x8(%r15,%rbx,8),%rax
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rax,%rcx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rsi,%rbx,8),%xmm2
mov    0x10(%r15,%rbx,8),%rax
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x18(%rsi,%rbx,8),%xmm1
mov    0x18(%r15,%rbx,8),%rax
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %rbx,%r12
jne    2130 <svd+0xfe0>
mov    %r8,%rbx
test   $0x1,%r13b
je     21ad <svd+0x105d>
mov    (%r15,%r8,8),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    0x50(%rsp),%rbx
cmp    0x8(%rsp),%r14
movapd %xmm4,%xmm3
je     20d0 <svd+0xf80>
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
mov    0x8(%r15,%rbx,8),%rax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,(%rax,%rcx,8)
add    $0x2,%rbx
cmp    %rbx,%r12
jne    21c0 <svd+0x1070>
jmp    20d0 <svd+0xf80>
nopl   (%rax)
mov    %r8,%rbx
cmpq   $0x3,0x10(%rsp)
jae    2130 <svd+0xfe0>
jmp    2188 <svd+0x1038>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    0x60(%rsp),%r11d
mov    0xb0(%rsp),%r8
movabs $0x3ff0000000000000,%rbx
mov    0x90(%rsp),%rbp
jge    2000 <svd+0xeb0>
mov    (%r15,%rdx,8),%rcx
test   $0x3,%r13b
je     227e <svd+0x112e>
mov    %r10,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rdi,8),%rax
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,(%rcx,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    2260 <svd+0x1110>
cmpq   $0x3,0x10(%rsp)
jb     2000 <svd+0xeb0>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdi,8),%rax
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,(%rcx,%rdi,8)
mov    0x8(%r15,%rdi,8),%rax
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,0x8(%rcx,%rdi,8)
mov    0x10(%r15,%rdi,8),%rax
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,0x10(%rcx,%rdi,8)
mov    0x18(%r15,%rdi,8),%rax
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,0x18(%rcx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r12
jne    2290 <svd+0x1140>
jmp    2000 <svd+0xeb0>
mov    0x60(%rsp),%rdi
test   %edi,%edi
mov    0x28(%rsp),%r10
mov    0x78(%rsp),%rbx
jle    2bfb <svd+0x1aab>
lea    -0x8(%r10),%rbp
lea    0x1(%rbx),%r14
xor    %r11d,%r11d
xorpd  %xmm4,%xmm4
movsd  0xcfe(%rip),%xmm1
mov    %r8,%r13
mov    %r12,0x8(%rsp)
movapd %xmm3,0x110(%rsp)
jmp    237b <svd+0x122b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r10,%r13,8),%rax
movsd  (%rax,%r13,8),%xmm0
movsd  0xcce(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%r13,8)
add    $0x1,%r11
addq   $0xffffffffffffffff,0x8(%rsp)
add    $0xffffffffffffffff,%r13
add    $0xfffffffffffffff8,%rbp
add    $0x1,%r14
cmp    %r12,%r11
je     252b <svd+0x13db>
lea    0x1(%r13),%rax
mov    %rax,0x10(%rsp)
movsd  (%r9,%r13,8),%xmm2
cmp    %r8,%r13
jge    240b <svd+0x12bb>
cmp    %r12,0x10(%rsp)
jge    240b <svd+0x12bb>
movabs $0x7fffffff8,%rax
lea    (%rax,%r11,8),%rdx
and    %rax,%rdx
add    $0x8,%rdx
mov    %r12,%rdi
sub    %r11,%rdi
shl    $0x3,%rdi
add    (%r10,%r13,8),%rdi
xor    %esi,%esi
mov    %r11,%rbx
movsd  %xmm2,0x50(%rsp)
call   1040 <memset@plt>
movsd  0x50(%rsp),%xmm2
xorpd  %xmm4,%xmm4
mov    %rbx,%r11
movsd  0xc42(%rip),%xmm1
movapd 0x110(%rsp),%xmm3
mov    0xb0(%rsp),%r8
mov    0x78(%rsp),%rbx
mov    0x38(%rsp),%r9
mov    0x60(%rsp),%rdi
movapd 0xbfa(%rip),%xmm7
mov    0x28(%rsp),%r10
ucomisd %xmm4,%xmm2
jne    2417 <svd+0x12c7>
jnp    2500 <svd+0x13b0>
movapd %xmm1,%xmm0
divsd  %xmm2,%xmm0
cmp    %r8,%r13
je     24c0 <svd+0x1370>
cmp    %r12,0x10(%rsp)
jge    24c0 <svd+0x1370>
mov    (%r10,%r13,8),%rax
mov    0x8(%rsp),%rcx
jmp    2448 <svd+0x12f8>
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %edi,%ecx
je     24c0 <svd+0x1370>
xorpd  %xmm1,%xmm1
cmp    %rbx,0x10(%rsp)
jge    247c <svd+0x132c>
xorpd  %xmm1,%xmm1
mov    0x8(%rsp),%rdx
nopl   0x0(%rax)
mov    (%r10,%rdx,8),%rsi
movsd  (%rsi,%r13,8),%xmm2
mulsd  (%rsi,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdx
cmp    %rbx,%rdx
jl     2460 <svd+0x1310>
cmp    %rbx,%r13
jge    2440 <svd+0x12f0>
divsd  (%rax,%r13,8),%xmm1
mulsd  %xmm0,%xmm1
mov    %r12,%rdx
xchg   %ax,%ax
mov    0x0(%rbp,%rdx,8),%rsi
movsd  (%rsi,%r13,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rcx,8),%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2490 <svd+0x1340>
jmp    2440 <svd+0x12f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %rbx,%r13
jge    2340 <svd+0x11f0>
mov    %r12,%rax
nopl   0x0(%rax)
mov    0x0(%rbp,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%r13,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    24d0 <svd+0x1380>
jmp    2340 <svd+0x11f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12,%rax
cmp    %rbx,%r13
jge    2340 <svd+0x11f0>
nopl   0x0(%rax)
mov    0x0(%rbp,%rax,8),%rcx
movq   $0x0,(%rcx,%r13,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    2510 <svd+0x13c0>
jmp    2340 <svd+0x11f0>
test   %edi,%edi
mov    0x30(%rsp),%rsi
jle    2bfb <svd+0x1aab>
lea    -0x1(%r12),%rax
mov    %rax,0x48(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0xc0(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xe0(%rsp)
mov    %r12,0x88(%rsp)
jmp    2582 <svd+0x1432>
nopl   0x0(%rax,%rax,1)
addq   $0xffffffffffffffff,0x88(%rsp)
test   %r13,%r13
jle    2bfb <svd+0x1aab>
mov    0x48(%rsp),%r13
lea    -0x1(%r13),%rax
mov    %rax,0x48(%rsp)
xor    %edx,%edx
mov    %r13,0x40(%rsp)
jmp    25e6 <svd+0x1496>
nopl   0x0(%rax)
mov    0x38(%rsp),%r9
mov    0x30(%rsp),%rsi
mov    0x100(%rsp),%rax
movq   $0x0,(%rsi,%rax,8)
movsd  %xmm5,(%rsi,%r13,8)
movsd  %xmm3,(%r9,%r13,8)
mov    0xe8(%rsp),%edx
add    $0x1,%edx
cmp    $0x1e,%edx
movapd 0xa25(%rip),%xmm7
movapd 0x110(%rsp),%xmm3
je     2570 <svd+0x1420>
mov    0x88(%rsp),%rax
mov    %edx,0xe8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rax),%ecx
movsd  (%rsi,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm3,%xmm0
jne    2618 <svd+0x14c8>
jnp    2650 <svd+0x1500>
movsd  -0x10(%r9,%rax,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm3,%xmm0
jne    262f <svd+0x14df>
jnp    2660 <svd+0x1510>
add    $0xffffffffffffffff,%rax
jg     2600 <svd+0x14b0>
mov    $0xffffffff,%r14d
mov    $0xffffffffffffffff,%rax
jmp    2668 <svd+0x1518>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffff,%eax
mov    %eax,%r14d
jmp    27a5 <svd+0x1655>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rax),%r14d
add    $0xfffffffffffffffe,%rax
movsd  0x9b0(%rip),%xmm0
movslq %r14d,%rbp
cmp    %rbp,%r13
jl     27a5 <svd+0x1655>
movslq %eax,%rbx
movapd %xmm0,%xmm6
jmp    26bb <svd+0x156b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x30(%rsp),%rsi
movapd 0x963(%rip),%xmm7
movapd 0x110(%rsp),%xmm3
mov    0x40(%rsp),%r13
lea    0x1(%rbp),%rax
cmp    %r13,%rbp
mov    %rax,%rbp
jge    27a0 <svd+0x1650>
movsd  (%rsi,%rbp,8),%xmm0
mulsd  %xmm6,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
addsd  %xmm3,%xmm1
ucomisd %xmm3,%xmm1
jne    26d8 <svd+0x1588>
jnp    26ab <svd+0x155b>
mov    0x38(%rsp),%r13
movsd  0x0(%r13,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rsp)
movapd %xmm0,0x10(%rsp)
call   1050 <radius@plt>
movsd  %xmm0,0x0(%r13,%rbp,8)
movsd  0x91c(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd 0x10(%rsp),%xmm6
xorpd  0x8fa(%rip),%xmm6
mulsd  %xmm1,%xmm6
cmpl   $0x0,0x108(%rsp)
jle    2690 <svd+0x1540>
movsd  0x8(%rsp),%xmm5
mulsd  %xmm1,%xmm5
xor    %eax,%eax
mov    0x28(%rsp),%rdx
mov    0xc8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm1
movsd  (%rcx,%rbp,8),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm6,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
mulsd  %xmm5,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2750 <svd+0x1600>
jmp    2690 <svd+0x1540>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%r9
movsd  (%r9,%r13,8),%xmm2
mov    %r14d,%eax
cmp    %rax,%r13
je     2b10 <svd+0x19c0>
movslq %r14d,%r14
movsd  (%r9,%r14,8),%xmm0
movaps %xmm0,0x50(%rsp)
mov    0x48(%rsp),%rax
movsd  (%r9,%rax,8),%xmm5
movsd  (%rsi,%rax,8),%xmm0
movsd  (%rsi,%r13,8),%xmm3
movsd  %xmm3,0x10(%rsp)
movapd %xmm5,%xmm4
subsd  %xmm2,%xmm4
movapd %xmm2,%xmm1
addsd  %xmm5,%xmm1
movapd %xmm5,0x60(%rsp)
mulsd  %xmm4,%xmm1
movapd %xmm0,%xmm4
subsd  %xmm3,%xmm4
addsd  %xmm3,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm3,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm5,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x7f3(%rip),%xmm1
movapd %xmm2,0x90(%rsp)
call   1050 <radius@plt>
movapd 0x60(%rsp),%xmm5
movapd 0x50(%rsp),%xmm3
movapd %xmm3,%xmm1
movapd 0x90(%rsp),%xmm2
subsd  %xmm2,%xmm1
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm2,%xmm4
movapd %xmm0,%xmm1
andpd  0x790(%rip),%xmm1
orpd   0x798(%rip),%xmm0
xorpd  %xmm2,%xmm2
movsd  0x8(%rsp),%xmm6
cmpnlesd %xmm6,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
addsd  %xmm6,%xmm2
divsd  %xmm2,%xmm5
movsd  0x10(%rsp),%xmm0
subsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
divsd  %xmm3,%xmm5
cmp    %r14,%r13
mov    %r14,0x100(%rsp)
jle    25a0 <svd+0x1450>
movsd  0x756(%rip),%xmm4
movapd %xmm4,%xmm1
mov    0x38(%rsp),%r9
jmp    291e <svd+0x17ce>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x10(%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
mov    0x40(%rsp),%r13
cmp    %r13,%r14
jge    25a5 <svd+0x1455>
movapd %xmm5,0x60(%rsp)
movapd %xmm3,0x50(%rsp)
mov    %r14,%r13
add    $0x1,%r14
mov    %r14d,%ebp
mov    0x30(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm0
movsd  (%r9,%rbp,8),%xmm2
movsd  %xmm2,0x10(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x90(%rsp)
mulsd  %xmm0,%xmm4
movsd  %xmm4,0x8(%rsp)
movapd %xmm5,%xmm0
call   1050 <radius@plt>
movapd 0x50(%rsp),%xmm5
movsd  %xmm0,(%rbx,%r13,8)
movapd 0x60(%rsp),%xmm6
unpcklpd 0x90(%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  0x10(%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,0x10(%rsp)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm7
movsd  (%rcx,%rbp,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm6,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rcx,%r13,8)
mulsd  %xmm6,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    29f0 <svd+0x18a0>
movapd %xmm5,%xmm0
movapd %xmm5,0x50(%rsp)
movapd %xmm6,0x60(%rsp)
movapd %xmm1,0x90(%rsp)
call   1050 <radius@plt>
movapd 0x60(%rsp),%xmm4
mov    0x38(%rsp),%r9
movsd  %xmm0,(%r9,%r13,8)
ucomisd 0x5be(%rip),%xmm0
jne    2a6e <svd+0x191e>
jnp    2a91 <svd+0x1941>
movsd  0x5aa(%rip),%xmm4
divsd  %xmm0,%xmm4
movapd 0x50(%rsp),%xmm0
unpcklpd 0x90(%rsp),%xmm0
unpcklpd %xmm4,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
cmpl   $0x0,0x108(%rsp)
mov    0x28(%rsp),%rdx
mov    0xc8(%rsp),%rsi
jle    28e0 <svd+0x1790>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm0
movsd  (%rcx,%rbp,8),%xmm5
movapd %xmm1,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%r13,8)
mulsd  %xmm4,%xmm5
subsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%rbp,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2ac0 <svd+0x1970>
jmp    28e0 <svd+0x1790>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
movapd 0x4f0(%rip),%xmm1
mov    0xe0(%rsp),%rdx
jbe    2570 <svd+0x1420>
xorpd  0x4da(%rip),%xmm2
movlpd %xmm2,(%r9,%r13,8)
cmpq   $0x3,0xf8(%rsp)
jae    2b4b <svd+0x19fb>
xor    %eax,%eax
jmp    2bac <svd+0x1a5c>
xor    %eax,%eax
nopl   (%rax)
mov    (%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r13,8)
mov    0x8(%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r13,8)
mov    0x10(%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r13,8)
mov    0x18(%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rcx,%r13,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    2b50 <svd+0x1a00>
cmpq   $0x0,0xc0(%rsp)
je     2570 <svd+0x1420>
lea    (%r15,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,8),%rdx
movsd  (%rdx,%r13,8),%xmm0
xorpd  0x42e(%rip),%xmm0
movlpd %xmm0,(%rdx,%r13,8)
add    $0x1,%rcx
cmp    %rcx,0xc0(%rsp)
jne    2bd0 <svd+0x1a80>
jmp    2570 <svd+0x1420>
mov    %rsi,%rdi
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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