int sv2u1v(double *d, double *a, 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;
  }
  for (i = 0, q = v, p = a; i < n; ++i) {
    for (j = 0; j < n; ++j, ++q, ++p) {
      if (j < i)
        *q = 0.;
      else if (j == i)
        *q = d[i];
      else
        *q = *p;
    }
  }
  atou1(a, m, n);
  for (i = 0, mm = n, nm = n - 1, p = v; 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 = a + i; k < m; ++k, p1 += n) {
          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;
  }
  atovm(v, n);
  qrbdu1(d, e, a, 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):
<sv2u1v>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1196 <sv2u1v+0x36>
movl   $0xffffffff,-0x4(%rbp)
jmp    2134 <sv2u1v+0xfd4>
mov    -0x1c(%rbp),%eax
add    -0x2c(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15f3 <sv2u1v+0x493>
cmpl   $0x1,-0x98(%rbp)
jle    158e <sv2u1v+0x42e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x90(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1299 <sv2u1v+0x139>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1224 <sv2u1v+0xc4>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1552 <sv2u1v+0x3f2>
movsd  -0x68(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    12ec <sv2u1v+0x18c>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x1ced(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x58(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x1cca(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x78(%rbp),%xmm1
movaps 0x1cbd(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1ca1(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x94(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    14e2 <sv2u1v+0x382>
movl   $0x0,-0x90(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1421 <sv2u1v+0x2c1>
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    13be <sv2u1v+0x25e>
movsd  -0x80(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    14c9 <sv2u1v+0x369>
movsd  -0x80(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%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    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1450 <sv2u1v+0x2f0>
jmp    14ce <sv2u1v+0x36e>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1384 <sv2u1v+0x224>
movl   $0x1,-0x90(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    154d <sv2u1v+0x3ed>
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x48(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
jmp    14f4 <sv2u1v+0x394>
jmp    1552 <sv2u1v+0x3f2>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x98(%rbp)
jne    15b3 <sv2u1v+0x453>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15b8 <sv2u1v+0x458>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    11db <sv2u1v+0x7b>
movl   $0x0,-0x8c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16e5 <sv2u1v+0x585>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16cc <sv2u1v+0x56c>
mov    -0x90(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    1657 <sv2u1v+0x4f7>
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    169b <sv2u1v+0x53b>
mov    -0x90(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jne    1686 <sv2u1v+0x526>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1696 <sv2u1v+0x536>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    169b <sv2u1v+0x53b>
jmp    16a0 <sv2u1v+0x540>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
jmp    1626 <sv2u1v+0x4c6>
jmp    16d1 <sv2u1v+0x571>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    160d <sv2u1v+0x4ad>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    $0x0,%al
call   1050 <atou1@plt>
movl   $0x0,-0x8c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1ff2 <sv2u1v+0xe92>
cmpl   $0x0,-0x8c(%rbp)
je     1bd2 <sv2u1v+0xa72>
cmpl   $0x1,-0x98(%rbp)
jle    1bd2 <sv2u1v+0xa72>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x90(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    17e8 <sv2u1v+0x688>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1773 <sv2u1v+0x613>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b96 <sv2u1v+0xa36>
movsd  -0x68(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    183b <sv2u1v+0x6db>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x179e(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x58(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x177b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x78(%rbp),%xmm1
movaps 0x176e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1752(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x94(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1a31 <sv2u1v+0x8d1>
movl   $0x0,-0x90(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1970 <sv2u1v+0x810>
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    190d <sv2u1v+0x7ad>
movl   $0x0,-0x90(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1a18 <sv2u1v+0x8b8>
movsd  -0x80(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%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    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    199f <sv2u1v+0x83f>
jmp    1a1d <sv2u1v+0x8bd>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    18d3 <sv2u1v+0x773>
movl   $0x0,-0x94(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b91 <sv2u1v+0xa31>
movl   $0x0,-0x90(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1ad3 <sv2u1v+0x973>
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1a7a <sv2u1v+0x91a>
movl   $0x0,-0x90(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1b63 <sv2u1v+0xa03>
movsd  -0x80(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%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    1af4 <sv2u1v+0x994>
jmp    1b68 <sv2u1v+0xa08>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1a51 <sv2u1v+0x8f1>
jmp    1b96 <sv2u1v+0xa36>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x98(%rbp)
jne    1bf7 <sv2u1v+0xa97>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x1,-0x9c(%rbp)
jle    1f7e <sv2u1v+0xe1e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x90(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1c91 <sv2u1v+0xb31>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
jmp    1c3d <sv2u1v+0xadd>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f42 <sv2u1v+0xde2>
movsd  -0x68(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1ce4 <sv2u1v+0xb84>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
divsd  -0x78(%rbp),%xmm1
movaps 0x1318(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x12fc(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x12c9(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x40(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x12a6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1ee5 <sv2u1v+0xd85>
movl   $0x0,-0x90(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1e21 <sv2u1v+0xcc1>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1dc3 <sv2u1v+0xc63>
movl   $0x0,-0x90(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1ecc <sv2u1v+0xd6c>
movsd  -0x80(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  (%rax),%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)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1e58 <sv2u1v+0xcf8>
jmp    1ed1 <sv2u1v+0xd71>
mov    -0x2c(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    1d81 <sv2u1v+0xc21>
movl   $0x1,-0x90(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1f3d <sv2u1v+0xddd>
movsd  -0x70(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1efb <sv2u1v+0xd9b>
jmp    1f42 <sv2u1v+0xde2>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x9c(%rbp)
jne    1fa3 <sv2u1v+0xe43>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1fa8 <sv2u1v+0xe48>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
mov    -0x9c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    171d <sv2u1v+0x5bd>
mov    -0x28(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    $0x0,%al
call   1070 <atovm@plt>
mov    -0x10(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%r8
mov    -0x2c(%rbp),%r9d
mov    $0x0,%al
call   1080 <qrbdu1@plt>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    2124 <sv2u1v+0xfc4>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    210b <sv2u1v+0xfab>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x90(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x8c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    2106 <sv2u1v+0xfa6>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    20a7 <sv2u1v+0xf47>
jmp    210b <sv2u1v+0xfab>
jmp    2110 <sv2u1v+0xfb0>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    2028 <sv2u1v+0xec8>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sv2u1v>:
mov    $0xffffffff,%eax
cmp    %r8d,%edx
jl     2957 <sv2u1v+0x17f7>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r8d,%r12d
mov    %edx,%r14d
mov    %rsi,%r15
mov    %rdi,%r13
mov    %rcx,0x80(%rsp)
lea    (%r12,%r14,1),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%rbx
movslq %r14d,%rax
lea    (%rbx,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    %r12d,%eax
mov    %rax,0x10(%rsp)
test   %r12d,%r12d
mov    %r14,0x70(%rsp)
mov    %r15,0x58(%rsp)
mov    %r12,0xa0(%rsp)
jle    1879 <sv2u1v+0x719>
mov    %r13,0x68(%rsp)
mov    0x10(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0xd8(%rsp)
lea    0x8(,%rax,8),%r11
mov    %rax,%r9
shl    $0x5,%r9
lea    0x0(,%rax,8),%rbp
lea    0x8(%r15),%r8
lea    0x0(,%rbp,2),%rcx
add    %rbp,%rcx
mov    %rcx,0x40(%rsp)
shl    $0x4,%rax
mov    %rax,0x30(%rsp)
lea    0x3(%r14),%r13d
xor    %esi,%esi
xorpd  %xmm10,%xmm10
movapd 0x1dca(%rip),%xmm7
movsd  0x1de1(%rip),%xmm8
movapd 0x1dc8(%rip),%xmm9
mov    %r15,%r10
mov    %r12d,%ecx
mov    %r14d,%r15d
mov    %r9,0x8(%rsp)
mov    %r11,0x88(%rsp)
jmp    1281 <sv2u1v+0x121>
add    $0x1,%rsi
lea    -0x1(%r12),%r15d
add    %r11,%r10
add    $0xffffffff,%ecx
add    %r11,%r8
add    $0x3,%r13b
cmp    0x10(%rsp),%rsi
je     1733 <sv2u1v+0x5d3>
movzbl %r13b,%r13d
and    $0x3,%r13d
mov    %r15d,%r12d
cmp    $0x2,%r15d
jl     1715 <sv2u1v+0x5b5>
mov    %ecx,0x28(%rsp)
lea    -0x1(%r12),%rcx
and    $0x3,%r15d
mov    %r12d,%r14d
and    $0xfffffffc,%r14d
mov    %rcx,%rax
mov    %rcx,(%rsp)
xorpd  %xmm5,%xmm5
cmp    $0x3,%rcx
jae    12d0 <sv2u1v+0x170>
xor    %ecx,%ecx
mov    %r10,%rax
test   $0x3,%r12b
jne    134d <sv2u1v+0x1ed>
jmp    137d <sv2u1v+0x21d>
nop
mov    %r10,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
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    12e0 <sv2u1v+0x180>
add    %r9,%rax
test   $0x3,%r12b
je     137d <sv2u1v+0x21d>
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    1360 <sv2u1v+0x200>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm5
xorpd  %xmm2,%xmm2
jbe    16fe <sv2u1v+0x59e>
ucomisd %xmm10,%xmm5
mov    %r8,0x38(%rsp)
mov    %rsi,0x50(%rsp)
jb     13a9 <sv2u1v+0x249>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    13fa <sv2u1v+0x29a>
movapd %xmm5,%xmm0
mov    %r10,0x20(%rsp)
movsd  %xmm5,0xa8(%rsp)
call   1060 <sqrt@plt>
movsd  0xa8(%rsp),%xmm5
mov    0x20(%rsp),%r10
xorpd  %xmm10,%xmm10
mov    0x50(%rsp),%rsi
mov    0x88(%rsp),%r11
movapd 0x1c27(%rip),%xmm9
movsd  0x1c2e(%rip),%xmm8
movapd 0x1c06(%rip),%xmm7
lea    -0x2(%r12),%rax
mov    %rax,0x20(%rsp)
mov    %r10,%r8
movsd  (%r10),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm7,%xmm3
movapd %xmm2,%xmm1
cmpltsd %xmm10,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movsd  (%rbx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
mov    0xa0(%rsp),%rax
sub    %esi,%eax
cmp    $0x2,%eax
jl     1630 <sv2u1v+0x4d0>
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm8,%xmm3
divsd  %xmm4,%xmm3
mov    0x28(%rsp),%r9d
mov    $0x1,%edx
mov    0x38(%rsp),%r10
jmp    1481 <sv2u1v+0x321>
nop
add    $0x1,%rdx
add    $0x8,%r10
cmp    %r9,%rdx
je     1630 <sv2u1v+0x4d0>
test   %r12d,%r12d
jle    1470 <sv2u1v+0x310>
lea    (%r8,%rdx,8),%rsi
cmpq   $0x3,(%rsp)
jae    14b0 <sv2u1v+0x350>
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
mov    %rsi,%rax
test   $0x3,%r12b
jne    151f <sv2u1v+0x3bf>
jmp    1549 <sv2u1v+0x3e9>
cs nopw 0x0(%rax,%rax,1)
nop
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 <sv2u1v+0x360>
add    0x8(%rsp),%rax
test   $0x3,%r12b
je     1549 <sv2u1v+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 <sv2u1v+0x3d0>
test   %r12d,%r12d
jle    1470 <sv2u1v+0x310>
xorpd  %xmm7,%xmm4
mulsd  %xmm3,%xmm4
cmpq   $0x3,(%rsp)
jae    1572 <sv2u1v+0x412>
xor    %ecx,%ecx
test   $0x3,%r12b
jne    15fa <sv2u1v+0x49a>
jmp    1470 <sv2u1v+0x310>
mov    %r10,%rax
xor    %ecx,%ecx
nopw   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 <sv2u1v+0x420>
add    0x8(%rsp),%rsi
test   $0x3,%r12b
je     1470 <sv2u1v+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 <sv2u1v+0x4a0>
jmp    1470 <sv2u1v+0x310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm8,%xmm3
divsd  %xmm0,%xmm3
mov    $0x1,%eax
mov    %r8,%r10
mov    %r8,%rcx
cmpq   $0x3,0x20(%rsp)
mov    0x8(%rsp),%r9
mov    0x38(%rsp),%r8
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rsi
jb     16bd <sv2u1v+0x55d>
mov    (%rsp),%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r10,%rcx
xor    %eax,%eax
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,%rsi,1)
movsd  0x18(%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rdi,1)
movsd  0x20(%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%r9,1)
add    %r9,%rcx
add    $0x4,%rax
cmp    %rax,%rdx
jne    1670 <sv2u1v+0x510>
add    $0x1,%rax
divsd  %xmm1,%xmm2
andpd  %xmm9,%xmm2
addsd  %xmm8,%xmm2
testb  $0x3,(%rsp)
je     16f9 <sv2u1v+0x599>
lea    (%rbx,%rax,8),%rax
mov    0x10(%rsp),%rdx
lea    (%rcx,%rdx,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    16e0 <sv2u1v+0x580>
mov    0x50(%rsp),%rsi
movsd  %xmm2,(%r10)
xorpd  %xmm7,%xmm1
mov    0x68(%rsp),%rax
movlpd %xmm1,(%rax,%rsi,8)
mov    0x28(%rsp),%ecx
cmp    $0x1,%r12d
jne    1260 <sv2u1v+0x100>
movsd  (%r10),%xmm0
mov    0x68(%rsp),%rax
movsd  %xmm0,(%rax,%rsi,8)
jmp    1260 <sv2u1v+0x100>
mov    0xa0(%rsp),%r12
test   %r12d,%r12d
mov    0x68(%rsp),%r13
mov    0x70(%rsp),%r14
mov    0x58(%rsp),%r15
jle    1879 <sv2u1v+0x719>
lea    -0x1(%r12),%r14d
mov    %r12d,%r9d
and    $0xfffffffe,%r9d
neg    %r9d
xor    %r8d,%r8d
xor    %edx,%edx
mov    %r15,%rsi
mov    0x80(%rsp),%r15
mov    %r15,%r10
jmp    17a0 <sv2u1v+0x640>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%r10)
add    $0x8,%r10
add    $0x8,%rsi
add    $0x1,%rdx
add    $0xffffffffffffffff,%r8
cmp    0x10(%rsp),%rdx
je     19d9 <sv2u1v+0x879>
lea    0x0(,%rdx,8),%r11
add    %r13,%r11
test   %r14d,%r14d
je     1850 <sv2u1v+0x6f0>
mov    $0x1,%ecx
mov    %r10,%rdi
jmp    17da <sv2u1v+0x67a>
xchg   %ax,%ax
movsd  %xmm0,0x8(%rdi)
add    $0x10,%rsi
add    $0x2,%rcx
lea    (%r9,%rcx,1),%ebp
add    $0x10,%rdi
cmp    $0x1,%ebp
je     1830 <sv2u1v+0x6d0>
mov    %rdi,%rax
lea    -0x1(%rcx),%rdi
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
cmp    %rdi,%rdx
ja     1801 <sv2u1v+0x6a1>
lea    (%r8,%rcx,1),%rdi
cmp    $0x1,%rdi
mov    %rsi,%rdi
cmove  %r11,%rdi
movsd  (%rdi),%xmm1
lea    (%r10,%rcx,8),%rdi
add    $0xfffffffffffffff8,%rdi
movsd  %xmm1,(%rdi)
cmp    %rcx,%rdx
ja     17c0 <sv2u1v+0x660>
lea    0x8(%rsi),%rbp
cmp    %rcx,%rdx
cmove  %r11,%rbp
movsd  0x0(%rbp),%xmm0
jmp    17c0 <sv2u1v+0x660>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x10,%rax
add    $0xffffffff,%ecx
mov    %rax,%r10
test   $0x1,%r12b
je     178d <sv2u1v+0x62d>
jmp    185c <sv2u1v+0x6fc>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   $0x1,%r12b
je     178d <sv2u1v+0x62d>
mov    %ecx,%eax
xorpd  %xmm0,%xmm0
cmp    %rax,%rdx
ja     1780 <sv2u1v+0x620>
cmovne %rsi,%r11
movsd  (%r11),%xmm0
jmp    1780 <sv2u1v+0x620>
mov    %r15,%rdi
mov    %r14d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <atou1@plt>
mov    0x80(%rsp),%r15
mov    %r15,%rdi
mov    0xa0(%rsp),%r14
mov    %r14d,%esi
xor    %eax,%eax
call   1070 <atovm@plt>
mov    %r13,%rdi
mov    0x90(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    0x70(%rsp),%rcx
mov    %r15,%r8
mov    %r14d,%r9d
xor    %eax,%eax
call   1080 <qrbdu1@plt>
test   %r14d,%r14d
jle    293c <sv2u1v+0x17dc>
lea    -0x1(%r14),%r9d
mov    %r14d,%r10d
and    $0x3,%r10d
and    $0xfffffffc,%r14d
mov    0x10(%rsp),%rax
mov    %rax,%r8
shl    $0x5,%r8
lea    0x0(,%rax,8),%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
movapd 0x16fe(%rip),%xmm1
movapd 0x16f6(%rip),%xmm2
mov    %r15,%r11
jmp    1923 <sv2u1v+0x7c3>
nop
add    $0x1,%rdi
add    $0x8,%r11
cmp    0x10(%rsp),%rdi
je     293c <sv2u1v+0x17dc>
movsd  0x0(%r13,%rdi,8),%xmm3
ucomisd %xmm3,%xmm0
jbe    1910 <sv2u1v+0x7b0>
xorpd  %xmm1,%xmm3
movlpd %xmm3,0x0(%r13,%rdi,8)
cmp    $0x3,%r9d
jae    1950 <sv2u1v+0x7f0>
lea    (%r15,%rdi,8),%rcx
test   %r10d,%r10d
jne    19b9 <sv2u1v+0x859>
jmp    1910 <sv2u1v+0x7b0>
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    1960 <sv2u1v+0x800>
add    %r8,%rcx
test   %r10d,%r10d
je     1910 <sv2u1v+0x7b0>
mov    %r10d,%eax
nopl   0x0(%rax)
movsd  (%rcx),%xmm3
xorpd  %xmm1,%xmm3
movlpd %xmm3,(%rcx)
add    %rsi,%rcx
add    $0xffffffff,%eax
jne    19c0 <sv2u1v+0x860>
jmp    1910 <sv2u1v+0x7b0>
mov    0x58(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    %ebp,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <atou1@plt>
test   %r12d,%r12d
jle    2910 <sv2u1v+0x17b0>
lea    -0x3(%r12),%r8d
mov    0x10(%rsp),%rcx
lea    0x2(%rcx),%rax
mov    %rax,0xc0(%rsp)
lea    -0x2(%r12),%ebp
lea    0x8(,%rcx,8),%rax
mov    %rax,0xa8(%rsp)
mov    %rcx,%r9
shl    $0x5,%r9
mov    %r14d,%edx
lea    0x0(,%rcx,8),%r14
mov    %r15,%rax
add    $0x8,%r15
lea    (%rax,%rcx,8),%rdi
add    $0x8,%rdi
xor    %r10d,%r10d
xorpd  %xmm14,%xmm14
mov    %r8d,0xb4(%rsp)
mov    %ebp,0x78(%rsp)
mov    %ebp,%esi
mov    %edx,0x7c(%rsp)
mov    %edx,%ebp
mov    0x58(%rsp),%rdx
mov    %rax,0x8(%rsp)
mov    %r12d,%ecx
movapd 0x158a(%rip),%xmm11
movsd  0x15a1(%rip),%xmm12
movapd 0x1588(%rip),%xmm13
mov    %r9,0x60(%rsp)
jmp    1ace <sv2u1v+0x96e>
nop
movsd  (%r9),%xmm0
movsd  %xmm0,(%rax,%r10,8)
add    $0x1,%r10
mov    0xa8(%rsp),%rax
add    %rax,0x8(%rsp)
add    %rax,%r15
add    $0x8,%rdx
add    $0xffffffff,%ebp
add    %rax,%rdi
add    $0xffffffff,%esi
add    $0xffffffff,%r8d
cmp    0x10(%rsp),%r10
mov    %r11,%r9
je     1889 <sv2u1v+0x729>
mov    %ecx,%r12d
test   %r10,%r10
je     213b <sv2u1v+0xfdb>
cmp    $0x2,%ecx
jl     213b <sv2u1v+0xfdb>
mov    %rbp,0x20(%rsp)
mov    %r12d,%ebp
and    $0xfffffffc,%ebp
mov    %ecx,%r13d
and    $0x3,%r13d
lea    -0x1(%r12),%rax
mov    %rax,(%rsp)
cmp    $0x3,%rax
mov    %rdx,0x40(%rsp)
mov    %rcx,0x38(%rsp)
xorpd  %xmm1,%xmm1
jae    1b30 <sv2u1v+0x9d0>
xor    %ecx,%ecx
mov    0x8(%rsp),%rax
test   $0x3,%r12b
jne    1bae <sv2u1v+0xa4e>
jmp    1bdd <sv2u1v+0xa7d>
nopl   0x0(%rax,%rax,1)
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    %r14,%rdx
movsd  (%rax,%r14,1),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r14,%rdx,1),%xmm0
add    %r14,%rdx
movsd  %xmm0,0x10(%rbx,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r14,%rdx,1),%xmm1
add    %r14,%rdx
movsd  %xmm1,0x18(%rbx,%rcx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
add    $0x4,%rcx
add    %r14,%rdx
cmp    %rcx,%rbp
jne    1b40 <sv2u1v+0x9e0>
add    %r9,%rax
test   $0x3,%r12b
je     1bdd <sv2u1v+0xa7d>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rdx
add    %r14,%rax
cmp    %rdx,%r13
jne    1bc0 <sv2u1v+0xa60>
xorpd  %xmm9,%xmm9
ucomisd %xmm9,%xmm1
xorpd  %xmm8,%xmm8
jbe    2111 <sv2u1v+0xfb1>
mov    %esi,0x1c(%rsp)
mov    %rdi,0x48(%rsp)
ucomisd %xmm14,%xmm1
mov    %r10,0x30(%rsp)
mov    %r8d,0x18(%rsp)
jb     1c15 <sv2u1v+0xab5>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1c54 <sv2u1v+0xaf4>
movapd %xmm1,%xmm0
movsd  %xmm1,0x28(%rsp)
call   1060 <sqrt@plt>
movsd  0x28(%rsp),%xmm1
xorpd  %xmm14,%xmm14
mov    0x30(%rsp),%r10
mov    0x60(%rsp),%r9
movapd 0x13ce(%rip),%xmm13
movsd  0x13d5(%rip),%xmm12
movapd 0x13ac(%rip),%xmm11
mov    0x8(%rsp),%r11
movsd  (%r11),%xmm8
movapd %xmm0,%xmm3
xorpd  %xmm11,%xmm3
movapd %xmm8,%xmm9
cmpltsd %xmm14,%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    0x10(%rsp),%rax
sub    %r10,%rax
cmp    $0x2,%rax
jl     1e90 <sv2u1v+0xd30>
mov    $0x1,%eax
mov    %r15,%r8
jmp    1ce1 <sv2u1v+0xb81>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x8,%r8
cmp    %r12,%rax
je     1e90 <sv2u1v+0xd30>
lea    (%r11,%rax,8),%rcx
cmpq   $0x3,(%rsp)
jae    1d00 <sv2u1v+0xba0>
xorpd  %xmm3,%xmm3
xor    %edi,%edi
mov    %rcx,%rdx
test   $0x3,%r12b
jne    1d6e <sv2u1v+0xc0e>
jmp    1d99 <sv2u1v+0xc39>
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    %r14,%rsi
mulsd  (%rdx,%r14,1),%xmm5
addsd  %xmm4,%xmm5
movsd  0x10(%rbx,%rdi,8),%xmm4
mulsd  (%r14,%rsi,1),%xmm4
add    %r14,%rsi
addsd  %xmm5,%xmm4
movsd  0x18(%rbx,%rdi,8),%xmm3
add    $0x4,%rdi
mulsd  (%r14,%rsi,1),%xmm3
add    %r14,%rsi
addsd  %xmm4,%xmm3
add    %r14,%rsi
cmp    %rdi,%rbp
jne    1d10 <sv2u1v+0xbb0>
add    %r9,%rdx
test   $0x3,%r12b
je     1d99 <sv2u1v+0xc39>
lea    (%rbx,%rdi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rdi,8),%xmm4
mulsd  (%rdx),%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rdi
add    %r14,%rdx
cmp    %rdi,%r13
jne    1d80 <sv2u1v+0xc20>
test   %r12d,%r12d
jle    1cd0 <sv2u1v+0xb70>
xorpd  %xmm11,%xmm3
mulsd  %xmm0,%xmm3
cmpq   $0x3,(%rsp)
jae    1dd0 <sv2u1v+0xc70>
xor    %esi,%esi
test   $0x3,%r12b
jne    1e5a <sv2u1v+0xcfa>
jmp    1cd0 <sv2u1v+0xb70>
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    %r14,%rdx
movsd  0x8(%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rcx,%r14,1),%xmm4
movsd  %xmm4,(%rcx,%r14,1)
lea    (%rdx,%r14,1),%rdi
movsd  0x10(%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%r14,%rdx,1),%xmm4
movsd  %xmm4,(%r14,%rdx,1)
lea    (%rdi,%r14,1),%rdx
movsd  0x18(%rbx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%r14,%rdi,1),%xmm4
add    $0x4,%rsi
movsd  %xmm4,(%r14,%rdi,1)
add    %r14,%rdx
cmp    %rsi,%rbp
jne    1de0 <sv2u1v+0xc80>
add    %r9,%rcx
test   $0x3,%r12b
je     1cd0 <sv2u1v+0xb70>
lea    (%rbx,%rsi,8),%rdx
xor    %esi,%esi
movsd  (%rdx,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rcx),%xmm4
movsd  %xmm4,(%rcx)
add    $0x1,%rsi
add    %r14,%rcx
cmp    %rsi,%r13
jne    1e60 <sv2u1v+0xd00>
jmp    1cd0 <sv2u1v+0xb70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
divsd  %xmm9,%xmm8
andpd  %xmm13,%xmm8
addsd  %xmm12,%xmm8
cmpl   $0x0,0x70(%rsp)
jle    2103 <sv2u1v+0xfa3>
lea    -0x4(%rbp),%rax
mov    0x38(%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    0x40(%rsp),%rdx
jmp    1f00 <sv2u1v+0xda0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%edi
add    %r14,%rdx
cmp    0x70(%rsp),%edi
je     20f2 <sv2u1v+0xf92>
test   %r12d,%r12d
jle    1ef0 <sv2u1v+0xd90>
cmpq   $0x3,(%rsp)
jae    1f20 <sv2u1v+0xdc0>
xorpd  %xmm3,%xmm3
xor    %ecx,%ecx
mov    %rdx,%rax
jmp    1f77 <sv2u1v+0xe17>
nopw   0x0(%rax,%rax,1)
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,%rbp
jne    1f30 <sv2u1v+0xdd0>
test   $0x3,%r12b
je     1fa7 <sv2u1v+0xe47>
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,%r13
jne    1f90 <sv2u1v+0xe30>
test   %r12d,%r12d
jle    1ef0 <sv2u1v+0xd90>
xorpd  %xmm11,%xmm3
mulsd  %xmm0,%xmm3
cmp    $0x4,%r12d
jae    1fca <sv2u1v+0xe6a>
xor    %r8d,%r8d
mov    %rdx,%rax
jmp    20a6 <sv2u1v+0xf46>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
test   %r10,%r10
je     20e4 <sv2u1v+0xf84>
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    1ff0 <sv2u1v+0xe90>
test   $0x1,%r9b
je     2096 <sv2u1v+0xf36>
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     1ef0 <sv2u1v+0xd90>
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    20c0 <sv2u1v+0xf60>
jmp    1ef0 <sv2u1v+0xd90>
xor    %eax,%eax
test   $0x1,%r9b
jne    2065 <sv2u1v+0xf05>
jmp    2096 <sv2u1v+0xf36>
mov    0x60(%rsp),%r9
mov    0x48(%rsp),%rdi
mov    0x30(%rsp),%r10
jmp    2108 <sv2u1v+0xfa8>
mov    0x48(%rsp),%rdi
mov    0x18(%rsp),%r8d
mov    0x1c(%rsp),%esi
mov    0x8(%rsp),%rax
movsd  %xmm8,(%rax)
xorpd  %xmm11,%xmm9
mov    0x68(%rsp),%r13
movlpd %xmm9,0x0(%r13,%r10,8)
mov    0x20(%rsp),%rbp
mov    0x40(%rsp),%rdx
mov    0x38(%rsp),%rcx
mov    %r9,%r11
add    $0xffffffff,%ecx
mov    0x8(%rsp),%r9
mov    %r13,%rax
cmp    $0x1,%r12d
je     1a90 <sv2u1v+0x930>
mov    0x8(%rsp),%rax
add    $0x8,%rax
mov    %rax,(%rsp)
cmp    $0x3,%r12d
jl     28f6 <sv2u1v+0x1796>
mov    %rcx,0x38(%rsp)
mov    0x78(%rsp),%eax
mov    %eax,%ecx
sub    %r10d,%ecx
mov    %ebp,%r13d
and    $0x3,%r13d
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %eax,0x88(%rsp)
mov    0x7c(%rsp),%eax
sub    %r10d,%eax
mov    %eax,0x50(%rsp)
xorpd  %xmm2,%xmm2
mov    (%rsp),%rax
mov    %rcx,0x28(%rsp)
cmp    $0x3,%ecx
jb     21fc <sv2u1v+0x109c>
xorpd  %xmm2,%xmm2
mov    0x88(%rsp),%ecx
mov    (%rsp),%rax
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    21c0 <sv2u1v+0x1060>
testb  $0x3,0x50(%rsp)
je     2226 <sv2u1v+0x10c6>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rcx
cmp    %ecx,%r13d
jne    2210 <sv2u1v+0x10b0>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
xorpd  %xmm10,%xmm10
mov    0x38(%rsp),%rcx
jbe    28d5 <sv2u1v+0x1775>
ucomisd %xmm14,%xmm2
mov    %rdi,0x48(%rsp)
mov    %r8d,0x18(%rsp)
mov    %esi,0x1c(%rsp)
mov    %rbp,0x20(%rsp)
mov    %rdx,0x40(%rsp)
jb     2266 <sv2u1v+0x1106>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    22a7 <sv2u1v+0x1147>
movapd %xmm2,%xmm0
mov    %r10,%rbp
movsd  %xmm2,0x98(%rsp)
call   1060 <sqrt@plt>
movsd  0x98(%rsp),%xmm2
xorpd  %xmm14,%xmm14
mov    %rbp,%r10
movapd 0xd7b(%rip),%xmm13
movsd  0xd82(%rip),%xmm12
movapd 0xd59(%rip),%xmm11
mov    (%rsp),%rcx
mov    0xb4(%rsp),%eax
sub    %r10d,%eax
mov    %rax,0x108(%rsp)
movsd  (%rcx),%xmm10
movapd %xmm0,%xmm3
xorpd  %xmm11,%xmm3
movapd %xmm10,%xmm1
cmpltsd %xmm14,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movapd %xmm10,%xmm8
addsd  %xmm1,%xmm8
movsd  %xmm8,(%rcx)
mov    0x10(%rsp),%rax
mov    %rax,%rcx
mov    %r10,0x30(%rsp)
sub    %r10,%rcx
imul   %rax,%rcx
cmp    %rax,%rcx
jle    2740 <sv2u1v+0x15e0>
mov    0x1c(%rsp),%ebp
add    $0x1,%rbp
and    $0xfffffffffffffffc,%rbp
mov    0x28(%rsp),%r8
lea    0x1(%r8),%rax
add    $0xfffffffffffffffc,%rbp
mov    %rax,0xf0(%rsp)
mov    %rax,%rdi
movabs $0x1fffffffc,%rax
and    %rax,%rdi
shr    $0x2,%rbp
lea    -0x4(%rdi),%rsi
mov    0x30(%rsp),%rax
mov    0xd8(%rsp),%r9
imul   %r9,%rax
add    $0x1,%rbp
mov    %rsi,0xe8(%rsp)
mov    %rsi,%rdx
shr    $0x2,%rdx
mov    0xc0(%rsp),%rsi
add    %rax,%rsi
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0xd0(%rsp)
add    $0x1,%rdx
mov    %rdx,0xe0(%rsp)
lea    (%r9,%rax,1),%rdx
mov    %rdx,0x98(%rsp)
add    %r8,%rsi
mov    %rsi,0x100(%rsp)
mov    0x80(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
add    $0x8,%rax
mov    (%rsp),%rdx
mov    %rax,0xf8(%rsp)
lea    0x8(%rax,%r8,8),%rax
mov    %rax,0x110(%rsp)
movapd %xmm10,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm12,%xmm9
divsd  %xmm4,%xmm9
mov    %rdi,0xb8(%rsp)
lea    (%rdx,%rdi,8),%rax
mov    %rax,0xc8(%rsp)
mov    0x48(%rsp),%r11
xor    %r8d,%r8d
mov    0x10(%rsp),%r9
jmp    2425 <sv2u1v+0x12c5>
nopl   0x0(%rax,%rax,1)
add    0x10(%rsp),%r9
add    $0x1,%r8
add    %r14,%r11
cmp    %rcx,%r9
jge    2740 <sv2u1v+0x15e0>
cmp    $0x2,%r12d
jl     2410 <sv2u1v+0x12b0>
lea    (%rdx,%r9,8),%r10
xorpd  %xmm4,%xmm4
mov    %r10,%rsi
mov    %rdx,%rdi
cmpl   $0x3,0x28(%rsp)
jb     24a6 <sv2u1v+0x1346>
xorpd  %xmm4,%xmm4
mov    0x88(%rsp),%esi
xor    %edi,%edi
nopl   (%rax)
movsd  (%r15,%rdi,1),%xmm0
movsd  0x8(%r15,%rdi,1),%xmm2
mulsd  (%r11,%rdi,1),%xmm0
mulsd  0x8(%r11,%rdi,1),%xmm2
addsd  %xmm4,%xmm0
movsd  0x10(%r15,%rdi,1),%xmm3
mulsd  0x10(%r11,%rdi,1),%xmm3
addsd  %xmm0,%xmm2
movsd  0x18(%r15,%rdi,1),%xmm4
mulsd  0x18(%r11,%rdi,1),%xmm4
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
add    $0x20,%rdi
add    $0xfffffffc,%esi
jne    2450 <sv2u1v+0x12f0>
lea    (%r11,%rdi,1),%rsi
add    %r15,%rdi
testb  $0x3,0x50(%rsp)
je     24c7 <sv2u1v+0x1367>
xor    %eax,%eax
nop
movsd  (%rdi,%rax,8),%xmm5
mulsd  (%rsi,%rax,8),%xmm5
addsd  %xmm5,%xmm4
add    $0x1,%rax
cmp    %eax,%r13d
jne    24b0 <sv2u1v+0x1350>
cmp    $0x2,%r12d
jl     2410 <sv2u1v+0x12b0>
xor    %edi,%edi
xorpd  %xmm11,%xmm4
mulsd  %xmm9,%xmm4
cmpl   $0x3,0x28(%rsp)
jae    24ec <sv2u1v+0x138c>
mov    %rdx,%rbp
jmp    2650 <sv2u1v+0x14f0>
mov    %r8,%rax
imul   0x10(%rsp),%rax
mov    0x98(%rsp),%rdx
add    %rax,%rdx
mov    0x80(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
cmp    0x110(%rsp),%rdx
jae    2535 <sv2u1v+0x13d5>
add    0x100(%rsp),%rax
lea    (%rsi,%rax,8),%rax
cmp    %rax,0xf8(%rsp)
jae    2535 <sv2u1v+0x13d5>
mov    (%rsp),%rbp
jmp    2650 <sv2u1v+0x14f0>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmpq   $0x0,0xe8(%rsp)
mov    (%rsp),%rdx
je     272b <sv2u1v+0x15cb>
mov    0xd0(%rsp),%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd (%r15,%rdi,8),%xmm6
movupd 0x10(%r15,%rdi,8),%xmm7
mulpd  %xmm5,%xmm6
movupd (%r11,%rdi,8),%xmm0
addpd  %xmm6,%xmm0
movupd 0x10(%r11,%rdi,8),%xmm6
movupd 0x20(%r11,%rdi,8),%xmm3
movupd 0x30(%r11,%rdi,8),%xmm2
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm0,(%r11,%rdi,8)
movupd %xmm7,0x10(%r11,%rdi,8)
movupd 0x20(%r15,%rdi,8),%xmm0
movupd 0x30(%r15,%rdi,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm0,0x20(%r11,%rdi,8)
movupd %xmm6,0x30(%r11,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    2560 <sv2u1v+0x1400>
testb  $0x1,0xe0(%rsp)
01
je     261a <sv2u1v+0x14ba>
movupd (%rdx,%rdi,8),%xmm0
movupd 0x10(%rdx,%rdi,8),%xmm2
movupd (%r10,%rdi,8),%xmm3
movupd 0x10(%r10,%rdi,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm5,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm0,(%r10,%rdi,8)
movupd %xmm2,0x10(%r10,%rdi,8)
mov    0xb8(%rsp),%rax
cmp    %rax,0xf0(%rsp)
je     2410 <sv2u1v+0x12b0>
mov    0xb8(%rsp),%rdi
lea    (%r10,%rdi,8),%r10
mov    0xc8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rax
add    %edi,%eax
mov    0x7c(%rsp),%edx
sub    %eax,%edx
mov    0x78(%rsp),%esi
sub    %eax,%esi
test   $0x3,%dl
je     26a4 <sv2u1v+0x1544>
mov    %r13d,%eax
sub    %dil,%al
movzbl %al,%eax
and    $0x3,%eax
neg    %eax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r10),%xmm0
movsd  %xmm0,(%r10)
add    $0x8,%r10
add    $0x8,%rbp
add    $0xffffffff,%edx
cmp    %edx,%eax
jne    2680 <sv2u1v+0x1520>
sub    %edx,%edi
mov    (%rsp),%rdx
cmp    $0x3,%esi
jb     2410 <sv2u1v+0x12b0>
mov    0x20(%rsp),%rsi
sub    %edi,%esi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r10,%rdi,8),%xmm0
movsd  %xmm0,(%r10,%rdi,8)
movsd  0x8(%rbp,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x8(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r10,%rdi,8)
movsd  0x10(%rbp,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x10(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r10,%rdi,8)
movsd  0x18(%rbp,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x18(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x18(%r10,%rdi,8)
add    $0x4,%rdi
cmp    %edi,%esi
jne    26c0 <sv2u1v+0x1560>
jmp    2410 <sv2u1v+0x12b0>
xor    %edi,%edi
testb  $0x1,0xe0(%rsp)
01
jne    25e5 <sv2u1v+0x1485>
jmp    261a <sv2u1v+0x14ba>
divsd  %xmm1,%xmm10
andpd  %xmm13,%xmm10
addsd  %xmm12,%xmm10
movapd %xmm12,%xmm3
divsd  %xmm8,%xmm3
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rcx
mov    $0x1,%edx
mov    0x108(%rsp),%rsi
cmp    $0x3,%esi
jae    2783 <sv2u1v+0x1623>
mov    0x60(%rsp),%r11
mov    0x30(%rsp),%r10
jmp    288f <sv2u1v+0x172f>
add    $0x1,%rsi
mov    %rsi,%r9
movabs $0x1fffffffc,%rax
and    %rax,%r9
lea    -0x4(%r9),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
test   %rax,%rax
je     283c <sv2u1v+0x16dc>
mov    0x18(%rsp),%r8d
mov    %r8d,%edi
add    $0x1,%rdi
and    $0xfffffffffffffffc,%rdi
add    $0xfffffffffffffffc,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
mov    0x60(%rsp),%r11
mov    0x8(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x10(%rax,%rbp,8),%xmm2
movupd 0x20(%rax,%rbp,8),%xmm4
movupd 0x30(%rax,%rbp,8),%xmm5
movupd 0x40(%rax,%rbp,8),%xmm6
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm4
movupd %xmm2,0x10(%rax,%rbp,8)
movupd %xmm4,0x20(%rax,%rbp,8)
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm6
movupd %xmm5,0x30(%rax,%rbp,8)
movupd %xmm6,0x40(%rax,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    27f0 <sv2u1v+0x1690>
jmp    2848 <sv2u1v+0x16e8>
xor    %ebp,%ebp
mov    0x60(%rsp),%r11
mov    0x18(%rsp),%r8d
test   $0x1,%dl
mov    0x30(%rsp),%r10
je     2870 <sv2u1v+0x1710>
movupd (%rcx,%rbp,8),%xmm2
movupd 0x10(%rcx,%rbp,8),%xmm4
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm4
movupd %xmm2,(%rcx,%rbp,8)
movupd %xmm4,0x10(%rcx,%rbp,8)
cmp    %r9,%rsi
jne    2885 <sv2u1v+0x1725>
mov    0x48(%rsp),%rdi
mov    0x1c(%rsp),%esi
mov    0x20(%rsp),%rbp
jmp    28cb <sv2u1v+0x176b>
mov    %r9d,%edx
or     $0x1,%edx
lea    (%rcx,%r9,8),%rcx
mov    0x20(%rsp),%rbp
mov    %ebp,%eax
sub    %edx,%eax
xor    %edx,%edx
mov    0x48(%rsp),%rdi
mov    0x1c(%rsp),%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%eax
jne    28b0 <sv2u1v+0x1750>
mov    0x18(%rsp),%r8d
mov    0x40(%rsp),%rdx
mov    0x38(%rsp),%rcx
mov    (%rsp),%rax
movsd  %xmm10,(%rax)
xorpd  %xmm11,%xmm1
mov    0x90(%rsp),%rax
movlpd %xmm1,(%rax,%r10,8)
mov    0x68(%rsp),%r13
mov    0x90(%rsp),%rax
cmp    $0x1,%ecx
mov    (%rsp),%r9
je     1a90 <sv2u1v+0x930>
jmp    1a9b <sv2u1v+0x93b>
mov    %r15,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1070 <atovm@plt>
mov    %r13,%rdi
mov    0x90(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    %ebp,%ecx
mov    %r15,%r8
mov    %r12d,%r9d
xor    %eax,%eax
call   1080 <qrbdu1@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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