#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ qrbdi(double *, double *, int);
double sqrt(double);
int sv2val(double *d, double *a, int m, int n) {
  double *p, *p1, *q, *w, *v;
  double s, h, u;
  int i, j, k, mm, nm, ms;
  if (m < n)
    return -1;
  w = (double *)calloc(m, sizeof(double));
  for (i = 0, mm = m, p = a; i < n && mm > 1; ++i, --mm, p += n + 1) {
    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;
      w[0] += h;
      for (k = 1, ms = n - i; k < ms; ++k) {
        for (j = 0, q = p + k, u = 0.; j < mm; q += n)
          u += w[j++] * *q;
        u = u * s;
        for (j = 0, q = p + k; j < mm; q += n)
          *q -= u * w[j++];
      }
      *p = -h;
    }
  }
  for (i = 0, p = a; i < n; ++i, p += n) {
    for (j = 0, q = p; j < i; ++j)
      *q++ = 0.;
  }
  for (i = 0, mm = n, nm = n - 1, p = a; i < n; ++i, --mm, --nm, p += n + 1) {
    if (i && mm > 1) {
      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;
        w[0] += h;
        for (k = 1, ms = n - i; k < ms; ++k) {
          for (j = 0, q = p + k, u = 0.; j < mm; q += n)
            u += w[j++] * *q;
          u *= s;
          for (j = 0, q = p + k; j < mm; q += n)
            *q -= u * w[j++];
        }
        *p = -h;
      }
    }
    p1 = p + 1;
    if (nm > 1) {
      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;
        s += *p1 * h;
        s = 1. / s;
        *p1 += h;
        for (k = n, ms = n * (m - i); k < ms; k += n) {
          for (j = 0, q = p1, v = p1 + k, u = 0.; j < nm; ++j)
            u += *q++ * *v++;
          u *= s;
          for (j = 0, q = p1, v = p1 + k; j < nm; ++j)
            *v++ -= u * *q++;
        }
        *p1 = -h;
      }
    }
  }
  for (j = 0, p = a; j < n; ++j, p += n + 1) {
    d[j] = *p;
    if (j < n - 1)
      w[j] = *(p + 1);
    else
      w[j] = 0.;
  }
  qrbdi(d, w, n);
  for (i = 0; i < n; ++i)
    if (d[i] < 0.)
      d[i] = -d[i];
  free(w);
  return 0;
}


x86 assembly (clang, -O0):
<sv2val>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1171 <sv2val+0x31>
movl   $0xffffffff,-0x4(%rbp)
jmp    1b80 <sv2val+0xa40>
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x64(%rbp),%ecx
xor    %eax,%eax
cmp    -0x20(%rbp),%ecx
mov    %al,-0x79(%rbp)
jge    11b2 <sv2val+0x72>
cmpl   $0x1,-0x70(%rbp)
setg   %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    11c2 <sv2val+0x82>
jmp    146a <sv2val+0x32a>
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    123f <sv2val+0xff>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    11d9 <sv2val+0x99>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1436 <sv2val+0x2f6>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1292 <sv2val+0x152>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xd47(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x6c(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1412 <sv2val+0x2d2>
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1369 <sv2val+0x229>
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x68(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1312 <sv2val+0x1d2>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    13ff <sv2val+0x2bf>
movsd  -0x60(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x68(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%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    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1392 <sv2val+0x252>
jmp    1404 <sv2val+0x2c4>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12e4 <sv2val+0x1a4>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    143b <sv2val+0x2fb>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x70(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1197 <sv2val+0x57>
movl   $0x0,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14ec <sv2val+0x3ac>
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    14c4 <sv2val+0x384>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1494 <sv2val+0x354>
jmp    14c9 <sv2val+0x389>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1479 <sv2val+0x339>
movl   $0x0,-0x64(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1a5c <sv2val+0x91c>
cmpl   $0x0,-0x64(%rbp)
je     17a3 <sv2val+0x663>
cmpl   $0x1,-0x70(%rbp)
jle    17a3 <sv2val+0x663>
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    15a7 <sv2val+0x467>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1541 <sv2val+0x401>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    179e <sv2val+0x65e>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    15fa <sv2val+0x4ba>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x9df(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x6c(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    177a <sv2val+0x63a>
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    16d1 <sv2val+0x591>
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x68(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    167a <sv2val+0x53a>
movsd  -0x50(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1767 <sv2val+0x627>
movsd  -0x60(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x68(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%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    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    16fa <sv2val+0x5ba>
jmp    176c <sv2val+0x62c>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    164c <sv2val+0x50c>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    17a3 <sv2val+0x663>
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x1,-0x74(%rbp)
jle    1a1f <sv2val+0x8df>
movl   $0x0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1818 <sv2val+0x6d8>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
jmp    17d0 <sv2val+0x690>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a1a <sv2val+0x8da>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    186b <sv2val+0x72b>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x76e(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x64(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    19f6 <sv2val+0x8b6>
movl   $0x0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    194a <sv2val+0x80a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rbp)
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    18f8 <sv2val+0x7b8>
movsd  -0x50(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    19e3 <sv2val+0x8a3>
movsd  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%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)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    197b <sv2val+0x83b>
jmp    19e8 <sv2val+0x8a8>
mov    -0x20(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    18c2 <sv2val+0x782>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1a1f <sv2val+0x8df>
jmp    1a24 <sv2val+0x8e4>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x70(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    150a <sv2val+0x3ca>
movl   $0x0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1af3 <sv2val+0x9b3>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1ab8 <sv2val+0x978>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ac8 <sv2val+0x988>
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1acd <sv2val+0x98d>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1a6b <sv2val+0x92b>
mov    -0x10(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1040 <qrbdi@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1b70 <sv2val+0xa30>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1b5d <sv2val+0xa1d>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b62 <sv2val+0xa22>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1b0a <sv2val+0x9ca>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sv2val>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %ecx,%ebp
mov    $0xffffffff,%eax
cmp    %ecx,%edx
jl     21e9 <sv2val+0x1099>
mov    %rsi,%rcx
mov    %rdi,0x80(%rsp)
mov    %edx,0x50(%rsp)
mov    %edx,%edi
mov    $0x8,%esi
mov    %rcx,0x28(%rsp)
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    %ebp,%r9d
test   %ebp,%ebp
mov    %r9,0x10(%rsp)
mov    %rbp,0x70(%rsp)
mov    %rbp,%rdx
jle    15dd <sv2val+0x48d>
cmpl   $0x2,0x50(%rsp)
jl     15dd <sv2val+0x48d>
mov    0x50(%rsp),%r14d
mov    %r14,%r8
neg    %r8
lea    0x8(,%r9,8),%r10
mov    %r9,%rbp
shl    $0x4,%rbp
mov    %rdx,%rdi
mov    0x28(%rsp),%rdx
lea    0x8(%rdx),%rsi
mov    %r9,%rax
shl    $0x5,%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%r9,8),%r13
xor    %ecx,%ecx
xorpd  %xmm5,%xmm5
movapd 0x1e02(%rip),%xmm6
mov    %rdx,(%rsp)
mov    %rdi,%rdx
mov    %r14,0x38(%rsp)
mov    %edx,%eax
mov    %edx,0x40(%rsp)
movl   $0x0,0x20(%rsp)
mov    %r8,0x30(%rsp)
mov    %r10,0x78(%rsp)
mov    %rbp,0x98(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rax
not    %rax
mov    %rax,%r11
cmp    %r8,%rax
mov    %rcx,0x68(%rsp)
mov    %rdx,%rdi
jne    1260 <sv2val+0x110>
xor    %eax,%eax
xorpd  %xmm4,%xmm4
mov    (%rsp),%rcx
jmp    12bb <sv2val+0x16b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm4,%xmm4
mov    (%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
movsd  (%rcx,%r9,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
movsd  (%rcx,%r9,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%rdx
jne    1280 <sv2val+0x130>
test   $0x1,%r14b
mov    %rdi,%rdx
je     12d9 <sv2val+0x189>
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
mov    %r14d,%r12d
and    $0x3,%r12d
mov    %r14,%r15
and    $0xfffffffffffffffc,%r15
add    0x38(%rsp),%r11
ucomisd %xmm5,%xmm4
jbe    15a8 <sv2val+0x458>
mov    %r11,0x8(%rsp)
mov    %rsi,0x60(%rsp)
jb     1310 <sv2val+0x1c0>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    133c <sv2val+0x1ec>
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
mov    %rdx,%rbp
movsd  %xmm4,0x58(%rsp)
call   1070 <sqrt@plt>
movsd  0x58(%rsp),%xmm4
mov    %rbp,%rdx
movapd 0x1ccd(%rip),%xmm6
xorpd  %xmm5,%xmm5
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    (%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm6,%xmm3
movapd %xmm2,%xmm1
cmpltsd %xmm5,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movsd  (%rbx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
mov    %edx,%eax
sub    0x20(%rsp),%eax
cmp    $0x2,%eax
jl     1580 <sv2val+0x430>
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movsd  0x1c7f(%rip),%xmm0
divsd  %xmm2,%xmm0
mov    0x40(%rsp),%r8d
mov    $0x1,%ecx
mov    0x60(%rsp),%rdx
jmp    13c1 <sv2val+0x271>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x8,%rdx
cmp    %r8,%rcx
je     1580 <sv2val+0x430>
mov    (%rsp),%rax
lea    (%rax,%rcx,8),%rbp
xorpd  %xmm2,%xmm2
cmp    $0x3,%rdi
jae    13f0 <sv2val+0x2a0>
xor    %eax,%eax
mov    %rbp,%rsi
test   $0x3,%r14b
jne    1462 <sv2val+0x312>
jmp    1489 <sv2val+0x339>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,%rsi
movsd  (%rbx,%rax,8),%xmm3
movsd  0x8(%rbx,%rax,8),%xmm4
mulsd  (%rdi),%xmm3
addsd  %xmm2,%xmm3
add    %r13,%rdi
mulsd  (%rsi,%r13,1),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rbx,%rax,8),%xmm3
mulsd  0x0(%r13,%rdi,1),%xmm3
add    %r13,%rdi
addsd  %xmm4,%xmm3
movsd  0x18(%rbx,%rax,8),%xmm2
add    $0x4,%rax
mulsd  0x0(%r13,%rdi,1),%xmm2
add    %r13,%rdi
addsd  %xmm3,%xmm2
add    %r13,%rdi
cmp    %rax,%r15
jne    1400 <sv2val+0x2b0>
add    0x18(%rsp),%rsi
test   $0x3,%r14b
je     1489 <sv2val+0x339>
lea    (%rbx,%rax,8),%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdi,8),%xmm3
mulsd  (%rsi),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rdi
add    %r13,%rsi
cmp    %rdi,%r12
jne    1470 <sv2val+0x320>
xorpd  %xmm6,%xmm2
mulsd  %xmm0,%xmm2
mov    0x8(%rsp),%rdi
cmp    $0x3,%rdi
jae    14b0 <sv2val+0x360>
xor    %eax,%eax
test   $0x3,%r14b
jne    1547 <sv2val+0x3f7>
jmp    13b0 <sv2val+0x260>
nopl   (%rax)
mov    %rdx,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rsi,%rbp
movsd  (%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rsi),%xmm3
movsd  %xmm3,(%rsi)
add    %r13,%rsi
movsd  0x8(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp,%r13,1),%xmm3
movsd  %xmm3,0x0(%rbp,%r13,1)
lea    (%rsi,%r13,1),%rdi
movsd  0x10(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%r13,%rsi,1),%xmm3
movsd  %xmm3,0x0(%r13,%rsi,1)
lea    (%rdi,%r13,1),%rsi
movsd  0x18(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%r13,%rdi,1),%xmm3
add    $0x4,%rax
movsd  %xmm3,0x0(%r13,%rdi,1)
add    %r13,%rsi
cmp    %rax,%r15
jne    14c0 <sv2val+0x370>
add    0x18(%rsp),%rbp
mov    0x8(%rsp),%rdi
test   $0x3,%r14b
je     13b0 <sv2val+0x260>
lea    (%rbx,%rax,8),%rax
xor    %esi,%esi
nopl   (%rax)
movsd  (%rax,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp),%xmm3
movsd  %xmm3,0x0(%rbp)
add    $0x1,%rsi
add    %r13,%rbp
cmp    %rsi,%r12
jne    1550 <sv2val+0x400>
jmp    13b0 <sv2val+0x260>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm6,%xmm1
mov    (%rsp),%rax
movlpd %xmm1,(%rax)
mov    0x70(%rsp),%rdx
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r10
mov    0x98(%rsp),%rbp
mov    0x60(%rsp),%rsi
mov    0x20(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x20(%rsp)
cmp    %edx,%eax
mov    0x68(%rsp),%rcx
jge    15dd <sv2val+0x48d>
lea    -0x1(%r14),%rax
add    %r10,(%rsp)
addl   $0xffffffff,0x40(%rsp)
add    $0x1,%rcx
add    %r10,%rsi
cmp    $0x2,%r14
mov    %rax,%r14
jg     1230 <sv2val+0xe0>
test   %edx,%edx
mov    0x80(%rsp),%r13
jle    21d4 <sv2val+0x1084>
xor    %eax,%eax
cmp    $0x1,%edx
je     176f <sv2val+0x61f>
lea    -0x1(%r9),%r14
lea    -0x2(%r9),%rax
mov    %r14,%rcx
and    $0x7,%r14d
mov    $0x1,%r15d
mov    0x28(%rsp),%rdx
cmp    $0x7,%rax
jb     171a <sv2val+0x5ca>
mov    0x10(%rsp),%rax
mov    %rax,%rdx
shl    $0x6,%rdx
mov    %rdx,0x18(%rsp)
lea    0x0(,%rax,8),%rbp
and    $0xfffffffffffffff8,%rcx
neg    %rcx
mov    %rcx,0x8(%rsp)
mov    $0x1,%r15d
mov    $0x40,%r13d
mov    0x28(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x38(%r13),%rdx
mov    %r12,(%rsp)
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    -0x30(%r13),%rdx
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    -0x28(%r13),%rdx
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    -0x20(%r13),%rdx
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    -0x18(%r13),%rdx
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    -0x10(%r13),%rdx
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    -0x8(%r13),%rdx
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
add    %rbp,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1040 <memset@plt>
add    $0x40,%r13
mov    0x8(%rsp),%rax
add    %r15,%rax
add    $0x8,%rax
add    $0x8,%r15
cmp    $0x1,%rax
jne    1660 <sv2val+0x510>
mov    (%rsp),%rdx
add    0x18(%rsp),%rdx
mov    0x80(%rsp),%r13
test   %r14,%r14
je     175a <sv2val+0x60a>
shl    $0x3,%r15
mov    0x10(%rsp),%rax
lea    (%rdx,%rax,8),%rbp
lea    0x0(,%rax,8),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
add    $0x8,%r15
add    %r12,%rbp
add    $0xffffffffffffffff,%r14
jne    1740 <sv2val+0x5f0>
mov    0x70(%rsp),%rdx
test   %edx,%edx
mov    0x10(%rsp),%r9
jle    21d4 <sv2val+0x1084>
lea    -0x1(%rdx),%eax
lea    0x1(%r9),%rcx
mov    %rcx,0xe0(%rsp)
movslq 0x50(%rsp),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x1(%r9),%rcx
mov    %rcx,0xd8(%rsp)
lea    0x2(%r9),%rcx
mov    %rcx,0xd0(%rsp)
mov    %rdx,%r13
lea    -0x1(%rax),%edx
mov    0x28(%rsp),%r10
lea    0x8(,%r9,8),%r11
mov    %r9,%rsi
shl    $0x4,%rsi
mov    %rax,%rcx
lea    0x8(%r10),%r12
mov    %r9,%rax
shl    $0x5,%rax
mov    %rax,0xb0(%rsp)
lea    0x0(,%r9,8),%rbp
lea    (%r10,%r9,8),%rdi
add    $0x8,%rdi
xor    %r14d,%r14d
xorpd  %xmm10,%xmm10
movapd 0x180f(%rip),%xmm9
mov    %edx,0x60(%rsp)
mov    %r10,0x18(%rsp)
mov    %edx,%r10d
mov    %rcx,%rax
mov    %rcx,0xa8(%rsp)
mov    %ecx,%r15d
mov    %r11,0x90(%rsp)
mov    %rsi,0xa0(%rsp)
jmp    1878 <sv2val+0x728>
nopl   (%rax)
xorpd  %xmm9,%xmm1
mov    (%rsp),%rax
movlpd %xmm1,(%rax)
mov    0x10(%rsp),%r9
mov    0x90(%rsp),%r11
mov    0xa0(%rsp),%rsi
mov    0x38(%rsp),%rdi
mov    %r10,%r14
mov    0x4c(%rsp),%r10d
add    $0x1,%r14
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%r13d
add    $0xffffffff,%r15d
add    %r11,0x18(%rsp)
add    %r11,%r12
add    %r11,%rdi
add    $0xffffffff,%r10d
cmp    %r9,%r14
je     2139 <sv2val+0xfe9>
mov    %r15,0x68(%rsp)
mov    %r13d,%eax
mov    %rax,0x8(%rsp)
test   %r14,%r14
je     1bd3 <sv2val+0xa83>
cmp    $0x2,%r13d
jl     1bd3 <sv2val+0xa83>
and    $0x3,%r13d
mov    0x8(%rsp),%rax
mov    %eax,%r15d
and    $0xfffffffc,%r15d
mov    %eax,%ecx
and    $0xfffffffe,%ecx
add    $0xffffffffffffffff,%rax
mov    %rax,(%rsp)
xorpd  %xmm4,%xmm4
mov    0x18(%rsp),%rax
xor    %edx,%edx
movsd  (%rax),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
movsd  (%rax,%r9,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
movsd  (%rax,%r9,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
add    $0x2,%rdx
add    %rsi,%rax
cmp    %rdx,%rcx
jne    18c0 <sv2val+0x770>
testb  $0x1,0x8(%rsp)
je     1917 <sv2val+0x7c7>
movsd  (%rax),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
ucomisd %xmm10,%xmm4
jbe    1bd3 <sv2val+0xa83>
mov    %rdi,0x38(%rsp)
mov    %r10d,0x4c(%rsp)
jb     1937 <sv2val+0x7e7>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    1971 <sv2val+0x821>
movapd %xmm4,%xmm0
mov    %r14,0x20(%rsp)
movsd  %xmm4,0x40(%rsp)
call   1070 <sqrt@plt>
movsd  0x40(%rsp),%xmm4
xorpd  %xmm10,%xmm10
mov    0x20(%rsp),%r14
mov    0x90(%rsp),%r11
movapd 0x1694(%rip),%xmm9
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm9,%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    %r9,%rax
mov    %r14,%r10
sub    %r14,%rax
cmp    $0x2,%rax
mov    0xb0(%rsp),%r14
jl     1bb0 <sv2val+0xa60>
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movsd  0x1640(%rip),%xmm0
divsd  %xmm2,%xmm0
mov    $0x1,%eax
mov    %r12,%r8
jmp    19f3 <sv2val+0x8a3>
xchg   %ax,%ax
add    $0x1,%rax
add    $0x8,%r8
cmp    0x8(%rsp),%rax
je     1bb0 <sv2val+0xa60>
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmpq   $0x3,(%rsp)
jae    1a20 <sv2val+0x8d0>
xorpd  %xmm2,%xmm2
xor    %edi,%edi
mov    %rcx,%rdx
testb  $0x3,0x8(%rsp)
jne    1a8e <sv2val+0x93e>
jmp    1ab9 <sv2val+0x969>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
mov    %r8,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
mov    %rsi,%rdx
movsd  (%rbx,%rdi,8),%xmm3
movsd  0x8(%rbx,%rdi,8),%xmm4
mulsd  (%rsi),%xmm3
addsd  %xmm2,%xmm3
add    %rbp,%rsi
mulsd  (%rdx,%rbp,1),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rbx,%rdi,8),%xmm3
mulsd  0x0(%rbp,%rsi,1),%xmm3
add    %rbp,%rsi
addsd  %xmm4,%xmm3
movsd  0x18(%rbx,%rdi,8),%xmm2
add    $0x4,%rdi
mulsd  0x0(%rbp,%rsi,1),%xmm2
add    %rbp,%rsi
addsd  %xmm3,%xmm2
add    %rbp,%rsi
cmp    %rdi,%r15
jne    1a30 <sv2val+0x8e0>
add    %r14,%rdx
testb  $0x3,0x8(%rsp)
je     1ab9 <sv2val+0x969>
lea    (%rbx,%rdi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rdi,8),%xmm3
mulsd  (%rdx),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rdi
add    %rbp,%rdx
cmp    %rdi,%r13
jne    1aa0 <sv2val+0x950>
cmpl   $0x0,0x8(%rsp)
jle    19e0 <sv2val+0x890>
xorpd  %xmm9,%xmm2
mulsd  %xmm0,%xmm2
cmpq   $0x3,(%rsp)
jae    1af0 <sv2val+0x9a0>
xor    %esi,%esi
testb  $0x3,0x8(%rsp)
jne    1b79 <sv2val+0xa29>
jmp    19e0 <sv2val+0x890>
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdx,%rcx
movsd  (%rbx,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx),%xmm3
movsd  %xmm3,(%rdx)
add    %rbp,%rdx
movsd  0x8(%rbx,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rbp,1),%xmm3
movsd  %xmm3,(%rcx,%rbp,1)
lea    (%rdx,%rbp,1),%rdi
movsd  0x10(%rbx,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp,%rdx,1),%xmm3
movsd  %xmm3,0x0(%rbp,%rdx,1)
lea    (%rdi,%rbp,1),%rdx
movsd  0x18(%rbx,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp,%rdi,1),%xmm3
add    $0x4,%rsi
movsd  %xmm3,0x0(%rbp,%rdi,1)
add    %rbp,%rdx
cmp    %rsi,%r15
jne    1b00 <sv2val+0x9b0>
add    %r14,%rcx
testb  $0x3,0x8(%rsp)
je     19e0 <sv2val+0x890>
lea    (%rbx,%rsi,8),%rdx
xor    %esi,%esi
nop
movsd  (%rdx,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx),%xmm3
movsd  %xmm3,(%rcx)
add    $0x1,%rsi
add    %rbp,%rcx
cmp    %rsi,%r13
jne    1b80 <sv2val+0xa30>
jmp    19e0 <sv2val+0x890>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm9,%xmm1
mov    0x18(%rsp),%rax
movlpd %xmm1,(%rax)
mov    0xa0(%rsp),%rsi
mov    0x38(%rsp),%rdi
mov    %r10,%r14
mov    0x4c(%rsp),%r10d
mov    0x68(%rsp),%r15
cmp    $0x2,%r15d
jl     184f <sv2val+0x6ff>
mov    %r10d,%r8d
add    $0x1,%r8
mov    0x60(%rsp),%eax
mov    %eax,%r11d
sub    %r14d,%r11d
and    $0xfffffffffffffffc,%r8
lea    0x1(%r11),%rax
add    $0xfffffffffffffffc,%r8
mov    %rax,0xf0(%rsp)
mov    %rax,%rcx
movabs $0x1fffffffc,%rax
and    %rax,%rcx
shr    $0x2,%r8
mov    %rcx,%rax
mov    %rcx,0x58(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,0x78(%rsp)
mov    %r14,%rax
imul   0xe0(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    %r15d,%r13d
and    $0x3,%r13d
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %eax,0x40(%rsp)
mov    0x18(%rsp),%rax
add    $0x8,%rax
xorpd  %xmm4,%xmm4
mov    %rax,(%rsp)
mov    %r11,%rcx
mov    %r11,0x20(%rsp)
cmp    $0x3,%r11d
jb     1cbc <sv2val+0xb6c>
xorpd  %xmm4,%xmm4
mov    0x40(%rsp),%ecx
mov    (%rsp),%rax
nopl   0x0(%rax)
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rax),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
add    $0x20,%rax
add    $0xfffffffc,%ecx
jne    1c80 <sv2val+0xb30>
mov    %rdi,0x38(%rsp)
add    $0x1,%r8
mov    0x78(%rsp),%rdi
shr    $0x2,%rdi
mov    0xd0(%rsp),%rcx
mov    0x30(%rsp),%rdx
lea    (%rcx,%rdx,1),%r11
test   $0x3,%r15b
je     1d06 <sv2val+0xbb6>
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rcx
cmp    %ecx,%r13d
jne    1cf0 <sv2val+0xba0>
and    $0xfffffffffffffffe,%r8
add    $0x1,%rdi
mov    %rdi,0xe8(%rsp)
mov    0xd8(%rsp),%rax
mov    0x30(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x98(%rsp)
add    0x20(%rsp),%r11
mov    %r11,0x50(%rsp)
ucomisd %xmm10,%xmm4
mov    0x90(%rsp),%r11
mov    0x38(%rsp),%rdi
jbe    184f <sv2val+0x6ff>
mov    %r10d,0x4c(%rsp)
mov    %r8,0xc8(%rsp)
jb     1d68 <sv2val+0xc18>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    1d9b <sv2val+0xc4b>
movapd %xmm4,%xmm0
movsd  %xmm4,0x88(%rsp)
call   1070 <sqrt@plt>
movsd  0x88(%rsp),%xmm4
xorpd  %xmm10,%xmm10
mov    0x68(%rsp),%r15
movapd 0x126a(%rip),%xmm9
mov    0x10(%rsp),%r9
mov    (%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm9,%xmm3
movapd %xmm2,%xmm1
cmpltsd %xmm10,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movapd %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0xb8(%rsp),%r11
mov    %r14,%r10
sub    %r14,%r11
imul   %r9,%r11
cmp    %r9,%r11
jle    1820 <sv2val+0x6d0>
mov    0x28(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
add    $0x8,%rcx
mov    0x20(%rsp),%rax
mov    %rcx,0x88(%rsp)
lea    0x8(%rcx,%rax,8),%rax
mov    %rax,0x30(%rsp)
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movsd  0x11ed(%rip),%xmm8
divsd  %xmm2,%xmm8
mov    0x58(%rsp),%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0xc0(%rsp)
mov    0x38(%rsp),%rdi
xor    %r8d,%r8d
mov    0x10(%rsp),%r9
jmp    1e65 <sv2val+0xd15>
nopl   0x0(%rax)
add    0x10(%rsp),%r9
add    $0x1,%r8
add    %rbp,%rdi
cmp    %r11,%r9
jge    1820 <sv2val+0x6d0>
test   %r15d,%r15d
jle    1e50 <sv2val+0xd00>
mov    (%rsp),%rax
lea    (%rax,%r9,8),%rdx
xorpd  %xmm2,%xmm2
mov    %rdx,%rsi
cmpl   $0x3,0x20(%rsp)
jb     1ee2 <sv2val+0xd92>
xorpd  %xmm2,%xmm2
mov    0x40(%rsp),%esi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,1),%xmm0
movsd  0x8(%r12,%rax,1),%xmm3
mulsd  (%rdi,%rax,1),%xmm0
mulsd  0x8(%rdi,%rax,1),%xmm3
addsd  %xmm2,%xmm0
movsd  0x10(%r12,%rax,1),%xmm4
mulsd  0x10(%rdi,%rax,1),%xmm4
addsd  %xmm0,%xmm3
movsd  0x18(%r12,%rax,1),%xmm2
mulsd  0x18(%rdi,%rax,1),%xmm2
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
add    $0x20,%rax
add    $0xfffffffc,%esi
jne    1e90 <sv2val+0xd40>
lea    (%rdi,%rax,1),%rsi
add    %r12,%rax
test   $0x3,%r15b
je     1f07 <sv2val+0xdb7>
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm3
mulsd  (%rsi,%rcx,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rcx
cmp    %ecx,%r13d
jne    1ef0 <sv2val+0xda0>
test   %r15d,%r15d
jle    1e50 <sv2val+0xd00>
xor    %r14d,%r14d
xorpd  %xmm9,%xmm2
mulsd  %xmm8,%xmm2
cmpl   $0x3,0x20(%rsp)
jb     1f63 <sv2val+0xe13>
mov    %r8,%rax
imul   0x10(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %rax,%rcx
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
cmp    0x30(%rsp),%rcx
jae    2032 <sv2val+0xee2>
add    0x50(%rsp),%rax
lea    (%rsi,%rax,8),%rax
cmp    %rax,0x88(%rsp)
jae    2032 <sv2val+0xee2>
mov    (%rsp),%rax
mov    %r15d,%ecx
sub    %r14d,%ecx
mov    0x60(%rsp),%r15d
sub    %r14d,%r15d
sub    %r10d,%r15d
test   $0x3,%cl
je     1fb2 <sv2val+0xe62>
mov    %r13d,%ecx
sub    %r14b,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
neg    %ecx
xor    %esi,%esi
nopl   (%rax)
movsd  (%rax),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdx),%xmm0
movsd  %xmm0,(%rdx)
add    $0x8,%rdx
add    $0x8,%rax
add    $0xffffffff,%esi
cmp    %esi,%ecx
jne    1f90 <sv2val+0xe40>
sub    %esi,%r14d
cmp    $0x3,%r15d
mov    0x68(%rsp),%r15
jb     1e50 <sv2val+0xd00>
mov    %r15d,%esi
sub    %r14d,%esi
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movsd  0x10(%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
movsd  0x18(%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %ecx,%esi
jne    1fd0 <sv2val+0xe80>
jmp    1e50 <sv2val+0xd00>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,0x78(%rsp)
je     212b <sv2val+0xfdb>
mov    0xc8(%rsp),%rsi
xor    %eax,%eax
movupd (%r12,%rax,8),%xmm4
movupd 0x10(%r12,%rax,8),%xmm5
mulpd  %xmm3,%xmm4
movupd (%rdi,%rax,8),%xmm6
addpd  %xmm4,%xmm6
movupd 0x10(%rdi,%rax,8),%xmm4
movupd 0x20(%rdi,%rax,8),%xmm7
movupd 0x30(%rdi,%rax,8),%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,(%rdi,%rax,8)
movupd %xmm5,0x10(%rdi,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm4
movupd 0x30(%r12,%rax,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm0,%xmm5
movupd %xmm4,0x20(%rdi,%rax,8)
movupd %xmm5,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    2050 <sv2val+0xf00>
testb  $0x1,0xe8(%rsp)
01
je     2102 <sv2val+0xfb2>
mov    (%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm4
movupd (%rdx,%rax,8),%xmm5
movupd 0x10(%rdx,%rax,8),%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm4,0x10(%rdx,%rax,8)
mov    0x58(%rsp),%rax
cmp    %rax,0xf0(%rsp)
je     1e50 <sv2val+0xd00>
mov    0x58(%rsp),%r14
lea    (%rdx,%r14,8),%rdx
mov    0xc0(%rsp),%rax
jmp    1f67 <sv2val+0xe17>
xor    %eax,%eax
testb  $0x1,0xe8(%rsp)
01
jne    20cd <sv2val+0xf7d>
jmp    2102 <sv2val+0xfb2>
mov    0x70(%rsp),%rdx
test   %edx,%edx
mov    0x80(%rsp),%r13
mov    0x28(%rsp),%rsi
jle    21d4 <sv2val+0x1084>
movslq 0xa8(%rsp),%rax
mov    %r9,%r14
add    $0xffffffffffffffff,%r14
je     2207 <sv2val+0x10b7>
add    $0x1,%edx
mov    %r9d,%r8d
and    $0xfffffffe,%r8d
mov    %rdx,%rdi
shl    $0x4,%rdi
xor    %ecx,%ecx
jmp    2192 <sv2val+0x1042>
nopl   (%rax)
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    %rdi,%rsi
add    $0x1,%rcx
cmp    %r8,%rcx
je     21fb <sv2val+0x10ab>
mov    %rcx,%rbp
movsd  (%rsi),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
cmp    %rax,%rcx
jge    21b2 <sv2val+0x1062>
movsd  0x8(%rsi),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
movsd  (%rsi,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rbp,8)
lea    0x1(%rbp),%rcx
cmp    %rax,%rcx
jge    2180 <sv2val+0x1030>
movsd  0x8(%rsi,%rdx,8),%xmm0
jmp    2180 <sv2val+0x1030>
mov    %r13,%rdi
mov    %rbx,%rsi
call   1050 <qrbdi@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x2,%rbp
test   $0x1,%r9b
jne    220f <sv2val+0x10bf>
jmp    222d <sv2val+0x10dd>
xor    %ebp,%ebp
test   $0x1,%r9b
je     222d <sv2val+0x10dd>
movsd  (%rsi),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
xorpd  %xmm0,%xmm0
cmp    %rax,%rbp
jge    2228 <sv2val+0x10d8>
movsd  0x8(%rsi),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mov    %r13,%rdi
mov    %rbx,%rsi
mov    0x70(%rsp),%rbp
mov    %ebp,%edx
call   1050 <qrbdi@plt>
test   %ebp,%ebp
jle    21df <sv2val+0x108f>
test   %r14,%r14
je     22ab <sv2val+0x115b>
mov    0x10(%rsp),%rdx
mov    %edx,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movapd 0xda0(%rip),%xmm2
jmp    2279 <sv2val+0x1129>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rax
cmp    %rax,%rcx
je     22b2 <sv2val+0x1162>
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    2291 <sv2val+0x1141>
xorpd  %xmm2,%xmm1
movlpd %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    2270 <sv2val+0x1120>
xorpd  %xmm2,%xmm1
movlpd %xmm1,0x8(%r13,%rax,8)
jmp    2270 <sv2val+0x1120>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
test   $0x1,%dl
je     21df <sv2val+0x108f>
movsd  0x0(%r13,%rax,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    21df <sv2val+0x108f>
xorpd  0xd28(%rip),%xmm0
movlpd %xmm0,0x0(%r13,%rax,8)
jmp    21df <sv2val+0x108f>

LLVM IR (-O0):
define i32 @sv2val(double* %0, double* %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca double*
%7 = alloca double*
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store double* %0, double** %6
store double* %1, double** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%24 = load i32, i32* %8
%25 = load i32, i32* %9
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %28
27: ; preds = %4
store i32 -1, i32* %5
br label %537
28: ; preds = %4
%29 = load i32, i32* %8
%30 = call i64 @calloc(i32 %29, i32 8)
%31 = inttoptr i64 %30 to double*
store double* %31, double** %13
store i32 0, i32* %18
%32 = load i32, i32* %8
store i32 %32, i32* %21
%33 = load double*, double** %7
store double* %33, double** %10
br label %34
34: ; preds = %164, %28
%35 = load i32, i32* %18
%36 = load i32, i32* %9
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %41
38: ; preds = %34
%39 = load i32, i32* %21
%40 = icmp sgt i32 %39, 1
br label %41
41: ; preds = %38, %34
%42 = phi i1 [ false, %34 ], [ %40, %38 ]
br i1 %42, label %43, label %174
43: ; preds = %41
store i32 0, i32* %19
%44 = load double*, double** %10
store double* %44, double** %12
store double 0.000000e+00, double* %15
br label %45
45: ; preds = %62, %43
%46 = load i32, i32* %19
%47 = load i32, i32* %21
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %69
49: ; preds = %45
%50 = load double*, double** %12
%51 = load double, double* %50
%52 = load double*, double** %13
%53 = load i32, i32* %19
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
store double %51, double* %55
%56 = load double*, double** %12
%57 = load double, double* %56
%58 = load double*, double** %12
%59 = load double, double* %58
%60 = load double, double* %15
%61 = call double @llvm.fmuladd.f64(double %57, double %59, double %60)
store double %61, double* %15
br label %62
62: ; preds = %49
%63 = load i32, i32* %19
%64 = add nsw i32 %63, 1
store i32 %64, i32* %19
%65 = load i32, i32* %9
%66 = load double*, double** %12
%67 = sext i32 %65 to i64
%68 = getelementptr inbounds double, double* %66, i64 %67
store double* %68, double** %12
br label %45
69: ; preds = %45
%70 = load double, double* %15
%71 = fcmp ogt double %70, 0.000000e+00
br i1 %71, label %72, label %163
72: ; preds = %69
%73 = load double, double* %15
%74 = call double @sqrt(double %73)
store double %74, double* %16
%75 = load double*, double** %10
%76 = load double, double* %75
%77 = fcmp olt double %76, 0.000000e+00
br i1 %77, label %78, label %81
78: ; preds = %72
%79 = load double, double* %16
%80 = fneg double %79
store double %80, double* %16
br label %81
81: ; preds = %78, %72
%82 = load double*, double** %10
%83 = load double, double* %82
%84 = load double, double* %16
%85 = load double, double* %15
%86 = call double @llvm.fmuladd.f64(double %83, double %84, double %85)
store double %86, double* %15
%87 = load double, double* %15
%88 = fdiv double 1.000000e+00, %87
store double %88, double* %15
%89 = load double, double* %16
%90 = load double*, double** %13
%91 = getelementptr inbounds double, double* %90, i64 0
%92 = load double, double* %91
%93 = fadd double %92, %89
store double %93, double* %91
store i32 1, i32* %20
%94 = load i32, i32* %9
%95 = load i32, i32* %18
%96 = sub nsw i32 %94, %95
store i32 %96, i32* %23
br label %97
97: ; preds = %156, %81
%98 = load i32, i32* %20
%99 = load i32, i32* %23
%100 = icmp slt i32 %98, %99
br i1 %100, label %101, label %159
101: ; preds = %97
store i32 0, i32* %19
%102 = load double*, double** %10
%103 = load i32, i32* %20
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %102, i64 %104
store double* %105, double** %12
store double 0.000000e+00, double* %17
br label %106
106: ; preds = %121, %101
%107 = load i32, i32* %19
%108 = load i32, i32* %21
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %126
110: ; preds = %106
%111 = load double*, double** %13
%112 = load i32, i32* %19
%113 = add nsw i32 %112, 1
store i32 %113, i32* %19
%114 = sext i32 %112 to i64
%115 = getelementptr inbounds double, double* %111, i64 %114
%116 = load double, double* %115
%117 = load double*, double** %12
%118 = load double, double* %117
%119 = load double, double* %17
%120 = call double @llvm.fmuladd.f64(double %116, double %118, double %119)
store double %120, double* %17
br label %121
121: ; preds = %110
%122 = load i32, i32* %9
%123 = load double*, double** %12
%124 = sext i32 %122 to i64
%125 = getelementptr inbounds double, double* %123, i64 %124
store double* %125, double** %12
br label %106
126: ; preds = %106
%127 = load double, double* %17
%128 = load double, double* %15
%129 = fmul double %127, %128
store double %129, double* %17
store i32 0, i32* %19
%130 = load double*, double** %10
%131 = load i32, i32* %20
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
store double* %133, double** %12
br label %134
134: ; preds = %150, %126
%135 = load i32, i32* %19
%136 = load i32, i32* %21
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %155
138: ; preds = %134
%139 = load double, double* %17
%140 = load double*, double** %13
%141 = load i32, i32* %19
%142 = add nsw i32 %141, 1
store i32 %142, i32* %19
%143 = sext i32 %141 to i64
%144 = getelementptr inbounds double, double* %140, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %12
%147 = load double, double* %146
%148 = fneg double %139
%149 = call double @llvm.fmuladd.f64(double %148, double %145, double %147)
store double %149, double* %146
br label %150
150: ; preds = %138
%151 = load i32, i32* %9
%152 = load double*, double** %12
%153 = sext i32 %151 to i64
%154 = getelementptr inbounds double, double* %152, i64 %153
store double* %154, double** %12
br label %134
155: ; preds = %134
br label %156
156: ; preds = %155
%157 = load i32, i32* %20
%158 = add nsw i32 %157, 1
store i32 %158, i32* %20
br label %97
159: ; preds = %97
%160 = load double, double* %16
%161 = fneg double %160
%162 = load double*, double** %10
store double %161, double* %162
br label %163
163: ; preds = %159, %69
br label %164
164: ; preds = %163
%165 = load i32, i32* %18
%166 = add nsw i32 %165, 1
store i32 %166, i32* %18
%167 = load i32, i32* %21
%168 = add nsw i32 %167, -1
store i32 %168, i32* %21
%169 = load i32, i32* %9
%170 = add nsw i32 %169, 1
%171 = load double*, double** %10
%172 = sext i32 %170 to i64
%173 = getelementptr inbounds double, double* %171, i64 %172
store double* %173, double** %10
br label %34
174: ; preds = %41
store i32 0, i32* %18
%175 = load double*, double** %7
store double* %175, double** %10
br label %176
176: ; preds = %193, %174
%177 = load i32, i32* %18
%178 = load i32, i32* %9
%179 = icmp slt i32 %177, %178
br i1 %179, label %180, label %200
180: ; preds = %176
store i32 0, i32* %19
%181 = load double*, double** %10
store double* %181, double** %12
br label %182
182: ; preds = %189, %180
%183 = load i32, i32* %19
%184 = load i32, i32* %18
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %192
186: ; preds = %182
%187 = load double*, double** %12
%188 = getelementptr inbounds double, double* %187, i32 1
store double* %188, double** %12
store double 0.000000e+00, double* %187
br label %189
189: ; preds = %186
%190 = load i32, i32* %19
%191 = add nsw i32 %190, 1
store i32 %191, i32* %19
br label %182
192: ; preds = %182
br label %193
193: ; preds = %192
%194 = load i32, i32* %18
%195 = add nsw i32 %194, 1
store i32 %195, i32* %18
%196 = load i32, i32* %9
%197 = load double*, double** %10
%198 = sext i32 %196 to i64
%199 = getelementptr inbounds double, double* %197, i64 %198
store double* %199, double** %10
br label %176
200: ; preds = %176
store i32 0, i32* %18
%201 = load i32, i32* %9
store i32 %201, i32* %21
%202 = load i32, i32* %9
%203 = sub nsw i32 %202, 1
store i32 %203, i32* %22
%204 = load double*, double** %7
store double* %204, double** %10
br label %205
205: ; preds = %452, %200
%206 = load i32, i32* %18
%207 = load i32, i32* %9
%208 = icmp slt i32 %206, %207
br i1 %208, label %209, label %464
209: ; preds = %205
%210 = load i32, i32* %18
%211 = icmp ne i32 %210, 0
br i1 %211, label %212, label %336
212: ; preds = %209
%213 = load i32, i32* %21
%214 = icmp sgt i32 %213, 1
br i1 %214, label %215, label %336
215: ; preds = %212
store i32 0, i32* %19
%216 = load double*, double** %10
store double* %216, double** %12
store double 0.000000e+00, double* %15
br label %217
217: ; preds = %234, %215
%218 = load i32, i32* %19
%219 = load i32, i32* %21
%220 = icmp slt i32 %218, %219
br i1 %220, label %221, label %241
221: ; preds = %217
%222 = load double*, double** %12
%223 = load double, double* %222
%224 = load double*, double** %13
%225 = load i32, i32* %19
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
store double %223, double* %227
%228 = load double*, double** %12
%229 = load double, double* %228
%230 = load double*, double** %12
%231 = load double, double* %230
%232 = load double, double* %15
%233 = call double @llvm.fmuladd.f64(double %229, double %231, double %232)
store double %233, double* %15
br label %234
234: ; preds = %221
%235 = load i32, i32* %19
%236 = add nsw i32 %235, 1
store i32 %236, i32* %19
%237 = load i32, i32* %9
%238 = load double*, double** %12
%239 = sext i32 %237 to i64
%240 = getelementptr inbounds double, double* %238, i64 %239
store double* %240, double** %12
br label %217
241: ; preds = %217
%242 = load double, double* %15
%243 = fcmp ogt double %242, 0.000000e+00
br i1 %243, label %244, label %335
244: ; preds = %241
%245 = load double, double* %15
%246 = call double @sqrt(double %245)
store double %246, double* %16
%247 = load double*, double** %10
%248 = load double, double* %247
%249 = fcmp olt double %248, 0.000000e+00
br i1 %249, label %250, label %253
250: ; preds = %244
%251 = load double, double* %16
%252 = fneg double %251
store double %252, double* %16
br label %253
253: ; preds = %250, %244
%254 = load double*, double** %10
%255 = load double, double* %254
%256 = load double, double* %16
%257 = load double, double* %15
%258 = call double @llvm.fmuladd.f64(double %255, double %256, double %257)
store double %258, double* %15
%259 = load double, double* %15
%260 = fdiv double 1.000000e+00, %259
store double %260, double* %15
%261 = load double, double* %16
%262 = load double*, double** %13
%263 = getelementptr inbounds double, double* %262, i64 0
%264 = load double, double* %263
%265 = fadd double %264, %261
store double %265, double* %263
store i32 1, i32* %20
%266 = load i32, i32* %9
%267 = load i32, i32* %18
%268 = sub nsw i32 %266, %267
store i32 %268, i32* %23
br label %269
269: ; preds = %328, %253
%270 = load i32, i32* %20
%271 = load i32, i32* %23
%272 = icmp slt i32 %270, %271
br i1 %272, label %273, label %331
273: ; preds = %269
store i32 0, i32* %19
%274 = load double*, double** %10
%275 = load i32, i32* %20
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %274, i64 %276
store double* %277, double** %12
store double 0.000000e+00, double* %17
br label %278
278: ; preds = %293, %273
%279 = load i32, i32* %19
%280 = load i32, i32* %21
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %298
282: ; preds = %278
%283 = load double*, double** %13
%284 = load i32, i32* %19
%285 = add nsw i32 %284, 1
store i32 %285, i32* %19
%286 = sext i32 %284 to i64
%287 = getelementptr inbounds double, double* %283, i64 %286
%288 = load double, double* %287
%289 = load double*, double** %12
%290 = load double, double* %289
%291 = load double, double* %17
%292 = call double @llvm.fmuladd.f64(double %288, double %290, double %291)
store double %292, double* %17
br label %293
293: ; preds = %282
%294 = load i32, i32* %9
%295 = load double*, double** %12
%296 = sext i32 %294 to i64
%297 = getelementptr inbounds double, double* %295, i64 %296
store double* %297, double** %12
br label %278
298: ; preds = %278
%299 = load double, double* %15
%300 = load double, double* %17
%301 = fmul double %300, %299
store double %301, double* %17
store i32 0, i32* %19
%302 = load double*, double** %10
%303 = load i32, i32* %20
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds double, double* %302, i64 %304
store double* %305, double** %12
br label %306
306: ; preds = %322, %298
%307 = load i32, i32* %19
%308 = load i32, i32* %21
%309 = icmp slt i32 %307, %308
br i1 %309, label %310, label %327
310: ; preds = %306
%311 = load double, double* %17
%312 = load double*, double** %13
%313 = load i32, i32* %19
%314 = add nsw i32 %313, 1
store i32 %314, i32* %19
%315 = sext i32 %313 to i64
%316 = getelementptr inbounds double, double* %312, i64 %315
%317 = load double, double* %316
%318 = load double*, double** %12
%319 = load double, double* %318
%320 = fneg double %311
%321 = call double @llvm.fmuladd.f64(double %320, double %317, double %319)
store double %321, double* %318
br label %322
322: ; preds = %310
%323 = load i32, i32* %9
%324 = load double*, double** %12
%325 = sext i32 %323 to i64
%326 = getelementptr inbounds double, double* %324, i64 %325
store double* %326, double** %12
br label %306
327: ; preds = %306
br label %328
328: ; preds = %327
%329 = load i32, i32* %20
%330 = add nsw i32 %329, 1
store i32 %330, i32* %20
br label %269
331: ; preds = %269
%332 = load double, double* %16
%333 = fneg double %332
%334 = load double*, double** %10
store double %333, double* %334
br label %335
335: ; preds = %331, %241
br label %336
336: ; preds = %335, %212, %209
%337 = load double*, double** %10
%338 = getelementptr inbounds double, double* %337, i64 1
store double* %338, double** %11
%339 = load i32, i32* %22
%340 = icmp sgt i32 %339, 1
br i1 %340, label %341, label %451
341: ; preds = %336
store i32 0, i32* %19
%342 = load double*, double** %11
store double* %342, double** %12
store double 0.000000e+00, double* %15
br label %343
343: ; preds = %354, %341
%344 = load i32, i32* %19
%345 = load i32, i32* %22
%346 = icmp slt i32 %344, %345
br i1 %346, label %347, label %359
347: ; preds = %343
%348 = load double*, double** %12
%349 = load double, double* %348
%350 = load double*, double** %12
%351 = load double, double* %350
%352 = load double, double* %15
%353 = call double @llvm.fmuladd.f64(double %349, double %351, double %352)
store double %353, double* %15
br label %354
354: ; preds = %347
%355 = load i32, i32* %19
%356 = add nsw i32 %355, 1
store i32 %356, i32* %19
%357 = load double*, double** %12
%358 = getelementptr inbounds double, double* %357, i32 1
store double* %358, double** %12
br label %343
359: ; preds = %343
%360 = load double, double* %15
%361 = fcmp ogt double %360, 0.000000e+00
br i1 %361, label %362, label %450
362: ; preds = %359
%363 = load double, double* %15
%364 = call double @sqrt(double %363)
store double %364, double* %16
%365 = load double*, double** %11
%366 = load double, double* %365
%367 = fcmp olt double %366, 0.000000e+00
br i1 %367, label %368, label %371
368: ; preds = %362
%369 = load double, double* %16
%370 = fneg double %369
store double %370, double* %16
br label %371
371: ; preds = %368, %362
%372 = load double*, double** %11
%373 = load double, double* %372
%374 = load double, double* %16
%375 = load double, double* %15
%376 = call double @llvm.fmuladd.f64(double %373, double %374, double %375)
store double %376, double* %15
%377 = load double, double* %15
%378 = fdiv double 1.000000e+00, %377
store double %378, double* %15
%379 = load double, double* %16
%380 = load double*, double** %11
%381 = load double, double* %380
%382 = fadd double %381, %379
store double %382, double* %380
%383 = load i32, i32* %9
store i32 %383, i32* %20
%384 = load i32, i32* %9
%385 = load i32, i32* %8
%386 = load i32, i32* %18
%387 = sub nsw i32 %385, %386
%388 = mul nsw i32 %384, %387
store i32 %388, i32* %23
br label %389
389: ; preds = %442, %371
%390 = load i32, i32* %20
%391 = load i32, i32* %23
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %446
393: ; preds = %389
store i32 0, i32* %19
%394 = load double*, double** %11
store double* %394, double** %12
%395 = load double*, double** %11
%396 = load i32, i32* %20
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %395, i64 %397
store double* %398, double** %14
store double 0.000000e+00, double* %17
br label %399
399: ; preds = %412, %393
%400 = load i32, i32* %19
%401 = load i32, i32* %22
%402 = icmp slt i32 %400, %401
br i1 %402, label %403, label %415
403: ; preds = %399
%404 = load double*, double** %12
%405 = getelementptr inbounds double, double* %404, i32 1
store double* %405, double** %12
%406 = load double, double* %404
%407 = load double*, double** %14
%408 = getelementptr inbounds double, double* %407, i32 1
store double* %408, double** %14
%409 = load double, double* %407
%410 = load double, double* %17
%411 = call double @llvm.fmuladd.f64(double %406, double %409, double %410)
store double %411, double* %17
br label %412
412: ; preds = %403
%413 = load i32, i32* %19
%414 = add nsw i32 %413, 1
store i32 %414, i32* %19
br label %399
415: ; preds = %399
%416 = load double, double* %15
%417 = load double, double* %17
%418 = fmul double %417, %416
store double %418, double* %17
store i32 0, i32* %19
%419 = load double*, double** %11
store double* %419, double** %12
%420 = load double*, double** %11
%421 = load i32, i32* %20
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %420, i64 %422
store double* %423, double** %14
br label %424
424: ; preds = %438, %415
%425 = load i32, i32* %19
%426 = load i32, i32* %22
%427 = icmp slt i32 %425, %426
br i1 %427, label %428, label %441
428: ; preds = %424
%429 = load double, double* %17
%430 = load double*, double** %12
%431 = getelementptr inbounds double, double* %430, i32 1
store double* %431, double** %12
%432 = load double, double* %430
%433 = load double*, double** %14
%434 = getelementptr inbounds double, double* %433, i32 1
store double* %434, double** %14
%435 = load double, double* %433
%436 = fneg double %429
%437 = call double @llvm.fmuladd.f64(double %436, double %432, double %435)
store double %437, double* %433
br label %438
438: ; preds = %428
%439 = load i32, i32* %19
%440 = add nsw i32 %439, 1
store i32 %440, i32* %19
br label %424
441: ; preds = %424
br label %442
442: ; preds = %441
%443 = load i32, i32* %9
%444 = load i32, i32* %20
%445 = add nsw i32 %444, %443
store i32 %445, i32* %20
br label %389
446: ; preds = %389
%447 = load double, double* %16
%448 = fneg double %447
%449 = load double*, double** %11
store double %448, double* %449
br label %450
450: ; preds = %446, %359
br label %451
451: ; preds = %450, %336
br label %452
452: ; preds = %451
%453 = load i32, i32* %18
%454 = add nsw i32 %453, 1
store i32 %454, i32* %18
%455 = load i32, i32* %21
%456 = add nsw i32 %455, -1
store i32 %456, i32* %21
%457 = load i32, i32* %22
%458 = add nsw i32 %457, -1
store i32 %458, i32* %22
%459 = load i32, i32* %9
%460 = add nsw i32 %459, 1
%461 = load double*, double** %10
%462 = sext i32 %460 to i64
%463 = getelementptr inbounds double, double* %461, i64 %462
store double* %463, double** %10
br label %205
464: ; preds = %205
store i32 0, i32* %19
%465 = load double*, double** %7
store double* %465, double** %10
br label %466
466: ; preds = %495, %464
%467 = load i32, i32* %19
%468 = load i32, i32* %9
%469 = icmp slt i32 %467, %468
br i1 %469, label %470, label %503
470: ; preds = %466
%471 = load double*, double** %10
%472 = load double, double* %471
%473 = load double*, double** %6
%474 = load i32, i32* %19
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds double, double* %473, i64 %475
store double %472, double* %476
%477 = load i32, i32* %19
%478 = load i32, i32* %9
%479 = sub nsw i32 %478, 1
%480 = icmp slt i32 %477, %479
br i1 %480, label %481, label %489
481: ; preds = %470
%482 = load double*, double** %10
%483 = getelementptr inbounds double, double* %482, i64 1
%484 = load double, double* %483
%485 = load double*, double** %13
%486 = load i32, i32* %19
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds double, double* %485, i64 %487
store double %484, double* %488
br label %494
489: ; preds = %470
%490 = load double*, double** %13
%491 = load i32, i32* %19
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds double, double* %490, i64 %492
store double 0.000000e+00, double* %493
br label %494
494: ; preds = %489, %481
br label %495
495: ; preds = %494
%496 = load i32, i32* %19
%497 = add nsw i32 %496, 1
store i32 %497, i32* %19
%498 = load i32, i32* %9
%499 = add nsw i32 %498, 1
%500 = load double*, double** %10
%501 = sext i32 %499 to i64
%502 = getelementptr inbounds double, double* %500, i64 %501
store double* %502, double** %10
br label %466
503: ; preds = %466
%504 = load double*, double** %6
%505 = load double*, double** %13
%506 = load i32, i32* %9
%507 = call i32 @qrbdi(double* %504, double* %505, i32 %506)
store i32 0, i32* %18
br label %508
508: ; preds = %531, %503
%509 = load i32, i32* %18
%510 = load i32, i32* %9
%511 = icmp slt i32 %509, %510
br i1 %511, label %512, label %534
512: ; preds = %508
%513 = load double*, double** %6
%514 = load i32, i32* %18
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %513, i64 %515
%517 = load double, double* %516
%518 = fcmp olt double %517, 0.000000e+00
br i1 %518, label %519, label %530
519: ; preds = %512
%520 = load double*, double** %6
%521 = load i32, i32* %18
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %520, i64 %522
%524 = load double, double* %523
%525 = fneg double %524
%526 = load double*, double** %6
%527 = load i32, i32* %18
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %526, i64 %528
store double %525, double* %529
br label %530
530: ; preds = %519, %512
br label %531
531: ; preds = %530
%532 = load i32, i32* %18
%533 = add nsw i32 %532, 1
store i32 %533, i32* %18
br label %508
534: ; preds = %508
%535 = load double*, double** %13
%536 = call i32 @free(double* %535)
store i32 0, i32* %5
br label %537
537: ; preds = %534, %27
%538 = load i32, i32* %5
ret i32 %538
}

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