#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(char *, int);
double fabs(double);
int /*<<< orphan*/ free(int *);
scalar_t__ mCalloc(int, int);
int Matinv(double *x, int n, int m) {
  int i, j, k;
  int *irow;
  double ee, t, t1, xmax;
  double det;
  ee = 1.0E-10;
  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) {
      free(irow);
      Exit((char *)"Cannot invert the matrix of eigen vectors : determinant "
                   "becomes zero at %3d.",
           i + 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 (1);
}


x86 assembly (clang, -O0):
<Matinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  0xebe(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xea9(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x4,%esi
call   1050 <mCalloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1482 <Matinv+0x352>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1211 <Matinv+0xe1>
movsd  -0x48(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe54(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    11fe <Matinv+0xce>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe29(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1203 <Matinv+0xd3>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    118e <Matinv+0x5e>
movsd  -0x48(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    124f <Matinv+0x11f>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x14(%rbp),%esi
add    $0x1,%esi
lea    0xdd6(%rip),%rdi
call   1040 <Exit@plt>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
je     12fb <Matinv+0x1cb>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12f6 <Matinv+0x1c6>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    126a <Matinv+0x13a>
jmp    12fb <Matinv+0x1cb>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xcec(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1418 <Matinv+0x2e8>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1342 <Matinv+0x212>
jmp    140a <Matinv+0x2da>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13d8 <Matinv+0x2a8>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%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    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1369 <Matinv+0x239>
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1325 <Matinv+0x1f5>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1459 <Matinv+0x329>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    141f <Matinv+0x2ef>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1174 <Matinv+0x44>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     1554 <Matinv+0x424>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
jne    14ae <Matinv+0x37e>
jmp    1546 <Matinv+0x416>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1541 <Matinv+0x411>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x14(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x14(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14b5 <Matinv+0x385>
jmp    1546 <Matinv+0x416>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    148b <Matinv+0x35b>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x50,%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,%ebp
mov    %esi,%ebx
mov    %rdi,0x10(%rsp)
mov    %esi,%edi
mov    $0x4,%esi
call   1050 <mCalloc@plt>
mov    %rax,%rdi
test   %ebx,%ebx
jle    194a <Matinv+0x81a>
mov    %ebx,0x4c(%rsp)
mov    %ebx,%r11d
movslq %ebp,%rax
mov    %eax,%r12d
mov    0x10(%rsp),%r10
lea    (%r10,%r12,8),%rcx
mov    %rcx,0x80(%rsp)
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x38(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x30(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r12,%rcx
neg    %rcx
mov    %rcx,0x78(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x28(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x20(%rsp)
lea    0x0(,%rax,8),%r15
mov    %rax,0x8(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x90(%rsp)
lea    0x30(%r10),%r13
lea    0x8(%r10),%rax
xor    %ebx,%ebx
movapd 0xe16(%rip),%xmm9
movsd  0xe2d(%rip),%xmm10
movsd  0xe2c(%rip),%xmm11
movapd 0xe0b(%rip),%xmm12
mov    %r10,%r14
mov    %rax,0x58(%rsp)
mov    %rax,%rsi
mov    %r13,0x50(%rsp)
mov    %r10,%rcx
mov    %r11,0x18(%rsp)
mov    %rdi,0x88(%rsp)
jmp    125c <Matinv+0x12c>
nopw   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rax
movsd  %xmm8,(%r10,%rax,8)
add    $0x1,%rbx
add    0x90(%rsp),%rcx
add    %r15,%r13
add    %r15,%rsi
add    %r15,%r14
cmp    %r11,%rbx
je     184f <Matinv+0x71f>
mov    %rbx,%rax
imul   0x8(%rsp),%rax
lea    (%r10,%rax,8),%rdx
mov    %rdx,0x68(%rsp)
mov    %rax,(%rsp)
add    %r12,%rax
lea    (%r10,%rax,8),%rax
mov    %rax,0x70(%rsp)
xorpd  %xmm0,%xmm0
mov    %rcx,0x60(%rsp)
mov    %rcx,%rax
mov    %rbx,%rcx
jmp    129c <Matinv+0x16c>
nop
add    $0x1,%rcx
add    %r15,%rax
cmp    %rcx,%r11
je     12c0 <Matinv+0x190>
movsd  (%rax),%xmm1
andpd  %xmm9,%xmm1
ucomisd %xmm0,%xmm1
jbe    1290 <Matinv+0x160>
mov    %ecx,(%rdi,%rbx,4)
movapd %xmm1,%xmm0
jmp    1290 <Matinv+0x160>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomisd %xmm0,%xmm10
mov    %rbx,0x40(%rsp)
jbe    1326 <Matinv+0x1f6>
mov    %rsi,%rbx
call   1030 <free@plt>
mov    0x40(%rsp),%rax
lea    0x1(%rax),%esi
lea    0xd4d(%rip),%rdi
call   1040 <Exit@plt>
mov    %rbx,%rsi
movapd 0xd1c(%rip),%xmm12
movsd  0xd2b(%rip),%xmm11
movsd  0xd1a(%rip),%xmm10
movapd 0xcf1(%rip),%xmm9
mov    0x40(%rsp),%rbx
mov    0x18(%rsp),%r11
mov    0x88(%rsp),%rdi
mov    0x10(%rsp),%r10
mov    (%rdi,%rbx,4),%eax
cmp    %rax,%rbx
je     14f0 <Matinv+0x3c0>
test   %ebp,%ebp
jle    14f0 <Matinv+0x3c0>
imul   %ebp,%eax
movslq %eax,%r9
cmp    $0x4,%ebp
jb     136b <Matinv+0x23b>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
cmp    %rcx,0x68(%rsp)
jae    13fa <Matinv+0x2ca>
lea    (%r10,%r9,8),%rcx
cmp    0x70(%rsp),%rcx
jae    13fa <Matinv+0x2ca>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r12b
je     13a7 <Matinv+0x277>
mov    (%rsp),%rax
lea    (%rdx,%rax,1),%rcx
movsd  (%r10,%rcx,8),%xmm0
mov    %rsi,%rax
lea    (%rdx,%r9,1),%rsi
movsd  (%r10,%rsi,8),%xmm1
movsd  %xmm1,(%r10,%rcx,8)
movsd  %xmm0,(%r10,%rsi,8)
mov    %rax,%rsi
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x78(%rsp),%rdx
je     14f0 <Matinv+0x3c0>
mov    0x58(%rsp),%rdx
lea    (%rdx,%r9,8),%rax
xchg   %ax,%ax
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rcx,8)
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rsi,%rcx,8),%xmm0
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    13c0 <Matinv+0x290>
jmp    14f0 <Matinv+0x3c0>
cmpq   $0x0,0x30(%rsp)
je     183a <Matinv+0x70a>
mov    %rsi,%r8
mov    0x50(%rsp),%rcx
lea    (%rcx,%r9,8),%rdx
mov    0x20(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x30(%r13,%rcx,8),%xmm0
movups -0x20(%r13,%rcx,8),%xmm1
movups -0x30(%rdx,%rcx,8),%xmm2
movups -0x20(%rdx,%rcx,8),%xmm3
movups %xmm2,-0x30(%r13,%rcx,8)
movups %xmm3,-0x20(%r13,%rcx,8)
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm1,-0x20(%rdx,%rcx,8)
movupd -0x10(%r13,%rcx,8),%xmm0
movupd 0x0(%r13,%rcx,8),%xmm1
movupd -0x10(%rdx,%rcx,8),%xmm2
movupd (%rdx,%rcx,8),%xmm3
movupd %xmm2,-0x10(%r13,%rcx,8)
movupd %xmm3,0x0(%r13,%rcx,8)
movupd %xmm0,-0x10(%rdx,%rcx,8)
movupd %xmm1,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1420 <Matinv+0x2f0>
testb  $0x1,0x28(%rsp)
je     14ce <Matinv+0x39e>
mov    (%rsp),%rax
lea    (%rcx,%rax,1),%rdx
movupd (%r10,%rdx,8),%xmm0
movupd 0x10(%r10,%rdx,8),%xmm1
add    %r9,%rcx
movupd (%r10,%rcx,8),%xmm2
movupd 0x10(%r10,%rcx,8),%xmm3
movupd %xmm2,(%r10,%rdx,8)
movupd %xmm3,0x10(%r10,%rdx,8)
movupd %xmm0,(%r10,%rcx,8)
movupd %xmm1,0x10(%r10,%rcx,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r12,%rcx
mov    %r8,%rsi
jne    136d <Matinv+0x23d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,0xa0(%rsp)
mov    (%rsp),%rax
add    %rbx,%rax
movapd %xmm11,%xmm8
mov    %rax,0x98(%rsp)
divsd  (%r10,%rax,8),%xmm8
movapd %xmm8,%xmm1
xorpd  %xmm12,%xmm1
mov    0x58(%rsp),%rcx
mov    0x50(%rsp),%rdx
xor    %esi,%esi
jmp    1551 <Matinv+0x421>
nopw   0x0(%rax,%rax,1)
movsd  %xmm2,(%r10,%r9,8)
mov    %r8d,%ebp
mov    0x40(%rsp),%rbx
add    $0x1,%rsi
add    %r15,%rdx
add    %r15,%rcx
cmp    %r11,%rsi
je     1720 <Matinv+0x5f0>
cmp    %rbx,%rsi
je     153e <Matinv+0x40e>
mov    %rsi,%rax
imul   0x8(%rsp),%rax
lea    (%rax,%rbx,1),%r9
movsd  (%r10,%r9,8),%xmm2
mulsd  %xmm1,%xmm2
mov    %ebp,%r8d
test   %ebp,%ebp
jle    1530 <Matinv+0x400>
mov    %r8d,%ebx
cmp    $0x4,%r8d
jb     159b <Matinv+0x46b>
lea    (%r10,%rax,8),%rbp
cmp    0x70(%rsp),%rbp
jae    1619 <Matinv+0x4e9>
lea    (%rax,%r12,1),%rbp
lea    (%r10,%rbp,8),%rbp
cmp    %rbp,0x68(%rsp)
jae    1619 <Matinv+0x4e9>
xor    %ebx,%ebx
mov    %rbx,%rbp
test   $0x1,%r12b
je     15cd <Matinv+0x49d>
mov    (%rsp),%rbp
add    %rbx,%rbp
add    %rbx,%rax
movsd  (%r10,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    0x78(%rsp),%rbx
je     1530 <Matinv+0x400>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r12
jne    15e0 <Matinv+0x4b0>
jmp    1530 <Matinv+0x400>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,0x30(%rsp)
je     1712 <Matinv+0x5e2>
mov    0x20(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%r13,%rbx,8),%xmm4
movupd -0x20(%r13,%rbx,8),%xmm5
mulpd  %xmm3,%xmm4
movupd -0x30(%rdx,%rbx,8),%xmm6
addpd  %xmm4,%xmm6
movupd -0x20(%rdx,%rbx,8),%xmm4
movupd -0x10(%rdx,%rbx,8),%xmm7
movupd (%rdx,%rbx,8),%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,-0x30(%rdx,%rbx,8)
movupd %xmm5,-0x20(%rdx,%rbx,8)
movupd -0x10(%r13,%rbx,8),%xmm4
movupd 0x0(%r13,%rbx,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm0,%xmm5
movupd %xmm4,-0x10(%rdx,%rbx,8)
movupd %xmm5,(%rdx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1640 <Matinv+0x510>
testb  $0x1,0x28(%rsp)
je     16fc <Matinv+0x5cc>
mov    (%rsp),%rbp
add    %rbx,%rbp
movupd (%r10,%rbp,8),%xmm0
movupd 0x10(%r10,%rbp,8),%xmm4
add    %rax,%rbx
movupd (%r10,%rbx,8),%xmm5
movupd 0x10(%r10,%rbx,8),%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm0,(%r10,%rbx,8)
movupd %xmm4,0x10(%r10,%rbx,8)
mov    0x38(%rsp),%rbp
mov    %rbp,%rbx
cmp    %r12,%rbp
je     1530 <Matinv+0x400>
jmp    159d <Matinv+0x46d>
xor    %ebx,%ebx
testb  $0x1,0x28(%rsp)
jne    16bb <Matinv+0x58b>
jmp    16fc <Matinv+0x5cc>
nopl   (%rax)
test   %ebp,%ebp
mov    0xa0(%rsp),%rsi
mov    0x60(%rsp),%rcx
jle    1230 <Matinv+0x100>
cmp    $0x4,%ebp
jae    1750 <Matinv+0x620>
xor    %eax,%eax
jmp    1810 <Matinv+0x6e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm8,%xmm1
unpcklpd %xmm8,%xmm1
cmpq   $0x0,0x30(%rsp)
je     182f <Matinv+0x6ff>
mov    0x20(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movupd -0x30(%r13,%rax,8),%xmm2
movupd -0x20(%r13,%rax,8),%xmm3
movupd -0x10(%r13,%rax,8),%xmm4
movupd 0x0(%r13,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%r13,%rax,8)
movupd %xmm3,-0x20(%r13,%rax,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%r13,%rax,8)
movupd %xmm5,0x0(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1770 <Matinv+0x640>
testb  $0x1,0x28(%rsp)
je     17ef <Matinv+0x6bf>
add    (%rsp),%rax
movupd (%r10,%rax,8),%xmm2
movupd 0x10(%r10,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r10,%rax,8)
movupd %xmm3,0x10(%r10,%rax,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
mov    0x60(%rsp),%rcx
je     1230 <Matinv+0x100>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm8,%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    1810 <Matinv+0x6e0>
jmp    1230 <Matinv+0x100>
xor    %eax,%eax
testb  $0x1,0x28(%rsp)
jne    17c9 <Matinv+0x699>
jmp    17ef <Matinv+0x6bf>
mov    %rsi,%r8
xor    %ecx,%ecx
testb  $0x1,0x28(%rsp)
jne    148f <Matinv+0x35f>
jmp    14ce <Matinv+0x39e>
cmpl   $0x0,0x4c(%rsp)
jle    194a <Matinv+0x81a>
mov    0x18(%rsp),%r8
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    18a2 <Matinv+0x772>
nopw   0x0(%rax,%rax,1)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    $0x1,%r9
jle    194a <Matinv+0x81a>
mov    %r8,%r9
add    $0xffffffffffffffff,%r8
mov    -0x4(%rdi,%r9,4),%eax
cmp    %rax,%r8
je     1890 <Matinv+0x760>
movslq %eax,%rbx
cmpl   $0x1,0x18(%rsp)
jne    18d0 <Matinv+0x7a0>
xor    %ebp,%ebp
jmp    1914 <Matinv+0x7e4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
lea    (%rax,%rbx,1),%rcx
mov    0x10(%rsp),%rax
xor    %ebp,%ebp
movsd  (%rax,%rsi,1),%xmm0
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,(%rax,%rsi,1)
movsd  %xmm0,(%rax,%rbx,8)
movsd  (%rax,%rdx,1),%xmm0
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,1)
movsd  %xmm0,(%rax,%rcx,8)
add    $0x2,%rbp
add    %r11,%rax
cmp    %rbp,%r10
jne    18e0 <Matinv+0x7b0>
testb  $0x1,0x18(%rsp)
je     1890 <Matinv+0x760>
imul   0x8(%rsp),%rbp
lea    (%r8,%rbp,1),%rax
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
add    %rbx,%rbp
movsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movsd  %xmm0,(%rcx,%rbp,8)
jmp    1890 <Matinv+0x760>
call   1030 <free@plt>
mov    $0x1,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [77 x i8] c"Cannot invert the matrix of eigen vectors : determinant becomes zero at %3d.\00"
define i32 @Matinv(double* nocapture %0, i32 %1, i32 %2) {
%4 = tail call i64 @mCalloc(i32 %1, i32 4)
%5 = inttoptr i64 %4 to i32*
%6 = icmp sgt i32 %1, 0
br i1 %6, label %7, label %439
7: ; preds = %3
%8 = icmp slt i32 %2, 1
%9 = icmp sgt i32 %2, 0
%10 = sext i32 %2 to i64
%11 = zext i32 %1 to i64
%12 = zext i32 %2 to i64
%13 = zext i32 %2 to i64
%14 = zext i32 %2 to i64
%15 = getelementptr double, double* %0, i64 %12
%16 = and i64 %12, 4294967292
%17 = add nsw i64 %16, -4
%18 = lshr exact i64 %17, 2
%19 = add nuw nsw i64 %18, 1
%20 = icmp ult i32 %2, 4
%21 = and i64 %12, 4294967292
%22 = and i64 %19, 1
%23 = icmp eq i64 %17, 0
%24 = and i64 %19, 9223372036854775806
%25 = icmp eq i64 %22, 0
%26 = icmp eq i64 %21, %12
%27 = and i64 %12, 1
%28 = icmp eq i64 %27, 0
%29 = sub nsw i64 0, %12
%30 = icmp ult i32 %2, 4
%31 = and i64 %12, 4294967292
%32 = and i64 %19, 1
%33 = icmp eq i64 %17, 0
%34 = and i64 %19, 9223372036854775806
%35 = icmp eq i64 %32, 0
%36 = icmp eq i64 %31, %12
%37 = and i64 %12, 1
%38 = icmp eq i64 %37, 0
%39 = sub nsw i64 0, %12
%40 = icmp ult i32 %2, 4
%41 = and i64 %12, 4294967292
%42 = and i64 %19, 1
%43 = icmp eq i64 %17, 0
%44 = and i64 %19, 9223372036854775806
%45 = icmp eq i64 %42, 0
%46 = icmp eq i64 %41, %12
br label %47
47: ; preds = %394, %7
%48 = phi i64 [ 0, %7 ], [ %395, %394 ]
%49 = mul i64 %48, %10
%50 = getelementptr double, double* %0, i64 %49
%51 = add i64 %49, %12
%52 = getelementptr double, double* %0, i64 %51
%53 = mul i64 %48, %10
%54 = getelementptr double, double* %0, i64 %53
%55 = add i64 %53, %12
%56 = getelementptr double, double* %0, i64 %55
%57 = getelementptr inbounds i32, i32* %5, i64 %48
br label %66
58: ; preds = %394
br i1 %6, label %59, label %439
59: ; preds = %58
%60 = sext i32 %2 to i64
%61 = zext i32 %1 to i64
%62 = and i64 %61, 1
%63 = icmp eq i32 %1, 1
%64 = and i64 %61, 4294967294
%65 = icmp eq i64 %62, 0
br label %397
66: ; preds = %47, %77
%67 = phi i64 [ %48, %47 ], [ %79, %77 ]
%68 = phi double [ 0.000000e+00, %47 ], [ %78, %77 ]
%69 = mul nsw i64 %67, %10
%70 = add nsw i64 %69, %48
%71 = getelementptr inbounds double, double* %0, i64 %70
%72 = load double, double* %71
%73 = tail call double @llvm.fabs.f64(double %72)
%74 = fcmp olt double %68, %73
br i1 %74, label %75, label %77
75: ; preds = %66
%76 = trunc i64 %67 to i32
store i32 %76, i32* %57
br label %77
77: ; preds = %66, %75
%78 = phi double [ %73, %75 ], [ %68, %66 ]
%79 = add nuw nsw i64 %67, 1
%80 = icmp eq i64 %79, %11
br i1 %80, label %81, label %66
81: ; preds = %77
%82 = fcmp olt double %78, 1.000000e-10
br i1 %82, label %83, label %88
83: ; preds = %81
%84 = tail call i32 @free(i32* %5)
%85 = trunc i64 %48 to i32
%86 = add i32 %85, 1
%87 = tail call i32 @Exit(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str, i64 0, i64 0), i32 %86)
br label %88
88: ; preds = %83, %81
%89 = getelementptr inbounds i32, i32* %5, i64 %48
%90 = load i32, i32* %89
%91 = zext i32 %90 to i64
%92 = icmp eq i64 %48, %91
%93 = or i1 %92, %8
%94 = mul nsw i64 %48, %10
br i1 %93, label %201, label %95
95: ; preds = %88
%96 = mul nsw i32 %90, %2
%97 = sext i32 %96 to i64
br i1 %20, label %170, label %98
98: ; preds = %95
%99 = getelementptr double, double* %0, i64 %97
%100 = getelementptr double, double* %15, i64 %97
%101 = icmp ult double* %50, %100
%102 = icmp ult double* %99, %52
%103 = and i1 %101, %102
br i1 %103, label %170, label %104
104: ; preds = %98
br i1 %23, 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, %24
br i1 %147, label %148, label %105
148: ; preds = %105, %104
%149 = phi i64 [ 0, %104 ], [ %145, %105 ]
br i1 %25, 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 %26, label %201, label %170
170: ; preds = %98, %95, %169
%171 = phi i64 [ 0, %98 ], [ 0, %95 ], [ %21, %169 ]
%172 = xor i64 %171, -1
br i1 %28, 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, %29
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, %12
br i1 %200, label %201, label %184
201: ; preds = %181, %184, %169, %88
%202 = add nsw i64 %94, %48
%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 %9, label %208, label %394
208: ; preds = %207
br i1 %40, 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 %43, 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, %44
br i1 %242, label %243, label %214
243: ; preds = %214, %209
%244 = phi i64 [ 0, %209 ], [ %240, %214 ]
br i1 %45, 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 %46, label %394, label %258
258: ; preds = %208, %257
%259 = phi i64 [ 0, %208 ], [ %41, %257 ]
br label %386
260: ; preds = %201, %383
%261 = phi i64 [ 0, %201 ], [ %384, %383 ]
%262 = mul i64 %261, %10
%263 = getelementptr double, double* %0, i64 %262
%264 = add i64 %262, %12
%265 = getelementptr double, double* %0, i64 %264
%266 = icmp eq i64 %261, %48
br i1 %266, label %383, label %267
267: ; preds = %260
%268 = mul nsw i64 %261, %10
%269 = add nsw i64 %268, %48
%270 = getelementptr inbounds double, double* %0, i64 %269
%271 = load double, double* %270
%272 = fmul double %271, %206
br i1 %9, label %273, label %382
273: ; preds = %267
br i1 %30, label %348, label %274
274: ; preds = %273
%275 = icmp ult double* %263, %56
%276 = icmp ult double* %54, %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 %33, 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, %34
br i1 %325, label %326, label %283
326: ; preds = %283, %278
%327 = phi i64 [ 0, %278 ], [ %323, %283 ]
br i1 %35, 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 %36, label %382, label %348
348: ; preds = %274, %273, %347
%349 = phi i64 [ 0, %274 ], [ 0, %273 ], [ %31, %347 ]
%350 = xor i64 %349, -1
br i1 %38, 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, %39
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, %13
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, %11
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, %14
br i1 %393, label %394, label %386
394: ; preds = %386, %257, %207
store double %205, double* %203
%395 = add nuw nsw i64 %48, 1
%396 = icmp eq i64 %395, %11
br i1 %396, label %58, label %47
397: ; preds = %59, %437
%398 = phi i64 [ %61, %59 ], [ %399, %437 ]
%399 = add nsw i64 %398, -1
%400 = getelementptr inbounds i32, i32* %5, i64 %399
%401 = load i32, i32* %400
%402 = zext i32 %401 to i64
%403 = icmp eq i64 %399, %402
br i1 %403, label %437, label %404
404: ; preds = %397
%405 = sext i32 %401 to i64
br i1 %63, 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, %60
%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, %60
%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, %64
br i1 %426, label %427, label %406
427: ; preds = %406, %404
%428 = phi i64 [ 0, %404 ], [ %424, %406 ]
br i1 %65, label %437, label %429
429: ; preds = %427
%430 = mul nsw i64 %428, %60
%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, %3, %58
%440 = tail call i32 @free(i32* %5)
ret i32 1
}