#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 *);
double hypot(double, double);
double macheps();
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *);
double sqrt(double);
int /*<<< orphan*/ svd_sort(double *, int, int, double *, double *);
int svd(double *A, int M, int N, double *U, double *V, double *q) {
  int i, j, k, l, t, t2, ierr, cancel, iter, l1;
  double eps, g, x, s, temp, f, h, c, y, z, scale;
  double *e;
  if (M < N) {
    printf("Rows (M) should be greater than Columns (B) \n");
    printf("Retry By Transposing the Input Matrix");
    return -1;
  }
  e = (double *)malloc(sizeof(double) * N);
  ierr = 0;
  eps = macheps();
  g = scale = x = 0.0;
  for (i = 0; i < M * N; ++i) {
    U[i] = A[i];
  }
  for (i = 0; i < N; ++i) {
    l = i + 1;
    e[i] = scale * g;
    g = 0.0;
    s = 0.0;
    scale = 0.0;
    if (i < M) {
      for (k = i; k < M; ++k) {
        scale += fabs(U[k * N + i]);
      }
      if (scale != 0.0) {
        for (k = i; k < M; ++k) {
          t = k * N;
          U[t + i] /= scale;
          temp = U[t + i];
          s += temp * temp;
        }
        f = U[i * N + i];
        g = (f < 0) ? sqrt(s) : -sqrt(s);
        h = f * g - s;
        U[i * N + i] = f - g;
        if (i < N - 1) {
          for (j = l; j < N; ++j) {
            s = 0.0;
            for (k = i; k < M; ++k) {
              t = k * N;
              s += U[t + i] * U[t + j];
            }
            f = s / h;
            for (k = i; k < M; ++k) {
              t = k * N;
              U[t + j] += f * U[t + i];
            }
          }
        }
        for (k = i; k < M; ++k) {
          t = k * N;
          U[t + i] *= scale;
        }
      }
    }
    q[i] = scale * g;
    g = 0.0;
    s = 0.0;
    scale = 0.0;
    if (i < M && i != N - 1) {
      t = i * N;
      for (k = l; k < M; ++k) {
        scale += fabs(U[t + k]);
      }
      if (scale != 0.0) {
        for (k = l; k < N; ++k) {
          U[t + k] /= scale;
          temp = U[t + k];
          s = s + temp * temp;
        }
        f = U[t + l];
        g = (f < 0) ? sqrt(s) : -sqrt(s);
        h = f * g - s;
        U[t + l] = f - g;
        for (k = l; k < N; ++k) {
          e[k] = U[t + k] / h;
        }
        for (j = l; j < M; j++) {
          s = 0.0;
          t2 = j * N;
          for (k = l; k < N; k++) {
            s += U[t2 + k] * U[t + k];
          }
          for (k = l; k < N; k++) {
            U[t2 + k] += s * e[k];
          }
        }
        for (k = l; k < N; k++)
          U[t + k] *= scale;
      }
    }
    temp = fabs(q[i]) + fabs(e[i]);
    if (x < temp) {
      x = temp;
    }
  }
  for (i = N - 1; i >= 0; --i) {
    t = i * N;
    if (i < N - 1) {
      if (g != 0.0) {
        h = U[t + i + 1] * g;
        for (j = l; j < N; ++j) {
          V[j * N + i] = U[t + j] / h;
        }
        for (j = l; j < N; ++j) {
          s = 0.0;
          for (k = l; k < N; ++k) {
            s += U[t + k] * V[k * N + j];
          }
          for (k = l; k < N; ++k) {
            V[k * N + j] += (s * V[k * N + i]);
          }
        }
      }
      for (j = l; j < N; ++j) {
        V[t + j] = V[j * N + i] = 0.0;
      }
    }
    V[t + i] = 1.0;
    g = e[i];
    l = i;
  }
  for (i = N - 1; i >= 0; --i) {
    t = i * N;
    l = i + 1;
    g = q[i];
    if (i < N - 1) {
      for (j = l; j < N; ++j) {
        U[t + j] = 0.0;
      }
    }
    if (g != 0.0) {
      if (i != N - 1) {
        for (j = l; j < N; ++j) {
          s = 0.0;
          for (k = l; k < M; ++k) {
            s += (U[k * N + i] * U[k * N + j]);
          }
          f = (s / U[t + i]) / g;
          for (k = i; k < M; ++k) {
            U[k * N + j] += (f * U[k * N + i]);
          }
        }
      }
      for (j = i; j < M; ++j) {
        U[j * N + i] = U[j * N + i] / g;
      }
    } else {
      for (j = i; j < M; ++j) {
        U[j * N + i] = 0.0;
      }
    }
    U[t + i] += 1.0;
  }
  eps = eps * x;
  for (k = N - 1; k >= 0; --k) {
    iter = 0;
    while (1) {
      iter++;
      if (iter > 50) {
        printf("Convergence Not Achieved \n");
        return 15;
      }
      cancel = 1;
      for (l = k; l >= 0; --l) {
        if (fabs(e[l]) <= eps) {
          cancel = 0;
          break;
        }
        if (fabs(q[l - 1]) <= eps) {
          break;
        }
      }
      if (cancel) {
        c = 0.0;
        s = 1.0;
        l1 = l - 1;
        for (i = l; i <= k; ++i) {
          f = s * e[i];
          e[i] *= c;
          if (fabs(f) <= eps) {
            break;
          }
          g = q[i];
          h = q[i] = hypot(f, g);
          c = g / h;
          s = -f / h;
          for (j = 0; j < M; ++j) {
            t = j * N;
            y = U[t + l1];
            z = U[t + i];
            U[t + l1] = y * c + z * s;
            U[t + i] = z * c - y * s;
          }
        }
      }
      z = q[k];
      if (l != k) {
        x = q[l];
        y = q[k - 1];
        g = e[k - 1];
        h = e[k];
        f = 0.5 * (((g + z) / h) * ((g - z) / y) + y / h - h / y);
        g = hypot(f, 1.0);
        if (f < 0.0) {
          temp = f - g;
        } else {
          temp = f + g;
        }
        f = x - (z / x) * z + (h / x) * (y / temp - h);
        c = s = 1.0;
        for (i = l + 1; i <= k; ++i) {
          g = e[i];
          y = q[i];
          h = s * g;
          g = c * g;
          e[i - 1] = z = hypot(f, h);
          c = f / z;
          s = h / z;
          f = x * c + g * s;
          g = g * c - x * s;
          h = y * s;
          y *= c;
          for (j = 0; j < N; ++j) {
            t = j * N;
            x = V[t + i - 1];
            z = V[t + i];
            V[t + i - 1] = x * c + z * s;
            V[t + i] = z * c - x * s;
          }
          q[i - 1] = z = hypot(f, h);
          if (z != 0.0) {
            c = f / z;
            s = h / z;
          }
          f = c * g + s * y;
          x = c * y - s * g;
          for (j = 0; j < M; ++j) {
            t = j * N;
            y = U[t + i - 1];
            z = U[t + i];
            U[t + i - 1] = y * c + z * s;
            U[t + i] = z * c - y * s;
          }
        }
        e[l] = 0.0;
        e[k] = f;
        q[k] = x;
      } else {
        if (z < 0.0) {
          q[k] = -z;
          for (j = 0; j < N; j++) {
            t = j * N;
            V[t + k] = -V[t + k];
          }
        }
        break;
      }
    }
  }
  svd_sort(U, M, N, V, q);
  free(e);
  return ierr;
}


x86 assembly (clang, -O0):
<svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11c1 <svd+0x51>
lea    0x1e7c(%rip),%rdi
call   1040 <printf@plt>
lea    0x1e9e(%rip),%rdi
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2892 <svd+0x1722>
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    $0x0,%al
call   1070 <macheps@plt>
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1246 <svd+0xd6>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120c <svd+0x9c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    19cd <svd+0x85d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15dd <svd+0x46d>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12f7 <svd+0x187>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d2b(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ac <svd+0x13c>
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1317 <svd+0x1a7>
jp     1317 <svd+0x1a7>
jmp    15d8 <svd+0x468>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1397 <svd+0x227>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    131d <svd+0x1ad>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    13dd <svd+0x26d>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1406 <svd+0x296>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    158a <svd+0x41a>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1585 <svd+0x415>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14fa <svd+0x38a>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14a0 <svd+0x330>
movsd  -0x78(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1572 <svd+0x402>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1515 <svd+0x3a5>
jmp    1577 <svd+0x407>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1486 <svd+0x316>
jmp    158a <svd+0x41a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15d3 <svd+0x463>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1590 <svd+0x420>
jmp    15d8 <svd+0x468>
jmp    15dd <svd+0x46d>
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1960 <svd+0x7f0>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1960 <svd+0x7f0>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1686 <svd+0x516>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x199c(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    163f <svd+0x4cf>
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16a6 <svd+0x536>
jp     16a6 <svd+0x536>
jmp    195b <svd+0x7eb>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    171c <svd+0x5ac>
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16ac <svd+0x53c>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    175e <svd+0x5ee>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1787 <svd+0x617>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1836 <svd+0x6c6>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17f2 <svd+0x682>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1917 <svd+0x7a7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18b0 <svd+0x740>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1860 <svd+0x6f0>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1904 <svd+0x794>
movsd  -0x78(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18b6 <svd+0x746>
jmp    1909 <svd+0x799>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    183c <svd+0x6cc>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1956 <svd+0x7e6>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    191d <svd+0x7ad>
jmp    195b <svd+0x7eb>
jmp    1960 <svd+0x7f0>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x168c(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1671(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    19ba <svd+0x84a>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    19bf <svd+0x84f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    124d <svd+0xdd>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1c0a <svd+0xa9a>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1bc7 <svd+0xa57>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a18 <svd+0x8a8>
jp     1a18 <svd+0x8a8>
jmp    1b74 <svd+0xa04>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a8a <svd+0x91a>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a40 <svd+0x8d0>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b6f <svd+0x9ff>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1afe <svd+0x98e>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aaa <svd+0x93a>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b5c <svd+0x9ec>
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b04 <svd+0x994>
jmp    1b61 <svd+0x9f1>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a90 <svd+0x920>
jmp    1b74 <svd+0xa04>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1bc2 <svd+0xa52>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b7a <svd+0xa0a>
jmp    1bc7 <svd+0xa57>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1434(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    19d6 <svd+0x866>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1e91 <svd+0xd21>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1c8d <svd+0xb1d>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1c88 <svd+0xb18>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c59 <svd+0xae9>
jmp    1c8d <svd+0xb1d>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1caa <svd+0xb3a>
jp     1caa <svd+0xb3a>
jmp    1e26 <svd+0xcb6>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1dd0 <svd+0xc60>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1dcb <svd+0xc5b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d33 <svd+0xbc3>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1cdb <svd+0xb6b>
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1db8 <svd+0xc48>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d5d <svd+0xbed>
jmp    1dbd <svd+0xc4d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cc1 <svd+0xb51>
jmp    1dd0 <svd+0xc60>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e21 <svd+0xcb1>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1dd6 <svd+0xc66>
jmp    1e64 <svd+0xcf4>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e5f <svd+0xcef>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e2c <svd+0xcbc>
jmp    1e64 <svd+0xcf4>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1197(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1c13 <svd+0xaa3>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     2869 <svd+0x16f9>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x32,-0x54(%rbp)
jle    1ee5 <svd+0xd75>
lea    0x11a0(%rip),%rdi
call   1040 <printf@plt>
movl   $0xf,-0x4(%rbp)
jmp    2892 <svd+0x1722>
movl   $0x1,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1f76 <svd+0xe06>
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x10ed(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f32 <svd+0xdc2>
movl   $0x0,-0x50(%rbp)
jmp    1f76 <svd+0xe06>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x10b5(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f63 <svd+0xdf3>
jmp    1f76 <svd+0xe06>
jmp    1f68 <svd+0xdf8>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1ef2 <svd+0xd82>
cmpl   $0x0,-0x50(%rbp)
je     218a <svd+0x101a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x107d(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     2185 <svd+0x1015>
movsd  -0x78(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movaps 0x1004(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2014 <svd+0xea4>
jmp    2185 <svd+0x1015>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
call   1060 <hypot@plt>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2172 <svd+0x1002>
mov    -0x38(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2095 <svd+0xf25>
jmp    2177 <svd+0x1007>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1fa7 <svd+0xe37>
jmp    218a <svd+0x101a>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     27a4 <svd+0x1634>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm1
addsd  -0xa8(%rbp),%xmm1
ff
divsd  -0x90(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm2
subsd  -0xa8(%rbp),%xmm2
ff
divsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
subsd  %xmm0,%xmm1
movsd  0xdb1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0xd8d(%rip),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    22b5 <svd+0x1145>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    22c7 <svd+0x1157>
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
divsd  -0x70(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
divsd  -0x80(%rbp),%xmm2
subsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xcd6(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xcc9(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     2762 <svd+0x15f2>
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
call   1060 <hypot@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xb8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%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  -0xa0(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2581 <svd+0x1411>
mov    -0x38(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    24a7 <svd+0x1337>
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
call   1060 <hypot@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    25d0 <svd+0x1460>
jp     25d0 <svd+0x1460>
jmp    25fd <svd+0x148d>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    274f <svd+0x15df>
mov    -0x38(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    266c <svd+0x14fc>
jmp    2754 <svd+0x15e4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2358 <svd+0x11e8>
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2851 <svd+0x16e1>
xorps  %xmm0,%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
jbe    284c <svd+0x16dc>
movsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2847 <svd+0x16d7>
mov    -0x38(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    27e8 <svd+0x1678>
jmp    284c <svd+0x16dc>
jmp    2856 <svd+0x16e6>
jmp    1eba <svd+0xd4a>
jmp    285b <svd+0x16eb>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1ea9 <svd+0xd39>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1090 <svd_sort@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x228,%rsp
cmp    %edx,%esi
jge    11c7 <svd+0x37>
lea    0x2ecc(%rip),%rdi
call   1040 <puts@plt>
lea    0x2e80(%rip),%rdi
call   1050 <printf@plt>
mov    $0xffffffff,%eax
jmp    348c <svd+0x22fc>
mov    %esi,%ebx
mov    %rdi,%r15
mov    %r8,0x78(%rsp)
mov    %r9,0xa8(%rsp)
lea    0x0(,%rdx,8),%edi
mov    %rdx,0x80(%rsp)
mov    %rcx,0x20(%rsp)
call   1070 <malloc@plt>
mov    %rax,0x18(%rsp)
xor    %eax,%eax
call   1090 <macheps@plt>
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%r10
movapd %xmm0,%xmm8
mov    %r10d,%ecx
imul   %ebx,%ecx
test   %ecx,%ecx
mov    %rbx,%r9
jle    1398 <svd+0x208>
mov    %ecx,%eax
cmp    $0x4,%ecx
jb     1242 <svd+0xb2>
lea    (%r15,%rax,8),%rcx
cmp    %rdi,%rcx
jbe    12c0 <svd+0x130>
lea    (%rdi,%rax,8),%rcx
cmp    %r15,%rcx
jbe    12c0 <svd+0x130>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1275 <svd+0xe5>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1260 <svd+0xd0>
cmp    $0x3,%rdx
jb     1398 <svd+0x208>
nop
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
movsd  0x10(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rcx,8)
movsd  0x18(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1280 <svd+0xf0>
jmp    1398 <svd+0x208>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rbp
jae    12e3 <svd+0x153>
xor    %ebp,%ebp
jmp    1354 <svd+0x1c4>
and    $0xfffffffffffffffc,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups (%r15,%rbp,8),%xmm0
movups 0x10(%r15,%rbp,8),%xmm1
movups %xmm0,(%rdi,%rbp,8)
movups %xmm1,0x10(%rdi,%rbp,8)
movups 0x20(%r15,%rbp,8),%xmm0
movups 0x30(%r15,%rbp,8),%xmm1
movups %xmm0,0x20(%rdi,%rbp,8)
movups %xmm1,0x30(%rdi,%rbp,8)
movups 0x40(%r15,%rbp,8),%xmm0
movups 0x50(%r15,%rbp,8),%xmm1
movups %xmm0,0x40(%rdi,%rbp,8)
movups %xmm1,0x50(%rdi,%rbp,8)
movupd 0x60(%r15,%rbp,8),%xmm0
movupd 0x70(%r15,%rbp,8),%xmm1
movupd %xmm0,0x60(%rdi,%rbp,8)
movupd %xmm1,0x70(%rdi,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    12f0 <svd+0x160>
test   %rdx,%rdx
je     138f <svd+0x1ff>
lea    (%rdi,%rbp,8),%rsi
add    $0x10,%rsi
lea    (%r15,%rbp,8),%rbx
add    $0x10,%rbx
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movupd -0x10(%rbx,%rbp,1),%xmm0
movupd (%rbx,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1370 <svd+0x1e0>
cmp    %rax,%rcx
jne    1244 <svd+0xb4>
test   %r10d,%r10d
mov    0xa8(%rsp),%r8
jle    3470 <svd+0x22e0>
lea    -0x1(%r10),%eax
mov    %rax,0x88(%rsp)
mov    %r10d,%r13d
movslq %r9d,%rax
mov    %rax,0x110(%rsp)
mov    %r9d,%eax
mov    %rax,0x108(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x1a0(%rsp)
lea    0x0(,%r13,8),%r14
lea    0x8(,%r13,8),%rax
mov    %rax,0x160(%rsp)
mov    0x18(%rsp),%rax
lea    (%rax,%r13,8),%rdx
mov    %rdx,0x120(%rsp)
lea    0x8(%rdi),%rbp
lea    -0x1(%r13),%rdx
mov    %rdx,0x140(%rsp)
lea    -0x2(%r13),%rdx
mov    %rdx,0x1c8(%rsp)
mov    %r13,%rcx
neg    %rcx
mov    %rcx,0x148(%rsp)
lea    0x18(%rax),%rdx
lea    -0x3(%r13),%rbx
lea    (%rdi,%r13,8),%rcx
mov    %rcx,0x48(%rsp)
xorpd  %xmm9,%xmm9
movapd 0x2bb5(%rip),%xmm7
movapd 0x2bac(%rip),%xmm10
xorpd  %xmm13,%xmm13
xorpd  %xmm4,%xmm4
xorpd  %xmm11,%xmm11
lea    0x38(%rdi,%r13,8),%rcx
lea    0x38(%rax),%r12
mov    %r12,0x100(%rsp)
lea    -0x5(%r13),%rsi
mov    %rsi,0x150(%rsp)
mov    $0x1,%esi
mov    %rsi,0x30(%rsp)
xor    %r15d,%r15d
mov    %rdi,0xf8(%rsp)
mov    %rbp,0xd0(%rsp)
mov    %r13,%r11
mov    %rbp,0x178(%rsp)
mov    %rbp,0x28(%rsp)
mov    %rbx,%rsi
mov    0x48(%rsp),%rbp
mov    0x108(%rsp),%rbx
mov    %rbx,0xc0(%rsp)
mov    %rdi,%r12
mov    %r9,0xb8(%rsp)
movsd  %xmm8,0xf0(%rsp)
mov    %r13,0x10(%rsp)
jmp    1584 <svd+0x3f4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r8,%r15,8),%rbx
movq   $0x0,(%r8,%r15,8)
xorpd  %xmm11,%xmm11
xorpd  %xmm13,%xmm13
movsd  (%rbx),%xmm0
movsd  (%rax,%r15,8),%xmm4
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm4
addsd  %xmm0,%xmm4
maxsd  %xmm12,%xmm4
addq   $0x1,0x30(%rsp)
mov    0x160(%rsp),%rbx
add    %rbx,%r12
addq   $0xffffffffffffffff,0xc0(%rsp)
add    %rbx,0x28(%rsp)
add    $0xffffffffffffffff,%r11
add    $0x8,%rdx
add    $0xffffffffffffffff,%rsi
add    %r14,0xd0(%rsp)
add    %r14,%rbp
add    %rbx,%rcx
addq   $0x8,0x100(%rsp)
addq   $0xffffffffffffffff,0x150(%rsp)
add    %r14,0xf8(%rsp)
mov    0x60(%rsp),%r15
cmp    %r13,%r15
je     216f <svd+0xfdf>
movapd %xmm4,%xmm12
mulsd  %xmm11,%xmm13
lea    0x1(%r15),%rbx
mov    %rbx,0x60(%rsp)
movsd  %xmm13,(%rax,%r15,8)
cmp    0x110(%rsp),%r15
jge    14f0 <svd+0x360>
mov    %rcx,0xa0(%rsp)
mov    %rbp,0x48(%rsp)
mov    0x150(%rsp),%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
mov    %rsi,%rcx
shr    %rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x130(%rsp)
mov    0x140(%rsp),%rbp
sub    %r15,%rbp
mov    %rbp,%rcx
mov    %rbp,0xb0(%rsp)
lea    -0x4(%rbp),%rcx
mov    %rcx,0x138(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x180(%rsp)
mov    %r15,%rcx
not    %rcx
lea    (%rcx,%r13,1),%rbp
add    $0xfffffffffffffffe,%rbp
add    %r13,%rcx
mov    %rcx,0x58(%rsp)
mov    %rbp,0x1a8(%rsp)
mov    %rbp,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,0x1b0(%rsp)
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    %rax,0x190(%rsp)
mov    0x160(%rsp),%rcx
imul   %r15,%rcx
mov    0x178(%rsp),%rax
mov    %rcx,0x1f0(%rsp)
add    %rcx,%rax
mov    %rax,0x1b8(%rsp)
mov    %r15,%rax
imul   %r13,%rax
mov    %rax,%rcx
mov    %rax,0xe8(%rsp)
add    %r13,%rax
mov    %r15,%rcx
mov    %r13,%r15
lea    (%rdi,%rax,8),%rax
mov    %rax,0x1c0(%rsp)
mov    %rcx,0x8(%rsp)
lea    0x2(%rcx),%rax
imul   %r13,%rax
mov    %rax,0x188(%rsp)
xorpd  %xmm3,%xmm3
mov    0xc0(%rsp),%rbp
mov    %rbp,%rax
mov    %r12,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm3
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    16d0 <svd+0x540>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm3
xorpd  %xmm1,%xmm1
mov    0x110(%rsp),%r13
mov    0x8(%rsp),%r15
jne    1708 <svd+0x578>
jnp    1935 <svd+0x7a5>
mov    %rbx,%r13
xorpd  %xmm5,%xmm5
mov    %rbp,%rax
mov    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    1720 <svd+0x590>
mov    %r15d,%eax
imul   %r10d,%eax
movslq %eax,%rbx
add    %r15,%rbx
movsd  (%rdi,%rbx,8),%xmm4
ucomisd %xmm9,%xmm5
mov    %rdx,0x98(%rsp)
mov    %rsi,0x90(%rsp)
jb     177a <svd+0x5ea>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
mov    0x88(%rsp),%rax
jmp    1824 <svd+0x694>
movapd %xmm5,%xmm0
mov    %r11,%r15
movsd  %xmm12,0x128(%rsp)
movsd  %xmm3,0x50(%rsp)
movsd  %xmm4,0x1e0(%rsp)
movsd  %xmm5,0x1d0(%rsp)
call   10a0 <sqrt@plt>
movsd  0x1d0(%rsp),%xmm5
movsd  0x1e0(%rsp),%xmm4
movsd  0x50(%rsp),%xmm3
movsd  0x128(%rsp),%xmm12
mov    %r15,%r11
mov    0x8(%rsp),%r15
mov    0xc0(%rsp),%rbp
xorpd  %xmm11,%xmm11
movapd 0x2818(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x88(%rsp),%rax
movapd 0x2803(%rip),%xmm7
movsd  0xf0(%rsp),%xmm8
mov    0xb8(%rsp),%r9
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%r10
mov    0xa8(%rsp),%r8
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  0x27d2(%rip),%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
cmp    %rax,%r15
mov    %r13,%rbx
mov    0x110(%rsp),%r13
jae    18fc <svd+0x76c>
mov    0x60(%rsp),%rax
cmp    0x10(%rsp),%rax
jae    18fc <svd+0x76c>
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mov    0x28(%rsp),%rax
mov    0x30(%rsp),%rcx
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    %rbp,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%r12,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm0
add    %r14,%rsi
add    $0xffffffffffffffff,%rdx
jne    18a0 <svd+0x710>
divsd  %xmm4,%xmm0
mov    %rbp,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rsi,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %r14,%rsi
add    $0xffffffffffffffff,%rdx
jne    18d0 <svd+0x740>
add    $0x1,%rcx
add    $0x8,%rax
cmp    0x10(%rsp),%rcx
jne    1890 <svd+0x700>
mov    %rbp,%rax
mov    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    1910 <svd+0x780>
mov    0x98(%rsp),%rdx
mov    0x90(%rsp),%rsi
mulsd  %xmm1,%xmm3
lea    (%r8,%r15,8),%rax
mov    %rax,0x50(%rsp)
movsd  %xmm3,(%r8,%r15,8)
cmp    0x88(%rsp),%r15
mov    0x18(%rsp),%rax
mov    0xa0(%rsp),%rcx
je     1a30 <svd+0x8a0>
cmp    %r13,0x60(%rsp)
jge    1a30 <svd+0x8a0>
xorpd  %xmm13,%xmm13
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm13
add    $0x1,%rax
cmp    %rax,%rbp
jne    1980 <svd+0x7f0>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm13
jne    19aa <svd+0x81a>
jnp    1a49 <svd+0x8b9>
mov    %rbx,0x1e0(%rsp)
xorpd  %xmm3,%xmm3
mov    0x60(%rsp),%r8
cmp    0x10(%rsp),%r8
jae    19f2 <svd+0x862>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
divsd  %xmm13,%xmm0
movsd  %xmm0,(%r12,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%r11
jne    19d0 <svd+0x840>
mov    0xe8(%rsp),%rax
lea    (%rax,%r8,1),%rbx
movsd  (%rdi,%rbx,8),%xmm2
ucomisd %xmm9,%xmm3
mov    %rdx,0x98(%rsp)
mov    %r11,0x198(%rsp)
jb     1a50 <svd+0x8c0>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1ad6 <svd+0x946>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm13,%xmm13
mov    0x10(%rsp),%r13
mov    0x48(%rsp),%rbp
mov    0x50(%rsp),%rbx
jmp    1506 <svd+0x376>
mov    0x18(%rsp),%rax
jmp    1a35 <svd+0x8a5>
movapd %xmm3,%xmm0
mov    %rsi,%r15
movsd  %xmm12,0x128(%rsp)
movapd %xmm13,0x1d0(%rsp)
mov    %r8,%rbp
movapd %xmm2,0x210(%rsp)
movsd  %xmm3,0x208(%rsp)
call   10a0 <sqrt@plt>
movsd  0x208(%rsp),%xmm3
movapd 0x210(%rsp),%xmm2
mov    %rbp,%r8
movapd 0x1d0(%rsp),%xmm13
movsd  0x128(%rsp),%xmm12
movapd 0x2549(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    %r15,%rsi
movapd 0x2539(%rip),%xmm7
movsd  0xf0(%rsp),%xmm8
mov    0x20(%rsp),%rdi
mov    0x130(%rsp),%rbp
movapd %xmm2,%xmm11
cmpltsd %xmm9,%xmm11
movapd %xmm11,%xmm1
andpd  %xmm0,%xmm1
xorpd  0x2516(%rip),%xmm0
andnpd %xmm0,%xmm11
orpd   %xmm1,%xmm11
movapd %xmm2,%xmm0
subsd  %xmm11,%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
cmp    0x10(%rsp),%r8
mov    0x18(%rsp),%rdx
mov    0xd0(%rsp),%rbx
jae    1c87 <svd+0xaf7>
mulsd  %xmm11,%xmm2
subsd  %xmm3,%xmm2
mov    0x30(%rsp),%rax
cmpq   $0x2,0x58(%rsp)
jb     1c0f <svd+0xa7f>
mov    0x1c0(%rsp),%rax
cmp    %rax,0x190(%rsp)
jae    1b71 <svd+0x9e1>
mov    0x30(%rsp),%rax
mov    0x1b8(%rsp),%rcx
cmp    0x120(%rsp),%rcx
jb     1c0f <svd+0xa7f>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x2,0x1a8(%rsp)
jae    1b88 <svd+0x9f8>
xor    %ecx,%ecx
jmp    1bc8 <svd+0xa38>
xor    %ecx,%ecx
mov    0x98(%rsp),%rax
mov    0x28(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rax,%rcx,8)
movupd 0x10(%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1ba0 <svd+0xa10>
mov    0x58(%rsp),%rax
and    $0xfffffffffffffffe,%rax
testb  $0x1,0x1b0(%rsp)
01
je     1bfe <svd+0xa6e>
add    0x30(%rsp),%rcx
mov    0xe8(%rsp),%rdx
add    %rcx,%rdx
movupd (%rdi,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
mov    0x18(%rsp),%rdx
movupd %xmm1,(%rdx,%rcx,8)
cmp    %rax,0x58(%rsp)
mov    0x18(%rsp),%rdx
je     1c87 <svd+0xaf7>
add    0x30(%rsp),%rax
mov    0x10(%rsp),%rdx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     1c40 <svd+0xab0>
mov    0xe8(%rsp),%rcx
add    %rax,%rcx
movsd  (%rdi,%rcx,8),%xmm0
divsd  %xmm2,%xmm0
mov    0x18(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
lea    0x1(%rax),%rcx
cmp    %rax,0x140(%rsp)
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rax
je     1c87 <svd+0xaf7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rbx,%rcx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1c60 <svd+0xad0>
mov    %rsi,0x90(%rsp)
cmp    %r13,%r8
mov    %rdx,%rax
jge    1f89 <svd+0xdf9>
mov    0x30(%rsp),%rdx
mov    0xe8(%rsp),%rcx
lea    (%rdx,%rcx,1),%r10
lea    0x1(%rdx),%r11
mov    0x58(%rsp),%r9
and    $0xfffffffffffffffc,%r9
lea    (%rdx,%r9,1),%r8
mov    0xa0(%rsp),%rdi
mov    0x48(%rsp),%rbp
xor    %r15d,%r15d
jmp    1cec <svd+0xb5c>
nop
add    $0x1,%rdx
add    $0x1,%r15
add    %r14,%rbp
add    %r14,%rdi
cmp    0x108(%rsp),%rdx
je     1f89 <svd+0xdf9>
mov    0x10(%rsp),%rcx
cmp    %rcx,0x60(%rsp)
jae    1cd0 <svd+0xb40>
mov    %rdx,%r13
imul   %rcx,%r13
xorpd  %xmm1,%xmm1
mov    0x30(%rsp),%rcx
testb  $0x1,0xb0(%rsp)
01
je     1d3c <svd+0xbac>
mov    0x30(%rsp),%rax
lea    (%rax,%r13,1),%rcx
mov    0x20(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mulsd  (%rax,%r10,8),%xmm0
mov    0x18(%rsp),%rax
addsd  %xmm9,%xmm0
mov    %r11,%rcx
movapd %xmm0,%xmm1
mov    0x8(%rsp),%rsi
cmp    %rsi,0x1c8(%rsp)
mov    0x10(%rsp),%rsi
mov    0xd0(%rsp),%rbx
je     1d8c <svd+0xbfc>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm0
mulsd  -0x8(%rbx,%rcx,8),%xmm2
mulsd  (%rbx,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rcx
movapd %xmm0,%xmm1
cmp    %rcx,%rsi
jne    1d60 <svd+0xbd0>
cmp    %rsi,0x60(%rsp)
jae    1cd0 <svd+0xb40>
mov    0x30(%rsp),%rcx
cmpq   $0x4,0x58(%rsp)
jb     1f00 <svd+0xd70>
mov    %r15,%rcx
imul   %rsi,%rcx
mov    0x1a0(%rsp),%rax
lea    (%rax,%rcx,1),%rbx
mov    0x20(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
mov    0x18(%rsp),%rax
add    0x1f0(%rsp),%rbx
cmp    0x120(%rsp),%rbx
jae    1e04 <svd+0xc74>
add    0x188(%rsp),%rcx
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,8),%rbx
mov    0x18(%rsp),%rax
mov    0x30(%rsp),%rcx
cmp    %rbx,0x190(%rsp)
jb     1f00 <svd+0xd70>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x138(%rsp)
mov    0x100(%rsp),%rsi
jae    1e26 <svd+0xc96>
xor    %ebx,%ebx
jmp    1e9f <svd+0xd0f>
mov    0x1e0(%rsp),%rcx
xor    %ebx,%ebx
movupd -0x30(%rsi,%rbx,8),%xmm2
movupd -0x20(%rsi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdi,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rdi,%rbx,8),%xmm2
movupd -0x10(%rdi,%rbx,8),%xmm5
movupd (%rdi,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rdi,%rbx,8)
movupd %xmm3,-0x20(%rdi,%rbx,8)
movupd -0x10(%rsi,%rbx,8),%xmm2
movupd (%rsi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rdi,%rbx,8)
movupd %xmm3,(%rdi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1e30 <svd+0xca0>
testb  $0x1,0x180(%rsp)
01
je     1eec <svd+0xd5c>
add    0x30(%rsp),%rbx
movupd (%rax,%rbx,8),%xmm2
movupd 0x10(%rax,%rbx,8),%xmm3
add    %r13,%rbx
mov    0x20(%rsp),%rax
movupd (%rax,%rbx,8),%xmm4
movupd 0x10(%rax,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm3,0x10(%rax,%rbx,8)
mov    0x18(%rsp),%rax
mov    %r8,%rcx
cmp    %r9,0x58(%rsp)
mov    0x10(%rsp),%rsi
je     1cd0 <svd+0xb40>
nop
mov    %esi,%eax
sub    %ecx,%eax
mov    %rcx,%rbx
test   $0x1,%al
je     1f31 <svd+0xda1>
add    %rcx,%r13
mov    0x18(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x20(%rsp),%rax
addsd  (%rax,%r13,8),%xmm1
movsd  %xmm1,(%rax,%r13,8)
lea    0x1(%rcx),%rbx
not    %rcx
cmp    0x148(%rsp),%rcx
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rcx
je     1cd0 <svd+0xb40>
nopl   0x0(%rax)
movsd  (%rax,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
movsd  0x8(%rax,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbp,%rbx,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1f50 <svd+0xdc0>
jmp    1cd0 <svd+0xb40>
mov    0x10(%rsp),%r13
cmp    %r13,0x60(%rsp)
jae    2006 <svd+0xe76>
mov    0x30(%rsp),%rcx
cmpq   $0x4,0x58(%rsp)
mov    0xa8(%rsp),%r8
mov    0x80(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    0xb8(%rsp),%r9
mov    0x98(%rsp),%rdx
mov    0x90(%rsp),%rsi
mov    0x8(%rsp),%r15
mov    0x50(%rsp),%rbx
jb     2124 <svd+0xf94>
movapd %xmm13,%xmm0
unpcklpd %xmm13,%xmm0
cmpq   $0x4,0x138(%rsp)
mov    0x198(%rsp),%r11
jae    2057 <svd+0xec7>
xor    %eax,%eax
mov    0x48(%rsp),%rbp
jmp    20b8 <svd+0xf28>
mov    0xa8(%rsp),%r8
mov    0x80(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    0xb8(%rsp),%r9
mov    0x98(%rsp),%rdx
mov    0x90(%rsp),%rsi
mov    0x48(%rsp),%rbp
mov    0xa0(%rsp),%rcx
mov    0x198(%rsp),%r11
mov    0x8(%rsp),%r15
mov    0x50(%rsp),%rbx
jmp    1506 <svd+0x376>
xor    %eax,%eax
mov    0x48(%rsp),%rbp
mov    0x28(%rsp),%rcx
mov    0x1e0(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rax,8),%xmm1
movupd 0x10(%rcx,%rax,8),%xmm2
movupd 0x20(%rcx,%rax,8),%xmm3
movupd 0x30(%rcx,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rcx,%rax,8)
movupd %xmm2,0x10(%rcx,%rax,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x20(%rcx,%rax,8)
movupd %xmm4,0x30(%rcx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    2070 <svd+0xee0>
mov    0x58(%rsp),%rbx
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
testb  $0x1,0x180(%rsp)
01
je     20f9 <svd+0xf69>
add    0x30(%rsp),%rax
add    0xe8(%rsp),%rax
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
cmp    %rcx,%rbx
jne    2115 <svd+0xf85>
mov    0x18(%rsp),%rax
mov    0xa0(%rsp),%rcx
mov    0x50(%rsp),%rbx
jmp    1506 <svd+0x376>
add    0x30(%rsp),%rcx
mov    0x18(%rsp),%rax
mov    0x50(%rsp),%rbx
mov    0x48(%rsp),%rbp
mov    0xf8(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r11,%rcx,8),%xmm0
mulsd  %xmm13,%xmm0
movsd  %xmm0,(%r11,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    2140 <svd+0xfb0>
mov    0xa0(%rsp),%rcx
mov    0x198(%rsp),%r11
jmp    1506 <svd+0x376>
test   %r10d,%r10d
jle    3470 <svd+0x22e0>
mov    %r13,%r12
add    %r13,%r12
mov    0x140(%rsp),%rbp
mov    %rbp,%rsi
imul   %r13,%rsi
lea    (%rdi,%rsi,8),%rcx
add    $0x8,%rcx
neg    %r14
mov    %r13,%rdx
shl    $0x4,%rdx
mov    0x78(%rsp),%rax
lea    -0x8(%rax),%rbx
mov    %rbx,0x28(%rsp)
lea    (%rax,%rsi,8),%r11
add    $0x8,%r11
movq   $0xfffffffffffffff8,0x50(%rsp)
ff ff
xorpd  %xmm0,%xmm0
mov    %rbp,0xb0(%rsp)
mov    %rax,0x98(%rsp)
mov    %r13,%rbp
mov    0x148(%rsp),%r15
jmp    2241 <svd+0x10b1>
nop
movslq 0xa0(%rsp),%rax
mov    0xc0(%rsp),%rbp
add    %rbp,%rax
mov    0x78(%rsp),%rsi
movabs $0x3ff0000000000000,%rbx
mov    %rbx,(%rsi,%rax,8)
mov    0x18(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm11
addq   $0xfffffffffffffff8,0x98(%rsp)
add    %r14,%rcx
addq   $0xffffffffffffffff,0xb0(%rsp)
addq   $0xfffffffffffffff8,0x28(%rsp)
addq   $0xfffffffffffffff8,0x50(%rsp)
add    %r14,%r11
cmpq   $0x1,0x8(%rsp)
jle    2682 <svd+0x14f2>
lea    -0x1(%rbp),%rsi
mov    %rsi,%rax
mov    %rsi,0xc0(%rsp)
imul   %r10d,%esi
mov    %rsi,0xa0(%rsp)
mov    %rbp,%rax
mov    %rbp,0x8(%rsp)
cmp    0x88(%rsp),%rbp
jg     21e0 <svd+0x1050>
mov    %r11,0x58(%rsp)
movslq 0x8(%rsp),%r8
mov    %r13,%rax
sub    %r8,%rax
mov    %rax,0x60(%rsp)
mov    %r8,%rax
mov    %r8,0x48(%rsp)
not    %r8
mov    0xc0(%rsp),%rax
imul   %r13,%rax
mov    %rax,0x90(%rsp)
ucomisd %xmm0,%xmm11
mov    %r8,0xd0(%rsp)
jne    22bb <svd+0x112b>
jnp    25a0 <svd+0x1410>
mov    0x8(%rsp),%rax
cmp    0x80(%rsp),%eax
jge    25a0 <svd+0x1410>
mov    0xc0(%rsp),%rdi
mov    0xa0(%rsp),%rax
lea    (%rax,%rdi,1),%esi
movslq %esi,%rsi
mov    0x20(%rsp),%rax
mulsd  0x8(%rax,%rsi,8),%xmm11
movslq 0x8(%rsp),%rbx
testb  $0x1,0x60(%rsp)
je     2328 <svd+0x1198>
mov    0x90(%rsp),%rsi
add    %rbx,%rsi
movsd  (%rax,%rsi,8),%xmm1
divsd  %xmm11,%xmm1
mov    %rbx,%rsi
imul   %r13,%rsi
add    %rdi,%rsi
mov    0x78(%rsp),%rax
movsd  %xmm1,(%rax,%rsi,8)
add    $0x1,%rbx
cmp    %r15,%r8
mov    0x80(%rsp),%rax
je     239b <svd+0x120b>
mov    %r13,%rsi
imul   %rbx,%rsi
mov    0x98(%rsp),%rbp
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
lea    0x1(%rbx),%rdi
imul   %r13,%rdi
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
mov    0x140(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm1
divsd  %xmm11,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
movsd  (%rcx,%rbx,8),%xmm1
divsd  %xmm11,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
add    $0x2,%rbx
add    %r12,%rbp
cmp    %rbx,%r13
jne    2370 <svd+0x11e0>
cmp    %eax,0x8(%rsp)
jge    25a0 <svd+0x1410>
mov    0x78(%rsp),%r10
mov    0x48(%rsp),%rax
lea    (%r10,%rax,8),%r9
movslq 0x8(%rsp),%r11
mov    0x90(%rsp),%rax
add    %r11,%rax
mov    %rax,0x100(%rsp)
mov    %r11,%rsi
imul   %r13,%rsi
lea    0x1(%r11),%rax
mov    %rax,0x150(%rsp)
mov    0xc0(%rsp),%rax
mov    %rsi,0x160(%rsp)
add    %rsi,%rax
mov    %rax,0xf8(%rsp)
mov    %r11,0x30(%rsp)
jmp    2422 <svd+0x1292>
add    $0x1,%r11
add    $0x8,%r10
add    $0x8,%r9
mov    0x10(%rsp),%r13
cmp    %r13,%r11
mov    0xd0(%rsp),%r8
je     25a0 <svd+0x1410>
xorpd  %xmm2,%xmm2
mov    0x30(%rsp),%rbx
testb  $0x1,0x60(%rsp)
mov    0x78(%rsp),%rax
je     2469 <svd+0x12d9>
mov    0x20(%rsp),%rsi
mov    0x100(%rsp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
mov    0x160(%rsp),%rsi
add    %r11,%rsi
mulsd  (%rax,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x150(%rsp),%rbx
movapd %xmm1,%xmm2
cmp    %r15,%r8
je     24be <svd+0x132e>
mov    %r13,%rsi
imul   %rbx,%rsi
lea    (%r10,%rsi,8),%rsi
lea    0x1(%rbx),%rdi
imul   %r13,%rdi
lea    (%r10,%rdi,8),%rbp
mov    0x48(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm3
mulsd  (%rsi,%rdi,8),%xmm3
movsd  (%rcx,%rbx,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  0x0(%rbp,%rdi,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rbx
add    %r12,%rdi
movapd %xmm1,%xmm2
cmp    %rbx,%r13
jne    2490 <svd+0x1300>
mov    0x30(%rsp),%rdi
testb  $0x1,0x60(%rsp)
je     24f8 <svd+0x1368>
mov    0x160(%rsp),%rsi
add    %r11,%rsi
mov    0xf8(%rsp),%rdi
movsd  (%rax,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rsi,8),%xmm2
movsd  %xmm2,(%rax,%rsi,8)
mov    0x150(%rsp),%rdi
cmp    %r15,%r8
je     2400 <svd+0x1270>
mov    0x10(%rsp),%r15
mov    %r15,%rbx
sub    %rdi,%rbx
mov    %r15,%rbp
imul   %rdi,%rbp
lea    (%r11,%rbp,1),%rsi
mov    0x78(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
add    0xb0(%rsp),%rbp
lea    (%rax,%rbp,8),%rbp
lea    0x1(%rdi),%rax
imul   %r15,%rax
lea    (%r9,%rax,8),%r8
lea    0x10(,%rdi,8),%r13
imul   %r15,%r13
mov    0x148(%rsp),%r15
add    0x28(%rsp),%r13
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rdi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rdi,1),%xmm2
movsd  %xmm2,(%rsi,%rdi,1)
movsd  0x0(%r13,%rdi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r8,%rdi,1),%xmm2
movsd  %xmm2,(%r8,%rdi,1)
add    %rdx,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2560 <svd+0x13d0>
jmp    2400 <svd+0x1270>
nopl   0x0(%rax)
mov    0x80(%rsp),%r10
cmp    %r10d,0x8(%rsp)
mov    0xa8(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0xb8(%rsp),%r9
mov    0x58(%rsp),%r11
jge    21e0 <svd+0x1050>
movslq 0x8(%rsp),%rbx
testb  $0x1,0x60(%rsp)
je     260c <svd+0x147c>
mov    %rbx,%rax
imul   %r13,%rax
add    0xc0(%rsp),%rax
mov    0x78(%rsp),%rsi
movq   $0x0,(%rsi,%rax,8)
mov    0x90(%rsp),%rax
add    %rbx,%rax
movq   $0x0,(%rsi,%rax,8)
add    $0x1,%rbx
cmp    %r15,0xd0(%rsp)
mov    0x58(%rsp),%r11
je     21e0 <svd+0x1050>
lea    0x10(,%rbx,8),%rsi
imul   %r13,%rsi
mov    0x78(%rsp),%rbp
add    %rbp,%rsi
lea    0x8(,%rbx,8),%rax
imul   %r13,%rax
add    %rbp,%rax
mov    0x50(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rax,%rbp,1)
movq   $0x0,-0x8(%r11,%rbx,8)
movq   $0x0,(%rsi,%rbp,1)
movq   $0x0,(%r11,%rbx,8)
add    $0x2,%rbx
add    %rdx,%rbp
cmp    %rbx,%r13
jne    2650 <svd+0x14c0>
jmp    21e0 <svd+0x1050>
test   %r10d,%r10d
mov    0x88(%rsp),%rsi
jle    3470 <svd+0x22e0>
mov    %r10d,%eax
imul   %r10d,%eax
mov    %eax,0x150(%rsp)
mov    %r10d,%eax
not    %eax
mov    %eax,0x28(%rsp)
mov    %r13,%rax
imul   %r13,%rax
lea    (%rdi,%rax,8),%r15
add    $0xfffffffffffffff8,%r15
lea    0x0(,%r13,8),%r14
mov    %r14,%rcx
xor    $0xfffffffffffffff8,%rcx
mov    %rcx,0x160(%rsp)
mov    0x110(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,0x60(%rsp)
lea    0x1(%r13),%rcx
imul   %r13,%rcx
lea    (%rdi,%rcx,8),%rbx
mov    %r13,%rdx
lea    (%rdi,%rcx,8),%r13
add    $0xfffffffffffffff8,%r13
lea    (%rdi,%rax,8),%rax
mov    %rax,0xc0(%rsp)
xor    %ebp,%ebp
xorpd  %xmm3,%xmm3
movsd  0x190e(%rip),%xmm2
movapd %xmm4,0x1f0(%rsp)
jmp    2761 <svd+0x15d1>
nopl   (%rax)
movslq %r9d,%rax
add    %rdx,%rax
movsd  (%rdi,%rax,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    0x8(%rsp),%rbp
add    $0x1,%rbp
mov    0x160(%rsp),%rax
add    %rax,%r15
add    %rax,%rbx
add    %rax,%r13
add    %rax,0xc0(%rsp)
cmp    0x10(%rsp),%rbp
je     2998 <svd+0x1808>
mov    %rdx,%r12
add    $0xffffffffffffffff,%rdx
movsd  -0x8(%r8,%r12,8),%xmm5
cmp    %rsi,%r12
mov    %rdx,0x30(%rsp)
jg     280d <svd+0x167d>
cmp    0x10(%rsp),%r12
jge    280d <svd+0x167d>
movabs $0x7fffffff8,%rax
lea    (%rax,%rbp,8),%rdx
and    %rax,%rdx
add    $0x8,%rdx
mov    0x28(%rsp),%eax
imul   %ebp,%eax
add    0x150(%rsp),%eax
cltq
lea    (%rdi,%rax,8),%rdi
xor    %esi,%esi
movsd  %xmm5,0x8(%rsp)
call   1060 <memset@plt>
movsd  0x8(%rsp),%xmm5
mov    0x30(%rsp),%rdx
xorpd  %xmm3,%xmm3
movapd 0x1f0(%rsp),%xmm4
movsd  0x1842(%rip),%xmm2
mov    0x88(%rsp),%rsi
movapd 0x1812(%rip),%xmm7
movsd  0xf0(%rsp),%xmm8
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%r10
mov    0xa8(%rsp),%r8
mov    %rbp,0x8(%rsp)
mov    %edx,%r9d
imul   %r10d,%r9d
ucomisd %xmm3,%xmm5
mov    0x110(%rsp),%rbp
jne    282d <svd+0x169d>
jnp    2960 <svd+0x17d0>
mov    %rbx,0xd0(%rsp)
cmp    %rsi,%rdx
je     2910 <svd+0x1780>
cmp    0x10(%rsp),%r12
jge    2910 <svd+0x1780>
mov    0x30(%rsp),%rax
mov    %rax,%r11
imul   0x10(%rsp),%r11
add    %rax,%r11
mov    0xc0(%rsp),%rdx
mov    0xd0(%rsp),%rsi
mov    %r12,%rcx
jmp    2885 <svd+0x16f5>
nop
add    $0x1,%rcx
add    $0x8,%rsi
add    $0x8,%rdx
cmp    %r10d,%ecx
je     2910 <svd+0x1780>
xorpd  %xmm0,%xmm0
cmp    %rbp,%r12
jge    28bc <svd+0x172c>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    %r12,%rax
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,1),%xmm1
mulsd  (%rsi,%rbx,1),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    %r14,%rbx
cmp    %rbp,%rax
jl     28a0 <svd+0x1710>
cmp    %rbp,%r12
jg     2870 <svd+0x16e0>
divsd  (%rdi,%r11,8),%xmm0
divsd  %xmm5,%xmm0
mov    0x60(%rsp),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rbx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rbx,1),%xmm1
movsd  %xmm1,(%rdx,%rbx,1)
add    %r14,%rbx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    28e0 <svd+0x1750>
jmp    2870 <svd+0x16e0>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rbp,%r12
mov    0x88(%rsp),%rsi
mov    0xd0(%rsp),%rbx
mov    0x30(%rsp),%rdx
jg     2720 <svd+0x1590>
mov    0x60(%rsp),%rax
mov    %r15,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    2940 <svd+0x17b0>
jmp    2720 <svd+0x1590>
nopl   (%rax)
mov    0x60(%rsp),%rax
mov    %r15,%rcx
cmp    %rbp,%r12
jg     2720 <svd+0x1590>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    2980 <svd+0x17f0>
jmp    2720 <svd+0x1590>
test   %r10d,%r10d
mov    0xb8(%rsp),%r9
mov    0x10(%rsp),%rcx
jle    3470 <svd+0x22e0>
mulsd  %xmm4,%xmm8
movabs $0xffffffff00000000,%rdx
ff ff ff
lea    -0x1(%rcx),%r12
mov    0x108(%rsp),%rax
lea    -0x1(%rax),%rsi
lea    (%rdi,%rax,8),%rbp
mov    %rbp,0x1c8(%rsp)
lea    0x1(%rax),%rbp
mov    %rbp,0x1b8(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x188(%rsp)
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x1a0(%rsp)
mov    %rcx,%rbp
shl    $0x20,%rbp
lea    (%rdx,%rbp,1),%rax
mov    %rax,0x138(%rsp)
lea    -0x2(%r9),%eax
mov    %rax,0x1b0(%rsp)
movabs $0xfffffffe00000000,%rax
ff ff ff
add    %rbp,%rax
mov    %rax,0x130(%rsp)
lea    0x0(,%rcx,8),%r15
mov    0x78(%rsp),%rax
lea    0x8(%rax),%rdx
mov    %rdx,0x1a8(%rsp)
mov    %rcx,%rdx
shl    $0x21,%rdx
mov    %rdx,0x1f0(%rsp)
mov    %rcx,%r11
shl    $0x4,%r11
xorpd  %xmm0,%xmm0
movhpd 0x15b4(%rip),%xmm0
movapd %xmm0,0x1e0(%rsp)
movapd 0x1593(%rip),%xmm1
shr    $0x20,%rsi
mov    %rsi,0x190(%rsp)
lea    0x8(%rdi),%rdx
mov    %rdx,0x128(%rsp)
lea    (%r11,%rax,1),%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x1d0(%rsp)
lea    (%rax,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x120(%rsp)
movsd  %xmm8,0xf0(%rsp)
mov    %r11,0xb0(%rsp)
mov    %r12,%rbx
lea    -0x1(%r12),%r13
mov    $0x1,%eax
mov    %r13,0x178(%rsp)
mov    %r12,0x28(%rsp)
jmp    2b45 <svd+0x19b5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movsd  0xf0(%rsp),%xmm8
movapd 0x14f6(%rip),%xmm7
mov    0x1c0(%rsp),%r14
mov    0x18(%rsp),%rax
movq   $0x0,(%rax,%r14,8)
movsd  %xmm0,(%rax,%rbx,8)
movsd  %xmm3,(%r8,%rbx,8)
mov    0x180(%rsp),%eax
add    $0x1,%eax
cmp    $0x33,%eax
movapd 0x14d1(%rip),%xmm1
je     349e <svd+0x230e>
mov    %eax,0x180(%rsp)
mov    %ebx,%ecx
mov    0x130(%rsp),%rdx
mov    0x138(%rsp),%rsi
mov    %rbx,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rax
mov    %rsi,%r13
mov    %rdx,%rbx
mov    %rcx,0x8(%rsp)
test   %r14,%r14
mov    %rsi,0x60(%rsp)
js     2bdc <svd+0x1a4c>
mov    %rax,%r12
mov    %eax,%eax
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
andpd  %xmm7,%xmm0
ucomisd %xmm0,%xmm8
jae    2bee <svd+0x1a5e>
mov    %r12,%rax
lea    -0x1(%r12),%r14
movsd  -0x8(%r8,%r12,8),%xmm0
andpd  %xmm7,%xmm0
movabs $0xffffffff00000000,%rcx
ff ff ff
mov    0x60(%rsp),%r13
lea    0x0(%r13,%rcx,1),%rsi
lea    (%rbx,%rcx,1),%rdx
mov    0x8(%rsp),%rcx
add    $0xffffffff,%ecx
ucomisd %xmm0,%xmm8
jb     2b70 <svd+0x19e0>
mov    %rax,%r12
sar    $0x20,%r13
cmp    0x28(%rsp),%r13
jle    3230 <svd+0x20a0>
mov    0x28(%rsp),%rbx
movsd  (%r8,%rbx,8),%xmm2
mov    %r12d,%eax
cmp    %rbx,%rax
je     3384 <svd+0x21f4>
mov    0x60(%rsp),%rax
mov    %rax,%r14
sar    $0x20,%r14
sar    $0x1d,%rax
movsd  (%r8,%rax,1),%xmm0
movaps %xmm0,0x30(%rsp)
mov    0x178(%rsp),%r13
movsd  (%r8,%r13,8),%xmm4
movsd  %xmm4,0x110(%rsp)
mov    0x18(%rsp),%rax
movsd  (%rax,%r13,8),%xmm5
movsd  (%rax,%rbx,8),%xmm3
movapd %xmm2,%xmm1
addsd  %xmm5,%xmm1
divsd  %xmm3,%xmm1
subsd  %xmm2,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm4,%xmm0
movapd %xmm3,0x60(%rsp)
divsd  %xmm3,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm3,%xmm1
divsd  %xmm4,%xmm1
subsd  %xmm1,%xmm0
mulsd  0x13a3(%rip),%xmm0
movsd  %xmm0,0x88(%rsp)
movsd  0x138a(%rip),%xmm1
movapd %xmm2,0xd0(%rsp)
call   1080 <hypot@plt>
movapd 0x30(%rsp),%xmm3
movsd  0x88(%rsp),%xmm4
movapd %xmm4,%xmm1
cmpltsd 0x1370(%rip),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
xorpd  0x1340(%rip),%xmm0
andpd  %xmm1,%xmm0
orpd   %xmm2,%xmm0
addsd  %xmm4,%xmm0
movapd 0xd0(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm2
subsd  %xmm1,%xmm2
movsd  0x110(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd 0x60(%rsp),%xmm0
subsd  %xmm0,%xmm1
divsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cmp    %rbx,%r14
jge    31f0 <svd+0x2060>
lea    0x1(%r14),%rax
mov    %rax,0x98(%rsp)
mov    0x1b8(%rsp),%rax
add    %r14,%rax
mov    %rax,0x90(%rsp)
unpcklpd %xmm0,%xmm3
mov    0x1b0(%rsp),%rax
add    %r12,%rax
mov    %rax,0xe8(%rsp)
add    $0xffffffffffffffff,%r12
mov    %r12,0x50(%rsp)
movslq 0x8(%rsp),%rsi
mov    %rsi,%r13
shl    $0x20,%r13
mov    0x1a8(%rsp),%rax
lea    (%rax,%rsi,8),%r12
mov    0x128(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,0x58(%rsp)
add    $0x1,%rsi
xor    %ecx,%ecx
mov    %r14,0x1c0(%rsp)
movsd  0x127d(%rip),%xmm1
movapd %xmm1,%xmm6
mov    0xa8(%rsp),%r8
mov    0x20(%rsp),%rdi
jmp    2e40 <svd+0x1cb0>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
xorpd  0x1244(%rip),%xmm0
movapd 0xc0(%rsp),%xmm3
movapd %xmm3,%xmm2
movapd 0x160(%rsp),%xmm4
unpcklpd %xmm4,%xmm2
unpcklpd %xmm1,%xmm0
mulpd  %xmm2,%xmm0
unpcklpd %xmm3,%xmm4
movapd %xmm6,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm0,%xmm3
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
movabs $0x100000000,%rax
add    %rax,%r13
mov    0xd0(%rsp),%r12
add    $0x8,%r12
addq   $0x8,0x58(%rsp)
add    $0x1,%rsi
mov    0x28(%rsp),%rbx
mov    0x88(%rsp),%r14
cmp    %rbx,%r14
jge    2af0 <svd+0x1960>
movapd %xmm3,0x30(%rsp)
mov    %rsi,0x110(%rsp)
mov    0x50(%rsp),%rdx
lea    (%rdx,%rcx,1),%eax
add    $0x1,%eax
cltq
lea    (%rdi,%rax,8),%rsi
mov    %rsi,0x48(%rsp)
mov    %rcx,%rsi
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x148(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%rsi,1),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0xf8(%rsp)
mov    0x90(%rsp),%rax
lea    (%rax,%rsi,1),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0x100(%rsp)
mov    %rsi,0x8(%rsp)
lea    0x1(%rdx,%rsi,1),%rax
mov    %rax,0xa0(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x88(%rsp)
mov    0x18(%rsp),%rbx
movsd  0x8(%rbx,%r14,8),%xmm0
movsd  0x8(%r8,%r14,8),%xmm2
movsd  %xmm2,0xd0(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x60(%rsp)
mulsd  %xmm0,%xmm6
movapd %xmm6,0xc0(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
call   1080 <hypot@plt>
movapd 0x30(%rsp),%xmm6
movapd 0x60(%rsp),%xmm5
movsd  %xmm0,(%rbx,%r14,8)
shufpd $0x2,%xmm6,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
movapd 0xc0(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
movapd %xmm5,%xmm2
mulsd  %xmm6,%xmm2
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movapd %xmm1,0xc0(%rsp)
movsd  0xd0(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm2,0x160(%rsp)
mov    0x10(%rsp),%rax
mov    %r12,0xd0(%rsp)
mov    %r12,%rcx
mov    %r13,%rdx
mov    0x78(%rsp),%rdi
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  (%rdi,%rsi,1),%xmm7
movsd  (%rcx),%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm5,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm0,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rdi,%rsi,1)
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx)
add    %rbp,%rdx
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    2fa0 <svd+0x1e10>
movapd %xmm6,%xmm0
movapd %xmm5,0x60(%rsp)
movapd %xmm6,0x30(%rsp)
movapd %xmm1,0x150(%rsp)
call   1080 <hypot@plt>
movapd 0x60(%rsp),%xmm1
mov    0xa8(%rsp),%r8
movsd  %xmm0,(%r8,%r14,8)
ucomisd 0x1011(%rip),%xmm0
mov    0x1f0(%rsp),%rbx
jne    302b <svd+0x1e9b>
jnp    3042 <svd+0x1eb2>
movapd 0x150(%rsp),%xmm1
unpcklpd 0x30(%rsp),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movapd %xmm1,%xmm6
unpckhpd %xmm1,%xmm6
mov    0xb8(%rsp),%r9
test   %r9d,%r9d
mov    0x80(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    0xb0(%rsp),%r11
mov    0x110(%rsp),%rsi
jle    2dc0 <svd+0x1c30>
cmp    $0x1,%r9d
je     30e0 <svd+0x1f50>
cmp    $0x1,%r10d
jne    30e0 <svd+0x1f50>
mov    0xe8(%rsp),%rax
mov    0x8(%rsp),%rcx
add    %ecx,%eax
add    $0x1,%eax
cmp    0xa0(%rsp),%eax
jl     30e0 <svd+0x1f50>
mov    $0x0,%edx
cmpq   $0x0,0x190(%rsp)
jne    30e2 <svd+0x1f52>
mov    0x100(%rsp),%rax
cmp    %rax,0x48(%rsp)
jae    315a <svd+0x1fca>
mov    0xf8(%rsp),%rax
cmp    0x148(%rsp),%rax
jae    315a <svd+0x1fca>
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
mov    0x10(%rsp),%rax
imul   %rdx,%rax
add    %eax,%r14d
shl    $0x20,%r14
add    %rsi,%rax
lea    (%rdi,%rax,8),%rax
mov    0x108(%rsp),%rcx
sub    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdx
sar    $0x1d,%rdx
movsd  (%rdi,%rdx,1),%xmm0
movsd  (%rax),%xmm4
movapd %xmm1,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rdx,1)
mulsd  %xmm6,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,(%rax)
add    %rbp,%r14
add    %r15,%rax
add    $0xffffffffffffffff,%rcx
jne    3110 <svd+0x1f80>
jmp    2dc0 <svd+0x1c30>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
mov    0x188(%rsp),%rax
mov    0x58(%rsp),%rcx
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rsi
sar    $0x1d,%rsi
movupd (%rdi,%rsi,1),%xmm5
movupd (%rcx),%xmm2
movapd %xmm0,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm5,%xmm4
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,(%rdi,%rsi,1)
mulpd  %xmm6,%xmm2
subpd  %xmm4,%xmm2
movupd %xmm2,(%rcx)
add    %rbx,%rdx
add    %r11,%rcx
add    $0xfffffffffffffffe,%rax
jne    3180 <svd+0x1ff0>
mov    0x188(%rsp),%rax
mov    %rax,%rdx
cmp    0x108(%rsp),%rax
mov    0x110(%rsp),%rsi
je     2dc0 <svd+0x1c30>
jmp    30e2 <svd+0x1f52>
nopl   0x0(%rax,%rax,1)
mov    0xa8(%rsp),%r8
mov    0x80(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    0xb8(%rsp),%r9
movsd  0xf0(%rsp),%xmm8
movapd 0xde1(%rip),%xmm7
mov    0xb0(%rsp),%r11
jmp    2b12 <svd+0x1982>
nopl   0x0(%rax)
sar    $0x20,%rbx
movslq 0x8(%rsp),%r14
shl    $0x3,%r14
movapd 0x1e0(%rsp),%xmm5
jmp    3290 <svd+0x2100>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r13),%rax
add    $0x8,%r14
cmp    0x28(%rsp),%r13
mov    %rax,%r13
mov    0x80(%rsp),%r10
movsd  0xf0(%rsp),%xmm8
movapd 0xd86(%rip),%xmm7
mov    0xb0(%rsp),%r11
movapd 0xd86(%rip),%xmm1
jge    2bee <svd+0x1a5e>
mov    0x18(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm5
movsd  %xmm5,(%rax,%r13,8)
movapd %xmm0,%xmm2
andpd  %xmm7,%xmm2
ucomisd %xmm2,%xmm8
jae    2bee <svd+0x1a5e>
movsd  (%r8,%r13,8),%xmm1
movaps %xmm1,0x110(%rsp)
movapd %xmm0,0x30(%rsp)
call   1080 <hypot@plt>
movapd 0x110(%rsp),%xmm5
mov    0xb8(%rsp),%r9
mov    0x20(%rsp),%rdi
mov    0xa8(%rsp),%r8
movsd  %xmm0,(%r8,%r13,8)
movapd 0x30(%rsp),%xmm1
xorpd  0xd01(%rip),%xmm1
unpcklpd %xmm1,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
test   %r9d,%r9d
jle    3250 <svd+0x20c0>
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mov    0x108(%rsp),%rax
mov    %rdi,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm1
movsd  (%rcx,%r14,1),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
mulsd  %xmm5,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%r14,1)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    3340 <svd+0x21b0>
jmp    3250 <svd+0x20c0>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
mov    0x10(%rsp),%r14
mov    0x178(%rsp),%r12
mov    0x1d0(%rsp),%rdx
mov    0x120(%rsp),%rbx
jbe    3432 <svd+0x22a2>
xorpd  0xc59(%rip),%xmm2
mov    0x28(%rsp),%rax
movlpd %xmm2,(%r8,%rax,8)
cmpq   $0x0,0x140(%rsp)
mov    0x1a0(%rsp),%rsi
je     340a <svd+0x227a>
xor    %ecx,%ecx
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rbx,%rcx,1),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rbx,%rcx,1)
movsd  (%rdx,%rcx,1),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rdx,%rcx,1)
add    $0x2,%rax
add    %r11,%rcx
cmp    %rax,%rsi
jne    33e0 <svd+0x2250>
jmp    340c <svd+0x227c>
xor    %eax,%eax
test   $0x1,%r14b
je     3432 <svd+0x22a2>
imul   %r14,%rax
add    0x28(%rsp),%rax
mov    0x78(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0xbe3(%rip),%xmm0
movlpd %xmm0,(%rcx,%rax,8)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x138(%rsp)
add    %rax,0x130(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x1d0(%rsp)
add    $0xfffffffffffffff8,%rbx
mov    %rbx,0x120(%rsp)
cmpq   $0x0,0x28(%rsp)
jg     2ac7 <svd+0x1937>
mov    %r9d,%esi
mov    %r10d,%edx
mov    0x78(%rsp),%rcx
call   10b0 <svd_sort@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x228,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xbb9(%rip),%rdi
call   1040 <puts@plt>
mov    $0xf,%eax
jmp    348c <svd+0x22fc>

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

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