#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 /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(int *);
int *malloc(size_t);
int /*<<< orphan*/ stderr;
int rref(double *A, size_t rows, size_t cols) {
  double eps = 1e-10;
  int *prows = malloc(rows * sizeof(int));
  if (!prows) {
    fprintf(stderr, "Error allocating memory for rref index array\n");
    return 1;
  }
  for (size_t i = 0; i < rows; i++) {
    size_t prow = i, pcol = i;
    double pval = -1;
    for (size_t j = i; j < rows; j++) {
      for (size_t k = 0; k < rows; k++) {
        if (fabs(A[j * cols + k]) >= pval) {
          pval = fabs(A[j * cols + k]);
          prow = j;
          pcol = k;
        }
      }
    }
    if (prow != i) {
      for (size_t j = 0; j < cols; j++) {
        double t = A[i * cols + j];
        A[i * cols + j] = A[prow * cols + j];
        A[prow * cols + j] = t;
      }
      prow = i;
    }
    prows[pcol] = prow;
    if (fabs(A[prow * cols + pcol]) < eps) {
      free(prows);
      fprintf(stderr, "Cannot invert singular matrix\n");
      return 1;
    }
    for (size_t j = 0; j < cols; j++) {
      if (j == pcol)
        continue;
      A[prow * cols + j] /= A[prow * cols + pcol];
    }
    A[prow * cols + pcol] = 1.0;
    for (size_t l = 0; l < rows; l++) {
      if (l == prow)
        continue;
      for (size_t j = 0; j < cols; j++) {
        if (j == pcol)
          continue;
        A[l * cols + j] -= A[l * cols + pcol] * A[prow * cols + j];
      }
      A[l * cols + pcol] = 0;
    }
  }
  for (size_t i = 0; i < rows; i++) {
    if (prows[i] <= i)
      continue;
    int k = prows[i];
    for (size_t j = 0; j < cols; j++) {
      double t = A[i * cols + j];
      A[i * cols + j] = A[k * cols + j];
      A[k * cols + j] = t;
    }
    prows[i] = i;
    for (size_t j = i + 1; j < cols; j++) {
      if (prows[j] == i) {
        prows[j] = k;
        break;
      }
    }
  }
  free(prows);
  return 0;
}


x86 assembly (clang, -O0):
<rref>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movsd  0xeb1(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1191 <rref+0x61>
mov    0x2e69(%rip),%rax
mov    (%rax),%edi
lea    0xeb0(%rip),%rsi
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    16ee <rref+0x5be>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1533 <rref+0x403>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
movsd  0xe49(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    127e <rref+0x14e>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1268 <rref+0x138>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe13(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x50(%rbp),%xmm0
jb     1252 <rref+0x122>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xde7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1257 <rref+0x127>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11e2 <rref+0xb2>
jmp    126d <rref+0x13d>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    11cc <rref+0x9c>
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
je     131d <rref+0x1ed>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1315 <rref+0x1e5>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1294 <rref+0x164>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xcd5(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1388 <rref+0x258>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    0x2c72(%rip),%rax
mov    (%rax),%edi
lea    0xce7(%rip),%rsi
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    16ee <rref+0x5be>
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    13f7 <rref+0x2c7>
mov    -0x78(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    13b1 <rref+0x281>
jmp    13e6 <rref+0x2b6>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1390 <rref+0x260>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movsd  0xc00(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    151d <rref+0x3ed>
mov    -0x80(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    143e <rref+0x30e>
jmp    150c <rref+0x3dc>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    14f3 <rref+0x3c3>
mov    -0x88(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    1470 <rref+0x340>
jmp    14dc <rref+0x3ac>
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x88(%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    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1449 <rref+0x319>
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    141d <rref+0x2ed>
jmp    1522 <rref+0x3f2>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1199 <rref+0x69>
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    16de <rref+0x5ae>
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
cmp    -0x90(%rbp),%rax
ja     1570 <rref+0x440>
jmp    16c7 <rref+0x597>
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
movq   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1637 <rref+0x507>
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    158f <rref+0x45f>
mov    -0x90(%rbp),%rax
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    16c2 <rref+0x592>
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
cmp    -0x90(%rbp),%rax
jne    16a6 <rref+0x576>
mov    -0x94(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    16c2 <rref+0x592>
jmp    16ab <rref+0x57b>
mov    -0xb0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb0(%rbp)
jmp    1660 <rref+0x530>
jmp    16c7 <rref+0x597>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    153e <rref+0x40e>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rref>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r13
lea    0x0(,%rsi,4),%rdi
call   1050 <malloc@plt>
test   %rax,%rax
je     168b <rref+0x55b>
test   %r14,%r14
je     1940 <rref+0x810>
mov    %rax,0x20(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x28(%rsp)
lea    -0x4(%rbx),%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
lea    -0x1(%rbx),%rax
mov    %rax,0x40(%rsp)
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    %rdx,%rax
mov    %rdx,0x18(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x50(%rsp)
mov    %rbx,%r8
and    $0xfffffffffffffffe,%r8
lea    0x8(%r13),%r11
lea    0x0(,%rbx,8),%rbp
lea    0x30(%r13),%rax
mov    $0x1,%dl
xor    %r10d,%r10d
movsd  0xe21(%rip),%xmm0
movapd 0xe29(%rip),%xmm1
movsd  0xe18(%rip),%xmm8
movapd 0xe18(%rip),%xmm3
mov    %r13,%r15
mov    %rax,0x10(%rsp)
mov    %rax,%r12
mov    %r11,0x38(%rsp)
mov    %rbp,0x48(%rsp)
mov    %r8,0x60(%rsp)
jmp    1239 <rref+0x109>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
add    %rbp,%r11
add    %rbp,%r12
add    %rbp,%r15
cmp    %r14,%r10
setb   %dl
je     16d9 <rref+0x5a9>
mov    %dl,0x7(%rsp)
mov    %r12,%rdi
mov    %r10,%rax
imul   %rbx,%rax
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
mov    %rdx,0x70(%rsp)
mov    %rax,0x8(%rsp)
add    %rbx,%rax
lea    0x0(%r13,%rax,8),%rax
mov    %rax,0x68(%rsp)
mov    %r11,%rax
mov    %r10,%r9
movapd %xmm0,%xmm4
mov    %r10,%rsi
mov    %r10,%r8
jmp    1290 <rref+0x160>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %rbp,%rax
cmp    %r14,%r9
jae    1360 <rref+0x230>
xor    %r12d,%r12d
cmp    $0x1,%r14
je     1310 <rref+0x1e0>
nopl   0x0(%rax)
movsd  -0x8(%rax,%r12,8),%xmm5
movsd  (%rax,%r12,8),%xmm6
andpd  %xmm3,%xmm5
ucomisd %xmm4,%xmm5
mov    %rsi,%rdx
cmovae %r12,%rdx
movapd %xmm4,%xmm7
cmpnlesd %xmm5,%xmm7
movapd %xmm7,%xmm2
andnpd %xmm5,%xmm2
andpd  %xmm4,%xmm7
orpd   %xmm2,%xmm7
andpd  %xmm3,%xmm6
cmovae %r9,%r8
lea    0x1(%r12),%rsi
ucomisd %xmm7,%xmm6
cmovae %r9,%r8
cmovb  %rdx,%rsi
movapd %xmm7,%xmm4
cmpnlesd %xmm6,%xmm4
movapd %xmm4,%xmm2
andpd  %xmm7,%xmm2
andnpd %xmm6,%xmm4
orpd   %xmm2,%xmm4
add    $0x2,%r12
cmp    %rcx,%r12
jne    12a0 <rref+0x170>
test   $0x1,%r14b
je     1280 <rref+0x150>
mov    %r9,%rdx
imul   %rbx,%rdx
add    %r12,%rdx
movsd  0x0(%r13,%rdx,8),%xmm5
andpd  %xmm1,%xmm5
ucomisd %xmm4,%xmm5
cmovae %r9,%r8
cmovae %r12,%rsi
movapd %xmm4,%xmm6
cmpnlesd %xmm5,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm5,%xmm7
andpd  %xmm4,%xmm6
orpd   %xmm7,%xmm6
movapd %xmm6,%xmm4
jmp    1280 <rref+0x150>
nopl   (%rax)
cmp    %r10,%r8
mov    %rdi,%r12
je     1530 <rref+0x400>
test   %rbx,%rbx
je     1530 <rref+0x400>
mov    %r8,%r9
imul   %rbx,%r9
cmp    $0x4,%rbx
jb     13b2 <rref+0x282>
lea    0x8(,%r8,8),%rax
imul   %rbx,%rax
add    %r13,%rax
cmp    0x70(%rsp),%rax
jbe    143e <rref+0x30e>
lea    0x0(,%r9,8),%rax
add    %r13,%rax
cmp    0x68(%rsp),%rax
jae    143e <rref+0x30e>
xor    %eax,%eax
mov    %rax,%rdx
test   $0x1,%bl
je     13eb <rref+0x2bb>
mov    0x8(%rsp),%rdx
add    %rax,%rdx
movsd  0x0(%r13,%rdx,8),%xmm4
lea    (%rax,%r9,1),%rdi
movsd  0x0(%r13,%rdi,8),%xmm5
movsd  %xmm5,0x0(%r13,%rdx,8)
movsd  %xmm4,0x0(%r13,%rdi,8)
mov    %rax,%rdx
or     $0x1,%rdx
cmp    %rax,0x40(%rsp)
je     1530 <rref+0x400>
mov    0x38(%rsp),%rax
lea    (%rax,%r9,8),%rax
nop
movsd  (%r15,%rdx,8),%xmm2
movsd  -0x8(%rax,%rdx,8),%xmm4
movsd  %xmm4,(%r15,%rdx,8)
movsd  %xmm2,-0x8(%rax,%rdx,8)
movsd  0x8(%r15,%rdx,8),%xmm2
movsd  (%rax,%rdx,8),%xmm4
movsd  %xmm4,0x8(%r15,%rdx,8)
movsd  %xmm2,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    1400 <rref+0x2d0>
jmp    1530 <rref+0x400>
cmpq   $0x4,0x30(%rsp)
jae    144a <rref+0x31a>
xor    %edi,%edi
jmp    14c6 <rref+0x396>
mov    0x10(%rsp),%rax
lea    (%rax,%r9,8),%rdx
mov    0x50(%rsp),%rax
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%r12,%rdi,8),%xmm4
movups -0x20(%r12,%rdi,8),%xmm5
movups -0x30(%rdx,%rdi,8),%xmm6
movups -0x20(%rdx,%rdi,8),%xmm7
movups %xmm6,-0x30(%r12,%rdi,8)
movups %xmm7,-0x20(%r12,%rdi,8)
movups %xmm4,-0x30(%rdx,%rdi,8)
movups %xmm5,-0x20(%rdx,%rdi,8)
movupd -0x10(%r12,%rdi,8),%xmm4
movupd (%r12,%rdi,8),%xmm5
movupd -0x10(%rdx,%rdi,8),%xmm6
movupd (%rdx,%rdi,8),%xmm7
movupd %xmm6,-0x10(%r12,%rdi,8)
movupd %xmm7,(%r12,%rdi,8)
movupd %xmm4,-0x10(%rdx,%rdi,8)
movupd %xmm5,(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    1460 <rref+0x330>
testb  $0x1,0x18(%rsp)
je     1510 <rref+0x3e0>
mov    0x8(%rsp),%rax
add    %rdi,%rax
movupd 0x0(%r13,%rax,8),%xmm4
movupd 0x10(%r13,%rax,8),%xmm5
add    %r9,%rdi
movupd 0x0(%r13,%rdi,8),%xmm6
movupd 0x10(%r13,%rdi,8),%xmm7
movupd %xmm6,0x0(%r13,%rax,8)
movupd %xmm7,0x10(%r13,%rax,8)
movupd %xmm4,0x0(%r13,%rdi,8)
movupd %xmm5,0x10(%r13,%rdi,8)
mov    0x58(%rsp),%rdx
mov    %rdx,%rax
cmp    %rbx,%rdx
jne    13b4 <rref+0x284>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    %r10d,(%rax,%rsi,4)
mov    0x8(%rsp),%r9
lea    (%r9,%rsi,1),%rax
movsd  0x0(%r13,%rax,8),%xmm2
andpd  %xmm1,%xmm2
ucomisd %xmm2,%xmm8
ja     16aa <rref+0x57a>
test   %rbx,%rbx
mov    0x60(%rsp),%r8
je     1604 <rref+0x4d4>
cmpq   $0x0,0x40(%rsp)
je     15e0 <rref+0x4b0>
xor    %edx,%edx
jmp    1589 <rref+0x459>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %r8,%rdx
je     15d0 <rref+0x4a0>
mov    %rdx,%rdi
cmp    %rdx,%rsi
je     15a6 <rref+0x476>
movsd  -0x8(%r11,%rdi,8),%xmm2
divsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r11,%rdi,8)
lea    0x1(%rdi),%rdx
cmp    %rsi,%rdx
je     1580 <rref+0x450>
movsd  (%r11,%rdi,8),%xmm2
divsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rdi,8)
jmp    1580 <rref+0x450>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rdi
test   $0x1,%bl
jne    15e7 <rref+0x4b7>
jmp    1604 <rref+0x4d4>
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
test   $0x1,%bl
je     1604 <rref+0x4d4>
cmp    %rsi,%rdi
je     1604 <rref+0x4d4>
add    %r9,%rdi
movsd  0x0(%r13,%rdi,8),%xmm2
divsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rdi,8)
movabs $0x3ff0000000000000,%rdx
mov    %rdx,0x0(%r13,%rax,8)
mov    %r13,%rax
xor    %edx,%edx
jmp    163e <rref+0x50e>
nopw   0x0(%rax,%rax,1)
movq   $0x0,0x0(%r13,%rdi,8)
mov    0x48(%rsp),%rbp
add    $0x1,%rdx
add    %rbp,%rax
cmp    %r14,%rdx
je     1220 <rref+0xf0>
cmp    %r10,%rdx
je     162e <rref+0x4fe>
mov    %rdx,%rdi
imul   %rbx,%rdi
add    %rsi,%rdi
test   %rbx,%rbx
je     1620 <rref+0x4f0>
xor    %ebp,%ebp
jmp    1669 <rref+0x539>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%rbx
je     1620 <rref+0x4f0>
cmp    %rbp,%rsi
je     1660 <rref+0x530>
movsd  0x0(%r13,%rdi,8),%xmm2
movsd  (%rax,%rbp,8),%xmm4
mulsd  (%r15,%rbp,8),%xmm2
subsd  %xmm2,%xmm4
movsd  %xmm4,(%rax,%rbp,8)
jmp    1660 <rref+0x530>
mov    0x294e(%rip),%rax
mov    (%rax),%edi
lea    0x985(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%eax
jmp    194a <rref+0x81a>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x2925(%rip),%rax
mov    (%rax),%edi
lea    0x98a(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%eax
testb  $0x1,0x7(%rsp)
jne    194a <rref+0x81a>
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
mov    0x18(%rsp),%rax
and    %rax,0x28(%rsp)
mov    %rbx,%r9
neg    %r9
mov    $0x1,%r15d
xor    %esi,%esi
mov    %r13,%rdi
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%rax
jmp    172c <rref+0x5fc>
nopl   0x0(%rax)
add    $0x1,%rsi
mov    0x48(%rsp),%rcx
add    %rcx,%rbp
add    %rcx,%rdi
add    $0x1,%r15
cmp    %r14,%rsi
je     1940 <rref+0x810>
mov    (%rax,%rsi,4),%r11d
movslq %r11d,%rdx
cmp    %rdx,%rsi
jae    1710 <rref+0x5e0>
test   %rbx,%rbx
je     1910 <rref+0x7e0>
mov    %rsi,%r12
imul   %rbx,%r12
mov    %rdx,%r10
imul   %rbx,%r10
cmp    $0x4,%rbx
jb     179b <rref+0x66b>
lea    0x0(,%r12,8),%rcx
add    %r13,%rcx
lea    0x8(,%rdx,8),%rdx
imul   %rbx,%rdx
add    %r13,%rdx
cmp    %rcx,%rdx
jbe    182a <rref+0x6fa>
lea    (%r12,%rbx,1),%rcx
lea    0x0(,%rcx,8),%rdx
add    %r13,%rdx
lea    0x0(,%r10,8),%rcx
add    %r13,%rcx
cmp    %rdx,%rcx
jae    182a <rref+0x6fa>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bl
je     17cf <rref+0x69f>
add    %rdx,%r12
movsd  0x0(%r13,%r12,8),%xmm0
lea    (%rdx,%r10,1),%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%r12,8)
movsd  %xmm0,0x0(%r13,%rcx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    %r9,%rdx
je     1910 <rref+0x7e0>
mov    0x38(%rsp),%rdx
lea    (%rdx,%r10,8),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rcx,8),%xmm0
movsd  -0x8(%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  %xmm0,-0x8(%rdx,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    17f0 <rref+0x6c0>
jmp    1910 <rref+0x7e0>
cmpq   $0x4,0x30(%rsp)
jae    1836 <rref+0x706>
xor    %edx,%edx
jmp    18b0 <rref+0x780>
mov    0x10(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
mov    0x28(%rsp),%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rbp,%rdx,8),%xmm0
movups -0x20(%rbp,%rdx,8),%xmm1
movups -0x30(%rcx,%rdx,8),%xmm2
movups -0x20(%rcx,%rdx,8),%xmm3
movups %xmm2,-0x30(%rbp,%rdx,8)
movups %xmm3,-0x20(%rbp,%rdx,8)
movups %xmm0,-0x30(%rcx,%rdx,8)
movups %xmm1,-0x20(%rcx,%rdx,8)
movupd -0x10(%rbp,%rdx,8),%xmm0
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd -0x10(%rcx,%rdx,8),%xmm2
movupd (%rcx,%rdx,8),%xmm3
movupd %xmm2,-0x10(%rbp,%rdx,8)
movupd %xmm3,0x0(%rbp,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm1,(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%r8
jne    1850 <rref+0x720>
testb  $0x1,0x18(%rsp)
je     18f6 <rref+0x7c6>
lea    (%rdx,%r12,1),%rcx
movupd 0x0(%r13,%rcx,8),%xmm0
movupd 0x10(%r13,%rcx,8),%xmm1
add    %r10,%rdx
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
movupd %xmm2,0x0(%r13,%rcx,8)
movupd %xmm3,0x10(%r13,%rcx,8)
movupd %xmm0,0x0(%r13,%rdx,8)
movupd %xmm1,0x10(%r13,%rdx,8)
mov    0x8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
jne    179d <rref+0x66d>
nopw   0x0(%rax,%rax,1)
mov    %esi,(%rax,%rsi,4)
mov    %r15,%rdx
cs nopw 0x0(%rax,%rax,1)
cmp    %rbx,%rdx
jae    1710 <rref+0x5e0>
movslq (%rax,%rdx,4),%rcx
add    $0x1,%rdx
cmp    %rcx,%rsi
jne    1920 <rref+0x7f0>
mov    %r11d,-0x4(%rax,%rdx,4)
jmp    1710 <rref+0x5e0>
mov    %rax,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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