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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(double *);
int solvru(double *, double *, int);
double sqrt(double);
double qrlsq(double *a, double *b, int m, int n, int *f) {
  double *p, *q, *w;
  double s, h, r;
  int i, j, k, mm, ms;
  if (m < n)
    return -1;
  w = (double *)calloc(m, sizeof(double));
  for (i = 0, mm = m, p = a; i < n; ++i, --mm, p += n + 1) {
    if (mm > 1) {
      for (j = 0, q = p, s = 0.; j < mm; ++j, q += n) {
        w[j] = *q;
        s += *q * *q;
      }
      if (s > 0.) {
        h = sqrt(s);
        if (*p < 0.)
          h = -h;
        s += *p * h;
        s = 1. / s;
        w[0] += h;
        for (k = 1, ms = n - i; k < ms; ++k) {
          for (j = 0, q = p + k, r = 0.; j < mm; q += n)
            r += w[j++] * *q;
          r = r * s;
          for (j = 0, q = p + k; j < mm; q += n)
            *q -= r * w[j++];
        }
        *p = -h;
        for (j = 0, q = b + i, r = 0.; j < mm;)
          r += w[j++] * *q++;
        for (j = 0, q = b + i, r *= s; j < mm;)
          *q++ -= r * w[j++];
      }
    }
  }
  *f = solvru(a, b, n);
  for (j = n, q = b + j, s = 0.; j < m; ++j, ++q)
    s += *q * *q;
  free(w);
  return s;
}


x86 assembly (clang, -O0):
<qrlsq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1178 <qrlsq+0x38>
movsd  0xe9a(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    15f5 <qrlsq+0x4b5>
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1561 <qrlsq+0x421>
cmpl   $0x1,-0x68(%rbp)
jle    152d <qrlsq+0x3ed>
movl   $0x0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1231 <qrlsq+0xf1>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    11cb <qrlsq+0x8b>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1528 <qrlsq+0x3e8>
movsd  -0x48(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1284 <qrlsq+0x144>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xd55(%rip),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x40(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x64(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1404 <qrlsq+0x2c4>
movl   $0x0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    135b <qrlsq+0x21b>
mov    -0x40(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1304 <qrlsq+0x1c4>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    13f1 <qrlsq+0x2b1>
movsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1384 <qrlsq+0x244>
jmp    13f6 <qrlsq+0x2b6>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12d6 <qrlsq+0x196>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1497 <qrlsq+0x357>
mov    -0x40(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    144a <qrlsq+0x30a>
movl   $0x0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1523 <qrlsq+0x3e3>
movsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    14c0 <qrlsq+0x380>
jmp    1528 <qrlsq+0x3e8>
jmp    152d <qrlsq+0x3ed>
jmp    1532 <qrlsq+0x3f2>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
jmp    119e <qrlsq+0x5e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1050 <solvru@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15e2 <qrlsq+0x4a2>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
jmp    159a <qrlsq+0x45a>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrlsq>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
cmp    %ecx,%edx
jge    1162 <qrlsq+0x22>
movsd  0xea3(%rip),%xmm0
jmp    19a3 <qrlsq+0x863>
mov    %r8,%r15
mov    %edx,%ebp
mov    %rdi,%r14
mov    %rsi,0x30(%rsp)
mov    %edx,%edi
mov    $0x8,%esi
mov    %ecx,0x14(%rsp)
call   1040 <calloc@plt>
mov    0x14(%rsp),%edx
mov    %rax,%rbx
test   %edx,%edx
jle    18e1 <qrlsq+0x7a1>
mov    %r15,0x58(%rsp)
mov    %edx,%r12d
lea    0x8(,%r12,8),%r11
mov    %r12,%r8
shl    $0x4,%r8
lea    0x8(%r14),%r9
mov    %r12,%rax
shl    $0x5,%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%r12,8),%r13
mov    0x30(%rsp),%rsi
lea    0x30(%rsi),%r10
lea    0x18(%rbx),%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
xorpd  %xmm8,%xmm8
movapd 0xe2d(%rip),%xmm7
movsd  0xe1c(%rip),%xmm9
mov    %r14,0x50(%rsp)
mov    %r14,0x18(%rsp)
mov    %edx,0x24(%rsp)
mov    %rbp,0x60(%rsp)
mov    %r8,0x78(%rsp)
jmp    1243 <qrlsq+0x103>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%ebp
add    %r11,0x18(%rsp)
addl   $0xffffffff,0x24(%rsp)
add    %r11,%r9
add    $0x8,%r10
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    %r12,%rcx
je     18d0 <qrlsq+0x790>
mov    %ebp,%eax
mov    %rax,0x8(%rsp)
cmp    $0x2,%ebp
jl     1210 <qrlsq+0xd0>
mov    %rbp,%rcx
mov    %ecx,%r14d
and    $0x3,%r14d
mov    0x8(%rsp),%rdi
mov    %edi,%r15d
and    $0xfffffffc,%r15d
lea    -0x4(%r15),%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x90(%rsp)
mov    %edi,%eax
and    $0xfffffffe,%eax
and    $0xfffffffc,%ecx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xa0(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x98(%rsp)
lea    -0x1(%rdi),%rcx
mov    %rcx,0x38(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rsi,%rcx,8),%rbp
lea    0x0(%rbp,%rdi,8),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%rbx,%rdi,8),%rcx
mov    %rcx,0xb0(%rsp)
xorpd  %xmm4,%xmm4
mov    0x18(%rsp),%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
movsd  (%rcx,%r12,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdi,8)
movsd  (%rcx,%r12,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
add    $0x2,%rdi
add    %r8,%rcx
cmp    %rdi,%rax
jne    12e0 <qrlsq+0x1a0>
testb  $0x1,0x8(%rsp)
je     1337 <qrlsq+0x1f7>
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
ucomisd %xmm8,%xmm4
jbe    1210 <qrlsq+0xd0>
mov    %rbp,0x80(%rsp)
mov    %r9,0x40(%rsp)
mov    %r10,0x88(%rsp)
jb     1362 <qrlsq+0x222>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    139c <qrlsq+0x25c>
movapd %xmm4,%xmm0
mov    %r11,%rbp
movsd  %xmm4,0x70(%rsp)
call   1060 <sqrt@plt>
movsd  0x70(%rsp),%xmm4
movsd  0xc85(%rip),%xmm9
movapd 0xc85(%rip),%xmm7
xorpd  %xmm8,%xmm8
mov    %rbp,%r11
mov    0x30(%rsp),%rsi
mov    0x14(%rsp),%edx
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm0,%xmm3
xorpd  %xmm7,%xmm3
movapd %xmm2,%xmm1
cmpltsd %xmm8,%xmm1
andpd  %xmm1,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm9,%xmm0
divsd  %xmm3,%xmm0
movsd  (%rbx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx)
mov    %edx,%eax
sub    0x28(%rsp),%eax
cmp    $0x2,%eax
jl     15e0 <qrlsq+0x4a0>
mov    0x24(%rsp),%r8d
mov    $0x1,%r10d
mov    0x40(%rsp),%r9
jmp    1421 <qrlsq+0x2e1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x8,%r9
cmp    %r8,%r10
je     15e0 <qrlsq+0x4a0>
test   %edi,%edi
jle    1410 <qrlsq+0x2d0>
mov    0x18(%rsp),%rax
lea    (%rax,%r10,8),%rbp
cmpq   $0x3,0x38(%rsp)
jae    1450 <qrlsq+0x310>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    %rbp,%rcx
test   $0x3,%dil
jne    14c7 <qrlsq+0x387>
jmp    14e9 <qrlsq+0x3a9>
xchg   %ax,%ax
xorpd  %xmm2,%xmm2
mov    %r9,%rdi
xor    %eax,%eax
nopl   0x0(%rax)
mov    %rdi,%rcx
movsd  (%rbx,%rax,8),%xmm3
movsd  0x8(%rbx,%rax,8),%xmm4
mulsd  (%rdi),%xmm3
addsd  %xmm2,%xmm3
add    %r13,%rdi
mulsd  (%rcx,%r13,1),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rbx,%rax,8),%xmm3
mulsd  0x0(%r13,%rdi,1),%xmm3
add    %r13,%rdi
addsd  %xmm4,%xmm3
movsd  0x18(%rbx,%rax,8),%xmm2
add    $0x4,%rax
mulsd  0x0(%r13,%rdi,1),%xmm2
add    %r13,%rdi
addsd  %xmm3,%xmm2
add    %r13,%rdi
cmp    %rax,%r15
jne    1460 <qrlsq+0x320>
add    0x48(%rsp),%rcx
mov    0x8(%rsp),%rdi
test   $0x3,%dil
je     14e9 <qrlsq+0x3a9>
lea    (%rbx,%rax,8),%rax
xor    %edi,%edi
nopl   (%rax)
movsd  (%rax,%rdi,8),%xmm3
mulsd  (%rcx),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rdi
add    %r13,%rcx
cmp    %rdi,%r14
jne    14d0 <qrlsq+0x390>
mov    0x8(%rsp),%rdi
test   %edi,%edi
jle    1410 <qrlsq+0x2d0>
xorpd  %xmm7,%xmm2
mulsd  %xmm0,%xmm2
cmpq   $0x3,0x38(%rsp)
jae    1517 <qrlsq+0x3d7>
xor    %eax,%eax
test   $0x3,%dil
jne    15a7 <qrlsq+0x467>
jmp    1410 <qrlsq+0x2d0>
mov    %r9,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
mov    %rcx,%rbp
movsd  (%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx),%xmm3
movsd  %xmm3,(%rcx)
add    %r13,%rcx
movsd  0x8(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp,%r13,1),%xmm3
movsd  %xmm3,0x0(%rbp,%r13,1)
lea    (%rcx,%r13,1),%rdi
movsd  0x10(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%r13,%rcx,1),%xmm3
movsd  %xmm3,0x0(%r13,%rcx,1)
lea    (%rdi,%r13,1),%rcx
movsd  0x18(%rbx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%r13,%rdi,1),%xmm3
add    $0x4,%rax
movsd  %xmm3,0x0(%r13,%rdi,1)
add    %r13,%rcx
cmp    %rax,%r15
jne    1520 <qrlsq+0x3e0>
add    0x48(%rsp),%rbp
mov    0x8(%rsp),%rdi
test   $0x3,%dil
je     1410 <qrlsq+0x2d0>
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp),%xmm3
movsd  %xmm3,0x0(%rbp)
add    $0x1,%rcx
add    %r13,%rbp
cmp    %rcx,%r14
jne    15b0 <qrlsq+0x470>
jmp    1410 <qrlsq+0x2d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm7,%xmm1
mov    0x18(%rsp),%rax
movlpd %xmm1,(%rax)
test   %edi,%edi
mov    0x78(%rsp),%r8
mov    0x40(%rsp),%r9
mov    0x88(%rsp),%r10
mov    0x80(%rsp),%rbp
jle    1210 <qrlsq+0xd0>
cmpq   $0x3,0x38(%rsp)
jae    1627 <qrlsq+0x4e7>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    %rbp,%rax
mov    0x8(%rsp),%rdi
jmp    1687 <qrlsq+0x547>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    %rbp,%rax
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rcx,8),%xmm2
mulsd  (%rax),%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
mulsd  0x8(%rax),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rbx,%rcx,8),%xmm2
mulsd  0x10(%rax),%xmm2
addsd  %xmm3,%xmm2
movsd  0x18(%rbx,%rcx,8),%xmm1
mulsd  0x18(%rax),%xmm1
add    $0x4,%rcx
add    $0x20,%rax
addsd  %xmm2,%xmm1
cmp    %rcx,%r15
jne    1640 <qrlsq+0x500>
test   $0x3,%dil
je     16b7 <qrlsq+0x577>
lea    (%rbx,%rcx,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdi,8),%xmm2
mulsd  (%rax,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%r14
jne    16a0 <qrlsq+0x560>
cmpl   $0x0,0x8(%rsp)
jle    1210 <qrlsq+0xd0>
xorpd  %xmm7,%xmm1
mulsd  %xmm1,%xmm0
mov    0x8(%rsp),%rdi
cmp    $0x4,%edi
jb     16f0 <qrlsq+0x5b0>
cmp    0xb0(%rsp),%rbp
jae    17d3 <qrlsq+0x693>
cmp    0xa8(%rsp),%rbx
jae    17d3 <qrlsq+0x693>
xor    %eax,%eax
mov    %rax,%rdi
not    %rdi
mov    0x8(%rsp),%rcx
add    %rcx,%rdi
test   $0x3,%cl
je     1740 <qrlsq+0x600>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x8(%rbp),%rcx
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
add    $0x1,%rax
addsd  0x0(%rbp),%xmm1
movsd  %xmm1,0x0(%rbp)
mov    %rcx,%rbp
add    $0xffffffffffffffff,%r14
jne    1710 <qrlsq+0x5d0>
cmp    $0x3,%rdi
jb     1210 <qrlsq+0xd0>
jmp    174d <qrlsq+0x60d>
mov    %rbp,%rcx
cmp    $0x3,%rdi
jb     1210 <qrlsq+0xd0>
mov    0x8(%rsp),%rdi
sub    %rax,%rdi
mov    0x68(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movsd  -0x10(%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rbp,8)
movsd  -0x8(%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rcx,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rcx,%rbp,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1770 <qrlsq+0x630>
jmp    1210 <qrlsq+0xd0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xa0(%rsp)
je     1879 <qrlsq+0x739>
xor    %ecx,%ecx
mov    0x90(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rbx,%rcx,8),%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r10,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r10,%rcx,8),%xmm2
movupd -0x10(%r10,%rcx,8),%xmm5
movupd (%r10,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r10,%rcx,8)
movupd %xmm3,-0x20(%r10,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r10,%rcx,8)
movupd %xmm3,(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1800 <qrlsq+0x6c0>
jmp    187b <qrlsq+0x73b>
xor    %ecx,%ecx
mov    %edi,%eax
and    $0xfffffffc,%eax
testb  $0x1,0x98(%rsp)
01
je     18bd <qrlsq+0x77d>
movupd (%rbx,%rcx,8),%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm3
movupd 0x0(%rbp,%rcx,8),%xmm4
movupd 0x10(%rbp,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm3,0x10(%rbp,%rcx,8)
cmp    %rdi,%rax
je     1210 <qrlsq+0xd0>
lea    0x0(%rbp,%rax,8),%rbp
jmp    16f2 <qrlsq+0x5b2>
mov    0x60(%rsp),%rbp
mov    0x58(%rsp),%r15
mov    0x50(%rsp),%r14
jmp    18e9 <qrlsq+0x7a9>
movslq %edx,%r12
mov    0x30(%rsp),%rsi
mov    %r14,%rdi
mov    %rsi,%r14
call   1050 <solvru@plt>
mov    0x14(%rsp),%edi
mov    %eax,(%r15)
xorpd  %xmm2,%xmm2
mov    %ebp,%edx
sub    %edi,%edx
jle    198f <qrlsq+0x84f>
lea    (%r14,%r12,8),%rax
mov    %edi,%ecx
not    %ecx
add    %ebp,%ecx
and    $0x3,%edx
je     1940 <qrlsq+0x800>
neg    %edx
xorpd  %xmm2,%xmm2
xor    %esi,%esi
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x8,%rax
add    $0xffffffff,%esi
cmp    %esi,%edx
jne    1920 <qrlsq+0x7e0>
sub    %esi,%edi
cmp    $0x3,%ecx
jae    1949 <qrlsq+0x809>
jmp    198f <qrlsq+0x84f>
xorpd  %xmm2,%xmm2
cmp    $0x3,%ecx
jb     198f <qrlsq+0x84f>
sub    %edi,%ebp
xor    %ecx,%ecx
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x4,%rcx
cmp    %ecx,%ebp
jne    1950 <qrlsq+0x810>
movsd  %xmm2,0x8(%rsp)
mov    %rbx,%rdi
call   1030 <free@plt>
movsd  0x8(%rsp),%xmm0
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @qrlsq(double* %0, double* %1, i32 %2, i32 %3, i32* %4) {
%6 = alloca double
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store double* %0, double** %7
store double* %1, double** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32* %4, i32** %11
%23 = load i32, i32* %9
%24 = load i32, i32* %10
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %27
26: ; preds = %5
store double -1.000000e+00, double* %6
br label %249
27: ; preds = %5
%28 = load i32, i32* %9
%29 = call i64 @calloc(i32 %28, i32 8)
%30 = inttoptr i64 %29 to double*
store double* %30, double** %14
store i32 0, i32* %18
%31 = load i32, i32* %9
store i32 %31, i32* %21
%32 = load double*, double** %7
store double* %32, double** %12
br label %33
33: ; preds = %208, %27
%34 = load i32, i32* %18
%35 = load i32, i32* %10
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %218
37: ; preds = %33
%38 = load i32, i32* %21
%39 = icmp sgt i32 %38, 1
br i1 %39, label %40, label %207
40: ; preds = %37
store i32 0, i32* %19
%41 = load double*, double** %12
store double* %41, double** %13
store double 0.000000e+00, double* %15
br label %42
42: ; preds = %59, %40
%43 = load i32, i32* %19
%44 = load i32, i32* %21
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %66
46: ; preds = %42
%47 = load double*, double** %13
%48 = load double, double* %47
%49 = load double*, double** %14
%50 = load i32, i32* %19
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double %48, double* %52
%53 = load double*, double** %13
%54 = load double, double* %53
%55 = load double*, double** %13
%56 = load double, double* %55
%57 = load double, double* %15
%58 = call double @llvm.fmuladd.f64(double %54, double %56, double %57)
store double %58, double* %15
br label %59
59: ; preds = %46
%60 = load i32, i32* %19
%61 = add nsw i32 %60, 1
store i32 %61, i32* %19
%62 = load i32, i32* %10
%63 = load double*, double** %13
%64 = sext i32 %62 to i64
%65 = getelementptr inbounds double, double* %63, i64 %64
store double* %65, double** %13
br label %42
66: ; preds = %42
%67 = load double, double* %15
%68 = fcmp ogt double %67, 0.000000e+00
br i1 %68, label %69, label %206
69: ; preds = %66
%70 = load double, double* %15
%71 = call double @sqrt(double %70)
store double %71, double* %16
%72 = load double*, double** %12
%73 = load double, double* %72
%74 = fcmp olt double %73, 0.000000e+00
br i1 %74, label %75, label %78
75: ; preds = %69
%76 = load double, double* %16
%77 = fneg double %76
store double %77, double* %16
br label %78
78: ; preds = %75, %69
%79 = load double*, double** %12
%80 = load double, double* %79
%81 = load double, double* %16
%82 = load double, double* %15
%83 = call double @llvm.fmuladd.f64(double %80, double %81, double %82)
store double %83, double* %15
%84 = load double, double* %15
%85 = fdiv double 1.000000e+00, %84
store double %85, double* %15
%86 = load double, double* %16
%87 = load double*, double** %14
%88 = getelementptr inbounds double, double* %87, i64 0
%89 = load double, double* %88
%90 = fadd double %89, %86
store double %90, double* %88
store i32 1, i32* %20
%91 = load i32, i32* %10
%92 = load i32, i32* %18
%93 = sub nsw i32 %91, %92
store i32 %93, i32* %22
br label %94
94: ; preds = %153, %78
%95 = load i32, i32* %20
%96 = load i32, i32* %22
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %156
98: ; preds = %94
store i32 0, i32* %19
%99 = load double*, double** %12
%100 = load i32, i32* %20
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
store double* %102, double** %13
store double 0.000000e+00, double* %17
br label %103
103: ; preds = %118, %98
%104 = load i32, i32* %19
%105 = load i32, i32* %21
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %123
107: ; preds = %103
%108 = load double*, double** %14
%109 = load i32, i32* %19
%110 = add nsw i32 %109, 1
store i32 %110, i32* %19
%111 = sext i32 %109 to i64
%112 = getelementptr inbounds double, double* %108, i64 %111
%113 = load double, double* %112
%114 = load double*, double** %13
%115 = load double, double* %114
%116 = load double, double* %17
%117 = call double @llvm.fmuladd.f64(double %113, double %115, double %116)
store double %117, double* %17
br label %118
118: ; preds = %107
%119 = load i32, i32* %10
%120 = load double*, double** %13
%121 = sext i32 %119 to i64
%122 = getelementptr inbounds double, double* %120, i64 %121
store double* %122, double** %13
br label %103
123: ; preds = %103
%124 = load double, double* %17
%125 = load double, double* %15
%126 = fmul double %124, %125
store double %126, double* %17
store i32 0, i32* %19
%127 = load double*, double** %12
%128 = load i32, i32* %20
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
store double* %130, double** %13
br label %131
131: ; preds = %147, %123
%132 = load i32, i32* %19
%133 = load i32, i32* %21
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %152
135: ; preds = %131
%136 = load double, double* %17
%137 = load double*, double** %14
%138 = load i32, i32* %19
%139 = add nsw i32 %138, 1
store i32 %139, i32* %19
%140 = sext i32 %138 to i64
%141 = getelementptr inbounds double, double* %137, i64 %140
%142 = load double, double* %141
%143 = load double*, double** %13
%144 = load double, double* %143
%145 = fneg double %136
%146 = call double @llvm.fmuladd.f64(double %145, double %142, double %144)
store double %146, double* %143
br label %147
147: ; preds = %135
%148 = load i32, i32* %10
%149 = load double*, double** %13
%150 = sext i32 %148 to i64
%151 = getelementptr inbounds double, double* %149, i64 %150
store double* %151, double** %13
br label %131
152: ; preds = %131
br label %153
153: ; preds = %152
%154 = load i32, i32* %20
%155 = add nsw i32 %154, 1
store i32 %155, i32* %20
br label %94
156: ; preds = %94
%157 = load double, double* %16
%158 = fneg double %157
%159 = load double*, double** %12
store double %158, double* %159
store i32 0, i32* %19
%160 = load double*, double** %8
%161 = load i32, i32* %18
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
store double* %163, double** %13
store double 0.000000e+00, double* %17
br label %164
164: ; preds = %168, %156
%165 = load i32, i32* %19
%166 = load i32, i32* %21
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %180
168: ; preds = %164
%169 = load double*, double** %14
%170 = load i32, i32* %19
%171 = add nsw i32 %170, 1
store i32 %171, i32* %19
%172 = sext i32 %170 to i64
%173 = getelementptr inbounds double, double* %169, i64 %172
%174 = load double, double* %173
%175 = load double*, double** %13
%176 = getelementptr inbounds double, double* %175, i32 1
store double* %176, double** %13
%177 = load double, double* %175
%178 = load double, double* %17
%179 = call double @llvm.fmuladd.f64(double %174, double %177, double %178)
store double %179, double* %17
br label %164
180: ; preds = %164
store i32 0, i32* %19
%181 = load double*, double** %8
%182 = load i32, i32* %18
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
store double* %184, double** %13
%185 = load double, double* %15
%186 = load double, double* %17
%187 = fmul double %186, %185
store double %187, double* %17
br label %188
188: ; preds = %192, %180
%189 = load i32, i32* %19
%190 = load i32, i32* %21
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %205
192: ; preds = %188
%193 = load double, double* %17
%194 = load double*, double** %14
%195 = load i32, i32* %19
%196 = add nsw i32 %195, 1
store i32 %196, i32* %19
%197 = sext i32 %195 to i64
%198 = getelementptr inbounds double, double* %194, i64 %197
%199 = load double, double* %198
%200 = load double*, double** %13
%201 = getelementptr inbounds double, double* %200, i32 1
store double* %201, double** %13
%202 = load double, double* %200
%203 = fneg double %193
%204 = call double @llvm.fmuladd.f64(double %203, double %199, double %202)
store double %204, double* %200
br label %188
205: ; preds = %188
br label %206
206: ; preds = %205, %66
br label %207
207: ; preds = %206, %37
br label %208
208: ; preds = %207
%209 = load i32, i32* %18
%210 = add nsw i32 %209, 1
store i32 %210, i32* %18
%211 = load i32, i32* %21
%212 = add nsw i32 %211, -1
store i32 %212, i32* %21
%213 = load i32, i32* %10
%214 = add nsw i32 %213, 1
%215 = load double*, double** %12
%216 = sext i32 %214 to i64
%217 = getelementptr inbounds double, double* %215, i64 %216
store double* %217, double** %12
br label %33
218: ; preds = %33
%219 = load double*, double** %7
%220 = load double*, double** %8
%221 = load i32, i32* %10
%222 = call i32 @solvru(double* %219, double* %220, i32 %221)
%223 = load i32*, i32** %11
store i32 %222, i32* %223
%224 = load i32, i32* %10
store i32 %224, i32* %19
%225 = load double*, double** %8
%226 = load i32, i32* %19
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %225, i64 %227
store double* %228, double** %13
store double 0.000000e+00, double* %15
br label %229
229: ; preds = %240, %218
%230 = load i32, i32* %19
%231 = load i32, i32* %9
%232 = icmp slt i32 %230, %231
br i1 %232, label %233, label %245
233: ; preds = %229
%234 = load double*, double** %13
%235 = load double, double* %234
%236 = load double*, double** %13
%237 = load double, double* %236
%238 = load double, double* %15
%239 = call double @llvm.fmuladd.f64(double %235, double %237, double %238)
store double %239, double* %15
br label %240
240: ; preds = %233
%241 = load i32, i32* %19
%242 = add nsw i32 %241, 1
store i32 %242, i32* %19
%243 = load double*, double** %13
%244 = getelementptr inbounds double, double* %243, i32 1
store double* %244, double** %13
br label %229
245: ; preds = %229
%246 = load double*, double** %14
%247 = call i32 @free(double* %246)
%248 = load double, double* %15
store double %248, double* %6
br label %249
249: ; preds = %245, %26
%250 = load double, double* %6
ret double %250
}

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