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


x86 assembly (clang, -O0):
<matinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
movsd  0xec2(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xead(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1187 <matinv+0x67>
mov    -0x1c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    115f <matinv+0x3f>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14dc <matinv+0x3bc>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe59(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124c <matinv+0x12c>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe19(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1239 <matinv+0x119>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdee(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    123e <matinv+0x11e>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c9 <matinv+0xa9>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12a9 <matinv+0x189>
movsd  -0x50(%rbp),%xmm0
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
lea    0xd86(%rip),%rdi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1040 <exit@plt>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
je     1355 <matinv+0x235>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1350 <matinv+0x230>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12c4 <matinv+0x1a4>
jmp    1355 <matinv+0x235>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xc92(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1472 <matinv+0x352>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    139c <matinv+0x27c>
jmp    1464 <matinv+0x344>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1432 <matinv+0x312>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x24(%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    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13c3 <matinv+0x2a3>
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    137f <matinv+0x25f>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14b3 <matinv+0x393>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1479 <matinv+0x359>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    118e <matinv+0x6e>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     15ae <matinv+0x48e>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jne    1508 <matinv+0x3e8>
jmp    15a0 <matinv+0x480>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    159b <matinv+0x47b>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x1c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x1c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    150f <matinv+0x3ef>
jmp    15a0 <matinv+0x480>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    14e5 <matinv+0x3c5>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
xor    %eax,%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
movsd  0xec6(%rip),%xmm9
test   %esi,%esi
jle    1a99 <matinv+0x979>
mov    %edx,%r14d
mov    %rdi,%r12
mov    %esi,%r8d
cmp    $0x8,%esi
jae    1157 <matinv+0x37>
xor    %eax,%eax
jmp    12b0 <matinv+0x190>
mov    %r8d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdx
jae    1186 <matinv+0x66>
movdqa 0xe91(%rip),%xmm0
xor    %edi,%edi
jmp    1258 <matinv+0x138>
and    $0xfffffffffffffffc,%rbp
movdqa 0xe7e(%rip),%xmm0
xor    %edi,%edi
movdqa 0xe83(%rip),%xmm8
movdqa 0xe8a(%rip),%xmm10
movdqa 0xe91(%rip),%xmm11
movdqa 0xe99(%rip),%xmm5
movdqa 0xea1(%rip),%xmm6
movdqa 0xea9(%rip),%xmm7
movdqa 0xeb1(%rip),%xmm2
movdqa 0xeb9(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm8,%xmm3
movdqu %xmm0,(%rcx,%rdi,4)
movdqu %xmm3,0x10(%rcx,%rdi,4)
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqa %xmm0,%xmm4
paddd  %xmm11,%xmm4
movdqu %xmm3,0x20(%rcx,%rdi,4)
movdqu %xmm4,0x30(%rcx,%rdi,4)
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqa %xmm0,%xmm4
paddd  %xmm6,%xmm4
movdqu %xmm3,0x40(%rcx,%rdi,4)
movdqu %xmm4,0x50(%rcx,%rdi,4)
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqa %xmm0,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm3,0x60(%rcx,%rdi,4)
movdqu %xmm4,0x70(%rcx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rbp
jne    11e0 <matinv+0xc0>
test   %rbx,%rbx
je     12a0 <matinv+0x180>
lea    (%rcx,%rdi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %edi,%edi
movdqa 0xdad(%rip),%xmm1
movdqa 0xdb5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rdi,1)
movdqu %xmm3,(%rdx,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rbx
jne    1280 <matinv+0x160>
cmp    %r8,%rax
je     12bc <matinv+0x19c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r8
jne    12b0 <matinv+0x190>
test   %esi,%esi
jle    1a99 <matinv+0x979>
mov    %esi,0x38(%rsp)
movslq %r14d,%rax
mov    %eax,%r10d
lea    (%r12,%r10,8),%rdx
mov    %rdx,0x88(%rsp)
mov    %r10d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x30(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x28(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,0x20(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x18(%rsp)
mov    %r10,%rdx
neg    %rdx
mov    %rdx,0x80(%rsp)
lea    (%r12,%rax,8),%rsi
lea    0x0(,%rax,8),%r11
mov    %rax,0x8(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x90(%rsp)
lea    0x30(%r12),%r15
lea    0x8(%r12),%rax
movsd  0xcb4(%rip),%xmm11
mov    $0x1,%ebx
xor    %r13d,%r13d
movapd 0xd43(%rip),%xmm12
movsd  0xca2(%rip),%xmm8
movapd 0xd41(%rip),%xmm10
movapd %xmm11,%xmm9
mov    %r12,%rdi
mov    %rax,0x48(%rsp)
mov    %rax,0x10(%rsp)
mov    %r15,0x40(%rsp)
mov    %r8,0x68(%rsp)
mov    %rcx,0x50(%rsp)
mov    %r14d,0x3c(%rsp)
jmp    13cb <matinv+0x2ab>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rax
movsd  %xmm13,(%r12,%rax,8)
add    $0x1,%rbx
add    0x90(%rsp),%rsi
add    %r11,%r15
add    %r11,0x10(%rsp)
add    %r11,%rdi
cmp    %r8,%r13
je     19aa <matinv+0x88a>
mov    %r13d,%eax
imul   %r14d,%eax
cltq
add    %r13,%rax
mov    %rax,0x60(%rsp)
movsd  (%r12,%rax,8),%xmm6
movapd %xmm6,%xmm0
andpd  %xmm12,%xmm0
lea    0x1(%r13),%rax
mov    %rax,0x58(%rsp)
cmp    %r8,%rax
jae    1440 <matinv+0x320>
mov    %rsi,%rax
mov    %rbx,%rdx
jmp    141c <matinv+0x2fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    %r11,%rax
cmp    %rdx,%r8
je     1440 <matinv+0x320>
movsd  (%rax),%xmm1
andpd  %xmm12,%xmm1
ucomisd %xmm0,%xmm1
jbe    1410 <matinv+0x2f0>
mov    %edx,(%rcx,%r13,4)
movapd %xmm1,%xmm0
jmp    1410 <matinv+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd %xmm0,%xmm8
ja     1ab2 <matinv+0x992>
mov    %r13,%rdx
imul   0x8(%rsp),%rdx
lea    (%rdx,%r10,1),%rax
mov    %rdx,(%rsp)
lea    (%r12,%rdx,8),%rdx
mov    %rdx,0x70(%rsp)
lea    (%r12,%rax,8),%rax
mov    %rax,0x78(%rsp)
mov    (%rcx,%r13,4),%eax
mov    %eax,%edx
imul   %r14d,%edx
movslq %edx,%rbp
mov    %r13,%rdx
add    %rbp,%rdx
mulsd  (%r12,%rdx,8),%xmm9
cmp    %rax,%r13
mov    %rsi,0xa0(%rsp)
mov    %rbx,0x98(%rsp)
je     1660 <matinv+0x540>
test   %r14d,%r14d
jle    1660 <matinv+0x540>
cmp    $0x4,%r14d
jae    14c0 <matinv+0x3a0>
xor    %eax,%eax
mov    0x10(%rsp),%rbx
jmp    15d0 <matinv+0x4b0>
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%rax
lea    (%rax,%rbp,8),%rax
cmp    %rax,0x70(%rsp)
mov    0x10(%rsp),%rbx
jae    14ea <matinv+0x3ca>
lea    (%r12,%rbp,8),%rax
cmp    0x78(%rsp),%rax
jae    14ea <matinv+0x3ca>
xor    %eax,%eax
jmp    15d0 <matinv+0x4b0>
cmpq   $0x0,0x28(%rsp)
je     1998 <matinv+0x878>
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,8),%rdx
mov    0x18(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r15,%rsi,8),%xmm0
movups -0x20(%r15,%rsi,8),%xmm1
movups -0x30(%rdx,%rsi,8),%xmm4
movups -0x20(%rdx,%rsi,8),%xmm6
movups %xmm4,-0x30(%r15,%rsi,8)
movups %xmm6,-0x20(%r15,%rsi,8)
movups %xmm0,-0x30(%rdx,%rsi,8)
movups %xmm1,-0x20(%rdx,%rsi,8)
movupd -0x10(%r15,%rsi,8),%xmm0
movupd (%r15,%rsi,8),%xmm1
movdqu -0x10(%rdx,%rsi,8),%xmm4
movupd (%rdx,%rsi,8),%xmm6
movdqu %xmm4,-0x10(%r15,%rsi,8)
movupd %xmm6,(%r15,%rsi,8)
movupd %xmm0,-0x10(%rdx,%rsi,8)
movupd %xmm1,(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    1510 <matinv+0x3f0>
testb  $0x1,0x20(%rsp)
je     15bb <matinv+0x49b>
mov    (%rsp),%rax
add    %rsi,%rax
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
add    %rbp,%rsi
movdqu (%r12,%rsi,8),%xmm4
movupd 0x10(%r12,%rsi,8),%xmm6
movdqu %xmm4,(%r12,%rax,8)
movupd %xmm6,0x10(%r12,%rax,8)
movupd %xmm0,(%r12,%rsi,8)
movupd %xmm1,0x10(%r12,%rsi,8)
mov    0x30(%rsp),%rdx
mov    %rdx,%rax
cmp    %r10,%rdx
je     1655 <matinv+0x535>
nopl   0x0(%rax)
mov    %rax,%rdx
test   $0x1,%r10b
je     1603 <matinv+0x4e3>
mov    (%rsp),%rdx
add    %rax,%rdx
movsd  (%r12,%rdx,8),%xmm0
lea    (%rax,%rbp,1),%rsi
movsd  (%r12,%rsi,8),%xmm1
movsd  %xmm1,(%r12,%rdx,8)
movsd  %xmm0,(%r12,%rsi,8)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    0x80(%rsp),%rax
je     1655 <matinv+0x535>
mov    0x48(%rsp),%rax
lea    (%rax,%rbp,8),%rax
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rdx,8),%xmm0
movsd  -0x8(%rax,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rdx,8)
movsd  %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm0
movsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    1620 <matinv+0x500>
mov    0x60(%rsp),%rax
movsd  (%r12,%rax,8),%xmm6
movapd %xmm11,%xmm13
divsd  %xmm6,%xmm13
movapd %xmm13,%xmm6
xorpd  %xmm10,%xmm6
mov    0x48(%rsp),%rbp
mov    0x40(%rsp),%rbx
xor    %esi,%esi
jmp    16a9 <matinv+0x589>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm4,(%r12,%r9,8)
add    $0x1,%rsi
add    %r11,%rbx
add    %r11,%rbp
cmp    %r8,%rsi
je     1890 <matinv+0x770>
cmp    %r13,%rsi
je     1696 <matinv+0x576>
mov    %rsi,%rcx
imul   0x8(%rsp),%rcx
lea    (%rcx,%r13,1),%r9
movsd  (%r12,%r9,8),%xmm4
mulsd  %xmm6,%xmm4
test   %r14d,%r14d
jle    1690 <matinv+0x570>
cmp    $0x4,%r14d
jb     16f2 <matinv+0x5d2>
lea    (%r12,%rcx,8),%rax
cmp    0x78(%rsp),%rax
jae    1779 <matinv+0x659>
lea    (%rcx,%r10,1),%rax
lea    (%r12,%rax,8),%rax
cmp    %rax,0x70(%rsp)
jae    1779 <matinv+0x659>
xor    %eax,%eax
mov    %rax,%rdx
test   $0x1,%r10b
je     1724 <matinv+0x604>
mov    (%rsp),%rdx
add    %rax,%rdx
add    %rax,%rcx
movsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    0x80(%rsp),%rax
je     1690 <matinv+0x570>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rdx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  -0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdx,8)
movsd  0x8(%rdi,%rdx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    1740 <matinv+0x620>
jmp    1690 <matinv+0x570>
movapd %xmm4,%xmm7
unpcklpd %xmm4,%xmm7
cmpq   $0x0,0x28(%rsp)
je     1883 <matinv+0x763>
mov    0x18(%rsp),%r14
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%r15,%r8,8),%xmm1
movupd -0x20(%r15,%r8,8),%xmm5
mulpd  %xmm7,%xmm1
movupd -0x30(%rbx,%r8,8),%xmm2
addpd  %xmm1,%xmm2
movupd -0x20(%rbx,%r8,8),%xmm1
movupd -0x10(%rbx,%r8,8),%xmm3
movupd (%rbx,%r8,8),%xmm0
mulpd  %xmm7,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm2,-0x30(%rbx,%r8,8)
movupd %xmm5,-0x20(%rbx,%r8,8)
movupd -0x10(%r15,%r8,8),%xmm1
movupd (%r15,%r8,8),%xmm2
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%rbx,%r8,8)
movupd %xmm2,(%rbx,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r14
jne    17a0 <matinv+0x680>
testb  $0x1,0x20(%rsp)
je     1863 <matinv+0x743>
mov    (%rsp),%rax
add    %r8,%rax
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
add    %rcx,%r8
movupd (%r12,%r8,8),%xmm2
movupd 0x10(%r12,%r8,8),%xmm3
mulpd  %xmm7,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%r12,%r8,8)
movupd %xmm1,0x10(%r12,%r8,8)
mov    0x30(%rsp),%rdx
mov    %rdx,%rax
cmp    %r10,%rdx
mov    0x68(%rsp),%r8
mov    0x3c(%rsp),%r14d
je     1690 <matinv+0x570>
jmp    16f4 <matinv+0x5d4>
xor    %r8d,%r8d
testb  $0x1,0x20(%rsp)
jne    1822 <matinv+0x702>
jmp    1863 <matinv+0x743>
nop
test   %r14d,%r14d
mov    0x50(%rsp),%rcx
mov    0xa0(%rsp),%rsi
mov    0x98(%rsp),%rbx
mov    0x58(%rsp),%r13
jle    13a0 <matinv+0x280>
cmp    $0x4,%r14d
jae    18c0 <matinv+0x7a0>
xor    %eax,%eax
jmp    1970 <matinv+0x850>
movapd %xmm13,%xmm4
unpcklpd %xmm13,%xmm4
cmpq   $0x0,0x28(%rsp)
je     198d <matinv+0x86d>
mov    0x18(%rsp),%rax
xor    %edx,%edx
nopl   (%rax)
movupd -0x30(%r15,%rdx,8),%xmm1
movupd -0x20(%r15,%rdx,8),%xmm6
movupd -0x10(%r15,%rdx,8),%xmm7
movupd (%r15,%rdx,8),%xmm5
mulpd  %xmm4,%xmm1
mulpd  %xmm4,%xmm6
movupd %xmm1,-0x30(%r15,%rdx,8)
movupd %xmm6,-0x20(%r15,%rdx,8)
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm5
movupd %xmm7,-0x10(%r15,%rdx,8)
movupd %xmm5,(%r15,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    18e0 <matinv+0x7c0>
testb  $0x1,0x20(%rsp)
je     195d <matinv+0x83d>
add    (%rsp),%rdx
movupd (%r12,%rdx,8),%xmm1
movupd 0x10(%r12,%rdx,8),%xmm5
mulpd  %xmm4,%xmm1
mulpd  %xmm4,%xmm5
movupd %xmm1,(%r12,%rdx,8)
movupd %xmm5,0x10(%r12,%rdx,8)
mov    0x30(%rsp),%rdx
mov    %rdx,%rax
cmp    %r10,%rdx
je     13a0 <matinv+0x280>
xchg   %ax,%ax
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm13,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1970 <matinv+0x850>
jmp    13a0 <matinv+0x280>
xor    %edx,%edx
testb  $0x1,0x20(%rsp)
jne    1937 <matinv+0x817>
jmp    195d <matinv+0x83d>
xor    %esi,%esi
testb  $0x1,0x20(%rsp)
jne    157d <matinv+0x45d>
jmp    15bb <matinv+0x49b>
mov    0x38(%rsp),%r14d
test   %r14d,%r14d
jle    1a99 <matinv+0x979>
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
mov    0x8(%rsp),%rax
mov    %rax,%r11
shl    $0x4,%r11
add    %r8,%rax
lea    -0x8(,%rax,8),%rdx
ff
lea    -0x8(,%r8,8),%rsi
ff
jmp    19f7 <matinv+0x8d7>
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    $0x1,%r9
mov    0x50(%rsp),%rcx
jle    1a99 <matinv+0x979>
mov    %r8,%r9
add    $0xffffffffffffffff,%r8
mov    -0x4(%rcx,%r9,4),%eax
cmp    %rax,%r8
je     19e0 <matinv+0x8c0>
movslq %eax,%rbx
cmp    $0x1,%r14d
jne    1a20 <matinv+0x900>
xor    %ebp,%ebp
jmp    1a64 <matinv+0x944>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rax
lea    (%rax,%rbx,1),%rdi
mov    %r12,%rax
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%rax,%rsi,1),%xmm0
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,(%rax,%rsi,1)
movsd  %xmm0,(%rax,%rbx,8)
movq   (%rax,%rdx,1),%xmm0
movq   (%rax,%rdi,8),%xmm1
movq   %xmm1,(%rax,%rdx,1)
movq   %xmm0,(%rax,%rdi,8)
add    $0x2,%rbp
add    %r11,%rax
cmp    %rbp,%r10
jne    1a30 <matinv+0x910>
testb  $0x1,0x68(%rsp)
je     19e0 <matinv+0x8c0>
imul   0x8(%rsp),%rbp
lea    (%r8,%rbp,1),%rax
movq   (%r12,%rax,8),%xmm0
add    %rbx,%rbp
movq   (%r12,%rbp,8),%xmm1
movq   %xmm1,(%r12,%rax,8)
movq   %xmm0,(%r12,%rbp,8)
jmp    19e0 <matinv+0x8c0>
movsd  %xmm9,(%rcx)
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x607(%rip),%rdi
mov    0x58(%rsp),%rsi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1040 <exit@plt>

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

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