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


x86 assembly (clang, -O0):
<svduv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    11aa <svduv+0x3a>
movl   $0xffffffff,-0x4(%rbp)
jmp    1b28 <svduv+0x9b8>
mov    -0x24(%rbp),%edi
add    -0x34(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    19d3 <svduv+0x863>
cmpl   $0x1,-0xa0(%rbp)
jle    15af <svduv+0x43f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    12b6 <svduv+0x146>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1241 <svduv+0xd1>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1573 <svduv+0x403>
movsd  -0x70(%rbp),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1309 <svduv+0x199>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xcd0(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x60(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0xcad(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x78(%rbp),%xmm0
call   1070 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xc83(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x94(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    1500 <svduv+0x390>
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    143f <svduv+0x2cf>
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    13dc <svduv+0x26c>
movsd  -0x70(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    14e7 <svduv+0x377>
movsd  -0x80(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    146e <svduv+0x2fe>
jmp    14ec <svduv+0x37c>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    13a2 <svduv+0x232>
movl   $0x1,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    156e <svduv+0x3fe>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x98(%rbp)
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x50(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
jmp    1512 <svduv+0x3a2>
jmp    1573 <svduv+0x403>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xa0(%rbp)
jne    15d4 <svduv+0x464>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
cmpl   $0x1,-0xa4(%rbp)
jle    195f <svduv+0x7ef>
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    166e <svduv+0x4fe>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
jmp    161a <svduv+0x4aa>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1923 <svduv+0x7b3>
movsd  -0x70(%rbp),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    16c1 <svduv+0x551>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x78(%rbp),%xmm0
call   1070 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x921(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x8ee(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x48(%rbp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  0x8cb(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    -0x94(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    18c3 <svduv+0x753>
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    17ff <svduv+0x68f>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    17a1 <svduv+0x631>
movsd  -0x70(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    18aa <svduv+0x73a>
movsd  -0x80(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
movsd  (%rax),%xmm2
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1836 <svduv+0x6c6>
jmp    18af <svduv+0x73f>
mov    -0x34(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    175f <svduv+0x5ef>
movl   $0x1,-0x98(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    191e <svduv+0x7ae>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    18d9 <svduv+0x769>
jmp    1923 <svduv+0x7b3>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0xa4(%rbp)
jne    1984 <svduv+0x814>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1989 <svduv+0x819>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0xa0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    11f8 <svduv+0x88>
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1080 <ldvmat@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x34(%rbp),%ecx
call   1040 <ldumat@plt>
mov    -0x10(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    -0x34(%rbp),%r9d
call   1050 <qrbdv@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1b18 <svduv+0x9a8>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1aff <svduv+0x98f>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x98(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1afa <svduv+0x98a>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1a9b <svduv+0x92b>
jmp    1aff <svduv+0x98f>
jmp    1b04 <svduv+0x994>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1a1c <svduv+0x8ac>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svduv>:
mov    $0xffffffff,%eax
cmp    %r9d,%ecx
jl     216c <svduv+0xffc>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9d,%r14d
mov    %r8,%r15
mov    %ecx,%ebp
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,0x18(%rsp)
lea    (%r14,%rbp,1),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
movslq %ebp,%rax
mov    %rax,0x118(%rsp)
lea    (%rbx,%rax,8),%r10
test   %r14d,%r14d
mov    %r10,0x40(%rsp)
jle    2119 <svduv+0xfa9>
mov    %r12,0xd0(%rsp)
mov    %r15,0xe0(%rsp)
mov    %r13,%rdx
mov    %r14d,%r13d
lea    0x1(%r13),%rax
mov    %rax,0xf8(%rsp)
lea    -0x3(%r14),%r8d
lea    0x2(%r13),%rax
mov    %rax,0xf0(%rsp)
lea    -0x2(%r14),%edi
lea    -0x1(%r14),%r11d
lea    0x8(,%r13,8),%r9
mov    %r13,%rax
shl    $0x4,%rax
mov    %rbp,%rcx
lea    0x8(%rdx),%r15
mov    %r13,%rbp
shl    $0x5,%rbp
mov    %rbp,0xa8(%rsp)
lea    0x0(,%r13,8),%rbp
lea    0x0(,%rbp,2),%rsi
add    %rbp,%rsi
mov    %rsi,0x110(%rsp)
lea    0x3(%rcx),%esi
lea    0x8(%rdx,%r13,8),%r12
movapd 0x1da6(%rip),%xmm7
mov    %r8d,0xb8(%rsp)
mov    %r8d,0x64(%rsp)
mov    %rax,%r8
mov    %edi,0x6c(%rsp)
mov    %edi,0x68(%rsp)
mov    %r12,%rdi
xor    %r12d,%r12d
mov    %r11d,0x34(%rsp)
mov    %r11d,%eax
mov    %rax,0x58(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %rdx,0x10(%rsp)
mov    %r14,0xe8(%rsp)
mov    %r14,0x50(%rsp)
mov    %rcx,0xd8(%rsp)
mov    %ecx,%r14d
mov    0x18(%rsp),%r11
mov    %r9,0x78(%rsp)
mov    %r8,0x88(%rsp)
jmp    1303 <svduv+0x193>
xchg   %ax,%ax
add    $0x1,%r12
mov    0x28(%rsp),%rax
lea    -0x1(%rax),%r14d
add    %r9,0x10(%rsp)
add    %r9,%r15
add    $0x3,%sil
mov    0x58(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x58(%rsp)
add    %r9,%rdi
addl   $0xffffffff,0x68(%rsp)
addl   $0xffffffff,0x64(%rsp)
mov    %edx,%eax
mov    %rax,0x50(%rsp)
cmp    %r13,%r12
je     1fa9 <svduv+0xe39>
movzbl %sil,%esi
and    $0x3,%esi
mov    %r14d,%eax
cmp    $0x2,%r14d
mov    %rax,0x28(%rsp)
jl     17a2 <svduv+0x632>
mov    %r12,0x20(%rsp)
lea    -0x1(%rax),%rdx
mov    %rdx,%rcx
mov    %rdx,(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x80(%rsp)
and    $0x3,%r14d
mov    %eax,%r12d
and    $0xfffffffc,%r12d
mov    %eax,%ecx
and    $0xfffffffe,%ecx
add    $0xfffffffffffffffe,%rax
mov    %rax,0xb0(%rsp)
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%rax
xor    %edx,%edx
nop
movsd  (%rax),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movsd  (%rax,%r13,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
movsd  (%rax,%r13,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdx
add    %r8,%rax
cmp    %rdx,%rcx
jne    1360 <svduv+0x1f0>
testb  $0x1,0x28(%rsp)
je     13b7 <svduv+0x247>
movsd  (%rax),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  (%rax),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
xorpd  %xmm5,%xmm5
ucomisd %xmm5,%xmm0
xorpd  %xmm1,%xmm1
jbe    1785 <svduv+0x615>
ucomisd 0x1c47(%rip),%xmm0
mov    %rsi,0x48(%rsp)
mov    %rdi,0x38(%rsp)
movsd  %xmm0,0x98(%rsp)
jb     13ec <svduv+0x27c>
sqrtsd %xmm0,%xmm0
jmp    13f9 <svduv+0x289>
call   1090 <sqrt@plt>
movapd 0x1c07(%rip),%xmm7
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm0,%xmm1
xorpd  %xmm7,%xmm1
movsd  %xmm2,0x90(%rsp)
cmpltsd 0x1bfc(%rip),%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
movapd %xmm2,0xc0(%rsp)
movsd  (%rbx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  %xmm0,(%rbx)
movsd  (%rax),%xmm0
divsd  %xmm2,%xmm0
call   1070 <fabs@plt>
movapd 0xc0(%rsp),%xmm5
movapd 0x1b9f(%rip),%xmm7
mov    %r13,%rcx
sub    0x20(%rsp),%rcx
cmp    $0x2,%rcx
mov    0x18(%rsp),%r11
movsd  0x1b96(%rip),%xmm4
mov    0x28(%rsp),%rdi
jl     1690 <svduv+0x520>
movsd  0x90(%rsp),%xmm1
mulsd  %xmm5,%xmm1
addsd  0x98(%rsp),%xmm1
movapd %xmm4,%xmm0
divsd  %xmm1,%xmm0
mov    0x50(%rsp),%r8d
mov    $0x1,%r10d
mov    %r15,%r9
jmp    14d1 <svduv+0x361>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
add    $0x8,%r9
cmp    %r8,%r10
je     1690 <svduv+0x520>
test   %edi,%edi
jle    14c0 <svduv+0x350>
mov    0x10(%rsp),%rcx
lea    (%rcx,%r10,8),%rdx
cmpq   $0x3,(%rsp)
jae    1500 <svduv+0x390>
xorpd  %xmm1,%xmm1
xor    %esi,%esi
mov    %rdx,%rcx
test   $0x3,%dil
jne    1577 <svduv+0x407>
jmp    1599 <svduv+0x429>
nopl   (%rax)
xorpd  %xmm1,%xmm1
mov    %r9,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
mov    %rdi,%rcx
movsd  (%rbx,%rsi,8),%xmm2
movsd  0x8(%rbx,%rsi,8),%xmm3
mulsd  (%rdi),%xmm2
addsd  %xmm1,%xmm2
add    %rbp,%rdi
mulsd  (%rcx,%rbp,1),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rbx,%rsi,8),%xmm2
mulsd  0x0(%rbp,%rdi,1),%xmm2
add    %rbp,%rdi
addsd  %xmm3,%xmm2
movsd  0x18(%rbx,%rsi,8),%xmm1
add    $0x4,%rsi
mulsd  0x0(%rbp,%rdi,1),%xmm1
add    %rbp,%rdi
addsd  %xmm2,%xmm1
add    %rbp,%rdi
cmp    %rsi,%r12
jne    1510 <svduv+0x3a0>
add    0xa8(%rsp),%rcx
mov    0x28(%rsp),%rdi
test   $0x3,%dil
je     1599 <svduv+0x429>
lea    (%rbx,%rsi,8),%rsi
xor    %edi,%edi
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm2
mulsd  (%rcx),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
add    %rbp,%rcx
cmp    %rdi,%r14
jne    1580 <svduv+0x410>
mov    0x28(%rsp),%rdi
test   %edi,%edi
jle    14c0 <svduv+0x350>
xorpd  %xmm7,%xmm1
mulsd  %xmm0,%xmm1
cmpq   $0x3,(%rsp)
jae    15c6 <svduv+0x456>
xor    %esi,%esi
test   $0x3,%dil
jne    1652 <svduv+0x4e2>
jmp    14c0 <svduv+0x350>
mov    %r9,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rdx
movsd  (%rbx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx),%xmm2
movsd  %xmm2,(%rcx)
add    %rbp,%rcx
movsd  0x8(%rbx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rbp,1),%xmm2
movsd  %xmm2,(%rdx,%rbp,1)
lea    (%rcx,%rbp,1),%rdi
movsd  0x10(%rbx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rcx,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,1)
lea    (%rdi,%rbp,1),%rcx
movsd  0x18(%rbx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rdi,1),%xmm2
add    $0x4,%rsi
movsd  %xmm2,0x0(%rbp,%rdi,1)
add    %rbp,%rcx
cmp    %rsi,%r12
jne    15d0 <svduv+0x460>
add    0xa8(%rsp),%rdx
mov    0x28(%rsp),%rdi
test   $0x3,%dil
je     14c0 <svduv+0x350>
lea    (%rbx,%rsi,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx),%xmm2
movsd  %xmm2,(%rdx)
add    $0x1,%rsi
add    %rbp,%rdx
cmp    %rsi,%r14
jne    1660 <svduv+0x4f0>
jmp    14c0 <svduv+0x350>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm4,%xmm0
divsd  0x8(%rsp),%xmm0
mov    $0x1,%ecx
mov    0x10(%rsp),%r14
mov    %r14,%rdx
cmpq   $0x3,0xb0(%rsp)
mov    0x40(%rsp),%r10
mov    0x78(%rsp),%r9
mov    0x88(%rsp),%r8
mov    0xa8(%rsp),%rdi
mov    0x110(%rsp),%r12
jb     173e <svduv+0x5ce>
mov    %r14,%rdx
xor    %ecx,%ecx
mov    0x80(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rbp,1)
movsd  0x10(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%r8,1)
movsd  0x18(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%r12,1)
movsd  0x20(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rdi,1)
add    %rdi,%rdx
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    16f0 <svduv+0x580>
add    $0x1,%rcx
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
addsd  %xmm4,%xmm1
testb  $0x3,(%rsp)
je     177b <svduv+0x60b>
lea    (%rbx,%rcx,8),%rax
lea    (%rdx,%r13,8),%rcx
xor    %edx,%edx
mov    0x48(%rsp),%rsi
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rcx)
add    $0x1,%rdx
add    %rbp,%rcx
cmp    %rdx,%rsi
jne    1760 <svduv+0x5f0>
jmp    1780 <svduv+0x610>
mov    0x48(%rsp),%rsi
mov    0x38(%rsp),%rdi
mov    0x10(%rsp),%rax
movsd  %xmm1,(%rax)
xorpd  %xmm7,%xmm5
mov    0x20(%rsp),%r12
movlpd %xmm5,(%r11,%r12,8)
mov    0x28(%rsp),%rax
cmp    $0x1,%eax
mov    0x10(%rsp),%rax
jne    17b6 <svduv+0x646>
movsd  (%rax),%xmm0
movsd  %xmm0,(%r11,%r12,8)
mov    0x50(%rsp),%rcx
lea    -0x1(%rcx),%edx
add    $0x8,%rax
mov    %rax,(%rsp)
cmp    $0x3,%ecx
jl     1f7d <svduv+0xe0d>
mov    %r10,%r9
mov    %r11,%r10
mov    0x6c(%rsp),%eax
mov    %eax,%ecx
sub    %r12d,%ecx
mov    0x58(%rsp),%rax
mov    %eax,%r14d
and    $0x3,%r14d
and    $0xfffffffc,%eax
mov    %eax,0xc0(%rsp)
mov    0x34(%rsp),%r11d
sub    %r12d,%r11d
xorpd  %xmm0,%xmm0
mov    (%rsp),%rax
mov    %rcx,0x8(%rsp)
cmp    $0x3,%ecx
mov    %r11d,0x80(%rsp)
jb     1874 <svduv+0x704>
xorpd  %xmm0,%xmm0
mov    0xc0(%rsp),%ecx
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax),%xmm2
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x18(%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
add    $0x20,%rax
add    $0xfffffffc,%ecx
jne    1830 <svduv+0x6c0>
mov    0x80(%rsp),%r11d
test   $0x3,%r11b
je     1896 <svduv+0x726>
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %ecx,%r14d
jne    1880 <svduv+0x710>
xorpd  %xmm10,%xmm10
ucomisd %xmm10,%xmm0
xorpd  %xmm1,%xmm1
mov    %r10,%r11
mov    %r9,%r10
mov    0x78(%rsp),%r9
jbe    1f6a <svduv+0xdfa>
mov    %rdi,0x38(%rsp)
ucomisd 0x1756(%rip),%xmm0
mov    %rsi,0x48(%rsp)
mov    %edx,0x60(%rsp)
movsd  %xmm0,0x70(%rsp)
jb     18d9 <svduv+0x769>
sqrtsd %xmm0,%xmm0
jmp    18e6 <svduv+0x776>
call   1090 <sqrt@plt>
movapd 0x171a(%rip),%xmm7
mov    0xb8(%rsp),%eax
sub    %r12d,%eax
mov    %rax,0x148(%rsp)
mov    (%rsp),%rax
movsd  (%rax),%xmm1
movapd %xmm0,%xmm2
xorpd  %xmm7,%xmm2
movapd %xmm1,%xmm3
cmpltsd 0x1703(%rip),%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm3
orpd   %xmm2,%xmm3
movapd %xmm3,0x150(%rsp)
divsd  %xmm3,%xmm1
movapd %xmm1,%xmm0
call   1070 <fabs@plt>
movapd 0x150(%rsp),%xmm10
mov    %eax,0xbc(%rsp)
mov    (%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm2,%xmm8
addsd  %xmm10,%xmm8
movsd  %xmm8,(%rax)
mov    0x118(%rsp),%rax
mov    %r12,0x20(%rsp)
sub    %r12,%rax
imul   %r13,%rax
mov    %rax,0xb0(%rsp)
cmp    %r13,%rax
movsd  0x1689(%rip),%xmm9
mov    0x50(%rsp),%r10
mov    0x8(%rsp),%rax
jle    1dd0 <svduv+0xc60>
mov    0x68(%rsp),%esi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
add    $0x1,%rax
add    $0xfffffffffffffffc,%rsi
mov    %rax,0x130(%rsp)
mov    %rax,%rdi
movabs $0x1fffffffc,%rax
and    %rax,%rdi
shr    $0x2,%rsi
lea    -0x4(%rdi),%rdx
mov    0x20(%rsp),%rax
mov    0xf8(%rsp),%r8
imul   %r8,%rax
add    $0x1,%rsi
mov    %rdx,0x128(%rsp)
mov    %rdx,%rcx
shr    $0x2,%rcx
mov    0xf0(%rsp),%rdx
add    %rax,%rdx
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x108(%rsp)
add    $0x1,%rcx
mov    %rcx,0x120(%rsp)
lea    (%r8,%rax,1),%rcx
mov    %rcx,0x98(%rsp)
add    0x8(%rsp),%rdx
mov    %rdx,0x140(%rsp)
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
add    $0x8,%rax
mov    0x8(%rsp),%rcx
mov    %rax,0x138(%rsp)
lea    0x8(%rax,%rcx,8),%rax
mov    %rax,0x90(%rsp)
mulsd  %xmm10,%xmm2
addsd  0x70(%rsp),%xmm2
movapd %xmm9,%xmm1
divsd  %xmm2,%xmm1
mov    (%rsp),%rax
mov    %rdi,0x70(%rsp)
lea    (%rax,%rdi,8),%rax
mov    %rax,0x100(%rsp)
mov    0x38(%rsp),%r9
xor    %r11d,%r11d
mov    %r13,%rax
jmp    1aa8 <svduv+0x938>
nopl   0x0(%rax,%rax,1)
add    %r13,%rax
add    $0x1,%r11
add    %rbp,%r9
cmp    0xb0(%rsp),%rax
jge    1dd0 <svduv+0xc60>
cmp    $0x2,%r10d
jl     1a90 <svduv+0x920>
mov    (%rsp),%rdi
lea    (%rdi,%rax,8),%r8
xorpd  %xmm2,%xmm2
mov    %r8,%rsi
cmp    $0x3,%ecx
mov    0x80(%rsp),%edx
jb     1b36 <svduv+0x9c6>
xorpd  %xmm2,%xmm2
mov    0xc0(%rsp),%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rdi,1),%xmm0
movsd  0x8(%r15,%rdi,1),%xmm3
mulsd  (%r9,%rdi,1),%xmm0
mulsd  0x8(%r9,%rdi,1),%xmm3
addsd  %xmm2,%xmm0
movsd  0x10(%r15,%rdi,1),%xmm4
mulsd  0x10(%r9,%rdi,1),%xmm4
addsd  %xmm0,%xmm3
movsd  0x18(%r15,%rdi,1),%xmm2
mulsd  0x18(%r9,%rdi,1),%xmm2
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
add    $0x20,%rdi
add    $0xfffffffc,%esi
jne    1ae0 <svduv+0x970>
lea    (%r9,%rdi,1),%rsi
add    %r15,%rdi
test   $0x3,%dl
je     1b57 <svduv+0x9e7>
xor    %edx,%edx
nopl   (%rax)
movsd  (%rdi,%rdx,8),%xmm3
mulsd  (%rsi,%rdx,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rdx
cmp    %edx,%r14d
jne    1b40 <svduv+0x9d0>
cmp    $0x2,%r10d
jl     1a90 <svduv+0x920>
xor    %edi,%edi
xorpd  0x1495(%rip),%xmm2
mulsd  %xmm1,%xmm2
cmp    $0x3,%ecx
jb     1bbb <svduv+0xa4b>
mov    %r11,%rdx
imul   %r13,%rdx
mov    0x98(%rsp),%rcx
lea    (%rcx,%rdx,1),%rsi
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rsi,8),%rsi
cmp    0x90(%rsp),%rsi
jae    1cae <svduv+0xb3e>
add    0x140(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
cmp    %rdx,0x138(%rsp)
jae    1cae <svduv+0xb3e>
mov    (%rsp),%r12
mov    0x20(%rsp),%rcx
lea    (%rdi,%rcx,1),%edx
mov    0x34(%rsp),%ecx
sub    %edx,%ecx
mov    0x6c(%rsp),%esi
sub    %edx,%esi
test   $0x3,%cl
je     1c1b <svduv+0xaab>
mov    %r14d,%ecx
sub    %dil,%cl
movzbl %cl,%r10d
and    $0x3,%r10d
neg    %r10d
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%r12),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r8),%xmm0
movsd  %xmm0,(%r8)
add    $0x8,%r8
add    $0x8,%r12
add    $0xffffffff,%edx
cmp    %edx,%r10d
jne    1bf0 <svduv+0xa80>
sub    %edx,%edi
mov    0x50(%rsp),%r10
mov    0x8(%rsp),%rcx
cmp    $0x3,%esi
jb     1a90 <svduv+0x920>
mov    0x58(%rsp),%rsi
sub    %edi,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,(%r8,%rdi,8)
movsd  0x8(%r12,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x8(%r8,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r8,%rdi,8)
movsd  0x10(%r12,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x10(%r8,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r8,%rdi,8)
movsd  0x18(%r12,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x18(%r8,%rdi,8),%xmm0
movsd  %xmm0,0x18(%r8,%rdi,8)
add    $0x4,%rdi
cmp    %edi,%esi
jne    1c40 <svduv+0xad0>
jmp    1a90 <svduv+0x920>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,0x128(%rsp)
je     1dbc <svduv+0xc4c>
mov    0x108(%rsp),%rsi
xor    %edi,%edi
nop
movupd (%r15,%rdi,8),%xmm4
movupd 0x10(%r15,%rdi,8),%xmm5
mulpd  %xmm3,%xmm4
movupd (%r9,%rdi,8),%xmm6
addpd  %xmm4,%xmm6
movupd 0x10(%r9,%rdi,8),%xmm4
movupd 0x20(%r9,%rdi,8),%xmm7
movupd 0x30(%r9,%rdi,8),%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,(%r9,%rdi,8)
movupd %xmm5,0x10(%r9,%rdi,8)
movupd 0x20(%r15,%rdi,8),%xmm4
movupd 0x30(%r15,%rdi,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm0,%xmm5
movupd %xmm4,0x20(%r9,%rdi,8)
movupd %xmm5,0x30(%r9,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1cd0 <svduv+0xb60>
testb  $0x1,0x120(%rsp)
01
je     1d8e <svduv+0xc1e>
mov    (%rsp),%rcx
movupd (%rcx,%rdi,8),%xmm0
movupd 0x10(%rcx,%rdi,8),%xmm4
movupd (%r8,%rdi,8),%xmm5
movupd 0x10(%r8,%rdi,8),%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm0,(%r8,%rdi,8)
movupd %xmm4,0x10(%r8,%rdi,8)
mov    0x70(%rsp),%rcx
cmp    %rcx,0x130(%rsp)
mov    0x8(%rsp),%rcx
je     1a90 <svduv+0x920>
mov    0x70(%rsp),%rdi
lea    (%r8,%rdi,8),%r8
mov    0x100(%rsp),%r12
jmp    1bbf <svduv+0xa4f>
xor    %edi,%edi
testb  $0x1,0x120(%rsp)
01
jne    1d55 <svduv+0xbe5>
jmp    1d8e <svduv+0xc1e>
nopw   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl 0xbc(%rsp),%xmm1
addsd  %xmm9,%xmm1
movapd %xmm9,%xmm2
divsd  %xmm8,%xmm2
mov    0x10(%rsp),%rcx
lea    0x10(%rcx),%rax
mov    $0x1,%edx
mov    0x148(%rsp),%r10
cmp    $0x3,%r10d
jae    1e35 <svduv+0xcc5>
mov    0x18(%rsp),%r11
movapd 0x11ec(%rip),%xmm7
mov    0x40(%rsp),%r10
mov    0x78(%rsp),%r9
mov    0x88(%rsp),%r8
mov    0x48(%rsp),%rsi
mov    0x20(%rsp),%r12
jmp    1f3d <svduv+0xdcd>
add    $0x1,%r10
mov    %r10,%r14
movabs $0x1fffffffc,%rdx
and    %rdx,%r14
lea    -0x4(%r14),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
test   %rsi,%rsi
mov    0x18(%rsp),%r11
movapd 0x1190(%rip),%xmm7
mov    0x78(%rsp),%r9
mov    0x88(%rsp),%r8
mov    0x20(%rsp),%r12
je     1f99 <svduv+0xe29>
mov    0x64(%rsp),%esi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd 0x10(%rcx,%rdi,8),%xmm3
movupd 0x20(%rcx,%rdi,8),%xmm4
movupd 0x30(%rcx,%rdi,8),%xmm5
movupd 0x40(%rcx,%rdi,8),%xmm6
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x10(%rcx,%rdi,8)
movupd %xmm4,0x20(%rcx,%rdi,8)
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm6
movupd %xmm5,0x30(%rcx,%rdi,8)
movupd %xmm6,0x40(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1eb0 <svduv+0xd40>
test   $0x1,%dl
je     1f1d <svduv+0xdad>
movupd (%rax,%rdi,8),%xmm3
movupd 0x10(%rax,%rdi,8),%xmm4
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,(%rax,%rdi,8)
movupd %xmm4,0x10(%rax,%rdi,8)
cmp    %r14,%r10
mov    0x40(%rsp),%r10
mov    0x48(%rsp),%rsi
jne    1f33 <svduv+0xdc3>
mov    0x38(%rsp),%rdi
jmp    1f66 <svduv+0xdf6>
mov    %r14d,%edx
or     $0x1,%edx
lea    (%rax,%r14,8),%rax
mov    0x58(%rsp),%rcx
sub    %edx,%ecx
xor    %edx,%edx
mov    0x38(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    1f50 <svduv+0xde0>
mov    0x60(%rsp),%edx
mov    (%rsp),%rax
movsd  %xmm1,(%rax)
xorpd  %xmm7,%xmm10
movlpd %xmm10,(%r10,%r12,8)
cmp    $0x1,%edx
jne    12c0 <svduv+0x150>
mov    (%rsp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,(%r10,%r12,8)
jmp    12c0 <svduv+0x150>
xor    %edi,%edi
test   $0x1,%dl
jne    1eff <svduv+0xd8f>
jmp    1f1d <svduv+0xdad>
mov    0xa0(%rsp),%rbp
mov    %rbp,%rdi
mov    0xe0(%rsp),%r15
mov    %r15,%rsi
mov    0xe8(%rsp),%r14
mov    %r14d,%edx
call   1080 <ldvmat@plt>
mov    %rbp,%rdi
mov    0xd0(%rsp),%r12
mov    %r12,%rsi
mov    0xd8(%rsp),%rbp
mov    %ebp,%edx
mov    %r14d,%ecx
call   1040 <ldumat@plt>
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    %r12,%rdx
mov    %ebp,%ecx
mov    %r15,%r8
mov    %r14d,%r9d
call   1050 <qrbdv@plt>
movapd 0xfef(%rip),%xmm3
mov    0x18(%rsp),%r11
test   %r14d,%r14d
jle    2151 <svduv+0xfe1>
mov    %r14d,%r9d
and    $0x3,%r9d
and    $0xfffffffc,%r14d
mov    %r13,%r8
shl    $0x5,%r8
lea    0x0(,%r13,8),%rdx
xor    %esi,%esi
xorpd  %xmm0,%xmm0
movapd 0xfb9(%rip),%xmm1
mov    %r15,%r10
jmp    2061 <svduv+0xef1>
nopl   0x0(%rax)
add    $0x1,%rsi
add    $0x8,%r10
cmp    %r13,%rsi
je     2151 <svduv+0xfe1>
movsd  (%r11,%rsi,8),%xmm2
ucomisd %xmm2,%xmm0
jbe    2050 <svduv+0xee0>
xorpd  %xmm3,%xmm2
movlpd %xmm2,(%r11,%rsi,8)
cmpl   $0x3,0x34(%rsp)
jae    2090 <svduv+0xf20>
lea    (%r15,%rsi,8),%rax
test   %r9d,%r9d
jne    20fb <svduv+0xf8b>
jmp    2050 <svduv+0xee0>
nopl   0x0(%rax)
mov    %r14d,%ecx
mov    %r10,%rbp
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%rax
movsd  0x0(%rbp),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,0x0(%rbp)
add    %rdx,%rbp
movsd  (%rax,%rdx,1),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%rax,%rdx,1)
lea    0x0(%rbp,%rdx,1),%rdi
movsd  (%rdx,%rbp,1),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%rdx,%rbp,1)
lea    (%rdi,%rdx,1),%rbp
movsd  (%rdx,%rdi,1),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%rdx,%rdi,1)
add    %rdx,%rbp
add    $0xfffffffc,%ecx
jne    20a0 <svduv+0xf30>
add    %r8,%rax
test   %r9d,%r9d
je     2050 <svduv+0xee0>
mov    %r9d,%ecx
xchg   %ax,%ax
movsd  (%rax),%xmm2
xorpd  %xmm3,%xmm2
movlpd %xmm2,(%rax)
add    %rdx,%rax
add    $0xffffffff,%ecx
jne    2100 <svduv+0xf90>
jmp    2050 <svduv+0xee0>
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
call   1080 <ldvmat@plt>
mov    %r13,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
mov    %r14d,%ecx
call   1040 <ldumat@plt>
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    %r12,%rdx
mov    %ebp,%ecx
mov    %r15,%r8
mov    %r14d,%r9d
call   1050 <qrbdv@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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