#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 qrbdu1(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 += nm) {
            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 += nm) {
          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):
<qrbdu1>:
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 <qrbdu1+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 <qrbdu1+0xa9>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    11be <qrbdu1+0xae>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1154 <qrbdu1+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 <qrbdu1+0x109>
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
setl   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    122c <qrbdu1+0x11c>
jmp    1a51 <qrbdu1+0x941>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jle    14b6 <qrbdu1+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 <qrbdu1+0x163>
jmp    14b6 <qrbdu1+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 <qrbdu1+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 <qrbdu1+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 <qrbdu1+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    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    139c <qrbdu1+0x28c>
jmp    1490 <qrbdu1+0x380>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12bd <qrbdu1+0x1ad>
jmp    14b6 <qrbdu1+0x3a6>
jmp    14a8 <qrbdu1+0x398>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1235 <qrbdu1+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
jbe    19cb <qrbdu1+0x8bb>
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    15d5 <qrbdu1+0x4c5>
jp     15d5 <qrbdu1+0x4c5>
jmp    15f2 <qrbdu1+0x4e2>
movsd  -0x78(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    15ff <qrbdu1+0x4ef>
movsd  0xa1e(%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    19c6 <qrbdu1+0x8b6>
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    16b0 <qrbdu1+0x5a0>
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    17eb <qrbdu1+0x6db>
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    1726 <qrbdu1+0x616>
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    19b3 <qrbdu1+0x8a3>
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    18ee <qrbdu1+0x7de>
jmp    19b8 <qrbdu1+0x8a8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1605 <qrbdu1+0x4f5>
jmp    19cb <qrbdu1+0x8bb>
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 0x5fb(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1a24 <qrbdu1+0x914>
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    1a3e <qrbdu1+0x92e>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a43 <qrbdu1+0x933>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f8 <qrbdu1+0xe8>
mov    -0x34(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrbdu1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
xor    %eax,%eax
cmp    $0x2,%r9d
jl     1bc9 <qrbdu1+0xab9>
mov    %r8,0xb8(%rsp)
movsd  (%rdi),%xmm1
andpd  0xebf(%rip),%xmm1
mov    %r9d,%r14d
lea    -0x1(%r14),%r8
cmp    $0x2,%r9d
mov    %r9d,0x4(%rsp)
mov    %rdx,0x68(%rsp)
jne    1163 <qrbdu1+0x53>
mov    $0x1,%ebx
movapd %xmm1,%xmm5
jmp    11cc <qrbdu1+0xbc>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ebx
movapd 0xe86(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
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 <qrbdu1+0x70>
test   $0x1,%r8b
je     11f9 <qrbdu1+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    0x4(%rsp),%ebp
cmp    $0x2,%ebp
jl     1bc9 <qrbdu1+0xab9>
movapd %xmm5,%xmm1
imul   $0x64,%ebp,%eax
mov    %eax,0xa4(%rsp)
mulsd  0xe04(%rip),%xmm1
mov    0x68(%rsp),%rdx
lea    -0x8(%rdx),%rax
mov    %rax,0xb0(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0x3c(%rsp)
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %eax,0x38(%rsp)
mov    %ebp,%eax
and    $0xfffffffe,%eax
mov    %eax,0xac(%rsp)
mov    %r14,%r15
shl    $0x4,%r15
shl    $0x3,%r14
xor    %eax,%eax
movapd 0xda1(%rip),%xmm12
xorpd  %xmm8,%xmm8
movapd 0xda3(%rip),%xmm9
mov    %ebp,%edx
mov    %rcx,0x30(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,0x20(%rsp)
movapd %xmm1,0xe0(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %eax,0xa8(%rsp)
mov    %rdx,0x18(%rsp)
lea    -0x1(%rdx),%r8d
movslq %r8d,%rdx
lea    0x0(,%rdx,8),%rax
mov    0xb0(%rsp),%rbp
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
lea    (%r14,%rdx,8),%rdx
mov    %r8,0x10(%rsp)
mov    %r8,%rbp
nopw   0x0(%rax,%rax,1)
mov    %rbp,%r8
test   %r8d,%r8d
jle    1550 <qrbdu1+0x440>
movsd  -0x8(%rsi,%r8,8),%xmm0
andpd  %xmm12,%xmm0
ucomisd %xmm0,%xmm1
ja     1553 <qrbdu1+0x443>
mov    %rax,%r13
mov    %rbx,%r9
mov    %rdx,%r12
lea    -0x1(%r8),%rbp
movsd  (%rdi,%rbp,8),%xmm0
andpd  %xmm12,%xmm0
add    $0xfffffffffffffff8,%rax
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%rdx
ucomisd %xmm0,%xmm1
jbe    12d0 <qrbdu1+0x1c0>
mov    0x18(%rsp),%rdx
cmp    %r8d,%edx
jle    1558 <qrbdu1+0x448>
movslq %r8d,%rbx
mov    0xb0(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    %rax,0x40(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x90(%rsp)
movslq %edx,%r10
movsd  0xcd2(%rip),%xmm1
mov    %r8,0x8(%rsp)
mov    %r10,0x98(%rsp)
jmp    1385 <qrbdu1+0x275>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x8,%r13
add    $0x8,%r12
cmp    %r10,%rbx
je     1553 <qrbdu1+0x443>
mov    $0xffffffff,%eax
add    %ebx,%eax
movsd  (%rsi,%rax,8),%xmm0
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rdi,%rbx,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     13d0 <qrbdu1+0x2c0>
sqrtsd %xmm0,%xmm0
jmp    142c <qrbdu1+0x31c>
nopl   0x0(%rax)
mov    %r9,%rbp
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    %rbp,%r9
mov    0x8(%rsp),%r8
movapd 0xc01(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0xbe3(%rip),%xmm12
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x30(%rsp),%rcx
movsd  %xmm0,(%rdi,%rbx,8)
xorpd  %xmm9,%xmm2
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm0
movapd %xmm2,%xmm1
divpd  %xmm0,%xmm1
test   %ecx,%ecx
jle    1370 <qrbdu1+0x260>
movapd %xmm1,%xmm0
xorpd  %xmm9,%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
mov    0x40(%rsp),%rax
cmpl   $0x0,0x3c(%rsp)
je     14f7 <qrbdu1+0x3e7>
mov    0x38(%rsp),%ebp
mov    %r9,%rax
mov    0x68(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
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,%r14,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,%r14,1)
add    %r15,%rdx
add    %r15,%rax
add    $0xfffffffe,%ebp
jne    1480 <qrbdu1+0x370>
test   $0x1,%cl
je     1370 <qrbdu1+0x260>
mov    0x90(%rsp),%rdx
lea    (%rax,%rdx,8),%rdx
movsd  (%rax),%xmm3
movsd  0x8(%rdx,%rbx,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,%rbx,8)
movsd  %xmm6,(%rax)
jmp    1370 <qrbdu1+0x260>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r8d,%r8d
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rbx
mov    %r8d,%eax
movsd  (%rdi,%rax,8),%xmm10
movsd  (%rdi,%rbx,8),%xmm4
lea    -0x2(%rdx),%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
mov    %r8,0x8(%rsp)
movsd  %xmm2,0x80(%rsp)
jb     15e0 <qrbdu1+0x4d0>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    163a <qrbdu1+0x52a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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
mov    0x8(%rsp),%r8
movapd 0x9f7(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x9d9(%rip),%xmm12
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x30(%rsp),%rcx
movapd %xmm0,%xmm1
mov    0x4(%rsp),%r9d
ucomisd %xmm8,%xmm1
mov    %rbp,0xd0(%rsp)
jbe    1b60 <qrbdu1+0xa50>
addsd  %xmm1,%xmm3
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm3
ucomisd %xmm8,%xmm3
jb     1670 <qrbdu1+0x560>
sqrtsd %xmm3,%xmm3
jmp    16d3 <qrbdu1+0x5c3>
nop
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
mov    0x8(%rsp),%r8
movapd 0x963(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x945(%rip),%xmm12
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    0x4(%rsp),%r9d
movapd %xmm0,%xmm3
ucomisd %xmm8,%xmm3
movsd  0x948(%rip),%xmm0
jne    16e4 <qrbdu1+0x5d4>
jnp    16f5 <qrbdu1+0x5e5>
mulsd  %xmm3,%xmm1
movsd  0x80(%rsp),%xmm0
divsd  %xmm1,%xmm0
cmp    %ebx,%r8d
jge    1b60 <qrbdu1+0xa50>
movslq %r8d,%rbp
movslq %ebx,%rax
mov    %rax,0x90(%rsp)
unpcklpd %xmm0,%xmm3
mov    0xb8(%rsp),%rax
lea    (%rax,%rbp,8),%r13
mov    0x68(%rsp),%rax
lea    (%rax,%rbp,8),%r10
mov    %rbp,0x98(%rsp)
mov    %rbp,%rdx
jmp    178d <qrbdu1+0x67d>
cs nopw 0x0(%rax,%rax,1)
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,%r13
add    $0x8,%r10
movapd %xmm1,%xmm10
cmp    0x90(%rsp),%rdx
je     1b65 <qrbdu1+0xa55>
mov    %rdx,%rbx
movsd  (%rsi,%rdx,8),%xmm11
cmp    0x98(%rsp),%rdx
jle    17e0 <qrbdu1+0x6d0>
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     17f0 <qrbdu1+0x6e0>
sqrtsd %xmm0,%xmm0
jmp    1877 <qrbdu1+0x767>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm13
jmp    1899 <qrbdu1+0x789>
nopw   0x0(%rax,%rax,1)
movsd  %xmm10,0x50(%rsp)
mov    %r10,%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,%r10
movsd  0x50(%rsp),%xmm10
mov    0x8(%rsp),%r8
movapd 0x7bb(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x79d(%rip),%xmm12
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    0x4(%rsp),%r9d
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,%r9d
jne    18d0 <qrbdu1+0x7c0>
mov    0xb8(%rsp),%rax
lea    (%rax,%rbx,8),%rax
jmp    1936 <qrbdu1+0x826>
nopl   0x0(%rax,%rax,1)
movapd %xmm13,%xmm2
movsd  %xmm1,%xmm2
mov    0xac(%rsp),%ebp
mov    %r13,%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,1),%xmm3
movapd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rax,%r14,1)
add    %r15,%rax
add    $0xfffffffe,%ebp
jne    18f0 <qrbdu1+0x7e0>
test   $0x1,%r9b
je     195f <qrbdu1+0x84f>
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,%r12d
movsd  (%rdi,%r12,8),%xmm2
mulsd  %xmm14,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
jb     19b0 <qrbdu1+0x8a0>
sqrtsd %xmm0,%xmm0
jmp    1a69 <qrbdu1+0x959>
nopl   (%rax)
movsd  %xmm10,0x50(%rsp)
mov    %r13,%rbp
mov    %r10,%r13
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    %r13,%r10
mov    %rbp,%r13
movsd  0x50(%rsp),%xmm10
mov    0x8(%rsp),%r8
movapd 0x5c9(%rip),%xmm9
xorpd  %xmm8,%xmm8
movapd 0x5ab(%rip),%xmm12
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    0x4(%rsp),%r9d
movsd  %xmm0,(%rdi,%rbx,8)
movsd  (%rdi,%r12,8),%xmm1
mulsd  %xmm13,%xmm1
unpcklpd %xmm2,%xmm3
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
test   %ecx,%ecx
jle    1740 <qrbdu1+0x630>
movapd %xmm0,%xmm7
xorpd  %xmm9,%xmm7
movapd %xmm3,%xmm2
unpcklpd %xmm3,%xmm2
cmpl   $0x0,0x3c(%rsp)
je     1b20 <qrbdu1+0xa10>
movapd %xmm3,%xmm4
movsd  %xmm7,%xmm4
mov    0x38(%rsp),%ebx
mov    %r10,%rax
nopl   0x0(%rax)
movupd (%rax),%xmm5
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%rax)
movupd (%rax,%r14,1),%xmm5
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%rax,%r14,1)
add    %r15,%rax
add    $0xfffffffe,%ebx
jne    1ac0 <qrbdu1+0x9b0>
test   $0x1,%cl
je     1740 <qrbdu1+0x630>
jmp    1b32 <qrbdu1+0xa22>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rax
lea    (%rax,%rbx,8),%rax
test   $0x1,%cl
je     1740 <qrbdu1+0x630>
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    1740 <qrbdu1+0x630>
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    0x18(%rsp),%rdx
mov    0x10(%rsp),%rax
cmova  %eax,%edx
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%r8d
xor    %eax,%eax
cmp    %r8d,%edx
sete   %al
sub    %eax,%edx
mov    0xa8(%rsp),%eax
add    $0x1,%eax
cmp    $0x2,%edx
jl     1bc9 <qrbdu1+0xab9>
cmp    0xa4(%rsp),%eax
movapd 0xe0(%rsp),%xmm1
jl     1290 <qrbdu1+0x180>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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