#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 */
double fabs(double);
double sqrt(double);
int qrbdv(double *dm, double *em, double *um, int mm, double *vm, int m) {
  int i, j, k, n, jj, nm;
  double u, x, y, a, b, c, s, t, w, *p, *q;
  for (j = 1, t = fabs(dm[0]); j < m; ++j)
    if ((s = fabs(dm[j]) + fabs(em[j - 1])) > t)
      t = s;
  t *= 1.e-15;
  n = 100 * m;
  nm = m;
  for (j = 0; m > 1 && j < n; ++j) {
    for (k = m - 1; k > 0; --k) {
      if (fabs(em[k - 1]) < t)
        break;
      if (fabs(dm[k - 1]) < t) {
        for (i = k, s = 1., c = 0.; i < m; ++i) {
          a = s * em[i - 1];
          b = dm[i];
          em[i - 1] *= c;
          dm[i] = u = sqrt(a * a + b * b);
          s = -a / u;
          c = b / u;
          for (jj = 0, p = um + k - 1; jj < mm; ++jj, p += mm) {
            q = p + i - k + 1;
            w = c * *p + s * *q;
            *q = c * *q - s * *p;
            *p = w;
          }
        }
        break;
      }
    }
    y = dm[k];
    x = dm[m - 1];
    u = em[m - 2];
    a = (y + x) * (y - x) - u * u;
    s = y * em[k];
    b = s + s;
    u = sqrt(a * a + b * b);
    if (u != 0.) {
      c = sqrt((u + a) / (u + u));
      if (c != 0.)
        s /= (c * u);
      else
        s = 1.;
      for (i = k; i < m - 1; ++i) {
        b = em[i];
        if (i > k) {
          a = s * em[i];
          b *= c;
          em[i - 1] = u = sqrt(x * x + a * a);
          c = x / u;
          s = a / u;
        }
        a = c * y + s * b;
        b = c * b - s * y;
        for (jj = 0, p = vm + i; jj < nm; ++jj, p += nm) {
          w = c * *p + s * *(p + 1);
          *(p + 1) = c * *(p + 1) - s * *p;
          *p = w;
        }
        s *= dm[i + 1];
        dm[i] = u = sqrt(a * a + s * s);
        y = c * dm[i + 1];
        c = a / u;
        s /= u;
        x = c * b + s * y;
        y = c * y - s * b;
        for (jj = 0, p = um + i; jj < mm; ++jj, p += mm) {
          w = c * *p + s * *(p + 1);
          *(p + 1) = c * *(p + 1) - s * *p;
          *p = w;
        }
      }
    }
    em[m - 2] = x;
    dm[m - 1] = y;
    if (fabs(x) < t)
      --m;
    if (m == k + 1)
      --m;
  }
  return j;
}


x86 assembly (clang, -O0):
<qrbdv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0xeb8(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11cc <qrbdv+0xbc>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe8c(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe6f(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
ucomisd -0x88(%rbp),%xmm0
ff
jbe    11b9 <qrbdv+0xa9>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    11be <qrbdv+0xae>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1154 <qrbdv+0x44>
movsd  0xe3c(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
imul   $0x64,-0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x2c(%rbp)
mov    %al,-0xa1(%rbp)
jle    1219 <qrbdv+0x109>
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
setl   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    122c <qrbdv+0x11c>
jmp    1a5c <qrbdv+0x94c>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jle    14b6 <qrbdv+0x3a6>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xda8(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1273 <qrbdv+0x163>
jmp    14b6 <qrbdv+0x3a6>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xd74(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    14a3 <qrbdv+0x393>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
movsd  0xd68(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    149e <qrbdv+0x38e>
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x98(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    148b <qrbdv+0x37b>
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0xa0(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0xa0(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    139c <qrbdv+0x28c>
jmp    1490 <qrbdv+0x380>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12bd <qrbdv+0x1ad>
jmp    14b6 <qrbdv+0x3a6>
jmp    14a8 <qrbdv+0x398>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1235 <qrbdv+0x125>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
subsd  -0x58(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15a1 <qrbdv+0x491>
jp     15a1 <qrbdv+0x491>
jmp    19d6 <qrbdv+0x8c6>
movsd  -0x50(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15e0 <qrbdv+0x4d0>
jp     15e0 <qrbdv+0x4d0>
jmp    15fd <qrbdv+0x4ed>
movsd  -0x78(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    160a <qrbdv+0x4fa>
movsd  0xa13(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    19d1 <qrbdv+0x8c1>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    16bb <qrbdv+0x5ab>
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    17f6 <qrbdv+0x6e6>
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    1731 <qrbdv+0x621>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19be <qrbdv+0x8ae>
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    18f9 <qrbdv+0x7e9>
jmp    19c3 <qrbdv+0x8b3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1610 <qrbdv+0x500>
jmp    19d6 <qrbdv+0x8c6>
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm1
movaps 0x5f0(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1a2f <qrbdv+0x91f>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1a49 <qrbdv+0x939>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a4e <qrbdv+0x93e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f8 <qrbdv+0xe8>
mov    -0x34(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrbdv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
xor    %eax,%eax
cmp    $0x2,%r9d
jl     1bec <qrbdv+0xadc>
mov    %r8,0xb8(%rsp)
movsd  (%rdi),%xmm1
andpd  0xebf(%rip),%xmm1
mov    %r9d,%r14d
lea    -0x1(%r14),%r8
cmp    $0x2,%r9d
mov    %r9d,(%rsp)
mov    %rdx,0x68(%rsp)
jne    1162 <qrbdv+0x52>
mov    $0x1,%ebx
movapd %xmm1,%xmm5
jmp    11cc <qrbdv+0xbc>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ebx
movapd 0xe87(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm2
movsd  0x8(%rdi,%rbx,8),%xmm3
andpd  %xmm0,%xmm2
movsd  -0x8(%rsi,%rbx,8),%xmm4
movsd  (%rsi,%rbx,8),%xmm5
andpd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
maxsd  %xmm1,%xmm4
andpd  %xmm0,%xmm3
andpd  %xmm0,%xmm5
addsd  %xmm3,%xmm5
maxsd  %xmm4,%xmm5
lea    (%rdx,%rbx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rbx
movapd %xmm5,%xmm1
cmp    $0x1,%rbp
jne    1180 <qrbdv+0x70>
test   $0x1,%r8b
je     11f9 <qrbdv+0xe9>
movsd  (%rdi,%rbx,8),%xmm0
movapd 0xe21(%rip),%xmm1
andpd  %xmm1,%xmm0
movsd  -0x8(%rsi,%rbx,8),%xmm2
andpd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
maxsd  %xmm5,%xmm2
movapd %xmm2,%xmm5
mov    (%rsp),%ebp
cmp    $0x2,%ebp
jl     1bec <qrbdv+0xadc>
movapd %xmm5,%xmm1
mulsd  0xe0f(%rip),%xmm1
imul   $0x64,%ebp,%edx
mov    %edx,0xa4(%rsp)
movslq %ecx,%r15
mov    0x68(%rsp),%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0xb0(%rsp)
lea    -0x1(%r15),%edx
mov    %edx,0x3c(%rsp)
mov    %r15d,%edx
and    $0xfffffffe,%edx
mov    %edx,0x38(%rsp)
mov    %ebp,%edx
and    $0xfffffffe,%edx
mov    %edx,0xac(%rsp)
mov    %r15,%r8
shl    $0x4,%r8
shl    $0x3,%r15
mov    %r14,%r9
shl    $0x4,%r9
xor    %eax,%eax
movapd 0xd96(%rip),%xmm12
xorpd  %xmm8,%xmm8
movapd 0xd98(%rip),%xmm9
mov    %ebp,%edx
mov    %ecx,0x4(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
movapd %xmm1,0xe0(%rsp)
mov    %r8,0x20(%rsp)
mov    %r9,0x18(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %eax,0xa8(%rsp)
mov    %rdx,0x10(%rsp)
lea    -0x1(%rdx),%ebx
movslq %ebx,%rdx
lea    0x0(,%rdx,8),%r10
mov    0xb0(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rbp
lea    (%r15,%rdx,8),%rdx
mov    %rbx,%rax
mov    %rbx,0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%rax
test   %eax,%eax
jle    1560 <qrbdv+0x450>
movsd  -0x8(%rsi,%rax,8),%xmm0
andpd  %xmm12,%xmm0
ucomisd %xmm0,%xmm1
ja     1570 <qrbdv+0x460>
mov    %r10,%r13
mov    %rbp,%r11
mov    %rdx,%r12
lea    -0x1(%rax),%rbx
movsd  (%rdi,%rbx,8),%xmm0
andpd  %xmm12,%xmm0
add    $0xfffffffffffffff8,%r10
add    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffff8,%rdx
ucomisd %xmm0,%xmm1
jbe    12e0 <qrbdv+0x1d0>
mov    0x10(%rsp),%rbp
cmp    %eax,%ebp
jle    1575 <qrbdv+0x465>
mov    %rax,0x8(%rsp)
mov    %rbp,%rdx
movslq %eax,%rbp
mov    0xb0(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x40(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x90(%rsp)
movslq %edx,%r10
movsd  0xcbd(%rip),%xmm1
mov    %r10,0x98(%rsp)
jmp    1395 <qrbdv+0x285>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
add    $0x8,%r13
add    $0x8,%r12
cmp    %r10,%rbp
je     1564 <qrbdv+0x454>
mov    $0xffffffff,%eax
add    %ebp,%eax
movsd  (%rsi,%rax,8),%xmm0
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rdi,%rbp,8),%xmm3
unpckhpd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     13e0 <qrbdv+0x2d0>
sqrtsd %xmm0,%xmm0
jmp    1440 <qrbdv+0x330>
nopl   0x0(%rax)
mov    %r11,%rbx
movapd %xmm2,0x50(%rsp)
movapd %xmm3,0x80(%rsp)
call   1030 <sqrt@plt>
movapd 0x80(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mov    0x98(%rsp),%r10
mov    %rbx,%r11
movapd 0xbf6(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0xbd8(%rip),%xmm12
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x4(%rsp),%ecx
movsd  %xmm0,(%rdi,%rbp,8)
xorpd  %xmm9,%xmm2
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
movapd %xmm2,%xmm1
divpd  %xmm0,%xmm1
test   %ecx,%ecx
jle    1380 <qrbdv+0x270>
movapd %xmm1,%xmm0
xorpd  %xmm9,%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
mov    0x40(%rsp),%rax
cmpl   $0x0,0x3c(%rsp)
je     1507 <qrbdv+0x3f7>
mov    0x38(%rsp),%ebx
mov    %r11,%rax
mov    0x68(%rsp),%rdx
nop
movsd  (%rax),%xmm3
movsd  (%rdx,%r13,1),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm2,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%r13,1)
movsd  %xmm6,(%rax)
movsd  (%rax,%r15,1),%xmm3
movsd  (%rdx,%r12,1),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm2,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%r12,1)
movsd  %xmm6,(%rax,%r15,1)
add    %r8,%rdx
add    %r8,%rax
add    $0xfffffffe,%ebx
jne    1490 <qrbdv+0x380>
test   $0x1,%cl
je     1380 <qrbdv+0x270>
mov    0x90(%rsp),%rdx
lea    (%rax,%rdx,8),%rdx
movsd  (%rax),%xmm3
movsd  0x8(%rdx,%rbp,8),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm2,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm3,%xmm0
mulsd  %xmm4,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rdx,%rbp,8)
movsd  %xmm6,(%rax)
jmp    1380 <qrbdv+0x270>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
jmp    1570 <qrbdv+0x460>
mov    0x8(%rsp),%rax
nopl   0x0(%rax)
mov    0x10(%rsp),%rbp
mov    %rax,0x8(%rsp)
mov    %eax,%eax
movsd  (%rdi,%rax,8),%xmm10
mov    0x60(%rsp),%rdx
movsd  (%rdi,%rdx,8),%xmm4
add    $0xfffffffe,%ebp
movsd  (%rsi,%rbp,8),%xmm0
movapd %xmm10,%xmm1
addsd  %xmm4,%xmm1
movapd %xmm10,%xmm3
subsd  %xmm4,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm0
subsd  %xmm0,%xmm3
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm10,%xmm2
movapd %xmm2,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
movsd  %xmm2,0x80(%rsp)
jb     15f0 <qrbdv+0x4e0>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    164e <qrbdv+0x53e>
nopl   (%rax)
movsd  %xmm10,0x50(%rsp)
movapd %xmm4,0x70(%rsp)
movsd  %xmm3,0x40(%rsp)
call   1030 <sqrt@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x70(%rsp),%xmm4
movsd  0x50(%rsp),%xmm10
movapd 0x9ec(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x9ce(%rip),%xmm12
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x4(%rsp),%ecx
movapd %xmm0,%xmm1
mov    (%rsp),%r10d
mov    0x60(%rsp),%rbx
ucomisd %xmm8,%xmm1
mov    %rbp,0xd0(%rsp)
jne    166c <qrbdv+0x55c>
jnp    1b80 <qrbdv+0xa70>
addsd  %xmm1,%xmm3
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm3
ucomisd %xmm8,%xmm3
jb     1690 <qrbdv+0x580>
sqrtsd %xmm3,%xmm3
jmp    16f6 <qrbdv+0x5e6>
nopl   0x0(%rax)
movapd %xmm3,%xmm0
movsd  %xmm10,0x50(%rsp)
movapd %xmm4,0x70(%rsp)
movsd  %xmm1,0x40(%rsp)
call   1030 <sqrt@plt>
movsd  0x40(%rsp),%xmm1
movapd 0x70(%rsp),%xmm4
movsd  0x50(%rsp),%xmm10
movapd 0x948(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x92a(%rip),%xmm12
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x4(%rsp),%ecx
mov    (%rsp),%r10d
movapd %xmm0,%xmm3
mov    0x8(%rsp),%rax
ucomisd %xmm8,%xmm3
movsd  0x920(%rip),%xmm0
jne    170c <qrbdv+0x5fc>
jnp    171d <qrbdv+0x60d>
mulsd  %xmm3,%xmm1
movsd  0x80(%rsp),%xmm0
divsd  %xmm1,%xmm0
cmp    %ebx,%eax
jge    1b80 <qrbdv+0xa70>
movslq %eax,%rbp
movslq %ebx,%rax
mov    %rax,0x98(%rsp)
unpcklpd %xmm0,%xmm3
mov    0xb8(%rsp),%rax
lea    (%rax,%rbp,8),%r11
mov    0x68(%rsp),%rax
lea    (%rax,%rbp,8),%r12
mov    %rbp,0x90(%rsp)
mov    %rbp,%rdx
jmp    17ad <qrbdv+0x69d>
nopl   0x0(%rax)
mulsd  %xmm14,%xmm10
mulsd  %xmm11,%xmm13
subsd  %xmm10,%xmm13
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm3,%xmm4
mulsd  %xmm13,%xmm4
addsd  %xmm2,%xmm4
mulsd  %xmm0,%xmm13
mulsd  %xmm3,%xmm1
subsd  %xmm13,%xmm1
add    $0x8,%r11
add    $0x8,%r12
movapd %xmm1,%xmm10
cmp    0x98(%rsp),%rdx
je     1b85 <qrbdv+0xa75>
mov    %rdx,%rbx
movsd  (%rsi,%rdx,8),%xmm11
cmp    0x90(%rsp),%rdx
jle    1800 <qrbdv+0x6f0>
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
mulsd  %xmm11,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     1810 <qrbdv+0x700>
sqrtsd %xmm0,%xmm0
jmp    189a <qrbdv+0x78a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm13
jmp    18bc <qrbdv+0x7ac>
nopw   0x0(%rax,%rax,1)
movsd  %xmm10,0x50(%rsp)
mov    %r11,%rbp
movapd %xmm11,0x80(%rsp)
movapd %xmm3,0x40(%rsp)
movapd %xmm4,0x70(%rsp)
movapd %xmm2,0xc0(%rsp)
call   1030 <sqrt@plt>
movapd 0xc0(%rsp),%xmm2
movapd 0x70(%rsp),%xmm4
movapd 0x40(%rsp),%xmm3
movapd 0x80(%rsp),%xmm11
mov    %rbp,%r11
movsd  0x50(%rsp),%xmm10
movapd 0x7a0(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x782(%rip),%xmm12
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x4(%rsp),%ecx
mov    (%rsp),%r10d
mulsd  %xmm3,%xmm11
mov    $0xffffffff,%eax
add    %ebx,%eax
movsd  %xmm0,(%rsi,%rax,8)
unpcklpd %xmm2,%xmm4
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm4
movapd %xmm4,%xmm13
movapd %xmm13,%xmm14
unpckhpd %xmm13,%xmm14
movapd %xmm14,%xmm1
xorpd  %xmm9,%xmm1
movapd %xmm13,%xmm0
unpcklpd %xmm13,%xmm0
cmp    $0x1,%r10d
jne    18f0 <qrbdv+0x7e0>
mov    0xb8(%rsp),%rax
lea    (%rax,%rbx,8),%rax
jmp    1956 <qrbdv+0x846>
xchg   %ax,%ax
movapd %xmm13,%xmm2
movsd  %xmm1,%xmm2
mov    0xac(%rsp),%ebp
mov    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rax),%xmm3
movapd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rax)
movupd (%rax,%r14,8),%xmm3
movapd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rax,%r14,8)
add    %r9,%rax
add    $0xfffffffe,%ebp
jne    1910 <qrbdv+0x800>
test   $0x1,%r10b
je     197f <qrbdv+0x86f>
movupd (%rax),%xmm2
movapd %xmm13,%xmm3
shufpd $0x1,%xmm1,%xmm3
mulpd  %xmm2,%xmm0
shufpd $0x1,%xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%rax)
movapd %xmm11,%xmm0
mulsd  %xmm14,%xmm0
movapd %xmm13,%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm0,%xmm3
lea    0x1(%rbx),%rdx
mov    %edx,%r13d
movsd  (%rdi,%r13,8),%xmm2
mulsd  %xmm14,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     19d0 <qrbdv+0x8c0>
sqrtsd %xmm0,%xmm0
jmp    1a8c <qrbdv+0x97c>
nopl   (%rax)
movsd  %xmm10,0x50(%rsp)
mov    %r12,%rbp
mov    %r11,%r12
movapd %xmm11,0x80(%rsp)
movapd %xmm3,0x40(%rsp)
movapd %xmm13,0x70(%rsp)
movapd %xmm14,0xc0(%rsp)
mov    %rbx,0xd8(%rsp)
mov    %rdx,%rbx
movapd %xmm2,0xf0(%rsp)
call   1030 <sqrt@plt>
movapd 0xf0(%rsp),%xmm2
mov    %rbx,%rdx
mov    0xd8(%rsp),%rbx
movapd 0xc0(%rsp),%xmm14
movapd 0x70(%rsp),%xmm13
movapd 0x40(%rsp),%xmm3
movapd 0x80(%rsp),%xmm11
mov    %r12,%r11
mov    %rbp,%r12
movsd  0x50(%rsp),%xmm10
movapd 0x5ae(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x590(%rip),%xmm12
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x4(%rsp),%ecx
mov    (%rsp),%r10d
movsd  %xmm0,(%rdi,%rbx,8)
movsd  (%rdi,%r13,8),%xmm1
mulsd  %xmm13,%xmm1
unpcklpd %xmm2,%xmm3
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
test   %ecx,%ecx
jle    1760 <qrbdv+0x650>
movapd %xmm0,%xmm7
xorpd  %xmm9,%xmm7
movapd %xmm3,%xmm2
unpcklpd %xmm3,%xmm2
cmpl   $0x0,0x3c(%rsp)
je     1b40 <qrbdv+0xa30>
movapd %xmm3,%xmm4
movsd  %xmm7,%xmm4
mov    0x38(%rsp),%ebx
mov    %r12,%rax
nop
movupd (%rax),%xmm5
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%rax)
movupd (%rax,%r15,1),%xmm5
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%rax,%r15,1)
add    %r8,%rax
add    $0xfffffffe,%ebx
jne    1ae0 <qrbdv+0x9d0>
test   $0x1,%cl
je     1760 <qrbdv+0x650>
jmp    1b52 <qrbdv+0xa42>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rax
lea    (%rax,%rbx,8),%rax
test   $0x1,%cl
je     1760 <qrbdv+0x650>
movupd (%rax),%xmm4
movapd %xmm3,%xmm5
shufpd $0x1,%xmm7,%xmm5
mulpd  %xmm4,%xmm2
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,(%rax)
jmp    1760 <qrbdv+0x650>
nopl   0x0(%rax)
movapd %xmm10,%xmm1
mov    0xd0(%rsp),%rax
movsd  %xmm4,(%rsi,%rax,8)
andpd  %xmm12,%xmm4
movapd 0xe0(%rsp),%xmm0
ucomisd %xmm4,%xmm0
mov    0x10(%rsp),%rdx
mov    0x60(%rsp),%rax
cmova  %eax,%edx
movsd  %xmm1,(%rdi,%rax,8)
mov    0x8(%rsp),%rbp
add    $0x1,%ebp
xor    %eax,%eax
cmp    %ebp,%edx
sete   %al
sub    %eax,%edx
mov    0xa8(%rsp),%eax
add    $0x1,%eax
cmp    $0x2,%edx
jl     1bec <qrbdv+0xadc>
cmp    0xa4(%rsp),%eax
movapd 0xe0(%rsp),%xmm1
jl     12a0 <qrbdv+0x190>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @qrbdv(double* nocapture %0, double* nocapture %1, double* nocapture %2, i32 %3, double* nocapture %4, i32 %5) {
%7 = icmp sgt i32 %5, 1
br i1 %7, label %8, label %370
8: ; preds = %6
%9 = load double, double* %0
%10 = tail call double @llvm.fabs.f64(double %9)
%11 = zext i32 %5 to i64
%12 = add nsw i64 %11, -1
%13 = and i64 %12, 1
%14 = icmp eq i32 %5, 2
br i1 %14, label %44, label %15
15: ; preds = %8
%16 = and i64 %12, -2
br label %17
17: ; preds = %17, %15
%18 = phi i64 [ 1, %15 ], [ %41, %17 ]
%19 = phi double [ %10, %15 ], [ %40, %17 ]
%20 = phi i64 [ 0, %15 ], [ %42, %17 ]
%21 = getelementptr inbounds double, double* %0, i64 %18
%22 = load double, double* %21
%23 = tail call double @llvm.fabs.f64(double %22)
%24 = add nsw i64 %18, -1
%25 = getelementptr inbounds double, double* %1, i64 %24
%26 = load double, double* %25
%27 = tail call double @llvm.fabs.f64(double %26)
%28 = fadd double %23, %27
%29 = fcmp ogt double %28, %19
%30 = select i1 %29, double %28, double %19
%31 = add nuw nsw i64 %18, 1
%32 = getelementptr inbounds double, double* %0, i64 %31
%33 = load double, double* %32
%34 = tail call double @llvm.fabs.f64(double %33)
%35 = getelementptr inbounds double, double* %1, i64 %18
%36 = load double, double* %35
%37 = tail call double @llvm.fabs.f64(double %36)
%38 = fadd double %34, %37
%39 = fcmp ogt double %38, %30
%40 = select i1 %39, double %38, double %30
%41 = add nuw nsw i64 %18, 2
%42 = add i64 %20, 2
%43 = icmp eq i64 %42, %16
br i1 %43, label %44, label %17
44: ; preds = %17, %8
%45 = phi double [ undef, %8 ], [ %40, %17 ]
%46 = phi i64 [ 1, %8 ], [ %41, %17 ]
%47 = phi double [ %10, %8 ], [ %40, %17 ]
%48 = icmp eq i64 %13, 0
br i1 %48, label %60, label %49
49: ; preds = %44
%50 = getelementptr inbounds double, double* %0, i64 %46
%51 = load double, double* %50
%52 = tail call double @llvm.fabs.f64(double %51)
%53 = add nsw i64 %46, -1
%54 = getelementptr inbounds double, double* %1, i64 %53
%55 = load double, double* %54
%56 = tail call double @llvm.fabs.f64(double %55)
%57 = fadd double %52, %56
%58 = fcmp ogt double %57, %47
%59 = select i1 %58, double %57, double %47
br label %60
60: ; preds = %44, %49
%61 = phi double [ %45, %44 ], [ %59, %49 ]
%62 = fmul double %61, 1.000000e-15
%63 = mul nsw i32 %5, 100
br i1 %7, label %64, label %370
64: ; preds = %60
%65 = icmp sgt i32 %3, 0
%66 = sext i32 %3 to i64
%67 = zext i32 %5 to i64
%68 = getelementptr inbounds double, double* %2, i64 -1
%69 = add i32 %3, -1
%70 = and i32 %3, 1
%71 = icmp eq i32 %69, 0
%72 = and i32 %3, -2
%73 = icmp eq i32 %70, 0
%74 = and i32 %5, 1
%75 = icmp eq i32 %5, 1
%76 = and i32 %5, -2
%77 = icmp eq i32 %74, 0
%78 = and i32 %3, 1
%79 = icmp eq i32 %69, 0
%80 = and i32 %3, -2
%81 = icmp eq i32 %78, 0
br label %82
82: ; preds = %64, %356
%83 = phi i32 [ %5, %64 ], [ %365, %356 ]
%84 = phi i32 [ 0, %64 ], [ %366, %356 ]
%85 = add nsw i32 %83, -1
%86 = zext i32 %85 to i64
br label %87
87: ; preds = %97, %82
%88 = phi i64 [ %92, %97 ], [ %86, %82 ]
%89 = trunc i64 %88 to i32
%90 = icmp sgt i32 %89, 0
br i1 %90, label %91, label %182
91: ; preds = %87
%92 = add nsw i64 %88, -1
%93 = getelementptr inbounds double, double* %1, i64 %92
%94 = load double, double* %93
%95 = tail call double @llvm.fabs.f64(double %94)
%96 = fcmp olt double %95, %62
br i1 %96, label %180, label %97
97: ; preds = %91
%98 = getelementptr inbounds double, double* %0, i64 %92
%99 = load double, double* %98
%100 = tail call double @llvm.fabs.f64(double %99)
%101 = fcmp olt double %100, %62
br i1 %101, label %102, label %87
102: ; preds = %97
%103 = trunc i64 %88 to i32
%104 = icmp sgt i32 %83, %103
br i1 %104, label %105, label %182
105: ; preds = %102
%106 = shl i64 %88, 32
%107 = ashr exact i64 %106, 32
%108 = getelementptr inbounds double, double* %68, i64 %107
%109 = sub nsw i64 0, %107
%110 = sext i32 %83 to i64
br label %111
111: ; preds = %105, %177
%112 = phi i64 [ %107, %105 ], [ %178, %177 ]
%113 = phi <2 x double> [ <double 1.000000e+00, double 0.000000e+00>, %105 ], [ %132, %177 ]
%114 = add i64 %112, 4294967295
%115 = and i64 %114, 4294967295
%116 = getelementptr inbounds double, double* %1, i64 %115
%117 = load double, double* %116
%118 = extractelement <2 x double> %113, i64 0
%119 = fmul double %118, %117
%120 = getelementptr inbounds double, double* %0, i64 %112
%121 = load double, double* %120
%122 = extractelement <2 x double> %113, i64 1
%123 = fmul double %122, %117
store double %123, double* %116
%124 = fmul double %121, %121
%125 = tail call double @llvm.fmuladd.f64(double %119, double %119, double %124)
%126 = tail call double @sqrt(double %125)
store double %126, double* %120
%127 = fneg double %119
%128 = insertelement <2 x double> poison, double %127, i64 0
%129 = insertelement <2 x double> %128, double %121, i64 1
%130 = insertelement <2 x double> poison, double %126, i64 0
%131 = shufflevector <2 x double> %130, <2 x double> poison, <2 x i32> zeroinitializer
%132 = fdiv <2 x double> %129, %131
br i1 %65, label %133, label %177
133: ; preds = %111
%134 = extractelement <2 x double> %132, i64 0
%135 = fneg double %134
br i1 %71, label %164, label %136
136: ; preds = %133
%137 = extractelement <2 x double> %132, i64 1
%138 = extractelement <2 x double> %132, i64 1
br label %139
139: ; preds = %139, %136
%140 = phi double* [ %108, %136 ], [ %161, %139 ]
%141 = phi i32 [ 0, %136 ], [ %162, %139 ]
%142 = getelementptr inbounds double, double* %140, i64 %112
%143 = getelementptr inbounds double, double* %142, i64 %109
%144 = getelementptr inbounds double, double* %143, i64 1
%145 = load double, double* %140
%146 = load double, double* %144
%147 = fmul double %134, %146
%148 = tail call double @llvm.fmuladd.f64(double %137, double %145, double %147)
%149 = fmul double %145, %135
%150 = tail call double @llvm.fmuladd.f64(double %137, double %146, double %149)
store double %150, double* %144
store double %148, double* %140
%151 = getelementptr inbounds double, double* %140, i64 %66
%152 = getelementptr inbounds double, double* %151, i64 %112
%153 = getelementptr inbounds double, double* %152, i64 %109
%154 = getelementptr inbounds double, double* %153, i64 1
%155 = load double, double* %151
%156 = load double, double* %154
%157 = fmul double %134, %156
%158 = tail call double @llvm.fmuladd.f64(double %138, double %155, double %157)
%159 = fmul double %155, %135
%160 = tail call double @llvm.fmuladd.f64(double %138, double %156, double %159)
store double %160, double* %154
store double %158, double* %151
%161 = getelementptr inbounds double, double* %151, i64 %66
%162 = add i32 %141, 2
%163 = icmp eq i32 %162, %72
br i1 %163, label %164, label %139
164: ; preds = %139, %133
%165 = phi double* [ %108, %133 ], [ %161, %139 ]
br i1 %73, label %177, label %166
166: ; preds = %164
%167 = getelementptr inbounds double, double* %165, i64 %109
%168 = getelementptr inbounds double, double* %167, i64 1
%169 = getelementptr inbounds double, double* %168, i64 %112
%170 = load double, double* %165
%171 = load double, double* %169
%172 = fmul double %134, %171
%173 = extractelement <2 x double> %132, i64 1
%174 = tail call double @llvm.fmuladd.f64(double %173, double %170, double %172)
%175 = fmul double %170, %135
%176 = tail call double @llvm.fmuladd.f64(double %173, double %171, double %175)
store double %176, double* %169
store double %174, double* %165
br label %177
177: ; preds = %166, %164, %111
%178 = add nsw i64 %112, 1
%179 = icmp eq i64 %178, %110
br i1 %179, label %182, label %111
180: ; preds = %91
%181 = trunc i64 %88 to i32
br label %182
182: ; preds = %87, %177, %180, %102
%183 = phi i32 [ %103, %102 ], [ %181, %180 ], [ %103, %177 ], [ 0, %87 ]
%184 = zext i32 %183 to i64
%185 = getelementptr inbounds double, double* %0, i64 %184
%186 = load double, double* %185
%187 = getelementptr inbounds double, double* %0, i64 %86
%188 = load double, double* %187
%189 = add nsw i32 %83, -2
%190 = zext i32 %189 to i64
%191 = getelementptr inbounds double, double* %1, i64 %190
%192 = load double, double* %191
%193 = fadd double %186, %188
%194 = fsub double %186, %188
%195 = fneg double %192
%196 = fmul double %192, %195
%197 = tail call double @llvm.fmuladd.f64(double %193, double %194, double %196)
%198 = getelementptr inbounds double, double* %1, i64 %184
%199 = load double, double* %198
%200 = fmul double %186, %199
%201 = fadd double %200, %200
%202 = fmul double %201, %201
%203 = tail call double @llvm.fmuladd.f64(double %197, double %197, double %202)
%204 = tail call double @sqrt(double %203)
%205 = fcmp une double %204, 0.000000e+00
br i1 %205, label %206, label %356
206: ; preds = %182
%207 = fadd double %204, %197
%208 = fadd double %204, %204
%209 = fdiv double %207, %208
%210 = tail call double @sqrt(double %209)
%211 = fcmp une double %210, 0.000000e+00
br i1 %211, label %212, label %215
212: ; preds = %206
%213 = fmul double %204, %210
%214 = fdiv double %200, %213
br label %215
215: ; preds = %206, %212
%216 = phi double [ %214, %212 ], [ 1.000000e+00, %206 ]
%217 = icmp slt i32 %183, %85
br i1 %217, label %218, label %356
218: ; preds = %215
%219 = sext i32 %183 to i64
%220 = sext i32 %85 to i64
%221 = insertelement <2 x double> poison, double %210, i64 0
%222 = insertelement <2 x double> %221, double %216, i64 1
br label %236
223: ; preds = %337, %330
%224 = phi double* [ %331, %330 ], [ %353, %337 ]
br i1 %81, label %234, label %225
225: ; preds = %223
%226 = bitcast double* %224 to <2 x double>*
%227 = load <2 x double>, <2 x double>* %226
%228 = insertelement <2 x double> %322, double %327, i64 0
%229 = fmul <2 x double> %228, %227
%230 = shufflevector <2 x double> %229, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%231 = shufflevector <2 x double> %322, <2 x double> undef, <2 x i32> zeroinitializer
%232 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %231, <2 x double> %227, <2 x double> %230)
%233 = bitcast double* %224 to <2 x double>*
store <2 x double> %232, <2 x double>* %233
br label %234
234: ; preds = %225, %223, %306
%235 = icmp eq i64 %307, %220
br i1 %235, label %356, label %236
236: ; preds = %218, %234
%237 = phi i64 [ %219, %218 ], [ %307, %234 ]
%238 = phi double [ %186, %218 ], [ %329, %234 ]
%239 = phi double [ %188, %218 ], [ %326, %234 ]
%240 = phi <2 x double> [ %222, %218 ], [ %322, %234 ]
%241 = getelementptr inbounds double, double* %1, i64 %237
%242 = load double, double* %241
%243 = icmp sgt i64 %237, %219
br i1 %243, label %244, label %260
244: ; preds = %236
%245 = extractelement <2 x double> %240, i64 1
%246 = fmul double %245, %242
%247 = extractelement <2 x double> %240, i64 0
%248 = fmul double %247, %242
%249 = fmul double %246, %246
%250 = tail call double @llvm.fmuladd.f64(double %239, double %239, double %249)
%251 = tail call double @sqrt(double %250)
%252 = add i64 %237, 4294967295
%253 = and i64 %252, 4294967295
%254 = getelementptr inbounds double, double* %1, i64 %253
store double %251, double* %254
%255 = insertelement <2 x double> poison, double %239, i64 0
%256 = insertelement <2 x double> %255, double %246, i64 1
%257 = insertelement <2 x double> poison, double %251, i64 0
%258 = shufflevector <2 x double> %257, <2 x double> poison, <2 x i32> zeroinitializer
%259 = fdiv <2 x double> %256, %258
br label %260
260: ; preds = %236, %244
%261 = phi double [ %248, %244 ], [ %242, %236 ]
%262 = phi <2 x double> [ %259, %244 ], [ %240, %236 ]
%263 = extractelement <2 x double> %262, i64 1
%264 = fmul double %261, %263
%265 = extractelement <2 x double> %262, i64 0
%266 = tail call double @llvm.fmuladd.f64(double %265, double %238, double %264)
%267 = fneg double %263
%268 = fmul double %238, %267
%269 = tail call double @llvm.fmuladd.f64(double %265, double %261, double %268)
%270 = getelementptr inbounds double, double* %4, i64 %237
br i1 %75, label %295, label %271
271: ; preds = %260
%272 = insertelement <2 x double> %262, double %267, i64 0
%273 = shufflevector <2 x double> %262, <2 x double> undef, <2 x i32> zeroinitializer
%274 = insertelement <2 x double> %262, double %267, i64 0
%275 = shufflevector <2 x double> %262, <2 x double> undef, <2 x i32> zeroinitializer
br label %276
276: ; preds = %276, %271
%277 = phi double* [ %270, %271 ], [ %292, %276 ]
%278 = phi i32 [ 0, %271 ], [ %293, %276 ]
%279 = bitcast double* %277 to <2 x double>*
%280 = load <2 x double>, <2 x double>* %279
%281 = fmul <2 x double> %272, %280
%282 = shufflevector <2 x double> %281, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%283 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %273, <2 x double> %280, <2 x double> %282)
%284 = bitcast double* %277 to <2 x double>*
store <2 x double> %283, <2 x double>* %284
%285 = getelementptr inbounds double, double* %277, i64 %67
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = fmul <2 x double> %274, %287
%289 = shufflevector <2 x double> %288, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%290 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %275, <2 x double> %287, <2 x double> %289)
%291 = bitcast double* %285 to <2 x double>*
store <2 x double> %290, <2 x double>* %291
%292 = getelementptr inbounds double, double* %285, i64 %67
%293 = add nuw nsw i32 %278, 2
%294 = icmp eq i32 %293, %76
br i1 %294, label %295, label %276
295: ; preds = %276, %260
%296 = phi double* [ %270, %260 ], [ %292, %276 ]
br i1 %77, label %306, label %297
297: ; preds = %295
%298 = bitcast double* %296 to <2 x double>*
%299 = load <2 x double>, <2 x double>* %298
%300 = insertelement <2 x double> %262, double %267, i64 0
%301 = fmul <2 x double> %300, %299
%302 = shufflevector <2 x double> %301, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%303 = shufflevector <2 x double> %262, <2 x double> undef, <2 x i32> zeroinitializer
%304 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %303, <2 x double> %299, <2 x double> %302)
%305 = bitcast double* %296 to <2 x double>*
store <2 x double> %304, <2 x double>* %305
br label %306
306: ; preds = %295, %297
%307 = add nsw i64 %237, 1
%308 = and i64 %307, 4294967295
%309 = getelementptr inbounds double, double* %0, i64 %308
%310 = load double, double* %309
%311 = fmul double %263, %310
%312 = fmul double %311, %311
%313 = tail call double @llvm.fmuladd.f64(double %266, double %266, double %312)
%314 = tail call double @sqrt(double %313)
%315 = getelementptr inbounds double, double* %0, i64 %237
store double %314, double* %315
%316 = load double, double* %309
%317 = fmul double %265, %316
%318 = insertelement <2 x double> poison, double %266, i64 0
%319 = insertelement <2 x double> %318, double %311, i64 1
%320 = insertelement <2 x double> poison, double %314, i64 0
%321 = shufflevector <2 x double> %320, <2 x double> poison, <2 x i32> zeroinitializer
%322 = fdiv <2 x double> %319, %321
%323 = extractelement <2 x double> %322, i64 1
%324 = fmul double %323, %317
%325 = extractelement <2 x double> %322, i64 0
%326 = tail call double @llvm.fmuladd.f64(double %325, double %269, double %324)
%327 = fneg double %323
%328 = fmul double %269, %327
%329 = tail call double @llvm.fmuladd.f64(double %325, double %317, double %328)
br i1 %65, label %330, label %234
330: ; preds = %306
%331 = getelementptr inbounds double, double* %2, i64 %237
br i1 %79, label %223, label %332
332: ; preds = %330
%333 = insertelement <2 x double> %322, double %327, i64 0
%334 = shufflevector <2 x double> %322, <2 x double> undef, <2 x i32> zeroinitializer
%335 = insertelement <2 x double> %322, double %327, i64 0
%336 = shufflevector <2 x double> %322, <2 x double> undef, <2 x i32> zeroinitializer
br label %337
337: ; preds = %337, %332
%338 = phi double* [ %331, %332 ], [ %353, %337 ]
%339 = phi i32 [ 0, %332 ], [ %354, %337 ]
%340 = bitcast double* %338 to <2 x double>*
%341 = load <2 x double>, <2 x double>* %340
%342 = fmul <2 x double> %333, %341
%343 = shufflevector <2 x double> %342, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%344 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %334, <2 x double> %341, <2 x double> %343)
%345 = bitcast double* %338 to <2 x double>*
store <2 x double> %344, <2 x double>* %345
%346 = getelementptr inbounds double, double* %338, i64 %66
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = fmul <2 x double> %335, %348
%350 = shufflevector <2 x double> %349, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%351 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %336, <2 x double> %348, <2 x double> %350)
%352 = bitcast double* %346 to <2 x double>*
store <2 x double> %351, <2 x double>* %352
%353 = getelementptr inbounds double, double* %346, i64 %66
%354 = add i32 %339, 2
%355 = icmp eq i32 %354, %80
br i1 %355, label %223, label %337
356: ; preds = %234, %215, %182
%357 = phi double [ %188, %182 ], [ %188, %215 ], [ %326, %234 ]
%358 = phi double [ %186, %182 ], [ %186, %215 ], [ %329, %234 ]
store double %357, double* %191
store double %358, double* %187
%359 = tail call double @llvm.fabs.f64(double %357)
%360 = fcmp olt double %359, %62
%361 = select i1 %360, i32 %85, i32 %83
%362 = add nsw i32 %183, 1
%363 = icmp eq i32 %361, %362
%364 = sext i1 %363 to i32
%365 = add nsw i32 %361, %364
%366 = add nuw nsw i32 %84, 1
%367 = icmp sgt i32 %365, 1
%368 = icmp slt i32 %366, %63
%369 = select i1 %367, i1 %368, i1 false
br i1 %369, label %82, label %370
370: ; preds = %356, %6, %60
%371 = phi i32 [ 0, %60 ], [ 0, %6 ], [ %366, %356 ]
ret i32 %371
}