void svdcmp(float **a, int m, int n, float *w, float **v) {
  int flag, i, its, j, jj, k, l, nm;
  float anorm, c, f, g, h, s, scale, x, y, z, *rv1;
  rv1 = vector(1, n);
  g = scale = anorm = 0.0;
  for (i = 1; i <= n; i++) {
    l = i + 1;
    rv1[i] = scale * g;
    g = s = scale = 0.0;
    if (i <= m) {
      for (k = i; k <= m; k++)
        scale += fabs(a[k][i]);
      if (scale) {
        for (k = i; k <= m; k++) {
          a[k][i] /= scale;
          s += a[k][i] * a[k][i];
        }
        f = a[i][i];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        a[i][i] = f - g;
        for (j = l; j <= n; j++) {
          for (s = 0.0, k = i; k <= m; k++)
            s += a[k][i] * a[k][j];
          f = s / h;
          for (k = i; k <= m; k++)
            a[k][j] += f * a[k][i];
        }
        for (k = i; k <= m; k++)
          a[k][i] *= scale;
      }
    }
    w[i] = scale * g;
    g = s = scale = 0.0;
    if (i <= m && i != n) {
      for (k = l; k <= n; k++)
        scale += fabs(a[i][k]);
      if (scale) {
        for (k = l; k <= n; k++) {
          a[i][k] /= scale;
          s += a[i][k] * a[i][k];
        }
        f = a[i][l];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        a[i][l] = f - g;
        for (k = l; k <= n; k++)
          rv1[k] = a[i][k] / h;
        for (j = l; j <= m; j++) {
          for (s = 0.0, k = l; k <= n; k++)
            s += a[j][k] * a[i][k];
          for (k = l; k <= n; k++)
            a[j][k] += s * rv1[k];
        }
        for (k = l; k <= n; k++)
          a[i][k] *= scale;
      }
    }
    anorm = ((anorm) > ((fabs(w[i]) + fabs(rv1[i])))
                 ? (anorm)
                 : ((fabs(w[i]) + fabs(rv1[i]))));
  }
  for (i = n; i >= 1; i--) {
    if (i < n) {
      if (g) {
        for (j = l; j <= n; j++)
          v[j][i] = (a[i][j] / a[i][l]) / g;
        for (j = l; j <= n; j++) {
          for (s = 0.0, k = l; k <= n; k++)
            s += a[i][k] * v[k][j];
          for (k = l; k <= n; k++)
            v[k][j] += s * v[k][i];
        }
      }
      for (j = l; j <= n; j++)
        v[i][j] = v[j][i] = 0.0;
    }
    v[i][i] = 1.0;
    g = rv1[i];
    l = i;
  }
  for (i = ((m) < (n) ? (m) : (n)); i >= 1; i--) {
    l = i + 1;
    g = w[i];
    for (j = l; j <= n; j++)
      a[i][j] = 0.0;
    if (g) {
      g = 1.0 / g;
      for (j = l; j <= n; j++) {
        for (s = 0.0, k = l; k <= m; k++)
          s += a[k][i] * a[k][j];
        f = (s / a[i][i]) * g;
        for (k = i; k <= m; k++)
          a[k][j] += f * a[k][i];
      }
      for (j = i; j <= m; j++)
        a[j][i] *= g;
    } else
      for (j = i; j <= m; j++)
        a[j][i] = 0.0;
    ++a[i][i];
  }
  for (k = n; k >= 1; k--) {
    for (its = 1; its <= 30; its++) {
      flag = 1;
      for (l = k; l >= 1; l--) {
        nm = l - 1;
        if ((float)(fabs(rv1[l]) + anorm) == anorm) {
          flag = 0;
          break;
        }
        if ((float)(fabs(w[nm]) + anorm) == anorm)
          break;
      }
      if (flag) {
        c = 0.0;
        s = 1.0;
        for (i = l; i <= k; i++) {
          f = s * rv1[i];
          rv1[i] = c * rv1[i];
          if ((float)(fabs(f) + anorm) == anorm)
            break;
          g = w[i];
          h = pythag(f, g);
          w[i] = h;
          h = 1.0 / h;
          c = g * h;
          s = -f * h;
          for (j = 1; j <= m; j++) {
            y = a[j][nm];
            z = a[j][i];
            a[j][nm] = y * c + z * s;
            a[j][i] = z * c - y * s;
          }
        }
      }
      z = w[k];
      if (l == k) {
        if (z < 0.0) {
          w[k] = -z;
          for (j = 1; j <= n; j++)
            v[j][k] = -v[j][k];
        }
        break;
      }
      if (its == 30)
        nrerror("no convergence in 30 svdcmp iterations");
      x = w[l];
      nm = k - 1;
      y = w[nm];
      g = rv1[nm];
      h = rv1[k];
      f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
      g = pythag(f, 1.0);
      f = ((x - z) * (x + z) +
           h * ((y / (f + ((f) >= 0.0 ? fabs(g) : -fabs(g)))) - h)) /
          x;
      c = s = 1.0;
      for (j = l; j <= nm; j++) {
        i = j + 1;
        g = rv1[i];
        y = w[i];
        h = s * g;
        g = c * g;
        z = pythag(f, h);
        rv1[j] = z;
        c = f / z;
        s = h / z;
        f = x * c + g * s;
        g = g * c - x * s;
        h = y * s;
        y *= c;
        for (jj = 1; jj <= n; jj++) {
          x = v[jj][j];
          z = v[jj][i];
          v[jj][j] = x * c + z * s;
          v[jj][i] = z * c - x * s;
        }
        z = pythag(f, h);
        w[j] = z;
        if (z) {
          z = 1.0 / z;
          c = f * z;
          s = h * z;
        }
        f = c * g + s * y;
        x = c * y - s * g;
        for (jj = 1; jj <= m; jj++) {
          y = a[jj][j];
          z = a[jj][i];
          a[jj][j] = y * c + z * s;
          a[jj][i] = z * c - y * s;
        }
      }
      rv1[l] = 0.0;
      rv1[k] = f;
      w[k] = x;
    }
  }
  free_vector(rv1, 1, n);
}


x86 assembly (clang, -O0):
<svdcmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x10(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1060 <vector@plt>
cltq
mov    %rax,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     197e <svdcmp+0x82e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movss  -0x5c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1518 <svdcmp+0x3c8>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     124b <svdcmp+0xfb>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1ddd(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f7 <svdcmp+0xa7>
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1267 <svdcmp+0x117>
jp     1267 <svdcmp+0x117>
jmp    1513 <svdcmp+0x3c3>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12e6 <svdcmp+0x196>
movss  -0x5c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    126d <svdcmp+0x11d>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1339 <svdcmp+0x1e9>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <sqrt@plt>
movaps 0x1cd5(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    136e <svdcmp+0x21e>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <sqrt@plt>
movaps 0x1cb2(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     14cf <svdcmp+0x37f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1451 <svdcmp+0x301>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fb <svdcmp+0x2ab>
movss  -0x58(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14bc <svdcmp+0x36c>
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1466 <svdcmp+0x316>
jmp    14c1 <svdcmp+0x371>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13e1 <svdcmp+0x291>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     150e <svdcmp+0x3be>
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14d5 <svdcmp+0x385>
jmp    1513 <svdcmp+0x3c3>
jmp    1518 <svdcmp+0x3c8>
movss  -0x5c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     18b6 <svdcmp+0x766>
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     18b6 <svdcmp+0x766>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     15b9 <svdcmp+0x469>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1a6f(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1565 <svdcmp+0x415>
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    15d5 <svdcmp+0x485>
jp     15d5 <svdcmp+0x485>
jmp    18b1 <svdcmp+0x761>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1654 <svdcmp+0x504>
movss  -0x5c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15db <svdcmp+0x48b>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     16a7 <svdcmp+0x557>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <sqrt@plt>
movaps 0x1967(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    16dc <svdcmp+0x58c>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <sqrt@plt>
movaps 0x1944(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1790 <svdcmp+0x640>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x54(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    174f <svdcmp+0x5ff>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     186d <svdcmp+0x71d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1806 <svdcmp+0x6b6>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17b0 <svdcmp+0x660>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     185a <svdcmp+0x70a>
movss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    180c <svdcmp+0x6bc>
jmp    185f <svdcmp+0x70f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1796 <svdcmp+0x646>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     18ac <svdcmp+0x75c>
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1873 <svdcmp+0x723>
jmp    18b1 <svdcmp+0x761>
jmp    18b6 <svdcmp+0x766>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0x1729(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x170d(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    191b <svdcmp+0x7cb>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    195f <svdcmp+0x80f>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x16cd(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0x16b1(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a1 <svdcmp+0x51>
mov    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jl     1b9c <svdcmp+0xa4c>
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b59 <svdcmp+0xa09>
movss  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    19b6 <svdcmp+0x866>
jp     19b6 <svdcmp+0x866>
jmp    1b04 <svdcmp+0x9b4>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1a1a <svdcmp+0x8ca>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
divss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19bc <svdcmp+0x86c>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1aff <svdcmp+0x9af>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1a90 <svdcmp+0x940>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a3a <svdcmp+0x8ea>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1aec <svdcmp+0x99c>
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a96 <svdcmp+0x946>
jmp    1af1 <svdcmp+0x9a1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a20 <svdcmp+0x8d0>
jmp    1b04 <svdcmp+0x9b4>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1b54 <svdcmp+0xa04>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b0a <svdcmp+0x9ba>
jmp    1b59 <svdcmp+0xa09>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  0x149f(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1984 <svdcmp+0x834>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1bb6 <svdcmp+0xa66>
mov    -0xc(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1bbf <svdcmp+0xa6f>
mov    -0x10(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jl     1e19 <svdcmp+0xcc9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1c25 <svdcmp+0xad5>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bf3 <svdcmp+0xaa3>
movss  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1c41 <svdcmp+0xaf1>
jp     1c41 <svdcmp+0xaf1>
jmp    1dac <svdcmp+0xc5c>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x13c6(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1d68 <svdcmp+0xc18>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1cd5 <svdcmp+0xb85>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c7f <svdcmp+0xb2f>
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1d55 <svdcmp+0xc05>
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cff <svdcmp+0xbaf>
jmp    1d5a <svdcmp+0xc0a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c65 <svdcmp+0xb15>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1da7 <svdcmp+0xc57>
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d6e <svdcmp+0xc1e>
jmp    1de9 <svdcmp+0xc99>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1de4 <svdcmp+0xc94>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1db2 <svdcmp+0xc62>
jmp    1de9 <svdcmp+0xc99>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  0x120f(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1bc8 <svdcmp+0xa78>
mov    -0x10(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x1,-0x38(%rbp)
jl     27c7 <svdcmp+0x1677>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x1e,-0x2c(%rbp)
jg     27b4 <svdcmp+0x1664>
movl   $0x1,-0x24(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x1,-0x3c(%rbp)
jl     1ef8 <svdcmp+0xda8>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x118e(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss -0x44(%rbp),%xmm0
jne    1ea3 <svdcmp+0xd53>
jp     1ea3 <svdcmp+0xd53>
movl   $0x0,-0x24(%rbp)
jmp    1ef8 <svdcmp+0xda8>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x1145(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss -0x44(%rbp),%xmm0
jne    1ee5 <svdcmp+0xd95>
jp     1ee5 <svdcmp+0xd95>
jmp    1ef8 <svdcmp+0xda8>
jmp    1eea <svdcmp+0xd9a>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e47 <svdcmp+0xcf7>
cmpl   $0x0,-0x24(%rbp)
je     2104 <svdcmp+0xfb4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0x10fe(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     20ff <svdcmp+0xfaf>
movss  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x1091(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss -0x44(%rbp),%xmm0
jne    1f99 <svdcmp+0xe49>
jp     1f99 <svdcmp+0xe49>
jmp    20ff <svdcmp+0xfaf>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x50(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    $0x2,%al
call   1050 <pythag@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1028(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     20ec <svdcmp+0xf9c>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    202f <svdcmp+0xedf>
jmp    20f1 <svdcmp+0xfa1>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1f1d <svdcmp+0xdcd>
jmp    2104 <svdcmp+0xfb4>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    21b9 <svdcmp+0x1069>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    21b4 <svdcmp+0x1064>
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     21af <svdcmp+0x105f>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    215e <svdcmp+0x100e>
jmp    21b4 <svdcmp+0x1064>
jmp    27b4 <svdcmp+0x1664>
cmpl   $0x1e,-0x2c(%rbp)
jne    21d1 <svdcmp+0x1081>
lea    0xe5e(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
addss  -0x68(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
subss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm3
addss  -0x54(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xdb5(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0x64(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd7e(%rip),%xmm1
mov    $0x2,%al
call   1050 <pythag@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
addss  -0x68(%rbp),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movss  -0x64(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2338 <svdcmp+0x11e8>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xcd9(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    236b <svdcmp+0x121b>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xcb8(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm3
ff
movsd  -0xb8(%rbp),%xmm4
ff
addsd  %xmm4,%xmm3
divsd  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xc42(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xc35(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     2772 <svdcmp+0x1622>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    $0x2,%al
call   1050 <pythag@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
divss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
divss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x64(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     25c0 <svdcmp+0x1470>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2503 <svdcmp+0x13b3>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    $0x2,%al
call   1050 <pythag@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2610 <svdcmp+0x14c0>
jp     2610 <svdcmp+0x14c0>
jmp    264c <svdcmp+0x14fc>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x9f7(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     275f <svdcmp+0x160f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    26a2 <svdcmp+0x1552>
jmp    2764 <svdcmp+0x1614>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    23e6 <svdcmp+0x1296>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e30 <svdcmp+0xce0>
jmp    27b9 <svdcmp+0x1669>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1e1f <svdcmp+0xccf>
mov    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1040 <free_vector@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svdcmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r8,%rbx
mov    %rcx,0x38(%rsp)
mov    %edx,%r15d
mov    %esi,%r13d
mov    %rdi,%r14
mov    $0x1,%edi
mov    %edx,%esi
xor    %eax,%eax
call   1070 <vector@plt>
cltq
mov    %r15d,%ecx
mov    %rcx,0x18(%rsp)
movslq %r13d,%r11
test   %r15d,%r15d
mov    %rbx,0x30(%rsp)
mov    %r14,0x70(%rsp)
mov    %rax,0x10(%rsp)
mov    %r15,0x48(%rsp)
mov    %r11,0xe8(%rsp)
jle    22d6 <svdcmp+0x1176>
lea    0x1(%r13),%ebx
lea    0x1(%r15),%ecx
mov    %rcx,0x20(%rsp)
lea    0x2(%r15),%ecx
mov    %rcx,0x190(%rsp)
lea    -0x2(%r15),%edi
lea    -0x1(%r15),%ecx
mov    %ecx,0x114(%rsp)
lea    0x3(%r15),%edx
lea    0x18(%rax),%rsi
add    $0x38,%rax
mov    %rax,0x68(%rsp)
xorps  %xmm8,%xmm8
mov    $0x1,%r15d
mov    $0x2,%eax
mov    %rax,(%rsp)
mov    $0xfffffffffffffffe,%r10
mov    $0x6,%ebp
mov    $0xe,%ecx
movaps 0x1dda(%rip),%xmm7
xorpd  %xmm9,%xmm9
movaps 0x1dfd(%rip),%xmm10
mov    %edi,0xf0(%rsp)
xorps  %xmm12,%xmm12
xorps  %xmm11,%xmm11
xorps  %xmm3,%xmm3
mov    %rbx,0xf8(%rsp)
mov    %r14,%r12
xor    %eax,%eax
mov    %rax,0x78(%rsp)
mov    0x38(%rsp),%r8
xor    %r9d,%r9d
mov    %edi,0xd0(%rsp)
jmp    12c5 <svdcmp+0x165>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rax
add    $0x1,%rax
add    $0x1,%r9d
addq   $0x1,0x78(%rsp)
add    $0x8,%r12
add    $0xffffffffffffffff,%rbx
add    $0xffffffffffffffff,%r10
add    $0x3,%dl
add    $0x4,%rsi
add    $0x1,%rbp
addl   $0xffffffff,0xf0(%rsp)
ff
add    $0x1,%rcx
addq   $0x4,0x68(%rsp)
mov    0x58(%rsp),%r15
mov    %rax,%rdi
mov    %rax,(%rsp)
cmp    0x190(%rsp),%rax
je     1f73 <svdcmp+0xe13>
mov    %r10,0x80(%rsp)
mov    %r9,0xa0(%rsp)
mulss  %xmm11,%xmm12
movzbl %dl,%edx
and    $0x3,%edx
lea    0x1(%r15),%rax
mov    %rax,0x58(%rsp)
mov    0x10(%rsp),%r10
movss  %xmm12,(%r10,%r15,4)
cmp    %r11,%r15
jle    1330 <svdcmp+0x1d0>
lea    (%r8,%r15,4),%rdi
movl   $0x0,(%r8,%r15,4)
xorps  %xmm11,%xmm11
xorps  %xmm12,%xmm12
mov    0xa0(%rsp),%r9
mov    0x80(%rsp),%r10
jmp    1721 <svdcmp+0x5c1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,0x40(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rbp,0xb8(%rsp)
mov    0xf0(%rsp),%eax
add    $0x1,%rax
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x118(%rsp)
and    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x108(%rsp)
mov    0xd0(%rsp),%eax
mov    %eax,%edi
mov    0x78(%rsp),%rcx
sub    %ecx,%edi
lea    0x1(%rdi),%rax
mov    %rax,%rbp
movabs $0x1fffffff8,%r9
and    %r9,%rbp
mov    %rbp,%rsi
mov    %rbp,0x138(%rsp)
lea    -0x8(%rbp),%rsi
mov    %rsi,0x128(%rsp)
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,0x130(%rsp)
mov    0x114(%rsp),%esi
sub    %ecx,%esi
mov    %esi,0x98(%rsp)
lea    0x4(%r9),%rsi
mov    %rax,0x120(%rsp)
and    %rax,%rsi
mov    %rsi,0xe0(%rsp)
lea    -0x4(%rsi),%rax
mov    %rax,0x188(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x100(%rsp)
mov    (%rsp),%rax
lea    (%r10,%rax,4),%rax
mov    %rax,0x148(%rsp)
lea    0xc(%r10,%rcx,4),%rax
lea    (%rax,%rdi,4),%rax
mov    %rax,0x150(%rsp)
mov    %rdi,0xc0(%rsp)
lea    0x3(%rcx,%rdi,1),%rax
mov    %rax,0x140(%rsp)
mov    0xd0(%rsp),%eax
mov    %eax,%ebp
mov    0xa0(%rsp),%r9
sub    %r9d,%ebp
xorps  %xmm4,%xmm4
lea    0x1(%rbp),%rsi
mov    $0x1,%eax
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rcx
movss  (%rcx,%r15,4),%xmm0
andps  %xmm7,%xmm0
addss  %xmm0,%xmm4
add    $0x1,%rax
cmp    %rax,%rbx
jne    1470 <svdcmp+0x310>
xorps  %xmm11,%xmm11
ucomiss %xmm11,%xmm4
xorps  %xmm0,%xmm0
movss  %xmm3,0xc(%rsp)
mov    %rdx,0x60(%rsp)
mov    0x80(%rsp),%r10
jne    14b0 <svdcmp+0x350>
jnp    1682 <svdcmp+0x522>
xorps  %xmm2,%xmm2
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rax,8),%rcx
movss  (%rcx,%r15,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,(%rcx,%r15,4)
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm2
add    $0x1,%rax
cmp    %rax,%rbx
jne    14c0 <svdcmp+0x360>
mov    (%r14,%r15,8),%rax
movss  (%rax,%r15,4),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
ucomisd %xmm9,%xmm0
jb     1517 <svdcmp+0x3b7>
sqrtsd %xmm0,%xmm0
ucomiss %xmm8,%xmm5
jae    15ae <svdcmp+0x44e>
orps   0x1b0e(%rip),%xmm0
jmp    15b5 <svdcmp+0x455>
mov    %r9,%r14
mov    %rsi,0xd8(%rsp)
movss  %xmm4,0xb0(%rsp)
movss  %xmm5,0x170(%rsp)
movss  %xmm2,0x160(%rsp)
call   1080 <sqrt@plt>
movss  0x160(%rsp),%xmm2
movss  0x170(%rsp),%xmm5
movss  0xb0(%rsp),%xmm4
mov    0xd8(%rsp),%rsi
xorps  %xmm11,%xmm11
movaps 0x1abf(%rip),%xmm10
xorpd  %xmm9,%xmm9
movaps 0x1a83(%rip),%xmm7
mov    0x80(%rsp),%r10
xorps  %xmm8,%xmm8
mov    0xe8(%rsp),%r11
mov    %r14,%r9
movss  0xc(%rsp),%xmm3
mov    0x70(%rsp),%r14
mov    0x38(%rsp),%r8
ucomiss %xmm8,%xmm5
jb     150b <svdcmp+0x3ab>
andps  0x1a5b(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movaps %xmm5,%xmm1
addss  %xmm0,%xmm1
xorps  %xmm10,%xmm0
mov    (%r14,%r15,8),%rax
movss  %xmm1,(%rax,%r15,4)
cmp    0x18(%rsp),%r15
jae    165b <svdcmp+0x4fb>
mulss  %xmm0,%xmm5
subss  %xmm2,%xmm5
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm1,%xmm1
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,8),%rdx
movss  (%rdx,%r15,4),%xmm2
mulss  (%rdx,%rax,4),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1600 <svdcmp+0x4a0>
divss  %xmm5,%xmm1
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rcx,8),%rdx
movss  (%rdx,%r15,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%rax,4),%xmm2
movss  %xmm2,(%rdx,%rax,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1630 <svdcmp+0x4d0>
add    $0x1,%rax
cmp    %eax,0x20(%rsp)
jne    15f0 <svdcmp+0x490>
mov    $0x1,%eax
mov    (%r12,%rax,8),%rcx
movss  (%rcx,%r15,4),%xmm1
mulss  %xmm4,%xmm1
movss  %xmm1,(%rcx,%r15,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1660 <svdcmp+0x500>
mov    0x60(%rsp),%rdx
mulss  %xmm0,%xmm4
lea    (%r8,%r15,4),%rdi
movss  %xmm4,(%r8,%r15,4)
cmp    0x18(%rsp),%r15
mov    0x50(%rsp),%rcx
je     1710 <svdcmp+0x5b0>
jae    1710 <svdcmp+0x5b0>
mov    (%r14,%r15,8),%rax
testb  $0x3,0x98(%rsp)
03
mov    %rsi,0xd8(%rsp)
mov    %rdi,0xb0(%rsp)
je     1762 <svdcmp+0x602>
mov    %r10,%rcx
mov    %r9,%r10
mov    %rcx,%rsi
mov    (%rsp),%rcx
lea    (%rax,%rcx,4),%r9
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movss  (%r9,%rcx,4),%xmm1
andps  %xmm7,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %ecx,%edx
jne    16e0 <svdcmp+0x580>
sub    %rsi,%rcx
mov    0xb0(%rsp),%rdi
mov    %r10,%r9
jmp    176c <svdcmp+0x60c>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm12,%xmm12
mov    0xb8(%rsp),%rbp
mov    0x40(%rsp),%rsi
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
mov    0x10(%rsp),%rax
movss  (%rax,%r15,4),%xmm0
movss  (%rdi),%xmm2
unpcklps %xmm0,%xmm2
andps  %xmm7,%xmm2
cvtps2pd %xmm2,%xmm2
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm0,%xmm1
ja     1270 <svdcmp+0x110>
xorps  %xmm3,%xmm3
cvtsd2ss %xmm0,%xmm3
jmp    1270 <svdcmp+0x110>
mov    %r10,%rsi
xorps  %xmm0,%xmm0
mov    (%rsp),%rcx
movaps %xmm0,%xmm12
cmpl   $0x3,0xc0(%rsp)
03
mov    0x20(%rsp),%rdx
jb     17c2 <svdcmp+0x662>
nop
movss  (%rax,%rcx,4),%xmm1
movss  0x4(%rax,%rcx,4),%xmm2
movss  0x8(%rax,%rcx,4),%xmm3
movss  0xc(%rax,%rcx,4),%xmm12
andps  %xmm7,%xmm1
addss  %xmm0,%xmm1
andps  %xmm7,%xmm2
addss  %xmm1,%xmm2
andps  %xmm7,%xmm3
addss  %xmm2,%xmm3
andps  %xmm7,%xmm12
addss  %xmm3,%xmm12
add    $0x4,%rcx
movaps %xmm12,%xmm0
cmp    %ecx,%edx
jne    1780 <svdcmp+0x620>
xorps  %xmm11,%xmm11
ucomiss %xmm11,%xmm12
jne    17d2 <svdcmp+0x672>
jnp    189c <svdcmp+0x73c>
mov    (%r14,%r15,8),%rax
xorps  %xmm4,%xmm4
cmp    0x18(%rsp),%r15
movss  0xc(%rsp),%xmm3
mov    0x40(%rsp),%rsi
jae    187b <svdcmp+0x71b>
xorps  %xmm0,%xmm0
mov    (%rsp),%rcx
testb  $0x1,0x98(%rsp)
01
je     1823 <svdcmp+0x6c3>
mov    (%rsp),%rcx
movss  (%rax,%rcx,4),%xmm4
divss  %xmm12,%xmm4
movss  %xmm4,(%rax,%rcx,4)
mulss  %xmm4,%xmm4
addss  %xmm8,%xmm4
add    $0x1,%rcx
movaps %xmm4,%xmm0
mov    0xd0(%rsp),%edx
cmp    0x78(%rsp),%edx
mov    0x20(%rsp),%rdx
je     187b <svdcmp+0x71b>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax,%rcx,4),%xmm1
movss  0x4(%rax,%rcx,4),%xmm4
divss  %xmm12,%xmm1
movss  %xmm1,(%rax,%rcx,4)
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
divss  %xmm12,%xmm4
movss  %xmm4,0x4(%rax,%rcx,4)
mulss  %xmm4,%xmm4
addss  %xmm1,%xmm4
add    $0x2,%rcx
movaps %xmm4,%xmm0
cmp    %ecx,%edx
jne    1840 <svdcmp+0x6e0>
mov    0x58(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
ucomisd %xmm9,%xmm0
jb     18bc <svdcmp+0x75c>
sqrtsd %xmm0,%xmm0
jmp    1926 <svdcmp+0x7c6>
mov    %rsi,%r10
movss  0xc(%rsp),%xmm3
mov    0x60(%rsp),%rdx
mov    0xb8(%rsp),%rbp
mov    0x50(%rsp),%rcx
jmp    171c <svdcmp+0x5bc>
mov    %rsi,%r14
movaps %xmm12,0x170(%rsp)
movaps %xmm2,0x160(%rsp)
movss  %xmm4,0x110(%rsp)
call   1080 <sqrt@plt>
movss  0x110(%rsp),%xmm4
movaps 0x160(%rsp),%xmm2
movaps 0x170(%rsp),%xmm12
movaps 0x1730(%rip),%xmm10
xorpd  %xmm9,%xmm9
movaps 0x16f4(%rip),%xmm7
xorps  %xmm8,%xmm8
mov    %r14,%rsi
mov    0xe8(%rsp),%r11
movss  0xc(%rsp),%xmm3
mov    0x70(%rsp),%r14
mov    0xf8(%rsp),%r9
mov    0x68(%rsp),%r8
ucomiss %xmm8,%xmm2
mov    %rsi,%r10
mov    0x108(%rsp),%rdi
jb     194d <svdcmp+0x7ed>
andps  0x16c5(%rip),%xmm0
jmp    1954 <svdcmp+0x7f4>
orps   0x16cc(%rip),%xmm0
xorps  %xmm11,%xmm11
cvtsd2ss %xmm0,%xmm11
movaps %xmm2,%xmm0
addss  %xmm11,%xmm0
xorps  %xmm10,%xmm11
mov    (%r14,%r15,8),%rax
mov    0x58(%rsp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmp    0x18(%rsp),%r15
jae    1ab6 <svdcmp+0x956>
mulss  %xmm11,%xmm2
subss  %xmm4,%xmm2
mov    (%rsp),%rcx
cmpl   $0x3,0xc0(%rsp)
03
jb     1a4e <svdcmp+0x8ee>
mov    0x140(%rsp),%rcx
lea    (%rax,%rcx,4),%rcx
cmp    %rcx,0x148(%rsp)
jae    19c9 <svdcmp+0x869>
mov    (%rsp),%rcx
lea    (%rax,%rcx,4),%rdx
cmp    0x150(%rsp),%rdx
jb     1a4e <svdcmp+0x8ee>
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
cmpq   $0x0,0x188(%rsp)
je     1f5e <svdcmp+0xdfe>
mov    0xb8(%rsp),%rcx
lea    (%rax,%rcx,4),%rdx
xor    %ecx,%ecx
mov    %r10,%rsi
movups -0x10(%rdx,%rcx,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,-0x10(%rsi,%rcx,4)
movups (%rdx,%rcx,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    19f0 <svdcmp+0x890>
testb  $0x1,0x100(%rsp)
01
je     1a30 <svdcmp+0x8d0>
add    (%rsp),%rcx
movups (%rax,%rcx,4),%xmm1
divps  %xmm0,%xmm1
mov    0x10(%rsp),%rdx
movups %xmm1,(%rdx,%rcx,4)
mov    0xe0(%rsp),%rcx
cmp    %rcx,0x120(%rsp)
je     1ab6 <svdcmp+0x956>
mov    0xe0(%rsp),%rcx
add    (%rsp),%rcx
mov    0x20(%rsp),%rdx
sub    %ecx,%edx
test   $0x1,%dl
jne    1a5f <svdcmp+0x8ff>
mov    %rcx,%rdx
jmp    1a79 <svdcmp+0x919>
movss  (%rax,%rcx,4),%xmm0
divss  %xmm2,%xmm0
mov    0x10(%rsp),%rdx
movss  %xmm0,(%rdx,%rcx,4)
mov    %rcx,%rdx
add    $0x1,%rdx
cmp    0x48(%rsp),%ecx
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rsi
je     1ab6 <svdcmp+0x956>
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,0x4(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %edx,%esi
jne    1a90 <svdcmp+0x930>
mov    %rbp,0x108(%rsp)
cmp    %r11,%r15
jge    1dcf <svdcmp+0xc6f>
mov    (%rsp),%r10
mov    0x138(%rsp),%rcx
add    %r10,%rcx
mov    %rcx,0xe0(%rsp)
mov    0x80(%rsp),%rdi
neg    %rdi
lea    (%rax,%r10,4),%rsi
mov    %rdi,0x100(%rsp)
jmp    1b0d <svdcmp+0x9ad>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    %r10d,%r9d
je     1dcf <svdcmp+0xc6f>
cmp    0x18(%rsp),%r15
jae    1b00 <svdcmp+0x9a0>
mov    (%r14,%r10,8),%rbp
testb  $0x3,0x98(%rsp)
03
je     1b61 <svdcmp+0xa01>
mov    (%rsp),%rcx
lea    0x0(,%rcx,4),%rdx
add    %rbp,%rdx
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x60(%rsp),%r8
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm1
mulss  (%rsi,%rcx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %ecx,%r8d
jne    1b40 <svdcmp+0x9e0>
add    %rdi,%rcx
mov    0x68(%rsp),%r8
jmp    1b68 <svdcmp+0xa08>
xorps  %xmm0,%xmm0
mov    (%rsp),%rcx
cmpl   $0x3,0xc0(%rsp)
03
mov    0x20(%rsp),%rdx
jb     1bc7 <svdcmp+0xa67>
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
movss  0x4(%rbp,%rcx,4),%xmm2
mulss  (%rax,%rcx,4),%xmm1
mulss  0x4(%rax,%rcx,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rbp,%rcx,4),%xmm3
mulss  0x8(%rax,%rcx,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rbp,%rcx,4),%xmm0
mulss  0xc(%rax,%rcx,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %ecx,%edx
jne    1b80 <svdcmp+0xa20>
cmp    0x18(%rsp),%r15
movss  0xc(%rsp),%xmm3
jae    1b00 <svdcmp+0x9a0>
mov    (%r14,%r10,8),%rbp
mov    (%rsp),%rcx
cmpl   $0x7,0xc0(%rsp)
07
jb     1d40 <svdcmp+0xbe0>
mov    (%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
cmp    0x150(%rsp),%rcx
jae    1c2c <svdcmp+0xacc>
mov    0x140(%rsp),%rcx
lea    0x0(,%rcx,4),%rdx
add    %rbp,%rdx
mov    (%rsp),%rcx
cmp    %rdx,0x148(%rsp)
jb     1d40 <svdcmp+0xbe0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x128(%rsp)
je     1cc1 <svdcmp+0xb61>
mov    0x50(%rsp),%rcx
lea    0x0(,%rcx,4),%rdx
add    %rbp,%rdx
mov    0x118(%rsp),%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x30(%r8,%rcx,4),%xmm2
movups -0x20(%r8,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
movups -0x30(%rdx,%rcx,4),%xmm4
addps  %xmm2,%xmm4
movups -0x20(%rdx,%rcx,4),%xmm2
movups -0x10(%rdx,%rcx,4),%xmm5
movups (%rdx,%rcx,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,-0x30(%rdx,%rcx,4)
movups %xmm3,-0x20(%rdx,%rcx,4)
movups -0x10(%r8,%rcx,4),%xmm2
movups (%r8,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,-0x10(%rdx,%rcx,4)
movups %xmm3,(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1c60 <svdcmp+0xb00>
jmp    1cc3 <svdcmp+0xb63>
xor    %ecx,%ecx
testb  $0x1,0x130(%rsp)
01
mov    0xf8(%rsp),%r9
mov    0x100(%rsp),%rdi
je     1d0f <svdcmp+0xbaf>
add    (%rsp),%rcx
mov    0x10(%rsp),%rdx
movups (%rdx,%rcx,4),%xmm2
movups 0x10(%rdx,%rcx,4),%xmm3
movups 0x0(%rbp,%rcx,4),%xmm4
movups 0x10(%rbp,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,0x0(%rbp,%rcx,4)
movups %xmm3,0x10(%rbp,%rcx,4)
mov    0xe0(%rsp),%rcx
mov    0x138(%rsp),%rdx
cmp    %rdx,0x120(%rsp)
movss  0xc(%rsp),%xmm3
je     1b00 <svdcmp+0x9a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rdx
sub    %ecx,%edx
test   $0x1,%dl
jne    1d5a <svdcmp+0xbfa>
mov    %rcx,%rdx
cmp    0x48(%rsp),%ecx
jne    1d90 <svdcmp+0xc30>
jmp    1b00 <svdcmp+0x9a0>
mov    0x10(%rsp),%rdx
movss  (%rdx,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
mov    %rcx,%rdx
add    $0x1,%rdx
cmp    0x48(%rsp),%ecx
je     1b00 <svdcmp+0x9a0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%rcx
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x0(%rbp,%rdx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rbp,%rdx,4),%xmm1
movss  %xmm1,0x4(%rbp,%rdx,4)
add    $0x2,%rdx
cmp    %edx,0x20(%rsp)
jne    1d90 <svdcmp+0xc30>
jmp    1b00 <svdcmp+0x9a0>
cmp    0x18(%rsp),%r15
jae    1e7e <svdcmp+0xd1e>
mov    (%rsp),%rdx
cmpl   $0x7,0x108(%rsp)
07
mov    0x38(%rsp),%r8
mov    0xa0(%rsp),%r9
mov    0x40(%rsp),%rsi
mov    0xb8(%rsp),%rbp
jb     1f20 <svdcmp+0xdc0>
movaps %xmm12,%xmm0
shufps $0x0,%xmm12,%xmm0
cmpq   $0x0,0x128(%rsp)
je     1eaa <svdcmp+0xd4a>
mov    %r9,%r10
mov    0x50(%rsp),%rcx
lea    (%rax,%rcx,4),%rdx
xor    %ecx,%ecx
mov    0x118(%rsp),%r9
mov    0xd8(%rsp),%rsi
nopl   0x0(%rax)
movups -0x30(%rdx,%rcx,4),%xmm1
movups -0x20(%rdx,%rcx,4),%xmm2
movups -0x10(%rdx,%rcx,4),%xmm3
movups (%rdx,%rcx,4),%xmm4
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,-0x30(%rdx,%rcx,4)
movups %xmm2,-0x20(%rdx,%rcx,4)
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,-0x10(%rdx,%rcx,4)
movups %xmm4,(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%r9
jne    1e40 <svdcmp+0xce0>
jmp    1eb7 <svdcmp+0xd57>
mov    0x38(%rsp),%r8
mov    0xa0(%rsp),%r9
mov    0x60(%rsp),%rdx
mov    0x40(%rsp),%rsi
mov    0x80(%rsp),%r10
mov    0xb8(%rsp),%rbp
jmp    1f4c <svdcmp+0xdec>
mov    %r9,%r10
xor    %ecx,%ecx
mov    0xd8(%rsp),%rsi
mov    %rsi,%rdx
movabs $0x1fffffff8,%rdi
and    %rdi,%rdx
testb  $0x1,0x130(%rsp)
01
je     1eed <svdcmp+0xd8d>
add    (%rsp),%rcx
movups (%rax,%rcx,4),%xmm1
movups 0x10(%rax,%rcx,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rax,%rcx,4)
movups %xmm2,0x10(%rax,%rcx,4)
cmp    %rdx,%rsi
movss  0xc(%rsp),%xmm3
mov    %r10,%r9
jne    1f17 <svdcmp+0xdb7>
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rcx
mov    0x40(%rsp),%rsi
mov    0xb0(%rsp),%rdi
jmp    1315 <svdcmp+0x1b5>
add    (%rsp),%rdx
mov    0x40(%rsp),%rsi
mov    0x20(%rsp),%rcx
mov    0x80(%rsp),%r10
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm0
mulss  %xmm12,%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    1f30 <svdcmp+0xdd0>
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rcx
mov    0xb0(%rsp),%rdi
jmp    1721 <svdcmp+0x5c1>
xor    %ecx,%ecx
testb  $0x1,0x100(%rsp)
01
jne    1a1c <svdcmp+0x8bc>
jmp    1a30 <svdcmp+0x8d0>
mov    0x48(%rsp),%r15
test   %r15d,%r15d
setg   %al
jle    22de <svdcmp+0x117e>
mov    %rax,0xa0(%rsp)
xorps  %xmm0,%xmm0
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%r8
mov    0x58(%rsp),%rbp
mov    0x30(%rsp),%rbx
jmp    1fcf <svdcmp+0xe6f>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rbp,8),%rax
movl   $0x3f800000,(%rax,%rbp,4)
movss  (%r8,%rbp,4),%xmm11
lea    -0x1(%rbp),%rax
cmp    $0x1,%rbp
jle    22c7 <svdcmp+0x1167>
mov    %rbp,%r9
mov    %rax,%rbp
cmp    0x18(%rsp),%rax
mov    0x20(%rsp),%rcx
jge    1fb0 <svdcmp+0xe50>
ucomiss %xmm0,%xmm11
mov    %rbp,%r12
jne    1ff0 <svdcmp+0xe90>
jnp    2070 <svdcmp+0xf10>
cmp    0x48(%rsp),%r9d
jg     2070 <svdcmp+0xf10>
mov    0x70(%rsp),%rax
mov    (%rax,%rbp,8),%r8
mov    %r9,%rdx
shl    $0x20,%rdx
movslq %r9d,%rsi
mov    %rdx,%rdi
sar    $0x1e,%rdi
add    %r8,%rdi
sar    $0x1d,%rdx
add    0x30(%rsp),%rdx
mov    %ecx,%r14d
sub    %r9d,%r14d
mov    %rbp,%rax
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rbp,4),%xmm1
divss  (%r8,%rsi,4),%xmm1
divss  %xmm11,%xmm1
mov    (%rdx,%rbp,8),%rbx
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rbp
cmp    %ebp,%r14d
jne    2030 <svdcmp+0xed0>
cmp    0x48(%rsp),%r9d
mov    0x10(%rsp),%r8
mov    %rax,%rbp
jle    213b <svdcmp+0xfdb>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x48(%rsp),%r15
cmp    %r15d,%r9d
mov    0x30(%rsp),%rbx
mov    0x70(%rsp),%r14
mov    0xe8(%rsp),%r11
jg     1fb0 <svdcmp+0xe50>
mov    %rcx,%rdx
mov    (%rbx,%rbp,8),%rax
movslq %r9d,%rcx
mov    %edx,%esi
sub    %r9d,%esi
mov    %r15d,%edx
sub    %r9d,%edx
mov    %r12,%rbp
and    $0x3,%esi
je     20cb <svdcmp+0xf6b>
nopl   (%rax)
mov    (%rbx,%rcx,8),%rdi
movl   $0x0,(%rdi,%rbp,4)
movl   $0x0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%esi
jne    20b0 <svdcmp+0xf50>
cmp    $0x3,%edx
mov    0x20(%rsp),%rsi
jb     1fb0 <svdcmp+0xe50>
nopl   0x0(%rax)
mov    (%rbx,%rcx,8),%rdx
movl   $0x0,(%rdx,%rbp,4)
movl   $0x0,(%rax,%rcx,4)
mov    0x8(%rbx,%rcx,8),%rdx
movl   $0x0,(%rdx,%rbp,4)
movl   $0x0,0x4(%rax,%rcx,4)
mov    0x10(%rbx,%rcx,8),%rdx
movl   $0x0,(%rdx,%rbp,4)
movl   $0x0,0x8(%rax,%rcx,4)
mov    0x18(%rbx,%rcx,8),%rdx
movl   $0x0,(%rdx,%rbp,4)
movl   $0x0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%esi
jne    20e0 <svdcmp+0xf80>
jmp    1fb0 <svdcmp+0xe50>
movslq %r9d,%r15
mov    0x70(%rsp),%rax
mov    (%rax,%rbp,8),%rsi
mov    0x48(%rsp),%rax
mov    %eax,%r11d
sub    %r9d,%r11d
mov    %r14d,%r10d
and    $0x3,%r10d
lea    0x1(%r15),%rax
mov    %rax,(%rsp)
mov    %r15,%rdx
jmp    2181 <svdcmp+0x1021>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %edx,%ecx
mov    0x10(%rsp),%r8
je     2070 <svdcmp+0xf10>
movaps %xmm3,%xmm4
xorps  %xmm1,%xmm1
test   %r10d,%r10d
je     22b0 <svdcmp+0x1150>
mov    %r10d,%eax
mov    %r15,%rbx
mov    0x30(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbx,4),%xmm2
mov    0x0(%rbp,%rbx,8),%rdi
mulss  (%rdi,%rdx,4),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rbx
add    $0xffffffff,%eax
jne    21a0 <svdcmp+0x1040>
cmp    $0x3,%r11d
jb     2227 <svdcmp+0x10c7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rbx,4),%xmm2
movss  0x4(%rsi,%rbx,4),%xmm3
mov    0x0(%rbp,%rbx,8),%rax
mov    0x8(%rbp,%rbx,8),%rdi
mulss  (%rax,%rdx,4),%xmm2
addss  %xmm1,%xmm2
mulss  (%rdi,%rdx,4),%xmm3
addss  %xmm2,%xmm3
movss  0x8(%rsi,%rbx,4),%xmm2
mov    0x10(%rbp,%rbx,8),%rax
mulss  (%rax,%rdx,4),%xmm2
movss  0xc(%rsi,%rbx,4),%xmm1
mov    0x18(%rbp,%rbx,8),%rax
mulss  (%rax,%rdx,4),%xmm1
addss  %xmm3,%xmm2
addss  %xmm2,%xmm1
add    $0x4,%rbx
cmp    %ebx,%ecx
jne    21d0 <svdcmp+0x1070>
mov    %r15,%rax
test   $0x1,%r14b
mov    %r12,%rbp
je     2253 <svdcmp+0x10f3>
mov    0x30(%rsp),%rax
mov    (%rax,%r15,8),%rax
movss  (%rax,%rbp,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rax,%rdx,4),%xmm2
movss  %xmm2,(%rax,%rdx,4)
mov    (%rsp),%rax
test   %r11d,%r11d
mov    0x30(%rsp),%rbx
movaps %xmm4,%xmm3
je     2170 <svdcmp+0x1010>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rax,8),%rdi
movss  (%rdi,%rbp,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdi,%rdx,4),%xmm2
movss  %xmm2,(%rdi,%rdx,4)
mov    0x8(%rbx,%rax,8),%rdi
movss  (%rdi,%rbp,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdi,%rdx,4),%xmm2
movss  %xmm2,(%rdi,%rdx,4)
add    $0x2,%rax
cmp    %eax,%ecx
jne    2270 <svdcmp+0x1110>
jmp    2170 <svdcmp+0x1010>
nopl   0x0(%rax)
mov    %r15,%rbx
mov    0x30(%rsp),%rbp
cmp    $0x3,%r11d
jae    21d0 <svdcmp+0x1070>
jmp    2227 <svdcmp+0x10c7>
mov    0x38(%rsp),%r8
mov    0xa0(%rsp),%r9
jmp    22e1 <svdcmp+0x1181>
xorps  %xmm3,%xmm3
mov    0x38(%rsp),%r8
xor    %r9d,%r9d
cmp    %r15d,%r13d
mov    %r15d,%eax
cmovl  %r13d,%eax
test   %eax,%eax
movss  %xmm3,0xc(%rsp)
jle    2540 <svdcmp+0x13e0>
lea    0x1(%rax),%edx
mov    %eax,%esi
not    %esi
mov    0x48(%rsp),%rcx
add    %ecx,%esi
mov    %rsi,0xa0(%rsp)
movslq %ecx,%rbx
mov    %eax,%r10d
lea    (%r14,%r10,8),%r15
mov    %r13d,%r12d
sub    %eax,%r12d
add    $0x1,%r12d
xor    %esi,%esi
xorps  %xmm4,%xmm4
movss  0xd10(%rip),%xmm5
mov    %r10,%rbp
mov    %edx,0x58(%rsp)
mov    %r10,0xc0(%rsp)
jmp    237e <svdcmp+0x121e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbp,8),%rax
movss  (%rax,%rbp,4),%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rsi
add    $0xffffffff,%edx
add    $0xffffffffffffffff,%rbp
add    $0xfffffffffffffff8,%r15
add    $0x1,%r12
cmp    %r10,%rsi
je     2540 <svdcmp+0x13e0>
movss  (%r8,%rbp,4),%xmm1
cmp    %rbx,%rbp
jge    24b0 <svdcmp+0x1350>
mov    0xa0(%rsp),%rax
add    %esi,%eax
mov    %edx,(%rsp)
lea    0x4(,%rax,4),%rdx
mov    0x58(%rsp),%eax
sub    %esi,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
add    (%r14,%rbp,8),%rdi
mov    %rsi,0x20(%rsp)
xor    %esi,%esi
mov    %r9,%r14
movss  %xmm1,0x80(%rsp)
call   1050 <memset@plt>
movss  0x80(%rsp),%xmm1
mov    (%rsp),%edx
movss  0xc61(%rip),%xmm5
xorps  %xmm4,%xmm4
mov    0x20(%rsp),%rsi
mov    0xc0(%rsp),%r10
mov    0xe8(%rsp),%r11
mov    %r14,%r9
movss  0xc(%rsp),%xmm3
mov    0x70(%rsp),%r14
mov    0x38(%rsp),%r8
ucomiss %xmm4,%xmm1
jne    2415 <svdcmp+0x12b5>
jnp    24d0 <svdcmp+0x1370>
movslq %edx,%rcx
lea    -0x1(%rcx),%rax
movaps %xmm5,%xmm0
divss  %xmm1,%xmm0
mov    (%r14,%rbp,8),%rdx
jmp    2440 <svdcmp+0x12e0>
nopl   0x0(%rax)
lea    0x1(%rcx),%rsi
cmp    %rbx,%rcx
mov    %rsi,%rcx
jge    2500 <svdcmp+0x13a0>
xorps  %xmm1,%xmm1
cmp    %r11,%rbp
jge    246c <svdcmp+0x130c>
xorps  %xmm1,%xmm1
mov    %rax,%rsi
xchg   %ax,%ax
mov    0x8(%r14,%rsi,8),%rdi
movss  (%rdi,%rbp,4),%xmm2
mulss  (%rdi,%rcx,4),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %r11,%rsi
jl     2450 <svdcmp+0x12f0>
cmp    %r11,%rbp
jg     2430 <svdcmp+0x12d0>
divss  (%rdx,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%r15,%rsi,8),%rdi
movss  (%rdi,%rbp,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdi,%rcx,4),%xmm2
movss  %xmm2,(%rdi,%rcx,4)
add    $0x1,%rsi
cmp    %esi,%r12d
jne    2480 <svdcmp+0x1320>
jmp    2430 <svdcmp+0x12d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomiss %xmm4,%xmm1
jne    24b7 <svdcmp+0x1357>
jnp    24d0 <svdcmp+0x1370>
movaps %xmm5,%xmm0
divss  %xmm1,%xmm0
cmp    %r11,%rbp
jg     2350 <svdcmp+0x11f0>
jmp    2511 <svdcmp+0x13b1>
nopl   0x0(%rax)
cmp    %r11,%rbp
jg     2350 <svdcmp+0x11f0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rcx
movl   $0x0,(%rcx,%rbp,4)
add    $0x1,%rax
cmp    %eax,%r12d
jne    24e0 <svdcmp+0x1380>
jmp    2350 <svdcmp+0x11f0>
nopl   0x0(%rax)
mov    0x20(%rsp),%rsi
mov    (%rsp),%edx
cmp    %r11,%rbp
jg     2350 <svdcmp+0x11f0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rax,8),%rcx
movss  (%rcx,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rbp,4)
add    $0x1,%rax
cmp    %eax,%r12d
jne    2520 <svdcmp+0x13c0>
jmp    2350 <svdcmp+0x11f0>
test   %r9b,%r9b
mov    0x30(%rsp),%rbp
mov    0x10(%rsp),%rbx
je     2c91 <svdcmp+0x1b31>
mov    0x48(%rsp),%rax
movslq %eax,%rcx
mov    %rcx,0x98(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
movsd  %xmm0,0xf0(%rsp)
lea    0x1(%r13),%r14d
lea    0x1(%rax),%r15d
lea    -0x1(%r15),%rax
lea    -0x2(%r15),%rcx
mov    %rcx,0x40(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x50(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0xd0(%rsp)
addq   $0xffffffffffffffff,0x18(%rsp)
movaps 0xa55(%rip),%xmm1
movaps 0xa7e(%rip),%xmm2
mov    %r13,0x158(%rsp)
jmp    25d0 <svdcmp+0x1470>
nopl   0x0(%rax)
addq   $0xffffffffffffffff,0x18(%rsp)
cmp    $0x1,%rsi
jle    2c91 <svdcmp+0x1b31>
mov    0x98(%rsp),%rsi
lea    -0x1(%rsi),%rax
mov    %rax,0x98(%rsp)
movl   $0x1,0x68(%rsp)
mov    %rsi,0x78(%rsp)
jmp    264c <svdcmp+0x14ec>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp),%rbx
mov    0x60(%rsp),%rax
movl   $0x0,(%rbx,%rax,4)
movss  %xmm6,(%rbx,%rsi,4)
movss  %xmm2,(%r8,%rsi,4)
mov    0x68(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x68(%rsp)
cmp    $0x1f,%eax
mov    0x158(%rsp),%r13
movss  0xc(%rsp),%xmm3
movaps 0x9c1(%rip),%xmm1
movaps 0x9ea(%rip),%xmm2
je     25c0 <svdcmp+0x1460>
mov    0x18(%rsp),%rax
mov    %esi,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x4(%rbx,%rax,4),%xmm0
andps  %xmm1,%xmm0
addss  %xmm3,%xmm0
ucomiss %xmm3,%xmm0
jne    2678 <svdcmp+0x1518>
jnp    27f8 <svdcmp+0x1698>
mov    %eax,%ecx
movss  (%r8,%rcx,4),%xmm0
andps  %xmm1,%xmm0
addss  %xmm3,%xmm0
ucomiss %xmm3,%xmm0
jne    268e <svdcmp+0x152e>
jnp    26a5 <svdcmp+0x1545>
lea    -0x1(%r12),%ecx
add    $0xffffffffffffffff,%rax
cmp    $0x2,%r12d
mov    %ecx,%r12d
jge    2660 <svdcmp+0x1500>
xor    %eax,%eax
xor    %r12d,%r12d
movslq %r12d,%rbp
cmp    %rbp,%rsi
jge    26c0 <svdcmp+0x1560>
mov    0x30(%rsp),%rbp
jmp    27f8 <svdcmp+0x1698>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rbx
xorps  %xmm5,%xmm5
movss  0x972(%rip),%xmm4
jmp    26eb <svdcmp+0x158b>
lea    0x1(%rbp),%rax
mov    0x78(%rsp),%rsi
cmp    %rsi,%rbp
mov    %rax,%rbp
movss  0xc(%rsp),%xmm3
jge    27e0 <svdcmp+0x1680>
mov    0x10(%rsp),%rax
movss  (%rax,%rbp,4),%xmm0
mulss  %xmm0,%xmm4
mulss  %xmm0,%xmm5
movss  %xmm5,(%rax,%rbp,4)
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
movaps %xmm0,%xmm1
andps  0x8fd(%rip),%xmm1
addsd  0xf0(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm3
jne    272b <svdcmp+0x15cb>
jnp    27e0 <svdcmp+0x1680>
movss  (%r8,%rbp,4),%xmm1
movss  %xmm1,(%rsp)
cvtss2sd %xmm1,%xmm1
mov    $0x2,%al
movaps %xmm4,0x20(%rsp)
call   1060 <pythag@plt>
movss  (%rsp),%xmm5
movaps 0x20(%rsp),%xmm4
mov    0x70(%rsp),%rdx
mov    0x38(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%r8,%rbp,4)
movss  0x8d1(%rip),%xmm1
divss  %xmm0,%xmm1
mulss  %xmm1,%xmm5
xorps  0x8b2(%rip),%xmm4
mulss  %xmm1,%xmm4
test   %r13d,%r13d
jle    26d0 <svdcmp+0x1570>
mov    $0x1,%eax
mov    (%rdx,%rax,8),%rcx
movss  (%rcx,%rbx,4),%xmm0
movss  (%rcx,%rbp,4),%xmm1
movaps %xmm4,%xmm2
mulss  %xmm1,%xmm2
movaps %xmm4,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rcx,%rbx,4)
mulss  %xmm5,%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%rbp,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    2790 <svdcmp+0x1630>
jmp    26d0 <svdcmp+0x1570>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rbp
mov    0x10(%rsp),%rbx
movaps 0x80f(%rip),%xmm1
movaps 0x838(%rip),%xmm2
movss  (%r8,%rsi,4),%xmm4
mov    %r12d,%eax
cmp    %rax,%rsi
je     2bd0 <svdcmp+0x1a70>
cmpl   $0x1e,0x68(%rsp)
movaps %xmm4,0x20(%rsp)
jne    2833 <svdcmp+0x16d3>
lea    0x833(%rip),%rdi
xor    %eax,%eax
call   1030 <nrerror@plt>
movaps 0x20(%rsp),%xmm4
mov    0x78(%rsp),%rsi
mov    0x38(%rsp),%r8
movslq %r12d,%r12
movss  (%r8,%r12,4),%xmm0
movaps %xmm0,0x80(%rsp)
mov    0x98(%rsp),%rax
movss  (%r8,%rax,4),%xmm0
movss  (%rbx,%rax,4),%xmm1
movss  (%rbx,%rsi,4),%xmm2
movaps %xmm4,%xmm3
addss  %xmm0,%xmm3
xorps  %xmm5,%xmm5
cvtss2sd %xmm0,%xmm5
subss  %xmm4,%xmm0
mulss  %xmm0,%xmm3
movaps %xmm1,%xmm0
subss  %xmm2,%xmm0
addss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm3,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
movsd  %xmm1,0x58(%rsp)
addsd  %xmm1,%xmm1
movsd  %xmm5,(%rsp)
mulsd  %xmm5,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc0(%rsp)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xa0(%rsp)
movsd  0x77c(%rip),%xmm1
mov    $0x2,%al
call   1060 <pythag@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0xc0(%rsp),%xmm1
ucomiss 0x75a(%rip),%xmm1
andps  0x70f(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
jae    28fe <svdcmp+0x179e>
xorps  0x722(%rip),%xmm0
movaps 0x80(%rsp),%xmm2
movaps %xmm2,%xmm1
movaps 0x20(%rsp),%xmm3
subss  %xmm3,%xmm1
addss  %xmm2,%xmm3
mulss  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addsd  0xa0(%rsp),%xmm0
movsd  (%rsp),%xmm3
divsd  %xmm0,%xmm3
movsd  0x58(%rsp),%xmm0
subsd  %xmm0,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
divsd  %xmm0,%xmm3
cvtsd2ss %xmm3,%xmm6
mov    0x78(%rsp),%rsi
cmp    %r12,%rsi
mov    0x38(%rsp),%r8
mov    %r12,0x60(%rsp)
jle    2600 <svdcmp+0x14a0>
movss  0x6cc(%rip),%xmm0
movaps %xmm0,%xmm5
movaps %xmm0,%xmm4
jmp    29ba <svdcmp+0x185a>
nopl   0x0(%rax)
movss  0x20(%rsp),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm4,%xmm6
movss  (%rsp),%xmm3
mulss  %xmm3,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm3
movaps %xmm4,%xmm2
mulss  %xmm1,%xmm2
subss  %xmm3,%xmm2
mov    0x58(%rsp),%r12
cmp    %rsi,%r12
jge    2600 <svdcmp+0x14a0>
movaps %xmm6,0xc0(%rsp)
movaps %xmm2,0x80(%rsp)
lea    0x1(%r12),%rax
mov    %rax,0x58(%rsp)
mov    %eax,%r13d
mov    0x10(%rsp),%rbx
movss  (%rbx,%r13,4),%xmm0
movss  (%r8,%r13,4),%xmm1
movss  %xmm1,0x20(%rsp)
mulss  %xmm0,%xmm5
movaps %xmm5,0xa0(%rsp)
mulss  %xmm0,%xmm4
movss  %xmm4,(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm5,%xmm1
mov    $0x2,%al
call   1060 <pythag@plt>
movaps 0x80(%rsp),%xmm5
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rbx,%r12,4)
movaps 0xc0(%rsp),%xmm6
unpcklps 0xa0(%rsp),%xmm6
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm6
movaps %xmm6,%xmm0
shufps $0x55,%xmm6,%xmm0
movss  (%rsp),%xmm4
movaps %xmm4,%xmm1
mulss  %xmm0,%xmm1
movss  0x20(%rsp),%xmm3
movaps %xmm3,%xmm7
mulss  %xmm0,%xmm7
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
addss  %xmm1,%xmm5
movaps %xmm4,%xmm1
mulss  %xmm6,%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,(%rsp)
movaps %xmm3,%xmm1
mulss  %xmm6,%xmm1
movss  %xmm1,0x20(%rsp)
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%rbp,%rax,8),%rcx
movss  (%rcx,%r12,4),%xmm1
movss  (%rcx,%r13,4),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm2,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm6,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%r12,4)
mulss  %xmm6,%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,(%rcx,%r13,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    2aa0 <svdcmp+0x1940>
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm7,%xmm1
mov    $0x2,%al
movaps %xmm5,0x80(%rsp)
movaps %xmm6,0xa0(%rsp)
movaps %xmm7,0xc0(%rsp)
call   1060 <pythag@plt>
movaps 0xa0(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x38(%rsp),%r8
movss  %xmm0,(%r8,%r12,4)
test   %eax,%eax
je     2b52 <svdcmp+0x19f2>
movss  0x509(%rip),%xmm4
divss  %xmm0,%xmm4
movaps 0x80(%rsp),%xmm0
unpcklps 0xc0(%rsp),%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
movaps %xmm4,%xmm5
shufps $0x55,%xmm4,%xmm5
cmpl   $0x0,0x158(%rsp)
mov    0x70(%rsp),%rdx
mov    0x78(%rsp),%rsi
jle    2980 <svdcmp+0x1820>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
mov    (%rdx,%rax,8),%rcx
movss  (%rcx,%r12,4),%xmm0
movss  (%rcx,%r13,4),%xmm1
movaps %xmm5,%xmm2
mulss  %xmm1,%xmm2
movaps %xmm5,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm4,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rcx,%r12,4)
mulss  %xmm4,%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%r13,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    2b80 <svdcmp+0x1a20>
jmp    2980 <svdcmp+0x1820>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
ucomiss %xmm4,%xmm0
jbe    25c0 <svdcmp+0x1460>
xorps  %xmm2,%xmm4
movss  %xmm4,(%r8,%rsi,4)
mov    $0x1,%eax
cmpq   $0x3,0x40(%rsp)
jb     2c55 <svdcmp+0x1af5>
xor    %eax,%eax
mov    0xd0(%rsp),%rdx
nopl   0x0(%rax)
mov    0x8(%rbp,%rax,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
mov    0x10(%rbp,%rax,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
mov    0x18(%rbp,%rax,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
mov    0x20(%rbp,%rax,8),%rcx
movss  (%rcx,%rsi,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    2c00 <svdcmp+0x1aa0>
add    $0x1,%rax
cmpq   $0x0,0x50(%rsp)
je     25c0 <svdcmp+0x1460>
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
xchg   %ax,%ax
mov    (%rax,%rcx,8),%rdx
movss  (%rdx,%rsi,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rcx
cmp    %rcx,0x50(%rsp)
jne    2c70 <svdcmp+0x1b10>
jmp    25c0 <svdcmp+0x1460>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    0x48(%rsp),%rdx
xor    %eax,%eax
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>

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

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