#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*/ free(int *);
scalar_t__ mCalloc(int, int);
int /*<<< orphan*/ printf(char *, int);
int Matinv(double *x, int n, int m, double *space) {
  int i, j, k;
  int *irow;
  double ee, t, t1, xmax;
  double det;
  ee = 1.0E-20;
  det = 1.0;
  irow = (int *)mCalloc(n, sizeof(int));
  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 < 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;
    }
  }
  free(irow);
  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)
movsd  0xeba(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xea5(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x4,%esi
call   1050 <mCalloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1489 <Matinv+0x359>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1215 <Matinv+0xe5>
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 0xe50(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1202 <Matinv+0xd2>
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 0xe25(%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    1207 <Matinv+0xd7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1192 <Matinv+0x62>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1256 <Matinv+0x126>
mov    -0x24(%rbp),%esi
add    $0x1,%esi
lea    0xddb(%rip),%rdi
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    156b <Matinv+0x43b>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
je     1302 <Matinv+0x1d2>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12fd <Matinv+0x1cd>
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    1271 <Matinv+0x141>
jmp    1302 <Matinv+0x1d2>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xce5(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    141f <Matinv+0x2ef>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1349 <Matinv+0x219>
jmp    1411 <Matinv+0x2e1>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13df <Matinv+0x2af>
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    1370 <Matinv+0x240>
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    132c <Matinv+0x1fc>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1460 <Matinv+0x330>
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    1426 <Matinv+0x2f6>
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    1178 <Matinv+0x48>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     155b <Matinv+0x42b>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    14b5 <Matinv+0x385>
jmp    154d <Matinv+0x41d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1548 <Matinv+0x418>
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    14bc <Matinv+0x38c>
jmp    154d <Matinv+0x41d>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1492 <Matinv+0x362>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Matinv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edx,%r15d
mov    %esi,%ebx
mov    %rdi,0x8(%rsp)
mov    %esi,%edi
mov    $0x4,%esi
call   1050 <mCalloc@plt>
mov    %rax,%r11
test   %ebx,%ebx
jle    1982 <Matinv+0x852>
mov    %ebx,0x4c(%rsp)
mov    %ebx,%r8d
movslq %r15d,%rsi
mov    %esi,%edi
mov    0x8(%rsp),%rbp
lea    0x0(,%rdi,8),%rax
add    %rbp,%rax
mov    %rax,0x78(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x40(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rdi,%rax
neg    %rax
mov    %rax,0x70(%rsp)
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%rsi,8),%rdx
mov    %rsi,%r9
lea    0x8(,%rsi,8),%rax
mov    %rax,0x80(%rsp)
lea    0x30(%rbp),%r12
lea    0x8(%rbp),%rax
xor    %esi,%esi
movapd 0xe15(%rip),%xmm11
movsd  0xe2c(%rip),%xmm10
movsd  0xe2b(%rip),%xmm9
movapd 0xe0a(%rip),%xmm8
mov    %rbp,%rbx
mov    %rax,0x58(%rsp)
mov    %rax,%r14
mov    %r12,0x50(%rsp)
mov    %rbp,%r10
mov    %r8,0x20(%rsp)
mov    %r11,0x88(%rsp)
mov    %r9,0x18(%rsp)
jmp    125d <Matinv+0x12d>
nopl   (%rax)
mov    0x90(%rsp),%rax
movsd  %xmm12,0x0(%rbp,%rax,8)
add    $0x1,%rsi
add    0x80(%rsp),%r10
add    %rdx,%r12
add    %rdx,%r14
add    %rdx,%rbx
cmp    %r8,%rsi
je     1883 <Matinv+0x753>
mov    %rsi,%rax
imul   %r9,%rax
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x60(%rsp)
mov    %rax,0x10(%rsp)
add    %rdi,%rax
lea    0x0(%rbp,%rax,8),%rax
mov    %rax,0x68(%rsp)
xorpd  %xmm4,%xmm4
mov    %r10,%rbp
mov    %rsi,%rax
jmp    12ac <Matinv+0x17c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
add    %rdx,%rbp
cmp    %rax,%r8
je     12d0 <Matinv+0x1a0>
movsd  0x0(%rbp),%xmm5
andpd  %xmm11,%xmm5
ucomisd %xmm4,%xmm5
jbe    12a0 <Matinv+0x170>
mov    %eax,(%r11,%rsi,4)
movapd %xmm5,%xmm4
jmp    12a0 <Matinv+0x170>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm4,%xmm10
ja     186a <Matinv+0x73a>
mov    %r10,0x98(%rsp)
mov    (%r11,%rsi,4),%eax
cmp    %rax,%rsi
mov    0x8(%rsp),%rbp
je     14c0 <Matinv+0x390>
test   %r15d,%r15d
jle    14c0 <Matinv+0x390>
imul   %r15d,%eax
movslq %eax,%r9
cmp    $0x4,%r15d
jb     1335 <Matinv+0x205>
mov    0x78(%rsp),%rax
lea    (%rax,%r9,8),%rax
cmp    %rax,0x60(%rsp)
jae    13de <Matinv+0x2ae>
lea    0x0(,%r9,8),%rax
add    %rbp,%rax
cmp    0x68(%rsp),%rax
jae    13de <Matinv+0x2ae>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dil
je     137f <Matinv+0x24f>
mov    0x10(%rsp),%rax
lea    (%rcx,%rax,1),%r10
movsd  0x0(%rbp,%r10,8),%xmm4
lea    (%rcx,%r9,1),%rbp
mov    0x8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm5
mov    0x8(%rsp),%rax
movsd  %xmm5,(%rax,%r10,8)
mov    0x8(%rsp),%rax
movsd  %xmm4,(%rax,%rbp,8)
mov    0x8(%rsp),%rbp
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x70(%rsp),%rcx
je     14c0 <Matinv+0x390>
mov    0x58(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rax,8),%xmm4
movsd  -0x8(%rcx,%rax,8),%xmm5
movsd  %xmm5,-0x8(%r14,%rax,8)
movsd  %xmm4,-0x8(%rcx,%rax,8)
movsd  (%r14,%rax,8),%xmm4
movsd  (%rcx,%rax,8),%xmm5
movsd  %xmm5,(%r14,%rax,8)
movsd  %xmm4,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    13a0 <Matinv+0x270>
jmp    14c0 <Matinv+0x390>
cmpq   $0x0,0x38(%rsp)
je     1858 <Matinv+0x728>
mov    0x50(%rsp),%rax
lea    (%rax,%r9,8),%rax
mov    0x28(%rsp),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x30(%r12,%rbp,8),%xmm4
movups -0x20(%r12,%rbp,8),%xmm5
movups -0x30(%rax,%rbp,8),%xmm6
movups -0x20(%rax,%rbp,8),%xmm7
movups %xmm6,-0x30(%r12,%rbp,8)
movups %xmm7,-0x20(%r12,%rbp,8)
movups %xmm4,-0x30(%rax,%rbp,8)
movups %xmm5,-0x20(%rax,%rbp,8)
movupd -0x10(%r12,%rbp,8),%xmm4
movupd (%r12,%rbp,8),%xmm5
movupd -0x10(%rax,%rbp,8),%xmm6
movupd (%rax,%rbp,8),%xmm7
movupd %xmm6,-0x10(%r12,%rbp,8)
movupd %xmm7,(%r12,%rbp,8)
movupd %xmm4,-0x10(%rax,%rbp,8)
movupd %xmm5,(%rax,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1400 <Matinv+0x2d0>
testb  $0x1,0x30(%rsp)
je     14a9 <Matinv+0x379>
mov    0x10(%rsp),%rax
add    %rbp,%rax
mov    0x8(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm4
movupd 0x10(%rcx,%rax,8),%xmm5
add    %r9,%rbp
movupd (%rcx,%rbp,8),%xmm6
movupd 0x10(%rcx,%rbp,8),%xmm7
movupd %xmm6,(%rcx,%rax,8)
movupd %xmm7,0x10(%rcx,%rax,8)
movupd %xmm4,(%rcx,%rbp,8)
movupd %xmm5,0x10(%rcx,%rbp,8)
mov    0x40(%rsp),%rax
mov    %rax,%rcx
cmp    %rdi,%rax
mov    0x8(%rsp),%rbp
jne    1337 <Matinv+0x207>
nop
mov    %r14,0xa0(%rsp)
mov    %r15d,%r14d
mov    0x10(%rsp),%rax
add    %rsi,%rax
movapd %xmm9,%xmm12
mov    %rax,0x90(%rsp)
divsd  0x0(%rbp,%rax,8),%xmm12
movapd %xmm12,%xmm5
xorpd  %xmm8,%xmm5
mov    0x58(%rsp),%r10
mov    0x50(%rsp),%r9
xor    %r15d,%r15d
mov    0x18(%rsp),%rcx
jmp    152f <Matinv+0x3ff>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rbp
movsd  %xmm6,0x0(%rbp,%r11,8)
add    $0x1,%r15
add    %rdx,%r9
add    %rdx,%r10
cmp    %r8,%r15
je     1730 <Matinv+0x600>
cmp    %rsi,%r15
je     151c <Matinv+0x3ec>
mov    %r15,%r13
imul   %rcx,%r13
lea    (%rsi,%r13,1),%r11
movsd  0x0(%rbp,%r11,8),%xmm6
mulsd  %xmm5,%xmm6
test   %r14d,%r14d
jle    1510 <Matinv+0x3e0>
cmp    $0x4,%r14d
jb     158a <Matinv+0x45a>
mov    0x8(%rsp),%rbp
lea    0x0(,%r13,8),%rax
add    %rbp,%rax
cmp    0x68(%rsp),%rax
jae    161b <Matinv+0x4eb>
lea    (%rdi,%r13,1),%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rax,0x60(%rsp)
jae    161b <Matinv+0x4eb>
xor    %eax,%eax
mov    %rax,%rbp
test   $0x1,%dil
je     15c9 <Matinv+0x499>
mov    0x10(%rsp),%rcx
add    %rax,%rcx
add    %rax,%r13
mov    0x8(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0x18(%rsp),%rcx
mulsd  %xmm6,%xmm0
addsd  0x0(%rbp,%r13,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r13,8)
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    0x70(%rsp),%rax
je     1510 <Matinv+0x3e0>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  -0x8(%r10,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%r10,%rbp,8)
movsd  0x8(%rbx,%rbp,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r10,%rbp,8),%xmm0
movsd  %xmm0,(%r10,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    15e0 <Matinv+0x4b0>
jmp    1510 <Matinv+0x3e0>
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
cmpq   $0x0,0x38(%rsp)
je     1723 <Matinv+0x5f3>
mov    0x28(%rsp),%r8
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%r12,%rbp,8),%xmm2
movupd -0x20(%r12,%rbp,8),%xmm3
mulpd  %xmm7,%xmm2
movupd -0x30(%r9,%rbp,8),%xmm1
addpd  %xmm2,%xmm1
movupd -0x20(%r9,%rbp,8),%xmm2
movupd -0x10(%r9,%rbp,8),%xmm0
movupd (%r9,%rbp,8),%xmm4
mulpd  %xmm7,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm1,-0x30(%r9,%rbp,8)
movupd %xmm3,-0x20(%r9,%rbp,8)
movupd -0x10(%r12,%rbp,8),%xmm1
movupd (%r12,%rbp,8),%xmm2
mulpd  %xmm7,%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r9,%rbp,8)
movupd %xmm2,(%r9,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%r8
jne    1640 <Matinv+0x510>
testb  $0x1,0x30(%rsp)
je     1703 <Matinv+0x5d3>
mov    0x10(%rsp),%rax
add    %rbp,%rax
mov    0x8(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
add    %r13,%rbp
movupd (%rcx,%rbp,8),%xmm2
movupd 0x10(%rcx,%rbp,8),%xmm3
mulpd  %xmm7,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%rcx,%rbp,8)
movupd %xmm1,0x10(%rcx,%rbp,8)
mov    0x40(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rcx
je     1510 <Matinv+0x3e0>
jmp    158c <Matinv+0x45c>
xor    %ebp,%ebp
testb  $0x1,0x30(%rsp)
jne    16c2 <Matinv+0x592>
jmp    1703 <Matinv+0x5d3>
xchg   %ax,%ax
mov    %rcx,%r9
mov    %r14d,%r15d
test   %r14d,%r14d
mov    0x88(%rsp),%r11
mov    0xa0(%rsp),%r14
mov    0x98(%rsp),%r10
jle    1230 <Matinv+0x100>
cmp    $0x4,%r15d
jae    1770 <Matinv+0x640>
xor    %eax,%eax
jmp    1830 <Matinv+0x700>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm12,%xmm5
unpcklpd %xmm12,%xmm5
cmpq   $0x0,0x38(%rsp)
je     184d <Matinv+0x71d>
mov    0x28(%rsp),%rax
xor    %ebp,%ebp
nopl   (%rax)
movupd -0x30(%r12,%rbp,8),%xmm6
movupd -0x20(%r12,%rbp,8),%xmm7
movupd -0x10(%r12,%rbp,8),%xmm3
movupd (%r12,%rbp,8),%xmm2
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm7
movupd %xmm6,-0x30(%r12,%rbp,8)
movupd %xmm7,-0x20(%r12,%rbp,8)
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm2
movupd %xmm3,-0x10(%r12,%rbp,8)
movupd %xmm2,(%r12,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
jne    1790 <Matinv+0x660>
testb  $0x1,0x30(%rsp)
je     180f <Matinv+0x6df>
add    0x10(%rsp),%rbp
mov    0x8(%rsp),%rax
movupd (%rax,%rbp,8),%xmm2
movupd 0x10(%rax,%rbp,8),%xmm3
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm3,0x10(%rax,%rbp,8)
mov    0x40(%rsp),%rbp
mov    %rbp,%rax
cmp    %rdi,%rbp
mov    0x8(%rsp),%rbp
je     1230 <Matinv+0x100>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1830 <Matinv+0x700>
jmp    1230 <Matinv+0x100>
xor    %ebp,%ebp
testb  $0x1,0x30(%rsp)
jne    17e7 <Matinv+0x6b7>
jmp    180f <Matinv+0x6df>
xor    %ebp,%ebp
testb  $0x1,0x30(%rsp)
jne    146d <Matinv+0x33d>
jmp    14a9 <Matinv+0x379>
add    $0x1,%esi
lea    0x7bc(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%eax
jmp    198c <Matinv+0x85c>
cmpl   $0x0,0x4c(%rsp)
jle    1982 <Matinv+0x852>
mov    %r9,%rcx
mov    0x20(%rsp),%r8
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
mov    %r9,%rsi
shl    $0x4,%rsi
lea    (%r9,%r8,1),%rax
lea    -0x8(,%rax,8),%rdi
ff
lea    -0x8(,%r8,8),%rbp
ff
jmp    18d2 <Matinv+0x7a2>
nopw   0x0(%rax,%rax,1)
add    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rbp
cmp    $0x1,%r9
jle    1982 <Matinv+0x852>
mov    %r8,%r9
add    $0xffffffffffffffff,%r8
mov    -0x4(%r11,%r9,4),%eax
cmp    %rax,%r8
je     18c0 <Matinv+0x790>
movslq %eax,%rbx
cmpl   $0x1,0x20(%rsp)
jne    1900 <Matinv+0x7d0>
xor    %eax,%eax
jmp    1944 <Matinv+0x814>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %rbx,%rcx
mov    0x8(%rsp),%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,1),%xmm0
movsd  (%rdx,%rbx,8),%xmm1
movsd  %xmm1,(%rdx,%rbp,1)
movsd  %xmm0,(%rdx,%rbx,8)
movsd  (%rdx,%rdi,1),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,1)
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x2,%rax
add    %rsi,%rdx
cmp    %rax,%r10
jne    1910 <Matinv+0x7e0>
testb  $0x1,0x20(%rsp)
mov    0x18(%rsp),%rcx
je     18c0 <Matinv+0x790>
imul   %rcx,%rax
lea    (%rax,%r8,1),%rcx
mov    0x8(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
add    %rbx,%rax
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
mov    0x18(%rsp),%rcx
movsd  %xmm0,(%rdx,%rax,8)
jmp    18c0 <Matinv+0x790>
mov    %r11,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xa8,%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
store double 0x3BC79CA10C924223, double* %14
store double 1.000000e+00, double* %18
%19 = load i32, i32* %7
%20 = call i64 @mCalloc(i32 %19, i32 4)
%21 = inttoptr i64 %20 to i32*
store i32* %21, i32** %13
store i32 0, i32* %10
br label %22
22: ; preds = %242, %4
%23 = load i32, i32* %10
%24 = load i32, i32* %7
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %245
26: ; preds = %22
store double 0.000000e+00, double* %17
%27 = load i32, i32* %10
store i32 %27, i32* %11
br label %28
28: ; preds = %62, %26
%29 = load i32, i32* %11
%30 = load i32, i32* %7
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %65
32: ; preds = %28
%33 = load double, double* %17
%34 = load double*, double** %6
%35 = load i32, i32* %11
%36 = load i32, i32* %8
%37 = mul nsw i32 %35, %36
%38 = load i32, i32* %10
%39 = add nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %34, i64 %40
%42 = load double, double* %41
%43 = call double @llvm.fabs.f64(double %42)
%44 = fcmp olt double %33, %43
br i1 %44, label %45, label %61
45: ; preds = %32
%46 = load double*, double** %6
%47 = load i32, i32* %11
%48 = load i32, i32* %8
%49 = mul nsw i32 %47, %48
%50 = load i32, i32* %10
%51 = add nsw i32 %49, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %46, i64 %52
%54 = load double, double* %53
%55 = call double @llvm.fabs.f64(double %54)
store double %55, double* %17
%56 = load i32, i32* %11
%57 = load i32*, i32** %13
%58 = load i32, i32* %10
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %57, i64 %59
store i32 %56, i32* %60
br label %61
61: ; preds = %45, %32
br label %62
62: ; preds = %61
%63 = load i32, i32* %11
%64 = add nsw i32 %63, 1
store i32 %64, i32* %11
br label %28
65: ; preds = %28
%66 = load double, double* %17
%67 = load double, double* %18
%68 = fmul double %67, %66
store double %68, double* %18
%69 = load double, double* %17
%70 = load double, double* %14
%71 = fcmp olt double %69, %70
br i1 %71, label %72, label %76
72: ; preds = %65
%73 = load i32, i32* %10
%74 = add nsw i32 %73, 1
%75 = call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i32 %74)
store i32 -1, i32* %5
br label %319
76: ; preds = %65
%77 = load i32*, i32** %13
%78 = load i32, i32* %10
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %80
%82 = load i32, i32* %10
%83 = icmp ne i32 %81, %82
br i1 %83, label %84, label %137
84: ; preds = %76
store i32 0, i32* %11
br label %85
85: ; preds = %133, %84
%86 = load i32, i32* %11
%87 = load i32, i32* %8
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %136
89: ; preds = %85
%90 = load double*, double** %6
%91 = load i32, i32* %10
%92 = load i32, i32* %8
%93 = mul nsw i32 %91, %92
%94 = load i32, i32* %11
%95 = add nsw i32 %93, %94
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %90, i64 %96
%98 = load double, double* %97
store double %98, double* %15
%99 = load double*, double** %6
%100 = load i32*, i32** %13
%101 = load i32, i32* %10
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %100, i64 %102
%104 = load i32, i32* %103
%105 = load i32, i32* %8
%106 = mul nsw i32 %104, %105
%107 = load i32, i32* %11
%108 = add nsw i32 %106, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %99, i64 %109
%111 = load double, double* %110
%112 = load double*, double** %6
%113 = load i32, i32* %10
%114 = load i32, i32* %8
%115 = mul nsw i32 %113, %114
%116 = load i32, i32* %11
%117 = add nsw i32 %115, %116
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %112, i64 %118
store double %111, double* %119
%120 = load double, double* %15
%121 = load double*, double** %6
%122 = load i32*, i32** %13
%123 = load i32, i32* %10
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
%126 = load i32, i32* %125
%127 = load i32, i32* %8
%128 = mul nsw i32 %126, %127
%129 = load i32, i32* %11
%130 = add nsw i32 %128, %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %121, i64 %131
store double %120, double* %132
br label %133
133: ; preds = %89
%134 = load i32, i32* %11
%135 = add nsw i32 %134, 1
store i32 %135, i32* %11
br label %85
136: ; preds = %85
br label %137
137: ; preds = %136, %76
%138 = load double*, double** %6
%139 = load i32, i32* %10
%140 = load i32, i32* %8
%141 = mul nsw i32 %139, %140
%142 = load i32, i32* %10
%143 = add nsw i32 %141, %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds double, double* %138, i64 %144
%146 = load double, double* %145
%147 = fdiv double 1.000000e+00, %146
store double %147, double* %15
store i32 0, i32* %11
br label %148
148: ; preds = %209, %137
%149 = load i32, i32* %11
%150 = load i32, i32* %7
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %212
152: ; preds = %148
%153 = load i32, i32* %11
%154 = load i32, i32* %10
%155 = icmp eq i32 %153, %154
br i1 %155, label %156, label %157
156: ; preds = %152
br label %209
157: ; preds = %152
%158 = load double, double* %15
%159 = load double*, double** %6
%160 = load i32, i32* %11
%161 = load i32, i32* %8
%162 = mul nsw i32 %160, %161
%163 = load i32, i32* %10
%164 = add nsw i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %159, i64 %165
%167 = load double, double* %166
%168 = fmul double %158, %167
store double %168, double* %16
store i32 0, i32* %12
br label %169
169: ; preds = %195, %157
%170 = load i32, i32* %12
%171 = load i32, i32* %8
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %198
173: ; preds = %169
%174 = load double, double* %16
%175 = load double*, double** %6
%176 = load i32, i32* %10
%177 = load i32, i32* %8
%178 = mul nsw i32 %176, %177
%179 = load i32, i32* %12
%180 = add nsw i32 %178, %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %175, i64 %181
%183 = load double, double* %182
%184 = load double*, double** %6
%185 = load i32, i32* %11
%186 = load i32, i32* %8
%187 = mul nsw i32 %185, %186
%188 = load i32, i32* %12
%189 = add nsw i32 %187, %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %184, i64 %190
%192 = load double, double* %191
%193 = fneg double %174
%194 = call double @llvm.fmuladd.f64(double %193, double %183, double %192)
store double %194, double* %191
br label %195
195: ; preds = %173
%196 = load i32, i32* %12
%197 = add nsw i32 %196, 1
store i32 %197, i32* %12
br label %169
198: ; preds = %169
%199 = load double, double* %16
%200 = fneg double %199
%201 = load double*, double** %6
%202 = load i32, i32* %11
%203 = load i32, i32* %8
%204 = mul nsw i32 %202, %203
%205 = load i32, i32* %10
%206 = add nsw i32 %204, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %201, i64 %207
store double %200, double* %208
br label %209
209: ; preds = %198, %156
%210 = load i32, i32* %11
%211 = add nsw i32 %210, 1
store i32 %211, i32* %11
br label %148
212: ; preds = %148
store i32 0, i32* %11
br label %213
213: ; preds = %229, %212
%214 = load i32, i32* %11
%215 = load i32, i32* %8
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %232
217: ; preds = %213
%218 = load double, double* %15
%219 = load double*, double** %6
%220 = load i32, i32* %10
%221 = load i32, i32* %8
%222 = mul nsw i32 %220, %221
%223 = load i32, i32* %11
%224 = add nsw i32 %222, %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %219, i64 %225
%227 = load double, double* %226
%228 = fmul double %227, %218
store double %228, double* %226
br label %229
229: ; preds = %217
%230 = load i32, i32* %11
%231 = add nsw i32 %230, 1
store i32 %231, i32* %11
br label %213
232: ; preds = %213
%233 = load double, double* %15
%234 = load double*, double** %6
%235 = load i32, i32* %10
%236 = load i32, i32* %8
%237 = mul nsw i32 %235, %236
%238 = load i32, i32* %10
%239 = add nsw i32 %237, %238
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %234, i64 %240
store double %233, double* %241
br label %242
242: ; preds = %232
%243 = load i32, i32* %10
%244 = add nsw i32 %243, 1
store i32 %244, i32* %10
br label %22
245: ; preds = %22
%246 = load i32, i32* %7
%247 = sub nsw i32 %246, 1
store i32 %247, i32* %10
br label %248
248: ; preds = %313, %245
%249 = load i32, i32* %10
%250 = icmp sge i32 %249, 0
br i1 %250, label %251, label %316
251: ; preds = %248
%252 = load i32*, i32** %13
%253 = load i32, i32* %10
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %252, i64 %254
%256 = load i32, i32* %255
%257 = load i32, i32* %10
%258 = icmp eq i32 %256, %257
br i1 %258, label %259, label %260
259: ; preds = %251
br label %313
260: ; preds = %251
store i32 0, i32* %11
br label %261
261: ; preds = %309, %260
%262 = load i32, i32* %11
%263 = load i32, i32* %7
%264 = icmp slt i32 %262, %263
br i1 %264, label %265, label %312
265: ; preds = %261
%266 = load double*, double** %6
%267 = load i32, i32* %11
%268 = load i32, i32* %8
%269 = mul nsw i32 %267, %268
%270 = load i32, i32* %10
%271 = add nsw i32 %269, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %266, i64 %272
%274 = load double, double* %273
store double %274, double* %15
%275 = load double*, double** %6
%276 = load i32, i32* %11
%277 = load i32, i32* %8
%278 = mul nsw i32 %276, %277
%279 = load i32*, i32** %13
%280 = load i32, i32* %10
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i32, i32* %279, i64 %281
%283 = load i32, i32* %282
%284 = add nsw i32 %278, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %275, i64 %285
%287 = load double, double* %286
%288 = load double*, double** %6
%289 = load i32, i32* %11
%290 = load i32, i32* %8
%291 = mul nsw i32 %289, %290
%292 = load i32, i32* %10
%293 = add nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %288, i64 %294
store double %287, double* %295
%296 = load double, double* %15
%297 = load double*, double** %6
%298 = load i32, i32* %11
%299 = load i32, i32* %8
%300 = mul nsw i32 %298, %299
%301 = load i32*, i32** %13
%302 = load i32, i32* %10
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %301, i64 %303
%305 = load i32, i32* %304
%306 = add nsw i32 %300, %305
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %297, i64 %307
store double %296, double* %308
br label %309
309: ; preds = %265
%310 = load i32, i32* %11
%311 = add nsw i32 %310, 1
store i32 %311, i32* %11
br label %261
312: ; preds = %261
br label %313
313: ; preds = %312, %259
%314 = load i32, i32* %10
%315 = add nsw i32 %314, -1
store i32 %315, i32* %10
br label %248
316: ; preds = %248
%317 = load i32*, i32** %13
%318 = call i32 @free(i32* %317)
store i32 0, i32* %5
br label %319
319: ; preds = %316, %72
%320 = load i32, i32* %5
ret i32 %320
}

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