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


x86 assembly (clang, -O0):
<svd_gr>:
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)
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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1218 <svd_gr+0xa8>
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    11de <svd_gr+0x6e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    199f <svd_gr+0x82f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15af <svd_gr+0x43f>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c9 <svd_gr+0x159>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1d59(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    127e <svd_gr+0x10e>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12e9 <svd_gr+0x179>
jp     12e9 <svd_gr+0x179>
jmp    15aa <svd_gr+0x43a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1369 <svd_gr+0x1f9>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ef <svd_gr+0x17f>
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    13af <svd_gr+0x23f>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    13d8 <svd_gr+0x268>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    155c <svd_gr+0x3ec>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1557 <svd_gr+0x3e7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14cc <svd_gr+0x35c>
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    1472 <svd_gr+0x302>
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    1544 <svd_gr+0x3d4>
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    14e7 <svd_gr+0x377>
jmp    1549 <svd_gr+0x3d9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1458 <svd_gr+0x2e8>
jmp    155c <svd_gr+0x3ec>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a5 <svd_gr+0x435>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1562 <svd_gr+0x3f2>
jmp    15aa <svd_gr+0x43a>
jmp    15af <svd_gr+0x43f>
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1932 <svd_gr+0x7c2>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1932 <svd_gr+0x7c2>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1658 <svd_gr+0x4e8>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x19ca(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1611 <svd_gr+0x4a1>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1678 <svd_gr+0x508>
jp     1678 <svd_gr+0x508>
jmp    192d <svd_gr+0x7bd>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16ee <svd_gr+0x57e>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    167e <svd_gr+0x50e>
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    1730 <svd_gr+0x5c0>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1759 <svd_gr+0x5e9>
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    1808 <svd_gr+0x698>
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    17c4 <svd_gr+0x654>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18e9 <svd_gr+0x779>
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    1882 <svd_gr+0x712>
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    1832 <svd_gr+0x6c2>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18d6 <svd_gr+0x766>
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    1888 <svd_gr+0x718>
jmp    18db <svd_gr+0x76b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    180e <svd_gr+0x69e>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1928 <svd_gr+0x7b8>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18ef <svd_gr+0x77f>
jmp    192d <svd_gr+0x7bd>
jmp    1932 <svd_gr+0x7c2>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x16ba(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x169f(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    198c <svd_gr+0x81c>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1991 <svd_gr+0x821>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121f <svd_gr+0xaf>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1bdc <svd_gr+0xa6c>
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    1b99 <svd_gr+0xa29>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19ea <svd_gr+0x87a>
jp     19ea <svd_gr+0x87a>
jmp    1b46 <svd_gr+0x9d6>
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    1a5c <svd_gr+0x8ec>
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    1a12 <svd_gr+0x8a2>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b41 <svd_gr+0x9d1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ad0 <svd_gr+0x960>
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    1a7c <svd_gr+0x90c>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b2e <svd_gr+0x9be>
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    1ad6 <svd_gr+0x966>
jmp    1b33 <svd_gr+0x9c3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a62 <svd_gr+0x8f2>
jmp    1b46 <svd_gr+0x9d6>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b94 <svd_gr+0xa24>
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    1b4c <svd_gr+0x9dc>
jmp    1b99 <svd_gr+0xa29>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1462(%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    19a8 <svd_gr+0x838>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1e63 <svd_gr+0xcf3>
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    1c5f <svd_gr+0xaef>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1c5a <svd_gr+0xaea>
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    1c2b <svd_gr+0xabb>
jmp    1c5f <svd_gr+0xaef>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c7c <svd_gr+0xb0c>
jp     1c7c <svd_gr+0xb0c>
jmp    1df8 <svd_gr+0xc88>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1da2 <svd_gr+0xc32>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d9d <svd_gr+0xc2d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d05 <svd_gr+0xb95>
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    1cad <svd_gr+0xb3d>
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    1d8a <svd_gr+0xc1a>
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    1d2f <svd_gr+0xbbf>
jmp    1d8f <svd_gr+0xc1f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c93 <svd_gr+0xb23>
jmp    1da2 <svd_gr+0xc32>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1df3 <svd_gr+0xc83>
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    1da8 <svd_gr+0xc38>
jmp    1e36 <svd_gr+0xcc6>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e31 <svd_gr+0xcc1>
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    1dfe <svd_gr+0xc8e>
jmp    1e36 <svd_gr+0xcc6>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x11c5(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1be5 <svd_gr+0xa75>
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     283d <svd_gr+0x16cd>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x32,-0x54(%rbp)
jle    1eb9 <svd_gr+0xd49>
lea    0x117a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xf,-0x4(%rbp)
jmp    2868 <svd_gr+0x16f8>
movl   $0x1,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1f4a <svd_gr+0xdda>
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1119(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f06 <svd_gr+0xd96>
movl   $0x0,-0x50(%rbp)
jmp    1f4a <svd_gr+0xdda>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x10e1(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f37 <svd_gr+0xdc7>
jmp    1f4a <svd_gr+0xdda>
jmp    1f3c <svd_gr+0xdcc>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1ec6 <svd_gr+0xd56>
cmpl   $0x0,-0x50(%rbp)
je     215e <svd_gr+0xfee>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x10a9(%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     2159 <svd_gr+0xfe9>
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 0x1030(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1fe8 <svd_gr+0xe78>
jmp    2159 <svd_gr+0xfe9>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
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    2146 <svd_gr+0xfd6>
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    2069 <svd_gr+0xef9>
jmp    214b <svd_gr+0xfdb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f7b <svd_gr+0xe0b>
jmp    215e <svd_gr+0xfee>
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     2778 <svd_gr+0x1608>
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)
ff
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm1
addsd  -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  0xddd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0xdb9(%rip),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    2289 <svd_gr+0x1119>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    229b <svd_gr+0x112b>
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  0xd02(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xcf5(%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     2736 <svd_gr+0x15c6>
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    2555 <svd_gr+0x13e5>
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    247b <svd_gr+0x130b>
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    25a4 <svd_gr+0x1434>
jp     25a4 <svd_gr+0x1434>
jmp    25d1 <svd_gr+0x1461>
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    2723 <svd_gr+0x15b3>
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    2640 <svd_gr+0x14d0>
jmp    2728 <svd_gr+0x15b8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    232c <svd_gr+0x11bc>
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    2825 <svd_gr+0x16b5>
xorps  %xmm0,%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jbe    2820 <svd_gr+0x16b0>
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    281b <svd_gr+0x16ab>
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    27bc <svd_gr+0x164c>
jmp    2820 <svd_gr+0x16b0>
jmp    282a <svd_gr+0x16ba>
jmp    1e8c <svd_gr+0xd1c>
jmp    282f <svd_gr+0x16bf>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e7b <svd_gr+0xd0b>
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_gr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x228,%rsp
mov    %r9,0x60(%rsp)
mov    %r8,0x28(%rsp)
mov    %rcx,%r12
mov    %edx,%ebp
mov    %esi,%ebx
mov    %rdi,%r14
movslq %edx,%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%rax,8),%r15
mov    %r15,%rdi
call   1060 <malloc@plt>
mov    %rax,0x20(%rsp)
xor    %eax,%eax
call   1080 <macheps@plt>
mov    %r12,%rdi
mov    %rbp,%r10
mov    %r10d,%edx
mov    %rbx,%rcx
mov    %rbx,0x118(%rsp)
imul   %ebx,%edx
test   %edx,%edx
jle    1359 <svd_gr+0x1d9>
mov    %edx,%ebx
cmp    $0x4,%edx
jb     1209 <svd_gr+0x89>
lea    (%r14,%rbx,8),%rdx
cmp    %rdi,%rdx
jbe    1280 <svd_gr+0x100>
lea    (%rdi,%rbx,8),%rdx
cmp    %r14,%rdx
jbe    1280 <svd_gr+0x100>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rbx,%rsi
mov    %rbx,%rcx
and    $0x3,%rcx
je     1235 <svd_gr+0xb5>
nopl   (%rax)
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1220 <svd_gr+0xa0>
cmp    $0x3,%rsi
jb     1359 <svd_gr+0x1d9>
nop
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    1240 <svd_gr+0xc0>
jmp    1359 <svd_gr+0x1d9>
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    12a5 <svd_gr+0x125>
xor    %ebp,%ebp
jmp    1314 <svd_gr+0x194>
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    12b0 <svd_gr+0x130>
test   %r8,%r8
je     1350 <svd_gr+0x1d0>
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    1330 <svd_gr+0x1b0>
cmp    %rbx,%rdx
jne    120b <svd_gr+0x8b>
test   %r10d,%r10d
mov    0x60(%rsp),%r8
mov    0x18(%rsp),%rdx
jle    31a0 <svd_gr+0x2020>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x158(%rsp)
lea    -0x1(%r10),%eax
mov    %rax,0xf8(%rsp)
movslq 0x118(%rsp),%r11
mov    %r10,%rbp
mov    %ebp,%r10d
mov    %r11d,%r12d
lea    -0x2(%r10),%rcx
mov    %rcx,0x130(%rsp)
lea    0x8(,%rdx,8),%rax
mov    %rax,0xa8(%rsp)
lea    0x8(%rdi),%r14
mov    0x20(%rsp),%rcx
lea    0x18(%rcx),%rax
mov    %rax,0x160(%rsp)
lea    -0x3(%r10),%r9
lea    (%rdi,%rdx,8),%rax
lea    0x38(%rdi,%rdx,8),%rdx
mov    %rdx,0x50(%rsp)
mov    %r14,%rdx
mov    %rcx,%rsi
add    $0x38,%rsi
mov    %rsi,0xb0(%rsp)
lea    -0x5(%r10),%r13
xorpd  %xmm8,%xmm8
mov    $0x1,%esi
mov    %rsi,0x10(%rsp)
xor    %esi,%esi
movapd 0x2bf5(%rip),%xmm7
movapd 0x2bec(%rip),%xmm9
xorpd  %xmm12,%xmm12
xorpd  %xmm4,%xmm4
xorpd  %xmm10,%xmm10
mov    %rdi,%r14
mov    %r10,0x170(%rsp)
mov    %r12,0x138(%rsp)
mov    %r12,0x70(%rsp)
mov    %rdi,%r12
mov    %rbp,0x68(%rsp)
mov    %rdi,0x38(%rsp)
mov    %r10,0x58(%rsp)
mov    %r11,0xd0(%rsp)
jmp    14e8 <svd_gr+0x368>
nopl   0x0(%rax)
lea    (%r8,%rbp,8),%rsi
movq   $0x0,(%r8,%rbp,8)
xorpd  %xmm10,%xmm10
xorpd  %xmm12,%xmm12
movsd  (%rsi),%xmm0
movsd  (%rcx,%rbp,8),%xmm4
andpd  %xmm9,%xmm0
andpd  %xmm9,%xmm4
addsd  %xmm0,%xmm4
maxsd  %xmm11,%xmm4
addq   $0x1,0x10(%rsp)
mov    0xa8(%rsp),%rsi
add    %rsi,%r12
addq   $0xffffffffffffffff,0x70(%rsp)
add    %rsi,%rdx
addq   $0xffffffffffffffff,0x170(%rsp)
addq   $0x8,0x160(%rsp)
add    $0xffffffffffffffff,%r9
add    %r15,%r14
add    %r15,%rax
add    %rsi,0x50(%rsp)
addq   $0x8,0xb0(%rsp)
add    $0xffffffffffffffff,%r13
mov    0x40(%rsp),%rsi
cmp    %r10,%rsi
je     1ec9 <svd_gr+0xd49>
movapd %xmm4,%xmm11
mov    %rsi,%rbp
mulsd  %xmm10,%xmm12
add    $0x1,%rsi
movsd  %xmm12,(%rcx,%rbp,8)
cmp    %r11,%rbp
mov    %rsi,0x40(%rsp)
jge    1460 <svd_gr+0x2e0>
mov    %rax,0xe0(%rsp)
mov    %r13,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x108(%rsp)
mov    %r9,%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x190(%rsp)
mov    %rbp,%rax
not    %rax
lea    (%rax,%r10,1),%rcx
mov    %rcx,0xc0(%rsp)
lea    (%rax,%r10,1),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x88(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x110(%rsp)
add    %r10,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x120(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,0x128(%rsp)
xorpd  %xmm3,%xmm3
mov    0x70(%rsp),%rax
mov    %r12,%rcx
xchg   %ax,%ax
movsd  (%rcx),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm3
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    15a0 <svd_gr+0x420>
xorpd  %xmm10,%xmm10
ucomisd %xmm10,%xmm3
xorpd  %xmm1,%xmm1
jne    15cb <svd_gr+0x44b>
jnp    17d7 <svd_gr+0x657>
xorpd  %xmm5,%xmm5
mov    0x70(%rsp),%rax
mov    %r12,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    15e0 <svd_gr+0x460>
mov    %r13,0x90(%rsp)
mov    %r9,0x98(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %ebp,%eax
imul   0x68(%rsp),%eax
movslq %eax,%r13
mov    %rbp,0x8(%rsp)
add    %rbp,%r13
movsd  (%rdi,%r13,8),%xmm4
ucomisd %xmm8,%xmm5
jb     163d <svd_gr+0x4bd>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    16b7 <svd_gr+0x537>
movapd %xmm5,%xmm0
movsd  %xmm11,0x100(%rsp)
movsd  %xmm3,0x30(%rsp)
movsd  %xmm4,0xb8(%rsp)
movsd  %xmm5,0x140(%rsp)
call   1090 <sqrt@plt>
movsd  0x140(%rsp),%xmm5
movsd  0xb8(%rsp),%xmm4
movsd  0x30(%rsp),%xmm3
movsd  0x100(%rsp),%xmm11
xorpd  %xmm10,%xmm10
movapd 0x2968(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    0xd0(%rsp),%r11
movapd 0x2953(%rip),%xmm7
mov    0x38(%rsp),%rdi
mov    0x60(%rsp),%r8
mov    0x70(%rsp),%rbp
movapd %xmm4,%xmm1
cmpltsd %xmm8,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  0x293a(%rip),%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%r13,8)
mov    0x8(%rsp),%rax
cmp    0xf8(%rsp),%rax
mov    0x58(%rsp),%r10
jae    179a <svd_gr+0x61a>
mov    0x40(%rsp),%rax
cmp    0x18(%rsp),%rax
jge    179a <svd_gr+0x61a>
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mov    0xa0(%rsp),%rax
mov    0x10(%rsp),%rcx
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    %rbp,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%r12,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm0
add    %r15,%rsi
add    $0xffffffffffffffff,%rdx
jne    1740 <svd_gr+0x5c0>
divsd  %xmm4,%xmm0
mov    %rbp,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rsi,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %r15,%rsi
add    $0xffffffffffffffff,%rdx
jne    1770 <svd_gr+0x5f0>
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r10,%rcx
jne    1730 <svd_gr+0x5b0>
mov    %rbp,%rax
mov    %r12,%rcx
movsd  (%rcx),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    17a0 <svd_gr+0x620>
mov    0xa0(%rsp),%rdx
mov    0x98(%rsp),%r9
mov    0x90(%rsp),%r13
mov    0x40(%rsp),%rsi
mov    0x8(%rsp),%rbp
mulsd  %xmm1,%xmm3
lea    (%r8,%rbp,8),%rax
mov    %rax,0x30(%rsp)
movsd  %xmm3,(%r8,%rbp,8)
cmp    0xf8(%rsp),%rbp
mov    0x20(%rsp),%rcx
mov    0xe0(%rsp),%rax
je     18e0 <svd_gr+0x760>
cmp    %r11,%rsi
jge    18e0 <svd_gr+0x760>
mov    %rbp,0x8(%rsp)
mov    %rbp,%rsi
imul   0x18(%rsp),%rsi
xorpd  %xmm12,%xmm12
mov    $0x1,%eax
mov    0x70(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x1,%rax
cmp    %rax,%rbp
jne    1830 <svd_gr+0x6b0>
xorpd  %xmm10,%xmm10
ucomisd %xmm10,%xmm12
jne    185a <svd_gr+0x6da>
jnp    18ef <svd_gr+0x76f>
xorpd  %xmm3,%xmm3
mov    0x40(%rsp),%rax
cmp    0x18(%rsp),%rax
mov    0x170(%rsp),%rbp
jge    18a2 <svd_gr+0x722>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
divsd  %xmm12,%xmm0
movsd  %xmm0,(%r12,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rbp
jne    1880 <svd_gr+0x700>
mov    0x40(%rsp),%rax
lea    (%rsi,%rax,1),%rbp
movsd  (%rdi,%rbp,8),%xmm2
ucomisd %xmm8,%xmm3
mov    %r9,0x98(%rsp)
mov    %r13,0x90(%rsp)
mov    %rsi,0xb8(%rsp)
jb     18fc <svd_gr+0x77c>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    1984 <svd_gr+0x804>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm12,%xmm12
mov    0x30(%rsp),%rsi
jmp    1476 <svd_gr+0x2f6>
mov    0xe0(%rsp),%rax
jmp    1dc1 <svd_gr+0xc41>
movapd %xmm3,%xmm0
mov    %rdx,%r13
movsd  %xmm11,0x100(%rsp)
movapd %xmm12,0x140(%rsp)
movapd %xmm2,0x1a0(%rsp)
movsd  %xmm3,0x188(%rsp)
call   1090 <sqrt@plt>
movsd  0x188(%rsp),%xmm3
movapd 0x1a0(%rsp),%xmm2
movapd 0x140(%rsp),%xmm12
movsd  0x100(%rsp),%xmm11
mov    0x40(%rsp),%rax
movapd 0x269e(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    %r13,%rdx
mov    0xd0(%rsp),%r11
movapd 0x2686(%rip),%xmm7
mov    0x20(%rsp),%rcx
mov    0x38(%rsp),%rdi
movapd %xmm2,%xmm10
cmpltsd %xmm8,%xmm10
movapd %xmm10,%xmm1
andpd  %xmm0,%xmm1
xorpd  0x2670(%rip),%xmm0
andnpd %xmm0,%xmm10
orpd   %xmm1,%xmm10
movapd %xmm2,%xmm0
subsd  %xmm10,%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
mov    %rax,%r13
cmp    0x18(%rsp),%rax
mov    0x58(%rsp),%rsi
jge    1ab8 <svd_gr+0x938>
mulsd  %xmm10,%xmm2
subsd  %xmm3,%xmm2
mov    0x10(%rsp),%rax
cmpq   $0x2,0xc0(%rsp)
jb     1aa0 <svd_gr+0x920>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x2,0x120(%rsp)
jae    19ff <svd_gr+0x87f>
xor    %ecx,%ecx
jmp    1a48 <svd_gr+0x8c8>
xor    %ecx,%ecx
mov    0x160(%rsp),%rax
mov    0x190(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rax,%rcx,8)
movupd 0x10(%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1a20 <svd_gr+0x8a0>
mov    0xc0(%rsp),%rbp
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
testb  $0x1,0x128(%rsp)
01
je     1a8a <svd_gr+0x90a>
add    0x10(%rsp),%rcx
mov    %rdx,%r8
mov    0xb8(%rsp),%rdx
add    %rcx,%rdx
movupd (%rdi,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
mov    0x20(%rsp),%rdx
movupd %xmm1,(%rdx,%rcx,8)
mov    %r8,%rdx
cmp    %rax,%rbp
mov    0x20(%rsp),%rcx
je     1ab8 <svd_gr+0x938>
add    0x10(%rsp),%rax
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1aa0 <svd_gr+0x920>
mov    %rdx,0xa0(%rsp)
cmp    %r11,%r13
mov    0x10(%rsp),%r10
mov    0xc0(%rsp),%rdx
jge    1d23 <svd_gr+0xba3>
mov    0xb8(%rsp),%rax
lea    (%r10,%rax,1),%rbx
lea    0x1(%r10),%r11
mov    %rdx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x128(%rsp)
add    %r10,%rax
mov    %rax,0x120(%rsp)
mov    0x50(%rsp),%rdi
mov    0xe0(%rsp),%rbp
mov    %r10,%rsi
jmp    1b38 <svd_gr+0x9b8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    %r15,%rbp
add    %r15,%rdi
cmp    0x138(%rsp),%rsi
je     1d23 <svd_gr+0xba3>
cmp    0x18(%rsp),%r13
jge    1b20 <svd_gr+0x9a0>
mov    %rsi,%r9
imul   0x18(%rsp),%r9
xorpd  %xmm1,%xmm1
mov    %r10,%rax
test   $0x1,%dl
je     1b78 <svd_gr+0x9f8>
lea    (%r10,%r9,1),%rax
mov    0x38(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  (%rcx,%rbx,8),%xmm0
mov    0x20(%rsp),%rcx
addsd  %xmm8,%xmm0
mov    %r11,%rax
movapd %xmm0,%xmm1
mov    0x8(%rsp),%rdx
cmp    %rdx,0x130(%rsp)
mov    0x58(%rsp),%r8
je     1bbe <svd_gr+0xa3e>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm2
mulsd  0x8(%r14,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%r8
jne    1b90 <svd_gr+0xa10>
cmp    0x18(%rsp),%r13
mov    0xc0(%rsp),%rdx
jge    1b20 <svd_gr+0x9a0>
mov    %r10,%rax
cmp    $0x4,%rdx
jb     1d00 <svd_gr+0xb80>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x88(%rsp)
mov    0xb0(%rsp),%rdx
jae    1c00 <svd_gr+0xa80>
xor    %eax,%eax
jmp    1c7f <svd_gr+0xaff>
mov    0x108(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rax,8),%xmm2
movupd -0x20(%rdx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdi,%rax,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rdi,%rax,8),%xmm2
movupd -0x10(%rdi,%rax,8),%xmm5
movupd (%rdi,%rax,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rdi,%rax,8)
movupd %xmm3,-0x20(%rdi,%rax,8)
movupd -0x10(%rdx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rdi,%rax,8)
movupd %xmm3,(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c10 <svd_gr+0xa90>
testb  $0x1,0x110(%rsp)
01
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%r10
je     1cd4 <svd_gr+0xb54>
add    %r10,%rax
movupd (%rcx,%rax,8),%xmm2
movupd 0x10(%rcx,%rax,8),%xmm3
add    %r9,%rax
mov    0x38(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm4
movupd 0x10(%rcx,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rax,8)
movupd %xmm3,0x10(%rcx,%rax,8)
mov    0x20(%rsp),%rcx
mov    0x120(%rsp),%rax
mov    0xc0(%rsp),%rdx
cmp    0x128(%rsp),%rdx
mov    0x58(%rsp),%r8
je     1b20 <svd_gr+0x9a0>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r8
jne    1d00 <svd_gr+0xb80>
jmp    1b20 <svd_gr+0x9a0>
mov    %r13,%rax
cmp    0x18(%rsp),%r13
jge    1d8a <svd_gr+0xc0a>
mov    %r10,%rcx
cmp    $0x4,%rdx
mov    0x60(%rsp),%r8
mov    0x38(%rsp),%rdi
mov    0x58(%rsp),%r10
mov    0xa0(%rsp),%rdx
mov    0x98(%rsp),%r9
mov    0x90(%rsp),%r13
mov    0x8(%rsp),%rbp
jb     1e90 <svd_gr+0xd10>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x4,0x88(%rsp)
jae    1dd0 <svd_gr+0xc50>
xor    %eax,%eax
mov    0xb8(%rsp),%rsi
jmp    1e38 <svd_gr+0xcb8>
mov    0x60(%rsp),%r8
mov    0x38(%rsp),%rdi
mov    0x58(%rsp),%r10
mov    0xd0(%rsp),%r11
mov    0xa0(%rsp),%rdx
mov    0x98(%rsp),%r9
mov    0xe0(%rsp),%rax
mov    0x90(%rsp),%r13
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%rsi
jmp    1476 <svd_gr+0x2f6>
xor    %eax,%eax
mov    0x108(%rsp),%rcx
mov    0xb8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdx,%rax,8),%xmm1
movupd 0x10(%rdx,%rax,8),%xmm2
movupd 0x20(%rdx,%rax,8),%xmm3
movupd 0x30(%rdx,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdx,%rax,8)
movupd %xmm2,0x10(%rdx,%rax,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x20(%rdx,%rax,8)
movupd %xmm4,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1df0 <svd_gr+0xc70>
mov    0xc0(%rsp),%r11
mov    %r11,%rcx
and    $0xfffffffffffffffc,%rcx
testb  $0x1,0x110(%rsp)
01
je     1e77 <svd_gr+0xcf7>
add    0x10(%rsp),%rax
add    %rsi,%rax
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
cmp    %rcx,%r11
je     1eaa <svd_gr+0xd2a>
add    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1e90 <svd_gr+0xd10>
mov    0x20(%rsp),%rcx
mov    0xd0(%rsp),%r11
mov    0xe0(%rsp),%rax
mov    0x30(%rsp),%rsi
jmp    1476 <svd_gr+0x2f6>
mov    0x68(%rsp),%r10
test   %r10d,%r10d
mov    0x18(%rsp),%rdx
jle    31a0 <svd_gr+0x2020>
mov    %rdx,%r14
neg    %r14
lea    -0x1(%rdx),%rcx
lea    (%rdx,%rdx,1),%r13
mov    %rcx,%rax
imul   %rdx,%rax
lea    (%rdi,%rax,8),%rsi
add    $0x8,%rsi
mov    %r15,%r9
neg    %r9
mov    %rdx,%r8
shl    $0x4,%r8
mov    0x28(%rsp),%rbx
lea    -0x8(%rbx),%rbp
mov    %rbp,0x170(%rsp)
lea    (%rbx,%rax,8),%r12
add    $0x8,%r12
movq   $0xfffffffffffffff8,0x98(%rsp)
xorpd  %xmm0,%xmm0
mov    %rcx,0x108(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rbx,0x90(%rsp)
mov    %rdx,%rbp
mov    %r8,0x1a0(%rsp)
mov    %r9,0x130(%rsp)
jmp    1fc1 <svd_gr+0xe41>
nopl   0x0(%rax)
movslq 0x160(%rsp),%rax
mov    0x10(%rsp),%rbp
add    %rbp,%rax
movabs $0x3ff0000000000000,%rcx
mov    0x28(%rsp),%rbx
mov    %rcx,(%rbx,%rax,8)
mov    0x20(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm10
addq   $0xfffffffffffffff8,0x90(%rsp)
add    %r9,%rsi
addq   $0xffffffffffffffff,0x50(%rsp)
addq   $0xfffffffffffffff8,0x170(%rsp)
addq   $0xfffffffffffffff8,0x98(%rsp)
add    %r9,%r12
cmpq   $0x1,0x8(%rsp)
jle    23f2 <svd_gr+0x1272>
lea    -0x1(%rbp),%rcx
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
imul   %r10d,%ecx
mov    %rcx,0x160(%rsp)
mov    %rbp,%rax
mov    %rbp,0x8(%rsp)
cmp    0xf8(%rsp),%rbp
jg     1f60 <svd_gr+0xde0>
mov    %r12,0x110(%rsp)
movslq 0x8(%rsp),%rax
mov    %rdx,%rbx
sub    %rax,%rbx
mov    %rax,%rcx
mov    %rax,0xa8(%rsp)
not    %rax
mov    %rax,0x40(%rsp)
mov    0x10(%rsp),%rax
imul   %rdx,%rax
mov    %rax,0x88(%rsp)
ucomisd %xmm0,%xmm10
mov    0x28(%rsp),%rbp
jne    2038 <svd_gr+0xeb8>
jnp    2320 <svd_gr+0x11a0>
mov    0x8(%rsp),%rax
cmp    0x68(%rsp),%eax
jge    2320 <svd_gr+0x11a0>
mov    0x10(%rsp),%r9
mov    0x160(%rsp),%rax
add    %r9d,%eax
cltq
mulsd  0x8(%rdi,%rax,8),%xmm10
movslq 0x8(%rsp),%rcx
mov    %rbx,0xc0(%rsp)
test   $0x1,%bl
je     209b <svd_gr+0xf1b>
mov    0x88(%rsp),%rax
add    %rcx,%rax
movsd  (%rdi,%rax,8),%xmm1
divsd  %xmm10,%xmm1
mov    %rcx,%rax
imul   %rdx,%rax
add    %r9,%rax
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rcx
mov    0x68(%rsp),%r9
cmp    %r14,0x40(%rsp)
je     20fb <svd_gr+0xf7b>
mov    %rdx,%rax
imul   %rcx,%rax
mov    0x90(%rsp),%rbx
lea    (%rbx,%rax,8),%rax
lea    0x1(%rcx),%rbp
imul   %rdx,%rbp
lea    (%rbx,%rbp,8),%rbx
mov    0x108(%rsp),%rbp
xchg   %ax,%ax
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm10,%xmm1
movsd  %xmm1,(%rax,%rbp,8)
movsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm10,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
add    $0x2,%rcx
add    %r13,%rbp
cmp    %rcx,%rdx
jne    20d0 <svd_gr+0xf50>
cmp    %r9d,0x8(%rsp)
mov    0xc0(%rsp),%rbx
jge    2320 <svd_gr+0x11a0>
mov    0xa8(%rsp),%rax
mov    0x28(%rsp),%r9
lea    (%r9,%rax,8),%r10
movslq 0x8(%rsp),%r12
mov    0x88(%rsp),%rax
add    %r12,%rax
mov    %rax,0x30(%rsp)
mov    %r12,%rcx
imul   %rdx,%rcx
lea    0x1(%r12),%rax
mov    %rax,0xe0(%rsp)
mov    0x10(%rsp),%rax
mov    %rcx,0xb0(%rsp)
add    %rcx,%rax
mov    %rax,0xa0(%rsp)
mov    %r12,0x70(%rsp)
jmp    21a2 <svd_gr+0x1022>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x8,%r9
add    $0x8,%r10
mov    0x18(%rsp),%rdx
cmp    %rdx,%r12
mov    0x38(%rsp),%rdi
mov    0xd0(%rsp),%r11
mov    %rbx,%r14
mov    0xc0(%rsp),%rbx
je     2320 <svd_gr+0x11a0>
xorpd  %xmm2,%xmm2
mov    0x70(%rsp),%rcx
test   $0x1,%bl
je     21df <svd_gr+0x105f>
mov    0x30(%rsp),%rax
movsd  (%rdi,%rax,8),%xmm1
mov    0xb0(%rsp),%rax
add    %r12,%rax
mov    0x28(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xe0(%rsp),%rcx
movapd %xmm1,%xmm2
cmp    %r14,0x40(%rsp)
je     223e <svd_gr+0x10be>
mov    %rdx,%rax
imul   %rcx,%rax
lea    (%r9,%rax,8),%rax
lea    0x1(%rcx),%rdi
imul   %rdx,%rdi
lea    (%r9,%rdi,8),%rbp
mov    0xa8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rsi,%rcx,8),%xmm3
mulsd  (%rax,%rdi,8),%xmm3
movsd  (%rsi,%rcx,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  0x0(%rbp,%rdi,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rcx
add    %r13,%rdi
movapd %xmm1,%xmm2
cmp    %rcx,%rdx
jne    2210 <svd_gr+0x1090>
mov    0x70(%rsp),%rdi
test   $0x1,%bl
je     227b <svd_gr+0x10fb>
mov    0xb0(%rsp),%rax
add    %r12,%rax
mov    0x28(%rsp),%rcx
mov    0xa0(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
mov    0xe0(%rsp),%rdi
mov    %r14,%rbx
cmp    %r14,0x40(%rsp)
je     2170 <svd_gr+0xff0>
mov    0x18(%rsp),%r8
mov    %r8,%rcx
sub    %rdi,%rcx
mov    %r8,%rax
imul   %rdi,%rax
lea    (%r12,%rax,1),%rbp
mov    0x28(%rsp),%rdx
lea    (%rdx,%rbp,8),%r11
add    0x50(%rsp),%rax
lea    (%rdx,%rax,8),%rax
lea    0x1(%rdi),%rbp
imul   %r8,%rbp
lea    (%r10,%rbp,8),%rbp
lea    0x10(,%rdi,8),%r14
imul   %r8,%r14
mov    0x1a0(%rsp),%r8
add    0x170(%rsp),%r14
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r11,%rdi,1),%xmm2
movsd  %xmm2,(%r11,%rdi,1)
movsd  (%r14,%rdi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rdi,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rdi,1)
add    %r8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    22e0 <svd_gr+0x1160>
jmp    2170 <svd_gr+0xff0>
nopl   0x0(%rax)
mov    0x68(%rsp),%r10
cmp    %r10d,0x8(%rsp)
mov    0x130(%rsp),%r9
mov    0x110(%rsp),%r12
jge    1f60 <svd_gr+0xde0>
movslq 0x8(%rsp),%rcx
test   $0x1,%bl
je     237c <svd_gr+0x11fc>
mov    %rcx,%rax
imul   %rdx,%rax
add    0x10(%rsp),%rax
mov    0x28(%rsp),%rbp
movq   $0x0,0x0(%rbp,%rax,8)
mov    0x88(%rsp),%rax
add    %rcx,%rax
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%rcx
cmp    %r14,0x40(%rsp)
je     1f60 <svd_gr+0xde0>
lea    0x10(,%rcx,8),%rax
imul   %rdx,%rax
mov    0x28(%rsp),%rbp
add    %rbp,%rax
lea    0x8(,%rcx,8),%rbx
imul   %rdx,%rbx
add    %rbp,%rbx
mov    0x98(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   $0x0,(%rbx,%rbp,1)
movq   $0x0,-0x8(%r12,%rcx,8)
movq   $0x0,(%rax,%rbp,1)
movq   $0x0,(%r12,%rcx,8)
add    $0x2,%rcx
add    %r8,%rbp
cmp    %rcx,%rdx
jne    23c0 <svd_gr+0x1240>
jmp    1f60 <svd_gr+0xde0>
test   %r10d,%r10d
mov    0x60(%rsp),%r8
jle    31a0 <svd_gr+0x2020>
mov    %r10d,%eax
imul   %r10d,%eax
mov    %eax,0xb0(%rsp)
mov    %r10d,%eax
not    %eax
mov    %eax,0xe0(%rsp)
mov    %rdx,%rax
imul   %rdx,%rax
lea    (%rdi,%rax,8),%r14
add    $0xfffffffffffffff8,%r14
mov    %r15,%rcx
xor    $0xfffffffffffffff8,%rcx
mov    %rcx,0xc0(%rsp)
lea    0x1(%r11),%rcx
mov    %rcx,0x40(%rsp)
lea    0x1(%rdx),%rcx
imul   %rdx,%rcx
lea    (%rdi,%rcx,8),%rsi
mov    %rsi,0x70(%rsp)
lea    (%rdi,%rcx,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    (%rdi,%rax,8),%rax
mov    %rax,0x8(%rsp)
xor    %esi,%esi
xorpd  %xmm3,%xmm3
movsd  0x1baf(%rip),%xmm2
movapd %xmm4,0x140(%rsp)
jmp    24c0 <svd_gr+0x1340>
nopl   0x0(%rax)
movslq %r8d,%rax
add    %rdx,%rax
movsd  (%rdi,%rax,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rsi
mov    0xc0(%rsp),%rax
add    %rax,%r14
add    %rax,0x70(%rsp)
add    %rax,%rbp
add    %rax,0x8(%rsp)
cmp    0x58(%rsp),%rsi
mov    0x60(%rsp),%r8
je     26c8 <svd_gr+0x1548>
mov    %rdx,%r12
add    $0xffffffffffffffff,%rdx
movsd  -0x8(%r8,%r12,8),%xmm5
cmp    0xf8(%rsp),%r12
jg     255d <svd_gr+0x13dd>
cmp    0x18(%rsp),%r12
jge    255d <svd_gr+0x13dd>
movabs $0x7fffffff8,%rax
mov    %rdx,%r13
lea    (%rax,%rsi,8),%rdx
and    %rax,%rdx
add    $0x8,%rdx
mov    0xe0(%rsp),%eax
imul   %esi,%eax
add    0xb0(%rsp),%eax
cltq
lea    (%rdi,%rax,8),%rdi
mov    %rsi,%rbx
xor    %esi,%esi
movsd  %xmm5,0x10(%rsp)
call   1050 <memset@plt>
movsd  0x10(%rsp),%xmm5
mov    %r13,%rdx
xorpd  %xmm3,%xmm3
mov    %rbx,%rsi
movsd  0x1ae6(%rip),%xmm2
movapd 0x140(%rsp),%xmm4
mov    0xd0(%rsp),%r11
movapd 0x1aad(%rip),%xmm7
mov    0x38(%rsp),%rdi
mov    0x68(%rsp),%r10
mov    %edx,%r8d
imul   %r10d,%r8d
ucomisd %xmm3,%xmm5
jne    2570 <svd_gr+0x13f0>
jnp    2690 <svd_gr+0x1510>
mov    %rsi,0x10(%rsp)
mov    %rdx,%r13
cmp    0xf8(%rsp),%rdx
je     2650 <svd_gr+0x14d0>
cmp    0x18(%rsp),%r12
jge    2650 <svd_gr+0x14d0>
mov    %r13,%rax
mov    %r13,%r9
imul   0x18(%rsp),%r9
add    %r13,%r9
mov    0x8(%rsp),%rdx
mov    0x70(%rsp),%rsi
mov    %r12,%rbx
jmp    25c5 <svd_gr+0x1445>
nop
add    $0x1,%rbx
add    $0x8,%rsi
add    $0x8,%rdx
cmp    %r10d,%ebx
je     2650 <svd_gr+0x14d0>
xorpd  %xmm0,%xmm0
cmp    %r11,%r12
jge    25fb <svd_gr+0x147b>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    %r12,%rcx
nopw   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    %r11,%rcx
jl     25e0 <svd_gr+0x1460>
cmp    %r11,%r12
jg     25b0 <svd_gr+0x1430>
divsd  (%rdi,%r9,8),%xmm0
divsd  %xmm5,%xmm0
mov    0x40(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,1),%xmm1
movsd  %xmm1,(%rdx,%rcx,1)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    2620 <svd_gr+0x14a0>
jmp    25b0 <svd_gr+0x1430>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r11,%r12
mov    0x10(%rsp),%rsi
mov    %r13,%rdx
jg     2480 <svd_gr+0x1300>
mov    0x40(%rsp),%rax
mov    %r14,%rcx
nopl   0x0(%rax)
movsd  (%rcx),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    2670 <svd_gr+0x14f0>
jmp    2480 <svd_gr+0x1300>
nopl   (%rax)
mov    0x40(%rsp),%rax
mov    %r14,%rcx
cmp    %r11,%r12
jg     2480 <svd_gr+0x1300>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rcx)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    26b0 <svd_gr+0x1530>
jmp    2480 <svd_gr+0x1300>
test   %r10d,%r10d
mov    0x18(%rsp),%rcx
jle    31a0 <svd_gr+0x2020>
mulsd  0x158(%rsp),%xmm4
movabs $0xffffffff00000000,%r9
ff ff ff
lea    -0x1(%rcx),%rsi
mov    0x138(%rsp),%rax
lea    -0x1(%rax),%rbp
lea    (%rdi,%rax,8),%rdx
mov    %rdx,0x120(%rsp)
lea    0x1(%rax),%rdx
mov    %rdx,0x200(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x158(%rsp)
mov    0x58(%rsp),%rax
and    $0xfffffffe,%eax
mov    %rax,0x1e0(%rsp)
mov    %rcx,%r13
shl    $0x20,%r13
lea    (%r9,%r13,1),%rax
mov    %rax,0x1d8(%rsp)
mov    0x118(%rsp),%rax
add    %r10d,%eax
add    $0xfffffffe,%eax
mov    %rax,0x1f8(%rsp)
movabs $0xfffffffe00000000,%rax
ff ff ff
add    %r13,%rax
mov    %rax,0x1d0(%rsp)
lea    (%r8,%rcx,8),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,0xb8(%rsp)
mov    0x28(%rsp),%rdx
lea    0x8(%rdx),%rax
mov    %rax,0x1f0(%rsp)
mov    %rcx,%r14
shl    $0x21,%r14
lea    0x8(%rdi),%rax
mov    %rax,0x1e8(%rsp)
xorpd  %xmm0,%xmm0
movhpd 0x1876(%rip),%xmm0
movapd %xmm0,0x210(%rsp)
movapd 0x1855(%rip),%xmm1
shr    $0x20,%rbp
mov    %rbp,0x188(%rsp)
mov    0x1a0(%rsp),%rax
add    %rdx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x1b8(%rsp)
lea    (%rdx,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x1b0(%rsp)
xor    %eax,%eax
mov    %rax,0x1c8(%rsp)
mov    %rsi,0x100(%rsp)
movapd %xmm4,0x140(%rsp)
mov    %r14,0x190(%rsp)
mov    %rsi,%r9
lea    -0x1(%rsi),%rax
mov    %rax,0x1c0(%rsp)
mov    $0x1,%eax
mov    %rsi,0xa8(%rsp)
jmp    2880 <svd_gr+0x1700>
nop
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd 0x17c0(%rip),%xmm7
movapd 0x140(%rsp),%xmm4
mov    0x208(%rsp),%rbp
movq   $0x0,(%rcx,%rbp,8)
movsd  %xmm0,(%rcx,%r9,8)
movsd  %xmm3,(%r8,%r9,8)
mov    0x19c(%rsp),%eax
add    $0x1,%eax
cmp    $0x33,%eax
movapd 0x1796(%rip),%xmm1
je     31d9 <svd_gr+0x2059>
mov    %eax,0x19c(%rsp)
mov    %r9d,%eax
mov    0x1d0(%rsp),%rcx
mov    0x1c8(%rsp),%rdx
mov    0x1d8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,%r11
mov    %rcx,%rbp
mov    %eax,%ebx
mov    0x100(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x50(%rsp)
add    %rdx,%rax
js     2918 <svd_gr+0x1798>
mov    %eax,%eax
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
andpd  %xmm7,%xmm0
ucomisd %xmm0,%xmm4
jae    292d <svd_gr+0x17ad>
mov    0xb8(%rsp),%rax
mov    0x50(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
movabs $0xffffffff00000000,%rax
lea    (%r11,%rax,1),%rsi
lea    -0x1(%rcx),%rdx
lea    (%rax,%rbp,1),%rcx
lea    -0x1(%rbx),%eax
ucomisd %xmm0,%xmm4
jb     28b0 <svd_gr+0x1730>
mov    %r11,%r12
sar    $0x20,%r12
cmp    %r9,%r12
mov    0x20(%rsp),%rcx
jle    2f60 <svd_gr+0x1de0>
movsd  (%r8,%r9,8),%xmm2
mov    0x100(%rsp),%rax
mov    0x50(%rsp),%rdx
add    %edx,%eax
cmp    %r9,%rax
je     30a4 <svd_gr+0x1f24>
mov    %r11,%rbp
sar    $0x20,%rbp
sar    $0x1d,%r11
movsd  (%r8,%r11,1),%xmm0
movaps %xmm0,0x70(%rsp)
mov    0x1c0(%rsp),%rax
movsd  (%r8,%rax,8),%xmm4
movsd  %xmm4,0x8(%rsp)
movsd  (%rcx,%rax,8),%xmm5
movsd  (%rcx,%r9,8),%xmm3
movapd %xmm2,%xmm1
addsd  %xmm5,%xmm1
divsd  %xmm3,%xmm1
subsd  %xmm2,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm4,%xmm0
movapd %xmm3,0x40(%rsp)
divsd  %xmm3,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm3,%xmm1
divsd  %xmm4,%xmm1
subsd  %xmm1,%xmm0
mulsd  0x166a(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x1654(%rip),%xmm1
movapd %xmm2,0xd0(%rsp)
call   1070 <hypot@plt>
movapd 0x70(%rsp),%xmm3
mov    0xa8(%rsp),%r9
movsd  0x10(%rsp),%xmm4
movapd %xmm4,%xmm1
cmpltsd 0x1635(%rip),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
xorpd  0x1605(%rip),%xmm0
andpd  %xmm1,%xmm0
orpd   %xmm2,%xmm0
addsd  %xmm4,%xmm0
movapd 0xd0(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd 0x40(%rsp),%xmm0
subsd  %xmm0,%xmm1
divsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cmp    %r9,%rbp
jge    2f30 <svd_gr+0x1db0>
lea    0x1(%rbp),%rax
mov    %rax,0x130(%rsp)
mov    0x200(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x108(%rsp)
unpcklpd %xmm0,%xmm3
mov    0xf8(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x128(%rsp)
add    0x1f8(%rsp),%rcx
mov    %rcx,0x50(%rsp)
movslq %ebx,%rsi
mov    %rsi,%r12
shl    $0x20,%r12
mov    0x1f0(%rsp),%rax
lea    (%rax,%rsi,8),%rbx
mov    0x1e8(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,0x88(%rsp)
add    $0x1,%rsi
xor    %r11d,%r11d
mov    %rbp,0x208(%rsp)
movsd  0x153a(%rip),%xmm1
movapd %xmm1,%xmm6
mov    0x60(%rsp),%r8
mov    0x38(%rsp),%rdi
mov    0x20(%rsp),%rcx
jmp    2b8e <svd_gr+0x1a0e>
xchg   %ax,%ax
movapd %xmm1,%xmm0
xorpd  0x1504(%rip),%xmm0
movapd 0xe0(%rsp),%xmm3
movapd %xmm3,%xmm2
movapd 0x170(%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,%r11
movabs $0x100000000,%rax
mov    0xd0(%rsp),%r12
add    %rax,%r12
mov    0xc0(%rsp),%rbx
add    $0x8,%rbx
addq   $0x8,0x88(%rsp)
add    $0x1,%rsi
mov    0xa8(%rsp),%r9
mov    0xb0(%rsp),%rbp
cmp    %r9,%rbp
mov    0x20(%rsp),%rcx
jge    2830 <svd_gr+0x16b0>
movapd %xmm3,0x70(%rsp)
mov    %rsi,0x8(%rsp)
mov    0x128(%rsp),%rsi
lea    (%rsi,%r11,1),%eax
cltq
lea    (%rdi,%rax,8),%rdx
mov    %rdx,0xa0(%rsp)
mov    0x120(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    0x130(%rsp),%rax
lea    (%rax,%r11,1),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0x110(%rsp)
mov    0x108(%rsp),%rax
lea    (%rax,%r11,1),%rax
lea    (%rdi,%rax,8),%rax
mov    %rax,0x98(%rsp)
mov    %r11,0x10(%rsp)
lea    (%rsi,%r11,1),%rax
mov    %rax,0x30(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0xb0(%rsp)
movsd  0x8(%rcx,%rbp,8),%xmm0
movsd  0x8(%r8,%rbp,8),%xmm2
movsd  %xmm2,0xd0(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
mulsd  %xmm0,%xmm6
movapd %xmm6,0xc0(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mov    %rcx,%r14
call   1070 <hypot@plt>
movapd 0x70(%rsp),%xmm6
movapd 0x40(%rsp),%xmm5
movsd  %xmm0,(%r14,%rbp,8)
shufpd $0x2,%xmm6,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
movapd 0xc0(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
movapd %xmm5,%xmm2
mulsd  %xmm6,%xmm2
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movapd %xmm1,0xe0(%rsp)
movsd  0xd0(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm2,0x170(%rsp)
mov    0x58(%rsp),%rax
mov    %rbx,0xc0(%rsp)
mov    %rbx,%rcx
mov    %r12,0xd0(%rsp)
mov    0x28(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %r12,%rsi
sar    $0x1d,%rsi
movsd  (%rbx,%rsi,1),%xmm7
movsd  (%rcx),%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm5,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm0,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rbx,%rsi,1)
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx)
add    %r13,%r12
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    2cf0 <svd_gr+0x1b70>
movapd %xmm6,%xmm0
movapd %xmm5,0x40(%rsp)
movapd %xmm6,0x70(%rsp)
movapd %xmm1,0x160(%rsp)
call   1070 <hypot@plt>
movapd 0x40(%rsp),%xmm1
mov    0x60(%rsp),%r8
movsd  %xmm0,(%r8,%rbp,8)
ucomisd 0x12c4(%rip),%xmm0
mov    0x18(%rsp),%r9
mov    0x190(%rsp),%r14
jne    2d7d <svd_gr+0x1bfd>
jnp    2d94 <svd_gr+0x1c14>
movapd 0x160(%rsp),%xmm1
unpcklpd 0x70(%rsp),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movapd %xmm1,%xmm6
unpckhpd %xmm1,%xmm6
cmpl   $0x0,0x118(%rsp)
mov    0x68(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    0x10(%rsp),%r11
jle    2b00 <svd_gr+0x1980>
cmpl   $0x1,0x118(%rsp)
01
jne    2e40 <svd_gr+0x1cc0>
xor    %edx,%edx
mov    %r9,%rax
imul   %rdx,%rax
add    %eax,%ebp
shl    $0x20,%rbp
add    %rsi,%rax
lea    (%rdi,%rax,8),%rax
mov    0x138(%rsp),%rcx
sub    %rdx,%rcx
nopl   0x0(%rax)
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    %r13,%rbp
add    %r15,%rax
add    $0xffffffffffffffff,%rcx
jne    2df0 <svd_gr+0x1c70>
jmp    2b00 <svd_gr+0x1980>
nopw   0x0(%rax,%rax,1)
cmp    $0x1,%r10d
jne    2dc8 <svd_gr+0x1c48>
mov    0x50(%rsp),%rax
add    %r11d,%eax
cmp    0x30(%rsp),%eax
jl     2dc8 <svd_gr+0x1c48>
mov    $0x0,%edx
cmpq   $0x0,0x188(%rsp)
jne    2dca <svd_gr+0x1c4a>
mov    0x98(%rsp),%rax
cmp    %rax,0xa0(%rsp)
jae    2e98 <svd_gr+0x1d18>
mov    0x110(%rsp),%rax
cmp    0x90(%rsp),%rax
jb     2dc8 <svd_gr+0x1c48>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
mov    0x158(%rsp),%rax
mov    0x88(%rsp),%rcx
mov    0xd0(%rsp),%rdx
mov    0x1a0(%rsp),%rbx
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    %r14,%rdx
add    %rbx,%rcx
add    $0xfffffffffffffffe,%rax
jne    2ec0 <svd_gr+0x1d40>
mov    0x158(%rsp),%rax
mov    %rax,%rdx
cmp    0x138(%rsp),%rax
mov    0x8(%rsp),%rsi
mov    0x10(%rsp),%r11
je     2b00 <svd_gr+0x1980>
jmp    2dca <svd_gr+0x1c4a>
nopl   (%rax)
mov    0x60(%rsp),%r8
mov    0x68(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x20(%rsp),%rcx
movapd 0x10b4(%rip),%xmm7
movapd 0x140(%rsp),%xmm4
jmp    2851 <svd_gr+0x16d1>
nopw   0x0(%rax,%rax,1)
sar    $0x20,%rbp
movslq %ebx,%r14
shl    $0x3,%r14
movapd 0x210(%rsp),%xmm5
mov    %r11,0x8(%rsp)
jmp    2fc5 <svd_gr+0x1e45>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%rax
add    $0x8,%r14
mov    0xa8(%rsp),%r9
cmp    %r9,%r12
mov    %rax,%r12
mov    0x68(%rsp),%r10
mov    0x20(%rsp),%rcx
movapd 0x1057(%rip),%xmm7
movapd 0x140(%rsp),%xmm4
movapd 0x1056(%rip),%xmm1
mov    0x8(%rsp),%r11
jge    292d <svd_gr+0x17ad>
movsd  (%rcx,%r12,8),%xmm2
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm5
movsd  %xmm5,(%rcx,%r12,8)
movapd %xmm0,%xmm2
andpd  %xmm7,%xmm2
ucomisd %xmm2,%xmm4
jae    292d <svd_gr+0x17ad>
movsd  (%r8,%r12,8),%xmm1
movaps %xmm1,0x70(%rsp)
movapd %xmm0,0x40(%rsp)
call   1070 <hypot@plt>
movapd 0x70(%rsp),%xmm5
mov    0x38(%rsp),%rdi
mov    0x60(%rsp),%r8
movsd  %xmm0,(%r8,%r12,8)
movapd 0x40(%rsp),%xmm1
xorpd  0xfe3(%rip),%xmm1
unpcklpd %xmm1,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
cmpl   $0x0,0x118(%rsp)
jle    2f80 <svd_gr+0x1e00>
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mov    0x138(%rsp),%rax
mov    %rdi,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm1
movsd  (%rcx,%r14,1),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
mulsd  %xmm5,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%r14,1)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    3060 <svd_gr+0x1ee0>
jmp    2f80 <svd_gr+0x1e00>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
mov    0x18(%rsp),%r11
mov    0x1b8(%rsp),%rdx
mov    0x1b0(%rsp),%rsi
jbe    3154 <svd_gr+0x1fd4>
xorpd  0xf41(%rip),%xmm2
movlpd %xmm2,(%r8,%r9,8)
cmp    $0x1,%r10d
mov    0x58(%rsp),%r9
mov    0x1e0(%rsp),%r12
jne    30ec <svd_gr+0x1f6c>
xor    %eax,%eax
jmp    3128 <svd_gr+0x1fa8>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x1a0(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,1),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rsi,%rcx,1)
movsd  (%rdx,%rcx,1),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rdx,%rcx,1)
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%r12
jne    3100 <svd_gr+0x1f80>
test   $0x1,%r9b
mov    0xa8(%rsp),%r9
je     3154 <svd_gr+0x1fd4>
imul   %r11,%rax
add    %r9,%rax
mov    0x28(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0xec1(%rip),%xmm0
movlpd %xmm0,(%rcx,%rax,8)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x1d8(%rsp)
addq   $0xffffffffffffffff,0x1c8(%rsp)
add    %rax,0x1d0(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x1b8(%rsp)
add    $0xfffffffffffffff8,%rsi
mov    %rsi,0x1b0(%rsp)
test   %r9,%r9
mov    0x1c0(%rsp),%rsi
jg     2811 <svd_gr+0x1691>
xor    %r14d,%r14d
mov    0x118(%rsp),%rsi
mov    %r10d,%edx
mov    0x28(%rsp),%rcx
xor    %eax,%eax
call   10a0 <svd_sort@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    %r14d,%eax
add    $0x228,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe58(%rip),%rdi
call   1040 <puts@plt>
mov    $0xf,%r14d
jmp    31c4 <svd_gr+0x2044>

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

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