#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 svdval(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, nm = n - 1, p = a; i < n; ++i, --mm, --nm, p += n + 1) {
    if (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):
<svdval>:
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 <svdval+0x31>
movl   $0xffffffff,-0x4(%rbp)
jmp    180c <svdval+0x6cc>
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    -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    16e8 <svdval+0x5a8>
cmpl   $0x1,-0x70(%rbp)
jle    142f <svdval+0x2ef>
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    1233 <svdval+0xf3>
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    11cd <svdval+0x8d>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    142a <svdval+0x2ea>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1286 <svdval+0x146>
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  0xd53(%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    1406 <svdval+0x2c6>
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    135d <svdval+0x21d>
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    1306 <svdval+0x1c6>
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    13f3 <svdval+0x2b3>
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    1386 <svdval+0x246>
jmp    13f8 <svdval+0x2b8>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12d8 <svdval+0x198>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    142f <svdval+0x2ef>
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x1,-0x74(%rbp)
jle    16ab <svdval+0x56b>
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    14a4 <svdval+0x364>
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    145c <svdval+0x31c>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16a6 <svdval+0x566>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    14f7 <svdval+0x3b7>
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  0xae2(%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    1682 <svdval+0x542>
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    15d6 <svdval+0x496>
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    1584 <svdval+0x444>
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    166f <svdval+0x52f>
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    1607 <svdval+0x4c7>
jmp    1674 <svdval+0x534>
mov    -0x20(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    154e <svdval+0x40e>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    16ab <svdval+0x56b>
jmp    16b0 <svdval+0x570>
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    11a0 <svdval+0x60>
movl   $0x0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    177f <svdval+0x63f>
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
je     1744 <svdval+0x604>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1754 <svdval+0x614>
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1759 <svdval+0x619>
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    16f7 <svdval+0x5b7>
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    17fc <svdval+0x6bc>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    17e9 <svdval+0x6a9>
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    17ee <svdval+0x6ae>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1796 <svdval+0x656>
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):
<svdval>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rsi,0x40(%rsp)
mov    $0xffffffff,%eax
cmp    %ecx,%edx
jl     1d1d <svdval+0xbdd>
mov    %ecx,%r12d
mov    %edx,%r13d
mov    %rdi,%r15
mov    %edx,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%rbx
test   %r12d,%r12d
jle    1c23 <svdval+0xae3>
mov    %r15,0xb0(%rsp)
lea    -0x1(%r12),%edx
mov    %r12d,%r8d
lea    0x1(%r8),%rax
mov    %rax,0x90(%rsp)
movslq %r13d,%rax
mov    %rax,0xb8(%rsp)
lea    0x2(%r8),%rax
mov    %rax,0xd0(%rsp)
lea    -0x2(%r12),%ebp
lea    0x8(,%r8,8),%r11
mov    %r8,%rdi
shl    $0x4,%rdi
mov    0x40(%rsp),%rcx
lea    0x8(%rcx),%r14
mov    %r8,%rax
shl    $0x5,%rax
mov    %rax,0xa0(%rsp)
mov    %r12,%rax
lea    0x0(,%r8,8),%r12
lea    (%rcx,%r8,8),%rsi
add    $0x8,%rsi
xor    %r9d,%r9d
xorpd  %xmm10,%xmm10
movapd 0xdf9(%rip),%xmm9
mov    %ebp,0x58(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rax,0xa8(%rsp)
mov    %eax,0x54(%rsp)
mov    %edx,0x84(%rsp)
mov    %edx,%eax
mov    %rax,0x10(%rsp)
mov    %ebp,%edx
mov    %r8,0x20(%rsp)
mov    %r11,0x70(%rsp)
mov    %rdi,0x88(%rsp)
jmp    129c <svdval+0x15c>
xorpd  %xmm9,%xmm1
movlpd %xmm1,0x0(%r13)
mov    0x70(%rsp),%r11
mov    0x88(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0xc(%rsp),%edx
mov    0x10(%rsp),%rcx
add    $0x1,%r9
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%r13d
add    $0xffffffff,%ecx
mov    %rcx,0x10(%rsp)
add    %r11,0x30(%rsp)
addl   $0xffffffff,0x54(%rsp)
add    %r11,%r14
add    %r11,%rsi
add    $0xffffffff,%edx
cmp    %r8,%r9
je     1b78 <svdval+0xa38>
mov    %r13d,%eax
mov    %rax,0x18(%rsp)
cmp    $0x2,%r13d
jl     15f9 <svdval+0x4b9>
mov    %edx,0xc(%rsp)
and    $0x3,%r13d
mov    0x18(%rsp),%rax
mov    %eax,%ebp
and    $0xfffffffc,%ebp
mov    %eax,%ecx
and    $0xfffffffe,%ecx
lea    -0x1(%rax),%r15
xorpd  %xmm4,%xmm4
mov    0x30(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
movsd  (%rax,%r8,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
movsd  (%rax,%r8,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
add    $0x2,%rdx
add    %rdi,%rax
cmp    %rdx,%rcx
jne    12e0 <svdval+0x1a0>
testb  $0x1,0x18(%rsp)
je     1337 <svdval+0x1f7>
movsd  (%rax),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
mov    0xc(%rsp),%edx
ucomisd %xmm10,%xmm4
jbe    15f9 <svdval+0x4b9>
mov    %rsi,0x60(%rsp)
mov    %r9,0x28(%rsp)
jb     135b <svdval+0x21b>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    138d <svdval+0x24d>
movapd %xmm4,%xmm0
movsd  %xmm4,0x38(%rsp)
call   1060 <sqrt@plt>
movsd  0x38(%rsp),%xmm4
xorpd  %xmm10,%xmm10
mov    0x28(%rsp),%r9
mov    0x70(%rsp),%r11
movapd 0xc78(%rip),%xmm9
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x30(%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    %r8,%rax
sub    %r9,%rax
cmp    $0x2,%rax
jl     15d0 <svdval+0x490>
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movsd  0xc2a(%rip),%xmm0
divsd  %xmm2,%xmm0
mov    0x54(%rsp),%r8d
mov    $0x1,%ecx
mov    %r14,%r9
jmp    1411 <svdval+0x2d1>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x8,%r9
cmp    %r8,%rcx
je     15d0 <svdval+0x490>
test   %edi,%edi
jle    1400 <svdval+0x2c0>
mov    0x30(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
xorpd  %xmm2,%xmm2
cmp    $0x3,%r15
jae    1440 <svdval+0x300>
xor    %eax,%eax
mov    %rdx,%rsi
test   $0x3,%dil
jne    14b8 <svdval+0x378>
jmp    14d9 <svdval+0x399>
nopl   0x0(%rax)
mov    %r9,%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    %r12,%rdi
mulsd  (%rsi,%r12,1),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rbx,%rax,8),%xmm3
mulsd  (%r12,%rdi,1),%xmm3
add    %r12,%rdi
addsd  %xmm4,%xmm3
movsd  0x18(%rbx,%rax,8),%xmm2
add    $0x4,%rax
mulsd  (%r12,%rdi,1),%xmm2
add    %r12,%rdi
addsd  %xmm3,%xmm2
add    %r12,%rdi
cmp    %rax,%rbp
jne    1450 <svdval+0x310>
add    0xa0(%rsp),%rsi
mov    0x18(%rsp),%rdi
test   $0x3,%dil
je     14d9 <svdval+0x399>
lea    (%rbx,%rax,8),%rax
xor    %edi,%edi
xchg   %ax,%ax
movsd  (%rax,%rdi,8),%xmm3
mulsd  (%rsi),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rdi
add    %r12,%rsi
cmp    %rdi,%r13
jne    14c0 <svdval+0x380>
mov    0x18(%rsp),%rdi
test   %edi,%edi
jle    1400 <svdval+0x2c0>
xorpd  %xmm9,%xmm2
mulsd  %xmm0,%xmm2
cmp    $0x3,%r15
jae    1506 <svdval+0x3c6>
xor    %eax,%eax
test   $0x3,%dil
jne    1594 <svdval+0x454>
jmp    1400 <svdval+0x2c0>
mov    %r9,%rsi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rdx
movsd  (%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rsi),%xmm3
movsd  %xmm3,(%rsi)
add    %r12,%rsi
movsd  0x8(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx,%r12,1),%xmm3
movsd  %xmm3,(%rdx,%r12,1)
lea    (%rsi,%r12,1),%rdi
movsd  0x10(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r12,%rsi,1),%xmm3
movsd  %xmm3,(%r12,%rsi,1)
lea    (%rdi,%r12,1),%rsi
movsd  0x18(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r12,%rdi,1),%xmm3
add    $0x4,%rax
movsd  %xmm3,(%r12,%rdi,1)
add    %r12,%rsi
cmp    %rax,%rbp
jne    1510 <svdval+0x3d0>
add    0xa0(%rsp),%rdx
mov    0x18(%rsp),%rdi
test   $0x3,%dil
je     1400 <svdval+0x2c0>
lea    (%rbx,%rax,8),%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx),%xmm3
movsd  %xmm3,(%rdx)
add    $0x1,%rsi
add    %r12,%rdx
cmp    %rsi,%r13
jne    15a0 <svdval+0x460>
jmp    1400 <svdval+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm9,%xmm1
mov    0x30(%rsp),%rax
movlpd %xmm1,(%rax)
mov    0x20(%rsp),%r8
mov    0x88(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    0xc(%rsp),%edx
mov    0x10(%rsp),%rcx
cmp    $0x2,%ecx
jl     126b <svdval+0x12b>
mov    %edx,%r10d
add    $0x1,%r10
mov    0x58(%rsp),%eax
mov    %eax,%r11d
sub    %r9d,%r11d
and    $0xfffffffffffffffc,%r10
lea    0x1(%r11),%rax
add    $0xfffffffffffffffc,%r10
mov    %rax,0xe0(%rsp)
mov    %rax,%rbp
movabs $0x1fffffffc,%rax
and    %rax,%rbp
shr    $0x2,%r10
mov    %rbp,%rax
mov    %rbp,0x78(%rsp)
lea    -0x4(%rbp),%rax
mov    %rax,0x98(%rsp)
mov    %r9,%rax
imul   0x90(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    %ecx,%r15d
and    $0x3,%r15d
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %eax,0x5c(%rsp)
mov    0x30(%rsp),%rax
lea    0x8(%rax),%r13
xorpd  %xmm4,%xmm4
mov    %r13,%rax
mov    %r11,%rcx
mov    %r11,0x38(%rsp)
cmp    $0x3,%r11d
jb     16dc <svdval+0x59c>
xorpd  %xmm4,%xmm4
mov    0x5c(%rsp),%ecx
mov    %r13,%rax
xchg   %ax,%ax
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    16a0 <svdval+0x560>
mov    %rsi,%r11
add    $0x1,%r10
mov    0x98(%rsp),%rbp
shr    $0x2,%rbp
mov    0xd0(%rsp),%rcx
mov    0x48(%rsp),%rsi
add    %rcx,%rsi
testb  $0x3,0x10(%rsp)
je     1726 <svdval+0x5e6>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rcx
cmp    %ecx,%r15d
jne    1710 <svdval+0x5d0>
and    $0xfffffffffffffffe,%r10
add    $0x1,%rbp
mov    %rbp,0xd8(%rsp)
mov    0x90(%rsp),%rax
mov    0x48(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xf0(%rsp)
add    0x38(%rsp),%rsi
mov    %rsi,0xe8(%rsp)
ucomisd %xmm10,%xmm4
mov    0x10(%rsp),%rcx
mov    0x70(%rsp),%rax
mov    %r11,%rsi
mov    %rax,%r11
jbe    126b <svdval+0x12b>
mov    %rsi,0x60(%rsp)
mov    %r9,0x28(%rsp)
mov    %edx,0xc(%rsp)
mov    %r10,0xc8(%rsp)
jb     1797 <svdval+0x657>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    17c4 <svdval+0x684>
movapd %xmm4,%xmm0
movsd  %xmm4,0x68(%rsp)
call   1060 <sqrt@plt>
movsd  0x68(%rsp),%xmm4
xorpd  %xmm10,%xmm10
mov    0x28(%rsp),%r9
movapd 0x841(%rip),%xmm9
mov    0x20(%rsp),%r8
movsd  0x0(%r13),%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,0x0(%r13)
mov    0xb8(%rsp),%r11
sub    %r9,%r11
imul   %r8,%r11
cmp    %r8,%r11
jle    1240 <svdval+0x100>
mov    0x40(%rsp),%rax
mov    0x48(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
add    $0x8,%rcx
mov    0x38(%rsp),%rax
mov    %rcx,0x68(%rsp)
lea    0x8(%rcx,%rax,8),%rax
mov    %rax,0x48(%rsp)
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movsd  0x7ca(%rip),%xmm8
divsd  %xmm2,%xmm8
mov    0x78(%rsp),%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
mov    %rax,0xc0(%rsp)
mov    0x60(%rsp),%rdi
xor    %r10d,%r10d
mov    %r8,%rbp
jmp    1883 <svdval+0x743>
add    %r8,%rbp
add    $0x1,%r10
add    %r12,%rdi
cmp    %r11,%rbp
jge    1240 <svdval+0x100>
cmpl   $0x0,0x10(%rsp)
jle    1870 <svdval+0x730>
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
xorpd  %xmm2,%xmm2
mov    %rcx,%rdx
mov    %r13,%rax
cmpl   $0x3,0x38(%rsp)
mov    0x10(%rsp),%r9
jb     1912 <svdval+0x7d2>
xorpd  %xmm2,%xmm2
mov    0x5c(%rsp),%edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%rax,1),%xmm0
movsd  0x8(%r14,%rax,1),%xmm3
mulsd  (%rdi,%rax,1),%xmm0
mulsd  0x8(%rdi,%rax,1),%xmm3
addsd  %xmm2,%xmm0
movsd  0x10(%r14,%rax,1),%xmm4
mulsd  0x10(%rdi,%rax,1),%xmm4
addsd  %xmm0,%xmm3
movsd  0x18(%r14,%rax,1),%xmm2
mulsd  0x18(%rdi,%rax,1),%xmm2
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
add    $0x20,%rax
add    $0xfffffffc,%edx
jne    18c0 <svdval+0x780>
lea    (%rdi,%rax,1),%rdx
add    %r14,%rax
test   $0x3,%r9b
je     1937 <svdval+0x7f7>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm3
mulsd  (%rdx,%rsi,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rsi
cmp    %esi,%r15d
jne    1920 <svdval+0x7e0>
test   %r9d,%r9d
jle    1870 <svdval+0x730>
xor    %r9d,%r9d
xorpd  %xmm9,%xmm2
mulsd  %xmm8,%xmm2
cmpl   $0x3,0x38(%rsp)
jb     1991 <svdval+0x851>
mov    %r10,%rax
imul   %r8,%rax
mov    0xf0(%rsp),%rdx
add    %rax,%rdx
mov    0x40(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
cmp    0x48(%rsp),%rdx
jae    1a62 <svdval+0x922>
add    0xe8(%rsp),%rax
lea    (%rsi,%rax,8),%rax
cmp    %rax,0x68(%rsp)
jae    1a62 <svdval+0x922>
mov    %r13,%rdx
mov    0x10(%rsp),%rax
sub    %r9d,%eax
mov    0x28(%rsp),%rsi
add    %r9d,%esi
mov    0x58(%rsp),%r8d
sub    %esi,%r8d
test   $0x3,%al
je     19e2 <svdval+0x8a2>
mov    %r15d,%eax
sub    %r9b,%al
movzbl %al,%eax
and    $0x3,%eax
neg    %eax
xor    %esi,%esi
movsd  (%rdx),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rcx),%xmm0
movsd  %xmm0,(%rcx)
add    $0x8,%rcx
add    $0x8,%rdx
add    $0xffffffff,%esi
cmp    %esi,%eax
jne    19c0 <svdval+0x880>
sub    %esi,%r9d
cmp    $0x3,%r8d
mov    0x20(%rsp),%r8
jb     1870 <svdval+0x730>
mov    0x10(%rsp),%rax
sub    %r9d,%eax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  0x8(%rdx,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x8(%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rsi,8)
movsd  0x10(%rdx,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x10(%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rsi,8)
movsd  0x18(%rdx,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x18(%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%eax
jne    1a00 <svdval+0x8c0>
jmp    1870 <svdval+0x730>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,0x98(%rsp)
je     1b6a <svdval+0xa2a>
mov    0xc8(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r14,%rax,8),%xmm4
movupd 0x10(%r14,%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(%r14,%rax,8),%xmm4
movupd 0x30(%r14,%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,%rdx
jne    1a90 <svdval+0x950>
testb  $0x1,0xd8(%rsp)
01
je     1b41 <svdval+0xa01>
movupd 0x0(%r13,%rax,8),%xmm0
movupd 0x10(%r13,%rax,8),%xmm4
movupd (%rcx,%rax,8),%xmm5
movupd 0x10(%rcx,%rax,8),%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm4,0x10(%rcx,%rax,8)
mov    0x78(%rsp),%rax
cmp    %rax,0xe0(%rsp)
je     1870 <svdval+0x730>
mov    0x78(%rsp),%r9
lea    (%rcx,%r9,8),%rcx
mov    0xc0(%rsp),%rdx
jmp    1994 <svdval+0x854>
xor    %eax,%eax
testb  $0x1,0xd8(%rsp)
01
jne    1b0d <svdval+0x9cd>
jmp    1b41 <svdval+0xa01>
mov    0xa8(%rsp),%r12
test   %r12d,%r12d
mov    0xb0(%rsp),%r15
jle    1c23 <svdval+0xae3>
mov    0x84(%rsp),%eax
mov    %r8,%r14
add    $0xffffffffffffffff,%r14
je     1c42 <svdval+0xb02>
lea    0x1(%r12),%edx
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
mov    %rdx,%rdi
shl    $0x4,%rdi
xor    %ecx,%ecx
mov    0x40(%rsp),%rsi
jmp    1be2 <svdval+0xaa2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    %rdi,%rsi
add    $0x1,%rcx
cmp    %r9,%rcx
je     1c36 <svdval+0xaf6>
mov    %rcx,%rbp
movsd  (%rsi),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
cmp    %rcx,%rax
je     1c01 <svdval+0xac1>
movsd  0x8(%rsi),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
movsd  (%rsi,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r15,%rbp,8)
lea    0x1(%rbp),%rcx
cmp    %rax,%rcx
je     1bd0 <svdval+0xa90>
movsd  0x8(%rsi,%rdx,8),%xmm0
jmp    1bd0 <svdval+0xa90>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r12d,%edx
call   1040 <qrbdi@plt>
jmp    1d13 <svdval+0xbd3>
add    $0x2,%rbp
test   $0x1,%r8b
jne    1c4f <svdval+0xb0f>
jmp    1c6c <svdval+0xb2c>
xor    %ebp,%ebp
mov    0x40(%rsp),%rsi
test   $0x1,%r8b
je     1c6c <svdval+0xb2c>
movsd  (%rsi),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
xorpd  %xmm0,%xmm0
cmp    %rax,%rbp
je     1c67 <svdval+0xb27>
movsd  0x8(%rsi),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r12d,%edx
call   1040 <qrbdi@plt>
test   %r12d,%r12d
jle    1d13 <svdval+0xbd3>
test   %r14,%r14
je     1ce9 <svdval+0xba9>
mov    0x20(%rsp),%rdx
mov    %edx,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movapd 0x360(%rip),%xmm2
jmp    1cb9 <svdval+0xb79>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rax
cmp    %rax,%rcx
je     1cf0 <svdval+0xbb0>
movsd  (%r15,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ccf <svdval+0xb8f>
xorpd  %xmm2,%xmm1
movlpd %xmm1,(%r15,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    1cb0 <svdval+0xb70>
xorpd  %xmm2,%xmm1
movlpd %xmm1,0x8(%r15,%rax,8)
jmp    1cb0 <svdval+0xb70>
xor    %eax,%eax
mov    0x20(%rsp),%rdx
test   $0x1,%dl
je     1d13 <svdval+0xbd3>
movsd  (%r15,%rax,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    1d13 <svdval+0xbd3>
xorpd  0x2f3(%rip),%xmm0
movlpd %xmm0,(%r15,%rax,8)
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

LLVM IR (-O0):
define i32 @svdval(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 %365
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 i32, i32* %9
%34 = sub nsw i32 %33, 1
store i32 %34, i32* %22
%35 = load double*, double** %7
store double* %35, double** %10
br label %36
36: ; preds = %280, %28
%37 = load i32, i32* %18
%38 = load i32, i32* %9
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %292
40: ; preds = %36
%41 = load i32, i32* %21
%42 = icmp sgt i32 %41, 1
br i1 %42, label %43, label %164
43: ; preds = %40
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* %15
%128 = load double, double* %17
%129 = fmul double %128, %127
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, %40
%165 = load double*, double** %10
%166 = getelementptr inbounds double, double* %165, i64 1
store double* %166, double** %11
%167 = load i32, i32* %22
%168 = icmp sgt i32 %167, 1
br i1 %168, label %169, label %279
169: ; preds = %164
store i32 0, i32* %19
%170 = load double*, double** %11
store double* %170, double** %12
store double 0.000000e+00, double* %15
br label %171
171: ; preds = %182, %169
%172 = load i32, i32* %19
%173 = load i32, i32* %22
%174 = icmp slt i32 %172, %173
br i1 %174, label %175, label %187
175: ; preds = %171
%176 = load double*, double** %12
%177 = load double, double* %176
%178 = load double*, double** %12
%179 = load double, double* %178
%180 = load double, double* %15
%181 = call double @llvm.fmuladd.f64(double %177, double %179, double %180)
store double %181, double* %15
br label %182
182: ; preds = %175
%183 = load i32, i32* %19
%184 = add nsw i32 %183, 1
store i32 %184, i32* %19
%185 = load double*, double** %12
%186 = getelementptr inbounds double, double* %185, i32 1
store double* %186, double** %12
br label %171
187: ; preds = %171
%188 = load double, double* %15
%189 = fcmp ogt double %188, 0.000000e+00
br i1 %189, label %190, label %278
190: ; preds = %187
%191 = load double, double* %15
%192 = call double @sqrt(double %191)
store double %192, double* %16
%193 = load double*, double** %11
%194 = load double, double* %193
%195 = fcmp olt double %194, 0.000000e+00
br i1 %195, label %196, label %199
196: ; preds = %190
%197 = load double, double* %16
%198 = fneg double %197
store double %198, double* %16
br label %199
199: ; preds = %196, %190
%200 = load double*, double** %11
%201 = load double, double* %200
%202 = load double, double* %16
%203 = load double, double* %15
%204 = call double @llvm.fmuladd.f64(double %201, double %202, double %203)
store double %204, double* %15
%205 = load double, double* %15
%206 = fdiv double 1.000000e+00, %205
store double %206, double* %15
%207 = load double, double* %16
%208 = load double*, double** %11
%209 = load double, double* %208
%210 = fadd double %209, %207
store double %210, double* %208
%211 = load i32, i32* %9
store i32 %211, i32* %20
%212 = load i32, i32* %9
%213 = load i32, i32* %8
%214 = load i32, i32* %18
%215 = sub nsw i32 %213, %214
%216 = mul nsw i32 %212, %215
store i32 %216, i32* %23
br label %217
217: ; preds = %270, %199
%218 = load i32, i32* %20
%219 = load i32, i32* %23
%220 = icmp slt i32 %218, %219
br i1 %220, label %221, label %274
221: ; preds = %217
store i32 0, i32* %19
%222 = load double*, double** %11
store double* %222, double** %12
%223 = load double*, double** %11
%224 = load i32, i32* %20
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
store double* %226, double** %14
store double 0.000000e+00, double* %17
br label %227
227: ; preds = %240, %221
%228 = load i32, i32* %19
%229 = load i32, i32* %22
%230 = icmp slt i32 %228, %229
br i1 %230, label %231, label %243
231: ; preds = %227
%232 = load double*, double** %12
%233 = getelementptr inbounds double, double* %232, i32 1
store double* %233, double** %12
%234 = load double, double* %232
%235 = load double*, double** %14
%236 = getelementptr inbounds double, double* %235, i32 1
store double* %236, double** %14
%237 = load double, double* %235
%238 = load double, double* %17
%239 = call double @llvm.fmuladd.f64(double %234, double %237, double %238)
store double %239, double* %17
br label %240
240: ; preds = %231
%241 = load i32, i32* %19
%242 = add nsw i32 %241, 1
store i32 %242, i32* %19
br label %227
243: ; preds = %227
%244 = load double, double* %15
%245 = load double, double* %17
%246 = fmul double %245, %244
store double %246, double* %17
store i32 0, i32* %19
%247 = load double*, double** %11
store double* %247, double** %12
%248 = load double*, double** %11
%249 = load i32, i32* %20
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %248, i64 %250
store double* %251, double** %14
br label %252
252: ; preds = %266, %243
%253 = load i32, i32* %19
%254 = load i32, i32* %22
%255 = icmp slt i32 %253, %254
br i1 %255, label %256, label %269
256: ; preds = %252
%257 = load double, double* %17
%258 = load double*, double** %12
%259 = getelementptr inbounds double, double* %258, i32 1
store double* %259, double** %12
%260 = load double, double* %258
%261 = load double*, double** %14
%262 = getelementptr inbounds double, double* %261, i32 1
store double* %262, double** %14
%263 = load double, double* %261
%264 = fneg double %257
%265 = call double @llvm.fmuladd.f64(double %264, double %260, double %263)
store double %265, double* %261
br label %266
266: ; preds = %256
%267 = load i32, i32* %19
%268 = add nsw i32 %267, 1
store i32 %268, i32* %19
br label %252
269: ; preds = %252
br label %270
270: ; preds = %269
%271 = load i32, i32* %9
%272 = load i32, i32* %20
%273 = add nsw i32 %272, %271
store i32 %273, i32* %20
br label %217
274: ; preds = %217
%275 = load double, double* %16
%276 = fneg double %275
%277 = load double*, double** %11
store double %276, double* %277
br label %278
278: ; preds = %274, %187
br label %279
279: ; preds = %278, %164
br label %280
280: ; preds = %279
%281 = load i32, i32* %18
%282 = add nsw i32 %281, 1
store i32 %282, i32* %18
%283 = load i32, i32* %21
%284 = add nsw i32 %283, -1
store i32 %284, i32* %21
%285 = load i32, i32* %22
%286 = add nsw i32 %285, -1
store i32 %286, i32* %22
%287 = load i32, i32* %9
%288 = add nsw i32 %287, 1
%289 = load double*, double** %10
%290 = sext i32 %288 to i64
%291 = getelementptr inbounds double, double* %289, i64 %290
store double* %291, double** %10
br label %36
292: ; preds = %36
store i32 0, i32* %19
%293 = load double*, double** %7
store double* %293, double** %10
br label %294
294: ; preds = %323, %292
%295 = load i32, i32* %19
%296 = load i32, i32* %9
%297 = icmp slt i32 %295, %296
br i1 %297, label %298, label %331
298: ; preds = %294
%299 = load double*, double** %10
%300 = load double, double* %299
%301 = load double*, double** %6
%302 = load i32, i32* %19
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %301, i64 %303
store double %300, double* %304
%305 = load i32, i32* %19
%306 = load i32, i32* %9
%307 = sub nsw i32 %306, 1
%308 = icmp ne i32 %305, %307
br i1 %308, label %309, label %317
309: ; preds = %298
%310 = load double*, double** %10
%311 = getelementptr inbounds double, double* %310, i64 1
%312 = load double, double* %311
%313 = load double*, double** %13
%314 = load i32, i32* %19
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %313, i64 %315
store double %312, double* %316
br label %322
317: ; preds = %298
%318 = load double*, double** %13
%319 = load i32, i32* %19
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %318, i64 %320
store double 0.000000e+00, double* %321
br label %322
322: ; preds = %317, %309
br label %323
323: ; preds = %322
%324 = load i32, i32* %19
%325 = add nsw i32 %324, 1
store i32 %325, i32* %19
%326 = load i32, i32* %9
%327 = add nsw i32 %326, 1
%328 = load double*, double** %10
%329 = sext i32 %327 to i64
%330 = getelementptr inbounds double, double* %328, i64 %329
store double* %330, double** %10
br label %294
331: ; preds = %294
%332 = load double*, double** %6
%333 = load double*, double** %13
%334 = load i32, i32* %9
%335 = call i32 @qrbdi(double* %332, double* %333, i32 %334)
store i32 0, i32* %18
br label %336
336: ; preds = %359, %331
%337 = load i32, i32* %18
%338 = load i32, i32* %9
%339 = icmp slt i32 %337, %338
br i1 %339, label %340, label %362
340: ; preds = %336
%341 = load double*, double** %6
%342 = load i32, i32* %18
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %341, i64 %343
%345 = load double, double* %344
%346 = fcmp olt double %345, 0.000000e+00
br i1 %346, label %347, label %358
347: ; preds = %340
%348 = load double*, double** %6
%349 = load i32, i32* %18
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %348, i64 %350
%352 = load double, double* %351
%353 = fneg double %352
%354 = load double*, double** %6
%355 = load i32, i32* %18
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double, double* %354, i64 %356
store double %353, double* %357
br label %358
358: ; preds = %347, %340
br label %359
359: ; preds = %358
%360 = load i32, i32* %18
%361 = add nsw i32 %360, 1
store i32 %361, i32* %18
br label %336
362: ; preds = %336
%363 = load double*, double** %13
%364 = call i32 @free(double* %363)
store i32 0, i32* %5
br label %365
365: ; preds = %362, %27
%366 = load i32, i32* %5
ret i32 %366
}

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