int svd(float *A, int M, int N, float *U, float *V, float *q) {
  int i, j, k, l, t, t2, ierr, cancel, iter, l1;
  float eps, g, x, s, temp, f, h, c, y, z, scale;
  float *e;
  if (M < N) {
    printf("Rows (M) should be greater than Columns (B) \n");
    printf("Retry By Transposing the Input Matrix");
    return -1;
  }
  e = (float *)malloc(sizeof(float) * 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 += fabsf(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) ? sqrtf(s) : -sqrtf(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 += fabsf(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) ? sqrtf(s) : -sqrtf(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 = fabsf(q[i]) + fabsf(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] = hypotf(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.5f * (((g + z) / h) * ((g - z) / y) + y / h - h / y);
        g = hypotf(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 = hypotf(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 = hypotf(f, h);
          if (z != 0.0) {
            c = f / z;
            s = h / z;
          }
          f = c * g + s * y;
          x = c * y - s * g;
          for (j = 0; j < M; ++j) {
            t = j * N;
            y = U[t + i - 1];
            z = U[t + i];
            U[t + i - 1] = y * c + z * s;
            U[t + i] = z * c - y * s;
          }
        }
        e[l] = 0.0;
        e[k] = f;
        q[k] = x;
      } else {
        if (z < 0.0) {
          q[k] = -z;
          for (j = 0; j < N; j++) {
            t = j * N;
            V[t + k] = -V[t + k];
          }
        }
        break;
      }
    }
  }
  svd_sort(U, M, N, V, q);
  free(e);
  return ierr;
}


x86 assembly (clang, -O0):
<svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11c5 <svd+0x55>
lea    0x1e8c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1eac(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    271b <svd+0x15ab>
movslq -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    $0x0,%al
call   1080 <macheps@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    124c <svd+0xdc>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1212 <svd+0xa2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1986 <svd+0x816>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x60(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15ba <svd+0x44a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12fd <svd+0x18d>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0x1d35(%rip),%xmm1
pand   %xmm1,%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12b2 <svd+0x142>
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1321 <svd+0x1b1>
jp     1321 <svd+0x1b1>
jmp    15b5 <svd+0x445>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13a1 <svd+0x231>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x84(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1327 <svd+0x1b7>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x70(%rbp),%xmm0
jbe    13e0 <svd+0x270>
movss  -0x68(%rbp),%xmm0
call   1070 <sqrtf@plt>
movss  %xmm0,-0x94(%rbp)
ff
jmp    13ff <svd+0x28f>
movss  -0x68(%rbp),%xmm0
call   1070 <sqrtf@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x60(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x70(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1567 <svd+0x3f7>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1562 <svd+0x3f2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14e0 <svd+0x370>
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
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1486 <svd+0x316>
movss  -0x68(%rbp),%xmm0
divss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    154f <svd+0x3df>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14f5 <svd+0x385>
jmp    1554 <svd+0x3e4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    146c <svd+0x2fc>
jmp    1567 <svd+0x3f7>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15b0 <svd+0x440>
mov    -0x3c(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    156d <svd+0x3fd>
jmp    15b5 <svd+0x445>
jmp    15ba <svd+0x44a>
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    191a <svd+0x7aa>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     191a <svd+0x7aa>
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    1663 <svd+0x4f3>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0x19cf(%rip),%xmm1
pand   %xmm1,%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    161c <svd+0x4ac>
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1687 <svd+0x517>
jp     1687 <svd+0x517>
jmp    1915 <svd+0x7a5>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16fd <svd+0x58d>
movss  -0x84(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x68(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    168d <svd+0x51d>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x70(%rbp),%xmm0
jbe    1738 <svd+0x5c8>
movss  -0x68(%rbp),%xmm0
call   1070 <sqrtf@plt>
movss  %xmm0,-0x98(%rbp)
ff
jmp    1757 <svd+0x5e7>
movss  -0x68(%rbp),%xmm0
call   1070 <sqrtf@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x60(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x70(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17f0 <svd+0x680>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x74(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17af <svd+0x63f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18d1 <svd+0x761>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%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    186a <svd+0x6fa>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    181a <svd+0x6aa>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18be <svd+0x74e>
movss  -0x68(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1870 <svd+0x700>
jmp    18c3 <svd+0x753>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17f6 <svd+0x686>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1910 <svd+0x7a0>
movss  -0x84(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18d7 <svd+0x767>
jmp    1915 <svd+0x7a5>
jmp    191a <svd+0x7aa>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0x16e2(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movaps 0x16c7(%rip),%xmm2
pand   %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1973 <svd+0x803>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1978 <svd+0x808>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1253 <svd+0xe3>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1bc1 <svd+0xa51>
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    1b7e <svd+0xa0e>
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19d5 <svd+0x865>
jp     19d5 <svd+0x865>
jmp    1b2b <svd+0x9bb>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a41 <svd+0x8d1>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x74(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19fa <svd+0x88a>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b26 <svd+0x9b6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ab5 <svd+0x945>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a61 <svd+0x8f1>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b13 <svd+0x9a3>
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1abb <svd+0x94b>
jmp    1b18 <svd+0x9a8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a47 <svd+0x8d7>
jmp    1b2b <svd+0x9bb>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b79 <svd+0xa09>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b31 <svd+0x9c1>
jmp    1b7e <svd+0xa0e>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  0x148d(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    198f <svd+0x81f>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1e52 <svd+0xce2>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1c44 <svd+0xad4>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1c3f <svd+0xacf>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c10 <svd+0xaa0>
jmp    1c44 <svd+0xad4>
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c65 <svd+0xaf5>
jp     1c65 <svd+0xaf5>
jmp    1ddb <svd+0xc6b>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1d85 <svd+0xc15>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d80 <svd+0xc10>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1cee <svd+0xb7e>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c96 <svd+0xb26>
movss  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
divss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d6d <svd+0xbfd>
movss  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d15 <svd+0xba5>
jmp    1d72 <svd+0xc02>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c7c <svd+0xb0c>
jmp    1d85 <svd+0xc15>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dd6 <svd+0xc66>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d8b <svd+0xc1b>
jmp    1e19 <svd+0xca9>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e14 <svd+0xca4>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1de1 <svd+0xc71>
jmp    1e19 <svd+0xca9>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x11f1(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1bca <svd+0xa5a>
movss  -0x5c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     26f0 <svd+0x1580>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x32,-0x54(%rbp)
jle    1ea8 <svd+0xd38>
lea    0x11ef(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xf,-0x4(%rbp)
jmp    271b <svd+0x15ab>
movl   $0x1,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1f49 <svd+0xdd9>
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1126(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1efd <svd+0xd8d>
movl   $0x0,-0x50(%rbp)
jmp    1f49 <svd+0xdd9>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x10e6(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1f36 <svd+0xdc6>
jmp    1f49 <svd+0xdd9>
jmp    1f3b <svd+0xdcb>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1eb5 <svd+0xd45>
cmpl   $0x0,-0x50(%rbp)
je     211b <svd+0xfab>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  0x10bd(%rip),%xmm0
movss  %xmm0,-0x68(%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     2116 <svd+0xfa6>
movss  -0x68(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x78(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1039(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1fe3 <svd+0xe73>
jmp    2116 <svd+0xfa6>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
call   1040 <hypotf@plt>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm0
divss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x70(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2103 <svd+0xf93>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2048 <svd+0xed8>
jmp    2108 <svd+0xf98>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f77 <svd+0xe07>
jmp    211b <svd+0xfab>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     263d <svd+0x14cd>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm1
addss  -0x80(%rbp),%xmm1
divss  -0x74(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
subss  -0x80(%rbp),%xmm2
divss  -0x7c(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm0
divss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
divss  -0x7c(%rbp),%xmm0
subss  %xmm0,%xmm1
movss  0xe4d(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  0xe33(%rip),%xmm1
call   1040 <hypotf@plt>
movss  %xmm0,-0x60(%rbp)
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2221 <svd+0x10b1>
movss  -0x70(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    2230 <svd+0x10c0>
movss  -0x70(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
divss  -0x64(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
divss  -0x64(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
divss  -0x6c(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xd99(%rip),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  0xd8c(%rip),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     25fe <svd+0x148e>
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x68(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x74(%rbp),%xmm1
call   1040 <hypotf@plt>
movss  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x7c(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    246f <svd+0x12ff>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    23ae <svd+0x123e>
movss  -0x70(%rbp),%xmm0
movss  -0x74(%rbp),%xmm1
call   1040 <hypotf@plt>
movss  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    24b6 <svd+0x1346>
jp     24b6 <svd+0x1346>
jmp    24d4 <svd+0x1364>
movss  -0x70(%rbp),%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    25eb <svd+0x147b>
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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    252a <svd+0x13ba>
jmp    25f0 <svd+0x1480>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    22a2 <svd+0x1132>
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    26d8 <svd+0x1568>
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    26d3 <svd+0x1563>
movss  -0x80(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    26ce <svd+0x155e>
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
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2679 <svd+0x1509>
jmp    26d3 <svd+0x1563>
jmp    26dd <svd+0x156d>
jmp    1e7b <svd+0xd0b>
jmp    26e2 <svd+0x1572>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e6a <svd+0xcfa>
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    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x208,%rsp
mov    %rdx,0x8(%rsp)
cmp    %edx,%esi
jge    11cf <svd+0x3f>
lea    0x2ecb(%rip),%rdi
call   1040 <puts@plt>
lea    0x2e7f(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xffffffff,%r15d
jmp    3404 <svd+0x2274>
mov    %rcx,%r14
mov    %esi,%ebp
mov    %rdi,%r13
mov    %r8,0xb8(%rsp)
mov    %r9,0x80(%rsp)
mov    0x8(%rsp),%rbx
movslq %ebx,%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%rax,4),%r15
mov    %r15,%rdi
call   1080 <malloc@plt>
mov    %rax,0x18(%rsp)
xor    %eax,%eax
call   10a0 <macheps@plt>
mov    %ebx,%edx
mov    %rbp,0x100(%rsp)
imul   %ebp,%edx
test   %edx,%edx
mov    %r14,%rdi
jle    13a5 <svd+0x215>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     1251 <svd+0xc1>
lea    0x0(,%r9,4),%rdx
add    %r13,%rdx
cmp    %rdi,%rdx
jbe    12d1 <svd+0x141>
lea    (%rdi,%r9,4),%rdx
cmp    %r13,%rdx
jbe    12d1 <svd+0x141>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rcx
and    $0x3,%rcx
je     1286 <svd+0xf6>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1270 <svd+0xe0>
cmp    $0x3,%rsi
jb     13a5 <svd+0x215>
movss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rdx,4)
movss  0x8(%r13,%rdx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rdx,4)
movss  0xc(%r13,%rdx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1290 <svd+0x100>
jmp    13a5 <svd+0x215>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbp
jae    12f7 <svd+0x167>
xor    %ebp,%ebp
jmp    1361 <svd+0x1d1>
and    $0xfffffffffffffffc,%rsi
xor    %ebp,%ebp
nopl   (%rax)
movups 0x0(%r13,%rbp,4),%xmm0
movups 0x10(%r13,%rbp,4),%xmm1
movups %xmm0,(%rdi,%rbp,4)
movups %xmm1,0x10(%rdi,%rbp,4)
movups 0x20(%r13,%rbp,4),%xmm0
movups 0x30(%r13,%rbp,4),%xmm1
movups %xmm0,0x20(%rdi,%rbp,4)
movups %xmm1,0x30(%rdi,%rbp,4)
movups 0x40(%r13,%rbp,4),%xmm0
movups 0x50(%r13,%rbp,4),%xmm1
movups %xmm0,0x40(%rdi,%rbp,4)
movups %xmm1,0x50(%rdi,%rbp,4)
movups 0x60(%r13,%rbp,4),%xmm0
movups 0x70(%r13,%rbp,4),%xmm1
movups %xmm0,0x60(%rdi,%rbp,4)
movups %xmm1,0x70(%rdi,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1300 <svd+0x170>
test   %r8,%r8
je     139c <svd+0x20c>
lea    (%rdi,%rbp,4),%rcx
add    $0x10,%rcx
lea    0x10(,%rbp,4),%rbp
add    %r13,%rbp
shl    $0x5,%r8
xor    %ebx,%ebx
nop
movups -0x10(%rbp,%rbx,1),%xmm0
movups 0x0(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1380 <svd+0x1f0>
cmp    %r9,%rdx
jne    1253 <svd+0xc3>
cmpl   $0x0,0x8(%rsp)
mov    0x80(%rsp),%r8
mov    0x100(%rsp),%rsi
mov    0x28(%rsp),%r11
jle    33e3 <svd+0x2253>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10c(%rsp)
mov    0x8(%rsp),%rcx
lea    -0x1(%rcx),%eax
mov    %rax,0x110(%rsp)
movslq %esi,%r10
mov    %ecx,%ebx
mov    %esi,%r12d
lea    -0x2(%rbx),%rcx
mov    %rcx,0xf0(%rsp)
lea    0x4(,%r11,4),%rax
mov    %rax,0x128(%rsp)
lea    0x4(%rdi),%r8
mov    0x18(%rsp),%r14
lea    0x14(%r14),%rbp
lea    -0x5(%rbx),%rsi
lea    (%rdi,%r11,4),%rcx
mov    %rcx,0xb0(%rsp)
lea    (%rdi,%r11,4),%rcx
add    $0x34,%rcx
mov    %rcx,0xf8(%rsp)
mov    %r14,%rdx
add    $0x34,%rdx
lea    -0x9(%rbx),%rax
mov    %rax,0x150(%rsp)
xorps  %xmm10,%xmm10
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
xor    %r9d,%r9d
movaps 0x2b9f(%rip),%xmm7
movaps 0x2ba7(%rip),%xmm8
xorps  %xmm12,%xmm12
xorps  %xmm4,%xmm4
xorps  %xmm9,%xmm9
mov    %rdi,%r13
mov    %rbx,0x60(%rsp)
mov    %r12,0x148(%rsp)
mov    %r12,0x40(%rsp)
mov    %rsi,%rax
mov    %rdi,%r12
mov    %rdi,0x20(%rsp)
mov    %rbx,0x88(%rsp)
mov    %r10,0x48(%rsp)
jmp    1562 <svd+0x3d2>
cs nopw 0x0(%rax,%rax,1)
mov    0x80(%rsp),%rcx
mov    0x30(%rsp),%rdx
mov    %rbp,%r9
lea    (%rcx,%rdx,4),%rbp
mov    0x30(%rsp),%rdx
movl   $0x0,(%rcx,%rdx,4)
mov    %rbp,%rdx
mov    %r9,%rbp
mov    0x30(%rsp),%rcx
xorps  %xmm9,%xmm9
xorps  %xmm12,%xmm12
mov    0x60(%rsp),%r9
movss  (%rdx),%xmm0
movss  (%r14,%rcx,4),%xmm4
andps  %xmm7,%xmm0
andps  %xmm7,%xmm4
addss  %xmm0,%xmm4
maxss  %xmm11,%xmm4
addq   $0x1,0x10(%rsp)
mov    0x128(%rsp),%rcx
add    %rcx,%r12
addq   $0xffffffffffffffff,0x40(%rsp)
add    %rcx,%r8
add    $0xffffffffffffffff,%r9
mov    %r9,0x60(%rsp)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rax
add    %r15,%r13
add    %r15,0xb0(%rsp)
add    %rcx,0xf8(%rsp)
mov    0x90(%rsp),%rdx
add    $0x4,%rdx
addq   $0xffffffffffffffff,0x150(%rsp)
mov    0x50(%rsp),%r9
cmp    %rbx,%r9
je     1ee0 <svd+0xd50>
movaps %xmm4,%xmm11
mulss  %xmm9,%xmm12
lea    0x1(%r9),%rcx
mov    %rcx,0x50(%rsp)
movss  %xmm12,(%r14,%r9,4)
cmp    %r10,%r9
mov    %r9,0x30(%rsp)
mov    %rdx,0x90(%rsp)
jge    14b0 <svd+0x320>
mov    0x150(%rsp),%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xe8(%rsp)
mov    %rax,0x130(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x118(%rsp)
not    %r9
lea    (%r9,%rbx,1),%rcx
mov    %rcx,0xc0(%rsp)
lea    (%r9,%rbx,1),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0xe0(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,0x120(%rsp)
lea    (%r9,%rbx,1),%rsi
add    $0xfffffffffffffffc,%rsi
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0xd0(%rsp)
xorps  %xmm3,%xmm3
mov    0x40(%rsp),%rbx
mov    %rbx,%rax
mov    %r12,%rcx
mov    0x60(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx),%xmm0
andps  %xmm7,%xmm0
addss  %xmm0,%xmm3
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    1630 <svd+0x4a0>
xorps  %xmm9,%xmm9
ucomiss %xmm9,%xmm3
xorps  %xmm1,%xmm1
mov    0x80(%rsp),%r14
jne    165f <svd+0x4cf>
jnp    183f <svd+0x6af>
mov    %rbp,0x70(%rsp)
xorps  %xmm5,%xmm5
mov    %rbx,%rax
mov    %r12,%rcx
nopl   (%rax)
movss  (%rcx),%xmm0
divss  %xmm3,%xmm0
movss  %xmm0,(%rcx)
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm5
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    1670 <svd+0x4e0>
mov    %r8,0x78(%rsp)
mov    0x30(%rsp),%rcx
mov    %ecx,%eax
imul   0x8(%rsp),%eax
movslq %eax,%rbx
add    %rcx,%rbx
movss  (%rdi,%rbx,4),%xmm4
ucomiss %xmm10,%xmm5
jb     16bb <svd+0x52b>
xorps  %xmm0,%xmm0
sqrtss %xmm5,%xmm0
jmp    174b <svd+0x5bb>
movaps %xmm5,%xmm0
movss  %xmm11,0xd8(%rsp)
mov    %rsi,%rbp
movss  %xmm3,0xa8(%rsp)
movss  %xmm4,0xa0(%rsp)
movss  %xmm5,0x180(%rsp)
call   1090 <sqrtf@plt>
movss  0x180(%rsp),%xmm5
movss  0xa0(%rsp),%xmm4
movss  0xa8(%rsp),%xmm3
mov    %rbp,%rsi
mov    0x30(%rsp),%rcx
movss  0xd8(%rsp),%xmm11
mov    0x60(%rsp),%r9
xorps  %xmm10,%xmm10
xorps  %xmm9,%xmm9
mov    0x48(%rsp),%r10
movaps 0x28de(%rip),%xmm8
movaps 0x28c7(%rip),%xmm7
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%r14
movaps %xmm4,%xmm1
cmpltss %xmm10,%xmm1
movaps %xmm1,%xmm2
andps  %xmm0,%xmm2
xorps  %xmm8,%xmm0
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
movaps %xmm4,%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rbx,4)
cmp    0x110(%rsp),%rcx
mov    0x40(%rsp),%rbx
jae    180f <svd+0x67f>
cmp    %r11,0x50(%rsp)
jge    180f <svd+0x67f>
mulss  %xmm1,%xmm4
subss  %xmm5,%xmm4
mov    0x78(%rsp),%rax
mov    0x10(%rsp),%rcx
xorps  %xmm0,%xmm0
mov    %rbx,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rbp,1),%xmm2
mulss  (%rax,%rbp,1),%xmm2
addss  %xmm2,%xmm0
add    %r15,%rbp
add    $0xffffffffffffffff,%rdx
jne    17b0 <svd+0x620>
divss  %xmm4,%xmm0
mov    %rbx,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rbp,1),%xmm2
mulss  %xmm0,%xmm2
addss  (%rax,%rbp,1),%xmm2
movss  %xmm2,(%rax,%rbp,1)
add    %r15,%rbp
add    $0xffffffffffffffff,%rdx
jne    17e0 <svd+0x650>
add    $0x1,%rcx
add    $0x4,%rax
cmp    0x88(%rsp),%rcx
jne    17a0 <svd+0x610>
mov    %rbx,%rax
mov    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rcx)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    1820 <svd+0x690>
mov    0x78(%rsp),%r8
mov    0x70(%rsp),%rbp
mulss  %xmm1,%xmm3
mov    0x30(%rsp),%rcx
lea    (%r14,%rcx,4),%rdx
movss  %xmm3,(%r14,%rcx,4)
cmp    0x110(%rsp),%rcx
mov    0x130(%rsp),%rax
je     1930 <svd+0x7a0>
cmp    %r10,0x50(%rsp)
jge    1930 <svd+0x7a0>
mov    %rcx,%r14
imul   %r11,%r14
xorps  %xmm12,%xmm12
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%rax,4),%xmm0
andps  %xmm7,%xmm0
addss  %xmm0,%xmm12
add    $0x1,%rax
cmp    %rax,%rbx
jne    1890 <svd+0x700>
xorps  %xmm9,%xmm9
ucomiss %xmm9,%xmm12
jne    18b7 <svd+0x727>
jnp    1946 <svd+0x7b6>
mov    %rsi,0x70(%rsp)
xorps  %xmm3,%xmm3
mov    0x50(%rsp),%rsi
cmp    %r11,%rsi
jge    1902 <svd+0x772>
xorps  %xmm3,%xmm3
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rax,4),%xmm0
divss  %xmm12,%xmm0
movss  %xmm0,(%r12,%rax,4)
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%r9
jne    18e0 <svd+0x750>
lea    (%r14,%rsi,1),%rbx
movss  (%rdi,%rbx,4),%xmm2
ucomiss %xmm10,%xmm3
mov    %rdx,0xa8(%rsp)
mov    %r14,0xa0(%rsp)
mov    %rbp,%r14
jb     1960 <svd+0x7d0>
xorps  %xmm0,%xmm0
sqrtss %xmm3,%xmm0
jmp    19e2 <svd+0x852>
xorps  %xmm12,%xmm12
mov    0x18(%rsp),%r14
mov    0x88(%rsp),%rbx
jmp    14e8 <svd+0x358>
mov    0x18(%rsp),%r14
mov    0x88(%rsp),%rbx
mov    0x130(%rsp),%rax
jmp    14e8 <svd+0x358>
movaps %xmm3,%xmm0
mov    %r8,%rbp
movss  %xmm11,0xd8(%rsp)
movaps %xmm12,0x180(%rsp)
movaps %xmm2,0x190(%rsp)
movss  %xmm3,0x170(%rsp)
call   1090 <sqrtf@plt>
movss  0x170(%rsp),%xmm3
movaps 0x190(%rsp),%xmm2
movaps 0x180(%rsp),%xmm12
mov    0x30(%rsp),%rcx
movss  0xd8(%rsp),%xmm11
mov    0x50(%rsp),%rsi
xorps  %xmm10,%xmm10
mov    %rbp,%r8
mov    0x48(%rsp),%r10
movaps 0x263f(%rip),%xmm8
movaps 0x2628(%rip),%xmm7
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%r9
movaps %xmm2,%xmm9
cmpltss %xmm10,%xmm9
movaps %xmm9,%xmm1
andps  %xmm0,%xmm1
xorps  %xmm8,%xmm0
andnps %xmm0,%xmm9
orps   %xmm1,%xmm9
movaps %xmm2,%xmm0
subss  %xmm9,%xmm0
movss  %xmm0,(%rdi,%rbx,4)
cmp    %r11,%rsi
mov    0x18(%rsp),%rbp
mov    0x88(%rsp),%rbx
jge    1b1a <svd+0x98a>
mulss  %xmm9,%xmm2
subss  %xmm3,%xmm2
mov    %r9,%rax
cmpq   $0x4,0xc0(%rsp)
jb     1ae9 <svd+0x959>
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
cmpq   $0x4,0x70(%rsp)
jae    1a62 <svd+0x8d2>
xor    %ecx,%ecx
mov    0x18(%rsp),%rbp
mov    0xd0(%rsp),%rdx
jmp    1aa6 <svd+0x916>
xor    %ecx,%ecx
mov    0x18(%rsp),%rbp
mov    0x118(%rsp),%rax
mov    0xd0(%rsp),%rdx
nopl   0x0(%rax)
movups (%r8,%rcx,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,-0x10(%r14,%rcx,4)
movups 0x10(%r8,%rcx,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,(%r14,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1a80 <svd+0x8f0>
mov    0xc0(%rsp),%rbx
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%dl
je     1ad4 <svd+0x944>
add    %r9,%rcx
mov    0xa0(%rsp),%rdx
add    %rcx,%rdx
movups (%rdi,%rdx,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,0x0(%rbp,%rcx,4)
cmp    %rax,%rbx
mov    0x88(%rsp),%rbx
mov    0x30(%rsp),%rcx
je     1b1a <svd+0x98a>
add    %r9,%rax
mov    0x18(%rsp),%rbp
mov    0x88(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1b00 <svd+0x970>
mov    %r14,0x70(%rsp)
mov    %r8,0x78(%rsp)
cmp    %r10,%rsi
mov    %rbp,%r14
jge    1d62 <svd+0xbd2>
mov    0xa0(%rsp),%rax
lea    (%r9,%rax,1),%r10
lea    0x1(%r9),%r11
mov    0xc0(%rsp),%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0xd0(%rsp)
add    %r9,%rax
mov    %rax,0x118(%rsp)
mov    0xf8(%rsp),%rdi
mov    0xb0(%rsp),%rsi
mov    %r9,%rdx
jmp    1b98 <svd+0xa08>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
add    %r15,%rsi
add    %r15,%rdi
cmp    0x148(%rsp),%rdx
je     1d62 <svd+0xbd2>
mov    0x50(%rsp),%rax
cmp    0x28(%rsp),%rax
jge    1b80 <svd+0x9f0>
mov    %rdx,%rbp
imul   0x28(%rsp),%rbp
xorps  %xmm1,%xmm1
mov    %r9,%rax
testb  $0x1,0xc0(%rsp)
01
je     1be1 <svd+0xa51>
lea    (%r9,%rbp,1),%rax
mov    0x20(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
mulss  (%rcx,%r10,4),%xmm0
mov    0x30(%rsp),%rcx
addss  %xmm10,%xmm0
mov    %r11,%rax
movaps %xmm0,%xmm1
cmp    %rcx,0xf0(%rsp)
je     1c1d <svd+0xa8d>
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm2
movss  0x4(%rsi,%rax,4),%xmm0
mulss  0x0(%r13,%rax,4),%xmm2
mulss  0x4(%r13,%rax,4),%xmm0
addss  %xmm1,%xmm2
addss  %xmm2,%xmm0
add    $0x2,%rax
movaps %xmm0,%xmm1
cmp    %rax,%rbx
jne    1bf0 <svd+0xa60>
mov    0x50(%rsp),%rax
cmp    0x28(%rsp),%rax
jge    1b80 <svd+0x9f0>
mov    %r9,%rax
cmpq   $0x8,0xc0(%rsp)
jb     1d40 <svd+0xbb0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0xe0(%rsp)
jae    1c55 <svd+0xac5>
xor    %eax,%eax
jmp    1ccf <svd+0xb3f>
mov    0x90(%rsp),%r8
mov    0xe8(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x30(%r8,%rax,4),%xmm2
movups -0x20(%r8,%rax,4),%xmm3
mulps  %xmm1,%xmm2
movups -0x30(%rdi,%rax,4),%xmm4
addps  %xmm2,%xmm4
movups -0x20(%rdi,%rax,4),%xmm2
movups -0x10(%rdi,%rax,4),%xmm5
movups (%rdi,%rax,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,-0x30(%rdi,%rax,4)
movups %xmm3,-0x20(%rdi,%rax,4)
movups -0x10(%r8,%rax,4),%xmm2
movups (%r8,%rax,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,-0x10(%rdi,%rax,4)
movups %xmm3,(%rdi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c70 <svd+0xae0>
testb  $0x1,0x120(%rsp)
01
mov    0x10(%rsp),%r9
je     1d12 <svd+0xb82>
add    %r9,%rax
movups (%r14,%rax,4),%xmm2
movups 0x10(%r14,%rax,4),%xmm3
add    %rbp,%rax
mov    0x20(%rsp),%rcx
movups (%rcx,%rax,4),%xmm4
movups 0x10(%rcx,%rax,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rcx,%rax,4)
movups %xmm3,0x10(%rcx,%rax,4)
mov    0x118(%rsp),%rax
mov    0xd0(%rsp),%rcx
cmp    %rcx,0xc0(%rsp)
mov    0x30(%rsp),%rcx
je     1b80 <svd+0x9f0>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r14,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rsi,%rax,4),%xmm1
movss  %xmm1,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1d40 <svd+0xbb0>
jmp    1b80 <svd+0x9f0>
mov    0x28(%rsp),%r11
cmp    %r11,0x50(%rsp)
jge    1dad <svd+0xc1d>
mov    %r9,%rcx
mov    0xc0(%rsp),%rdx
cmp    $0x8,%rdx
mov    0x20(%rsp),%rdi
mov    0x78(%rsp),%r8
jb     1e98 <svd+0xd08>
movaps %xmm12,%xmm0
shufps $0x0,%xmm12,%xmm0
cmpq   $0x8,0xe0(%rsp)
jae    1ddb <svd+0xc4b>
xor    %eax,%eax
mov    0x60(%rsp),%r9
jmp    1e34 <svd+0xca4>
mov    0x20(%rsp),%rdi
mov    0x48(%rsp),%r10
mov    0x78(%rsp),%r8
mov    0x70(%rsp),%rbp
mov    0x130(%rsp),%rax
mov    0x60(%rsp),%r9
mov    0xa8(%rsp),%rdx
jmp    14e8 <svd+0x358>
xor    %eax,%eax
mov    0x60(%rsp),%r9
mov    0xe8(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movups (%r8,%rax,4),%xmm1
movups 0x10(%r8,%rax,4),%xmm2
movups 0x20(%r8,%rax,4),%xmm3
movups 0x30(%r8,%rax,4),%xmm4
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%r8,%rax,4)
movups %xmm2,0x10(%r8,%rax,4)
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,0x20(%r8,%rax,4)
movups %xmm4,0x30(%r8,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1df0 <svd+0xc60>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
testb  $0x1,0x120(%rsp)
01
je     1e6a <svd+0xcda>
add    0x10(%rsp),%rax
add    0xa0(%rsp),%rax
movups (%rdi,%rax,4),%xmm1
movups 0x10(%rdi,%rax,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rdi,%rax,4)
movups %xmm2,0x10(%rdi,%rax,4)
cmp    %rcx,%rdx
jne    1e93 <svd+0xd03>
mov    0x48(%rsp),%r10
mov    0x130(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    0xa8(%rsp),%rdx
mov    0x70(%rsp),%rbp
jmp    14e8 <svd+0x358>
add    0x10(%rsp),%rcx
mov    0x130(%rsp),%rax
mov    0x60(%rsp),%r9
mov    0xa8(%rsp),%rdx
nopl   (%rax)
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm12,%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1eb0 <svd+0xd20>
mov    0x48(%rsp),%r10
mov    0x30(%rsp),%rcx
mov    0x70(%rsp),%rbp
jmp    14e8 <svd+0x358>
cmpl   $0x0,0x8(%rsp)
mov    0x80(%rsp),%r8
mov    0x100(%rsp),%rsi
jle    33e3 <svd+0x2253>
mov    %r11,%rax
imul   %r11,%rax
mov    %rax,0xf0(%rsp)
lea    -0x1(%r11),%rcx
mov    %rcx,%rsi
imul   %r11,%rsi
mov    %r11,%rax
neg    %rax
mov    %rax,0x30(%rsp)
mov    %r11,%rax
shl    $0x4,%rax
mov    %rax,0x118(%rsp)
lea    (%r11,%r11,1),%r9
lea    (%rdi,%rsi,4),%rdx
add    $0x4,%rdx
mov    %r15,%rax
neg    %rax
mov    %rax,0xa0(%rsp)
lea    0x0(,%r11,8),%rbp
mov    0xb8(%rsp),%r14
lea    -0x4(%r14),%rax
mov    %rax,0xb0(%rsp)
lea    (%r14,%rsi,4),%rbx
add    $0x4,%rbx
movq   $0xfffffffffffffffc,0xe0(%rsp)
xor    %eax,%eax
mov    %rax,0xd8(%rsp)
xorps  %xmm0,%xmm0
mov    %r14,0xd0(%rsp)
mov    %rcx,0xe8(%rsp)
mov    %rcx,0x130(%rsp)
mov    %rsi,0x168(%rsp)
mov    %rsi,0xa8(%rsp)
xor    %ecx,%ecx
mov    %r11,%rdi
mov    %rbp,0x190(%rsp)
jmp    204a <svd+0xeba>
movslq 0xf8(%rsp),%rax
mov    0xc0(%rsp),%rdi
add    %rdi,%rax
mov    %r8,%r14
movl   $0x3f800000,(%r8,%rax,4)
3f
mov    0x18(%rsp),%rax
movss  (%rax,%rdi,4),%xmm9
mov    0x128(%rsp),%rcx
add    $0x1,%rcx
sub    %r13,0xa8(%rsp)
addq   $0xffffffffffffffff,0x130(%rsp)
addq   $0xfffffffffffffffc,0xd8(%rsp)
addq   $0xfffffffffffffffc,0xd0(%rsp)
mov    0xa0(%rsp),%rax
add    %rax,%rdx
addq   $0xfffffffffffffffc,0xb0(%rsp)
addq   $0xfffffffffffffffc,0xe0(%rsp)
add    %rax,%rbx
cmpq   $0x1,0x90(%rsp)
mov    %r13,%r11
jle    264e <svd+0x14be>
movslq %edi,%r12
mov    %r11,%r13
imul   %r12,%r11
mov    %rcx,%rax
not    %rax
add    0xf0(%rsp),%rax
lea    (%r14,%rax,4),%rax
mov    0xe8(%rsp),%rsi
mov    %rcx,0x128(%rsp)
sub    %rcx,%rsi
add    %r11,%rsi
mov    %r14,%r8
lea    (%r14,%rsi,4),%rcx
cmp    %rcx,%rax
mov    %rcx,%rsi
cmovb  %rax,%rsi
cmova  %rax,%rcx
mov    %rcx,0x60(%rsp)
lea    -0x1(%rdi),%r14
mov    %r14,%rax
mov    %r14,0xc0(%rsp)
mov    0x8(%rsp),%rcx
imul   %ecx,%eax
mov    %rax,0xf8(%rsp)
mov    %rdi,0x90(%rsp)
cmp    0x110(%rsp),%rdi
jg     1fc0 <svd+0xe30>
mov    %rbx,0x180(%rsp)
mov    %r13,%rax
sub    %r12,%rax
mov    %rax,0x50(%rsp)
mov    %r12,%rax
mov    %r12,0x78(%rsp)
not    %r12
mov    %r12,0x40(%rsp)
mov    0xc0(%rsp),%rax
mov    %r13,%r14
imul   %r13,%rax
mov    %rax,0x140(%rsp)
ucomiss %xmm0,%xmm9
jne    2111 <svd+0xf81>
jnp    2580 <svd+0x13f0>
mov    0x90(%rsp),%rax
cmp    0x8(%rsp),%eax
jge    2580 <svd+0x13f0>
mov    0xc0(%rsp),%rax
mov    0xf8(%rsp),%rdi
add    %edi,%eax
cltq
mov    0x20(%rsp),%rbp
mulss  0x4(%rbp,%rax,4),%xmm9
movslq 0x90(%rsp),%r12
cmpq   $0x4,0x50(%rsp)
jb     21ae <svd+0x101e>
mov    0x128(%rsp),%rax
imul   %r14,%rax
mov    0xf0(%rsp),%rdi
sub    %rax,%rdi
lea    0x0(,%rdi,4),%rdi
add    %rbp,%rdi
cmp    %rdi,%rsi
mov    0x78(%rsp),%rdi
jae    2260 <svd+0x10d0>
mov    0x60(%rsp),%rcx
add    $0x4,%rcx
mov    0x168(%rsp),%rsi
sub    %rax,%rsi
add    %rdi,%rsi
lea    0x0(,%rsi,4),%rax
add    %rbp,%rax
cmp    %rcx,%rax
jae    2260 <svd+0x10d0>
mov    0x8(%rsp),%r8
mov    %r8d,%eax
sub    %r12d,%eax
mov    %r12,%rcx
test   $0x1,%al
je     21fb <svd+0x106b>
mov    0x140(%rsp),%rax
add    %r12,%rax
mov    0x20(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm1
divss  %xmm9,%xmm1
mov    %r12,%rax
imul   %r14,%rax
add    0xc0(%rsp),%rax
mov    0xb8(%rsp),%rcx
movss  %xmm1,(%rcx,%rax,4)
lea    0x1(%r12),%rcx
not    %r12
cmp    0x30(%rsp),%r12
je     2344 <svd+0x11b4>
mov    %r14,%rax
imul   %rcx,%rax
mov    0xd0(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
lea    0x1(%rcx),%rsi
imul   %r14,%rsi
lea    (%rdi,%rsi,4),%rsi
mov    0xe8(%rsp),%rdi
movss  -0x4(%rdx,%rcx,4),%xmm1
divss  %xmm9,%xmm1
movss  %xmm1,(%rax,%rdi,4)
movss  (%rdx,%rcx,4),%xmm1
divss  %xmm9,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
add    $0x2,%rcx
add    %r9,%rdi
cmp    %rcx,%r14
jne    2230 <svd+0x10a0>
jmp    2344 <svd+0x11b4>
mov    0xa8(%rsp),%rax
add    %rdi,%rax
lea    0x0(,%rax,4),%r10
add    %rbp,%r10
mov    %r11,%rbp
add    0x130(%rsp),%rbp
lea    0x10(,%rdi,4),%rcx
imul   %r14,%rcx
mov    0xd8(%rsp),%rbx
add    %rbx,%rcx
lea    0xc(,%rdi,4),%r13
imul   %r14,%r13
add    %rbx,%r13
lea    0x8(,%rdi,4),%r11
imul   %r14,%r11
add    %rbx,%r11
mov    0x50(%rsp),%rbx
and    $0xfffffffffffffffc,%rbx
add    %rbx,%r12
movaps %xmm9,%xmm1
shufps $0x0,%xmm9,%xmm1
mov    0xb8(%rsp),%rax
xor    %esi,%esi
mov    0x8(%rsp),%r8
mov    0x118(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r10,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movss  %xmm2,(%rax,%rbp,4)
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movss  %xmm3,-0x4(%rax,%r11,1)
movaps %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movss  %xmm3,-0x4(%rax,%r13,1)
shufps $0xff,%xmm2,%xmm2
movss  %xmm2,-0x4(%rax,%rcx,1)
add    $0x4,%rsi
add    %rdi,%rax
cmp    %rsi,%rbx
jne    22f0 <svd+0x1160>
cmp    %rbx,0x50(%rsp)
mov    0x28(%rsp),%r14
mov    0x48(%rsp),%r10
jne    21b3 <svd+0x1023>
cmp    %r8d,0x90(%rsp)
mov    0xb8(%rsp),%r8
mov    0x190(%rsp),%rbp
jge    2580 <svd+0x13f0>
mov    0x78(%rsp),%rax
mov    %r8,%r13
lea    (%r8,%rax,4),%r12
movslq 0x90(%rsp),%rcx
mov    0x140(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x70(%rsp)
mov    %rcx,%rsi
imul   %r14,%rsi
lea    0x1(%rcx),%rax
mov    %rax,0x10(%rsp)
mov    0xc0(%rsp),%rax
mov    %rsi,0x150(%rsp)
add    %rsi,%rax
mov    %rax,0x120(%rsp)
mov    %rcx,0x60(%rsp)
jmp    23ea <svd+0x125a>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x4,%r13
add    $0x4,%r12
mov    0x28(%rsp),%rax
mov    %rax,%r14
cmp    %rax,%rcx
mov    0xb8(%rsp),%r8
mov    0x48(%rsp),%r10
je     2580 <svd+0x13f0>
xorps  %xmm2,%xmm2
mov    0x60(%rsp),%rbx
testb  $0x1,0x50(%rsp)
je     2425 <svd+0x1295>
mov    0x20(%rsp),%rax
mov    0x70(%rsp),%rsi
movss  (%rax,%rsi,4),%xmm1
mov    0x150(%rsp),%rax
add    %rcx,%rax
mulss  (%r8,%rax,4),%xmm1
addss  %xmm0,%xmm1
mov    0x10(%rsp),%rbx
movaps %xmm1,%xmm2
mov    0x40(%rsp),%rsi
cmp    0x30(%rsp),%rsi
je     248d <svd+0x12fd>
mov    %r14,%rax
imul   %rbx,%rax
lea    0x0(,%rax,4),%rax
add    %r13,%rax
lea    0x1(%rbx),%rdi
imul   %r14,%rdi
lea    0x0(,%rdi,4),%rbp
add    %r13,%rbp
mov    0x78(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rdx,%rbx,4),%xmm3
mulss  (%rax,%rdi,4),%xmm3
movss  (%rdx,%rbx,4),%xmm1
addss  %xmm2,%xmm3
mulss  0x0(%rbp,%rdi,4),%xmm1
addss  %xmm3,%xmm1
add    $0x2,%rbx
add    %r9,%rdi
movaps %xmm1,%xmm2
cmp    %rbx,%r14
jne    2460 <svd+0x12d0>
mov    0x60(%rsp),%rdi
testb  $0x1,0x50(%rsp)
je     24c7 <svd+0x1337>
mov    0x150(%rsp),%rax
add    %rcx,%rax
mov    0x120(%rsp),%rdi
movss  (%r8,%rdi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%r8,%rax,4),%xmm2
movss  %xmm2,(%r8,%rax,4)
mov    0x10(%rsp),%rdi
cmp    0x30(%rsp),%rsi
mov    0x190(%rsp),%rbp
je     23c0 <svd+0x1230>
mov    0x28(%rsp),%r14
mov    %r14,%rbx
sub    %rdi,%rbx
mov    %r14,%rax
imul   %rdi,%rax
lea    (%rcx,%rax,1),%rbp
mov    0xb8(%rsp),%rsi
lea    (%rsi,%rbp,4),%r8
mov    0x190(%rsp),%rbp
add    0x130(%rsp),%rax
lea    (%rsi,%rax,4),%r10
lea    0x1(%rdi),%rax
imul   %r14,%rax
lea    (%r12,%rax,4),%rax
lea    0x8(,%rdi,4),%r11
imul   %r14,%r11
add    0xb0(%rsp),%r11
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r10,%rdi,1),%xmm2
mulss  %xmm1,%xmm2
addss  (%r8,%rdi,1),%xmm2
movss  %xmm2,(%r8,%rdi,1)
movss  (%r11,%rdi,1),%xmm2
mulss  %xmm1,%xmm2
addss  (%rax,%rdi,1),%xmm2
movss  %xmm2,(%rax,%rdi,1)
add    %rbp,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2540 <svd+0x13b0>
jmp    23c0 <svd+0x1230>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
cmp    %eax,0x90(%rsp)
mov    0x180(%rsp),%rbx
mov    %r14,%r13
jge    1fc0 <svd+0xe30>
movslq 0x90(%rsp),%rcx
testb  $0x1,0x50(%rsp)
je     25dd <svd+0x144d>
mov    %rcx,%rax
imul   %r14,%rax
add    0xc0(%rsp),%rax
mov    %r8,%rsi
movl   $0x0,(%r8,%rax,4)
mov    0x140(%rsp),%rax
add    %rcx,%rax
movl   $0x0,(%r8,%rax,4)
add    $0x1,%rcx
mov    0x40(%rsp),%rax
cmp    0x30(%rsp),%rax
mov    %r14,%r13
je     1fc0 <svd+0xe30>
lea    0x8(,%rcx,4),%rax
imul   %r13,%rax
mov    %r8,%rdi
add    %r8,%rax
lea    0x4(,%rcx,4),%rsi
imul   %r13,%rsi
add    %r8,%rsi
mov    0xe0(%rsp),%rdi
nopl   0x0(%rax)
movl   $0x0,(%rsi,%rdi,1)
movl   $0x0,-0x4(%rbx,%rcx,4)
movl   $0x0,(%rax,%rdi,1)
movl   $0x0,(%rbx,%rcx,4)
add    $0x2,%rcx
add    %rbp,%rdi
cmp    %rcx,%r13
jne    2620 <svd+0x1490>
jmp    1fc0 <svd+0xe30>
cmpl   $0x0,0x8(%rsp)
mov    0x80(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x100(%rsp),%rsi
jle    33e3 <svd+0x2253>
mov    0x8(%rsp),%rcx
mov    %ecx,%eax
imul   %ecx,%eax
mov    %eax,0x150(%rsp)
mov    %ecx,%eax
not    %eax
mov    %eax,0x10(%rsp)
mov    0xf0(%rsp),%rcx
lea    (%rdi,%rcx,4),%r14
add    $0xfffffffffffffffc,%r14
mov    %r15,%rax
xor    $0xfffffffffffffffc,%rax
mov    %rax,0xc0(%rsp)
lea    0x1(%r10),%rax
mov    %rax,0x50(%rsp)
lea    0x1(%r11),%rax
imul   %r11,%rax
lea    (%rdi,%rax,4),%rbx
lea    (%rdi,%rax,4),%r13
add    $0xfffffffffffffffc,%r13
lea    (%rdi,%rcx,4),%rbp
xor    %esi,%esi
xorps  %xmm3,%xmm3
movss  0x195c(%rip),%xmm2
mov    %r11,%r12
movaps %xmm4,0x170(%rsp)
jmp    272f <svd+0x159f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r9d,%rax
mov    0x30(%rsp),%r12
add    %r12,%rax
movss  (%rdi,%rax,4),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rsi
mov    0xc0(%rsp),%rax
add    %rax,%r14
add    %rax,%rbx
add    %rax,%r13
add    %rax,%rbp
cmp    0x88(%rsp),%rsi
je     2967 <svd+0x17d7>
lea    -0x1(%r12),%rax
movss  -0x4(%r8,%r12,4),%xmm5
cmp    0x110(%rsp),%r12
mov    %rax,0x30(%rsp)
mov    %rsi,0x60(%rsp)
jg     27e1 <svd+0x1651>
cmp    %r11,%r12
jge    27e1 <svd+0x1651>
movabs $0x3fffffffc,%rax
lea    (%rax,%rsi,4),%rdx
and    %rax,%rdx
add    $0x4,%rdx
mov    0x10(%rsp),%eax
imul   %esi,%eax
add    0x150(%rsp),%eax
cltq
lea    (%rdi,%rax,4),%rdi
xor    %esi,%esi
movss  %xmm5,0x90(%rsp)
call   1070 <memset@plt>
movss  0x90(%rsp),%xmm5
mov    0x30(%rsp),%rax
xorps  %xmm3,%xmm3
mov    0x60(%rsp),%rsi
movss  0x187d(%rip),%xmm2
movaps 0x170(%rsp),%xmm4
mov    0x48(%rsp),%r10
movaps 0x1848(%rip),%xmm8
movaps 0x1831(%rip),%xmm7
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%r8
mov    %eax,%r9d
imul   0x8(%rsp),%r9d
ucomiss %xmm3,%xmm5
jne    27f5 <svd+0x1665>
jnp    2930 <svd+0x17a0>
mov    %rbp,0x40(%rsp)
mov    %rbx,0x90(%rsp)
cmp    0x110(%rsp),%rax
je     28e0 <svd+0x1750>
cmp    %r11,%r12
jge    28e0 <svd+0x1750>
mov    0x30(%rsp),%rax
mov    %rax,%rcx
imul   %r11,%rcx
add    %rax,%rcx
mov    0x40(%rsp),%rdx
mov    0x90(%rsp),%rsi
mov    %r12,%rax
jmp    2856 <svd+0x16c6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x4,%rsi
add    $0x4,%rdx
cmp    0x8(%rsp),%eax
je     28e0 <svd+0x1750>
xorps  %xmm0,%xmm0
cmp    %r10,%r12
jge    288c <svd+0x16fc>
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
mov    %r12,%rbx
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rbp,1),%xmm1
mulss  (%rsi,%rbp,1),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rbx
add    %r15,%rbp
cmp    %r10,%rbx
jl     2870 <svd+0x16e0>
cmp    %r10,%r12
jg     2840 <svd+0x16b0>
divss  (%rdi,%rcx,4),%xmm0
divss  %xmm5,%xmm0
mov    0x50(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rbx,1),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdx,%rbx,1),%xmm1
movss  %xmm1,(%rdx,%rbx,1)
add    %r15,%rbx
add    $0xffffffffffffffff,%rbp
cmp    %rbp,%r12
jne    28b0 <svd+0x1720>
jmp    2840 <svd+0x16b0>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r10,%r12
mov    0x90(%rsp),%rbx
mov    0x40(%rsp),%rbp
mov    0x60(%rsp),%rsi
jg     26f0 <svd+0x1560>
mov    0x50(%rsp),%rcx
mov    %r14,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx),%xmm0
divss  %xmm5,%xmm0
movss  %xmm0,(%rdx)
add    %r15,%rdx
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%r12
jne    2910 <svd+0x1780>
jmp    26f0 <svd+0x1560>
nopl   (%rax)
mov    0x50(%rsp),%rcx
mov    %r14,%rdx
cmp    %r10,%r12
jg     26f0 <svd+0x1560>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rdx)
add    %r15,%rdx
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%r12
jne    2950 <svd+0x17c0>
jmp    26f0 <svd+0x1560>
cmpl   $0x0,0x8(%rsp)
mov    0x100(%rsp),%rsi
jle    33e3 <svd+0x2253>
mulss  0x10c(%rsp),%xmm4
movabs $0xffffffff00000000,%rcx
ff ff ff
lea    -0x1(%r11),%rdx
mov    0x148(%rsp),%rax
lea    -0x1(%rax),%rbx
lea    (%rdi,%rax,4),%rbp
mov    %rbp,0xd8(%rsp)
lea    0x1(%rax),%rbp
mov    %rbp,0x1f8(%rsp)
and    $0xfffffffc,%eax
mov    %rax,0x168(%rsp)
mov    0x88(%rsp),%rax
and    $0xfffffffe,%eax
mov    %rax,0x1d8(%rsp)
mov    %r11,%rbp
shl    $0x20,%rbp
lea    (%rcx,%rbp,1),%rax
mov    %rax,0x1d0(%rsp)
mov    0x8(%rsp),%rax
add    %esi,%eax
add    $0xfffffffe,%eax
mov    %rax,0x1f0(%rsp)
movabs $0xfffffffe00000000,%rax
ff ff ff
add    %rbp,%rax
mov    %rax,0x1c8(%rsp)
lea    (%r8,%r11,4),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x180(%rsp)
mov    0xb8(%rsp),%rax
lea    0x4(%rax),%rcx
mov    %rcx,0x1e8(%rsp)
mov    %r11,%rcx
shl    $0x22,%rcx
mov    %rcx,0xa8(%rsp)
lea    0x4(%rdi),%rcx
mov    %rcx,0x1e0(%rsp)
shr    $0x20,%rbx
mov    %rbx,0x140(%rsp)
lea    (%rax,%r11,8),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x1b0(%rsp)
lea    (%rax,%r11,4),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x1a8(%rsp)
xor    %eax,%eax
mov    %rax,0x1c0(%rsp)
mov    %rdx,0xa0(%rsp)
movaps %xmm4,0x170(%rsp)
mov    %rdx,%r10
lea    -0x1(%rdx),%rax
mov    %rax,0x1b8(%rsp)
mov    $0x1,%eax
mov    0x18(%rsp),%r14
mov    %rdx,0xb0(%rsp)
jmp    2b0f <svd+0x197f>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
mov    0x18(%rsp),%r14
movaps 0x152d(%rip),%xmm7
movaps 0x170(%rsp),%xmm4
mov    0x200(%rsp),%rbx
mov    0x28(%rsp),%r11
movl   $0x0,(%r14,%rbx,4)
movss  %xmm0,(%r14,%r10,4)
movss  %xmm3,(%r8,%r10,4)
mov    0x10c(%rsp),%eax
add    $0x1,%eax
cmp    $0x33,%eax
je     3419 <svd+0x2289>
mov    %eax,0x10c(%rsp)
mov    %r10d,%r9d
mov    0x1c8(%rsp),%rcx
mov    0x1c0(%rsp),%rdx
mov    0x1d0(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%r12
mov    %rcx,%rbx
mov    %r9d,%eax
mov    %rax,0x50(%rsp)
mov    0xa0(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,0x10(%rsp)
add    %rdx,%rax
js     2bb0 <svd+0x1a20>
mov    %eax,%eax
movss  (%r14,%rax,4),%xmm0
andps  %xmm7,%xmm0
ucomiss %xmm0,%xmm4
jae    2bc0 <svd+0x1a30>
mov    0x180(%rsp),%rax
mov    0x10(%rsp),%rdx
movss  (%rax,%rdx,4),%xmm0
andps  %xmm7,%xmm0
movabs $0xffffffff00000000,%rcx
ff ff ff
lea    (%r12,%rcx,1),%rax
add    $0xffffffffffffffff,%rdx
add    %rbx,%rcx
mov    0x50(%rsp),%rsi
lea    -0x1(%rsi),%r9d
ucomiss %xmm0,%xmm4
mov    0x18(%rsp),%r14
jb     2b40 <svd+0x19b0>
mov    %r12,%r13
sar    $0x20,%r13
cmp    %r10,%r13
jle    31c0 <svd+0x2030>
movss  (%r8,%r10,4),%xmm1
mov    0xa0(%rsp),%rax
mov    0x10(%rsp),%rcx
add    %ecx,%eax
cmp    %r10,%rax
je     32f2 <svd+0x2162>
mov    %r12,%rbx
sar    $0x20,%rbx
sar    $0x1e,%r12
movss  (%r8,%r12,1),%xmm0
movaps %xmm0,0x30(%rsp)
mov    0x1b8(%rsp),%rax
movss  (%r8,%rax,4),%xmm3
movss  %xmm3,0x48(%rsp)
mov    0x18(%rsp),%r14
movss  (%r14,%rax,4),%xmm5
movss  (%r14,%r10,4),%xmm2
movaps %xmm1,%xmm4
movaps %xmm1,0x90(%rsp)
addss  %xmm5,%xmm1
divss  %xmm2,%xmm1
subss  %xmm4,%xmm5
divss  %xmm3,%xmm5
mulss  %xmm1,%xmm5
movaps %xmm3,%xmm0
movaps %xmm2,0x60(%rsp)
divss  %xmm2,%xmm0
addss  %xmm5,%xmm0
movaps %xmm2,%xmm1
divss  %xmm3,%xmm1
subss  %xmm1,%xmm0
mulss  0x13d9(%rip),%xmm0
movss  %xmm0,0x40(%rsp)
movss  0x13c7(%rip),%xmm1
call   1050 <hypotf@plt>
movaps 0x30(%rsp),%xmm3
mov    0xb0(%rsp),%r10
movaps 0x138d(%rip),%xmm8
movss  0x40(%rsp),%xmm4
movaps %xmm4,%xmm1
cmpltss 0x13a3(%rip),%xmm1
movaps %xmm1,%xmm2
andnps %xmm0,%xmm2
xorps  %xmm8,%xmm0
andps  %xmm1,%xmm0
orps   %xmm2,%xmm0
addss  %xmm4,%xmm0
movaps 0x90(%rsp),%xmm2
movaps %xmm2,%xmm1
divss  %xmm3,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm3,%xmm2
subss  %xmm1,%xmm2
movss  0x48(%rsp),%xmm1
divss  %xmm0,%xmm1
movaps 0x60(%rsp),%xmm0
subss  %xmm0,%xmm1
divss  %xmm3,%xmm0
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
cmp    %r10,%rbx
jge    3190 <svd+0x2000>
lea    0x1(%rbx),%rax
mov    %rax,0xf0(%rsp)
mov    0x1f8(%rsp),%rax
add    %rbx,%rax
mov    %rax,0xe8(%rsp)
unpcklps %xmm0,%xmm3
mov    0x110(%rsp),%rax
mov    0x10(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xd0(%rsp)
add    0x1f0(%rsp),%rcx
mov    %rcx,0x10(%rsp)
movslq 0x50(%rsp),%rcx
mov    %rbx,%r14
mov    %rcx,%r12
shl    $0x20,%r12
mov    0x1e8(%rsp),%rax
lea    (%rax,%rcx,4),%r13
mov    0x1e0(%rsp),%rax
lea    (%rax,%rcx,4),%rax
mov    %rax,0xe0(%rsp)
add    $0x1,%rcx
mov    %rcx,0x90(%rsp)
xor    %ebx,%ebx
mov    %r14,0x200(%rsp)
movss  0x12b1(%rip),%xmm1
movaps %xmm1,%xmm6
mov    0x80(%rsp),%r8
mov    0x20(%rsp),%rdi
jmp    2e19 <svd+0x1c89>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm1,%xmm0
xorps  %xmm8,%xmm0
movaps 0xc0(%rsp),%xmm3
movaps %xmm3,%xmm2
movaps 0x150(%rsp),%xmm4
unpcklps %xmm4,%xmm2
unpcklps %xmm1,%xmm0
mulps  %xmm2,%xmm0
unpcklps %xmm3,%xmm4
movaps %xmm6,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm0,%xmm3
mov    0x60(%rsp),%rbx
add    $0x1,%rbx
movabs $0x100000000,%rax
add    %rax,%r12
mov    0x48(%rsp),%r13
add    $0x4,%r13
addq   $0x4,0xe0(%rsp)
add    $0x1,%r11
mov    %r11,0x90(%rsp)
mov    0xb0(%rsp),%r10
mov    0x40(%rsp),%r14
cmp    %r10,%r14
jge    2ac0 <svd+0x1930>
movaps %xmm3,0x30(%rsp)
mov    0xd0(%rsp),%rdx
lea    (%rdx,%rbx,1),%eax
cltq
lea    (%rdi,%rax,4),%rcx
mov    %rcx,0x128(%rsp)
mov    0xd8(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0x70(%rsp)
mov    0xf0(%rsp),%rax
add    %rbx,%rax
lea    (%rdi,%rax,4),%rax
mov    %rax,0x120(%rsp)
mov    0xe8(%rsp),%rax
lea    (%rax,%rbx,1),%rax
lea    (%rdi,%rax,4),%rax
mov    %rax,0x78(%rsp)
mov    %rbx,0x60(%rsp)
lea    (%rdx,%rbx,1),%rax
mov    %rax,0xf8(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x40(%rsp)
mov    0x18(%rsp),%rbx
movss  0x4(%rbx,%r14,4),%xmm0
movss  0x4(%r8,%r14,4),%xmm2
movss  %xmm2,0x48(%rsp)
mulss  %xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
mulss  %xmm0,%xmm6
movaps %xmm6,0xc0(%rsp)
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
call   1050 <hypotf@plt>
movaps 0x30(%rsp),%xmm6
movss  %xmm0,(%rbx,%r14,4)
movaps %xmm6,%xmm1
movaps 0x50(%rsp),%xmm2
movss  %xmm2,%xmm1
shufps $0x0,%xmm0,%xmm0
movaps %xmm1,%xmm5
divps  %xmm0,%xmm5
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
movaps 0xc0(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm5,%xmm1
movaps %xmm5,%xmm2
mulss  %xmm6,%xmm2
mulss  %xmm0,%xmm6
addss  %xmm1,%xmm6
mulss  %xmm0,%xmm3
movaps %xmm3,%xmm1
subss  %xmm2,%xmm1
movaps %xmm1,0xc0(%rsp)
movss  0x48(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm5,%xmm1
movaps %xmm0,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm2,0x150(%rsp)
mov    0x88(%rsp),%rax
mov    %r13,0x48(%rsp)
mov    %r13,%rcx
mov    %r12,%rdx
mov    0xb8(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rsi
sar    $0x1e,%rsi
movss  (%rdi,%rsi,1),%xmm7
movss  (%rcx),%xmm2
movaps %xmm5,%xmm3
mulss  %xmm2,%xmm3
movaps %xmm5,%xmm4
mulss  %xmm7,%xmm4
mulss  %xmm0,%xmm7
addss  %xmm3,%xmm7
movss  %xmm7,(%rdi,%rsi,1)
mulss  %xmm0,%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,(%rcx)
add    %rbp,%rdx
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    2f60 <svd+0x1dd0>
movaps %xmm6,%xmm0
movaps %xmm5,0x50(%rsp)
movaps %xmm6,0x30(%rsp)
movaps %xmm1,0x130(%rsp)
call   1050 <hypotf@plt>
movaps 0x50(%rsp),%xmm1
mov    0x80(%rsp),%rax
mov    %rax,%r8
movss  %xmm0,(%rax,%r14,4)
ucomiss 0x105e(%rip),%xmm0
jne    2fde <svd+0x1e4e>
jnp    2ff2 <svd+0x1e62>
movaps 0x130(%rsp),%xmm1
unpcklps 0x30(%rsp),%xmm1
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm1
movaps %xmm1,%xmm6
shufps $0x55,%xmm1,%xmm6
mov    0x100(%rsp),%rsi
test   %esi,%esi
mov    0x20(%rsp),%rdi
movaps 0x1000(%rip),%xmm8
mov    0x118(%rsp),%r9
mov    0xa8(%rsp),%r10
mov    0x90(%rsp),%r11
jle    2da0 <svd+0x1c10>
cmp    $0x4,%esi
jae    30b0 <svd+0x1f20>
xor    %edx,%edx
mov    0x28(%rsp),%rax
imul   %rdx,%rax
add    %eax,%r14d
shl    $0x20,%r14
add    %r11,%rax
lea    (%rdi,%rax,4),%rax
mov    0x148(%rsp),%rcx
sub    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdx
sar    $0x1e,%rdx
movss  (%rdi,%rdx,1),%xmm0
movss  (%rax),%xmm4
movaps %xmm1,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm6,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rdi,%rdx,1)
mulss  %xmm6,%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,(%rax)
add    %rbp,%r14
add    %r15,%rax
add    $0xffffffffffffffff,%rcx
jne    3060 <svd+0x1ed0>
jmp    2da0 <svd+0x1c10>
nopl   0x0(%rax,%rax,1)
cmpl   $0x1,0x8(%rsp)
jne    3037 <svd+0x1ea7>
mov    0x10(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %ecx,%eax
cmp    0xf8(%rsp),%eax
jl     3037 <svd+0x1ea7>
mov    $0x0,%edx
cmpq   $0x0,0x140(%rsp)
jne    3039 <svd+0x1ea9>
mov    0x78(%rsp),%rax
cmp    %rax,0x128(%rsp)
jae    310a <svd+0x1f7a>
mov    0x120(%rsp),%rax
cmp    0x70(%rsp),%rax
jb     3037 <svd+0x1ea7>
movaps %xmm1,%xmm0
shufps $0x0,%xmm1,%xmm0
mov    0x168(%rsp),%rax
mov    0xe0(%rsp),%rcx
mov    %r12,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdx
sar    $0x1e,%rdx
movups (%rdi,%rdx,1),%xmm5
movups (%rcx),%xmm2
movaps %xmm0,%xmm3
mulps  %xmm2,%xmm3
movaps %xmm0,%xmm4
mulps  %xmm5,%xmm4
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
movups %xmm5,(%rdi,%rdx,1)
mulps  %xmm6,%xmm2
subps  %xmm4,%xmm2
movups %xmm2,(%rcx)
add    %r10,%rbx
add    %r9,%rcx
add    $0xfffffffffffffffc,%rax
jne    3130 <svd+0x1fa0>
mov    0x168(%rsp),%rax
mov    %rax,%rdx
cmp    0x148(%rsp),%rax
mov    0x90(%rsp),%r11
je     2da0 <svd+0x1c10>
jmp    3039 <svd+0x1ea9>
nop
mov    0x80(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%r11
movaps 0xe57(%rip),%xmm7
movaps 0x170(%rsp),%xmm4
jmp    2ae8 <svd+0x1958>
cs nopw 0x0(%rax,%rax,1)
sar    $0x20,%rbx
movslq 0x50(%rsp),%r14
shl    $0x2,%r14
movaps 0xe4c(%rip),%xmm5
jmp    3210 <svd+0x2080>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r13),%rax
add    $0x4,%r14
mov    0xb0(%rsp),%r10
cmp    %r10,%r13
mov    %rax,%r13
mov    0x28(%rsp),%r11
movaps 0xdfe(%rip),%xmm7
movaps 0x170(%rsp),%xmm4
jge    2bc0 <svd+0x1a30>
mov    0x18(%rsp),%rax
movss  (%rax,%r13,4),%xmm1
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm5
movss  %xmm5,(%rax,%r13,4)
movaps %xmm0,%xmm1
andps  %xmm7,%xmm1
ucomiss %xmm1,%xmm4
jae    2bc0 <svd+0x1a30>
movss  (%r8,%r13,4),%xmm1
movaps %xmm1,0x60(%rsp)
movaps %xmm0,0x30(%rsp)
call   1050 <hypotf@plt>
movaps 0x60(%rsp),%xmm5
movaps 0xdaf(%rip),%xmm8
mov    0x20(%rsp),%rdi
mov    0x80(%rsp),%r8
movss  %xmm0,(%r8,%r13,4)
movaps 0x30(%rsp),%xmm1
xorps  %xmm8,%xmm1
unpcklps %xmm1,%xmm5
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm5
cmpl   $0x0,0x100(%rsp)
jle    31e0 <svd+0x2050>
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
mov    0x148(%rsp),%rax
mov    %rdi,%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm1
movss  (%rcx,%r14,1),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm2,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm5,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%rbx,4)
mulss  %xmm5,%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,(%rcx,%r14,1)
add    %r15,%rcx
add    $0xffffffffffffffff,%rax
jne    32b0 <svd+0x2120>
jmp    31e0 <svd+0x2050>
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
mov    0x1b0(%rsp),%rbx
mov    0x1a8(%rsp),%rdx
mov    0x100(%rsp),%rsi
jbe    3397 <svd+0x2207>
xorps  %xmm8,%xmm1
movss  %xmm1,(%r8,%r10,4)
cmpl   $0x1,0x8(%rsp)
mov    0x1d8(%rsp),%r9
jne    3333 <svd+0x21a3>
xor    %eax,%eax
jmp    3368 <svd+0x21d8>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x190(%rsp),%r10
nop
movss  (%rdx,%rcx,1),%xmm0
xorps  %xmm8,%xmm0
movss  %xmm0,(%rdx,%rcx,1)
movss  (%rbx,%rcx,1),%xmm0
xorps  %xmm8,%xmm0
movss  %xmm0,(%rbx,%rcx,1)
add    $0x2,%rax
add    %r10,%rcx
cmp    %rax,%r9
jne    3340 <svd+0x21b0>
testb  $0x1,0x88(%rsp)
01
mov    0xb0(%rsp),%r10
je     3397 <svd+0x2207>
imul   %r11,%rax
add    %r10,%rax
mov    0xb8(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
xorps  %xmm8,%xmm0
movss  %xmm0,(%rcx,%rax,4)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x1d0(%rsp)
addq   $0xffffffffffffffff,0x1c0(%rsp)
add    %rax,0x1c8(%rsp)
add    $0xfffffffffffffffc,%rbx
mov    %rbx,0x1b0(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x1a8(%rsp)
test   %r10,%r10
mov    0x1b8(%rsp),%rdx
jg     2a92 <svd+0x1902>
xor    %r15d,%r15d
mov    0x8(%rsp),%rdx
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
call   10b0 <svd_sort@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15d,%eax
add    $0x208,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc42(%rip),%rdi
call   1040 <puts@plt>
mov    $0xf,%r15d
jmp    3404 <svd+0x2274>

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

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