#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*/ printf(char *, double, int);
int matinv(double x[], int n, int m, double space[]) {
  register int i, j, k;
  int *irow = (int *)space;
  double ee = 1.0e-30, t, t1, xmax;
  double det = 1.0;
  for (i = 0; i < n; i++) {
    xmax = 0.;
    for (j = i; j < n; j++)
      if (xmax < fabs(x[j * m + i])) {
        xmax = fabs(x[j * m + i]);
        irow[i] = j;
      }
    det *= xmax;
    if (xmax < ee) {
      printf("\nDet = %.4e close to zero at %3d!\t\n", xmax, i + 1);
      return (-1);
    }
    if (irow[i] != i) {
      for (j = 0; j < m; j++) {
        t = x[i * m + j];
        x[i * m + j] = x[irow[i] * m + j];
        x[irow[i] * m + j] = t;
      }
    }
    t = 1. / x[i * m + i];
    for (j = 0; j < n; j++) {
      if (j == i)
        continue;
      t1 = t * x[j * m + i];
      for (k = 0; k < m; k++)
        x[j * m + k] -= t1 * x[i * m + k];
      x[j * m + i] = -t1;
    }
    for (j = 0; j < m; j++)
      x[i * m + j] *= t;
    x[i * m + i] = t;
  }
  for (i = n - 1; i >= 0; i--) {
    if (irow[i] == i)
      continue;
    for (j = 0; j < n; j++) {
      t = x[j * m + i];
      x[j * m + i] = x[j * m + irow[i]];
      x[j * m + irow[i]] = t;
    }
  }
  return (0);
}


x86 assembly (clang, -O0):
<matinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
movsd  0xed2(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xebd(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1465 <matinv+0x355>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ec <matinv+0xdc>
movsd  -0x58(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe79(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    11d9 <matinv+0xc9>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe4e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11de <matinv+0xce>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1169 <matinv+0x59>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1232 <matinv+0x122>
movsd  -0x58(%rbp),%xmm0
mov    -0x24(%rbp),%esi
add    $0x1,%esi
lea    0xdff(%rip),%rdi
call   1030 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    153e <matinv+0x42e>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
je     12de <matinv+0x1ce>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12d9 <matinv+0x1c9>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    124d <matinv+0x13d>
jmp    12de <matinv+0x1ce>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd09(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13fb <matinv+0x2eb>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1325 <matinv+0x215>
jmp    13ed <matinv+0x2dd>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13bb <matinv+0x2ab>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x2c(%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    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    134c <matinv+0x23c>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1308 <matinv+0x1f8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    143c <matinv+0x32c>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1402 <matinv+0x2f2>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114f <matinv+0x3f>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     1537 <matinv+0x427>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    1491 <matinv+0x381>
jmp    1529 <matinv+0x419>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1524 <matinv+0x414>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x38(%rbp),%rdx
movslq -0x24(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x38(%rbp),%rdx
movslq -0x24(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1498 <matinv+0x388>
jmp    1529 <matinv+0x419>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    146e <matinv+0x35e>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matinv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rcx,0x20(%rsp)
test   %esi,%esi
jle    18cf <matinv+0x7bf>
mov    %esi,0x54(%rsp)
mov    %esi,%r11d
movslq %edx,%rbx
mov    %ebx,%eax
lea    (%rdi,%rax,8),%rcx
mov    %rcx,0x80(%rsp)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x40(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x38(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0x78(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x30(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x28(%rsp)
lea    0x0(,%rbx,8),%rbp
lea    0x8(,%rbx,8),%rcx
mov    %rcx,0x88(%rsp)
lea    0x30(%rdi),%r13
lea    0x8(%rdi),%rcx
xor    %r10d,%r10d
movapd 0xe54(%rip),%xmm11
movsd  0xe6b(%rip),%xmm10
movsd  0xe6a(%rip),%xmm9
movapd 0xe49(%rip),%xmm8
mov    %rdi,%r8
mov    %rcx,0x60(%rsp)
mov    %rcx,%r15
mov    %r13,0x58(%rsp)
mov    %rdi,%r9
mov    0x20(%rsp),%r14
mov    %r11,0x48(%rsp)
mov    %rbx,0x18(%rsp)
mov    %rdi,%rsi
mov    %rdi,0x10(%rsp)
jmp    122c <matinv+0x11c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x90(%rsp),%rcx
movsd  %xmm12,(%rsi,%rcx,8)
add    $0x1,%r10
add    0x88(%rsp),%r9
add    %rbp,%r13
add    %rbp,%r15
add    %rbp,%r8
cmp    %r11,%r10
je     17d9 <matinv+0x6c9>
mov    %r10,%rcx
imul   0x18(%rsp),%rcx
lea    (%rsi,%rcx,8),%rdi
mov    %rdi,0x68(%rsp)
mov    %rcx,0x8(%rsp)
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x70(%rsp)
xorpd  %xmm0,%xmm0
mov    %r9,%rcx
mov    %r10,%rbx
jmp    126c <matinv+0x15c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    %rbp,%rcx
cmp    %rbx,%r11
je     1290 <matinv+0x180>
movsd  (%rcx),%xmm5
andpd  %xmm11,%xmm5
ucomisd %xmm0,%xmm5
jbe    1260 <matinv+0x150>
mov    %ebx,(%r14,%r10,4)
movapd %xmm5,%xmm0
jmp    1260 <matinv+0x150>
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd %xmm0,%xmm10
ja     17bc <matinv+0x6ac>
mov    %r9,0x98(%rsp)
mov    (%r14,%r10,4),%ecx
cmp    %rcx,%r10
je     1460 <matinv+0x350>
test   %edx,%edx
jle    1460 <matinv+0x350>
imul   %edx,%ecx
movslq %ecx,%r9
cmp    $0x4,%edx
jb     12ee <matinv+0x1de>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
cmp    %rcx,0x68(%rsp)
mov    0x10(%rsp),%rcx
jae    137e <matinv+0x26e>
lea    (%rcx,%r9,8),%rcx
cmp    0x70(%rsp),%rcx
jae    137e <matinv+0x26e>
xor    %ebx,%ebx
mov    %rbx,%rcx
test   $0x1,%al
je     1323 <matinv+0x213>
mov    0x8(%rsp),%rcx
add    %rbx,%rcx
mov    0x10(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm0
lea    (%rbx,%r9,1),%rsi
movsd  (%rdi,%rsi,8),%xmm5
movsd  %xmm5,(%rdi,%rcx,8)
movsd  %xmm0,(%rdi,%rsi,8)
mov    %rbx,%rcx
or     $0x1,%rcx
not    %rbx
cmp    0x78(%rsp),%rbx
je     1460 <matinv+0x350>
mov    0x60(%rsp),%rsi
lea    (%rsi,%r9,8),%rsi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rcx,8),%xmm0
movsd  -0x8(%rsi,%rcx,8),%xmm5
movsd  %xmm5,-0x8(%r15,%rcx,8)
movsd  %xmm0,-0x8(%rsi,%rcx,8)
movsd  (%r15,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm5
movsd  %xmm5,(%r15,%rcx,8)
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1340 <matinv+0x230>
jmp    1460 <matinv+0x350>
cmpq   $0x0,0x38(%rsp)
je     17aa <matinv+0x69a>
mov    0x58(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
mov    0x28(%rsp),%rsi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x30(%r13,%rbx,8),%xmm0
movups -0x20(%r13,%rbx,8),%xmm5
movups -0x30(%rcx,%rbx,8),%xmm6
movups -0x20(%rcx,%rbx,8),%xmm7
movups %xmm6,-0x30(%r13,%rbx,8)
movups %xmm7,-0x20(%r13,%rbx,8)
movups %xmm0,-0x30(%rcx,%rbx,8)
movups %xmm5,-0x20(%rcx,%rbx,8)
movupd -0x10(%r13,%rbx,8),%xmm0
movupd 0x0(%r13,%rbx,8),%xmm5
movupd -0x10(%rcx,%rbx,8),%xmm6
movupd (%rcx,%rbx,8),%xmm7
movupd %xmm6,-0x10(%r13,%rbx,8)
movupd %xmm7,0x0(%r13,%rbx,8)
movupd %xmm0,-0x10(%rcx,%rbx,8)
movupd %xmm5,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    13a0 <matinv+0x290>
testb  $0x1,0x30(%rsp)
je     144b <matinv+0x33b>
mov    0x8(%rsp),%rcx
add    %rbx,%rcx
mov    0x10(%rsp),%rsi
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm5
add    %r9,%rbx
movupd (%rsi,%rbx,8),%xmm6
movupd 0x10(%rsi,%rbx,8),%xmm7
movupd %xmm6,(%rsi,%rcx,8)
movupd %xmm7,0x10(%rsi,%rcx,8)
movupd %xmm0,(%rsi,%rbx,8)
movupd %xmm5,0x10(%rsi,%rbx,8)
mov    0x40(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rax,%rcx
jne    12f0 <matinv+0x1e0>
nopl   0x0(%rax)
mov    %r15,0xa0(%rsp)
mov    %edx,%edi
mov    0x8(%rsp),%rcx
add    %r10,%rcx
movapd %xmm9,%xmm12
mov    0x10(%rsp),%rsi
mov    %rcx,0x90(%rsp)
divsd  (%rsi,%rcx,8),%xmm12
movapd %xmm12,%xmm5
xorpd  %xmm8,%xmm5
mov    0x60(%rsp),%r14
mov    0x58(%rsp),%r12
xor    %ebx,%ebx
jmp    14c9 <matinv+0x3b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm6,(%rsi,%r15,8)
add    $0x1,%rbx
add    %rbp,%r12
add    %rbp,%r14
cmp    %r11,%rbx
je     16a0 <matinv+0x590>
cmp    %r10,%rbx
je     14b6 <matinv+0x3a6>
mov    %rbx,%r9
imul   0x18(%rsp),%r9
lea    (%r9,%r10,1),%r15
movsd  (%rsi,%r15,8),%xmm6
mulsd  %xmm5,%xmm6
test   %edi,%edi
jle    14b0 <matinv+0x3a0>
cmp    $0x4,%edi
jb     1510 <matinv+0x400>
lea    (%rsi,%r9,8),%rcx
cmp    0x70(%rsp),%rcx
jae    158d <matinv+0x47d>
lea    (%r9,%rax,1),%rcx
lea    (%rsi,%rcx,8),%rcx
cmp    %rcx,0x68(%rsp)
jae    158d <matinv+0x47d>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%al
je     1540 <matinv+0x430>
mov    0x8(%rsp),%rcx
add    %rdx,%rcx
add    %rdx,%r9
movsd  (%rsi,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%rsi,%r9,8),%xmm0
movsd  %xmm0,(%rsi,%r9,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x78(%rsp),%rdx
je     14b0 <matinv+0x3a0>
xchg   %ax,%ax
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  -0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1550 <matinv+0x440>
jmp    14b0 <matinv+0x3a0>
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
cmpq   $0x0,0x38(%rsp)
je     168e <matinv+0x57e>
mov    0x28(%rsp),%rcx
xor    %r11d,%r11d
nopl   0x0(%rax)
movupd -0x30(%r13,%r11,8),%xmm3
movupd -0x20(%r13,%r11,8),%xmm4
mulpd  %xmm7,%xmm3
movupd -0x30(%r12,%r11,8),%xmm2
addpd  %xmm3,%xmm2
movupd -0x20(%r12,%r11,8),%xmm3
movupd -0x10(%r12,%r11,8),%xmm1
movupd (%r12,%r11,8),%xmm0
mulpd  %xmm7,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm2,-0x30(%r12,%r11,8)
movupd %xmm4,-0x20(%r12,%r11,8)
movupd -0x10(%r13,%r11,8),%xmm2
movupd 0x0(%r13,%r11,8),%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm0,%xmm3
movupd %xmm2,-0x10(%r12,%r11,8)
movupd %xmm3,(%r12,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%rcx
jne    15b0 <matinv+0x4a0>
testb  $0x1,0x30(%rsp)
je     1673 <matinv+0x563>
mov    0x8(%rsp),%rcx
add    %r11,%rcx
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
add    %r9,%r11
movupd (%rsi,%r11,8),%xmm2
movupd 0x10(%rsi,%r11,8),%xmm3
mulpd  %xmm7,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%rsi,%r11,8)
movupd %xmm1,0x10(%rsi,%r11,8)
mov    0x40(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
mov    0x48(%rsp),%r11
je     14b0 <matinv+0x3a0>
jmp    1512 <matinv+0x402>
xor    %r11d,%r11d
testb  $0x1,0x30(%rsp)
jne    1633 <matinv+0x523>
jmp    1673 <matinv+0x563>
nopw   0x0(%rax,%rax,1)
mov    %edi,%edx
test   %edi,%edi
mov    0x20(%rsp),%r14
mov    0xa0(%rsp),%r15
mov    0x98(%rsp),%r9
jle    1200 <matinv+0xf0>
cmp    $0x4,%edx
jae    16d0 <matinv+0x5c0>
xor    %ecx,%ecx
jmp    1780 <matinv+0x670>
nopl   0x0(%rax,%rax,1)
movapd %xmm12,%xmm5
unpcklpd %xmm12,%xmm5
cmpq   $0x0,0x38(%rsp)
je     179f <matinv+0x68f>
mov    0x28(%rsp),%rcx
xor    %ebx,%ebx
nopl   (%rax)
movupd -0x30(%r13,%rbx,8),%xmm6
movupd -0x20(%r13,%rbx,8),%xmm7
movupd -0x10(%r13,%rbx,8),%xmm4
movupd 0x0(%r13,%rbx,8),%xmm3
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm7
movupd %xmm6,-0x30(%r13,%rbx,8)
movupd %xmm7,-0x20(%r13,%rbx,8)
mulpd  %xmm5,%xmm4
mulpd  %xmm5,%xmm3
movupd %xmm4,-0x10(%r13,%rbx,8)
movupd %xmm3,0x0(%r13,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    16f0 <matinv+0x5e0>
testb  $0x1,0x30(%rsp)
je     176c <matinv+0x65c>
add    0x8(%rsp),%rbx
movupd (%rsi,%rbx,8),%xmm3
movupd 0x10(%rsi,%rbx,8),%xmm4
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm4
movupd %xmm3,(%rsi,%rbx,8)
movupd %xmm4,0x10(%rsi,%rbx,8)
mov    0x40(%rsp),%rdi
mov    %rdi,%rcx
cmp    %rax,%rdi
je     1200 <matinv+0xf0>
nopl   (%rax)
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1780 <matinv+0x670>
jmp    1200 <matinv+0xf0>
xor    %ebx,%ebx
testb  $0x1,0x30(%rsp)
jne    1749 <matinv+0x639>
jmp    176c <matinv+0x65c>
xor    %ebx,%ebx
testb  $0x1,0x30(%rsp)
jne    140f <matinv+0x2ff>
jmp    144b <matinv+0x33b>
add    $0x1,%r10d
lea    0x869(%rip),%rdi
mov    %r10d,%esi
call   1030 <printf@plt>
mov    $0xffffffff,%eax
jmp    18d1 <matinv+0x7c1>
cmpl   $0x0,0x54(%rsp)
jle    18cf <matinv+0x7bf>
mov    %r11,%r9
mov    0x18(%rsp),%rax
and    $0xfffffffe,%r11d
mov    %rax,%rdx
shl    $0x4,%rdx
add    %r9,%rax
lea    -0x8(,%rax,8),%rdi
ff
lea    -0x8(,%r9,8),%rbp
ff
jmp    1822 <matinv+0x712>
nopl   0x0(%rax)
add    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rbp
cmp    $0x1,%r10
jle    18cf <matinv+0x7bf>
mov    %r9,%r10
add    $0xffffffffffffffff,%r9
mov    -0x4(%r14,%r10,4),%eax
cmp    %rax,%r9
je     1810 <matinv+0x700>
movslq %eax,%rbx
cmpl   $0x1,0x48(%rsp)
jne    1850 <matinv+0x740>
xor    %ecx,%ecx
jmp    1894 <matinv+0x784>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
add    %rbx,%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,1),%xmm0
movsd  (%rsi,%rbx,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,1)
movsd  %xmm0,(%rsi,%rbx,8)
movsd  (%rsi,%rdi,1),%xmm0
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%rdi,1)
movsd  %xmm0,(%rsi,%rax,8)
add    $0x2,%rcx
add    %rdx,%rsi
cmp    %rcx,%r11
jne    1860 <matinv+0x750>
testb  $0x1,0x48(%rsp)
mov    0x20(%rsp),%r14
mov    0x10(%rsp),%rsi
je     1810 <matinv+0x700>
imul   0x18(%rsp),%rcx
lea    (%rcx,%r9,1),%rax
movsd  (%rsi,%rax,8),%xmm0
add    %rbx,%rcx
movsd  (%rsi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  %xmm0,(%rsi,%rcx,8)
jmp    1810 <matinv+0x700>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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