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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int nullspace(double *matrix, double *nullspace, int n, int *buffer) {
  int *pnopivot = buffer, nonpivot = 0;
  int *ppivot = buffer + n;
  int i, j, k, l, ptr, max;
  double pivot, t;
  double tol = 1e-12;
  ptr = 0;
  i = 0;
  for (j = 0; j < n; j++) {
    pivot = fabs(matrix[n * i + j]);
    max = i;
    for (k = i + 1; k < n; k++) {
      t = fabs(matrix[n * k + j]);
      if (pivot < t) {
        pivot = t;
        max = k;
      }
    }
    if (pivot < tol) {
      *(pnopivot++) = j;
      nonpivot++;
      for (k = i; k < n; k++)
        matrix[n * k + j] = 0;
    } else {
      *(ppivot++) = j;
      for (k = j; k < n; k++) {
        t = matrix[i * n + k];
        matrix[i * n + k] = matrix[max * n + k];
        matrix[max * n + k] = t;
      }
      pivot = matrix[i * n + j];
      for (k = j; k < n; k++)
        matrix[i * n + k] /= pivot;
      for (k = 0; k < i; k++) {
        pivot = -matrix[k * n + j];
        for (l = j; l < n; l++)
          matrix[k * n + l] += pivot * matrix[i * n + l];
      }
      for (k = i + 1; k < n; k++) {
        pivot = matrix[k * n + j];
        for (l = j; l < n; l++)
          matrix[k * n + l] -= pivot * matrix[i * n + l];
      }
      i++;
    }
  }
  for (k = 0; k < nonpivot; k++) {
    j = buffer[k];
    for (l = 0; l < n - nonpivot; l++)
      nullspace[k * n + buffer[n + l]] = -matrix[l * n + j];
    for (l = 0; l < nonpivot; l++)
      nullspace[k * n + buffer[l]] = (j == buffer[l]) ? 1 : 0;
  }
  return nonpivot;
}


x86 assembly (clang, -O0):
<nullspace>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movsd  0xec3(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14ef <nullspace+0x3ef>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe90(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1201 <nullspace+0x101>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe4f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    11ee <nullspace+0xee>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    11f3 <nullspace+0xf3>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1198 <nullspace+0x98>
movsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1270 <nullspace+0x170>
mov    -0x40(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    126b <nullspace+0x16b>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1238 <nullspace+0x138>
jmp    14dc <nullspace+0x3dc>
mov    -0x40(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1306 <nullspace+0x206>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    128a <nullspace+0x18a>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1365 <nullspace+0x265>
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1327 <nullspace+0x227>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    141b <nullspace+0x31b>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1408 <nullspace+0x308>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13b0 <nullspace+0x2b0>
jmp    140d <nullspace+0x30d>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    136c <nullspace+0x26c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14d3 <nullspace+0x3d3>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14c0 <nullspace+0x3c0>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%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    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1451 <nullspace+0x351>
jmp    14c5 <nullspace+0x3c5>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1424 <nullspace+0x324>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14e1 <nullspace+0x3e1>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1157 <nullspace+0x57>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15f6 <nullspace+0x4f6>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jge    1586 <nullspace+0x486>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x20(%rbp),%rdx
mov    -0x14(%rbp),%esi
add    -0x48(%rbp),%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1517 <nullspace+0x417>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15e3 <nullspace+0x4e3>
mov    -0x40(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x48(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    158d <nullspace+0x48d>
jmp    15e8 <nullspace+0x4e8>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14f6 <nullspace+0x3f6>
mov    -0x2c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<nullspace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
test   %edx,%edx
jle    1d42 <nullspace+0xc42>
mov    %rdi,%r13
mov    %rsi,0x48(%rsp)
movslq %edx,%rbx
lea    (%rcx,%rbx,4),%rax
mov    %rax,0x30(%rsp)
mov    %edx,%r11d
lea    -0x2(%rdx),%eax
mov    %eax,0x24(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x10(%rsp)
mov    %rbx,%r10
shl    $0x4,%r10
lea    0x0(,%rbx,8),%r15
lea    -0x4(%r11),%rax
mov    %rax,-0x60(%rsp)
lea    0x10(%rdi),%r12
lea    0x8(%rdi),%rax
mov    %rax,-0x18(%rsp)
lea    -0x2(%r11),%rax
mov    %rax,0x38(%rsp)
mov    %rbx,%rax
shl    $0x5,%rax
mov    %rax,0x58(%rsp)
xor    %r14d,%r14d
movapd 0xe7b(%rip),%xmm9
movapd 0xe73(%rip),%xmm2
movsd  0xe8a(%rip),%xmm8
movapd 0xe72(%rip),%xmm0
mov    %r11,0x40(%rsp)
mov    %rdi,-0x10(%rsp)
xor    %edi,%edi
mov    %rcx,0x50(%rsp)
mov    %rcx,0x28(%rsp)
movl   $0x0,-0x4c(%rsp)
xor    %r9d,%r9d
mov    %rdx,-0x48(%rsp)
mov    %rbx,-0x68(%rsp)
mov    %r10,-0x20(%rsp)
mov    %r15,0x18(%rsp)
mov    %r13,-0x78(%rsp)
jmp    123f <nullspace+0x13f>
nopw   0x0(%rax,%rax,1)
mov    -0x48(%rsp),%rdx
mov    -0x20(%rsp),%r10
mov    0x18(%rsp),%r15
mov    -0x60(%rsp),%rcx
mov    -0x30(%rsp),%r12
mov    -0x38(%rsp),%r14
mov    -0x3c(%rsp),%eax
mov    -0x78(%rsp),%r13
mov    -0x80(%rsp),%rdi
add    $0x1,%rdi
add    $0x8,%r14
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x60(%rsp)
add    $0x8,%r12
addq   $0x8,-0x10(%rsp)
addq   $0xffffffffffffffff,0x38(%rsp)
addq   $0xffffffffffffffff,0x40(%rsp)
mov    %eax,%r9d
cmp    %r11,%rdi
je     1b9e <nullspace+0xa9e>
mov    %r9d,%eax
imul   %edx,%eax
cltq
mov    %rax,-0x70(%rsp)
add    %rdi,%rax
mov    %rax,-0x58(%rsp)
movsd  0x0(%r13,%rax,8),%xmm5
andpd  %xmm9,%xmm5
lea    0x1(%r9),%esi
cmp    %edx,%esi
mov    %rdi,-0x80(%rsp)
mov    %esi,-0x3c(%rsp)
jge    1290 <nullspace+0x190>
movslq %esi,%rcx
mov    %r9d,%eax
not    %eax
add    %edx,%eax
test   $0x1,%al
jne    12a0 <nullspace+0x1a0>
mov    %r9d,%ebx
cmp    %r9d,0x24(%rsp)
jne    12d3 <nullspace+0x1d3>
jmp    1339 <nullspace+0x239>
xchg   %ax,%ax
mov    %r9d,%ebx
movapd %xmm5,%xmm4
jmp    1339 <nullspace+0x239>
nopl   0x0(%rax)
mov    %rcx,%rax
imul   %rbx,%rax
add    %rdi,%rax
movsd  0x0(%r13,%rax,8),%xmm4
andpd  %xmm9,%xmm4
ucomisd %xmm5,%xmm4
mov    %r9d,%ebx
cmova  %esi,%ebx
maxsd  %xmm5,%xmm4
add    $0x1,%rcx
movapd %xmm4,%xmm5
cmp    %r9d,0x24(%rsp)
je     1339 <nullspace+0x239>
mov    -0x68(%rsp),%r8
imul   %rcx,%r8
add    -0x80(%rsp),%r8
lea    0x1(%rcx),%rax
imul   %r15,%rax
add    %r14,%rax
mov    %r13,%rbp
movapd %xmm5,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%r8,8),%xmm5
andpd  %xmm2,%xmm5
ucomisd %xmm4,%xmm5
cmova  %ecx,%ebx
maxsd  %xmm4,%xmm5
movsd  0x0(%rbp,%rax,1),%xmm4
andpd  %xmm2,%xmm4
ucomisd %xmm5,%xmm4
lea    0x1(%rcx),%esi
cmova  %esi,%ebx
maxsd  %xmm5,%xmm4
add    $0x2,%rcx
add    %r10,%rbp
cmp    %edx,%ecx
jne    1300 <nullspace+0x200>
ucomisd %xmm4,%xmm8
jbe    13e0 <nullspace+0x2e0>
mov    0x28(%rsp),%rax
mov    -0x80(%rsp),%rdi
mov    %edi,(%rax)
add    $0x4,%rax
addl   $0x1,-0x4c(%rsp)
cmp    %edx,%r9d
mov    %rax,0x28(%rsp)
jge    1470 <nullspace+0x370>
movslq %r9d,%rcx
mov    %edx,%ebx
sub    %r9d,%ebx
mov    %rcx,%rax
not    %rax
mov    -0x68(%rsp),%rsi
add    %rsi,%rax
and    $0x3,%rbx
je     1482 <nullspace+0x382>
imul   %rcx,%rsi
add    %rdi,%rsi
lea    0x0(,%rsi,8),%rsi
add    %r13,%rsi
neg    %rbx
xor    %ebp,%ebp
xchg   %ax,%ax
movq   $0x0,(%rsi)
add    $0xffffffffffffffff,%rbp
add    %r15,%rsi
cmp    %rbp,%rbx
jne    13a0 <nullspace+0x2a0>
sub    %rbp,%rcx
mov    -0x68(%rsp),%rbx
cmp    $0x3,%rax
jae    148f <nullspace+0x38f>
mov    %r9d,%eax
mov    -0x60(%rsp),%rcx
jmp    120c <nullspace+0x10c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%rbp
mov    -0x80(%rsp),%rsi
sub    %rsi,%rbp
lea    0x0(,%rbp,8),%rdi
add    %r13,%rdi
mov    0x30(%rsp),%rax
mov    %esi,(%rax)
imul   %edx,%ebx
movslq %ebx,%r8
mov    %rsi,%rdx
cmp    $0x4,%rbp
jb     1610 <nullspace+0x510>
mov    -0x58(%rsp),%rax
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
lea    (%rsi,%r8,1),%rax
lea    (%rdi,%rax,8),%rdx
cmp    %rdx,%rcx
jae    144d <nullspace+0x34d>
mov    -0x58(%rsp),%rcx
lea    (%rdi,%rcx,8),%rcx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
mov    %rsi,%rdx
cmp    %rcx,%rax
jb     1610 <nullspace+0x510>
lea    -0x4(%rbp),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
cmp    $0x4,%rax
jae    1526 <nullspace+0x426>
xor    %ecx,%ecx
jmp    15ae <nullspace+0x4ae>
nopl   (%rax)
mov    %r9d,%eax
mov    -0x68(%rsp),%rbx
mov    -0x60(%rsp),%rcx
jmp    120c <nullspace+0x10c>
mov    %rsi,%rbx
cmp    $0x3,%rax
jb     13c5 <nullspace+0x2c5>
mov    %r14,-0x38(%rsp)
mov    %rbx,%rax
sub    %rcx,%rax
lea    0x3(%rcx),%rsi
imul   %rbx,%rsi
mov    -0x10(%rsp),%r14
lea    (%r14,%rsi,8),%r8
lea    0x2(%rcx),%rsi
imul   %rbx,%rsi
lea    (%r14,%rsi,8),%rsi
mov    %rbx,%rbp
imul   %rcx,%rbp
lea    (%r14,%rbp,8),%rbp
add    $0x1,%rcx
imul   %rbx,%rcx
lea    (%r14,%rcx,8),%rcx
xor    %ebx,%ebx
mov    0x58(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,0x0(%rbp,%rbx,1)
movq   $0x0,(%rcx,%rbx,1)
movq   $0x0,(%rsi,%rbx,1)
movq   $0x0,(%r8,%rbx,1)
add    %r14,%rbx
add    $0xfffffffffffffffc,%rax
jne    14e0 <nullspace+0x3e0>
mov    %r9d,%eax
mov    -0x68(%rsp),%rbx
mov    -0x38(%rsp),%r14
mov    -0x80(%rsp),%rdi
mov    -0x60(%rsp),%rcx
jmp    120c <nullspace+0x10c>
mov    -0x60(%rsp),%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r12,%r8,8),%rdx
mov    -0x70(%rsp),%rcx
lea    (%r12,%rcx,8),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rsi,%rcx,8),%xmm4
movups (%rsi,%rcx,8),%xmm5
movups -0x10(%rdx,%rcx,8),%xmm6
movups (%rdx,%rcx,8),%xmm7
movups %xmm6,-0x10(%rsi,%rcx,8)
movups %xmm7,(%rsi,%rcx,8)
movups %xmm4,-0x10(%rdx,%rcx,8)
movups %xmm5,(%rdx,%rcx,8)
movupd 0x10(%rsi,%rcx,8),%xmm4
movupd 0x20(%rsi,%rcx,8),%xmm5
movupd 0x10(%rdx,%rcx,8),%xmm6
movupd 0x20(%rdx,%rcx,8),%xmm7
movupd %xmm6,0x10(%rsi,%rcx,8)
movupd %xmm7,0x20(%rsi,%rcx,8)
movupd %xmm4,0x10(%rdx,%rcx,8)
movupd %xmm5,0x20(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1550 <nullspace+0x450>
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%bl
je     1602 <nullspace+0x502>
add    -0x80(%rsp),%rcx
mov    -0x70(%rsp),%rax
add    %rcx,%rax
movupd 0x0(%r13,%rax,8),%xmm4
movupd 0x10(%r13,%rax,8),%xmm5
add    %r8,%rcx
movupd 0x0(%r13,%rcx,8),%xmm6
movupd 0x10(%r13,%rcx,8),%xmm7
movupd %xmm6,0x0(%r13,%rax,8)
movupd %xmm7,0x10(%r13,%rax,8)
movupd %xmm4,0x0(%r13,%rcx,8)
movupd %xmm5,0x10(%r13,%rcx,8)
cmp    %rdx,%rbp
je     16a5 <nullspace+0x5a5>
add    -0x80(%rsp),%rdx
mov    %r11d,%ecx
sub    %edx,%ecx
mov    %rdx,%rax
test   $0x1,%cl
je     1649 <nullspace+0x549>
mov    -0x70(%rsp),%rax
add    %rdx,%rax
movsd  0x0(%r13,%rax,8),%xmm4
lea    (%rdx,%r8,1),%rcx
movsd  0x0(%r13,%rcx,8),%xmm5
movsd  %xmm5,0x0(%r13,%rax,8)
movsd  %xmm4,0x0(%r13,%rcx,8)
lea    0x1(%rdx),%rax
not    %rdx
cmp    0x10(%rsp),%rdx
je     16a5 <nullspace+0x5a5>
mov    -0x18(%rsp),%rdx
lea    (%rdx,%r8,8),%rcx
mov    -0x70(%rsp),%rsi
lea    (%rdx,%rsi,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rax,8),%xmm4
movsd  -0x8(%rcx,%rax,8),%xmm5
movsd  %xmm5,-0x8(%rdx,%rax,8)
movsd  %xmm4,-0x8(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm4
movsd  (%rcx,%rax,8),%xmm5
movsd  %xmm5,(%rdx,%rax,8)
movsd  %xmm4,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    1670 <nullspace+0x570>
mov    -0x58(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm4
mov    -0x80(%rsp),%rbx
mov    %rbx,%rax
cmp    $0x2,%rbp
mov    %r12,-0x30(%rsp)
jb     1766 <nullspace+0x666>
lea    -0x2(%rbp),%rax
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmp    $0x2,%rax
jae    16e8 <nullspace+0x5e8>
xor    %edx,%edx
jmp    1738 <nullspace+0x638>
mov    0x38(%rsp),%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    -0x10(%rsp),%rdx
mov    -0x70(%rsp),%rsi
lea    (%rdx,%rsi,8),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rdx,8),%xmm6
movupd 0x10(%rsi,%rdx,8),%xmm7
divpd  %xmm5,%xmm6
movupd %xmm6,(%rsi,%rdx,8)
divpd  %xmm5,%xmm7
movupd %xmm7,0x10(%rsi,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rax
jne    1710 <nullspace+0x610>
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
test   $0x1,%cl
je     175e <nullspace+0x65e>
add    %rbx,%rdx
add    -0x70(%rsp),%rdx
movupd 0x0(%r13,%rdx,8),%xmm6
divpd  %xmm5,%xmm6
movupd %xmm6,0x0(%r13,%rdx,8)
cmp    %rax,%rbp
je     1797 <nullspace+0x697>
add    %rbx,%rax
mov    -0x70(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm5
divsd  %xmm4,%xmm5
movsd  %xmm5,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1780 <nullspace+0x680>
mov    %rdi,-0x28(%rsp)
mov    %r14,-0x38(%rsp)
mov    0x40(%rsp),%r10
and    $0xfffffffffffffffc,%r10
test   %r9d,%r9d
mov    %rbp,%r13
jle    1970 <nullspace+0x870>
mov    %r9d,%eax
mov    -0x78(%rsp),%rcx
mov    -0x58(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    %rcx,0x8(%rsp)
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rdx,8),%r12
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
mov    -0x80(%rsp),%rcx
mov    %rdx,(%rsp)
add    %rdx,%rcx
mov    %rcx,-0x8(%rsp)
mov    -0x30(%rsp),%r8
mov    -0x70(%rsp),%rcx
lea    (%r8,%rcx,8),%rdx
mov    -0x18(%rsp),%rbx
lea    (%rbx,%rcx,8),%rcx
xor    %r14d,%r14d
jmp    182b <nullspace+0x72b>
nopl   0x0(%rax)
add    $0x1,%r14
mov    0x18(%rsp),%r15
add    %r15,%r8
add    %r15,%rbx
cmp    %rax,%r14
mov    %r13,%rbp
je     1970 <nullspace+0x870>
mov    %r14,%r9
imul   -0x68(%rsp),%r9
mov    -0x80(%rsp),%r15
lea    (%r9,%r15,1),%rsi
mov    -0x78(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm4
xorpd  %xmm0,%xmm4
cmp    $0x4,%rbp
jb     18e0 <nullspace+0x7e0>
mov    -0x78(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
cmp    %r12,%rsi
jae    187c <nullspace+0x77c>
lea    (%r9,%r11,1),%rsi
mov    -0x78(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
mov    -0x80(%rsp),%r15
cmp    %rsi,0x8(%rsp)
jb     18e0 <nullspace+0x7e0>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rsi,8),%xmm6
movupd (%rdx,%rsi,8),%xmm7
movupd -0x10(%r8,%rsi,8),%xmm3
movupd (%r8,%rsi,8),%xmm1
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm5,%xmm7
addpd  %xmm1,%xmm7
movupd %xmm6,-0x10(%r8,%rsi,8)
movupd %xmm7,(%r8,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    1890 <nullspace+0x790>
mov    -0x8(%rsp),%r15
cmp    (%rsp),%r13
je     1810 <nullspace+0x710>
nopl   (%rax)
mov    %r11d,%esi
sub    %r15d,%esi
mov    %r15,%rbp
test   $0x1,%sil
je     191b <nullspace+0x81b>
mov    -0x70(%rsp),%rsi
add    %r15,%rsi
add    %r15,%r9
mov    -0x78(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x0(%rbp,%r9,8),%xmm1
movsd  %xmm1,0x0(%rbp,%r9,8)
lea    0x1(%r15),%rbp
not    %r15
cmp    0x10(%rsp),%r15
je     1810 <nullspace+0x710>
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  -0x8(%rbx,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r11
jne    1930 <nullspace+0x830>
jmp    1810 <nullspace+0x710>
nopw   0x0(%rax,%rax,1)
addq   $0x4,0x30(%rsp)
mov    -0x48(%rsp),%rdx
mov    -0x3c(%rsp),%eax
cmp    %edx,%eax
jge    1b80 <nullspace+0xa80>
movslq %eax,%r12
mov    -0x68(%rsp),%rbx
mov    %rbx,%rax
imul   %r12,%rax
mov    -0x80(%rsp),%rdx
lea    (%rdx,%rax,1),%rcx
mov    %rcx,0x8(%rsp)
lea    (%rax,%r11,1),%rcx
mov    %rcx,-0x8(%rsp)
mov    -0x78(%rsp),%rcx
mov    -0x58(%rsp),%rsi
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x60(%rsp)
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,(%rsp)
mov    %rbp,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x58(%rsp)
add    %rdx,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x30(%rsp),%rcx
mov    -0x70(%rsp),%rdx
lea    (%rcx,%rdx,8),%r9
lea    (%rcx,%rax,8),%r14
mov    -0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%r8
lea    (%rcx,%rdx,8),%rcx
xor    %edx,%edx
jmp    1a31 <nullspace+0x931>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0x1,%rdx
mov    0x18(%rsp),%rax
add    %rax,%r14
add    %rax,%r8
cmp    -0x48(%rsp),%r12d
mov    %r13,%rbp
je     11e0 <nullspace+0xe0>
mov    %r12,%rax
imul   %rbx,%rax
mov    -0x80(%rsp),%r15
lea    (%rax,%r15,1),%rsi
mov    -0x78(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm4
xorpd  %xmm0,%xmm4
cmp    $0x4,%rbp
jb     1af0 <nullspace+0x9f0>
mov    %rdx,%rsi
imul   %rbx,%rsi
mov    0x8(%rsp),%rdi
lea    (%rdi,%rsi,1),%rbp
mov    -0x78(%rsp),%rdi
lea    (%rdi,%rbp,8),%rbp
cmp    (%rsp),%rbp
jae    1a92 <nullspace+0x992>
add    -0x8(%rsp),%rsi
mov    -0x78(%rsp),%rdi
lea    (%rdi,%rsi,8),%rbp
mov    -0x80(%rsp),%r15
cmp    %rbp,0x60(%rsp)
jb     1af0 <nullspace+0x9f0>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%r9,%rsi,8),%xmm1
movupd (%r9,%rsi,8),%xmm3
movupd -0x10(%r14,%rsi,8),%xmm6
movupd (%r14,%rsi,8),%xmm7
mulpd  %xmm5,%xmm1
addpd  %xmm6,%xmm1
mulpd  %xmm5,%xmm3
addpd  %xmm7,%xmm3
movupd %xmm1,-0x10(%r14,%rsi,8)
movupd %xmm3,(%r14,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    1aa0 <nullspace+0x9a0>
mov    -0x28(%rsp),%r15
cmp    -0x58(%rsp),%r13
je     1a10 <nullspace+0x910>
mov    %r11d,%ebx
sub    %r15d,%ebx
mov    %r15,%rbp
test   $0x1,%bl
je     1b28 <nullspace+0xa28>
mov    -0x70(%rsp),%rbx
add    %r15,%rbx
add    %r15,%rax
mov    -0x78(%rsp),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
lea    0x1(%r15),%rbp
not    %r15
cmp    0x10(%rsp),%r15
mov    -0x68(%rsp),%rbx
je     1a10 <nullspace+0x910>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  -0x8(%r8,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%r8,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  (%r8,%rbp,8),%xmm1
movsd  %xmm1,(%r8,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r11
jne    1b40 <nullspace+0xa40>
jmp    1a10 <nullspace+0x910>
nopl   0x0(%rax,%rax,1)
mov    -0x68(%rsp),%rbx
mov    -0x20(%rsp),%r10
mov    -0x60(%rsp),%rcx
mov    -0x30(%rsp),%r12
mov    -0x38(%rsp),%r14
jmp    1202 <nullspace+0x102>
mov    -0x4c(%rsp),%eax
test   %eax,%eax
jle    1d44 <nullspace+0xc44>
mov    %edx,%r8d
sub    %eax,%r8d
mov    %eax,%r10d
mov    %r8,-0x80(%rsp)
and    $0xfffffffe,%r8d
mov    %r10d,%r9d
and    $0xfffffffe,%r9d
mov    0x50(%rsp),%r12
lea    (%r12,%rbx,4),%r15
add    $0x4,%r15
xor    %r14d,%r14d
movapd 0x435(%rip),%xmm1
movsd  0x445(%rip),%xmm2
mov    0x48(%rsp),%rcx
jmp    1c07 <nullspace+0xb07>
nopw   0x0(%rax,%rax,1)
add    %edx,%esi
movslq %esi,%rdx
movsd  %xmm3,(%rcx,%rdx,8)
add    $0x1,%r14
cmp    %r10,%r14
je     1d44 <nullspace+0xc44>
movslq (%r12,%r14,4),%r13
cmpl   $0x0,-0x80(%rsp)
jle    1cc4 <nullspace+0xbc4>
mov    %r10,%rdi
mov    %r14d,%eax
imul   -0x48(%rsp),%eax
movslq %eax,%rdx
cmpl   $0x1,-0x80(%rsp)
jne    1c30 <nullspace+0xb30>
xor    %r11d,%r11d
jmp    1c8a <nullspace+0xb8a>
lea    (%rbx,%r13,1),%rsi
mov    -0x78(%rsp),%rbp
xor    %r11d,%r11d
mov    -0x20(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r13,8),%xmm3
xorpd  %xmm1,%xmm3
movslq -0x4(%r15,%r11,4),%rbx
add    %rdx,%rbx
movlpd %xmm3,(%rcx,%rbx,8)
movsd  0x0(%rbp,%rsi,8),%xmm3
xorpd  %xmm1,%xmm3
movslq (%r15,%r11,4),%rbx
add    %rdx,%rbx
movlpd %xmm3,(%rcx,%rbx,8)
add    $0x2,%r11
add    %r10,%rbp
cmp    %r11,%r8
jne    1c50 <nullspace+0xb50>
testb  $0x1,-0x80(%rsp)
mov    -0x68(%rsp),%rbx
mov    -0x4c(%rsp),%eax
mov    %rdi,%r10
je     1cc4 <nullspace+0xbc4>
mov    %r11,%rsi
imul   %rbx,%rsi
add    %r13,%rsi
mov    -0x78(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm3
xorpd  %xmm0,%xmm3
add    %rbx,%r11
movslq (%r12,%r11,4),%rsi
add    %rdx,%rsi
movlpd %xmm3,(%rcx,%rsi,8)
mov    %r14d,%edx
imul   -0x48(%rsp),%edx
xor    %ebp,%ebp
cmp    $0x1,%eax
jne    1d13 <nullspace+0xc13>
test   $0x1,%r10b
je     1bfa <nullspace+0xafa>
mov    (%r12,%rbp,4),%esi
movapd %xmm2,%xmm3
cmp    %esi,%r13d
je     1bf0 <nullspace+0xaf0>
xorpd  %xmm3,%xmm3
jmp    1bf0 <nullspace+0xaf0>
nopw   0x0(%rax,%rax,1)
add    %edx,%esi
movslq %esi,%rsi
movsd  %xmm3,(%rcx,%rsi,8)
add    $0x2,%rbp
cmp    %rbp,%r9
je     1cd3 <nullspace+0xbd3>
mov    (%r12,%rbp,4),%esi
movapd %xmm2,%xmm3
cmp    %esi,%r13d
je     1d24 <nullspace+0xc24>
xorpd  %xmm3,%xmm3
add    %edx,%esi
movslq %esi,%rsi
movsd  %xmm3,(%rcx,%rsi,8)
mov    0x4(%r12,%rbp,4),%esi
movapd %xmm2,%xmm3
cmp    %esi,%r13d
je     1d00 <nullspace+0xc00>
xorpd  %xmm3,%xmm3
jmp    1d00 <nullspace+0xc00>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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