#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 house(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(2 * n, sizeof(double));
  for (j = 0, qw = qs + n, pc = a; j < n; pc += n + 1)
    qw[j++] = *pc;
  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);
  for (j = 0, pc = a, qw = qs + n; j < n; ++j, pc += n + 1) {
    *pc = qw[j];
    for (i = 1, p = pc + n; i < n - j; p += n)
      pc[i++] = *p;
  }
  free(qs);
}


x86 assembly (clang, -O0):
<house>:
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
shl    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11c8 <house+0x98>
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x48(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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    1180 <house+0x50>
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    16a8 <house+0x578>
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     1249 <house+0x119>
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    1203 <house+0xd3>
movsd  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    165b <house+0x52b>
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    12cd <house+0x19d>
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd70(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd41(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    132d <house+0x1fd>
movsd  -0x30(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd24(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
cvtsi2sd %eax,%xmm1
movsd  0xcfd(%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    13ac <house+0x27c>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x44(%rbp)
je     1382 <house+0x252>
movsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1399 <house+0x269>
movsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    139e <house+0x26e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1340 <house+0x210>
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    14f9 <house+0x3c9>
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    14aa <house+0x37a>
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    142f <house+0x2ff>
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    13db <house+0x2ab>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    157c <house+0x44c>
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    1500 <house+0x3d0>
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    1656 <house+0x526>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1626 <house+0x4f6>
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    15b5 <house+0x485>
jmp    162b <house+0x4fb>
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    15a3 <house+0x473>
jmp    165b <house+0x52b>
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    11d7 <house+0xa7>
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    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    17c5 <house+0x695>
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x48(%rbp),%ecx
cmp    %ecx,%eax
jge    179a <house+0x66a>
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    1750 <house+0x620>
jmp    179f <house+0x66f>
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    1715 <house+0x5e5>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<house>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%r14d
mov    %rdx,0x20(%rsp)
mov    %rsi,%r12
mov    %rdi,%rbp
lea    (%r14,%r14,1),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r13
movslq %r14d,%rcx
mov    %r14d,%esi
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
test   %ecx,%ecx
mov    %r14,0x80(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rsi,%rax
mov    %rsi,0xb8(%rsp)
jle    11a7 <house+0x77>
lea    0x1(%r14),%r9d
lea    -0x1(%rsi),%rcx
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11b9 <house+0x89>
xor    %edx,%edx
mov    %rbp,%rdi
jmp    122b <house+0xfb>
xor    %eax,%eax
mov    %rbp,%r15
mov    0x20(%rsp),%rbx
mov    %r12,%r8
jmp    1e01 <house+0xcd1>
and    $0xfffffffc,%esi
mov    %rbp,%rcx
mov    0x38(%rsp),%rdx
lea    0x18(,%rdx,8),%rbp
add    %r13,%rbp
mov    %r9,%r8
shl    $0x5,%r8
lea    0x0(,%r9,8),%rbx
xor    %edx,%edx
mov    %rcx,%rdi
movsd  (%rcx),%xmm0
movsd  %xmm0,-0x18(%rbp,%rdx,8)
add    %rbx,%rcx
movsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,-0x10(%rbp,%rdx,8)
movsd  (%rbx,%rcx,1),%xmm0
add    %rbx,%rcx
movsd  %xmm0,-0x8(%rbp,%rdx,8)
movsd  (%rbx,%rcx,1),%xmm0
add    %rbx,%rcx
movsd  %xmm0,0x0(%rbp,%rdx,8)
add    $0x4,%rdx
add    %rbx,%rcx
cmp    %rdx,%rsi
jne    11e0 <house+0xb0>
add    %r8,%rdi
mov    0x58(%rsp),%rbp
mov    0x20(%rsp),%rbx
mov    %r12,%r8
test   %rax,%rax
je     1275 <house+0x145>
add    0x38(%rsp),%rdx
lea    0x0(,%rdx,8),%rcx
add    %r13,%rcx
lea    0x0(,%r9,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    %rdx,%rdi
cmp    %rsi,%rax
jne    1260 <house+0x130>
mov    %r9,0xe0(%rsp)
xor    %eax,%eax
mov    %rbp,%r15
cmp    $0x3,%r14d
jl     1e01 <house+0xcd1>
lea    -0x2(%r14),%eax
mov    %eax,0xc8(%rsp)
mov    %eax,%r9d
lea    -0x1(%r14),%ecx
lea    0x8(%r13),%rax
mov    %rax,0xd0(%rsp)
mov    0xb8(%rsp),%rax
lea    0x8(,%rax,8),%r10
lea    0x18(%rbp),%rdi
lea    0x10(%r13),%rax
mov    %rax,0xd8(%rsp)
mov    $0x2,%r11d
xor    %r12d,%r12d
xorpd  %xmm8,%xmm8
mov    %ecx,0xcc(%rsp)
mov    %ecx,%eax
mov    %rbp,%r15
mov    %r14d,%edx
mov    %r8,0x98(%rsp)
mov    %r9,0xa8(%rsp)
mov    %r10,0xa0(%rsp)
jmp    136b <house+0x23b>
mov    0x80(%rsp),%r14
mov    0x98(%rsp),%r8
mov    0x20(%rsp),%rbx
mov    0xa8(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%r11
mov    0xb0(%rsp),%r12
mov    0x18(%rsp),%edx
movsd  (%r15),%xmm0
movsd  %xmm0,(%r8,%r12,8)
movsd  %xmm7,(%rbx,%r12,8)
add    $0x1,%r12
add    %r10,%r15
add    $0x1,%r11
mov    (%rsp),%rax
add    $0xffffffff,%eax
add    %r10,%rdi
cmp    %r9,%r12
je     1df5 <house+0xcc5>
mov    %edx,%ecx
mov    %eax,%edx
mov    %rdx,(%rsp)
lea    -0x1(%rcx),%edx
mov    %r12d,%ebp
not    %ebp
add    %r14d,%ebp
xorpd  %xmm7,%xmm7
test   %ebp,%ebp
jle    133c <house+0x20c>
mov    %edx,0x18(%rsp)
mov    %ecx,%edx
lea    -0x1(%rdx),%rcx
add    $0xfffffffffffffffe,%rdx
cmp    $0x3,%rdx
jae    13b0 <house+0x280>
xorpd  %xmm7,%xmm7
mov    $0x1,%edx
test   $0x3,%cl
jne    140e <house+0x2de>
jmp    1436 <house+0x306>
nopl   (%rax)
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
xorpd  %xmm7,%xmm7
xor    %edx,%edx
nopl   (%rax)
movsd  0x8(%r15,%rdx,8),%xmm0
movsd  0x10(%r15,%rdx,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm7,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x18(%r15,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x20(%r15,%rdx,8),%xmm7
mulsd  %xmm7,%xmm7
addsd  %xmm0,%xmm7
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    13c0 <house+0x290>
add    $0x1,%rdx
test   $0x3,%cl
je     1436 <house+0x306>
and    $0x3,%eax
lea    (%r15,%rdx,8),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm7
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1420 <house+0x2f0>
ucomisd %xmm8,%xmm7
jbe    1338 <house+0x208>
mov    %r8,%r14
mov    %r12,0xb0(%rsp)
mov    %r11,0x70(%rsp)
mov    %rdi,0x78(%rsp)
cvttsd2si %xmm7,%edi
call   1050 <sqrt@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x8(%r15),%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
movapd %xmm1,0x60(%rsp)
jbe    14a7 <house+0x377>
subsd  %xmm1,%xmm2
movapd %xmm1,%xmm0
mulsd  0x1b84(%rip),%xmm0
movsd  %xmm2,0x8(%rsp)
mulsd  %xmm2,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
movapd 0x60(%rsp),%xmm7
jmp    14d4 <house+0x3a4>
addsd  %xmm1,%xmm2
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm2,0x8(%rsp)
mulsd  %xmm2,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
movapd 0x60(%rsp),%xmm7
xorpd  0x1b2c(%rip),%xmm7
test   %ebp,%ebp
mov    0x20(%rsp),%rbx
mov    0xa8(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%r11
mov    0xb0(%rsp),%r12
xorpd  %xmm8,%xmm8
xorpd  %xmm4,%xmm4
mov    0x18(%rsp),%edx
jle    15fb <house+0x4cb>
mov    0xcc(%rsp),%ecx
mov    %ecx,%esi
sub    %r12d,%esi
mov    %r12,%rbx
imul   0xe0(%rsp),%rbx
mov    0x58(%rsp),%rcx
mov    %rbx,0x40(%rsp)
lea    (%rcx,%rbx,8),%rbx
add    $0x8,%rbx
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x1acf(%rip),%xmm0
divsd  %xmm1,%xmm0
movq   $0x0,0x0(%r13)
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15)
cmp    $0x1,%edx
mov    %rsi,0x10(%rsp)
mov    0x80(%rsp),%r14
je     1777 <house+0x647>
lea    -0x1(%rsi),%rax
mov    $0x1,%ecx
cmp    $0x4,%rax
jb     16f6 <house+0x5c6>
lea    (%rbx,%rsi,8),%rdx
cmp    %rdx,0xd0(%rsp)
jae    15d7 <house+0x4a7>
lea    0x0(,%rsi,8),%rdx
add    %r13,%rdx
mov    0x58(%rsp),%rsi
mov    %rax,0x60(%rsp)
mov    %rbx,%rax
mov    0x40(%rsp),%rbx
lea    (%rsi,%rbx,8),%rsi
add    $0x10,%rsi
mov    %rax,%rbx
mov    0x60(%rsp),%rax
cmp    %rdx,%rsi
mov    0x10(%rsp),%rsi
jb     16f6 <house+0x5c6>
lea    -0x5(%rsi),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%rcx
jae    160b <house+0x4db>
xor    %esi,%esi
jmp    169e <house+0x56e>
mov    %r14,%r8
mov    0x80(%rsp),%r14
jmp    133c <house+0x20c>
mov    (%rsp),%rcx
add    $0xfffffffffffffffb,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd %xmm4,0x8(%r13,%rsi,8)
movupd %xmm4,0x18(%r13,%rsi,8)
movupd 0x10(%r15,%rsi,8),%xmm2
movupd 0x20(%r15,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x10(%r15,%rsi,8)
movupd %xmm3,0x20(%r15,%rsi,8)
movupd %xmm4,0x28(%r13,%rsi,8)
movupd %xmm4,0x38(%r13,%rsi,8)
movupd 0x30(%r15,%rsi,8),%xmm2
movupd 0x40(%r15,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x30(%r15,%rsi,8)
movupd %xmm3,0x40(%r15,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1630 <house+0x500>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x1,%dl
je     16e4 <house+0x5b4>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd %xmm4,0x0(%r13,%rsi,1)
movupd %xmm4,0x10(%r13,%rsi,1)
movupd 0x8(%r15,%rsi,1),%xmm2
movupd 0x18(%r15,%rsi,1),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x8(%r15,%rsi,1)
movupd %xmm3,0x18(%r15,%rsi,1)
cmp    %rcx,%rax
mov    0x18(%rsp),%edx
mov    0x10(%rsp),%rsi
je     176f <house+0x63f>
or     $0x1,%rcx
mov    %rcx,%rax
test   $0x1,%sil
mov    0x18(%rsp),%edx
jne    1722 <house+0x5f2>
movq   $0x0,0x0(%r13,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
add    %rsi,%rcx
mov    (%rsp),%rcx
je     176f <house+0x63f>
xchg   %ax,%ax
movq   $0x0,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
movq   $0x0,0x8(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1730 <house+0x600>
test   %ebp,%ebp
jle    19e8 <house+0x8b8>
mov    (%rsp),%rax
and    $0xfffffffc,%eax
add    $0xfffffffffffffffc,%rax
mov    %esi,%ecx
and    $0xfffffffc,%ecx
shr    $0x2,%rax
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rax
mov    %rcx,0x50(%rsp)
shr    $0x2,%rcx
and    $0xfffffffffffffffe,%rax
mov    %rax,0x90(%rsp)
add    $0x1,%rcx
mov    %rcx,0x48(%rsp)
mov    0x40(%rsp),%rax
lea    0x2(%rax),%rcx
mov    %rcx,0xc0(%rsp)
add    $0x1,%rax
mov    %rax,0x40(%rsp)
lea    0x0(,%rsi,8),%rax
add    %r13,%rax
mov    %rax,0x28(%rsp)
mov    %rbx,0x30(%rsp)
lea    (%rbx,%rsi,8),%rax
mov    %rax,0x8(%rsp)
mov    0x38(%rsp),%rax
lea    0x8(%r15,%rax,8),%r12
mov    %ebp,%esi
mov    %edx,%eax
mov    %rax,0x60(%rsp)
xorpd  %xmm0,%xmm0
mov    $0x1,%r10d
mov    %r13,%rbx
mov    %rdi,%r14
xor    %edi,%edi
mov    %r11,%rcx
mov    %r12,%rdx
jmp    1858 <house+0x728>
cs nopw 0x0(%rax,%rax,1)
mov    %rax,%rdx
movsd  0x0(%r13,%rdi,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
lea    (%rdx,%rcx,8),%rdx
add    $0x8,%rdx
add    $0x1,%rcx
add    $0x1,%r10
add    $0x8,%r14
add    $0x8,%rbx
mov    %r11,%rdi
cmp    0x60(%rsp),%r11
je     1918 <house+0x7e8>
movsd  0x8(%r15,%rdi,8),%xmm1
movsd  (%rdx),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rdi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rdi,8)
lea    0x1(%rdi),%r11
cmp    %rsi,%r11
jae    182a <house+0x6fa>
movsd  0x8(%r15,%r10,8),%xmm3
mulsd  0x8(%rdx),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rdi,8)
movsd  0x8(%rdx),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%r10,8),%xmm2
lea    0x8(%rdx),%rax
movsd  %xmm2,0x0(%r13,%r10,8)
lea    0x1(%r10),%edx
cmp    %edx,%ebp
jle    1820 <house+0x6f0>
mov    $0x2,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x10(%r14,%r9,8),%xmm2
mulsd  0x8(%rax),%xmm2
lea    0x8(%rax),%rdx
addsd  0x0(%r13,%rdi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rdi,8)
movsd  0x8(%rax),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rbx,%r9,8),%xmm2
movsd  %xmm2,(%rbx,%r9,8)
add    $0x1,%r9
lea    (%r9,%rdi,1),%r8d
mov    %rdx,%rax
cmp    %r8d,%ebp
jg     18d0 <house+0x7a0>
jmp    1823 <house+0x6f3>
test   %ebp,%ebp
mov    0x80(%rsp),%r14
jle    1309 <house+0x1d9>
xorpd  0x16d0(%rip),%xmm0
cmpl   $0x4,0x10(%rsp)
mov    0x18(%rsp),%edx
jb     1956 <house+0x826>
cmp    0x8(%rsp),%r13
jae    19fa <house+0x8ca>
mov    0x28(%rsp),%rax
cmp    %rax,0x30(%rsp)
jae    19fa <house+0x8ca>
xor    %ecx,%ecx
mov    (%rsp),%rdi
mov    %rcx,%rax
testb  $0x1,0x10(%rsp)
je     198a <house+0x85a>
movsd  0x8(%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
add    0x10(%rsp),%rcx
je     1b26 <house+0x9f6>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r13,%rax,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    19a0 <house+0x870>
jmp    1b26 <house+0x9f6>
mov    0x20(%rsp),%rbx
mov    0x98(%rsp),%r8
jmp    133c <house+0x20c>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x50(%rsp)
mov    (%rsp),%rdi
je     1ac4 <house+0x994>
xor    %eax,%eax
mov    0x90(%rsp),%rcx
mov    0x48(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r15,%rax,8),%xmm2
movupd 0x18(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd 0x0(%r13,%rax,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r13,%rax,8),%xmm2
movupd 0x20(%r13,%rax,8),%xmm5
movupd 0x30(%r13,%rax,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
addpd  %xmm4,%xmm4
addpd  %xmm3,%xmm3
movupd %xmm4,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x28(%r15,%rax,8),%xmm2
movupd 0x38(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm3,%xmm3
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm3,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1a30 <house+0x900>
jmp    1acb <house+0x99b>
xor    %eax,%eax
mov    0x48(%rsp),%r8
mov    0x10(%rsp),%rbx
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
test   $0x1,%r8b
je     1b1d <house+0x9ed>
movupd 0x8(%r15,%rax,8),%xmm2
movupd 0x18(%r15,%rax,8),%xmm3
movupd 0x0(%r13,%rax,8),%xmm4
movupd 0x10(%r13,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm3,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
cmp    %rbx,%rcx
jne    195c <house+0x82c>
test   %ebp,%ebp
jle    1dc1 <house+0xc91>
mov    $0x1,%r11d
mov    0x78(%rsp),%rbp
mov    0xd8(%rsp),%rcx
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    0x70(%rsp),%rbx
xor    %r10d,%r10d
jmp    1b88 <house+0xa58>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r8,%rbx,8),%r12
add    $0x1,%rbx
add    $0x1,%r11
addq   $0xffffffffffffffff,0x30(%rsp)
add    $0x8,%rcx
add    $0x8,%rbp
mov    %r14,%r10
cmp    0x60(%rsp),%r14
je     1301 <house+0x1d1>
mov    %rbx,0x8(%rsp)
cmp    %rdi,%r11
mov    %rdi,%rbx
cmova  %r11,%rbx
lea    0x1(%r10),%r14
mov    0x10(%rsp),%rax
cmp    %rax,%r14
mov    %rax,%r9
cmova  %r14,%r9
sub    %r10,%r9
cmp    %rax,%r14
cmova  %r14,%rax
cmp    $0x4,%r9
jae    1bd0 <house+0xaa0>
mov    %r10,%rax
mov    %r12,%r8
mov    0x8(%rsp),%rbx
jmp    1d70 <house+0xc40>
nopw   0x0(%rax,%rax,1)
mov    %r11,0x88(%rsp)
mov    %r10,%rdx
not    %rdx
add    %rax,%rdx
mov    0x40(%rsp),%rdi
add    %r10,%rdi
mov    0x58(%rsp),%r8
lea    (%r8,%rdi,8),%rdi
mov    %rdi,0x90(%rsp)
mov    0xc0(%rsp),%rdi
add    %r10,%rdi
lea    (%r8,%rdi,8),%r11
lea    0x0(%r13,%r10,8),%rdi
mov    %rdi,0x50(%rsp)
lea    (%r11,%rdx,8),%rdi
mov    %rdi,0x28(%rsp)
lea    0x0(,%r14,8),%rdi
add    %r13,%rdi
lea    0x0(,%rax,8),%r8
add    %r13,%r8
lea    (%r12,%rdx,8),%rax
add    $0x8,%rax
cmp    %r11,%r12
setb   0x48(%rsp)
cmp    %rax,0x90(%rsp)
setb   %r11b
cmp    %r8,%r12
setb   %dl
cmp    %rax,0x50(%rsp)
setb   %al
cmp    %rdi,%r12
setb   %dil
cmp    0x28(%rsp),%r12
setb   %r8b
mov    %r11b,0x28(%rsp)
test   %r11b,0x48(%rsp)
jne    1d4f <house+0xc1f>
and    %al,%dl
jne    1d4f <house+0xc1f>
and    %al,%dil
mov    0x88(%rsp),%r11
jne    1d3e <house+0xc0e>
and    0x28(%rsp),%r8b
jne    1d3e <house+0xc0e>
add    0x30(%rsp),%rbx
and    $0xfffffffffffffffc,%rbx
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
lea    (%r10,%rdx,1),%rax
lea    (%r12,%rdx,8),%r8
movsd  0x8(%r15,%r10,8),%xmm0
unpcklpd %xmm0,%xmm0
movsd  0x0(%r13,%r10,8),%xmm1
unpcklpd %xmm1,%xmm1
xor    %edi,%edi
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
movupd -0x10(%rbp,%rdi,8),%xmm4
movupd 0x0(%rbp,%rdi,8),%xmm5
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm0,%xmm3
addpd  %xmm5,%xmm3
movupd (%r12,%rdi,8),%xmm4
subpd  %xmm2,%xmm4
movupd 0x10(%r12,%rdi,8),%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,(%r12,%rdi,8)
movupd %xmm2,0x10(%r12,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbx
jne    1cd0 <house+0xba0>
cmp    %rdx,%r9
mov    (%rsp),%rdi
mov    0x8(%rsp),%rbx
je     1b60 <house+0xa30>
jmp    1d70 <house+0xc40>
mov    %r10,%rax
mov    %r12,%r8
mov    (%rsp),%rdi
mov    0x8(%rsp),%rbx
jmp    1d70 <house+0xc40>
mov    %r10,%rax
mov    %r12,%r8
mov    (%rsp),%rdi
mov    0x8(%rsp),%rbx
mov    0x88(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r15,%r10,8),%xmm0
movsd  0x0(%r13,%r10,8),%xmm1
mulsd  0x8(%r15,%rax,8),%xmm1
mulsd  0x0(%r13,%rax,8),%xmm0
addsd  %xmm1,%xmm0
lea    0x8(%rdx),%r8
movsd  (%rdx),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx)
add    $0x1,%rax
mov    %r8,%rdx
cmp    %rsi,%rax
jb     1d80 <house+0xc50>
jmp    1b60 <house+0xa30>
mov    0x98(%rsp),%r8
mov    0x20(%rsp),%rbx
mov    0xa8(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%r11
mov    0xb0(%rsp),%r12
jmp    133c <house+0x20c>
mov    0x58(%rsp),%rbp
mov    0xc8(%rsp),%eax
movsd  (%r15),%xmm0
mov    %eax,%eax
movsd  %xmm0,(%r8,%rax,8)
movsd  0x8(%r15),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
mov    0x38(%rsp),%rcx
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rax,8)
test   %r14d,%r14d
mov    0xb8(%rsp),%r8
jle    206a <house+0xf3a>
mov    0x38(%rsp),%rax
lea    0x0(,%rax,8),%r9
add    %r13,%r9
lea    0x1(%r8),%r15
lea    0x8(,%r8,8),%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
lea    0x0(,%rax,8),%rdi
lea    (%rdi,%rdi,2),%rcx
mov    %rcx,0x8(%rsp)
mov    %rax,%rcx
shl    $0x4,%rcx
mov    %rcx,(%rsp)
lea    0x0(,%rax,4),%rcx
mov    %rcx,0xc0(%rsp)
lea    0x3(%r14),%edx
mov    $0x20,%r12d
xor    %ecx,%ecx
mov    %rcx,0x30(%rsp)
mov    %rbp,%rcx
mov    %r14d,%ebx
mov    %r14d,0x10(%rsp)
mov    %rax,0x28(%rsp)
mov    %rsi,0x50(%rsp)
xor    %r10d,%r10d
mov    %r9,0x18(%rsp)
mov    %r15,0x40(%rsp)
jmp    1f0d <house+0xddd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
mov    0x48(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %rax,%rcx
add    %rax,%r12
sub    %rax,0x30(%rsp)
add    %rax,0x50(%rsp)
add    %rax,0x8(%rsp)
add    %rax,(%rsp)
add    %r15,0x28(%rsp)
addl   $0xffffffff,0x10(%rsp)
add    $0x3,%dl
cmp    %r8,%r10
je     206a <house+0xf3a>
movzbl %dl,%edx
and    $0x3,%edx
mov    %r14d,%eax
sub    %r10d,%eax
movsd  (%r9,%r10,8),%xmm0
mov    %rcx,0x60(%rsp)
movsd  %xmm0,(%rcx)
cmp    $0x2,%eax
jl     1ed0 <house+0xda0>
lea    -0x1(%rax),%rbx
add    $0xfffffffffffffffe,%rax
mov    $0x1,%r11d
mov    0x60(%rsp),%rcx
cmp    $0x3,%rax
jb     2030 <house+0xf00>
mov    %rbx,0x88(%rsp)
mov    0x10(%rsp),%r14d
add    $0xffffffffffffffff,%r14
and    $0xfffffffffffffffc,%r14
mov    $0xffffffffffffffff,%r11
mov    0x28(%rsp),%r8
mov    (%rsp),%rax
mov    0x8(%rsp),%r15
mov    0x50(%rsp),%r9
mov    0x30(%rsp),%rbx
mov    %r12,0x90(%rsp)
mov    %r12,%rcx
mov    0xc0(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r8,8),%xmm0
movsd  %xmm0,-0x18(%rbp,%rcx,1)
movsd  0x0(%rbp,%rax,1),%xmm0
movsd  %xmm0,-0x10(%rbp,%rcx,1)
movsd  0x0(%rbp,%r15,1),%xmm0
movsd  %xmm0,-0x8(%rbp,%rcx,1)
movsd  0x0(%rbp,%r9,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,1)
add    $0x20,%rcx
sub    %rsi,%rbx
add    %rsi,%r9
add    %rsi,%r15
add    %rsi,%rax
add    %r12,%r8
lea    (%r14,%r11,1),%rbp
add    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffc,%r11
cmp    $0xffffffffffffffff,%rbp
mov    0x58(%rsp),%rbp
jne    1fa0 <house+0xe70>
neg    %r11
mov    %rbp,%rcx
sub    %rbx,%rcx
mov    0x80(%rsp),%r14
mov    0xb8(%rsp),%r8
mov    0x18(%rsp),%r9
mov    0x40(%rsp),%r15
mov    0x90(%rsp),%r12
mov    0x88(%rsp),%rbx
test   $0x3,%bl
je     1ed0 <house+0xda0>
mov    0x60(%rsp),%rax
lea    (%rax,%r11,8),%rax
mov    0x38(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
xor    %ebx,%ebx
nopl   (%rax)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
add    %rdi,%rcx
cmp    %rbx,%rdx
jne    2050 <house+0xf20>
jmp    1ed0 <house+0xda0>
mov    %r13,%rdi
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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