int svd_gr2(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, tol, c, y, z;
  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();
  tol = eps * eps;
  g = 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] = g;
    s = 0.0;
    for (k = i; k < M; ++k) {
      t = k * N;
      temp = U[t + i];
      s += temp * temp;
    }
    if (s < tol) {
      g = 0.0;
    } else {
      f = U[i * N + i];
      g = (f < 0) ? sqrt(s) : -sqrt(s);
      h = f * g - s;
      U[i * N + i] = f - g;
      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]);
        }
      }
    }
    q[i] = g;
    s = 0.0;
    t = i * N;
    for (k = l; k < N; ++k) {
      temp = U[t + k];
      s = s + temp * temp;
    }
    if (s < tol) {
      g = 0.0;
    } else {
      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];
        }
      }
    }
    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_gr2>:
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    11c5 <svd_gr2+0x55>
lea    0x1e7c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1e9c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    26c0 <svd_gr2+0x1550>
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    $0x0,%al
call   1070 <macheps@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
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    1253 <svd_gr2+0xe3>
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    1219 <svd_gr2+0xa9>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17f7 <svd_gr2+0x687>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12e9 <svd_gr2+0x179>
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
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    1292 <svd_gr2+0x122>
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    130d <svd_gr2+0x19d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    14ef <svd_gr2+0x37f>
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    1353 <svd_gr2+0x1e3>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    137c <svd_gr2+0x20c>
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    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    14ea <svd_gr2+0x37a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    145f <svd_gr2+0x2ef>
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    1405 <svd_gr2+0x295>
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    14d7 <svd_gr2+0x367>
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    147a <svd_gr2+0x30a>
jmp    14dc <svd_gr2+0x36c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13eb <svd_gr2+0x27b>
jmp    14ef <svd_gr2+0x37f>
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
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    -0x18(%rbp),%eax
jge    1566 <svd_gr2+0x3f6>
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    1519 <svd_gr2+0x3a9>
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    158a <svd_gr2+0x41a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    178a <svd_gr2+0x61a>
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    15cc <svd_gr2+0x45c>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    15f5 <svd_gr2+0x485>
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    16a4 <svd_gr2+0x534>
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    1660 <svd_gr2+0x4f0>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1785 <svd_gr2+0x615>
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    171e <svd_gr2+0x5ae>
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    16ce <svd_gr2+0x55e>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1772 <svd_gr2+0x602>
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    1724 <svd_gr2+0x5b4>
jmp    1777 <svd_gr2+0x607>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16aa <svd_gr2+0x53a>
jmp    178a <svd_gr2+0x61a>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1862(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1847(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    17e4 <svd_gr2+0x674>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    17e9 <svd_gr2+0x679>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    125a <svd_gr2+0xea>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1a34 <svd_gr2+0x8c4>
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    19f1 <svd_gr2+0x881>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1842 <svd_gr2+0x6d2>
jp     1842 <svd_gr2+0x6d2>
jmp    199e <svd_gr2+0x82e>
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    18b4 <svd_gr2+0x744>
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    186a <svd_gr2+0x6fa>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1999 <svd_gr2+0x829>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1928 <svd_gr2+0x7b8>
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    18d4 <svd_gr2+0x764>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1986 <svd_gr2+0x816>
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    192e <svd_gr2+0x7be>
jmp    198b <svd_gr2+0x81b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18ba <svd_gr2+0x74a>
jmp    199e <svd_gr2+0x82e>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    19ec <svd_gr2+0x87c>
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    19a4 <svd_gr2+0x834>
jmp    19f1 <svd_gr2+0x881>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x160a(%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    1800 <svd_gr2+0x690>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1cbb <svd_gr2+0xb4b>
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    1ab7 <svd_gr2+0x947>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ab2 <svd_gr2+0x942>
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    1a83 <svd_gr2+0x913>
jmp    1ab7 <svd_gr2+0x947>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ad4 <svd_gr2+0x964>
jp     1ad4 <svd_gr2+0x964>
jmp    1c50 <svd_gr2+0xae0>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1bfa <svd_gr2+0xa8a>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1bf5 <svd_gr2+0xa85>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b5d <svd_gr2+0x9ed>
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    1b05 <svd_gr2+0x995>
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    1be2 <svd_gr2+0xa72>
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    1b87 <svd_gr2+0xa17>
jmp    1be7 <svd_gr2+0xa77>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1aeb <svd_gr2+0x97b>
jmp    1bfa <svd_gr2+0xa8a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c4b <svd_gr2+0xadb>
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    1c00 <svd_gr2+0xa90>
jmp    1c8e <svd_gr2+0xb1e>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c89 <svd_gr2+0xb19>
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    1c56 <svd_gr2+0xae6>
jmp    1c8e <svd_gr2+0xb1e>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x136d(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1a3d <svd_gr2+0x8cd>
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     2695 <svd_gr2+0x1525>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x32,-0x54(%rbp)
jle    1d11 <svd_gr2+0xba1>
lea    0x1376(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xf,-0x4(%rbp)
jmp    26c0 <svd_gr2+0x1550>
movl   $0x1,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1da2 <svd_gr2+0xc32>
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x12c1(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1d5e <svd_gr2+0xbee>
movl   $0x0,-0x50(%rbp)
jmp    1da2 <svd_gr2+0xc32>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1289(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1d8f <svd_gr2+0xc1f>
jmp    1da2 <svd_gr2+0xc32>
jmp    1d94 <svd_gr2+0xc24>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1d1e <svd_gr2+0xbae>
cmpl   $0x0,-0x50(%rbp)
je     1fb6 <svd_gr2+0xe46>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x1251(%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     1fb1 <svd_gr2+0xe41>
movsd  -0x78(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%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 0x11d8(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1e40 <svd_gr2+0xcd0>
jmp    1fb1 <svd_gr2+0xe41>
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,-0xa0(%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    1f9e <svd_gr2+0xe2e>
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,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%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  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%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    1ec1 <svd_gr2+0xd51>
jmp    1fa3 <svd_gr2+0xe33>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1dd3 <svd_gr2+0xc63>
jmp    1fb6 <svd_gr2+0xe46>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     25d0 <svd_gr2+0x1460>
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,-0xa8(%rbp)
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  -0xb0(%rbp),%xmm1
ff
divsd  -0x90(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm2
subsd  -0xb0(%rbp),%xmm2
ff
divsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm0,%xmm1
movsd  0xf85(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0xf61(%rip),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    20e1 <svd_gr2+0xf71>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    20f3 <svd_gr2+0xf83>
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
divsd  -0x70(%rbp),%xmm1
movsd  -0xb0(%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  -0xa8(%rbp),%xmm2
ff
divsd  -0x80(%rbp),%xmm2
subsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xeaa(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xe9d(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     258e <svd_gr2+0x141e>
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,-0xa8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%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,-0xb0(%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  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%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  -0xa0(%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  -0xa8(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    23ad <svd_gr2+0x123d>
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,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%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  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%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    22d3 <svd_gr2+0x1163>
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
call   1060 <hypot@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    23fc <svd_gr2+0x128c>
jp     23fc <svd_gr2+0x128c>
jmp    2429 <svd_gr2+0x12b9>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%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    257b <svd_gr2+0x140b>
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,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%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  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%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    2498 <svd_gr2+0x1328>
jmp    2580 <svd_gr2+0x1410>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2184 <svd_gr2+0x1014>
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    267d <svd_gr2+0x150d>
xorps  %xmm0,%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jbe    2678 <svd_gr2+0x1508>
movsd  -0xb0(%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    2673 <svd_gr2+0x1503>
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    2614 <svd_gr2+0x14a4>
jmp    2678 <svd_gr2+0x1508>
jmp    2682 <svd_gr2+0x1512>
jmp    1ce4 <svd_gr2+0xb74>
jmp    2687 <svd_gr2+0x1517>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1cd3 <svd_gr2+0xb63>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    $0x0,%al
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_gr2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
cmp    %edx,%esi
jge    11ca <svd_gr2+0x3a>
lea    0x2ecc(%rip),%rdi
call   1040 <puts@plt>
lea    0x2e80(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xffffffff,%r15d
jmp    2ffc <svd_gr2+0x1e6c>
mov    %r9,%rbp
mov    %edx,%r12d
mov    %rdi,%r14
mov    %r8,0x48(%rsp)
movslq %edx,%rax
mov    %rax,0x10(%rsp)
lea    0x0(,%rax,8),%r15
mov    %r15,%rdi
mov    %rcx,0x58(%rsp)
mov    %rsi,0x80(%rsp)
call   1070 <malloc@plt>
mov    %rax,0x90(%rsp)
xor    %eax,%eax
call   1090 <macheps@plt>
mov    0x80(%rsp),%rsi
mov    0x58(%rsp),%rdi
mov    %r12d,%edx
imul   %esi,%edx
test   %edx,%edx
mov    %rbp,%r8
mov    %rbp,0x88(%rsp)
jle    13c9 <svd_gr2+0x239>
mov    %edx,%ebx
cmp    $0x4,%edx
jb     1253 <svd_gr2+0xc3>
lea    (%r14,%rbx,8),%rdx
cmp    %rdi,%rdx
jbe    12e0 <svd_gr2+0x150>
lea    (%rdi,%rbx,8),%rdx
cmp    %r14,%rdx
jbe    12e0 <svd_gr2+0x150>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rbx,%rsi
mov    %rbx,%rcx
and    $0x3,%rcx
je     1285 <svd_gr2+0xf5>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1270 <svd_gr2+0xe0>
cmp    $0x3,%rsi
mov    0x80(%rsp),%rsi
jb     13c9 <svd_gr2+0x239>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rdx,8)
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rdx,8)
movsd  0x18(%r14,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    12a0 <svd_gr2+0x110>
jmp    13c9 <svd_gr2+0x239>
mov    %ebx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rcx
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rcx
jae    1305 <svd_gr2+0x175>
xor    %ebp,%ebp
jmp    1374 <svd_gr2+0x1e4>
and    $0xfffffffffffffffc,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups (%r14,%rbp,8),%xmm0
movups 0x10(%r14,%rbp,8),%xmm1
movups %xmm0,(%rdi,%rbp,8)
movups %xmm1,0x10(%rdi,%rbp,8)
movups 0x20(%r14,%rbp,8),%xmm0
movups 0x30(%r14,%rbp,8),%xmm1
movups %xmm0,0x20(%rdi,%rbp,8)
movups %xmm1,0x30(%rdi,%rbp,8)
movups 0x40(%r14,%rbp,8),%xmm0
movups 0x50(%r14,%rbp,8),%xmm1
movups %xmm0,0x40(%rdi,%rbp,8)
movups %xmm1,0x50(%rdi,%rbp,8)
movupd 0x60(%r14,%rbp,8),%xmm0
movupd 0x70(%r14,%rbp,8),%xmm1
movupd %xmm0,0x60(%rdi,%rbp,8)
movupd %xmm1,0x70(%rdi,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1310 <svd_gr2+0x180>
test   %r8,%r8
je     13b0 <svd_gr2+0x220>
lea    (%rdi,%rbp,8),%rcx
add    $0x10,%rcx
lea    (%r14,%rbp,8),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %esi,%esi
nop
movupd -0x10(%rbp,%rsi,1),%xmm0
movupd 0x0(%rbp,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rsi,1)
movupd %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1390 <svd_gr2+0x200>
cmp    %rbx,%rdx
mov    0x88(%rsp),%r8
mov    0x80(%rsp),%rsi
jne    1255 <svd_gr2+0xc5>
test   %r12d,%r12d
mov    0x48(%rsp),%rbx
mov    0x90(%rsp),%r11
mov    0x10(%rsp),%r9
jle    2fe1 <svd_gr2+0x1e51>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x150(%rsp)
movapd %xmm0,%xmm8
mulsd  %xmm0,%xmm8
movslq %esi,%r14
mov    %r12,0x38(%rsp)
mov    %r12d,%r10d
mov    %esi,%eax
lea    -0x2(%r10),%rcx
mov    %rcx,0xc0(%rsp)
lea    0x8(,%r9,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    0x8(%rdi),%rsi
lea    0x18(%r11),%rcx
lea    -0x3(%r10),%rbp
mov    %rbp,0xd8(%rsp)
lea    (%rdi,%r9,8),%rbp
mov    %rbp,0x50(%rsp)
lea    (%rdi,%r9,8),%rbp
add    $0x38,%rbp
mov    %rbp,0x130(%rsp)
mov    %r11,%r13
add    $0x38,%r13
lea    -0x5(%r10),%rbp
mov    %rbp,0x78(%rsp)
xorpd  %xmm9,%xmm9
mov    $0x1,%ebp
mov    %rbp,0x8(%rsp)
xor    %edx,%edx
movapd 0x2b92(%rip),%xmm10
mov    %rdi,%r12
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
mov    %r10,0x140(%rsp)
mov    %rax,0x118(%rsp)
mov    %rax,0xa0(%rsp)
mov    %rdi,%rbp
mov    %r10,0xb8(%rsp)
movsd  %xmm8,0xf8(%rsp)
jmp    155e <svd_gr2+0x3ce>
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%r8
mov    0x48(%rsp),%rbx
mov    0x10(%rsp),%r9
mov    0xe0(%rsp),%rsi
mov    0x40(%rsp),%rcx
mov    0x20(%rsp),%rdx
mov    0x60(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
movsd  (%r11,%rax,8),%xmm4
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm4
addsd  %xmm0,%xmm4
maxsd  %xmm11,%xmm4
addq   $0x1,0x8(%rsp)
mov    0xd0(%rsp),%rax
add    %rax,%rbp
addq   $0xffffffffffffffff,0xa0(%rsp)
add    %rax,%rsi
addq   $0xffffffffffffffff,0x140(%rsp)
add    $0x8,%rcx
addq   $0xffffffffffffffff,0xd8(%rsp)
add    %r15,%r12
add    %r15,0x50(%rsp)
add    %rax,0x130(%rsp)
add    $0x8,%r13
addq   $0xffffffffffffffff,0x78(%rsp)
cmp    %r10,%rdx
je     1c42 <svd_gr2+0xab2>
mov    %rcx,0x40(%rsp)
movapd %xmm4,%xmm11
movsd  %xmm1,(%r11,%rdx,8)
xorpd  %xmm5,%xmm5
cmp    %r14,%rdx
jge    15a5 <svd_gr2+0x415>
xorpd  %xmm5,%xmm5
mov    0xa0(%rsp),%rax
mov    %rbp,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    1590 <svd_gr2+0x400>
lea    0x1(%rdx),%rcx
xorpd  %xmm3,%xmm3
ucomisd %xmm5,%xmm8
xorpd  %xmm1,%xmm1
mov    %rcx,0x20(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rsi,0xe0(%rsp)
ja     176d <svd_gr2+0x5dd>
mov    %edx,%eax
imul   0x38(%rsp),%eax
cltq
add    %rdx,%rax
movsd  (%rdi,%rax,8),%xmm4
ucomisd %xmm9,%xmm5
jb     1600 <svd_gr2+0x470>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    168f <svd_gr2+0x4ff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm5,%xmm0
movsd  %xmm11,0x70(%rsp)
movsd  %xmm4,0x18(%rsp)
movsd  %xmm5,0x30(%rsp)
mov    %rax,0x98(%rsp)
call   10a0 <sqrt@plt>
mov    0x98(%rsp),%rax
movsd  0x30(%rsp),%xmm5
movsd  0x18(%rsp),%xmm4
xorpd  %xmm3,%xmm3
mov    0x60(%rsp),%rdx
movsd  0x70(%rsp),%xmm11
mov    0x20(%rsp),%rcx
movapd 0x29ba(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0xe0(%rsp),%rsi
movsd  0xf8(%rsp),%xmm8
mov    0xb8(%rsp),%r10
mov    0x10(%rsp),%r9
mov    0x90(%rsp),%r11
mov    0x58(%rsp),%rdi
mov    0x88(%rsp),%r8
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  0x2957(%rip),%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
cmp    %r9,%rcx
jge    176d <svd_gr2+0x5dd>
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mov    %rsi,%rax
mov    0x8(%rsp),%rcx
jmp    16f2 <svd_gr2+0x562>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r10,%rcx
mov    0x60(%rsp),%rdx
je     1760 <svd_gr2+0x5d0>
cmp    %r14,%rdx
jge    16e0 <svd_gr2+0x550>
xorpd  %xmm0,%xmm0
mov    0xa0(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm0
add    %r15,%rsi
add    $0xffffffffffffffff,%rdx
jne    1710 <svd_gr2+0x580>
cmp    %r14,0x60(%rsp)
jge    16e0 <svd_gr2+0x550>
divsd  %xmm4,%xmm0
mov    0xa0(%rsp),%rdx
xor    %esi,%esi
nopl   (%rax)
movsd  0x0(%rbp,%rsi,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %r15,%rsi
add    $0xffffffffffffffff,%rdx
jne    1740 <svd_gr2+0x5b0>
jmp    16e0 <svd_gr2+0x550>
nop
mov    0xe0(%rsp),%rsi
mov    0x20(%rsp),%rcx
movsd  %xmm1,(%r8,%rdx,8)
cmp    %r9,%rcx
mov    0x40(%rsp),%rcx
mov    0x140(%rsp),%rdx
jge    17a7 <svd_gr2+0x617>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rdx
jne    1790 <svd_gr2+0x600>
xorpd  %xmm1,%xmm1
ucomisd %xmm3,%xmm8
mov    0x20(%rsp),%rdx
ja     14e4 <svd_gr2+0x354>
mov    0x60(%rsp),%rcx
imul   %r9,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
lea    (%rcx,%rdx,1),%rax
movsd  (%rdi,%rax,8),%xmm4
ucomisd %xmm9,%xmm3
mov    %rax,0x30(%rsp)
jb     17f0 <svd_gr2+0x660>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    186a <svd_gr2+0x6da>
nopl   (%rax)
movapd %xmm3,%xmm0
movsd  %xmm11,0x70(%rsp)
movsd  %xmm3,0x98(%rsp)
movapd %xmm4,0x120(%rsp)
call   10a0 <sqrt@plt>
movapd 0x120(%rsp),%xmm4
movsd  0x98(%rsp),%xmm3
movsd  0x70(%rsp),%xmm11
mov    0x20(%rsp),%rdx
movapd 0x27d7(%rip),%xmm10
xorpd  %xmm9,%xmm9
movsd  0xf8(%rsp),%xmm8
mov    0xb8(%rsp),%r10
mov    0x10(%rsp),%r9
mov    0x90(%rsp),%r11
mov    0x58(%rsp),%rdi
mov    0x88(%rsp),%r8
mov    0x60(%rsp),%rcx
not    %rcx
lea    (%rcx,%r10,1),%rax
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  0x2770(%rip),%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
mov    0x30(%rsp),%rsi
movsd  %xmm0,(%rdi,%rsi,8)
cmp    %r9,%rdx
jge    19a9 <svd_gr2+0x819>
mulsd  %xmm1,%xmm4
subsd  %xmm3,%xmm4
mov    0x8(%rsp),%rsi
cmp    $0x2,%rax
jb     1990 <svd_gr2+0x800>
mov    %rcx,0x30(%rsp)
lea    (%rcx,%r10,1),%rsi
add    $0xfffffffffffffffe,%rsi
mov    %rsi,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,0x70(%rsp)
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmp    $0x2,%rsi
jae    18f8 <svd_gr2+0x768>
xor    %ebx,%ebx
jmp    1948 <svd_gr2+0x7b8>
mov    0xd8(%rsp),%rsi
shr    %rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebx,%ebx
mov    0xe0(%rsp),%rdx
mov    0x40(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rbx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd 0x10(%rdx,%rbx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%rcx,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1920 <svd_gr2+0x790>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
testb  $0x1,0x70(%rsp)
je     1973 <svd_gr2+0x7e3>
add    0x8(%rsp),%rbx
mov    0x18(%rsp),%rcx
lea    (%rbx,%rcx,1),%rdx
movupd (%rdi,%rdx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%r11,%rbx,8)
cmp    %rsi,%rax
mov    0x48(%rsp),%rbx
mov    0x20(%rsp),%rdx
mov    0x30(%rsp),%rcx
je     19a9 <svd_gr2+0x819>
add    0x8(%rsp),%rsi
nopl   0x0(%rax)
movsd  (%r12,%rsi,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r11,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1990 <svd_gr2+0x800>
cmp    %r14,%rdx
jge    1c30 <svd_gr2+0xaa0>
mov    %rcx,%rdx
mov    0x78(%rsp),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
add    %r10,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x70(%rsp)
shr    $0x2,%rdx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x110(%rsp)
add    $0x1,%rdx
mov    %rdx,0x98(%rsp)
mov    0x8(%rsp),%r9
add    %r9,0x18(%rsp)
lea    0x1(%r9),%rcx
mov    %rcx,0x30(%rsp)
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x120(%rsp)
add    %r9,%rcx
mov    %rcx,0x100(%rsp)
mov    0x130(%rsp),%rdx
mov    0x50(%rsp),%rcx
jmp    1a48 <svd_gr2+0x8b8>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r15,%rcx
add    %r15,%rdx
cmp    0x118(%rsp),%r9
je     14c0 <svd_gr2+0x330>
mov    0x20(%rsp),%rsi
cmp    0x10(%rsp),%rsi
jge    1a30 <svd_gr2+0x8a0>
mov    %r9,%r8
imul   0x10(%rsp),%r8
xorpd  %xmm2,%xmm2
mov    0x8(%rsp),%rsi
test   $0x1,%al
je     1a8f <svd_gr2+0x8ff>
mov    0x8(%rsp),%rsi
add    %r8,%rsi
movsd  (%rdi,%rsi,8),%xmm0
mov    0x18(%rsp),%rsi
mulsd  (%rdi,%rsi,8),%xmm0
addsd  %xmm9,%xmm0
mov    0x30(%rsp),%rsi
movapd %xmm0,%xmm2
mov    0x60(%rsp),%rbx
cmp    %rbx,0xc0(%rsp)
je     1acd <svd_gr2+0x93d>
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm3
movsd  0x8(%rcx,%rsi,8),%xmm0
mulsd  (%r12,%rsi,8),%xmm3
mulsd  0x8(%r12,%rsi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rsi
movapd %xmm0,%xmm2
cmp    %rsi,%r10
jne    1aa0 <svd_gr2+0x910>
mov    0x20(%rsp),%rsi
cmp    0x10(%rsp),%rsi
jge    1a30 <svd_gr2+0x8a0>
mov    0x8(%rsp),%rsi
cmp    $0x4,%rax
jb     1c00 <svd_gr2+0xa70>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x4,0x70(%rsp)
jae    1b04 <svd_gr2+0x974>
xor    %r10d,%r10d
jmp    1b8c <svd_gr2+0x9fc>
mov    0x110(%rsp),%r11
xor    %r10d,%r10d
nop
movupd -0x30(%r13,%r10,8),%xmm3
movupd -0x20(%r13,%r10,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%rdx,%r10,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%rdx,%r10,8),%xmm3
movupd -0x10(%rdx,%r10,8),%xmm6
movupd (%rdx,%r10,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%rdx,%r10,8)
movupd %xmm4,-0x20(%rdx,%r10,8)
movupd -0x10(%r13,%r10,8),%xmm3
movupd 0x0(%r13,%r10,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%rdx,%r10,8)
movupd %xmm4,(%rdx,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%r11
jne    1b10 <svd_gr2+0x980>
testb  $0x1,0x98(%rsp)
01
mov    0x58(%rsp),%rdi
mov    0x90(%rsp),%r11
je     1be2 <svd_gr2+0xa52>
add    0x8(%rsp),%r10
movupd (%r11,%r10,8),%xmm3
movupd 0x10(%r11,%r10,8),%xmm4
add    %r8,%r10
movupd (%rdi,%r10,8),%xmm5
movupd 0x10(%rdi,%r10,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rdi,%r10,8)
movupd %xmm4,0x10(%rdi,%r10,8)
mov    0x100(%rsp),%rsi
cmp    0x120(%rsp),%rax
mov    0xb8(%rsp),%r10
je     1a30 <svd_gr2+0x8a0>
movsd  (%r11,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rcx,%rsi,8),%xmm2
movsd  %xmm2,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1c00 <svd_gr2+0xa70>
jmp    1a30 <svd_gr2+0x8a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xe0(%rsp),%rsi
mov    0x40(%rsp),%rcx
jmp    14e4 <svd_gr2+0x354>
mov    0x38(%rsp),%r12
test   %r12d,%r12d
mov    0x80(%rsp),%rsi
jle    2fe1 <svd_gr2+0x1e51>
lea    -0x1(%r12),%eax
mov    %rax,0x1d8(%rsp)
mov    %eax,%eax
mov    %rax,0x50(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x130(%rsp)
lea    -0x1(%r9),%rdx
lea    (%r9,%r9,1),%r8
mov    %rdx,%rax
imul   %r9,%rax
lea    (%rdi,%rax,8),%rsi
add    $0x8,%rsi
mov    %r15,%r13
neg    %r13
mov    %r9,%rcx
shl    $0x4,%rcx
mov    %rcx,0x108(%rsp)
lea    -0x8(%rbx),%rcx
mov    %rcx,0x30(%rsp)
lea    (%rbx,%rax,8),%r12
add    $0x8,%r12
movq   $0xfffffffffffffff8,0x100(%rsp)
xorpd  %xmm0,%xmm0
mov    %rdx,0xf8(%rsp)
mov    %rdx,0xe0(%rsp)
mov    %rbx,0xd8(%rsp)
mov    %r9,%rdx
mov    %r13,0x110(%rsp)
jmp    1d4f <svd_gr2+0xbbf>
nopl   0x0(%rax)
movslq 0x140(%rsp),%rax
mov    0xc0(%rsp),%rdx
add    %rdx,%rax
mov    0x48(%rsp),%rbx
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rbx,%rax,8)
movsd  (%r11,%rdx,8),%xmm1
addq   $0xfffffffffffffff8,0xd8(%rsp)
add    %r13,%rsi
addq   $0xffffffffffffffff,0xe0(%rsp)
addq   $0xfffffffffffffff8,0x30(%rsp)
addq   $0xfffffffffffffff8,0x100(%rsp)
add    %r13,%r12
cmpq   $0x1,0x20(%rsp)
jle    21b2 <svd_gr2+0x1022>
lea    -0x1(%rdx),%rcx
mov    %rcx,%rax
mov    %rcx,0xc0(%rsp)
imul   0x38(%rsp),%ecx
mov    %rcx,0x140(%rsp)
mov    %rdx,%rax
mov    %rdx,0x20(%rsp)
cmp    0x50(%rsp),%rdx
jg     1cf0 <svd_gr2+0xb60>
mov    %r12,0x120(%rsp)
movslq 0x20(%rsp),%rdx
mov    %r9,%rbx
sub    %rdx,%rbx
mov    %rdx,%rax
mov    %rdx,0x78(%rsp)
mov    %rdx,%r12
not    %r12
mov    0xc0(%rsp),%rax
imul   %r9,%rax
mov    %rax,0xd0(%rsp)
ucomisd %xmm0,%xmm1
mov    0x130(%rsp),%r11
mov    %r12,0xa0(%rsp)
mov    %rbx,0x8(%rsp)
jne    1dd4 <svd_gr2+0xc44>
jnp    20b0 <svd_gr2+0xf20>
mov    0x20(%rsp),%rax
cmp    0x38(%rsp),%eax
jge    20b0 <svd_gr2+0xf20>
mov    0xc0(%rsp),%rbp
mov    0x140(%rsp),%rax
add    %ebp,%eax
cltq
mov    0x58(%rsp),%rcx
mulsd  0x8(%rcx,%rax,8),%xmm1
movslq 0x20(%rsp),%rdi
test   $0x1,%bl
je     1e38 <svd_gr2+0xca8>
mov    0xd0(%rsp),%rax
add    %rdi,%rax
movsd  (%rcx,%rax,8),%xmm2
divsd  %xmm1,%xmm2
mov    %rdi,%rax
imul   %r9,%rax
add    %rbp,%rax
mov    0x48(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
add    $0x1,%rdi
mov    0x38(%rsp),%r10
cmp    %r11,%r12
je     1ea9 <svd_gr2+0xd19>
mov    %r9,%rax
imul   %rdi,%rax
mov    0xd8(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
lea    0x1(%rdi),%rcx
imul   %r9,%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    0xf8(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdi,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rbp,8)
movsd  (%rsi,%rdi,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
add    $0x2,%rdi
add    %r8,%rbp
cmp    %rdi,%r9
jne    1e80 <svd_gr2+0xcf0>
cmp    %r10d,0x20(%rsp)
jge    20b0 <svd_gr2+0xf20>
mov    0x78(%rsp),%rax
mov    0x48(%rsp),%r10
lea    (%r10,%rax,8),%rdx
movslq 0x20(%rsp),%r13
mov    0xd0(%rsp),%rax
add    %r13,%rax
mov    %rax,0x70(%rsp)
mov    %r13,%rcx
imul   %r9,%rcx
lea    0x1(%r13),%rax
mov    %rax,0x40(%rsp)
mov    0xc0(%rsp),%rax
mov    %rcx,0x18(%rsp)
add    %rcx,%rax
mov    %rax,0x98(%rsp)
mov    %r13,0x60(%rsp)
jmp    1f3a <svd_gr2+0xdaa>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x8,%r10
add    $0x8,%rbx
mov    %rbx,%rdx
mov    0x10(%rsp),%r9
cmp    %r9,%r13
mov    0xa0(%rsp),%r12
mov    0x8(%rsp),%rbx
je     20b0 <svd_gr2+0xf20>
xorpd  %xmm2,%xmm2
mov    0x60(%rsp),%rdi
test   $0x1,%bl
je     1f76 <svd_gr2+0xde6>
mov    0x58(%rsp),%rax
mov    0x70(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rsp),%rax
add    %r13,%rax
mov    0x48(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x40(%rsp),%rdi
movapd %xmm1,%xmm2
cmp    %r11,%r12
je     1fce <svd_gr2+0xe3e>
mov    %r9,%rax
imul   %rdi,%rax
lea    (%r10,%rax,8),%rax
lea    0x1(%rdi),%rcx
imul   %r9,%rcx
lea    (%r10,%rcx,8),%rbp
mov    0x78(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdi,8),%xmm3
mulsd  (%rax,%rcx,8),%xmm3
movsd  (%rsi,%rdi,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  0x0(%rbp,%rcx,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rdi
add    %r8,%rcx
movapd %xmm1,%xmm2
cmp    %rdi,%r9
jne    1fa0 <svd_gr2+0xe10>
mov    0x60(%rsp),%rcx
test   $0x1,%bl
je     2005 <svd_gr2+0xe75>
mov    0x18(%rsp),%rax
add    %r13,%rax
mov    0x48(%rsp),%rcx
mov    0x98(%rsp),%rdi
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0x40(%rsp),%rcx
cmp    %r11,%r12
mov    %rdx,%rbx
je     1f10 <svd_gr2+0xd80>
mov    0x10(%rsp),%r11
mov    %r11,%rdi
sub    %rcx,%rdi
mov    %r11,%rax
imul   %rcx,%rax
lea    (%rax,%r13,1),%rbp
mov    0x48(%rsp),%rdx
lea    (%rdx,%rbp,8),%rbp
add    0xe0(%rsp),%rax
lea    (%rdx,%rax,8),%rax
lea    0x1(%rcx),%rdx
imul   %r11,%rdx
lea    (%rbx,%rdx,8),%r9
lea    0x10(,%rcx,8),%r12
imul   %r11,%r12
mov    0x130(%rsp),%r11
mov    0x108(%rsp),%rdx
add    0x30(%rsp),%r12
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rcx,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,1)
movsd  (%r12,%rcx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r9,%rcx,1),%xmm2
movsd  %xmm2,(%r9,%rcx,1)
add    %rdx,%rcx
add    $0xfffffffffffffffe,%rdi
jne    2070 <svd_gr2+0xee0>
jmp    1f10 <svd_gr2+0xd80>
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
cmp    0x38(%rsp),%eax
mov    0x58(%rsp),%rdi
mov    0x90(%rsp),%r11
mov    0xb8(%rsp),%r10
mov    0x110(%rsp),%r13
mov    0x120(%rsp),%r12
jge    1cf0 <svd_gr2+0xb60>
movslq 0x20(%rsp),%rdx
testb  $0x1,0x8(%rsp)
je     2123 <svd_gr2+0xf93>
mov    %rdx,%rax
imul   %r9,%rax
add    0xc0(%rsp),%rax
mov    0x48(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    0xd0(%rsp),%rax
add    %rdx,%rax
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%rdx
mov    0xa0(%rsp),%rax
cmp    0x130(%rsp),%rax
mov    0x108(%rsp),%rbx
mov    0x120(%rsp),%r12
je     1cf0 <svd_gr2+0xb60>
lea    0x10(,%rdx,8),%rax
imul   %r9,%rax
mov    0x48(%rsp),%rbp
add    %rbp,%rax
lea    0x8(,%rdx,8),%rcx
imul   %r9,%rcx
add    %rbp,%rcx
mov    0x100(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rcx,%rbp,1)
movq   $0x0,-0x8(%r12,%rdx,8)
movq   $0x0,(%rax,%rbp,1)
movq   $0x0,(%r12,%rdx,8)
add    $0x2,%rdx
add    %rbx,%rbp
cmp    %rdx,%r9
jne    2180 <svd_gr2+0xff0>
jmp    1cf0 <svd_gr2+0xb60>
mov    0x38(%rsp),%r12
test   %r12d,%r12d
mov    0x88(%rsp),%r8
mov    0x80(%rsp),%rsi
jle    2fe1 <svd_gr2+0x1e51>
mov    %r12d,%eax
imul   %r12d,%eax
mov    %eax,0x30(%rsp)
mov    %r12d,%eax
not    %eax
mov    %eax,0xe0(%rsp)
mov    %r9,%rax
imul   %r9,%rax
lea    (%rdi,%rax,8),%r12
add    $0xfffffffffffffff8,%r12
mov    %r15,%rcx
xor    $0xfffffffffffffff8,%rcx
mov    %rcx,0x18(%rsp)
lea    0x1(%r14),%rcx
mov    %rcx,0x60(%rsp)
lea    0x1(%r9),%rcx
imul   %r9,%rcx
lea    (%rdi,%rcx,8),%rdx
mov    %rdx,0xa0(%rsp)
lea    (%rdi,%rcx,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    (%rdi,%rax,8),%rax
mov    %rax,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
xorpd  %xmm3,%xmm3
movsd  0x1dda(%rip),%xmm2
mov    %r9,%rdx
movapd %xmm4,0x160(%rsp)
jmp    22b1 <svd_gr2+0x1121>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %r8d,%rax
add    %rdx,%rax
movsd  (%rdi,%rax,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0x18(%rsp),%rax
add    %rax,%r12
add    %rax,0xa0(%rsp)
add    %rax,%rbp
add    %rax,0xc0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    %r10,%rcx
mov    0x88(%rsp),%r8
je     24d8 <svd_gr2+0x1348>
mov    %rdx,%r13
add    $0xffffffffffffffff,%rdx
movsd  -0x8(%r8,%r13,8),%xmm5
cmp    0x50(%rsp),%r13
mov    %rdx,0x8(%rsp)
jg     2351 <svd_gr2+0x11c1>
cmp    %r9,%r13
jge    2351 <svd_gr2+0x11c1>
movabs $0x7fffffff8,%rax
mov    0x20(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
and    %rax,%rdx
add    $0x8,%rdx
mov    0xe0(%rsp),%eax
imul   %ecx,%eax
add    0x30(%rsp),%eax
cltq
lea    (%rdi,%rax,8),%rdi
xor    %esi,%esi
movsd  %xmm5,0x40(%rsp)
call   1060 <memset@plt>
movsd  0x40(%rsp),%xmm5
mov    0x8(%rsp),%rdx
xorpd  %xmm3,%xmm3
movsd  0x1cfa(%rip),%xmm2
movapd 0x160(%rsp),%xmm4
mov    0xb8(%rsp),%r10
mov    0x10(%rsp),%r9
mov    0x90(%rsp),%r11
mov    0x80(%rsp),%rsi
mov    0x58(%rsp),%rdi
mov    %edx,%r8d
imul   0x38(%rsp),%r8d
ucomisd %xmm3,%xmm5
jne    2366 <svd_gr2+0x11d6>
jnp    24a0 <svd_gr2+0x1310>
cmp    0x50(%rsp),%rdx
je     2450 <svd_gr2+0x12c0>
cmp    0x10(%rsp),%r13
jge    2450 <svd_gr2+0x12c0>
mov    0x8(%rsp),%rax
mov    %rax,%r9
imul   0x10(%rsp),%r9
add    %rax,%r9
mov    0xc0(%rsp),%rdx
mov    0xa0(%rsp),%rsi
mov    %r13,%rbx
jmp    23c6 <svd_gr2+0x1236>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
add    $0x8,%rsi
add    $0x8,%rdx
cmp    0x38(%rsp),%ebx
je     2450 <svd_gr2+0x12c0>
xorpd  %xmm0,%xmm0
cmp    %r14,%r13
jge    23fb <svd_gr2+0x126b>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    %r13,%rcx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,1),%xmm1
mulsd  (%rsi,%rax,1),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
add    %r15,%rax
cmp    %r14,%rcx
jl     23e0 <svd_gr2+0x1250>
cmp    %r14,%r13
jg     23b0 <svd_gr2+0x1220>
divsd  (%rdi,%r9,8),%xmm0
divsd  %xmm5,%xmm0
mov    0x60(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,1),%xmm1
movsd  %xmm1,(%rdx,%rcx,1)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r13
jne    2420 <svd_gr2+0x1290>
jmp    23b0 <svd_gr2+0x1220>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r14,%r13
mov    0x48(%rsp),%rbx
mov    0x80(%rsp),%rsi
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdx
jg     2260 <svd_gr2+0x10d0>
mov    0x60(%rsp),%rax
mov    %r12,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r13
jne    2480 <svd_gr2+0x12f0>
jmp    2260 <svd_gr2+0x10d0>
nopl   (%rax)
mov    0x60(%rsp),%rax
mov    %r12,%rcx
cmp    %r14,%r13
jg     2260 <svd_gr2+0x10d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rcx)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r13
jne    24c0 <svd_gr2+0x1330>
jmp    2260 <svd_gr2+0x10d0>
mov    0x38(%rsp),%r12
test   %r12d,%r12d
jle    2fe1 <svd_gr2+0x1e51>
mulsd  0x150(%rsp),%xmm4
movabs $0xffffffff00000000,%r13
ff ff ff
lea    -0x1(%r9),%rdx
mov    0x118(%rsp),%rax
lea    -0x1(%rax),%rbp
lea    (%rdi,%rax,8),%rcx
mov    %rcx,0x150(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0x1d0(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x1a0(%rsp)
mov    %r10d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x1b0(%rsp)
mov    %r9,%r14
shl    $0x20,%r14
lea    (%r14,%r13,1),%rax
mov    %rax,0x198(%rsp)
lea    (%r12,%rsi,1),%eax
add    $0xfffffffe,%eax
mov    %rax,0x1c8(%rsp)
movabs $0xfffffffe00000000,%rax
ff ff ff
add    %r14,%rax
mov    %rax,0x190(%rsp)
lea    (%r8,%r9,8),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,0x1f0(%rsp)
lea    0x8(%rbx),%rax
mov    %rax,0x1c0(%rsp)
mov    %r9,%r13
shl    $0x21,%r13
lea    0x8(%rdi),%rax
mov    %rax,0x1b8(%rsp)
movapd 0x1a68(%rip),%xmm1
xorpd  %xmm0,%xmm0
movhpd 0x1a6c(%rip),%xmm0
movapd %xmm0,0x200(%rsp)
movapd 0x1a3b(%rip),%xmm2
shr    $0x20,%rbp
mov    %rbp,0x1e8(%rsp)
mov    0x108(%rsp),%rax
add    %rbx,%rax
add    $0xfffffffffffffff8,%rax
lea    (%rbx,%r9,8),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x170(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x188(%rsp)
mov    %rdx,0x1a8(%rsp)
movapd %xmm4,0x160(%rsp)
mov    %r13,0x1f8(%rsp)
mov    %rdx,%rbp
lea    -0x1(%rdx),%rcx
mov    %rcx,0x180(%rsp)
mov    $0x1,%ecx
mov    %rax,0x178(%rsp)
mov    %rdx,0x78(%rsp)
jmp    2698 <svd_gr2+0x1508>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd 0x160(%rsp),%xmm4
mov    0x1e0(%rsp),%r12
movq   $0x0,(%r11,%r12,8)
movsd  %xmm0,(%r11,%rbp,8)
movsd  %xmm3,(%r8,%rbp,8)
mov    0x15c(%rsp),%ecx
add    $0x1,%ecx
cmp    $0x33,%ecx
mov    0xb8(%rsp),%r10
movapd 0x1986(%rip),%xmm1
movapd 0x196e(%rip),%xmm2
je     3011 <svd_gr2+0x1e81>
mov    %ecx,0x15c(%rsp)
mov    %ebp,%eax
mov    0x190(%rsp),%rcx
mov    0x188(%rsp),%rdx
mov    0x198(%rsp),%rsi
nopl   0x0(%rax)
mov    %rsi,%r13
mov    %rcx,%rbp
mov    %rax,0x8(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x50(%rsp)
add    %rdx,%rax
mov    %rsi,0x60(%rsp)
js     2737 <svd_gr2+0x15a7>
mov    %eax,%eax
movsd  (%r11,%rax,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm4
jae    2746 <svd_gr2+0x15b6>
mov    0x1f0(%rsp),%rax
mov    0x50(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm1,%xmm0
movabs $0xffffffff00000000,%rax
ff ff ff
mov    0x60(%rsp),%r13
lea    0x0(%r13,%rax,1),%rsi
lea    -0x1(%rcx),%rdx
lea    (%rax,%rbp,1),%rcx
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
ucomisd %xmm0,%xmm4
jb     26c0 <svd_gr2+0x1530>
sar    $0x20,%r13
cmp    0x78(%rsp),%r13
jle    2da0 <svd_gr2+0x1c10>
mov    0x78(%rsp),%rbp
movsd  (%r8,%rbp,8),%xmm3
mov    0x1a8(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %ecx,%eax
cmp    %rbp,%rax
je     2ef4 <svd_gr2+0x1d64>
mov    0x60(%rsp),%rax
mov    %rax,%r12
sar    $0x20,%r12
sar    $0x1d,%rax
movsd  (%r8,%rax,1),%xmm0
movaps %xmm0,0x20(%rsp)
mov    0x180(%rsp),%rax
movsd  (%r8,%rax,8),%xmm4
movsd  %xmm4,0xa0(%rsp)
movsd  (%r11,%rax,8),%xmm5
movsd  (%r11,%rbp,8),%xmm2
movapd %xmm3,%xmm1
addsd  %xmm5,%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm3,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm4,%xmm0
movapd %xmm2,0x60(%rsp)
divsd  %xmm2,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
subsd  %xmm1,%xmm0
mulsd  0x1843(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x182d(%rip),%xmm1
movapd %xmm3,0xc0(%rsp)
call   1080 <hypot@plt>
movapd 0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm4
movapd %xmm4,%xmm1
cmpltsd 0x1816(%rip),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
xorpd  0x17d6(%rip),%xmm0
andpd  %xmm1,%xmm0
orpd   %xmm2,%xmm0
addsd  %xmm4,%xmm0
movapd 0xc0(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm2
subsd  %xmm1,%xmm2
movsd  0xa0(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd 0x60(%rsp),%xmm0
subsd  %xmm0,%xmm1
divsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cmp    %rbp,%r12
jge    2d70 <svd_gr2+0x1be0>
lea    0x1(%r12),%rax
mov    %rax,0xd0(%rsp)
mov    0x1d0(%rsp),%rax
add    %r12,%rax
mov    %rax,0x110(%rsp)
unpcklpd %xmm0,%xmm3
mov    0x1d8(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xf8(%rsp)
add    0x1c8(%rsp),%rcx
mov    %rcx,0x50(%rsp)
movslq 0x8(%rsp),%r10
mov    %r10,%rcx
shl    $0x20,%rcx
mov    0x1c0(%rsp),%rax
lea    (%rax,%r10,8),%rdx
mov    0x1b8(%rsp),%rax
lea    (%rax,%r10,8),%rax
mov    %rax,0x18(%rsp)
add    $0x1,%r10
mov    %r12,%rax
xor    %esi,%esi
mov    %r12,0x1e0(%rsp)
movsd  0x1716(%rip),%xmm1
movapd %xmm1,%xmm6
mov    0x88(%rsp),%r8
mov    0x58(%rsp),%rdi
mov    0x90(%rsp),%r11
jmp    29ad <svd_gr2+0x181d>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
xorpd  0x16c4(%rip),%xmm0
movapd 0xe0(%rsp),%xmm3
movapd %xmm3,%xmm2
movapd 0x140(%rsp),%xmm4
unpcklpd %xmm4,%xmm2
unpcklpd %xmm1,%xmm0
mulpd  %xmm2,%xmm0
unpcklpd %xmm3,%xmm4
movapd %xmm6,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm0,%xmm3
add    $0x1,%rsi
movabs $0x100000000,%rax
mov    0x8(%rsp),%rcx
add    %rax,%rcx
mov    0x40(%rsp),%rdx
add    $0x8,%rdx
add    $0x8,%r12
mov    %r12,0x18(%rsp)
add    $0x1,%r10
mov    0x78(%rsp),%rbp
mov    0x30(%rsp),%rax
cmp    %rbp,%rax
jge    2640 <svd_gr2+0x14b0>
mov    %rcx,0x8(%rsp)
movapd %xmm3,0x20(%rsp)
mov    %r10,0xa0(%rsp)
mov    %rax,%rbp
mov    %rdx,%r12
mov    0xf8(%rsp),%rdx
lea    (%rdx,%rsi,1),%eax
cltq
lea    (%rdi,%rax,8),%rcx
mov    %rcx,0x98(%rsp)
mov    0x150(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x100(%rsp)
mov    0xd0(%rsp),%rax
lea    (%rax,%rsi,1),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x110(%rsp),%rax
lea    (%rax,%rsi,1),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0x120(%rsp)
mov    %rsi,0xc0(%rsp)
lea    (%rdx,%rsi,1),%rax
mov    %rax,0x70(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x30(%rsp)
movsd  0x8(%r11,%rbp,8),%xmm0
movsd  0x8(%r8,%rbp,8),%xmm2
movsd  %xmm2,0x40(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x60(%rsp)
mulsd  %xmm0,%xmm6
movapd %xmm6,0xe0(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mov    %r11,%r13
call   1080 <hypot@plt>
movapd 0x20(%rsp),%xmm6
movapd 0x60(%rsp),%xmm5
movsd  %xmm0,0x0(%r13,%rbp,8)
shufpd $0x2,%xmm6,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
movapd 0xe0(%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,0xe0(%rsp)
movsd  0x40(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm2,0x140(%rsp)
mov    0xb8(%rsp),%rax
mov    %r12,0x40(%rsp)
mov    0x8(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  (%rbx,%rsi,1),%xmm7
movsd  (%r12),%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm5,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm0,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rbx,%rsi,1)
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%r12)
add    %r14,%rdx
add    %r15,%r12
add    $0xffffffffffffffff,%rax
jne    2b10 <svd_gr2+0x1980>
movapd %xmm6,%xmm0
movapd %xmm5,0x60(%rsp)
movapd %xmm6,0x20(%rsp)
movapd %xmm1,0x130(%rsp)
call   1080 <hypot@plt>
movapd 0x60(%rsp),%xmm1
mov    0x88(%rsp),%r8
movsd  %xmm0,(%r8,%rbp,8)
ucomisd 0x149d(%rip),%xmm0
mov    0x1f8(%rsp),%r13
jne    2b9f <svd_gr2+0x1a0f>
jnp    2bb6 <svd_gr2+0x1a26>
movapd 0x130(%rsp),%xmm1
unpcklpd 0x20(%rsp),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movapd %xmm1,%xmm6
unpckhpd %xmm1,%xmm6
mov    0x80(%rsp),%rax
test   %eax,%eax
mov    0x58(%rsp),%rdi
mov    0x90(%rsp),%r11
mov    0x10(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x18(%rsp),%r12
mov    0xc0(%rsp),%rsi
jle    2930 <svd_gr2+0x17a0>
cmp    $0x1,%eax
jne    2c70 <svd_gr2+0x1ae0>
xor    %edx,%edx
mov    %r9,%rax
imul   %rdx,%rax
add    %eax,%ebp
shl    $0x20,%rbp
add    %r10,%rax
lea    (%rdi,%rax,8),%rax
mov    0x118(%rsp),%rcx
sub    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
mov    %rbp,%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    %r14,%rbp
add    %r15,%rax
add    $0xffffffffffffffff,%rcx
jne    2c20 <svd_gr2+0x1a90>
jmp    2930 <svd_gr2+0x17a0>
nopw   0x0(%rax,%rax,1)
cmpl   $0x1,0x38(%rsp)
jne    2bfa <svd_gr2+0x1a6a>
mov    0x50(%rsp),%rax
add    %esi,%eax
cmp    0x70(%rsp),%eax
jl     2bfa <svd_gr2+0x1a6a>
mov    $0x0,%edx
cmpq   $0x0,0x1e8(%rsp)
jne    2bfc <svd_gr2+0x1a6c>
mov    0x120(%rsp),%rax
cmp    %rax,0x98(%rsp)
jae    2cc8 <svd_gr2+0x1b38>
mov    0xd8(%rsp),%rax
cmp    0x100(%rsp),%rax
jb     2bfa <svd_gr2+0x1a6a>
mov    %rbx,%r10
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
mov    0x1a0(%rsp),%rax
mov    %r12,%rcx
mov    0x8(%rsp),%rdx
mov    0x108(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
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    %r13,%rdx
add    %rbx,%rcx
add    $0xfffffffffffffffe,%rax
jne    2cf0 <svd_gr2+0x1b60>
mov    0x1a0(%rsp),%rax
mov    %rax,%rdx
cmp    0x118(%rsp),%rax
mov    %r10,%rbx
mov    0xa0(%rsp),%r10
mov    0xc0(%rsp),%rsi
je     2930 <svd_gr2+0x17a0>
jmp    2bfc <svd_gr2+0x1a6c>
cs nopw 0x0(%rax,%rax,1)
mov    0x88(%rsp),%r8
mov    0x58(%rsp),%rdi
mov    0x90(%rsp),%r11
mov    0x10(%rsp),%r9
movapd 0x160(%rsp),%xmm4
jmp    2659 <svd_gr2+0x14c9>
nopl   0x0(%rax,%rax,1)
sar    $0x20,%rbp
movslq 0x8(%rsp),%r12
shl    $0x3,%r12
movapd 0x200(%rsp),%xmm5
jmp    2e04 <svd_gr2+0x1c74>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r13),%rax
add    $0x8,%r12
cmp    0x78(%rsp),%r13
mov    %rax,%r13
mov    0x90(%rsp),%r11
mov    0x10(%rsp),%r9
mov    0xb8(%rsp),%r10
movapd 0x160(%rsp),%xmm4
movapd 0x121a(%rip),%xmm1
movapd 0x1202(%rip),%xmm2
jge    2746 <svd_gr2+0x15b6>
movsd  (%r11,%r13,8),%xmm3
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm5
movsd  %xmm5,(%r11,%r13,8)
movapd %xmm0,%xmm3
andpd  %xmm1,%xmm3
ucomisd %xmm3,%xmm4
jae    2746 <svd_gr2+0x15b6>
movsd  (%r8,%r13,8),%xmm1
movaps %xmm1,0xa0(%rsp)
movapd %xmm0,0x20(%rsp)
call   1080 <hypot@plt>
movapd 0xa0(%rsp),%xmm5
mov    0x58(%rsp),%rdi
mov    0x88(%rsp),%r8
movsd  %xmm0,(%r8,%r13,8)
movapd 0x20(%rsp),%xmm1
xorpd  0x118b(%rip),%xmm1
unpcklpd %xmm1,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
cmpl   $0x0,0x80(%rsp)
jle    2dc0 <svd_gr2+0x1c30>
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mov    0x118(%rsp),%rax
mov    %rdi,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rbp,8),%xmm1
movsd  (%rcx,%r12,1),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
mulsd  %xmm5,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%r12,1)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    2eb0 <svd_gr2+0x1d20>
jmp    2dc0 <svd_gr2+0x1c30>
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
mov    0x38(%rsp),%r12
mov    0x80(%rsp),%rsi
jbe    2f98 <svd_gr2+0x1e08>
xorpd  0x10e9(%rip),%xmm3
movlpd %xmm3,(%r8,%rbp,8)
cmp    $0x1,%r12d
jne    2f27 <svd_gr2+0x1d97>
xor    %eax,%eax
jmp    2f74 <svd_gr2+0x1de4>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x178(%rsp),%rbp
mov    0x170(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,1),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rdx,%rcx,1)
movsd  0x0(%rbp,%rcx,1),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x0(%rbp,%rcx,1)
add    $0x2,%rax
add    0x108(%rsp),%rcx
cmp    %rax,0x1b0(%rsp)
jne    2f40 <svd_gr2+0x1db0>
test   $0x1,%r10b
mov    0x78(%rsp),%rbp
je     2f98 <svd_gr2+0x1e08>
imul   %r9,%rax
add    %rbp,%rax
movsd  (%rbx,%rax,8),%xmm0
xorpd  0x106d(%rip),%xmm0
movlpd %xmm0,(%rbx,%rax,8)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x198(%rsp)
addq   $0xffffffffffffffff,0x188(%rsp)
add    %rax,0x190(%rsp)
mov    0x178(%rsp),%rax
add    $0xfffffffffffffff8,%rax
addq   $0xfffffffffffffff8,0x170(%rsp)
test   %rbp,%rbp
mov    0x180(%rsp),%rdx
jg     2613 <svd_gr2+0x1483>
xor    %r15d,%r15d
mov    %r12d,%edx
mov    %rbx,%rcx
xor    %eax,%eax
mov    %r11,%rbx
call   10b0 <svd_sort@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15d,%eax
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1046(%rip),%rdi
call   1040 <puts@plt>
mov    $0xf,%r15d
jmp    2ffc <svd_gr2+0x1e6c>

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

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