#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 sqrt(int);
void housev(double *a, double *d, double *dp, int n) {
  double sc, x, y, h;
  int i, j, k, m, e;
  double *qw, *qs, *pc, *p;
  qs = (double *)calloc(n, sizeof(double));
  for (j = 0, pc = a; j < n - 2; ++j, pc += n + 1) {
    m = n - j - 1;
    for (i = 1, sc = 0.; i <= m; ++i)
      sc += pc[i] * pc[i];
    if (sc > 0.) {
      sc = sqrt(sc);
      if ((x = *(pc + 1)) < 0.) {
        y = x - sc;
        h = 1. / sqrt(-2. * sc * y);
      } else {
        y = x + sc;
        h = 1. / sqrt(2. * sc * y);
        sc = -sc;
      }
      for (i = 0, qw = pc + 1; i < m; ++i) {
        qs[i] = 0.;
        if (i)
          qw[i] *= h;
        else
          qw[i] = y * h;
      }
      for (i = 0, e = j + 2, p = pc + n + 1, h = 0.; i < m; ++i, p += e++) {
        qs[i] += (y = qw[i]) * *p++;
        for (k = i + 1; k < m; ++k) {
          qs[i] += qw[k] * *p;
          qs[k] += y * *p++;
        }
        h += y * qs[i];
      }
      for (i = 0; i < m; ++i) {
        qs[i] -= h * qw[i];
        qs[i] += qs[i];
      }
      for (i = 0, e = j + 2, p = pc + n + 1; i < m; ++i, p += e++) {
        for (k = i; k < m; ++k)
          *p++ -= qw[i] * qs[k] + qs[i] * qw[k];
      }
    }
    d[j] = *pc;
    dp[j] = sc;
  }
  d[j] = *pc;
  dp[j] = *(pc + 1);
  d[j + 1] = *(pc += n + 1);
  free(qs);
  for (i = 0, m = n + n, p = pc; i < m; ++i)
    *p-- = 0.;
  *pc = 1.;
  *(pc -= n + 1) = 1.;
  qw = pc - n;
  for (m = 2; m < n; ++m, qw -= n + 1) {
    for (j = 0, p = pc, *pc = 1.; j < m; ++j, p += n) {
      for (i = 0, qs = p, h = 0.; i < m;)
        h += qw[i++] * *qs++;
      for (i = 0, qs = p, h += h; i < m;)
        *qs++ -= h * qw[i++];
    }
    for (i = 0, p = qw + m; i < n; ++i)
      *(--p) = 0.;
    *(pc -= n + 1) = 1.;
  }
}


x86 assembly (clang, -O0):
<housev>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    163b <housev+0x50b>
mov    -0x1c(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     11dc <housev+0xac>
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1196 <housev+0x66>
movsd  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15ee <housev+0x4be>
cvttsd2si -0x28(%rbp),%edi
call   1050 <sqrt@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x70(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  %xmm1,-0x30(%rbp)
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1260 <housev+0x130>
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xddd(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
cvtsi2sd %eax,%xmm1
movsd  0xdae(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    12c0 <housev+0x190>
movsd  -0x30(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd91(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd6a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    133f <housev+0x20f>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x44(%rbp)
je     1315 <housev+0x1e5>
movsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    132c <housev+0x1fc>
movsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1331 <housev+0x201>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12d3 <housev+0x1a3>
movl   $0x0,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    148c <housev+0x35c>
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    143d <housev+0x30d>
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13c2 <housev+0x292>
movsd  -0x38(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x54(%rbp),%ecx
mov    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    136e <housev+0x23e>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    150f <housev+0x3df>
movsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1493 <housev+0x363>
movl   $0x0,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x78(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    15e9 <housev+0x4b9>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    15b9 <housev+0x489>
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1548 <housev+0x418>
jmp    15be <housev+0x48e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x54(%rbp),%ecx
mov    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    1536 <housev+0x406>
jmp    15ee <housev+0x4be>
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    116a <housev+0x3a>
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x70(%rbp)
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    16ec <housev+0x5bc>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16bc <housev+0x58c>
mov    -0x70(%rbp),%rax
movsd  0x908(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x70(%rbp)
movsd  0x8d9(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1935 <housev+0x805>
movl   $0x0,-0x48(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
movsd  0x88e(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    188f <housev+0x75f>
movl   $0x0,-0x44(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    17e6 <housev+0x6b6>
mov    -0x60(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1799 <housev+0x669>
movl   $0x0,-0x44(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1867 <housev+0x737>
movsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%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    1804 <housev+0x6d4>
jmp    186c <housev+0x73c>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    1776 <housev+0x646>
movl   $0x0,-0x44(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18da <housev+0x7aa>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18a9 <housev+0x779>
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x70(%rbp)
movsd  0x6fb(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    174b <housev+0x61b>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<housev>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%r14d
mov    %rdx,0xb8(%rsp)
mov    %rsi,0xc0(%rsp)
mov    %rdi,%r13
mov    %ecx,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%r12
lea    -0x2(%r14),%ecx
mov    %r14d,%r15d
mov    %ecx,%eax
mov    %rax,0xc8(%rsp)
cmp    $0x2,%r14d
jle    1c42 <housev+0xb02>
mov    %ecx,0xb0(%rsp)
lea    0x1(%r15),%rax
mov    %rax,0x78(%rsp)
lea    -0x1(%r14),%eax
lea    0x8(%r12),%rcx
mov    %rcx,0xd0(%rsp)
lea    0x8(,%r15,8),%rcx
mov    %rcx,0xe0(%rsp)
lea    0x18(%r13),%r10
lea    0x10(%r12),%rcx
mov    %rcx,0xd8(%rsp)
mov    $0x2,%edi
xor    %ebp,%ebp
xorpd  %xmm8,%xmm8
mov    %eax,0xb4(%rsp)
mov    %r13,0x48(%rsp)
mov    %r14d,%r8d
mov    %r15,0x58(%rsp)
mov    %r14,0x98(%rsp)
jmp    127b <housev+0x13b>
mov    0x58(%rsp),%r15
mov    0x98(%rsp),%r14
mov    0x40(%rsp),%r10
mov    0x50(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    0x2c(%rsp),%r8d
mov    0x38(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%r13),%xmm0
mov    0xc0(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mov    0xb8(%rsp),%rax
movsd  %xmm7,(%rax,%rbp,8)
add    $0x1,%rbp
mov    0xe0(%rsp),%rax
add    %rax,%r13
add    $0x1,%rdi
add    $0xffffffff,%r9d
add    %rax,%r10
mov    %r9d,%eax
cmp    0xc8(%rsp),%rbp
je     1c4d <housev+0xb0d>
mov    %r8d,%ecx
mov    %eax,%r9d
lea    -0x1(%rcx),%r8d
mov    %ebp,%edx
not    %edx
add    %r14d,%edx
xorpd  %xmm7,%xmm7
test   %edx,%edx
jle    1230 <housev+0xf0>
mov    %edx,%ebx
mov    %ecx,%edx
lea    -0x1(%rdx),%rcx
add    $0xfffffffffffffffe,%rdx
cmp    $0x3,%rdx
jae    12c0 <housev+0x180>
xorpd  %xmm7,%xmm7
mov    $0x1,%edx
test   $0x3,%cl
jne    131e <housev+0x1de>
jmp    1346 <housev+0x206>
nopl   0x0(%rax)
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
xorpd  %xmm7,%xmm7
xor    %edx,%edx
nopl   (%rax)
movsd  0x8(%r13,%rdx,8),%xmm0
movsd  0x10(%r13,%rdx,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm7,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x18(%r13,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x20(%r13,%rdx,8),%xmm7
mulsd  %xmm7,%xmm7
addsd  %xmm0,%xmm7
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    12d0 <housev+0x190>
add    $0x1,%rdx
test   $0x3,%cl
je     1346 <housev+0x206>
and    $0x3,%eax
lea    0x0(,%rdx,8),%rcx
add    %r13,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm7
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1330 <housev+0x1f0>
ucomisd %xmm8,%xmm7
jbe    1230 <housev+0xf0>
mov    %r9,0x38(%rsp)
mov    %r8d,0x2c(%rsp)
mov    %rbp,0x70(%rsp)
mov    %rdi,0x50(%rsp)
mov    %r10,0x40(%rsp)
cvttsd2si %xmm7,%edi
call   1060 <sqrt@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x8(%r13),%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
movapd %xmm1,0x80(%rsp)
jbe    13c1 <housev+0x281>
subsd  %xmm1,%xmm2
movapd %xmm1,%xmm0
mulsd  0x1c6d(%rip),%xmm0
movsd  %xmm2,0x8(%rsp)
mulsd  %xmm2,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movapd 0x80(%rsp),%xmm7
jmp    13f1 <housev+0x2b1>
addsd  %xmm1,%xmm2
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm2,0x8(%rsp)
mulsd  %xmm2,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movapd 0x80(%rsp),%xmm7
xorpd  0x1c0f(%rip),%xmm7
test   %ebx,%ebx
mov    0x40(%rsp),%r10
mov    0x50(%rsp),%rdi
mov    0x70(%rsp),%rbp
xorpd  %xmm8,%xmm8
xorpd  %xmm4,%xmm4
mov    0x2c(%rsp),%r8d
mov    0x38(%rsp),%r9
jle    1230 <housev+0xf0>
mov    0xb4(%rsp),%ecx
mov    %ecx,%esi
sub    %ebp,%esi
mov    %rbp,%rcx
imul   0x78(%rsp),%rcx
mov    %rcx,%r11
mov    0x48(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
add    $0x8,%rcx
mov    %rcx,(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x1bc6(%rip),%xmm0
divsd  %xmm1,%xmm0
movq   $0x0,(%r12)
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13)
cmp    $0x1,%r8d
mov    %rsi,0x20(%rsp)
je     1636 <housev+0x4f6>
lea    -0x1(%rsi),%rax
mov    $0x1,%ecx
cmp    $0x4,%rax
jb     15c1 <housev+0x481>
mov    (%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
cmp    %rdx,0xd0(%rsp)
jae    14c1 <housev+0x381>
lea    (%r12,%rsi,8),%rdx
mov    0x48(%rsp),%rsi
lea    (%rsi,%r11,8),%rsi
add    $0x10,%rsi
cmp    %rdx,%rsi
mov    0x20(%rsp),%rsi
jb     15c1 <housev+0x481>
lea    -0x5(%rsi),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%rcx
jae    14e5 <housev+0x3a5>
xor    %esi,%esi
jmp    156e <housev+0x42e>
lea    -0x5(%r9),%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd %xmm4,0x8(%r12,%rsi,8)
movupd %xmm4,0x18(%r12,%rsi,8)
movupd 0x10(%r13,%rsi,8),%xmm2
movupd 0x20(%r13,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x10(%r13,%rsi,8)
movupd %xmm3,0x20(%r13,%rsi,8)
movupd %xmm4,0x28(%r12,%rsi,8)
movupd %xmm4,0x38(%r12,%rsi,8)
movupd 0x30(%r13,%rsi,8),%xmm2
movupd 0x40(%r13,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x30(%r13,%rsi,8)
movupd %xmm3,0x40(%r13,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1500 <housev+0x3c0>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x1,%dl
je     15b3 <housev+0x473>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd %xmm4,(%r12,%rsi,1)
movupd %xmm4,0x10(%r12,%rsi,1)
movupd 0x8(%r13,%rsi,1),%xmm2
movupd 0x18(%r13,%rsi,1),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x8(%r13,%rsi,1)
movupd %xmm3,0x18(%r13,%rsi,1)
cmp    %rcx,%rax
mov    0x20(%rsp),%rsi
je     162e <housev+0x4ee>
or     $0x1,%rcx
mov    %rcx,%rax
test   $0x1,%sil
jne    15e8 <housev+0x4a8>
movq   $0x0,(%r12,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
add    %rsi,%rcx
je     162e <housev+0x4ee>
movq   $0x0,(%r12,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movq   $0x0,0x8(%r12,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    15f0 <housev+0x4b0>
test   %ebx,%ebx
jle    1230 <housev+0xf0>
and    $0xfffffffc,%r9d
add    $0xfffffffffffffffc,%r9
mov    %esi,%eax
and    $0xfffffffc,%eax
shr    $0x2,%r9
add    $0xfffffffffffffffc,%rax
add    $0x1,%r9
mov    %rax,0x60(%rsp)
shr    $0x2,%rax
and    $0xfffffffffffffffe,%r9
mov    %r9,0x18(%rsp)
add    $0x1,%rax
mov    %rax,0x68(%rsp)
lea    0x2(%r11),%rax
mov    %rax,0xa0(%rsp)
add    $0x1,%r11
mov    %r11,0xa8(%rsp)
lea    (%r12,%rsi,8),%rax
mov    %rax,0x10(%rsp)
mov    (%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,0x30(%rsp)
lea    0x8(%r13,%r15,8),%r15
mov    %ebx,%esi
mov    %ebx,%eax
mov    %rax,0x8(%rsp)
mov    %r8d,%eax
mov    %rax,0x80(%rsp)
xorpd  %xmm0,%xmm0
mov    $0x1,%r8d
mov    %r12,%rbp
mov    %rdi,%rcx
xor    %edi,%edi
mov    %r15,%r9
jmp    170a <housev+0x5ca>
nopl   0x0(%rax,%rax,1)
mov    %rax,%r9
movsd  (%r12,%rdi,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
lea    (%r9,%rcx,8),%r9
add    $0x8,%r9
add    $0x1,%rcx
add    $0x1,%r8
add    $0x8,%r10
add    $0x8,%rbp
mov    %r11,%rdi
cmp    0x80(%rsp),%r11
je     17c8 <housev+0x688>
movsd  0x8(%r13,%rdi,8),%xmm1
movsd  (%r9),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r12,%rdi,8),%xmm2
movsd  %xmm2,(%r12,%rdi,8)
lea    0x1(%rdi),%r11
cmp    0x8(%rsp),%r11
jae    16d9 <housev+0x599>
movsd  0x8(%r13,%r8,8),%xmm3
mulsd  0x8(%r9),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r12,%rdi,8)
movsd  0x8(%r9),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r12,%r8,8),%xmm2
lea    0x8(%r9),%rax
movsd  %xmm2,(%r12,%r8,8)
lea    0x1(%r8),%edx
cmp    %edx,%esi
jle    16d0 <housev+0x590>
mov    $0x2,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x10(%r10,%rdx,8),%xmm2
mulsd  0x8(%rax),%xmm2
lea    0x8(%rax),%r9
addsd  (%r12,%rdi,8),%xmm2
movsd  %xmm2,(%r12,%rdi,8)
movsd  0x8(%rax),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
add    $0x1,%rdx
lea    (%rdx,%rdi,1),%r14d
mov    %r9,%rax
cmp    %r14d,%ebx
mov    %ebx,%esi
jg     1780 <housev+0x640>
jmp    16d3 <housev+0x593>
test   %esi,%esi
jle    11fd <housev+0xbd>
xorpd  0x1828(%rip),%xmm0
cmpl   $0x4,0x20(%rsp)
mov    0x38(%rsp),%r9
jb     17fe <housev+0x6be>
cmp    0x30(%rsp),%r12
jae    1886 <housev+0x746>
mov    0x10(%rsp),%rax
cmp    %rax,(%rsp)
jae    1886 <housev+0x746>
xor    %ecx,%ecx
mov    0x40(%rsp),%r10
mov    %rcx,%rax
testb  $0x1,0x20(%rsp)
je     1831 <housev+0x6f1>
movsd  0x8(%r13,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
add    0x20(%rsp),%rcx
je     199e <housev+0x85e>
nop
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1840 <housev+0x700>
jmp    199e <housev+0x85e>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x60(%rsp)
mov    0x40(%rsp),%r10
je     1942 <housev+0x802>
xor    %eax,%eax
mov    0x18(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movupd 0x8(%r13,%rax,8),%xmm2
movupd 0x18(%r13,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r12,%rax,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r12,%rax,8),%xmm2
movupd 0x20(%r12,%rax,8),%xmm5
movupd 0x30(%r12,%rax,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
addpd  %xmm4,%xmm4
addpd  %xmm3,%xmm3
movupd %xmm4,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
movupd 0x28(%r13,%rax,8),%xmm2
movupd 0x38(%r13,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm3,%xmm3
movupd %xmm2,0x20(%r12,%rax,8)
movupd %xmm3,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    18b0 <housev+0x770>
jmp    1944 <housev+0x804>
xor    %eax,%eax
mov    0x20(%rsp),%rdx
mov    %edx,%ecx
and    $0xfffffffc,%ecx
testb  $0x1,0x68(%rsp)
je     1995 <housev+0x855>
movupd 0x8(%r13,%rax,8),%xmm2
movupd 0x18(%r13,%rax,8),%xmm3
movupd (%r12,%rax,8),%xmm4
movupd 0x10(%r12,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm3,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
cmp    %rdx,%rcx
jne    1805 <housev+0x6c5>
test   %esi,%esi
jle    1c21 <housev+0xae1>
mov    $0x1,%r11d
mov    %r10,%rcx
mov    0xd8(%rsp),%rdi
xor    %r9d,%r9d
mov    0x50(%rsp),%rbx
xor    %r8d,%r8d
mov    0x8(%rsp),%rsi
jmp    19f9 <housev+0x8b9>
nopl   0x0(%rax)
lea    (%r14,%rbx,8),%r15
add    $0x1,%rbx
add    $0x1,%r11
add    $0xffffffffffffffff,%r9
add    $0x8,%rdi
add    $0x8,%rcx
mov    %rdx,%r8
cmp    0x80(%rsp),%rdx
je     11fd <housev+0xbd>
mov    %rbx,(%rsp)
mov    0x38(%rsp),%rbp
cmp    %rbp,%r11
cmova  %r11,%rbp
lea    0x1(%r8),%rdx
mov    0x20(%rsp),%rax
cmp    %rax,%rdx
mov    %rax,%r10
cmova  %rdx,%r10
sub    %r8,%r10
cmp    %rax,%rdx
cmova  %rdx,%rax
cmp    $0x4,%r10
jae    1a40 <housev+0x900>
mov    %r8,%rax
mov    %r15,%r14
mov    (%rsp),%rbx
jmp    1bd1 <housev+0xa91>
nopl   0x0(%rax,%rax,1)
mov    %r9,0x10(%rsp)
mov    %r11,0x30(%rsp)
mov    %r8,%rbx
not    %rbx
add    %rax,%rbx
mov    0xa8(%rsp),%rsi
add    %r8,%rsi
mov    0x48(%rsp),%r11
lea    (%r11,%rsi,8),%r9
mov    0xa0(%rsp),%rsi
lea    (%rsi,%r8,1),%rsi
lea    (%r11,%rsi,8),%r11
lea    (%r12,%r8,8),%r14
lea    (%r11,%rbx,8),%rsi
mov    %rsi,0x68(%rsp)
mov    %rdx,0x18(%rsp)
lea    (%r12,%rdx,8),%rdx
mov    %rdx,0x60(%rsp)
lea    (%r12,%rax,8),%rax
lea    (%r15,%rbx,8),%rdx
add    $0x8,%rdx
cmp    %r11,%r15
setb   %sil
cmp    %rdx,%r9
setb   %bl
cmp    %rax,%r15
setb   %r11b
cmp    %rdx,%r14
setb   %al
cmp    0x60(%rsp),%r15
setb   %r9b
cmp    0x68(%rsp),%r15
setb   %r14b
test   %bl,%sil
jne    1bb3 <housev+0xa73>
and    %al,%r11b
jne    1bb3 <housev+0xa73>
and    %al,%r9b
mov    0x8(%rsp),%rsi
mov    0x30(%rsp),%r11
jne    1bab <housev+0xa6b>
and    %bl,%r14b
jne    1bab <housev+0xa6b>
add    0x10(%rsp),%rbp
and    $0xfffffffffffffffc,%rbp
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
lea    (%r8,%rdx,1),%rax
lea    (%r15,%rdx,8),%r14
movsd  0x8(%r13,%r8,8),%xmm0
unpcklpd %xmm0,%xmm0
movsd  (%r12,%r8,8),%xmm1
unpcklpd %xmm1,%xmm1
xor    %r11d,%r11d
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%r11,8),%xmm2
movupd (%rdi,%r11,8),%xmm3
movupd -0x10(%rcx,%r11,8),%xmm4
movupd (%rcx,%r11,8),%xmm5
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm0,%xmm3
addpd  %xmm5,%xmm3
movupd (%r15,%r11,8),%xmm4
subpd  %xmm2,%xmm4
movupd 0x10(%r15,%r11,8),%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,(%r15,%r11,8)
movupd %xmm2,0x10(%r15,%r11,8)
add    $0x4,%r11
cmp    %r11,%rbp
jne    1b30 <housev+0x9f0>
cmp    %rdx,%r10
mov    0x30(%rsp),%r11
mov    0x10(%rsp),%r9
mov    (%rsp),%rbx
mov    0x18(%rsp),%rdx
je     19d0 <housev+0x890>
jmp    1bd1 <housev+0xa91>
mov    %r8,%rax
mov    %r15,%r14
jmp    1bc3 <housev+0xa83>
mov    %r8,%rax
mov    %r15,%r14
mov    0x8(%rsp),%rsi
mov    0x30(%rsp),%r11
mov    0x10(%rsp),%r9
mov    (%rsp),%rbx
mov    0x18(%rsp),%rdx
mov    %r14,%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x8(%r13,%r8,8),%xmm0
movsd  (%r12,%r8,8),%xmm1
mulsd  0x8(%r13,%rax,8),%xmm1
mulsd  (%r12,%rax,8),%xmm0
addsd  %xmm1,%xmm0
lea    0x8(%rbp),%r14
movsd  0x0(%rbp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp)
add    $0x1,%rax
mov    %r14,%rbp
cmp    %rsi,%rax
jb     1be0 <housev+0xaa0>
jmp    19d0 <housev+0x890>
mov    0x58(%rsp),%r15
mov    0x98(%rsp),%r14
mov    0x50(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    0x2c(%rsp),%r8d
jmp    1230 <housev+0xf0>
lea    0x1(%r14),%eax
movslq %eax,%rbp
xor    %eax,%eax
jmp    1c59 <housev+0xb19>
mov    0xb0(%rsp),%eax
mov    0x78(%rsp),%rbp
movsd  0x0(%r13),%xmm0
mov    %eax,%eax
mov    0xc0(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x8(%r13),%xmm0
mov    0xb8(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
mov    %r12,%rdi
call   1030 <free@plt>
test   %r14d,%r14d
jle    1cc9 <housev+0xb89>
lea    (%r14,%r14,1),%eax
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
lea    -0x1(%rdx),%eax
mov    %rbp,%rcx
sub    %rax,%rcx
lea    0x0(,%rcx,8),%rdi
add    %r13,%rdi
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%rsi
mov    %rsi,0x0(%r13,%rbp,8)
mov    %r13,0x48(%rsp)
mov    %rsi,0x0(%r13)
cmp    $0x3,%r14d
jl     2105 <housev+0xfc5>
mov    %rbp,%rdx
movslq %r14d,%rdi
lea    0x0(,%rdi,8),%rax
mov    0x48(%rsp),%r10
mov    %r10,%rbp
mov    %rax,0x80(%rsp)
sub    %rax,%rbp
add    $0xffffffff,%r14d
add    %rdi,%r14
mov    $0x1,%eax
sub    %r14,%rax
lea    (%r10,%rax,8),%rax
mov    %rax,0x18(%rsp)
shl    $0x3,%rdx
mov    $0x8,%eax
sub    %rdx,%rax
mov    %rax,0xa8(%rsp)
neg    %rdx
mov    %rdx,0x78(%rsp)
shl    $0x3,%r15
mov    $0x2,%r13d
mov    $0x2,%eax
mov    %rdi,0x38(%rsp)
sub    %rdi,%rax
lea    (%r10,%rax,8),%rax
mov    %rax,0xa0(%rsp)
xor    %r14d,%r14d
mov    %r15,0x58(%rsp)
jmp    1db9 <housev+0xc79>
nopl   (%rax)
mov    0x60(%rsp),%rdi
xor    %esi,%esi
mov    0x58(%rsp),%rdx
call   1040 <memset@plt>
mov    0x78(%rsp),%rax
movabs $0x3ff0000000000000,%rsi
mov    0x68(%rsp),%r10
mov    %rsi,(%r10,%rax,1)
add    %rax,%r10
add    $0x1,%r13
add    %rax,%rbp
mov    0x8(%rsp),%rax
mov    %rax,%r14
cmp    0xc8(%rsp),%rax
je     2105 <housev+0xfc5>
mov    %r13d,%r15d
and    $0x3,%r15d
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x10(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x8(%rsp)
mov    %r13,%r8
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%r8
lea    -0x4(%r8),%rax
mov    %rax,0x20(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x30(%rsp)
mov    0xa8(%rsp),%r11
imul   %r14,%r11
mov    0xa0(%rsp),%rax
add    %r11,%rax
mov    %rax,(%rsp)
mov    0x18(%rsp),%rax
add    %r11,%rax
mov    %rax,0x60(%rsp)
mov    %rsi,(%r10)
mov    %r10,0x68(%rsp)
xor    %r9d,%r9d
jmp    1e58 <housev+0xd18>
add    $0x1,%r9
add    0x80(%rsp),%r10
mov    %r9d,%eax
cmp    %rax,%r13
je     1d70 <housev+0xc30>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    %r10,%r12
cmp    $0x2,%r14
jb     1ec0 <housev+0xd80>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  (%r12),%xmm1
movsd  0x8(%rbp,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x8(%r12),%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%rbp,%rsi,8),%xmm1
mulsd  0x10(%r12),%xmm1
addsd  %xmm2,%xmm1
movsd  0x18(%rbp,%rsi,8),%xmm0
mulsd  0x18(%r12),%xmm0
add    $0x4,%rsi
add    $0x20,%r12
addsd  %xmm1,%xmm0
cmp    %rsi,%rdx
jne    1e70 <housev+0xd30>
test   $0x3,%r13b
je     1ef8 <housev+0xdb8>
lea    0x0(,%rsi,8),%rax
add    %rbp,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm1
mulsd  (%r12,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1ee0 <housev+0xda0>
addsd  %xmm0,%xmm0
xorpd  0x10fc(%rip),%xmm0
cmp    $0x4,%r13
jb     1f36 <housev+0xdf6>
cmp    %r10,(%rsp)
jbe    2010 <housev+0xed0>
mov    %r9,%rax
imul   0x38(%rsp),%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
add    %r11,%rax
add    $0x10,%rax
cmp    %rbp,%rax
jbe    2010 <housev+0xed0>
xor    %ebx,%ebx
mov    %r10,%rdi
mov    0x8(%rsp),%rax
sub    %rbx,%rax
test   $0x3,%r13b
je     1f80 <housev+0xe40>
mov    %r15,%rcx
nopl   0x0(%rax)
lea    0x8(%rdi),%rsi
movsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
add    $0x1,%rbx
addsd  (%rdi),%xmm1
movsd  %xmm1,(%rdi)
mov    %rsi,%rdi
add    $0xffffffffffffffff,%rcx
jne    1f50 <housev+0xe10>
cmp    $0x3,%rax
jb     1e40 <housev+0xd00>
jmp    1f8d <housev+0xe4d>
nop
mov    %rdi,%rsi
cmp    $0x3,%rax
jb     1e40 <housev+0xd00>
mov    %r13,%rax
sub    %rbx,%rax
lea    0x0(,%rbx,8),%rdi
add    %rbp,%rdi
xor    %ebx,%ebx
movsd  (%rdi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rbx,8),%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  0x8(%rdi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rbx,8)
movsd  0x10(%rdi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x10(%rsi,%rbx,8)
movsd  0x18(%rdi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x18(%rsi,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1fa0 <housev+0xe60>
jmp    1e40 <housev+0xd00>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x20(%rsp)
je     20fa <housev+0xfba>
mov    0x10(%rsp),%rbx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rsi,8),%xmm2
movupd 0x10(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r10,%rsi,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r10,%rsi,8),%xmm2
movupd 0x20(%r10,%rsi,8),%xmm5
movupd 0x30(%r10,%rsi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r10,%rsi,8)
movupd %xmm3,0x10(%r10,%rsi,8)
movupd 0x20(%rbp,%rsi,8),%xmm2
movupd 0x30(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r10,%rsi,8)
movupd %xmm3,0x30(%r10,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbx
jne    2030 <housev+0xef0>
testb  $0x1,0x30(%rsp)
je     20e5 <housev+0xfa5>
movupd 0x0(%rbp,%rsi,8),%xmm2
movupd 0x10(%rbp,%rsi,8),%xmm3
movupd (%r10,%rsi,8),%xmm4
movupd 0x10(%r10,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r10,%rsi,8)
movupd %xmm3,0x10(%r10,%rsi,8)
cmp    %r8,%r13
je     1e40 <housev+0xd00>
lea    (%r10,%r8,8),%rdi
mov    %r8,%rbx
jmp    1f3b <housev+0xdfb>
xor    %esi,%esi
testb  $0x1,0x30(%rsp)
jne    20af <housev+0xf6f>
jmp    20e5 <housev+0xfa5>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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