int sv2uv(double *d, double *a, double *u, int m, double *v, int n) {
  double *p, *p1, *q, *pp, *w, *e;
  double s, t, h, r, sv;
  int i, j, k, mm, nm, ms;
  if (m < n)
    return -1;
  w = (double *)calloc(m + n, sizeof(double));
  e = w + m;
  for (i = 0, mm = m, p = a; i < n; ++i, --mm, p += n + 1) {
    if (mm > 1) {
      sv = h = 0.;
      for (j = 0, q = p, s = 0.; j < mm; ++j, q += n) {
        w[j] = *q;
        s += *q * *q;
      }
      if (s > 0.) {
        h = sqrt(s);
        if (*p < 0.)
          h = -h;
        s += *p * h;
        s = 1. / s;
        t = 1. / (w[0] += h);
        sv = 1. + fabs(*p / h);
        for (k = 1, ms = n - i; k < ms; ++k) {
          for (j = 0, q = p + k, r = 0.; j < mm; q += n)
            r += w[j++] * *q;
          r = r * s;
          for (j = 0, q = p + k; j < mm; q += n)
            *q -= r * w[j++];
        }
        for (j = 1, q = p; j < mm;)
          *(q += n) = w[j++] * t;
      }
      *p = sv;
      d[i] = -h;
    }
    if (mm == 1)
      d[i] = *p;
  }
  ldumat(a, u, m, n);
  for (i = 0, q = a; i < n; ++i) {
    for (j = 0; j < n; ++j, ++q) {
      if (j < i)
        *q = 0.;
      else if (j == i)
        *q = d[i];
    }
  }
  for (i = 0, mm = n, nm = n - 1, p = a; i < n; ++i, --mm, --nm, p += n + 1) {
    if (i && mm > 1) {
      sv = h = 0.;
      for (j = 0, q = p, s = 0.; j < mm; ++j, q += n) {
        w[j] = *q;
        s += *q * *q;
      }
      if (s > 0.) {
        h = sqrt(s);
        if (*p < 0.)
          h = -h;
        s += *p * h;
        s = 1. / s;
        t = 1. / (w[0] += h);
        sv = 1. + fabs(*p / h);
        for (k = 1, ms = n - i; k < ms; ++k) {
          for (j = 0, q = p + k, r = 0.; j < mm; q += n)
            r += w[j++] * *q;
          for (j = 0, q = p + k, r *= s; j < mm; q += n)
            *q -= r * w[j++];
        }
        for (k = 0, p1 = u + i; k < m; ++k, p1 += m) {
          for (j = 0, q = p1, r = 0.; j < mm;)
            r += w[j++] * *q++;
          for (j = 0, q = p1, r *= s; j < mm;)
            *q++ -= r * w[j++];
        }
      }
      *p = sv;
      d[i] = -h;
    }
    if (mm == 1)
      d[i] = *p;
    p1 = p + 1;
    if (nm > 1) {
      sv = h = 0.;
      for (j = 0, q = p1, s = 0.; j < nm; ++j, ++q)
        s += *q * *q;
      if (s > 0.) {
        h = sqrt(s);
        if (*p1 < 0.)
          h = -h;
        sv = 1. + fabs(*p1 / h);
        s += *p1 * h;
        s = 1. / s;
        t = 1. / (*p1 += h);
        for (k = n, ms = n * (n - i); k < ms; k += n) {
          for (j = 0, q = p1, pp = p1 + k, r = 0.; j < nm; ++j)
            r += *q++ * *pp++;
          for (j = 0, q = p1, pp = p1 + k, r *= s; j < nm; ++j)
            *pp++ -= r * *q++;
        }
        for (j = 1, q = p1 + 1; j < nm; ++j)
          *q++ *= t;
      }
      *p1 = sv;
      e[i] = -h;
    }
    if (nm == 1)
      e[i] = *p1;
  }
  ldvmat(a, v, n);
  qrbdv(d, e, u, m, v, n);
  for (i = 0; i < n; ++i) {
    if (d[i] < 0.) {
      d[i] = -d[i];
      for (j = 0, p = v + i; j < n; ++j, p += n)
        *p = -*p;
    }
  }
  free(w);
  return 0;
}


x86 assembly (clang, -O0):
<sv2uv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    119a <sv2uv+0x3a>
movl   $0xffffffff,-0x4(%rbp)
jmp    215f <sv2uv+0xfff>
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1609 <sv2uv+0x4a9>
cmpl   $0x1,-0xa0(%rbp)
jle    15a4 <sv2uv+0x444>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    129d <sv2uv+0x13d>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1228 <sv2uv+0xc8>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1568 <sv2uv+0x408>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    12f0 <sv2uv+0x190>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1ce9(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm1
mov    -0x60(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x1cc6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x80(%rbp),%xmm1
movaps 0x1cb9(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1c9d(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x94(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    14f8 <sv2uv+0x398>
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    142e <sv2uv+0x2ce>
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    13c5 <sv2uv+0x265>
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    14df <sv2uv+0x37f>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1463 <sv2uv+0x303>
jmp    14e4 <sv2uv+0x384>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1388 <sv2uv+0x228>
movl   $0x1,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1563 <sv2uv+0x403>
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x50(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
jmp    150a <sv2uv+0x3aa>
jmp    1568 <sv2uv+0x408>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xa0(%rbp)
jne    15c9 <sv2uv+0x469>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15ce <sv2uv+0x46e>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0xa0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    11df <sv2uv+0x7f>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    $0x0,%al
call   1040 <ldumat@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    16e7 <sv2uv+0x587>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    16ce <sv2uv+0x56e>
mov    -0x98(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    167a <sv2uv+0x51a>
mov    -0x50(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    16a9 <sv2uv+0x549>
mov    -0x98(%rbp),%eax
cmp    -0x94(%rbp),%eax
jne    16a4 <sv2uv+0x544>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    16a9 <sv2uv+0x549>
jmp    16ae <sv2uv+0x54e>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
jmp    1649 <sv2uv+0x4e9>
jmp    16d3 <sv2uv+0x573>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1630 <sv2uv+0x4d0>
movl   $0x0,-0x94(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2019 <sv2uv+0xeb9>
cmpl   $0x0,-0x94(%rbp)
je     1be7 <sv2uv+0xa87>
cmpl   $0x1,-0xa0(%rbp)
jle    1be7 <sv2uv+0xa87>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    17d9 <sv2uv+0x679>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1764 <sv2uv+0x604>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1bab <sv2uv+0xa4b>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    182c <sv2uv+0x6cc>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x17ad(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm1
mov    -0x60(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x178a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x80(%rbp),%xmm1
movaps 0x177d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1761(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x94(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    1a34 <sv2uv+0x8d4>
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    196a <sv2uv+0x80a>
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1901 <sv2uv+0x7a1>
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1a1b <sv2uv+0x8bb>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    199f <sv2uv+0x83f>
jmp    1a20 <sv2uv+0x8c0>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    18c4 <sv2uv+0x764>
movl   $0x0,-0x9c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1ba6 <sv2uv+0xa46>
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1adf <sv2uv+0x97f>
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1a80 <sv2uv+0x920>
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1b78 <sv2uv+0xa18>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    1b06 <sv2uv+0x9a6>
jmp    1b7d <sv2uv+0xa1d>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1a54 <sv2uv+0x8f4>
jmp    1bab <sv2uv+0xa4b>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xa0(%rbp)
jne    1c0c <sv2uv+0xaac>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x1,-0xa4(%rbp)
jle    1fa5 <sv2uv+0xe45>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1ca6 <sv2uv+0xb46>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
jmp    1c52 <sv2uv+0xaf2>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f69 <sv2uv+0xe09>
movsd  -0x70(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1cf9 <sv2uv+0xb99>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x80(%rbp),%xmm1
movaps 0x1303(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x12e7(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x12b4(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm1
mov    -0x48(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x1291(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    -0x94(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    1f0c <sv2uv+0xdac>
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1e3f <sv2uv+0xcdf>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1ddb <sv2uv+0xc7b>
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1ef3 <sv2uv+0xd93>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm2
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1e7c <sv2uv+0xd1c>
jmp    1ef8 <sv2uv+0xd98>
mov    -0x34(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    1d96 <sv2uv+0xc36>
movl   $0x1,-0x98(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1f64 <sv2uv+0xe04>
movsd  -0x78(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1f22 <sv2uv+0xdc2>
jmp    1f69 <sv2uv+0xe09>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xa4(%rbp)
jne    1fca <sv2uv+0xe6a>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1fcf <sv2uv+0xe6f>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0xa0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    170e <sv2uv+0x5ae>
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    $0x0,%al
call   1070 <ldvmat@plt>
mov    -0x10(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    -0x34(%rbp),%r9d
mov    $0x0,%al
call   1050 <qrbdv@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    214f <sv2uv+0xfef>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    2136 <sv2uv+0xfd6>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x98(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2131 <sv2uv+0xfd1>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    20d2 <sv2uv+0xf72>
jmp    2136 <sv2uv+0xfd6>
jmp    213b <sv2uv+0xfdb>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    2053 <sv2uv+0xef3>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sv2uv>:
mov    $0xffffffff,%eax
cmp    %r9d,%ecx
jl     2944 <sv2uv+0x17e4>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9d,%r14d
mov    %ecx,%r15d
mov    %rdx,%rbp
mov    %rsi,%r12
mov    %rdi,%r13
mov    %r8,0xc8(%rsp)
lea    (%r14,%r15,1),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
movslq %r15d,%rax
mov    %rax,0xd0(%rsp)
lea    (%rbx,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    %r14d,%r11d
test   %r14d,%r14d
mov    %r11,0x18(%rsp)
mov    %r12,0x58(%rsp)
mov    %r14,0xa8(%rsp)
mov    %r15,0xa0(%rsp)
mov    %rbp,0x78(%rsp)
jle    278a <sv2uv+0x162a>
mov    %r13,0x60(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0xf0(%rsp)
lea    0x8(,%r11,8),%r8
mov    %r11,%rdi
shl    $0x5,%rdi
lea    0x0(,%r11,8),%rbp
lea    0x8(%r12),%rsi
lea    0x0(,%rbp,2),%r9
add    %rbp,%r9
mov    %r11,%r10
shl    $0x4,%r10
lea    0x3(%r15),%r13d
xorpd  %xmm9,%xmm9
movapd 0x1dc4(%rip),%xmm7
movsd  0x1ddb(%rip),%xmm8
mov    %r12,(%rsp)
mov    %r14d,%edx
xor    %ecx,%ecx
mov    %rdi,0x38(%rsp)
mov    %r8,0x48(%rsp)
mov    %r9,0x30(%rsp)
mov    %r10,0x98(%rsp)
jmp    1290 <sv2uv+0x130>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
lea    -0x1(%r12),%r15d
add    %r8,(%rsp)
add    $0xffffffff,%edx
add    %r8,%rsi
add    $0x3,%r13b
cmp    %r11,%rcx
je     1749 <sv2uv+0x5e9>
movzbl %r13b,%r13d
and    $0x3,%r13d
mov    %r15d,%r12d
cmp    $0x2,%r15d
jl     1728 <sv2uv+0x5c8>
mov    %edx,0x20(%rsp)
mov    %rcx,0x28(%rsp)
lea    -0x1(%r12),%rcx
and    $0x3,%r15d
mov    %r12d,%r14d
and    $0xfffffffc,%r14d
mov    %rcx,%rax
mov    %rcx,0x8(%rsp)
xorpd  %xmm5,%xmm5
cmp    $0x3,%rcx
jae    12f0 <sv2uv+0x190>
xor    %ecx,%ecx
mov    (%rsp),%rax
test   $0x3,%r12b
jne    136d <sv2uv+0x20d>
jmp    139d <sv2uv+0x23d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,%rax
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm5,%xmm0
add    %rbp,%rdx
movsd  (%rax,%rbp,1),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rdx,1),%xmm0
add    %rbp,%rdx
movsd  %xmm0,0x10(%rbx,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rdx,1),%xmm5
add    %rbp,%rdx
movsd  %xmm5,0x18(%rbx,%rcx,8)
mulsd  %xmm5,%xmm5
addsd  %xmm0,%xmm5
add    $0x4,%rcx
add    %rbp,%rdx
cmp    %rcx,%r14
jne    1300 <sv2uv+0x1a0>
add    %rdi,%rax
test   $0x3,%r12b
je     139d <sv2uv+0x23d>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rdx
add    %rbp,%rax
cmp    %rdx,%r15
jne    1380 <sv2uv+0x220>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm5
xorpd  %xmm2,%xmm2
jbe    1709 <sv2uv+0x5a9>
ucomisd %xmm9,%xmm5
mov    %rsi,0x50(%rsp)
jb     13c4 <sv2uv+0x264>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    13fa <sv2uv+0x29a>
movapd %xmm5,%xmm0
movsd  %xmm5,0xb0(%rsp)
call   1080 <sqrt@plt>
movsd  0xb0(%rsp),%xmm5
xorpd  %xmm9,%xmm9
movsd  0x1c33(%rip),%xmm8
movapd 0x1c0b(%rip),%xmm7
mov    0x18(%rsp),%r11
lea    -0x2(%r12),%r8
mov    (%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm7,%xmm3
movapd %xmm2,%xmm1
cmpltsd %xmm9,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movsd  (%rbx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
mov    0xa8(%rsp),%rax
sub    0x28(%rsp),%eax
cmp    $0x2,%eax
jl     1630 <sv2uv+0x4d0>
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm8,%xmm3
divsd  %xmm4,%xmm3
mov    0x20(%rsp),%r9d
mov    $0x1,%edx
mov    0x50(%rsp),%r10
jmp    1481 <sv2uv+0x321>
nopl   0x0(%rax)
add    $0x1,%rdx
add    $0x8,%r10
cmp    %r9,%rdx
je     1630 <sv2uv+0x4d0>
test   %r12d,%r12d
jle    1470 <sv2uv+0x310>
mov    (%rsp),%rax
lea    (%rax,%rdx,8),%rsi
cmpq   $0x3,0x8(%rsp)
jae    14b0 <sv2uv+0x350>
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
mov    %rsi,%rax
test   $0x3,%r12b
jne    151f <sv2uv+0x3bf>
jmp    1549 <sv2uv+0x3e9>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm4,%xmm4
mov    %r10,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    %rdi,%rax
movsd  (%rbx,%rcx,8),%xmm5
movsd  0x8(%rbx,%rcx,8),%xmm6
mulsd  (%rdi),%xmm5
addsd  %xmm4,%xmm5
add    %rbp,%rdi
mulsd  (%rax,%rbp,1),%xmm6
addsd  %xmm5,%xmm6
movsd  0x10(%rbx,%rcx,8),%xmm5
mulsd  0x0(%rbp,%rdi,1),%xmm5
add    %rbp,%rdi
addsd  %xmm6,%xmm5
movsd  0x18(%rbx,%rcx,8),%xmm4
add    $0x4,%rcx
mulsd  0x0(%rbp,%rdi,1),%xmm4
add    %rbp,%rdi
addsd  %xmm5,%xmm4
add    %rbp,%rdi
cmp    %rcx,%r14
jne    14c0 <sv2uv+0x360>
add    0x38(%rsp),%rax
test   $0x3,%r12b
je     1549 <sv2uv+0x3e9>
lea    (%rbx,%rcx,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rdi,8),%xmm5
mulsd  (%rax),%xmm5
addsd  %xmm5,%xmm4
add    $0x1,%rdi
add    %rbp,%rax
cmp    %rdi,%r15
jne    1530 <sv2uv+0x3d0>
test   %r12d,%r12d
jle    1470 <sv2uv+0x310>
xorpd  %xmm7,%xmm4
mulsd  %xmm3,%xmm4
cmpq   $0x3,0x8(%rsp)
jae    1573 <sv2uv+0x413>
xor    %ecx,%ecx
test   $0x3,%r12b
jne    15fa <sv2uv+0x49a>
jmp    1470 <sv2uv+0x310>
mov    %r10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    %rax,%rsi
movsd  (%rbx,%rcx,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  (%rax),%xmm5
movsd  %xmm5,(%rax)
add    %rbp,%rax
movsd  0x8(%rbx,%rcx,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  (%rsi,%rbp,1),%xmm5
movsd  %xmm5,(%rsi,%rbp,1)
lea    (%rax,%rbp,1),%rdi
movsd  0x10(%rbx,%rcx,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  0x0(%rbp,%rax,1),%xmm5
movsd  %xmm5,0x0(%rbp,%rax,1)
lea    (%rdi,%rbp,1),%rax
movsd  0x18(%rbx,%rcx,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  0x0(%rbp,%rdi,1),%xmm5
add    $0x4,%rcx
movsd  %xmm5,0x0(%rbp,%rdi,1)
add    %rbp,%rax
cmp    %rcx,%r14
jne    1580 <sv2uv+0x420>
add    0x38(%rsp),%rsi
test   $0x3,%r12b
je     1470 <sv2uv+0x310>
lea    (%rbx,%rcx,8),%rax
xor    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  (%rsi),%xmm5
movsd  %xmm5,(%rsi)
add    $0x1,%rcx
add    %rbp,%rsi
cmp    %rcx,%r15
jne    1600 <sv2uv+0x4a0>
jmp    1470 <sv2uv+0x310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm8,%xmm3
divsd  %xmm0,%xmm3
mov    $0x1,%eax
mov    (%rsp),%rcx
cmp    $0x3,%r8
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%rsi
mov    0x30(%rsp),%r9
mov    0x98(%rsp),%r10
jb     16ce <sv2uv+0x56e>
mov    0x8(%rsp),%rdx
and    $0xfffffffffffffffc,%rdx
mov    (%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rbp,1)
movsd  0x10(%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r10,1)
movsd  0x18(%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r9,1)
movsd  0x20(%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rdi,1)
add    %rdi,%rcx
add    $0x4,%rax
cmp    %rax,%rdx
jne    1680 <sv2uv+0x520>
add    $0x1,%rax
divsd  %xmm1,%xmm2
andpd  0x1936(%rip),%xmm2
addsd  %xmm8,%xmm2
testb  $0x3,0x8(%rsp)
je     1709 <sv2uv+0x5a9>
lea    (%rbx,%rax,8),%rax
lea    (%rcx,%r11,8),%rcx
xor    %edx,%edx
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
add    $0x1,%rdx
add    %rbp,%rcx
cmp    %rdx,%r13
jne    16f0 <sv2uv+0x590>
mov    (%rsp),%rax
movsd  %xmm2,(%rax)
xorpd  %xmm7,%xmm1
mov    0x60(%rsp),%rax
mov    0x28(%rsp),%rcx
movlpd %xmm1,(%rax,%rcx,8)
mov    0x20(%rsp),%edx
cmp    $0x1,%r12d
jne    1270 <sv2uv+0x110>
mov    (%rsp),%rax
movsd  (%rax),%xmm0
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
jmp    1270 <sv2uv+0x110>
mov    0x58(%rsp),%rbp
mov    %rbp,%rdi
mov    0x78(%rsp),%rsi
mov    0xa0(%rsp),%r12
mov    %r12d,%edx
mov    0xa8(%rsp),%r14
mov    %r14d,%ecx
xor    %eax,%eax
call   1040 <ldumat@plt>
mov    0x18(%rsp),%r9
test   %r14d,%r14d
mov    0xc8(%rsp),%r15
mov    0x60(%rsp),%r13
jle    28f9 <sv2uv+0x1799>
lea    -0x1(%r14),%r10d
mov    %r14d,%eax
and    $0xfffffffe,%eax
neg    %eax
xor    %r8d,%r8d
xor    %edx,%edx
jmp    17cc <sv2uv+0x66c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rsi)
add    $0x8,%rsi
add    $0x1,%rdx
add    $0xffffffffffffffff,%r8
mov    %rsi,%rbp
cmp    %r9,%rdx
je     1870 <sv2uv+0x710>
test   %r10d,%r10d
je     1840 <sv2uv+0x6e0>
mov    $0x1,%edi
mov    %rbp,%rsi
jmp    17f6 <sv2uv+0x696>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x10,%rsi
add    $0x2,%rdi
lea    (%rax,%rdi,1),%ecx
cmp    $0x1,%ecx
je     1830 <sv2uv+0x6d0>
lea    -0x1(%rdi),%rcx
xorpd  %xmm0,%xmm0
cmp    %rcx,%rdx
ja     1814 <sv2uv+0x6b4>
lea    (%r8,%rdi,1),%rcx
cmp    $0x1,%rcx
jne    181a <sv2uv+0x6ba>
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdi,8)
xorpd  %xmm0,%xmm0
cmp    %rdi,%rdx
ja     17e0 <sv2uv+0x680>
jne    17e6 <sv2uv+0x686>
movsd  0x0(%r13,%rdx,8),%xmm0
jmp    17e0 <sv2uv+0x680>
xchg   %ax,%ax
add    $0xffffffff,%edi
test   $0x1,%r14b
je     17b8 <sv2uv+0x658>
jmp    184f <sv2uv+0x6ef>
nop
xor    %edi,%edi
mov    %rbp,%rsi
test   $0x1,%r14b
je     17b8 <sv2uv+0x658>
mov    %edi,%ecx
xorpd  %xmm0,%xmm0
cmp    %rcx,%rdx
ja     17b0 <sv2uv+0x650>
jne    17b4 <sv2uv+0x654>
movsd  0x0(%r13,%rdx,8),%xmm0
jmp    17b0 <sv2uv+0x650>
test   %r14d,%r14d
mov    0x58(%rsp),%rbp
jle    28f9 <sv2uv+0x1799>
lea    -0x3(%r14),%eax
lea    0x2(%r9),%rcx
mov    %rcx,0xd8(%rsp)
lea    -0x2(%r14),%edx
lea    0x8(,%r9,8),%r8
mov    %r9,%r11
shl    $0x5,%r11
mov    %rbp,%rcx
lea    0x0(,%r9,8),%rbp
lea    0x8(%rcx),%r15
shlq   $0x3,0xd0(%rsp)
lea    (%rcx,%r9,8),%rdi
add    $0x8,%rdi
xorpd  %xmm13,%xmm13
mov    %eax,0xbc(%rsp)
mov    %eax,%esi
mov    %edx,0x6c(%rsp)
mov    %r10d,%eax
mov    %rax,0x38(%rsp)
mov    0x78(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    %rcx,0x8(%rsp)
mov    %r14d,%ecx
xor    %r14d,%r14d
movapd 0x1704(%rip),%xmm11
movsd  0x171b(%rip),%xmm12
mov    %r10d,0x70(%rsp)
mov    %r8,0x80(%rsp)
mov    %r11,0x88(%rsp)
jmp    195f <sv2uv+0x7ff>
nopl   0x0(%rax)
movsd  (%r10),%xmm0
movsd  %xmm0,(%rax,%r14,8)
add    $0x1,%r14
add    %r8,0x8(%rsp)
add    %r8,%r15
addq   $0x8,0x98(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x38(%rsp)
add    %r8,%rdi
add    $0xffffffff,%edx
add    $0xffffffff,%esi
cmp    %r9,%r14
je     279d <sv2uv+0x163d>
mov    %ecx,%r12d
test   %r14,%r14
je     1fd3 <sv2uv+0xe73>
cmp    $0x2,%ecx
jl     1fd3 <sv2uv+0xe73>
mov    %edx,0x30(%rsp)
mov    %r14,0x48(%rsp)
mov    %r12d,%r13d
and    $0xfffffffc,%r13d
mov    %rcx,0x20(%rsp)
mov    %ecx,%r14d
and    $0x3,%r14d
lea    -0x1(%r12),%rax
mov    %rax,(%rsp)
xorpd  %xmm1,%xmm1
cmp    $0x3,%rax
jae    19c0 <sv2uv+0x860>
xor    %ecx,%ecx
mov    0x8(%rsp),%rax
test   $0x3,%r12b
jne    1a3d <sv2uv+0x8dd>
jmp    1a6d <sv2uv+0x90d>
nopl   0x0(%rax)
mov    0x8(%rsp),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rax
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    %rbp,%rdx
movsd  (%rax,%rbp,1),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rdx,1),%xmm0
add    %rbp,%rdx
movsd  %xmm0,0x10(%rbx,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rdx,1),%xmm1
add    %rbp,%rdx
movsd  %xmm1,0x18(%rbx,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
add    $0x4,%rcx
add    %rbp,%rdx
cmp    %rcx,%r13
jne    19d0 <sv2uv+0x870>
add    %r11,%rax
test   $0x3,%r12b
je     1a6d <sv2uv+0x90d>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rdx
add    %rbp,%rax
cmp    %rdx,%r14
jne    1a50 <sv2uv+0x8f0>
xorpd  %xmm9,%xmm9
ucomisd %xmm9,%xmm1
xorpd  %xmm8,%xmm8
mov    0x30(%rsp),%edx
mov    0x20(%rsp),%rcx
jbe    1fb3 <sv2uv+0xe53>
ucomisd %xmm13,%xmm1
mov    %rdi,0x40(%rsp)
mov    %esi,0x14(%rsp)
jb     1aa4 <sv2uv+0x944>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1add <sv2uv+0x97d>
movapd %xmm1,%xmm0
movsd  %xmm1,0x28(%rsp)
call   1080 <sqrt@plt>
movsd  0x28(%rsp),%xmm1
xorpd  %xmm13,%xmm13
mov    0x88(%rsp),%r11
movsd  0x1551(%rip),%xmm12
movapd 0x1528(%rip),%xmm11
mov    0x18(%rsp),%r9
mov    0x8(%rsp),%r10
movsd  (%r10),%xmm8
movapd %xmm0,%xmm3
xorpd  %xmm11,%xmm3
movapd %xmm8,%xmm9
cmpltsd %xmm13,%xmm9
andpd  %xmm9,%xmm3
andnpd %xmm0,%xmm9
orpd   %xmm3,%xmm9
movapd %xmm8,%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm12,%xmm0
divsd  %xmm3,%xmm0
movsd  (%rbx),%xmm3
addsd  %xmm9,%xmm3
movsd  %xmm3,(%rbx)
mov    %r9,%rax
sub    0x48(%rsp),%rax
cmp    $0x2,%rax
jl     1d10 <sv2uv+0xbb0>
mov    $0x1,%eax
mov    %r15,%r8
jmp    1b61 <sv2uv+0xa01>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x8,%r8
cmp    %r12,%rax
je     1d10 <sv2uv+0xbb0>
lea    (%r10,%rax,8),%rcx
cmpq   $0x3,(%rsp)
jae    1b80 <sv2uv+0xa20>
xorpd  %xmm3,%xmm3
xor    %edi,%edi
mov    %rcx,%rdx
test   $0x3,%r12b
jne    1bed <sv2uv+0xa8d>
jmp    1c19 <sv2uv+0xab9>
xorpd  %xmm3,%xmm3
mov    %r8,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
mov    %rsi,%rdx
movsd  (%rbx,%rdi,8),%xmm4
movsd  0x8(%rbx,%rdi,8),%xmm5
mulsd  (%rsi),%xmm4
addsd  %xmm3,%xmm4
add    %rbp,%rsi
mulsd  (%rdx,%rbp,1),%xmm5
addsd  %xmm4,%xmm5
movsd  0x10(%rbx,%rdi,8),%xmm4
mulsd  0x0(%rbp,%rsi,1),%xmm4
add    %rbp,%rsi
addsd  %xmm5,%xmm4
movsd  0x18(%rbx,%rdi,8),%xmm3
add    $0x4,%rdi
mulsd  0x0(%rbp,%rsi,1),%xmm3
add    %rbp,%rsi
addsd  %xmm4,%xmm3
add    %rbp,%rsi
cmp    %rdi,%r13
jne    1b90 <sv2uv+0xa30>
add    %r11,%rdx
test   $0x3,%r12b
je     1c19 <sv2uv+0xab9>
lea    (%rbx,%rdi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm4
mulsd  (%rdx),%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rdi
add    %rbp,%rdx
cmp    %rdi,%r14
jne    1c00 <sv2uv+0xaa0>
test   %r12d,%r12d
jle    1b50 <sv2uv+0x9f0>
xorpd  %xmm11,%xmm3
mulsd  %xmm0,%xmm3
cmpq   $0x3,(%rsp)
jae    1c50 <sv2uv+0xaf0>
xor    %esi,%esi
test   $0x3,%r12b
jne    1cd8 <sv2uv+0xb78>
jmp    1b50 <sv2uv+0x9f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdx,%rcx
movsd  (%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rdx),%xmm4
movsd  %xmm4,(%rdx)
add    %rbp,%rdx
movsd  0x8(%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rcx,%rbp,1),%xmm4
movsd  %xmm4,(%rcx,%rbp,1)
lea    (%rdx,%rbp,1),%rdi
movsd  0x10(%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  0x0(%rbp,%rdx,1),%xmm4
movsd  %xmm4,0x0(%rbp,%rdx,1)
lea    (%rdi,%rbp,1),%rdx
movsd  0x18(%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  0x0(%rbp,%rdi,1),%xmm4
add    $0x4,%rsi
movsd  %xmm4,0x0(%rbp,%rdi,1)
add    %rbp,%rdx
cmp    %rsi,%r13
jne    1c60 <sv2uv+0xb00>
add    %r11,%rcx
test   $0x3,%r12b
je     1b50 <sv2uv+0x9f0>
lea    (%rbx,%rsi,8),%rdx
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rdx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rcx),%xmm4
movsd  %xmm4,(%rcx)
add    $0x1,%rsi
add    %rbp,%rcx
cmp    %rsi,%r14
jne    1ce0 <sv2uv+0xb80>
jmp    1b50 <sv2uv+0x9f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
divsd  %xmm9,%xmm8
andpd  0x12f2(%rip),%xmm8
addsd  %xmm12,%xmm8
cmpl   $0x0,0xa0(%rsp)
jle    1f99 <sv2uv+0xe39>
lea    -0x4(%r13),%rax
mov    0x20(%rsp),%r10
and    $0xfffffffc,%r10d
shr    $0x2,%rax
add    $0xfffffffffffffffc,%r10
add    $0x1,%rax
mov    %r10,%r9
shr    $0x2,%r9
and    $0xfffffffffffffffe,%rax
mov    %rax,0x28(%rsp)
add    $0x1,%r9
mov    %r12d,%r11d
and    $0xfffffffc,%r11d
xor    %edi,%edi
mov    0x98(%rsp),%rdx
jmp    1d98 <sv2uv+0xc38>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%edi
add    0xd0(%rsp),%rdx
cmp    0xa0(%rsp),%edi
je     1f82 <sv2uv+0xe22>
test   %r12d,%r12d
jle    1d80 <sv2uv+0xc20>
cmpq   $0x3,(%rsp)
jae    1db0 <sv2uv+0xc50>
xorpd  %xmm3,%xmm3
xor    %ecx,%ecx
mov    %rdx,%rax
jmp    1e07 <sv2uv+0xca7>
nop
xorpd  %xmm3,%xmm3
xor    %ecx,%ecx
mov    %rdx,%rax
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm1
mulsd  (%rax),%xmm1
movsd  0x8(%rbx,%rcx,8),%xmm2
addsd  %xmm3,%xmm1
mulsd  0x8(%rax),%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%rbx,%rcx,8),%xmm1
mulsd  0x10(%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  0x18(%rbx,%rcx,8),%xmm3
mulsd  0x18(%rax),%xmm3
add    $0x4,%rcx
add    $0x20,%rax
addsd  %xmm1,%xmm3
cmp    %rcx,%r13
jne    1dc0 <sv2uv+0xc60>
test   $0x3,%r12b
je     1e37 <sv2uv+0xcd7>
lea    (%rbx,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rsi,8),%xmm4
mulsd  (%rax,%rsi,8),%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1e20 <sv2uv+0xcc0>
test   %r12d,%r12d
jle    1d80 <sv2uv+0xc20>
xorpd  %xmm11,%xmm3
mulsd  %xmm0,%xmm3
cmp    $0x4,%r12d
jae    1e5a <sv2uv+0xcfa>
xor    %r8d,%r8d
mov    %rdx,%rax
jmp    1f36 <sv2uv+0xdd6>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
test   %r10,%r10
je     1f74 <sv2uv+0xe14>
mov    0x28(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rbx,%rax,8),%xmm5
movupd 0x10(%rbx,%rax,8),%xmm6
mulpd  %xmm4,%xmm5
movupd (%rdx,%rax,8),%xmm7
addpd  %xmm5,%xmm7
movupd 0x10(%rdx,%rax,8),%xmm5
movupd 0x20(%rdx,%rax,8),%xmm2
movupd 0x30(%rdx,%rax,8),%xmm1
mulpd  %xmm4,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm7,(%rdx,%rax,8)
movupd %xmm6,0x10(%rdx,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm5
movupd 0x30(%rbx,%rax,8),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm5,0x20(%rdx,%rax,8)
movupd %xmm6,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1e80 <sv2uv+0xd20>
test   $0x1,%r9b
je     1f26 <sv2uv+0xdc6>
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm5
movupd 0x10(%rdx,%rax,8),%xmm6
mulpd  %xmm4,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm4,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm1,(%rdx,%rax,8)
movupd %xmm2,0x10(%rdx,%rax,8)
cmp    %r12,%r11
je     1d80 <sv2uv+0xc20>
lea    (%rdx,%r11,8),%rax
mov    %r11,%r8
lea    (%rbx,%r8,8),%rcx
mov    %r12,%rsi
sub    %r8,%rsi
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%r8,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%rax,%r8,8),%xmm1
movsd  %xmm1,(%rax,%r8,8)
add    $0x1,%r8
cmp    %r8,%rsi
jne    1f50 <sv2uv+0xdf0>
jmp    1d80 <sv2uv+0xc20>
xor    %eax,%eax
test   $0x1,%r9b
jne    1ef5 <sv2uv+0xd95>
jmp    1f26 <sv2uv+0xdc6>
mov    0x18(%rsp),%r9
mov    0x80(%rsp),%r8
mov    0x88(%rsp),%r11
jmp    1fa1 <sv2uv+0xe41>
mov    0x80(%rsp),%r8
mov    0x40(%rsp),%rdi
mov    0x14(%rsp),%esi
mov    0x30(%rsp),%edx
mov    0x20(%rsp),%rcx
mov    0x8(%rsp),%rax
movsd  %xmm8,(%rax)
xorpd  %xmm11,%xmm9
mov    0x60(%rsp),%r13
mov    0x48(%rsp),%r14
movlpd %xmm9,0x0(%r13,%r14,8)
add    $0xffffffff,%ecx
mov    0x8(%rsp),%r10
mov    %r13,%rax
cmp    $0x1,%r12d
je     1920 <sv2uv+0x7c0>
mov    0x8(%rsp),%rax
add    $0x8,%rax
mov    %rax,(%rsp)
cmp    $0x3,%r12d
jl     2760 <sv2uv+0x1600>
mov    %rcx,0x20(%rsp)
mov    0x6c(%rsp),%eax
mov    %eax,%ecx
sub    %r14d,%ecx
mov    0x38(%rsp),%rax
mov    %eax,%r13d
and    $0x3,%r13d
and    $0xfffffffc,%eax
mov    %eax,0x74(%rsp)
mov    0x70(%rsp),%r10d
sub    %r14d,%r10d
xorpd  %xmm2,%xmm2
mov    (%rsp),%rax
mov    %rcx,0x50(%rsp)
cmp    $0x3,%ecx
jb     208c <sv2uv+0xf2c>
xorpd  %xmm2,%xmm2
mov    0x74(%rsp),%ecx
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x20,%rax
add    $0xfffffffc,%ecx
jne    2050 <sv2uv+0xef0>
test   $0x3,%r10b
je     20b6 <sv2uv+0xf56>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rcx
cmp    %ecx,%r13d
jne    20a0 <sv2uv+0xf40>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
xorpd  %xmm10,%xmm10
mov    0x20(%rsp),%rcx
jbe    273f <sv2uv+0x15df>
ucomisd %xmm13,%xmm2
mov    %rdi,0x40(%rsp)
mov    %esi,0x14(%rsp)
mov    %edx,0x30(%rsp)
mov    %r10d,0xb0(%rsp)
jb     20f3 <sv2uv+0xf93>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    2124 <sv2uv+0xfc4>
movapd %xmm2,%xmm0
movsd  %xmm2,0x28(%rsp)
call   1080 <sqrt@plt>
movsd  0x28(%rsp),%xmm2
xorpd  %xmm13,%xmm13
movsd  0xf0a(%rip),%xmm12
movapd 0xee1(%rip),%xmm11
mov    0x18(%rsp),%r9
mov    (%rsp),%rcx
mov    0xbc(%rsp),%eax
sub    %r14d,%eax
mov    %rax,0x120(%rsp)
movsd  (%rcx),%xmm10
movapd %xmm0,%xmm3
xorpd  %xmm11,%xmm3
movapd %xmm10,%xmm1
cmpltsd %xmm13,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movapd %xmm10,%xmm8
addsd  %xmm1,%xmm8
movsd  %xmm8,(%rcx)
mov    %r9,%rax
sub    %r14,%rax
imul   %r9,%rax
mov    %rax,0x28(%rsp)
cmp    %r9,%rax
jle    25ba <sv2uv+0x145a>
mov    0x30(%rsp),%edi
add    $0x1,%rdi
and    $0xfffffffffffffffc,%rdi
mov    0x50(%rsp),%r8
lea    0x1(%r8),%rax
add    $0xfffffffffffffffc,%rdi
mov    %rax,0x108(%rsp)
mov    %rax,%rsi
movabs $0x1fffffffc,%rax
and    %rax,%rsi
shr    $0x2,%rdi
lea    -0x4(%rsi),%rdx
mov    %r14,%rax
mov    0xf0(%rsp),%r9
imul   %r9,%rax
add    $0x1,%rdi
mov    %rdx,0x100(%rsp)
mov    %rdx,%rcx
shr    $0x2,%rcx
mov    0xd8(%rsp),%rdx
add    %rax,%rdx
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xe8(%rsp)
add    $0x1,%rcx
mov    %rcx,0xf8(%rsp)
lea    (%r9,%rax,1),%rcx
mov    %rcx,0x130(%rsp)
add    %r8,%rdx
mov    %rdx,0x118(%rsp)
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
add    $0x8,%rax
mov    (%rsp),%rcx
mov    %rax,0x110(%rsp)
lea    0x8(%rax,%r8,8),%rax
mov    %rax,0x128(%rsp)
movapd %xmm10,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm12,%xmm9
divsd  %xmm4,%xmm9
mov    %rsi,0xc0(%rsp)
lea    (%rcx,%rsi,8),%rax
mov    %rax,0xe0(%rsp)
mov    0x40(%rsp),%r8
xor    %r11d,%r11d
mov    0x18(%rsp),%r9
mov    %r14,0x48(%rsp)
jmp    2297 <sv2uv+0x1137>
add    0x18(%rsp),%r9
add    $0x1,%r11
add    %rbp,%r8
cmp    0x28(%rsp),%r9
jge    25ba <sv2uv+0x145a>
cmp    $0x2,%r12d
jl     2280 <sv2uv+0x1120>
lea    (%rcx,%r9,8),%r10
xorpd  %xmm4,%xmm4
mov    %r10,%rax
mov    %rcx,%rsi
cmpl   $0x3,0x50(%rsp)
jb     2316 <sv2uv+0x11b6>
xorpd  %xmm4,%xmm4
mov    0x74(%rsp),%eax
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%r15,%rsi,1),%xmm0
movsd  0x8(%r15,%rsi,1),%xmm2
mulsd  (%r8,%rsi,1),%xmm0
mulsd  0x8(%r8,%rsi,1),%xmm2
addsd  %xmm4,%xmm0
movsd  0x10(%r15,%rsi,1),%xmm3
mulsd  0x10(%r8,%rsi,1),%xmm3
addsd  %xmm0,%xmm2
movsd  0x18(%r15,%rsi,1),%xmm4
mulsd  0x18(%r8,%rsi,1),%xmm4
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
add    $0x20,%rsi
add    $0xfffffffc,%eax
jne    22c0 <sv2uv+0x1160>
lea    (%r8,%rsi,1),%rax
add    %r15,%rsi
testb  $0x3,0xb0(%rsp)
03
je     2347 <sv2uv+0x11e7>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rdx,8),%xmm5
mulsd  (%rax,%rdx,8),%xmm5
addsd  %xmm5,%xmm4
add    $0x1,%rdx
cmp    %edx,%r13d
jne    2330 <sv2uv+0x11d0>
cmp    $0x2,%r12d
jl     2280 <sv2uv+0x1120>
xor    %edi,%edi
xorpd  %xmm11,%xmm4
mulsd  %xmm9,%xmm4
cmpl   $0x3,0x50(%rsp)
jae    236c <sv2uv+0x120c>
mov    %rcx,%rsi
jmp    24d0 <sv2uv+0x1370>
mov    %r11,%rax
imul   0x18(%rsp),%rax
mov    0x130(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
cmp    0x128(%rsp),%rdx
jae    23b3 <sv2uv+0x1253>
add    0x118(%rsp),%rax
lea    (%rcx,%rax,8),%rax
cmp    %rax,0x110(%rsp)
jae    23b3 <sv2uv+0x1253>
mov    (%rsp),%rsi
jmp    24d0 <sv2uv+0x1370>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmpq   $0x0,0x100(%rsp)
je     245d <sv2uv+0x12fd>
mov    0xe8(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r15,%rsi,8),%xmm6
movupd 0x10(%r15,%rsi,8),%xmm7
mulpd  %xmm5,%xmm6
movupd (%r8,%rsi,8),%xmm0
addpd  %xmm6,%xmm0
movupd 0x10(%r8,%rsi,8),%xmm6
movupd 0x20(%r8,%rsi,8),%xmm3
movupd 0x30(%r8,%rsi,8),%xmm2
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm0,(%r8,%rsi,8)
movupd %xmm7,0x10(%r8,%rsi,8)
movupd 0x20(%r15,%rsi,8),%xmm0
movupd 0x30(%r15,%rsi,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm0,0x20(%r8,%rsi,8)
movupd %xmm6,0x30(%r8,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    23e0 <sv2uv+0x1280>
jmp    245f <sv2uv+0x12ff>
xor    %esi,%esi
testb  $0x1,0xf8(%rsp)
01
mov    (%rsp),%rcx
je     24a2 <sv2uv+0x1342>
movupd (%rcx,%rsi,8),%xmm0
movupd 0x10(%rcx,%rsi,8),%xmm2
movupd (%r10,%rsi,8),%xmm3
movupd 0x10(%r10,%rsi,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm5,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm0,(%r10,%rsi,8)
movupd %xmm2,0x10(%r10,%rsi,8)
mov    0xc0(%rsp),%rax
cmp    %rax,0x108(%rsp)
je     2280 <sv2uv+0x1120>
mov    0xc0(%rsp),%rdi
lea    (%r10,%rdi,8),%r10
mov    0xe0(%rsp),%rsi
nopl   0x0(%rax)
lea    (%rdi,%r14,1),%edx
mov    0x70(%rsp),%ecx
sub    %edx,%ecx
mov    0x6c(%rsp),%eax
sub    %edx,%eax
test   $0x3,%cl
je     252b <sv2uv+0x13cb>
mov    %r13d,%ecx
sub    %dil,%cl
movzbl %cl,%edx
and    $0x3,%edx
neg    %edx
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r10),%xmm0
movsd  %xmm0,(%r10)
add    $0x8,%r10
add    $0x8,%rsi
add    $0xffffffff,%r14d
cmp    %r14d,%edx
jne    2500 <sv2uv+0x13a0>
sub    %r14d,%edi
mov    0x48(%rsp),%r14
mov    (%rsp),%rcx
cmp    $0x3,%eax
jb     2280 <sv2uv+0x1120>
mov    0x38(%rsp),%rax
sub    %edi,%eax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r10,%rdi,8),%xmm0
movsd  %xmm0,(%r10,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x8(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r10,%rdi,8)
movsd  0x10(%rsi,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x10(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r10,%rdi,8)
movsd  0x18(%rsi,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x18(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x18(%r10,%rdi,8)
add    $0x4,%rdi
cmp    %edi,%eax
jne    2550 <sv2uv+0x13f0>
jmp    2280 <sv2uv+0x1120>
divsd  %xmm1,%xmm10
andpd  0xa48(%rip),%xmm10
addsd  %xmm12,%xmm10
movapd %xmm12,%xmm3
divsd  %xmm8,%xmm3
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rcx
mov    $0x1,%edx
mov    0x120(%rsp),%r10
cmp    $0x3,%r10d
jae    260d <sv2uv+0x14ad>
mov    0x18(%rsp),%r9
mov    0x80(%rsp),%r8
mov    0x88(%rsp),%r11
jmp    2707 <sv2uv+0x15a7>
add    $0x1,%r10
mov    %r10,%r12
movabs $0x1fffffffc,%rax
and    %rax,%r12
lea    -0x4(%r12),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
test   %rax,%rax
mov    0x18(%rsp),%r9
mov    0x80(%rsp),%r8
mov    0x88(%rsp),%r11
je     277a <sv2uv+0x161a>
mov    0x14(%rsp),%eax
add    $0x1,%rax
and    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %edi,%edi
mov    0x8(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movupd 0x10(%rsi,%rdi,8),%xmm2
movupd 0x20(%rsi,%rdi,8),%xmm4
movupd 0x30(%rsi,%rdi,8),%xmm5
movupd 0x40(%rsi,%rdi,8),%xmm6
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm4
movupd %xmm2,0x10(%rsi,%rdi,8)
movupd %xmm4,0x20(%rsi,%rdi,8)
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm6
movupd %xmm5,0x30(%rsi,%rdi,8)
movupd %xmm6,0x40(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    2680 <sv2uv+0x1520>
test   $0x1,%dl
je     26ed <sv2uv+0x158d>
movupd (%rcx,%rdi,8),%xmm2
movupd 0x10(%rcx,%rdi,8),%xmm4
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm4
movupd %xmm2,(%rcx,%rdi,8)
movupd %xmm4,0x10(%rcx,%rdi,8)
cmp    %r12,%r10
jne    26fd <sv2uv+0x159d>
mov    0x40(%rsp),%rdi
mov    0x14(%rsp),%esi
jmp    2736 <sv2uv+0x15d6>
mov    %r12d,%edx
or     $0x1,%edx
lea    (%rcx,%r12,8),%rcx
mov    0x14(%rsp),%esi
mov    0x38(%rsp),%rax
sub    %edx,%eax
xor    %edx,%edx
mov    0x40(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%eax
jne    2720 <sv2uv+0x15c0>
mov    0x30(%rsp),%edx
mov    0x20(%rsp),%rcx
mov    (%rsp),%rax
movsd  %xmm10,(%rax)
xorpd  %xmm11,%xmm1
mov    0x90(%rsp),%rax
movlpd %xmm1,(%rax,%r14,8)
mov    0x60(%rsp),%r13
mov    0x90(%rsp),%rax
cmp    $0x1,%ecx
mov    (%rsp),%r10
je     1920 <sv2uv+0x7c0>
jmp    192b <sv2uv+0x7cb>
xor    %edi,%edi
test   $0x1,%dl
jne    26cf <sv2uv+0x156f>
jmp    26ed <sv2uv+0x158d>
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1040 <ldumat@plt>
mov    0x58(%rsp),%rdi
mov    0xc8(%rsp),%r15
mov    %r15,%rsi
mov    0xa8(%rsp),%r14
mov    %r14d,%edx
xor    %eax,%eax
call   1070 <ldvmat@plt>
mov    %r13,%rdi
mov    0x90(%rsp),%rsi
mov    0x78(%rsp),%rdx
mov    0xa0(%rsp),%rcx
mov    %r15,%r8
mov    %r14d,%r9d
xor    %eax,%eax
call   1050 <qrbdv@plt>
test   %r14d,%r14d
jle    2929 <sv2uv+0x17c9>
lea    -0x1(%r14),%r9d
mov    %r14d,%r10d
and    $0x3,%r10d
and    $0xfffffffc,%r14d
mov    0x18(%rsp),%rax
mov    %rax,%r8
shl    $0x5,%r8
lea    0x0(,%rax,8),%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
movapd 0x7e2(%rip),%xmm1
movapd 0x7da(%rip),%xmm2
mov    %r15,%r11
jmp    2843 <sv2uv+0x16e3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x8,%r11
cmp    0x18(%rsp),%rdi
je     2929 <sv2uv+0x17c9>
movsd  0x0(%r13,%rdi,8),%xmm3
ucomisd %xmm3,%xmm0
jbe    2830 <sv2uv+0x16d0>
xorpd  %xmm1,%xmm3
movlpd %xmm3,0x0(%r13,%rdi,8)
cmp    $0x3,%r9d
jae    2870 <sv2uv+0x1710>
lea    (%r15,%rdi,8),%rcx
test   %r10d,%r10d
jne    28d9 <sv2uv+0x1779>
jmp    2830 <sv2uv+0x16d0>
nopl   0x0(%rax)
mov    %r14d,%eax
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,%rcx
movsd  (%rdx),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdx)
add    %rsi,%rdx
movsd  (%rcx,%rsi,1),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rcx,%rsi,1)
lea    (%rdx,%rsi,1),%rbp
movsd  (%rsi,%rdx,1),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rsi,%rdx,1)
lea    0x0(%rbp,%rsi,1),%rdx
movsd  (%rsi,%rbp,1),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rsi,%rbp,1)
add    %rsi,%rdx
add    $0xfffffffc,%eax
jne    2880 <sv2uv+0x1720>
add    %r8,%rcx
test   %r10d,%r10d
je     2830 <sv2uv+0x16d0>
mov    %r10d,%eax
nopl   0x0(%rax)
movsd  (%rcx),%xmm3
xorpd  %xmm1,%xmm3
movlpd %xmm3,(%rcx)
add    %rsi,%rcx
add    $0xffffffff,%eax
jne    28e0 <sv2uv+0x1780>
jmp    2830 <sv2uv+0x16d0>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1070 <ldvmat@plt>
mov    %r13,%rdi
mov    0x90(%rsp),%rsi
mov    0x78(%rsp),%rdx
mov    %r12d,%ecx
mov    %r15,%r8
mov    %r14d,%r9d
xor    %eax,%eax
call   1050 <qrbdv@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @sv2uv(double* %0, double* %1, double* %2, i32 %3, double* %4, i32 %5) {
%7 = alloca i32
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca double*
%13 = alloca i32
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store double* %0, double** %8
store double* %1, double** %9
store double* %2, double** %10
store i32 %3, i32* %11
store double* %4, double** %12
store i32 %5, i32* %13
%31 = load i32, i32* %11
%32 = load i32, i32* %13
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %35
34: ; preds = %6
store i32 -1, i32* %7
br label %715
35: ; preds = %6
%36 = load i32, i32* %11
%37 = load i32, i32* %13
%38 = add nsw i32 %36, %37
%39 = sext i32 %38 to i64
%40 = call i8* @calloc(i64 %39, i64 8)
%41 = bitcast i8* %40 to double*
store double* %41, double** %18
%42 = load double*, double** %18
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %42, i64 %44
store double* %45, double** %19
store i32 0, i32* %25
%46 = load i32, i32* %11
store i32 %46, i32* %28
%47 = load double*, double** %9
store double* %47, double** %14
br label %48
48: ; preds = %218, %35
%49 = load i32, i32* %25
%50 = load i32, i32* %13
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %228
52: ; preds = %48
%53 = load i32, i32* %28
%54 = icmp sgt i32 %53, 1
br i1 %54, label %55, label %207
55: ; preds = %52
store double 0.000000e+00, double* %22
store double 0.000000e+00, double* %24
store i32 0, i32* %26
%56 = load double*, double** %14
store double* %56, double** %16
store double 0.000000e+00, double* %20
br label %57
57: ; preds = %74, %55
%58 = load i32, i32* %26
%59 = load i32, i32* %28
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %81
61: ; preds = %57
%62 = load double*, double** %16
%63 = load double, double* %62
%64 = load double*, double** %18
%65 = load i32, i32* %26
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %64, i64 %66
store double %63, double* %67
%68 = load double*, double** %16
%69 = load double, double* %68
%70 = load double*, double** %16
%71 = load double, double* %70
%72 = load double, double* %20
%73 = call double @llvm.fmuladd.f64(double %69, double %71, double %72)
store double %73, double* %20
br label %74
74: ; preds = %61
%75 = load i32, i32* %26
%76 = add nsw i32 %75, 1
store i32 %76, i32* %26
%77 = load i32, i32* %13
%78 = load double*, double** %16
%79 = sext i32 %77 to i64
%80 = getelementptr inbounds double, double* %78, i64 %79
store double* %80, double** %16
br label %57
81: ; preds = %57
%82 = load double, double* %20
%83 = fcmp ogt double %82, 0.000000e+00
br i1 %83, label %84, label %198
84: ; preds = %81
%85 = load double, double* %20
%86 = call double @sqrt(double %85)
store double %86, double* %22
%87 = load double*, double** %14
%88 = load double, double* %87
%89 = fcmp olt double %88, 0.000000e+00
br i1 %89, label %90, label %93
90: ; preds = %84
%91 = load double, double* %22
%92 = fneg double %91
store double %92, double* %22
br label %93
93: ; preds = %90, %84
%94 = load double*, double** %14
%95 = load double, double* %94
%96 = load double, double* %22
%97 = load double, double* %20
%98 = call double @llvm.fmuladd.f64(double %95, double %96, double %97)
store double %98, double* %20
%99 = load double, double* %20
%100 = fdiv double 1.000000e+00, %99
store double %100, double* %20
%101 = load double, double* %22
%102 = load double*, double** %18
%103 = getelementptr inbounds double, double* %102, i64 0
%104 = load double, double* %103
%105 = fadd double %104, %101
store double %105, double* %103
%106 = fdiv double 1.000000e+00, %105
store double %106, double* %21
%107 = load double*, double** %14
%108 = load double, double* %107
%109 = load double, double* %22
%110 = fdiv double %108, %109
%111 = call double @llvm.fabs.f64(double %110)
%112 = fadd double 1.000000e+00, %111
store double %112, double* %24
store i32 1, i32* %27
%113 = load i32, i32* %13
%114 = load i32, i32* %25
%115 = sub nsw i32 %113, %114
store i32 %115, i32* %30
br label %116
116: ; preds = %175, %93
%117 = load i32, i32* %27
%118 = load i32, i32* %30
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %178
120: ; preds = %116
store i32 0, i32* %26
%121 = load double*, double** %14
%122 = load i32, i32* %27
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
store double* %124, double** %16
store double 0.000000e+00, double* %23
br label %125
125: ; preds = %140, %120
%126 = load i32, i32* %26
%127 = load i32, i32* %28
%128 = icmp slt i32 %126, %127
br i1 %128, label %129, label %145
129: ; preds = %125
%130 = load double*, double** %18
%131 = load i32, i32* %26
%132 = add nsw i32 %131, 1
store i32 %132, i32* %26
%133 = sext i32 %131 to i64
%134 = getelementptr inbounds double, double* %130, i64 %133
%135 = load double, double* %134
%136 = load double*, double** %16
%137 = load double, double* %136
%138 = load double, double* %23
%139 = call double @llvm.fmuladd.f64(double %135, double %137, double %138)
store double %139, double* %23
br label %140
140: ; preds = %129
%141 = load i32, i32* %13
%142 = load double*, double** %16
%143 = sext i32 %141 to i64
%144 = getelementptr inbounds double, double* %142, i64 %143
store double* %144, double** %16
br label %125
145: ; preds = %125
%146 = load double, double* %23
%147 = load double, double* %20
%148 = fmul double %146, %147
store double %148, double* %23
store i32 0, i32* %26
%149 = load double*, double** %14
%150 = load i32, i32* %27
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %149, i64 %151
store double* %152, double** %16
br label %153
153: ; preds = %169, %145
%154 = load i32, i32* %26
%155 = load i32, i32* %28
%156 = icmp slt i32 %154, %155
br i1 %156, label %157, label %174
157: ; preds = %153
%158 = load double, double* %23
%159 = load double*, double** %18
%160 = load i32, i32* %26
%161 = add nsw i32 %160, 1
store i32 %161, i32* %26
%162 = sext i32 %160 to i64
%163 = getelementptr inbounds double, double* %159, i64 %162
%164 = load double, double* %163
%165 = load double*, double** %16
%166 = load double, double* %165
%167 = fneg double %158
%168 = call double @llvm.fmuladd.f64(double %167, double %164, double %166)
store double %168, double* %165
br label %169
169: ; preds = %157
%170 = load i32, i32* %13
%171 = load double*, double** %16
%172 = sext i32 %170 to i64
%173 = getelementptr inbounds double, double* %171, i64 %172
store double* %173, double** %16
br label %153
174: ; preds = %153
br label %175
175: ; preds = %174
%176 = load i32, i32* %27
%177 = add nsw i32 %176, 1
store i32 %177, i32* %27
br label %116
178: ; preds = %116
store i32 1, i32* %26
%179 = load double*, double** %14
store double* %179, double** %16
br label %180
180: ; preds = %184, %178
%181 = load i32, i32* %26
%182 = load i32, i32* %28
%183 = icmp slt i32 %181, %182
br i1 %183, label %184, label %197
184: ; preds = %180
%185 = load double*, double** %18
%186 = load i32, i32* %26
%187 = add nsw i32 %186, 1
store i32 %187, i32* %26
%188 = sext i32 %186 to i64
%189 = getelementptr inbounds double, double* %185, i64 %188
%190 = load double, double* %189
%191 = load double, double* %21
%192 = fmul double %190, %191
%193 = load i32, i32* %13
%194 = load double*, double** %16
%195 = sext i32 %193 to i64
%196 = getelementptr inbounds double, double* %194, i64 %195
store double* %196, double** %16
store double %192, double* %196
br label %180
197: ; preds = %180
br label %198
198: ; preds = %197, %81
%199 = load double, double* %24
%200 = load double*, double** %14
store double %199, double* %200
%201 = load double, double* %22
%202 = fneg double %201
%203 = load double*, double** %8
%204 = load i32, i32* %25
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %203, i64 %205
store double %202, double* %206
br label %207
207: ; preds = %198, %52
%208 = load i32, i32* %28
%209 = icmp eq i32 %208, 1
br i1 %209, label %210, label %217
210: ; preds = %207
%211 = load double*, double** %14
%212 = load double, double* %211
%213 = load double*, double** %8
%214 = load i32, i32* %25
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %213, i64 %215
store double %212, double* %216
br label %217
217: ; preds = %210, %207
br label %218
218: ; preds = %217
%219 = load i32, i32* %25
%220 = add nsw i32 %219, 1
store i32 %220, i32* %25
%221 = load i32, i32* %28
%222 = add nsw i32 %221, -1
store i32 %222, i32* %28
%223 = load i32, i32* %13
%224 = add nsw i32 %223, 1
%225 = load double*, double** %14
%226 = sext i32 %224 to i64
%227 = getelementptr inbounds double, double* %225, i64 %226
store double* %227, double** %14
br label %48
228: ; preds = %48
%229 = load double*, double** %9
%230 = load double*, double** %10
%231 = load i32, i32* %11
%232 = load i32, i32* %13
%233 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @ldumat to i32 (double*, double*, i32, i32, ...)*)(double* %229, double* %230, i32 %231, i32 %232)
store i32 0, i32* %25
%234 = load double*, double** %9
store double* %234, double** %16
br label %235
235: ; preds = %269, %228
%236 = load i32, i32* %25
%237 = load i32, i32* %13
%238 = icmp slt i32 %236, %237
br i1 %238, label %239, label %272
239: ; preds = %235
store i32 0, i32* %26
br label %240
240: ; preds = %263, %239
%241 = load i32, i32* %26
%242 = load i32, i32* %13
%243 = icmp slt i32 %241, %242
br i1 %243, label %244, label %268
244: ; preds = %240
%245 = load i32, i32* %26
%246 = load i32, i32* %25
%247 = icmp slt i32 %245, %246
br i1 %247, label %248, label %250
248: ; preds = %244
%249 = load double*, double** %16
store double 0.000000e+00, double* %249
br label %262
250: ; preds = %244
%251 = load i32, i32* %26
%252 = load i32, i32* %25
%253 = icmp eq i32 %251, %252
br i1 %253, label %254, label %261
254: ; preds = %250
%255 = load double*, double** %8
%256 = load i32, i32* %25
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %255, i64 %257
%259 = load double, double* %258
%260 = load double*, double** %16
store double %259, double* %260
br label %261
261: ; preds = %254, %250
br label %262
262: ; preds = %261, %248
br label %263
263: ; preds = %262
%264 = load i32, i32* %26
%265 = add nsw i32 %264, 1
store i32 %265, i32* %26
%266 = load double*, double** %16
%267 = getelementptr inbounds double, double* %266, i32 1
store double* %267, double** %16
br label %240
268: ; preds = %240
br label %269
269: ; preds = %268
%270 = load i32, i32* %25
%271 = add nsw i32 %270, 1
store i32 %271, i32* %25
br label %235
272: ; preds = %235
store i32 0, i32* %25
%273 = load i32, i32* %13
store i32 %273, i32* %28
%274 = load i32, i32* %13
%275 = sub nsw i32 %274, 1
store i32 %275, i32* %29
%276 = load double*, double** %9
store double* %276, double** %14
br label %277
277: ; preds = %641, %272
%278 = load i32, i32* %25
%279 = load i32, i32* %13
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %653
281: ; preds = %277
%282 = load i32, i32* %25
%283 = icmp ne i32 %282, 0
br i1 %283, label %284, label %477
284: ; preds = %281
%285 = load i32, i32* %28
%286 = icmp sgt i32 %285, 1
br i1 %286, label %287, label %477
287: ; preds = %284
store double 0.000000e+00, double* %22
store double 0.000000e+00, double* %24
store i32 0, i32* %26
%288 = load double*, double** %14
store double* %288, double** %16
store double 0.000000e+00, double* %20
br label %289
289: ; preds = %306, %287
%290 = load i32, i32* %26
%291 = load i32, i32* %28
%292 = icmp slt i32 %290, %291
br i1 %292, label %293, label %313
293: ; preds = %289
%294 = load double*, double** %16
%295 = load double, double* %294
%296 = load double*, double** %18
%297 = load i32, i32* %26
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %296, i64 %298
store double %295, double* %299
%300 = load double*, double** %16
%301 = load double, double* %300
%302 = load double*, double** %16
%303 = load double, double* %302
%304 = load double, double* %20
%305 = call double @llvm.fmuladd.f64(double %301, double %303, double %304)
store double %305, double* %20
br label %306
306: ; preds = %293
%307 = load i32, i32* %26
%308 = add nsw i32 %307, 1
store i32 %308, i32* %26
%309 = load i32, i32* %13
%310 = load double*, double** %16
%311 = sext i32 %309 to i64
%312 = getelementptr inbounds double, double* %310, i64 %311
store double* %312, double** %16
br label %289
313: ; preds = %289
%314 = load double, double* %20
%315 = fcmp ogt double %314, 0.000000e+00
br i1 %315, label %316, label %468
316: ; preds = %313
%317 = load double, double* %20
%318 = call double @sqrt(double %317)
store double %318, double* %22
%319 = load double*, double** %14
%320 = load double, double* %319
%321 = fcmp olt double %320, 0.000000e+00
br i1 %321, label %322, label %325
322: ; preds = %316
%323 = load double, double* %22
%324 = fneg double %323
store double %324, double* %22
br label %325
325: ; preds = %322, %316
%326 = load double*, double** %14
%327 = load double, double* %326
%328 = load double, double* %22
%329 = load double, double* %20
%330 = call double @llvm.fmuladd.f64(double %327, double %328, double %329)
store double %330, double* %20
%331 = load double, double* %20
%332 = fdiv double 1.000000e+00, %331
store double %332, double* %20
%333 = load double, double* %22
%334 = load double*, double** %18
%335 = getelementptr inbounds double, double* %334, i64 0
%336 = load double, double* %335
%337 = fadd double %336, %333
store double %337, double* %335
%338 = fdiv double 1.000000e+00, %337
store double %338, double* %21
%339 = load double*, double** %14
%340 = load double, double* %339
%341 = load double, double* %22
%342 = fdiv double %340, %341
%343 = call double @llvm.fabs.f64(double %342)
%344 = fadd double 1.000000e+00, %343
store double %344, double* %24
store i32 1, i32* %27
%345 = load i32, i32* %13
%346 = load i32, i32* %25
%347 = sub nsw i32 %345, %346
store i32 %347, i32* %30
br label %348
348: ; preds = %407, %325
%349 = load i32, i32* %27
%350 = load i32, i32* %30
%351 = icmp slt i32 %349, %350
br i1 %351, label %352, label %410
352: ; preds = %348
store i32 0, i32* %26
%353 = load double*, double** %14
%354 = load i32, i32* %27
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %353, i64 %355
store double* %356, double** %16
store double 0.000000e+00, double* %23
br label %357
357: ; preds = %372, %352
%358 = load i32, i32* %26
%359 = load i32, i32* %28
%360 = icmp slt i32 %358, %359
br i1 %360, label %361, label %377
361: ; preds = %357
%362 = load double*, double** %18
%363 = load i32, i32* %26
%364 = add nsw i32 %363, 1
store i32 %364, i32* %26
%365 = sext i32 %363 to i64
%366 = getelementptr inbounds double, double* %362, i64 %365
%367 = load double, double* %366
%368 = load double*, double** %16
%369 = load double, double* %368
%370 = load double, double* %23
%371 = call double @llvm.fmuladd.f64(double %367, double %369, double %370)
store double %371, double* %23
br label %372
372: ; preds = %361
%373 = load i32, i32* %13
%374 = load double*, double** %16
%375 = sext i32 %373 to i64
%376 = getelementptr inbounds double, double* %374, i64 %375
store double* %376, double** %16
br label %357
377: ; preds = %357
store i32 0, i32* %26
%378 = load double*, double** %14
%379 = load i32, i32* %27
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
store double* %381, double** %16
%382 = load double, double* %20
%383 = load double, double* %23
%384 = fmul double %383, %382
store double %384, double* %23
br label %385
385: ; preds = %401, %377
%386 = load i32, i32* %26
%387 = load i32, i32* %28
%388 = icmp slt i32 %386, %387
br i1 %388, label %389, label %406
389: ; preds = %385
%390 = load double, double* %23
%391 = load double*, double** %18
%392 = load i32, i32* %26
%393 = add nsw i32 %392, 1
store i32 %393, i32* %26
%394 = sext i32 %392 to i64
%395 = getelementptr inbounds double, double* %391, i64 %394
%396 = load double, double* %395
%397 = load double*, double** %16
%398 = load double, double* %397
%399 = fneg double %390
%400 = call double @llvm.fmuladd.f64(double %399, double %396, double %398)
store double %400, double* %397
br label %401
401: ; preds = %389
%402 = load i32, i32* %13
%403 = load double*, double** %16
%404 = sext i32 %402 to i64
%405 = getelementptr inbounds double, double* %403, i64 %404
store double* %405, double** %16
br label %385
406: ; preds = %385
br label %407
407: ; preds = %406
%408 = load i32, i32* %27
%409 = add nsw i32 %408, 1
store i32 %409, i32* %27
br label %348
410: ; preds = %348
store i32 0, i32* %27
%411 = load double*, double** %10
%412 = load i32, i32* %25
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %411, i64 %413
store double* %414, double** %15
br label %415
415: ; preds = %460, %410
%416 = load i32, i32* %27
%417 = load i32, i32* %11
%418 = icmp slt i32 %416, %417
br i1 %418, label %419, label %467
419: ; preds = %415
store i32 0, i32* %26
%420 = load double*, double** %15
store double* %420, double** %16
store double 0.000000e+00, double* %23
br label %421
421: ; preds = %425, %419
%422 = load i32, i32* %26
%423 = load i32, i32* %28
%424 = icmp slt i32 %422, %423
br i1 %424, label %425, label %437
425: ; preds = %421
%426 = load double*, double** %18
%427 = load i32, i32* %26
%428 = add nsw i32 %427, 1
store i32 %428, i32* %26
%429 = sext i32 %427 to i64
%430 = getelementptr inbounds double, double* %426, i64 %429
%431 = load double, double* %430
%432 = load double*, double** %16
%433 = getelementptr inbounds double, double* %432, i32 1
store double* %433, double** %16
%434 = load double, double* %432
%435 = load double, double* %23
%436 = call double @llvm.fmuladd.f64(double %431, double %434, double %435)
store double %436, double* %23
br label %421
437: ; preds = %421
store i32 0, i32* %26
%438 = load double*, double** %15
store double* %438, double** %16
%439 = load double, double* %20
%440 = load double, double* %23
%441 = fmul double %440, %439
store double %441, double* %23
br label %442
442: ; preds = %446, %437
%443 = load i32, i32* %26
%444 = load i32, i32* %28
%445 = icmp slt i32 %443, %444
br i1 %445, label %446, label %459
446: ; preds = %442
%447 = load double, double* %23
%448 = load double*, double** %18
%449 = load i32, i32* %26
%450 = add nsw i32 %449, 1
store i32 %450, i32* %26
%451 = sext i32 %449 to i64
%452 = getelementptr inbounds double, double* %448, i64 %451
%453 = load double, double* %452
%454 = load double*, double** %16
%455 = getelementptr inbounds double, double* %454, i32 1
store double* %455, double** %16
%456 = load double, double* %454
%457 = fneg double %447
%458 = call double @llvm.fmuladd.f64(double %457, double %453, double %456)
store double %458, double* %454
br label %442
459: ; preds = %442
br label %460
460: ; preds = %459
%461 = load i32, i32* %27
%462 = add nsw i32 %461, 1
store i32 %462, i32* %27
%463 = load i32, i32* %11
%464 = load double*, double** %15
%465 = sext i32 %463 to i64
%466 = getelementptr inbounds double, double* %464, i64 %465
store double* %466, double** %15
br label %415
467: ; preds = %415
br label %468
468: ; preds = %467, %313
%469 = load double, double* %24
%470 = load double*, double** %14
store double %469, double* %470
%471 = load double, double* %22
%472 = fneg double %471
%473 = load double*, double** %8
%474 = load i32, i32* %25
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds double, double* %473, i64 %475
store double %472, double* %476
br label %477
477: ; preds = %468, %284, %281
%478 = load i32, i32* %28
%479 = icmp eq i32 %478, 1
br i1 %479, label %480, label %487
480: ; preds = %477
%481 = load double*, double** %14
%482 = load double, double* %481
%483 = load double*, double** %8
%484 = load i32, i32* %25
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds double, double* %483, i64 %485
store double %482, double* %486
br label %487
487: ; preds = %480, %477
%488 = load double*, double** %14
%489 = getelementptr inbounds double, double* %488, i64 1
store double* %489, double** %15
%490 = load i32, i32* %29
%491 = icmp sgt i32 %490, 1
br i1 %491, label %492, label %630
492: ; preds = %487
store double 0.000000e+00, double* %22
store double 0.000000e+00, double* %24
store i32 0, i32* %26
%493 = load double*, double** %15
store double* %493, double** %16
store double 0.000000e+00, double* %20
br label %494
494: ; preds = %505, %492
%495 = load i32, i32* %26
%496 = load i32, i32* %29
%497 = icmp slt i32 %495, %496
br i1 %497, label %498, label %510
498: ; preds = %494
%499 = load double*, double** %16
%500 = load double, double* %499
%501 = load double*, double** %16
%502 = load double, double* %501
%503 = load double, double* %20
%504 = call double @llvm.fmuladd.f64(double %500, double %502, double %503)
store double %504, double* %20
br label %505
505: ; preds = %498
%506 = load i32, i32* %26
%507 = add nsw i32 %506, 1
store i32 %507, i32* %26
%508 = load double*, double** %16
%509 = getelementptr inbounds double, double* %508, i32 1
store double* %509, double** %16
br label %494
510: ; preds = %494
%511 = load double, double* %20
%512 = fcmp ogt double %511, 0.000000e+00
br i1 %512, label %513, label %621
513: ; preds = %510
%514 = load double, double* %20
%515 = call double @sqrt(double %514)
store double %515, double* %22
%516 = load double*, double** %15
%517 = load double, double* %516
%518 = fcmp olt double %517, 0.000000e+00
br i1 %518, label %519, label %522
519: ; preds = %513
%520 = load double, double* %22
%521 = fneg double %520
store double %521, double* %22
br label %522
522: ; preds = %519, %513
%523 = load double*, double** %15
%524 = load double, double* %523
%525 = load double, double* %22
%526 = fdiv double %524, %525
%527 = call double @llvm.fabs.f64(double %526)
%528 = fadd double 1.000000e+00, %527
store double %528, double* %24
%529 = load double*, double** %15
%530 = load double, double* %529
%531 = load double, double* %22
%532 = load double, double* %20
%533 = call double @llvm.fmuladd.f64(double %530, double %531, double %532)
store double %533, double* %20
%534 = load double, double* %20
%535 = fdiv double 1.000000e+00, %534
store double %535, double* %20
%536 = load double, double* %22
%537 = load double*, double** %15
%538 = load double, double* %537
%539 = fadd double %538, %536
store double %539, double* %537
%540 = fdiv double 1.000000e+00, %539
store double %540, double* %21
%541 = load i32, i32* %13
store i32 %541, i32* %27
%542 = load i32, i32* %13
%543 = load i32, i32* %13
%544 = load i32, i32* %25
%545 = sub nsw i32 %543, %544
%546 = mul nsw i32 %542, %545
store i32 %546, i32* %30
br label %547
547: ; preds = %600, %522
%548 = load i32, i32* %27
%549 = load i32, i32* %30
%550 = icmp slt i32 %548, %549
br i1 %550, label %551, label %604
551: ; preds = %547
store i32 0, i32* %26
%552 = load double*, double** %15
store double* %552, double** %16
%553 = load double*, double** %15
%554 = load i32, i32* %27
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %553, i64 %555
store double* %556, double** %17
store double 0.000000e+00, double* %23
br label %557
557: ; preds = %570, %551
%558 = load i32, i32* %26
%559 = load i32, i32* %29
%560 = icmp slt i32 %558, %559
br i1 %560, label %561, label %573
561: ; preds = %557
%562 = load double*, double** %16
%563 = getelementptr inbounds double, double* %562, i32 1
store double* %563, double** %16
%564 = load double, double* %562
%565 = load double*, double** %17
%566 = getelementptr inbounds double, double* %565, i32 1
store double* %566, double** %17
%567 = load double, double* %565
%568 = load double, double* %23
%569 = call double @llvm.fmuladd.f64(double %564, double %567, double %568)
store double %569, double* %23
br label %570
570: ; preds = %561
%571 = load i32, i32* %26
%572 = add nsw i32 %571, 1
store i32 %572, i32* %26
br label %557
573: ; preds = %557
store i32 0, i32* %26
%574 = load double*, double** %15
store double* %574, double** %16
%575 = load double*, double** %15
%576 = load i32, i32* %27
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %575, i64 %577
store double* %578, double** %17
%579 = load double, double* %20
%580 = load double, double* %23
%581 = fmul double %580, %579
store double %581, double* %23
br label %582
582: ; preds = %596, %573
%583 = load i32, i32* %26
%584 = load i32, i32* %29
%585 = icmp slt i32 %583, %584
br i1 %585, label %586, label %599
586: ; preds = %582
%587 = load double, double* %23
%588 = load double*, double** %16
%589 = getelementptr inbounds double, double* %588, i32 1
store double* %589, double** %16
%590 = load double, double* %588
%591 = load double*, double** %17
%592 = getelementptr inbounds double, double* %591, i32 1
store double* %592, double** %17
%593 = load double, double* %591
%594 = fneg double %587
%595 = call double @llvm.fmuladd.f64(double %594, double %590, double %593)
store double %595, double* %591
br label %596
596: ; preds = %586
%597 = load i32, i32* %26
%598 = add nsw i32 %597, 1
store i32 %598, i32* %26
br label %582
599: ; preds = %582
br label %600
600: ; preds = %599
%601 = load i32, i32* %13
%602 = load i32, i32* %27
%603 = add nsw i32 %602, %601
store i32 %603, i32* %27
br label %547
604: ; preds = %547
store i32 1, i32* %26
%605 = load double*, double** %15
%606 = getelementptr inbounds double, double* %605, i64 1
store double* %606, double** %16
br label %607
607: ; preds = %617, %604
%608 = load i32, i32* %26
%609 = load i32, i32* %29
%610 = icmp slt i32 %608, %609
br i1 %610, label %611, label %620
611: ; preds = %607
%612 = load double, double* %21
%613 = load double*, double** %16
%614 = getelementptr inbounds double, double* %613, i32 1
store double* %614, double** %16
%615 = load double, double* %613
%616 = fmul double %615, %612
store double %616, double* %613
br label %617
617: ; preds = %611
%618 = load i32, i32* %26
%619 = add nsw i32 %618, 1
store i32 %619, i32* %26
br label %607
620: ; preds = %607
br label %621
621: ; preds = %620, %510
%622 = load double, double* %24
%623 = load double*, double** %15
store double %622, double* %623
%624 = load double, double* %22
%625 = fneg double %624
%626 = load double*, double** %19
%627 = load i32, i32* %25
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds double, double* %626, i64 %628
store double %625, double* %629
br label %630
630: ; preds = %621, %487
%631 = load i32, i32* %29
%632 = icmp eq i32 %631, 1
br i1 %632, label %633, label %640
633: ; preds = %630
%634 = load double*, double** %15
%635 = load double, double* %634
%636 = load double*, double** %19
%637 = load i32, i32* %25
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds double, double* %636, i64 %638
store double %635, double* %639
br label %640
640: ; preds = %633, %630
br label %641
641: ; preds = %640
%642 = load i32, i32* %25
%643 = add nsw i32 %642, 1
store i32 %643, i32* %25
%644 = load i32, i32* %28
%645 = add nsw i32 %644, -1
store i32 %645, i32* %28
%646 = load i32, i32* %29
%647 = add nsw i32 %646, -1
store i32 %647, i32* %29
%648 = load i32, i32* %13
%649 = add nsw i32 %648, 1
%650 = load double*, double** %14
%651 = sext i32 %649 to i64
%652 = getelementptr inbounds double, double* %650, i64 %651
store double* %652, double** %14
br label %277
653: ; preds = %277
%654 = load double*, double** %9
%655 = load double*, double** %12
%656 = load i32, i32* %13
%657 = call i32 (double*, double*, i32, ...) bitcast (i32 (...)* @ldvmat to i32 (double*, double*, i32, ...)*)(double* %654, double* %655, i32 %656)
%658 = load double*, double** %8
%659 = load double*, double** %19
%660 = load double*, double** %10
%661 = load i32, i32* %11
%662 = load double*, double** %12
%663 = load i32, i32* %13
%664 = call i32 (double*, double*, double*, i32, double*, i32, ...) bitcast (i32 (...)* @qrbdv to i32 (double*, double*, double*, i32, double*, i32, ...)*)(double* %658, double* %659, double* %660, i32 %661, double* %662, i32 %663)
store i32 0, i32* %25
br label %665
665: ; preds = %709, %653
%666 = load i32, i32* %25
%667 = load i32, i32* %13
%668 = icmp slt i32 %666, %667
br i1 %668, label %669, label %712
669: ; preds = %665
%670 = load double*, double** %8
%671 = load i32, i32* %25
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds double, double* %670, i64 %672
%674 = load double, double* %673
%675 = fcmp olt double %674, 0.000000e+00
br i1 %675, label %676, label %708
676: ; preds = %669
%677 = load double*, double** %8
%678 = load i32, i32* %25
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %677, i64 %679
%681 = load double, double* %680
%682 = fneg double %681
%683 = load double*, double** %8
%684 = load i32, i32* %25
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds double, double* %683, i64 %685
store double %682, double* %686
store i32 0, i32* %26
%687 = load double*, double** %12
%688 = load i32, i32* %25
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %687, i64 %689
store double* %690, double** %14
br label %691
691: ; preds = %700, %676
%692 = load i32, i32* %26
%693 = load i32, i32* %13
%694 = icmp slt i32 %692, %693
br i1 %694, label %695, label %707
695: ; preds = %691
%696 = load double*, double** %14
%697 = load double, double* %696
%698 = fneg double %697
%699 = load double*, double** %14
store double %698, double* %699
br label %700
700: ; preds = %695
%701 = load i32, i32* %26
%702 = add nsw i32 %701, 1
store i32 %702, i32* %26
%703 = load i32, i32* %13
%704 = load double*, double** %14
%705 = sext i32 %703 to i64
%706 = getelementptr inbounds double, double* %704, i64 %705
store double* %706, double** %14
br label %691
707: ; preds = %691
br label %708
708: ; preds = %707, %669
br label %709
709: ; preds = %708
%710 = load i32, i32* %25
%711 = add nsw i32 %710, 1
store i32 %711, i32* %25
br label %665
712: ; preds = %665
%713 = load double*, double** %18
%714 = bitcast double* %713 to i8*
store i32 0, i32* %7
br label %715
715: ; preds = %712, %34
%716 = load i32, i32* %7
ret i32 %716
}

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