int relax_svd(double *U, int m, int n, int ustride, double *V, int vstride,
              double *w, double *rv1) {
  int flag, i, its, j, o, k, l, nm;
  double anorm, c, f, g, h, s, scale, x, y, z;
  if (m < n) {
    return -1;
  }
  g = scale = anorm = 0.0;
  for (i = 0; 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(U[k * ustride + i]);
      if (scale != 0.0) {
        for (k = i; k < m; k++) {
          U[k * ustride + i] /= scale;
          s += U[k * ustride + i] * U[k * ustride + i];
        }
        f = U[i * ustride + i];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        U[i * ustride + i] = f - g;
        for (j = l; j < n; j++) {
          for (s = 0.0, k = i; k < m; k++)
            s += U[k * ustride + i] * U[k * ustride + j];
          f = s / h;
          for (k = i; k < m; k++)
            U[k * ustride + j] += f * U[k * ustride + i];
        }
        for (k = i; k < m; k++)
          U[k * ustride + i] *= scale;
      }
    }
    w[i] = scale * g;
    g = s = scale = 0.0;
    if (i < m && i != n - 1) {
      for (k = l; k < n; k++)
        scale += fabs(U[i * ustride + k]);
      if (scale) {
        for (k = l; k < n; k++) {
          U[i * ustride + k] /= scale;
          s += U[i * ustride + k] * U[i * ustride + k];
        }
        f = U[i * ustride + l];
        g = -((f) >= 0.0 ? fabs(sqrt(s)) : -fabs(sqrt(s)));
        h = f * g - s;
        U[i * ustride + l] = f - g;
        for (k = l; k < n; k++)
          rv1[k] = U[i * ustride + k] / h;
        for (j = l; j < m; j++) {
          for (s = 0.0, k = l; k < n; k++)
            s += U[j * ustride + k] * U[i * ustride + k];
          for (k = l; k < n; k++)
            U[j * ustride + k] += s * rv1[k];
        }
        for (k = l; k < n; k++)
          U[i * ustride + k] *= scale;
      }
    }
    double tmp = fabs(w[i]) + fabs(rv1[i]);
    anorm = anorm > tmp ? anorm : tmp;
  }
  for (i = n - 1; i >= 0; i--) {
    if (i < n - 1) {
      if (g != 0.0) {
        for (j = l; j < n; j++)
          V[j * vstride + i] = (U[i * ustride + j] / U[i * ustride + l]) / g;
        for (j = l; j < n; j++) {
          for (s = 0.0, k = l; k < n; k++)
            s += U[i * ustride + k] * V[k * vstride + j];
          for (k = l; k < n; k++)
            V[k * vstride + j] += s * V[k * vstride + i];
        }
      }
      for (j = l; j < n; j++)
        V[i * vstride + j] = V[j * vstride + i] = 0.0;
    }
    V[i * vstride + i] = 1.0;
    g = rv1[i];
    l = i;
  }
  for (i = n - 1; i >= 0; i--) {
    l = i + 1;
    g = w[i];
    for (j = l; j < n; j++)
      U[i * ustride + j] = 0.0;
    if (g != 0.0) {
      g = 1.0 / g;
      for (j = l; j < n; j++) {
        for (s = 0.0, k = l; k < m; k++)
          s += U[k * ustride + i] * U[k * ustride + j];
        f = (s / U[i * ustride + i]) * g;
        for (k = i; k < m; k++)
          U[k * ustride + j] += f * U[k * ustride + i];
      }
      for (j = i; j < m; j++)
        U[j * ustride + i] *= g;
    } else {
      for (j = i; j < m; j++)
        U[j * ustride + i] = 0.0;
    }
    U[i * ustride + i] += 1.0;
  }
  for (k = n - 1; k >= 0; k--) {
    for (its = 1; its <= 30; its++) {
      flag = 1;
      for (l = k; l >= 0; l--) {
        nm = l - 1;
        if (fabs(rv1[l]) + anorm == anorm) {
          flag = 0;
          break;
        }
        if (fabs(w[nm]) + anorm == anorm)
          break;
      }
      if (flag != 0) {
        c = 0.0;
        s = 1.0;
        for (i = l; i < k; i++) {
          f = s * rv1[i];
          rv1[i] = c * rv1[i];
          if (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 = U[j * ustride + nm];
            z = U[j * ustride + i];
            U[j * ustride + nm] = y * c + z * s;
            U[j * ustride + i] = z * c - y * s;
          }
        }
      }
      z = w[k];
      if (l == k) {
        if (z < 0.0) {
          w[k] = -z;
          for (j = 0; j < n; j++)
            V[j * vstride + k] = -V[j * vstride + k];
        }
        break;
      }
      if (its == 30)
        return -1;
      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 (o = 0; o < n; o++) {
          x = V[o * vstride + j];
          z = V[o * vstride + i];
          V[o * vstride + j] = x * c + z * s;
          V[o * vstride + i] = z * c - x * s;
        }
        z = pythag(f, h);
        w[j] = z;
        if (z != 0.0) {
          z = 1.0 / z;
          c = f * z;
          s = h * z;
        }
        f = c * g + s * y;
        x = c * y - s * g;
        for (o = 0; o < m; o++) {
          y = U[o * ustride + j];
          z = U[o * ustride + i];
          U[o * ustride + j] = y * c + z * s;
          U[o * ustride + i] = z * c - y * s;
        }
      }
      rv1[l] = 0.0;
      rv1[k] = f;
      w[k] = x;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<relax_svd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1160 <relax_svd+0x40>
movl   $0xffffffff,-0x4(%rbp)
jmp    27f2 <relax_svd+0x16d2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1950 <relax_svd+0x830>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    150d <relax_svd+0x3ed>
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1229 <relax_svd+0x109>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1df9(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11de <relax_svd+0xbe>
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1249 <relax_svd+0x129>
jp     1249 <relax_svd+0x129>
jmp    1508 <relax_svd+0x3e8>
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ce <relax_svd+0x1ae>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    124f <relax_svd+0x12f>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     131d <relax_svd+0x1fd>
movsd  -0x80(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps 0x1cf4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1351 <relax_svd+0x231>
movsd  -0x80(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps 0x1cd2(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    14c0 <relax_svd+0x3a0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1440 <relax_svd+0x320>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13e8 <relax_svd+0x2c8>
movsd  -0x80(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14ad <relax_svd+0x38d>
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1455 <relax_svd+0x335>
jmp    14b2 <relax_svd+0x392>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13ce <relax_svd+0x2ae>
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1503 <relax_svd+0x3e3>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14c6 <relax_svd+0x3a6>
jmp    1508 <relax_svd+0x3e8>
jmp    150d <relax_svd+0x3ed>
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18c4 <relax_svd+0x7a4>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     18c4 <relax_svd+0x7a4>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15b0 <relax_svd+0x490>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1a72(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1565 <relax_svd+0x445>
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15d0 <relax_svd+0x4b0>
jp     15d0 <relax_svd+0x4b0>
jmp    18bf <relax_svd+0x79f>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1655 <relax_svd+0x535>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15d6 <relax_svd+0x4b6>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     16a4 <relax_svd+0x584>
movsd  -0x80(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps 0x196d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    16d8 <relax_svd+0x5b8>
movsd  -0x80(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps 0x194b(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1797 <relax_svd+0x677>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1755 <relax_svd+0x635>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1877 <relax_svd+0x757>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    180f <relax_svd+0x6ef>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17b7 <relax_svd+0x697>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1864 <relax_svd+0x744>
movsd  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1815 <relax_svd+0x6f5>
jmp    1869 <relax_svd+0x749>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    179d <relax_svd+0x67d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18ba <relax_svd+0x79a>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    187d <relax_svd+0x75d>
jmp    18bf <relax_svd+0x79f>
jmp    18c4 <relax_svd+0x7a4>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1728(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1710(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
jbe    1925 <relax_svd+0x805>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1935 <relax_svd+0x815>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1182 <relax_svd+0x62>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1b81 <relax_svd+0xa61>
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b3d <relax_svd+0xa1d>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1991 <relax_svd+0x871>
jp     1991 <relax_svd+0x871>
jmp    1ae6 <relax_svd+0x9c6>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    19f8 <relax_svd+0x8d8>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1997 <relax_svd+0x877>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ae1 <relax_svd+0x9c1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a70 <relax_svd+0x950>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a18 <relax_svd+0x8f8>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ace <relax_svd+0x9ae>
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a76 <relax_svd+0x956>
jmp    1ad3 <relax_svd+0x9b3>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    19fe <relax_svd+0x8de>
jmp    1ae6 <relax_svd+0x9c6>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b38 <relax_svd+0xa18>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aec <relax_svd+0x9cc>
jmp    1b3d <relax_svd+0xa1d>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x14ba(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1959 <relax_svd+0x839>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1dd9 <relax_svd+0xcb9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1be8 <relax_svd+0xac8>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1bb5 <relax_svd+0xa95>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c05 <relax_svd+0xae5>
jp     1c05 <relax_svd+0xae5>
jmp    1d6a <relax_svd+0xc4a>
movsd  0x1403(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d25 <relax_svd+0xc05>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c8f <relax_svd+0xb6f>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c37 <relax_svd+0xb17>
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d12 <relax_svd+0xbf2>
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1cba <relax_svd+0xb9a>
jmp    1d17 <relax_svd+0xbf7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c1d <relax_svd+0xafd>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d65 <relax_svd+0xc45>
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d2b <relax_svd+0xc0b>
jmp    1da8 <relax_svd+0xc88>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1da3 <relax_svd+0xc83>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d70 <relax_svd+0xc50>
jmp    1da8 <relax_svd+0xc88>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x124f(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1b8a <relax_svd+0xa6a>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     27eb <relax_svd+0x16cb>
movl   $0x1,-0x38(%rbp)
cmpl   $0x1e,-0x38(%rbp)
jg     27d8 <relax_svd+0x16b8>
movl   $0x1,-0x30(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     1e9d <relax_svd+0xd7d>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x11cf(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jne    1e57 <relax_svd+0xd37>
jp     1e57 <relax_svd+0xd37>
movl   $0x0,-0x30(%rbp)
jmp    1e9d <relax_svd+0xd7d>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1195(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jne    1e8a <relax_svd+0xd6a>
jp     1e8a <relax_svd+0xd6a>
jmp    1e9d <relax_svd+0xd7d>
jmp    1e8f <relax_svd+0xd6f>
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    1e0a <relax_svd+0xcea>
cmpl   $0x0,-0x30(%rbp)
je     20b0 <relax_svd+0xf90>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x1159(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    20ab <relax_svd+0xf8b>
movsd  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movaps 0x10f0(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jne    1f2f <relax_svd+0xe0f>
jp     1f2f <relax_svd+0xe0f>
jmp    20ab <relax_svd+0xf8b>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
mov    $0x2,%al
call   1030 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x109b(%rip),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2098 <relax_svd+0xf78>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
movsd  -0x98(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1fbb <relax_svd+0xe9b>
jmp    209d <relax_svd+0xf7d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ec2 <relax_svd+0xda2>
jmp    20b0 <relax_svd+0xf90>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jne    217c <relax_svd+0x105c>
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    2177 <relax_svd+0x1057>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2172 <relax_svd+0x1052>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2115 <relax_svd+0xff5>
jmp    2177 <relax_svd+0x1057>
jmp    27d8 <relax_svd+0x16b8>
cmpl   $0x1e,-0x38(%rbp)
jne    2192 <relax_svd+0x1072>
movl   $0xffffffff,-0x4(%rbp)
jmp    27f2 <relax_svd+0x16d2>
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
addsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
subsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm3
addsd  -0x78(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xde7(%rip),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  0xdbc(%rip),%xmm1
mov    $0x2,%al
call   1030 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     22ed <relax_svd+0x11cd>
movsd  -0x70(%rbp),%xmm0
movaps 0xd24(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    231c <relax_svd+0x11fc>
movsd  -0x70(%rbp),%xmm0
movaps 0xd07(%rip),%xmm1
pand   %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0xf0(%rbp),%xmm5
ff
addsd  %xmm5,%xmm4
divsd  %xmm4,%xmm3
subsd  -0x78(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  0xc96(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xc89(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2793 <relax_svd+0x1673>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
mov    $0x2,%al
call   1030 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    25ac <relax_svd+0x148c>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    24cf <relax_svd+0x13af>
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
mov    $0x2,%al
call   1030 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    25fe <relax_svd+0x14de>
jp     25fe <relax_svd+0x14de>
jmp    263a <relax_svd+0x151a>
movsd  0xa0a(%rip),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2780 <relax_svd+0x1660>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    26a3 <relax_svd+0x1583>
jmp    2785 <relax_svd+0x1665>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2392 <relax_svd+0x1272>
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1df3 <relax_svd+0xcd3>
jmp    27dd <relax_svd+0x16bd>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1de2 <relax_svd+0xcc2>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<relax_svd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
cmp    %edx,%esi
jge    114f <relax_svd+0x1f>
mov    $0xffffffff,%eax
jmp    3062 <relax_svd+0x1f32>
mov    %edx,%ebp
mov    %rdi,0x10(%rsp)
test   %edx,%edx
jle    3060 <relax_svd+0x1f30>
mov    %r9d,0x138(%rsp)
mov    %r8,0x48(%rsp)
mov    0x228(%rsp),%r8
lea    -0x1(%rbp),%eax
mov    %rax,0xd0(%rsp)
mov    %ecx,0xdc(%rsp)
movslq %ecx,%rax
movslq %esi,%r13
mov    %ebp,%r15d
mov    %esi,%ecx
mov    %rcx,0x140(%rsp)
lea    0x1(%rax),%rdx
mov    %rdx,0x188(%rsp)
lea    0x0(,%rax,8),%r14
lea    0x8(,%rax,8),%rcx
mov    %rcx,0xe0(%rsp)
lea    (%rax,%r15,1),%rcx
mov    %rcx,0x1e0(%rsp)
lea    (%r8,%r15,8),%rdx
mov    %rdx,0x190(%rsp)
mov    0x10(%rsp),%rbx
lea    0x8(%rbx),%r9
lea    -0x1(%r15),%rdx
mov    %rdx,0x108(%rsp)
mov    %r15,%rdx
neg    %rdx
mov    %rdx,0x50(%rsp)
xorpd  %xmm9,%xmm9
movapd 0x2dff(%rip),%xmm7
movapd 0x2df6(%rip),%xmm10
xorpd  %xmm12,%xmm12
xorpd  %xmm11,%xmm11
xorpd  %xmm5,%xmm5
lea    -0x2(%r15),%rdx
mov    %rdx,0xc8(%rsp)
mov    %rbp,0x80(%rsp)
lea    0x18(%r8),%r10
lea    -0x3(%r15),%rcx
mov    %rcx,0x58(%rsp)
lea    (%rbx,%rax,8),%rcx
mov    %rcx,0x28(%rsp)
mov    %rax,0xa0(%rsp)
lea    0x38(%rbx,%rax,8),%rdx
lea    0x38(%r8),%rbp
mov    %rbp,0x40(%rsp)
lea    -0x5(%r15),%rbp
mov    $0x1,%ecx
mov    %rcx,0x30(%rsp)
xor    %r11d,%r11d
mov    %rbx,%rax
mov    %r9,%r12
mov    %r15,0x110(%rsp)
mov    %r9,0x1d8(%rsp)
mov    %r9,%rdi
mov    %rbp,%r9
mov    0x140(%rsp),%rcx
mov    %rcx,0x60(%rsp)
mov    %rbx,%rbp
mov    %esi,0x13c(%rsp)
mov    0x28(%rsp),%rsi
mov    %rdx,%rcx
mov    0x58(%rsp),%rdx
mov    %r15,0x90(%rsp)
mov    %r13,0x148(%rsp)
jmp    1380 <relax_svd+0x250>
xchg   %ax,%ax
mov    0x220(%rsp),%rbx
mov    %r12,0xb0(%rsp)
mov    %r8,%r12
mov    %rdx,%r8
mov    %rsi,%rdx
mov    %rdi,%rsi
mov    %r9,%rdi
mov    %r10,%r9
lea    (%rbx,%r11,8),%r10
movq   $0x0,(%rbx,%r11,8)
mov    %r10,%rbx
mov    %r9,%r10
mov    %rdi,%r9
mov    %rsi,%rdi
mov    %rdx,%rsi
mov    %r8,%rdx
mov    %r12,%r8
mov    0xb0(%rsp),%r12
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
movsd  (%rbx),%xmm0
movsd  (%r8,%r11,8),%xmm1
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
maxsd  %xmm1,%xmm5
addq   $0x1,0x30(%rsp)
mov    0xe0(%rsp),%rbx
add    %rbx,%rbp
addq   $0xffffffffffffffff,0x60(%rsp)
add    %rbx,%rdi
addq   $0xffffffffffffffff,0x110(%rsp)
add    $0x8,%r10
add    $0xffffffffffffffff,%rdx
add    %r14,%r12
add    %r14,%rsi
add    %rbx,%rcx
addq   $0x8,0x40(%rsp)
add    $0xffffffffffffffff,%r9
add    %r14,%rax
mov    0x8(%rsp),%r11
cmp    %r15,%r11
je     1f65 <relax_svd+0xe35>
mulsd  %xmm11,%xmm12
lea    0x1(%r11),%rbx
mov    %rbx,0x8(%rsp)
movsd  %xmm12,(%r8,%r11,8)
cmp    %r13,%r11
jge    12c0 <relax_svd+0x190>
mov    %rax,0xb0(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %r9,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x198(%rsp)
mov    %rdx,%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x1c8(%rsp)
mov    0x108(%rsp),%rcx
sub    %r11,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,0x1a8(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0xc0(%rsp)
mov    %r11,%rax
not    %rax
lea    (%rax,%r15,1),%rcx
add    $0xfffffffffffffffe,%rcx
add    %r15,%rax
mov    %rax,0x1a0(%rsp)
mov    %rcx,0x1d0(%rsp)
mov    %rcx,%rax
shr    %rax
add    $0x1,%rax
mov    %rax,0x158(%rsp)
mov    0x30(%rsp),%rax
lea    (%r8,%rax,8),%rax
mov    %rax,0x100(%rsp)
mov    0xe0(%rsp),%rcx
imul   %r11,%rcx
mov    0x1d8(%rsp),%rax
mov    %rcx,0x130(%rsp)
add    %rcx,%rax
mov    %rax,0x160(%rsp)
mov    %r11,%rcx
imul   0xa0(%rsp),%rcx
lea    (%rcx,%r15,1),%rax
mov    0x10(%rsp),%rbx
lea    (%rbx,%rax,8),%rax
mov    %rax,0x168(%rsp)
mov    %rcx,0x98(%rsp)
mov    0x1e0(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xf8(%rsp)
xorpd  %xmm4,%xmm4
mov    0x60(%rsp),%rax
mov    %rbp,%rcx
nopl   0x0(%rax)
movsd  (%rcx),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm4
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    14c0 <relax_svd+0x390>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm4
xorpd  %xmm0,%xmm0
jne    14eb <relax_svd+0x3bb>
jnp    16ff <relax_svd+0x5cf>
xorpd  %xmm3,%xmm3
mov    0x60(%rsp),%rax
mov    %rbp,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rcx)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    1500 <relax_svd+0x3d0>
mov    %r11d,%eax
imul   0xdc(%rsp),%eax
movslq %eax,%r15
add    %r11,%r15
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm6
ucomisd %xmm9,%xmm3
mov    %rdx,0x58(%rsp)
mov    %rsi,0x28(%rsp)
jb     1556 <relax_svd+0x426>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    15f9 <relax_svd+0x4c9>
movapd %xmm3,%xmm0
movsd  %xmm5,0x20(%rsp)
mov    %r10,0x170(%rsp)
mov    %r9,%rbx
mov    %rdi,0x78(%rsp)
mov    %r11,0x88(%rsp)
movsd  %xmm4,0x128(%rsp)
movsd  %xmm6,0x1b0(%rsp)
movsd  %xmm3,0x150(%rsp)
call   1050 <sqrt@plt>
movsd  0x150(%rsp),%xmm3
movsd  0x1b0(%rsp),%xmm6
movsd  0x128(%rsp),%xmm4
mov    0x10(%rsp),%rcx
mov    0x88(%rsp),%r11
xorpd  %xmm11,%xmm11
mov    %rbx,%r9
mov    0x170(%rsp),%r10
movapd 0x2a27(%rip),%xmm10
xorpd  %xmm9,%xmm9
movsd  0x20(%rsp),%xmm5
movapd 0x2a14(%rip),%xmm7
mov    0x78(%rsp),%rdi
mov    0x228(%rsp),%r8
mov    0x8(%rsp),%rax
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
movapd 0x2a01(%rip),%xmm8
orpd   %xmm8,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm6,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,%xmm0
xorpd  %xmm8,%xmm0
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rcx,%r15,8)
mov    0x90(%rsp),%r15
cmp    %r15,%rax
jae    16ca <relax_svd+0x59a>
mulsd  %xmm0,%xmm6
subsd  %xmm3,%xmm6
mov    %rdi,%rax
mov    0x30(%rsp),%rcx
nopl   (%rax)
xorpd  %xmm1,%xmm1
mov    0x60(%rsp),%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm1
add    %r14,%rsi
add    $0xffffffffffffffff,%rdx
jne    1670 <relax_svd+0x540>
divsd  %xmm6,%xmm1
mov    0x60(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rsi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %r14,%rsi
add    $0xffffffffffffffff,%rdx
jne    16a0 <relax_svd+0x570>
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r15,%rcx
jne    1660 <relax_svd+0x530>
mov    0x60(%rsp),%rax
mov    %rbp,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    16e0 <relax_svd+0x5b0>
mov    0x58(%rsp),%rdx
mov    0x28(%rsp),%rsi
mulsd  %xmm0,%xmm4
mov    0x220(%rsp),%rax
lea    (%rax,%r11,8),%rbx
movsd  %xmm4,(%rax,%r11,8)
cmp    0xd0(%rsp),%r11
mov    0xa8(%rsp),%rcx
mov    0xb0(%rsp),%rax
je     1310 <relax_svd+0x1e0>
cmp    %r15,0x8(%rsp)
jae    1310 <relax_svd+0x1e0>
mov    %rdi,0x78(%rsp)
xorpd  %xmm12,%xmm12
mov    $0x1,%eax
mov    0x110(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rax,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x1,%rax
cmp    %rax,%rdi
jne    1760 <relax_svd+0x630>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm12
mov    0x78(%rsp),%rdi
jne    178f <relax_svd+0x65f>
jnp    182b <relax_svd+0x6fb>
xorpd  %xmm6,%xmm6
cmp    %r15,0x8(%rsp)
mov    0x110(%rsp),%rcx
jae    17d2 <relax_svd+0x6a2>
xorpd  %xmm6,%xmm6
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
divsd  %xmm12,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%rax
cmp    %rax,%rcx
jne    17b0 <relax_svd+0x680>
mov    0x8(%rsp),%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,1),%r15
mov    0x10(%rsp),%rax
movsd  (%rax,%r15,8),%xmm4
ucomisd %xmm9,%xmm6
mov    %rdx,0x58(%rsp)
mov    %rsi,0x28(%rsp)
mov    %r9,0x180(%rsp)
mov    %r11,0x88(%rsp)
mov    %rbx,0x128(%rsp)
jb     1838 <relax_svd+0x708>
xorps  %xmm0,%xmm0
sqrtsd %xmm6,%xmm0
mov    0x1a0(%rsp),%r11
jmp    18bb <relax_svd+0x78b>
mov    0xb0(%rsp),%rax
jmp    1315 <relax_svd+0x1e5>
movapd %xmm6,%xmm0
movsd  %xmm5,0x20(%rsp)
mov    %r10,%rbx
movapd %xmm12,0x170(%rsp)
movapd %xmm4,0x1b0(%rsp)
movsd  %xmm6,0x150(%rsp)
call   1050 <sqrt@plt>
movsd  0x150(%rsp),%xmm6
movapd 0x1b0(%rsp),%xmm4
movapd 0x170(%rsp),%xmm12
mov    0x10(%rsp),%rax
mov    0x78(%rsp),%rdi
mov    %rbx,%r10
mov    0x1a0(%rsp),%r11
movapd 0x2760(%rip),%xmm10
xorpd  %xmm9,%xmm9
movsd  0x20(%rsp),%xmm5
movapd 0x274d(%rip),%xmm7
mov    0x228(%rsp),%r8
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
movapd 0x2745(%rip),%xmm3
orpd   %xmm3,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm4,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd %xmm2,%xmm11
xorpd  %xmm3,%xmm11
addsd  %xmm4,%xmm2
movsd  %xmm2,(%rax,%r15,8)
mov    0x90(%rsp),%r15
mov    0x8(%rsp),%rdx
cmp    %r15,%rdx
jae    1a5b <relax_svd+0x92b>
mulsd  %xmm11,%xmm4
subsd  %xmm6,%xmm4
mov    0x30(%rsp),%rax
cmp    $0x2,%r11
jb     19ee <relax_svd+0x8be>
mov    0x168(%rsp),%rax
cmp    %rax,0x100(%rsp)
jae    1953 <relax_svd+0x823>
mov    0x30(%rsp),%rax
mov    0x160(%rsp),%rcx
cmp    0x190(%rsp),%rcx
jb     19ee <relax_svd+0x8be>
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmpq   $0x2,0x1d0(%rsp)
jae    196a <relax_svd+0x83a>
xor    %ecx,%ecx
jmp    19aa <relax_svd+0x87a>
xor    %ecx,%ecx
mov    0x1c8(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdi,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r10,%rcx,8)
movupd 0x10(%rdi,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r10,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rax
jne    1980 <relax_svd+0x850>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
testb  $0x1,0x158(%rsp)
01
je     19e4 <relax_svd+0x8b4>
add    0x30(%rsp),%rcx
mov    0x98(%rsp),%rdx
add    %rcx,%rdx
mov    0x10(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm1
mov    0x8(%rsp),%rdx
divpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rcx,8)
cmp    %rax,%r11
je     1a5b <relax_svd+0x92b>
add    0x30(%rsp),%rax
mov    %r15d,%edx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     1a1e <relax_svd+0x8ee>
mov    0x98(%rsp),%rcx
add    %rax,%rcx
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r8,%rax,8)
lea    0x1(%rax),%rcx
cmp    %rax,0x108(%rsp)
mov    0x8(%rsp),%rdx
je     1a5b <relax_svd+0x92b>
nopl   (%rax)
movsd  -0x8(%r12,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    1a30 <relax_svd+0x900>
mov    %r10,0x170(%rsp)
cmp    %r13,%rdx
jge    1da9 <relax_svd+0xc79>
mov    0x30(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,0x20(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0x168(%rsp)
mov    %r11,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x160(%rsp)
add    %rax,%rcx
mov    %rcx,0x158(%rsp)
mov    0xa8(%rsp),%rdi
mov    0x28(%rsp),%rsi
xor    %r9d,%r9d
jmp    1adc <relax_svd+0x9ac>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x1,%r9
add    %r14,%rsi
add    %r14,%rdi
cmp    0x140(%rsp),%rax
je     1da9 <relax_svd+0xc79>
cmp    %r15,%rdx
jae    1ac0 <relax_svd+0x990>
mov    %rax,%r10
imul   0xa0(%rsp),%r10
xorpd  %xmm1,%xmm1
mov    0x30(%rsp),%rcx
testb  $0x1,0x18(%rsp)
je     1b2f <relax_svd+0x9ff>
mov    0x30(%rsp),%rcx
add    %r10,%rcx
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
mov    0x20(%rsp),%rcx
mulsd  (%rdx,%rcx,8),%xmm0
mov    0x8(%rsp),%rdx
addsd  %xmm9,%xmm0
mov    0x168(%rsp),%rcx
movapd %xmm0,%xmm1
mov    0x88(%rsp),%rbx
cmp    %rbx,0xc8(%rsp)
mov    0x90(%rsp),%r15
je     1b7d <relax_svd+0xa4d>
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm2
movsd  0x8(%rsi,%rcx,8),%xmm0
mulsd  -0x8(%r12,%rcx,8),%xmm2
mulsd  (%r12,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rcx
movapd %xmm0,%xmm1
cmp    %rcx,%r15
jne    1b50 <relax_svd+0xa20>
cmp    %r15,%rdx
jae    1ac0 <relax_svd+0x990>
mov    0x30(%rsp),%rbx
cmp    $0x4,%r11
jb     1d20 <relax_svd+0xbf0>
mov    %r9,%rcx
imul   0xa0(%rsp),%rcx
mov    0x188(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbx
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbx
add    0x130(%rsp),%rbx
cmp    0x190(%rsp),%rbx
jae    1bec <relax_svd+0xabc>
add    0xf8(%rsp),%rcx
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    0x30(%rsp),%rbx
cmp    %rcx,0x100(%rsp)
jb     1d20 <relax_svd+0xbf0>
movapd %xmm5,%xmm8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x1a8(%rsp)
mov    0x40(%rsp),%rbx
jae    1c15 <relax_svd+0xae5>
xor    %ecx,%ecx
mov    0x10(%rsp),%rdx
jmp    1c9f <relax_svd+0xb6f>
mov    0x198(%rsp),%r8
xor    %ecx,%ecx
mov    0x10(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rbx,%rcx,8),%xmm2
movupd -0x20(%rbx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdi,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rdi,%rcx,8),%xmm2
movupd -0x10(%rdi,%rcx,8),%xmm5
movupd (%rdi,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rdi,%rcx,8)
movupd %xmm3,-0x20(%rdi,%rcx,8)
movupd -0x10(%rbx,%rcx,8),%xmm2
movupd (%rbx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rdi,%rcx,8)
movupd %xmm3,(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r8
jne    1c30 <relax_svd+0xb00>
testb  $0x1,0xc0(%rsp)
01
mov    0x228(%rsp),%r8
je     1cec <relax_svd+0xbbc>
add    0x30(%rsp),%rcx
movupd (%r8,%rcx,8),%xmm2
movupd 0x10(%r8,%rcx,8),%xmm3
add    %r10,%rcx
movupd (%rdx,%rcx,8),%xmm4
movupd 0x10(%rdx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rcx,8)
movupd %xmm3,0x10(%rdx,%rcx,8)
mov    0x158(%rsp),%rbx
cmp    0x160(%rsp),%r11
mov    0x90(%rsp),%r15
movapd %xmm8,%xmm5
mov    0x8(%rsp),%rdx
je     1ac0 <relax_svd+0x990>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15d,%edx
sub    %ebx,%edx
mov    %rbx,%rcx
test   $0x1,%dl
je     1d4f <relax_svd+0xc1f>
add    %rbx,%r10
movsd  (%r8,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x10(%rsp),%rcx
addsd  (%rcx,%r10,8),%xmm1
movsd  %xmm1,(%rcx,%r10,8)
lea    0x1(%rbx),%rcx
not    %rbx
cmp    0x50(%rsp),%rbx
mov    0x90(%rsp),%r15
mov    0x8(%rsp),%rdx
je     1ac0 <relax_svd+0x990>
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rsi,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    1d70 <relax_svd+0xc40>
jmp    1ac0 <relax_svd+0x990>
cmp    %r15,%rdx
jae    1e16 <relax_svd+0xce6>
mov    0x30(%rsp),%rcx
mov    %r11,%rsi
cmp    $0x4,%r11
mov    0x170(%rsp),%r10
mov    0x58(%rsp),%rdx
mov    0x180(%rsp),%r9
mov    0xb0(%rsp),%rax
mov    0x78(%rsp),%rdi
mov    0x88(%rsp),%r11
mov    0x128(%rsp),%rbx
jb     1f38 <relax_svd+0xe08>
movapd %xmm12,%xmm0
unpcklpd %xmm12,%xmm0
cmpq   $0x4,0x1a8(%rsp)
jae    1e5a <relax_svd+0xd2a>
mov    %rsi,%r13
xor    %eax,%eax
mov    0x28(%rsp),%rsi
jmp    1eb8 <relax_svd+0xd88>
mov    0x170(%rsp),%r10
mov    0x58(%rsp),%rdx
mov    0x28(%rsp),%rsi
mov    0xa8(%rsp),%rcx
mov    0x180(%rsp),%r9
mov    0xb0(%rsp),%rax
mov    0x78(%rsp),%rdi
mov    0x88(%rsp),%r11
mov    0x128(%rsp),%rbx
jmp    1315 <relax_svd+0x1e5>
mov    %rsi,%r13
xor    %eax,%eax
mov    0x28(%rsp),%rsi
mov    0x198(%rsp),%rcx
nopl   0x0(%rax)
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
movupd 0x20(%rdi,%rax,8),%xmm3
movupd 0x30(%rdi,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x20(%rdi,%rax,8)
movupd %xmm4,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1e70 <relax_svd+0xd40>
mov    %r13,%rcx
and    $0xfffffffffffffffc,%rcx
testb  $0x1,0xc0(%rsp)
01
je     1f01 <relax_svd+0xdd1>
add    0x30(%rsp),%rax
add    0x98(%rsp),%rax
mov    0x10(%rsp),%rbx
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rbx,%rax,8)
movupd %xmm2,0x10(%rbx,%rax,8)
mov    0x128(%rsp),%rbx
cmp    %rcx,%r13
jne    1f23 <relax_svd+0xdf3>
mov    0xa8(%rsp),%rcx
mov    0xb0(%rsp),%rax
mov    0x148(%rsp),%r13
jmp    1315 <relax_svd+0x1e5>
add    0x30(%rsp),%rcx
mov    0xb0(%rsp),%rax
mov    0x148(%rsp),%r13
mov    0x28(%rsp),%rsi
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1f40 <relax_svd+0xe10>
mov    0xa8(%rsp),%rcx
jmp    1315 <relax_svd+0x1e5>
mov    0x80(%rsp),%r10
test   %r10d,%r10d
jle    3060 <relax_svd+0x1f30>
mov    0x138(%rsp),%edi
movslq %edi,%rbp
lea    0x0(,%rbp,8),%rbx
mov    0x108(%rsp),%rsi
mov    %rsi,%rcx
imul   0xa0(%rsp),%rcx
mov    0x10(%rsp),%rax
mov    %rcx,0xc0(%rsp)
lea    (%rax,%rcx,8),%rdx
mov    %r14,%r11
neg    %r11
mov    %rbp,%r13
add    %rbp,%r13
mov    %rbp,%rax
shl    $0x4,%rax
mov    %rax,0xa8(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%rsi,8),%rax
mov    %rax,0x88(%rsp)
mov    %rsi,%rax
mov    %rbp,0x40(%rsp)
imul   %rbp,%rax
lea    (%rcx,%rax,8),%rax
add    $0x8,%rax
mov    %rbx,0xf8(%rsp)
mov    %rbx,%r12
neg    %r12
xorpd  %xmm0,%xmm0
mov    %rcx,0xc8(%rsp)
mov    %rsi,0xb0(%rsp)
mov    %r15,%rbp
mov    %r11,0x98(%rsp)
mov    %r12,0x100(%rsp)
jmp    2084 <relax_svd+0xf54>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x18(%rsp),%rbp
mov    %ebp,%ecx
imul   %edi,%ecx
movslq %ecx,%rcx
add    %rbp,%rcx
mov    0x48(%rsp),%rsi
movabs $0x3ff0000000000000,%rbx
mov    %rbx,(%rsi,%rcx,8)
movsd  (%r8,%rbp,8),%xmm11
addq   $0xffffffffffffffff,0xb0(%rsp)
add    %r11,%rdx
addq   $0xfffffffffffffff8,0x88(%rsp)
addq   $0xfffffffffffffff8,0xc8(%rsp)
add    %r12,%rax
cmp    $0x1,%r9
jle    2452 <relax_svd+0x1322>
mov    %rbp,%r9
lea    -0x1(%rbp),%rcx
mov    %rcx,0x18(%rsp)
cmp    0xd0(%rsp),%rbp
jg     2030 <relax_svd+0xf00>
mov    %rax,0x130(%rsp)
mov    %r9,0x20(%rsp)
movslq %r9d,%rcx
mov    %r15,%rax
sub    %rcx,%rax
mov    %rax,0x8(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rcx,%rax
not    %rax
mov    %rax,0x60(%rsp)
ucomisd %xmm0,%xmm11
jne    20d2 <relax_svd+0xfa2>
jnp    2360 <relax_svd+0x1230>
mov    0x20(%rsp),%rax
cmp    0x80(%rsp),%eax
jge    2360 <relax_svd+0x1230>
mov    0x48(%rsp),%rsi
mov    0x28(%rsp),%rax
lea    (%rsi,%rax,8),%r11
mov    0x40(%rsp),%rcx
imul   %rax,%rcx
add    0xb0(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
mov    0x18(%rsp),%rbp
imul   0xa0(%rsp),%rbp
mov    0x20(%rsp),%r9
movslq %r9d,%rsi
mov    %rbp,%rax
mov    %rbp,0x58(%rsp)
add    %rsi,%rbp
mov    0x10(%rsp),%rax
mov    0xf8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rsi,8),%xmm1
divsd  (%rax,%rbp,8),%xmm1
divsd  %xmm11,%xmm1
movsd  %xmm1,(%rcx)
add    $0x1,%rsi
add    %rbx,%rcx
cmp    %rsi,%r15
jne    2140 <relax_svd+0x1010>
cmp    0x80(%rsp),%r9d
jge    2360 <relax_svd+0x1230>
movslq 0x20(%rsp),%rdi
add    %rdi,0x58(%rsp)
mov    %rdi,%rcx
imul   0x40(%rsp),%rcx
lea    0x1(%rdi),%rax
mov    %rax,0x110(%rsp)
mov    0x18(%rsp),%rax
mov    %rcx,0xe0(%rsp)
add    %rcx,%rax
mov    %rax,0x78(%rsp)
mov    0x48(%rsp),%r12
mov    %rdi,%r9
mov    %rdi,0x30(%rsp)
jmp    21da <relax_svd+0x10aa>
add    $0x1,%r9
add    $0x8,%r12
add    $0x8,%r11
mov    0x90(%rsp),%r15
cmp    %r15,%r9
mov    0x228(%rsp),%r8
mov    0x30(%rsp),%rdi
je     2360 <relax_svd+0x1230>
xorpd  %xmm2,%xmm2
mov    %rdi,%rbp
testb  $0x1,0x8(%rsp)
je     221d <relax_svd+0x10ed>
mov    0x10(%rsp),%rax
mov    0x58(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0xe0(%rsp),%rax
lea    (%rax,%r9,1),%rcx
mov    0x48(%rsp),%rsi
mulsd  (%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x110(%rsp),%rbp
movapd %xmm1,%xmm2
mov    0x60(%rsp),%rax
cmp    0x50(%rsp),%rax
je     227d <relax_svd+0x114d>
mov    0x40(%rsp),%rax
mov    %rax,%rcx
imul   %rbp,%rcx
lea    (%r12,%rcx,8),%rcx
lea    0x1(%rbp),%rsi
imul   %rax,%rsi
lea    (%r12,%rsi,8),%rbx
mov    0x28(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm3
mulsd  (%rcx,%rsi,8),%xmm3
movsd  0x8(%rdx,%rbp,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  (%rbx,%rsi,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rbp
add    %r13,%rsi
movapd %xmm1,%xmm2
cmp    %rbp,%r15
jne    2250 <relax_svd+0x1120>
mov    %rdi,%rsi
testb  $0x1,0x8(%rsp)
je     22b8 <relax_svd+0x1188>
mov    0xe0(%rsp),%rax
lea    (%rax,%r9,1),%rcx
mov    0x48(%rsp),%rsi
mov    0x78(%rsp),%rax
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rcx,8),%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
mov    0x110(%rsp),%rsi
mov    0x60(%rsp),%rax
cmp    0x50(%rsp),%rax
mov    0xa8(%rsp),%r10
je     21b0 <relax_svd+0x1080>
mov    0x90(%rsp),%rbp
sub    %rsi,%rbp
mov    0x40(%rsp),%r15
mov    %r15,%rcx
imul   %rsi,%rcx
lea    (%r9,%rcx,1),%rbx
mov    0x48(%rsp),%rax
lea    (%rax,%rbx,8),%r8
add    0xb0(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
add    $0x1,%rsi
imul   %r15,%rsi
lea    (%r11,%rsi,8),%rbx
mov    0x88(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%r15,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r8,%r15,1),%xmm2
movsd  %xmm2,(%r8,%r15,1)
movsd  (%rsi,%r15,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rbx,%r15,1),%xmm2
movsd  %xmm2,(%rbx,%r15,1)
add    %r10,%r15
add    $0xfffffffffffffffe,%rbp
jne    2320 <relax_svd+0x11f0>
jmp    21b0 <relax_svd+0x1080>
nopw   0x0(%rax,%rax,1)
mov    0x80(%rsp),%r10
mov    0x20(%rsp),%r9
cmp    %r10d,%r9d
mov    0x138(%rsp),%edi
mov    0x98(%rsp),%r11
mov    0x130(%rsp),%rax
mov    0x100(%rsp),%r12
jge    2030 <relax_svd+0xf00>
movslq %r9d,%rbp
testb  $0x1,0x8(%rsp)
je     23db <relax_svd+0x12ab>
mov    0x18(%rsp),%r9
mov    %r9,%rcx
mov    0x40(%rsp),%rbx
imul   %rbx,%rcx
mov    %rbp,%rsi
imul   %rbx,%rsi
add    %r9,%rsi
mov    0x20(%rsp),%r9
mov    0x48(%rsp),%rbx
movq   $0x0,(%rbx,%rsi,8)
add    %rbp,%rcx
movq   $0x0,(%rbx,%rcx,8)
add    $0x1,%rbp
mov    0x60(%rsp),%rcx
cmp    0x50(%rsp),%rcx
je     2030 <relax_svd+0xf00>
lea    0x1(%rbp),%rcx
mov    0x40(%rsp),%rsi
imul   %rsi,%rcx
mov    0xc8(%rsp),%rbx
lea    (%rbx,%rcx,8),%rcx
imul   %rbp,%rsi
lea    (%rbx,%rsi,8),%rsi
mov    0x108(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rsi,%rbx,8)
movq   $0x0,-0x8(%rax,%rbp,8)
movq   $0x0,(%rcx,%rbx,8)
movq   $0x0,(%rax,%rbp,8)
add    $0x2,%rbp
add    %r13,%rbx
cmp    %rbp,%r15
jne    2420 <relax_svd+0x12f0>
jmp    2030 <relax_svd+0xf00>
test   %r10d,%r10d
mov    0x220(%rsp),%r9
jle    3060 <relax_svd+0x1f30>
mov    0xdc(%rsp),%eax
mov    0xd0(%rsp),%rcx
imul   %eax,%ecx
add    %r10d,%ecx
mov    %rcx,0xd0(%rsp)
not    %eax
mov    %eax,0xb0(%rsp)
mov    0xc0(%rsp),%rdx
add    %r15,%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,8),%r13
add    $0xfffffffffffffff8,%r13
mov    %r14,%rcx
xor    $0xfffffffffffffff8,%rcx
mov    %rcx,0xe0(%rsp)
mov    0x148(%rsp),%rbx
lea    0x1(%rbx),%r12
mov    0x188(%rsp),%rcx
imul   %r15,%rcx
lea    (%rax,%rcx,8),%r11
lea    (%rax,%rcx,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    (%rax,%rdx,8),%rdx
xor    %edi,%edi
xorpd  %xmm4,%xmm4
movsd  0x1b3a(%rip),%xmm3
mov    %r15,%rsi
movsd  %xmm5,0x20(%rsp)
mov    %r12,0x18(%rsp)
jmp    2550 <relax_svd+0x1420>
cs nopw 0x0(%rax,%rax,1)
mov    0x60(%rsp),%rsi
mov    %rsi,%rax
imul   0xa0(%rsp),%rax
add    %rsi,%rax
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rdi
mov    0xe0(%rsp),%rax
add    %rax,%r13
add    %rax,%r11
add    %rax,%rbp
add    %rax,%rdx
mov    0x90(%rsp),%r15
cmp    %r15,%rdi
je     277d <relax_svd+0x164d>
mov    %r15,%rax
mov    %rsi,%r15
lea    -0x1(%rsi),%rcx
mov    %rcx,0x60(%rsp)
movsd  -0x8(%r9,%rsi,8),%xmm1
cmp    %rax,%rsi
jge    26e0 <relax_svd+0x15b0>
movabs $0x7fffffff8,%rax
mov    %rdx,0x50(%rsp)
lea    (%rax,%rdi,8),%rdx
and    %rax,%rdx
add    $0x8,%rdx
mov    0xb0(%rsp),%eax
imul   %edi,%eax
add    0xd0(%rsp),%eax
cltq
mov    0x10(%rsp),%rcx
mov    %rdi,0x30(%rsp)
lea    (%rcx,%rax,8),%rdi
mov    %r11,0x8(%rsp)
xor    %esi,%esi
movsd  %xmm1,0x110(%rsp)
call   1030 <memset@plt>
movsd  0x110(%rsp),%xmm1
xorpd  %xmm4,%xmm4
mov    0x30(%rsp),%rdi
mov    0x50(%rsp),%rdx
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%r12
movsd  0x1a38(%rip),%xmm3
mov    0x80(%rsp),%r10
movsd  0x20(%rsp),%xmm5
movapd 0x1a02(%rip),%xmm7
mov    0x220(%rsp),%r9
mov    0x228(%rsp),%r8
ucomisd %xmm4,%xmm1
jne    261a <relax_svd+0x14ea>
jnp    2700 <relax_svd+0x15d0>
movapd %xmm3,%xmm0
divsd  %xmm1,%xmm0
mov    0x60(%rsp),%rcx
mov    %ecx,%eax
imul   0xdc(%rsp),%eax
movslq %eax,%r8
add    %rcx,%r8
mov    %rdx,%rcx
mov    %r15,%rsi
jmp    2655 <relax_svd+0x1525>
nop
add    $0x1,%rsi
add    $0x8,%r11
add    $0x8,%rcx
cmp    %r10d,%esi
je     2730 <relax_svd+0x1600>
xorpd  %xmm1,%xmm1
cmp    %rbx,%r15
jge    268c <relax_svd+0x155c>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
mov    %r15,%rax
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,1),%xmm2
mulsd  (%r11,%rdi,1),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rax
add    %r14,%rdi
cmp    %rbx,%rax
jl     2670 <relax_svd+0x1540>
cmp    %rbx,%r15
jg     2640 <relax_svd+0x1510>
mov    0x10(%rsp),%rax
divsd  (%rax,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
mov    %r12,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rdi,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rdi,1),%xmm2
movsd  %xmm2,(%rcx,%rdi,1)
add    %r14,%rdi
add    $0xffffffffffffffff,%rax
cmp    %rax,%r15
jne    26b0 <relax_svd+0x1580>
jmp    2640 <relax_svd+0x1510>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm4,%xmm1
jne    26e8 <relax_svd+0x15b8>
jnp    2700 <relax_svd+0x15d0>
movapd %xmm3,%xmm0
divsd  %xmm1,%xmm0
jmp    2747 <relax_svd+0x1617>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%rax
mov    %r13,%rcx
cmp    %rbx,%r15
jg     2500 <relax_svd+0x13d0>
nop
movq   $0x0,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r15
jne    2710 <relax_svd+0x15e0>
jmp    2500 <relax_svd+0x13d0>
nopl   0x0(%rax,%rax,1)
mov    0x228(%rsp),%r8
mov    0x8(%rsp),%r11
mov    0x50(%rsp),%rdx
mov    0x30(%rsp),%rdi
mov    %r12,%rax
mov    %r13,%rcx
cmp    %rbx,%r15
jg     2500 <relax_svd+0x13d0>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rax,%r15
jne    2760 <relax_svd+0x1630>
jmp    2500 <relax_svd+0x13d0>
test   %r10d,%r10d
jle    3060 <relax_svd+0x1f30>
lea    -0x1(%r15),%r13
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x28(%rsp)
mov    0x140(%rsp),%rax
mov    %eax,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x88(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0x58(%rsp)
mov    0x48(%rsp),%rdi
mov    0x40(%rsp),%rcx
lea    (%rdi,%rcx,8),%rax
mov    %rax,0x98(%rsp)
mov    0x10(%rsp),%rsi
mov    0xa0(%rsp),%rax
lea    (%rsi,%rax,8),%rdx
mov    %rdx,0x100(%rsp)
shl    $0x4,%rax
mov    %rax,0xd0(%rsp)
lea    (%rcx,%r15,1),%rax
lea    (%rdi,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0xf8(%rsp)
lea    (%rdi,%r15,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0xc0(%rsp)
mov    %r15,0xc8(%rsp)
mov    %r13,%rax
mov    %r13,0x18(%rsp)
add    $0xffffffffffffffff,%r13
mov    $0x1,%edx
mov    %r15,%rax
mov    %r13,0x130(%rsp)
jmp    28a0 <relax_svd+0x1770>
movapd %xmm1,%xmm2
mov    0x228(%rsp),%r8
mov    0x220(%rsp),%r9
mov    0x78(%rsp),%rax
movq   $0x0,(%r8,%rax,8)
mov    0x18(%rsp),%rax
movsd  %xmm0,(%r8,%rax,8)
movsd  %xmm2,(%r9,%rax,8)
mov    0x80(%rsp),%edx
add    $0x1,%edx
mov    0xc8(%rsp),%rax
movapd 0x177c(%rip),%xmm7
movsd  0x20(%rsp),%xmm5
mov    0x130(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rax),%ecx
movsd  (%r8,%rcx,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm5,%xmm0
ucomisd %xmm5,%xmm0
jne    28b9 <relax_svd+0x1789>
jnp    28e5 <relax_svd+0x17b5>
movsd  -0x10(%r9,%rax,8),%xmm0
andpd  %xmm7,%xmm0
addsd  %xmm5,%xmm0
ucomisd %xmm5,%xmm0
jne    28d0 <relax_svd+0x17a0>
jnp    28f8 <relax_svd+0x17c8>
add    $0xffffffffffffffff,%rax
jg     28a0 <relax_svd+0x1770>
mov    $0xffffffff,%r15d
mov    $0xffffffffffffffff,%rax
jmp    2900 <relax_svd+0x17d0>
add    $0xffffffff,%eax
mov    %eax,%r15d
movsd  0x172d(%rip),%xmm1
jmp    2a59 <relax_svd+0x1929>
lea    -0x1(%rax),%r15d
add    $0xfffffffffffffffe,%rax
movsd  0x1718(%rip),%xmm1
movslq %r15d,%r12
cmp    %r12,0x18(%rsp)
jle    2a59 <relax_svd+0x1929>
mov    %edx,0x80(%rsp)
movslq %eax,%rbp
mov    0xa0(%rsp),%rax
lea    (%rax,%r12,1),%rbx
shl    $0x3,%rbx
add    %rax,%rbp
xorpd  %xmm6,%xmm6
movapd %xmm1,%xmm0
jmp    2969 <relax_svd+0x1839>
nopl   (%rax)
add    $0x1,%r12
add    $0x8,%rbx
cmp    0x18(%rsp),%r12
mov    0x228(%rsp),%r8
movapd 0x16a3(%rip),%xmm7
movsd  0x20(%rsp),%xmm5
jge    2a52 <relax_svd+0x1922>
movsd  (%r8,%r12,8),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm6
movsd  %xmm6,(%r8,%r12,8)
movapd %xmm0,%xmm2
andpd  %xmm7,%xmm2
addsd  %xmm5,%xmm2
ucomisd %xmm5,%xmm2
jne    2995 <relax_svd+0x1865>
jnp    2a52 <relax_svd+0x1922>
movsd  (%r9,%r12,8),%xmm1
movsd  %xmm1,0x8(%rsp)
mov    $0x2,%al
movapd %xmm0,0x60(%rsp)
call   1040 <pythag@plt>
movsd  0x8(%rsp),%xmm6
movapd 0x60(%rsp),%xmm0
movsd  0x165e(%rip),%xmm1
mov    0x220(%rsp),%r9
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movsd  %xmm3,(%r9,%r12,8)
movapd %xmm1,%xmm2
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm6
xorpd  0x1625(%rip),%xmm0
mulsd  %xmm2,%xmm0
cmpl   $0x2,0x13c(%rsp)
02
jl     2940 <relax_svd+0x1810>
mov    0x58(%rsp),%rax
mov    0x10(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm5
movsd  (%rcx,%rbx,1),%xmm4
movapd %xmm0,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm6,%xmm5
addsd  %xmm2,%xmm5
movsd  %xmm5,(%rcx,%rbp,8)
mulsd  %xmm6,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,(%rcx,%rbx,1)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    2a10 <relax_svd+0x18e0>
jmp    2940 <relax_svd+0x1810>
mov    0x80(%rsp),%edx
mov    0x18(%rsp),%rcx
movsd  (%r9,%rcx,8),%xmm2
mov    %r15d,%eax
cmp    %rax,%rcx
je     2f73 <relax_svd+0x1e43>
cmp    $0x1e,%edx
je     1145 <relax_svd+0x15>
mov    0x48(%rsp),%r12
mov    %edx,0x80(%rsp)
movslq %r15d,%rbp
movsd  (%r9,%rbp,8),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  (%r9,%r13,8),%xmm5
movsd  (%r8,%r13,8),%xmm0
mov    0x18(%rsp),%rbx
movsd  (%r8,%rbx,8),%xmm3
movsd  %xmm3,0x8(%rsp)
movapd %xmm5,%xmm4
subsd  %xmm2,%xmm4
movapd %xmm2,0x30(%rsp)
addsd  %xmm5,%xmm2
movapd %xmm5,0x60(%rsp)
mulsd  %xmm4,%xmm2
movapd %xmm0,%xmm4
subsd  %xmm3,%xmm4
addsd  %xmm3,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm3,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm5,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    $0x2,%al
call   1040 <pythag@plt>
movapd 0x60(%rsp),%xmm0
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movsd  0x50(%rsp),%xmm4
movapd %xmm4,%xmm1
movapd 0x30(%rsp),%xmm2
subsd  %xmm2,%xmm1
addsd  %xmm4,%xmm2
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm2
movapd %xmm2,%xmm4
movapd %xmm3,%xmm1
andpd  0x14c2(%rip),%xmm1
orpd   0x14ca(%rip),%xmm3
xorpd  %xmm2,%xmm2
movsd  0xe0(%rsp),%xmm6
cmpnlesd %xmm6,%xmm2
andpd  %xmm2,%xmm3
andnpd %xmm1,%xmm2
movapd %xmm5,%xmm1
orpd   %xmm3,%xmm2
addsd  %xmm6,%xmm2
divsd  %xmm2,%xmm0
movsd  0x8(%rsp),%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
divsd  %xmm5,%xmm0
cmp    %rbp,%rbx
mov    %rbp,0x78(%rsp)
jle    2838 <relax_svd+0x1708>
mov    0x98(%rsp),%rax
mov    %rbp,%rcx
lea    (%rax,%rbp,8),%r15
lea    (%r12,%rbp,8),%r13
mov    0x100(%rsp),%rax
lea    (%rax,%rbp,8),%r12
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rbx
mov    %rbp,%rax
movsd  0x1459(%rip),%xmm7
movapd %xmm7,%xmm9
mov    0x228(%rsp),%r8
mov    0x220(%rsp),%r9
jmp    2c4a <relax_svd+0x1b1a>
xchg   %ax,%ax
movapd 0xe0(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
movsd  0x8(%rsp),%xmm3
mulsd  %xmm8,%xmm3
subsd  %xmm0,%xmm3
movsd  0x30(%rsp),%xmm2
mulsd  %xmm8,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm9,%xmm1
movapd %xmm7,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm9,%xmm3
mulsd  %xmm7,%xmm2
subsd  %xmm3,%xmm2
add    $0x8,%r15
add    $0x8,%r13
add    $0x8,%r12
add    $0x8,%rbx
movapd %xmm2,%xmm1
cmp    0x18(%rsp),%rax
jge    284c <relax_svd+0x171c>
movsd  %xmm7,0x8(%rsp)
movsd  %xmm1,0x50(%rsp)
movapd %xmm0,0x60(%rsp)
mov    %rax,%rbp
movsd  0x8(%r8,%rax,8),%xmm2
movsd  0x8(%r9,%rax,8),%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  %xmm2,0xe0(%rsp)
mulsd  %xmm2,%xmm9
movapd %xmm9,0x110(%rsp)
movapd %xmm9,%xmm1
mov    $0x2,%al
call   1040 <pythag@plt>
movapd 0x60(%rsp),%xmm6
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x228(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
unpcklpd 0x110(%rsp),%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
movapd %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
cmpq   $0x0,0x108(%rsp)
je     2d70 <relax_svd+0x1c40>
xor    %ecx,%ecx
xor    %eax,%eax
movapd 0x1323(%rip),%xmm5
mov    0xa8(%rsp),%rdx
mov    0x28(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rcx,1),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm5,%xmm2
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
movapd %xmm7,%xmm2
shufpd $0x1,%xmm7,%xmm2
mulpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,0x0(%r13,%rcx,1)
movupd (%r15,%rcx,1),%xmm1
movapd %xmm1,%xmm3
xorpd  %xmm5,%xmm3
movapd %xmm1,%xmm4
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%r15,%rcx,1)
add    $0x2,%rax
add    %rdx,%rcx
cmp    %rax,%rsi
jne    2d00 <relax_svd+0x1bd0>
jmp    2d72 <relax_svd+0x1c42>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
testb  $0x1,0x90(%rsp)
01
movsd  0x8(%rsp),%xmm3
je     2db7 <relax_svd+0x1c87>
imul   0x40(%rsp),%rax
add    %rbp,%rax
mov    0x48(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm0
xorpd  0x126b(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm7,%xmm2
addpd  %xmm2,%xmm0
movupd %xmm0,(%rcx,%rax,8)
mulsd  0xe0(%rsp),%xmm3
movsd  %xmm3,0x8(%rsp)
movapd %xmm3,%xmm1
mulsd  %xmm7,%xmm1
movsd  0x50(%rsp),%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movsd  0x30(%rsp),%xmm1
movapd %xmm7,0xe0(%rsp)
mulsd  %xmm7,%xmm1
movapd %xmm0,0x110(%rsp)
movapd %xmm1,0xb0(%rsp)
mov    $0x2,%al
movapd %xmm6,0x60(%rsp)
call   1040 <pythag@plt>
movapd 0x60(%rsp),%xmm8
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mov    0x220(%rsp),%r9
movsd  %xmm1,(%r9,%rbp,8)
movapd %xmm8,%xmm7
test   %eax,%eax
je     2e59 <relax_svd+0x1d29>
movsd  0x11e5(%rip),%xmm7
divsd  %xmm1,%xmm7
movapd 0x110(%rsp),%xmm0
unpcklpd 0xb0(%rsp),%xmm0
unpcklpd %xmm7,%xmm7
mulpd  %xmm0,%xmm7
lea    0x1(%rbp),%rax
movapd %xmm7,%xmm9
unpckhpd %xmm7,%xmm9
mov    0x13c(%rsp),%ecx
test   %ecx,%ecx
mov    0x228(%rsp),%r8
movapd 0x1190(%rip),%xmm6
mov    0x88(%rsp),%rsi
mov    0xd0(%rsp),%rdi
jle    2be0 <relax_svd+0x1ab0>
movapd %xmm7,%xmm1
unpcklpd %xmm7,%xmm1
cmp    $0x1,%ecx
jne    2eb0 <relax_svd+0x1d80>
xor    %ecx,%ecx
jmp    2f27 <relax_svd+0x1df7>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rbx,%rdx,1),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm6,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
movapd %xmm9,%xmm3
shufpd $0x1,%xmm9,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rbx,%rdx,1)
movupd (%r12,%rdx,1),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm6,%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm4,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,(%r12,%rdx,1)
add    $0x2,%rcx
add    %rdi,%rdx
cmp    %rcx,%rsi
jne    2ec0 <relax_svd+0x1d90>
testb  $0x1,0x140(%rsp)
01
je     2be0 <relax_svd+0x1ab0>
imul   0xa0(%rsp),%rcx
add    %rbp,%rcx
mov    0x10(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm2
movapd %xmm2,%xmm3
mulpd  %xmm2,%xmm1
xorpd  0x10b5(%rip),%xmm2
shufpd $0x1,%xmm2,%xmm3
mulpd  %xmm9,%xmm3
addpd  %xmm3,%xmm1
movupd %xmm1,(%rdx,%rcx,8)
jmp    2be0 <relax_svd+0x1ab0>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
mov    0x90(%rsp),%r10
mov    0xf8(%rsp),%rdx
mov    0xc0(%rsp),%rbx
mov    0xc8(%rsp),%r15
jbe    3034 <relax_svd+0x1f04>
xorpd  0x1067(%rip),%xmm2
mov    0x18(%rsp),%rax
movlpd %xmm2,(%r9,%rax,8)
cmpq   $0x0,0x108(%rsp)
je     300a <relax_svd+0x1eda>
xor    %ecx,%ecx
xor    %eax,%eax
movapd 0x1045(%rip),%xmm1
mov    0xa8(%rsp),%r11
mov    0x28(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,1),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rbx,%rcx,1)
movsd  (%rdx,%rcx,1),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rdx,%rcx,1)
add    $0x2,%rax
add    %r11,%rcx
cmp    %rax,%rdi
jne    2fe0 <relax_svd+0x1eb0>
jmp    300c <relax_svd+0x1edc>
xor    %eax,%eax
test   $0x1,%r10b
je     3034 <relax_svd+0x1f04>
imul   0x40(%rsp),%rax
add    0x18(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0xfe1(%rip),%xmm0
movlpd %xmm0,(%rcx,%rax,8)
add    $0xffffffffffffffff,%r15
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0xf8(%rsp)
add    $0xfffffffffffffff8,%rbx
mov    %rbx,0xc0(%rsp)
xor    %eax,%eax
cmpq   $0x0,0x18(%rsp)
jg     2812 <relax_svd+0x16e2>
jmp    3062 <relax_svd+0x1f32>
xor    %eax,%eax
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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