#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 *, int);
int matinv(double x[], int n, int m, double space[]) {
  register int i, j, k;
  int *irow = (int *)space;
  double ee = 1.0e-20, 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 becomes zero at %3d!\t\n", 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 < n; 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    1460 <matinv+0x350>
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    122d <matinv+0x11d>
mov    -0x24(%rbp),%esi
add    $0x1,%esi
lea    0xe04(%rip),%rdi
call   1030 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1539 <matinv+0x429>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
je     12d9 <matinv+0x1c9>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12d4 <matinv+0x1c4>
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    1248 <matinv+0x138>
jmp    12d9 <matinv+0x1c9>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd0e(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f6 <matinv+0x2e6>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1320 <matinv+0x210>
jmp    13e8 <matinv+0x2d8>
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    -0x14(%rbp),%eax
jge    13b6 <matinv+0x2a6>
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    1347 <matinv+0x237>
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    1303 <matinv+0x1f3>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1437 <matinv+0x327>
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    13fd <matinv+0x2ed>
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     1532 <matinv+0x422>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    148c <matinv+0x37c>
jmp    1524 <matinv+0x414>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    151f <matinv+0x40f>
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    1493 <matinv+0x383>
jmp    1524 <matinv+0x414>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1469 <matinv+0x359>
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    $0xb8,%rsp
test   %esi,%esi
jle    192e <matinv+0x81e>
mov    %rdi,%r13
movslq %edx,%rdi
mov    %esi,0x18(%rsp)
mov    %esi,%eax
mov    %edi,%r11d
lea    0x0(,%r11,8),%rsi
add    %r13,%rsi
mov    %rsi,0x68(%rsp)
mov    %r11d,%esi
and    $0xfffffffc,%esi
mov    %rsi,0x38(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x30(%rsp)
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %eax,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xa8(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xa0(%rsp)
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
lea    -0x1(%rax),%rsi
mov    %rsi,0x60(%rsp)
mov    %r11,%rsi
neg    %rsi
mov    %rsi,0x70(%rsp)
mov    %rbx,%rsi
mov    %rbx,0x98(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x90(%rsp)
mov    %rbp,%rsi
mov    %rbp,0x28(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x20(%rsp)
lea    0x0(,%rdi,8),%r12
movapd 0xe28(%rip),%xmm11
movsd  0xe3f(%rip),%xmm10
movsd  0xe3e(%rip),%xmm9
movapd 0xe1d(%rip),%xmm8
mov    %rdi,0x10(%rsp)
lea    0x8(,%rdi,8),%rsi
mov    %rsi,0x78(%rsp)
lea    0x30(%r13),%r14
lea    0x8(%r13),%r15
xor    %r9d,%r9d
mov    %r13,%rdi
mov    %r15,0x48(%rsp)
mov    %r14,0x40(%rsp)
mov    %r13,%r8
mov    %rcx,0x50(%rsp)
mov    %edx,0x1c(%rsp)
jmp    125a <matinv+0x14a>
nopl   0x0(%rax,%rax,1)
mov    0x80(%rsp),%rsi
movsd  %xmm12,0x0(%r13,%rsi,8)
add    $0x1,%r9
add    0x78(%rsp),%r8
add    %r12,%r14
add    %r12,%r15
add    %r12,%rdi
cmp    %rax,%r9
je     1847 <matinv+0x737>
mov    %r9,%rbx
imul   0x10(%rsp),%rbx
lea    0x0(,%rbx,8),%rsi
add    %r13,%rsi
mov    %rsi,0x58(%rsp)
lea    (%rbx,%r11,1),%rsi
lea    0x0(%r13,%rsi,8),%rbp
mov    %rbx,0x8(%rsp)
lea    (%rbx,%rax,1),%rsi
lea    0x0(%r13,%rsi,8),%rsi
mov    %rsi,0xb0(%rsp)
xorpd  %xmm4,%xmm4
mov    %r8,%rbx
mov    %r9,%rsi
jmp    12ac <matinv+0x19c>
xchg   %ax,%ax
add    $0x1,%rsi
add    %r12,%rbx
cmp    %rsi,%rax
je     12d0 <matinv+0x1c0>
movsd  (%rbx),%xmm5
andpd  %xmm11,%xmm5
ucomisd %xmm4,%xmm5
jbe    12a0 <matinv+0x190>
mov    %esi,(%rcx,%r9,4)
movapd %xmm5,%xmm4
jmp    12a0 <matinv+0x190>
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd %xmm4,%xmm10
ja     182a <matinv+0x71a>
mov    %r8,0x88(%rsp)
mov    (%rcx,%r9,4),%esi
cmp    %rsi,%r9
je     14b0 <matinv+0x3a0>
test   %edx,%edx
jle    14b0 <matinv+0x3a0>
imul   %edx,%esi
movslq %esi,%r8
cmp    $0x4,%edx
jb     132b <matinv+0x21b>
mov    0x68(%rsp),%rsi
lea    (%rsi,%r8,8),%rsi
cmp    %rsi,0x58(%rsp)
jae    13c0 <matinv+0x2b0>
lea    0x0(,%r8,8),%rsi
add    %r13,%rsi
cmp    %rbp,%rsi
jae    13c0 <matinv+0x2b0>
xor    %ebx,%ebx
mov    %rbx,%rsi
test   $0x1,%r11b
je     1365 <matinv+0x255>
mov    0x8(%rsp),%rsi
add    %rbx,%rsi
movsd  0x0(%r13,%rsi,8),%xmm4
lea    (%rbx,%r8,1),%rbp
movsd  0x0(%r13,%rbp,8),%xmm5
movsd  %xmm5,0x0(%r13,%rsi,8)
movsd  %xmm4,0x0(%r13,%rbp,8)
mov    %rbx,%rsi
or     $0x1,%rsi
not    %rbx
cmp    0x70(%rsp),%rbx
je     14b0 <matinv+0x3a0>
mov    0x48(%rsp),%rbp
lea    0x0(%rbp,%r8,8),%rbp
nopl   (%rax)
movsd  -0x8(%r15,%rsi,8),%xmm4
movsd  -0x8(%rbp,%rsi,8),%xmm5
movsd  %xmm5,-0x8(%r15,%rsi,8)
movsd  %xmm4,-0x8(%rbp,%rsi,8)
movsd  (%r15,%rsi,8),%xmm4
movsd  0x0(%rbp,%rsi,8),%xmm5
movsd  %xmm5,(%r15,%rsi,8)
movsd  %xmm4,0x0(%rbp,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r11
jne    1380 <matinv+0x270>
jmp    14b0 <matinv+0x3a0>
cmpq   $0x0,0x30(%rsp)
je     1818 <matinv+0x708>
mov    0x40(%rsp),%rsi
lea    (%rsi,%r8,8),%rsi
mov    0x20(%rsp),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x30(%r14,%rbx,8),%xmm4
movups -0x20(%r14,%rbx,8),%xmm5
movups -0x30(%rsi,%rbx,8),%xmm6
movups -0x20(%rsi,%rbx,8),%xmm7
movups %xmm6,-0x30(%r14,%rbx,8)
movups %xmm7,-0x20(%r14,%rbx,8)
movups %xmm4,-0x30(%rsi,%rbx,8)
movups %xmm5,-0x20(%rsi,%rbx,8)
movupd -0x10(%r14,%rbx,8),%xmm4
movupd (%r14,%rbx,8),%xmm5
movupd -0x10(%rsi,%rbx,8),%xmm6
movupd (%rsi,%rbx,8),%xmm7
movupd %xmm6,-0x10(%r14,%rbx,8)
movupd %xmm7,(%r14,%rbx,8)
movupd %xmm4,-0x10(%rsi,%rbx,8)
movupd %xmm5,(%rsi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    13e0 <matinv+0x2d0>
testb  $0x1,0x28(%rsp)
je     1490 <matinv+0x380>
mov    0x8(%rsp),%rsi
add    %rbx,%rsi
movupd 0x0(%r13,%rsi,8),%xmm4
movupd 0x10(%r13,%rsi,8),%xmm5
add    %r8,%rbx
movupd 0x0(%r13,%rbx,8),%xmm6
movupd 0x10(%r13,%rbx,8),%xmm7
movupd %xmm6,0x0(%r13,%rsi,8)
movupd %xmm7,0x10(%r13,%rsi,8)
movupd %xmm4,0x0(%r13,%rbx,8)
movupd %xmm5,0x10(%r13,%rbx,8)
mov    0x38(%rsp),%rsi
mov    %rsi,%rbx
cmp    %r11,%rsi
jne    132d <matinv+0x21d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rcx
add    %r9,%rcx
movapd %xmm9,%xmm12
mov    %rcx,0x80(%rsp)
divsd  0x0(%r13,%rcx,8),%xmm12
movapd %xmm12,%xmm5
xorpd  %xmm8,%xmm5
mov    0x48(%rsp),%rdx
mov    0x40(%rsp),%r10
xor    %ebx,%ebx
jmp    150a <matinv+0x3fa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm6,0x0(%r13,%r8,8)
add    $0x1,%rbx
add    %r12,%r10
add    %r12,%rdx
cmp    %rax,%rbx
je     1700 <matinv+0x5f0>
cmp    %r9,%rbx
je     14f7 <matinv+0x3e7>
mov    %rbx,%rbp
imul   0x10(%rsp),%rbp
lea    (%r9,%rbp,1),%r8
movsd  0x0(%r13,%r8,8),%xmm6
mulsd  %xmm5,%xmm6
cmpl   $0x4,0x18(%rsp)
jb     155d <matinv+0x44d>
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
cmp    0xb0(%rsp),%rcx
jae    15d7 <matinv+0x4c7>
lea    (%rax,%rbp,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cmp    %rcx,0x58(%rsp)
jae    15d7 <matinv+0x4c7>
xor    %esi,%esi
mov    %rsi,%rcx
test   $0x1,%al
je     1591 <matinv+0x481>
mov    0x8(%rsp),%rcx
add    %rsi,%rcx
add    %rsi,%rbp
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
mov    %rsi,%rcx
or     $0x1,%rcx
cmp    %rsi,0x60(%rsp)
je     14f0 <matinv+0x3e0>
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  -0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    15a0 <matinv+0x490>
jmp    14f0 <matinv+0x3e0>
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
cmpq   $0x0,0xa0(%rsp)
je     16e3 <matinv+0x5d3>
mov    0x90(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r14,%rcx,8),%xmm2
movupd -0x20(%r14,%rcx,8),%xmm3
mulpd  %xmm7,%xmm2
movupd -0x30(%r10,%rcx,8),%xmm1
addpd  %xmm2,%xmm1
movupd -0x20(%r10,%rcx,8),%xmm2
movupd -0x10(%r10,%rcx,8),%xmm0
movupd (%r10,%rcx,8),%xmm4
mulpd  %xmm7,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm1,-0x30(%r10,%rcx,8)
movupd %xmm3,-0x20(%r10,%rcx,8)
movupd -0x10(%r14,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm7,%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r10,%rcx,8)
movupd %xmm2,(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1600 <matinv+0x4f0>
testb  $0x1,0x98(%rsp)
01
je     16ca <matinv+0x5ba>
mov    0x8(%rsp),%rsi
add    %rcx,%rsi
movupd 0x0(%r13,%rsi,8),%xmm0
movupd 0x10(%r13,%rsi,8),%xmm1
add    %rbp,%rcx
movupd 0x0(%r13,%rcx,8),%xmm2
movupd 0x10(%r13,%rcx,8),%xmm3
mulpd  %xmm7,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x0(%r13,%rcx,8)
movupd %xmm1,0x10(%r13,%rcx,8)
mov    0xa8(%rsp),%rcx
mov    %rcx,%rsi
cmp    %rax,%rcx
je     14f0 <matinv+0x3e0>
jmp    155f <matinv+0x44f>
xor    %ecx,%ecx
testb  $0x1,0x98(%rsp)
01
jne    1685 <matinv+0x575>
jmp    16ca <matinv+0x5ba>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%edx
test   %edx,%edx
mov    0x50(%rsp),%rcx
mov    0x88(%rsp),%r8
jle    1230 <matinv+0x120>
cmp    $0x4,%edx
jae    1730 <matinv+0x620>
xor    %esi,%esi
jmp    17f0 <matinv+0x6e0>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm12,%xmm5
unpcklpd %xmm12,%xmm5
cmpq   $0x0,0x30(%rsp)
je     180d <matinv+0x6fd>
mov    0x20(%rsp),%rbp
xor    %esi,%esi
nopl   (%rax)
movupd -0x30(%r14,%rsi,8),%xmm6
movupd -0x20(%r14,%rsi,8),%xmm7
movupd -0x10(%r14,%rsi,8),%xmm3
movupd (%r14,%rsi,8),%xmm2
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm7
movupd %xmm6,-0x30(%r14,%rsi,8)
movupd %xmm7,-0x20(%r14,%rsi,8)
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
movupd %xmm3,-0x10(%r14,%rsi,8)
movupd %xmm2,(%r14,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbp
jne    1750 <matinv+0x640>
testb  $0x1,0x28(%rsp)
je     17d0 <matinv+0x6c0>
add    0x8(%rsp),%rsi
movupd 0x0(%r13,%rsi,8),%xmm2
movupd 0x10(%r13,%rsi,8),%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,0x0(%r13,%rsi,8)
movupd %xmm3,0x10(%r13,%rsi,8)
mov    0x38(%rsp),%rbp
mov    %rbp,%rsi
cmp    %r11,%rbp
je     1230 <matinv+0x120>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rsi,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r11
jne    17f0 <matinv+0x6e0>
jmp    1230 <matinv+0x120>
xor    %esi,%esi
testb  $0x1,0x28(%rsp)
jne    17a7 <matinv+0x697>
jmp    17d0 <matinv+0x6c0>
xor    %ebx,%ebx
testb  $0x1,0x28(%rsp)
jne    144d <matinv+0x33d>
jmp    1490 <matinv+0x380>
add    $0x1,%r9d
lea    0x7fb(%rip),%rdi
mov    %r9d,%esi
call   1030 <printf@plt>
mov    $0xffffffff,%eax
jmp    1930 <matinv+0x820>
cmpl   $0x0,0x18(%rsp)
jle    192e <matinv+0x81e>
mov    %eax,%r10d
and    $0xfffffffe,%r10d
mov    0x10(%rsp),%rdx
mov    %rdx,%r11
shl    $0x4,%r11
add    %rax,%rdx
lea    -0x8(,%rdx,8),%rsi
ff
lea    -0x8(,%rax,8),%rdi
ff
mov    %rax,%r8
jmp    1897 <matinv+0x787>
nopl   (%rax)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffff8,%rdi
cmp    $0x1,%r9
mov    0x50(%rsp),%rcx
jle    192e <matinv+0x81e>
mov    %r8,%r9
add    $0xffffffffffffffff,%r8
mov    -0x4(%rcx,%r9,4),%ecx
cmp    %rcx,%r8
je     1880 <matinv+0x770>
movslq %ecx,%rbx
cmpq   $0x0,0x60(%rsp)
je     18fa <matinv+0x7ea>
mov    0x10(%rsp),%rcx
add    %rbx,%rcx
mov    %r13,%rdx
xor    %ebp,%ebp
movsd  (%rdx,%rdi,1),%xmm0
movsd  (%rdx,%rbx,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,1)
movsd  %xmm0,(%rdx,%rbx,8)
movsd  (%rdx,%rsi,1),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,1)
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x2,%rbp
add    %r11,%rdx
cmp    %rbp,%r10
jne    18c0 <matinv+0x7b0>
test   $0x1,%al
je     1880 <matinv+0x770>
jmp    1900 <matinv+0x7f0>
xor    %ebp,%ebp
test   $0x1,%al
je     1880 <matinv+0x770>
imul   0x10(%rsp),%rbp
lea    (%r8,%rbp,1),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
add    %rbx,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  %xmm0,0x0(%r13,%rbp,8)
jmp    1880 <matinv+0x770>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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