#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 */
scalar_t__ Is_zero(double);
double **createIdentity(int);
int /*<<< orphan*/ deallocateSpace(double **, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
double **Invert_matrix(double **data, int size) {
  double **inverse = createIdentity(size);
  if (inverse == NULL) {
    fprintf(stderr,
            "ERROR: Memory allocation failed for the inverse matrix.\n");
    return NULL;
  }
  int i, j, k;
  int pivot, y, z;
  double lower, current;
  double leftState, rightState, state, currState;
  for (i = 0; i < size; i++) {
    pivot = i;
    for (y = i + 1; y < size; y++) {
      lower = data[y - 1][i];
      current = data[y][i];
      lower = lower > 0 ? lower : -1 * lower;
      current = current > 0 ? current : -1 * current;
      if (current > lower) {
        pivot = y;
      }
    }
    if (Is_zero(data[pivot][i])) {
      deallocateSpace(inverse, size);
      deallocateSpace(data, size);
      return NULL;
    }
    for (z = 0; z < size; z++) {
      leftState = data[i][z];
      data[i][z] = data[pivot][z];
      data[pivot][z] = leftState;
      rightState = inverse[i][z];
      inverse[i][z] = inverse[pivot][z];
      inverse[pivot][z] = rightState;
    }
    state = data[i][i];
    j = 0;
    while (j < size) {
      data[i][j] /= state;
      inverse[i][j] /= state;
      j++;
    }
    j = 0;
    while (j < size) {
      if (j != i) {
        currState = data[j][i];
        for (k = 0; k < size; k++) {
          data[j][k] -= currState * data[i][k];
          inverse[j][k] -= currState * inverse[i][k];
        }
      }
      j++;
    }
  }
  deallocateSpace(data, size);
  return inverse;
}


x86 assembly (clang, -O0):
<Invert_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <createIdentity@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    118b <Invert_matrix+0x4b>
mov    0x2e70(%rip),%rax
mov    (%rax),%edi
lea    0xe8f(%rip),%rsi
call   1050 <fprintf@plt>
movq   $0x0,-0x8(%rbp)
jmp    1576 <Invert_matrix+0x436>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1562 <Invert_matrix+0x422>
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1295 <Invert_matrix+0x155>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1213 <Invert_matrix+0xd3>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1225 <Invert_matrix+0xe5>
movsd  0xde5(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1250 <Invert_matrix+0x110>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1262 <Invert_matrix+0x122>
movsd  0xda8(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1282 <Invert_matrix+0x142>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1287 <Invert_matrix+0x147>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ad <Invert_matrix+0x6d>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <Is_zero@plt>
cmp    $0x0,%rax
je     12de <Invert_matrix+0x19e>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <deallocateSpace@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <deallocateSpace@plt>
movq   $0x0,-0x8(%rbp)
jmp    1576 <Invert_matrix+0x436>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13bb <Invert_matrix+0x27b>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e5 <Invert_matrix+0x1a5>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    143c <Invert_matrix+0x2fc>
movsd  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13dc <Invert_matrix+0x29c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    154f <Invert_matrix+0x40f>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     1541 <Invert_matrix+0x401>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    153c <Invert_matrix+0x3fc>
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%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)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%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    147c <Invert_matrix+0x33c>
jmp    1541 <Invert_matrix+0x401>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1443 <Invert_matrix+0x303>
jmp    1554 <Invert_matrix+0x414>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1192 <Invert_matrix+0x52>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <deallocateSpace@plt>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Invert_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %esi,%r15d
mov    %rdi,%r13
mov    %esi,%edi
call   1030 <createIdentity@plt>
test   %rax,%rax
je     1897 <Invert_matrix+0x757>
mov    %rax,%r12
test   %r15d,%r15d
jle    188a <Invert_matrix+0x74a>
mov    %r15d,%r14d
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x48(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x60(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x50(%rsp)
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x30(%rsp)
lea    0x0(,%r14,8),%rdx
and    $0xffffffffffffffe0,%rdx
mov    $0x1,%ecx
xor    %ebp,%ebp
movapd 0xe2d(%rip),%xmm4
mov    %r15d,0x8(%rsp)
mov    %r13,0x18(%rsp)
mov    %r12,0x20(%rsp)
mov    %rdx,0x58(%rsp)
jmp    120a <Invert_matrix+0xca>
nopl   0x0(%rax)
mov    0x70(%rsp),%rcx
add    $0x1,%rcx
mov    0x68(%rsp),%rax
mov    %rax,%rbp
cmp    %r14,%rax
je     188a <Invert_matrix+0x74a>
lea    0x1(%rbp),%rax
cmp    %r14,%rax
mov    %rcx,0x70(%rsp)
mov    %rax,0x68(%rsp)
mov    %ebp,%eax
jae    127e <Invert_matrix+0x13e>
nop
mov    -0x8(%r13,%rcx,8),%rdx
mov    0x0(%r13,%rcx,8),%rsi
movsd  (%rdx,%rbp,8),%xmm0
movsd  (%rsi,%rbp,8),%xmm1
movapd %xmm0,%xmm2
xorpd  %xmm4,%xmm2
xorpd  %xmm3,%xmm3
cmpltsd %xmm0,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm2,%xmm3
orpd   %xmm0,%xmm3
movapd %xmm1,%xmm0
xorpd  %xmm4,%xmm0
xorpd  %xmm2,%xmm2
cmpltsd %xmm1,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
ucomisd %xmm3,%xmm2
cmova  %ecx,%eax
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1220 <Invert_matrix+0xe0>
movslq %eax,%rbx
mov    0x0(%r13,%rbx,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1060 <Is_zero@plt>
test   %rax,%rax
jne    18ae <Invert_matrix+0x76e>
mov    0x0(%r13,%rbp,8),%rax
mov    0x0(%r13,%rbx,8),%rcx
mov    (%r12,%rbp,8),%rdx
mov    (%r12,%rbx,8),%rsi
cmp    $0x4,%r15d
mov    %rbp,0x10(%rsp)
jae    12d0 <Invert_matrix+0x190>
mov    %rbp,%r8
xor    %ebp,%ebp
movapd 0xd3d(%rip),%xmm4
movapd 0xd35(%rip),%xmm5
jmp    1430 <Invert_matrix+0x2f0>
lea    (%rax,%r14,8),%rdi
lea    (%rcx,%r14,8),%rbp
lea    (%rdx,%r14,8),%rbx
lea    (%rsi,%r14,8),%r11
cmp    %rbp,%rax
setb   0x7(%rsp)
cmp    %rdi,%rcx
setb   %r15b
cmp    %rbx,%rax
setb   %r13b
cmp    %rdi,%rdx
setb   0x28(%rsp)
cmp    %r11,%rax
setb   %r8b
cmp    %rdi,%rsi
setb   0xf(%rsp)
cmp    %rbx,%rcx
setb   %r9b
cmp    %rbp,%rdx
setb   0xe(%rsp)
cmp    %r11,%rcx
setb   %r10b
cmp    %rbp,%rsi
setb   %bpl
cmp    %r11,%rdx
setb   %dil
cmp    %rbx,%rsi
setb   %bl
test   %r15b,0x7(%rsp)
movapd 0xcbc(%rip),%xmm4
movapd 0xcb4(%rip),%xmm5
jne    140f <Invert_matrix+0x2cf>
and    0x28(%rsp),%r13b
jne    140f <Invert_matrix+0x2cf>
and    0xf(%rsp),%r8b
jne    140f <Invert_matrix+0x2cf>
and    0xe(%rsp),%r9b
mov    0x8(%rsp),%r15d
mov    0x18(%rsp),%r13
jne    141d <Invert_matrix+0x2dd>
and    %bpl,%r10b
mov    0x10(%rsp),%r8
jne    140b <Invert_matrix+0x2cb>
mov    $0x0,%ebp
and    %bl,%dil
jne    1430 <Invert_matrix+0x2f0>
xor    %edi,%edi
mov    0x58(%rsp),%rbp
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups (%rcx,%rdi,1),%xmm2
movups 0x10(%rcx,%rdi,1),%xmm3
movups %xmm2,(%rax,%rdi,1)
movups %xmm3,0x10(%rax,%rdi,1)
movups %xmm0,(%rcx,%rdi,1)
movups %xmm1,0x10(%rcx,%rdi,1)
movupd (%rdx,%rdi,1),%xmm0
movupd 0x10(%rdx,%rdi,1),%xmm1
movupd (%rsi,%rdi,1),%xmm2
movupd 0x10(%rsi,%rdi,1),%xmm3
movupd %xmm2,(%rdx,%rdi,1)
movupd %xmm3,0x10(%rdx,%rdi,1)
movupd %xmm0,(%rsi,%rdi,1)
movupd %xmm1,0x10(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    13a0 <Invert_matrix+0x260>
mov    0x60(%rsp),%rdi
mov    %rdi,%rbp
cmp    %r14,%rdi
jne    1430 <Invert_matrix+0x2f0>
jmp    14e1 <Invert_matrix+0x3a1>
xor    %ebp,%ebp
jmp    1430 <Invert_matrix+0x2f0>
xor    %ebp,%ebp
mov    0x8(%rsp),%r15d
mov    0x18(%rsp),%r13
jmp    141f <Invert_matrix+0x2df>
xor    %ebp,%ebp
mov    0x10(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rdi
test   $0x1,%r14b
je     1468 <Invert_matrix+0x328>
movsd  (%rax,%rbp,8),%xmm0
movsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
movsd  %xmm0,(%rcx,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
movsd  %xmm0,(%rsi,%rbp,8)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    0x50(%rsp),%rbp
je     14e1 <Invert_matrix+0x3a1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rdi,8),%xmm0
movsd  (%rcx,%rdi,8),%xmm1
movsd  %xmm1,(%rax,%rdi,8)
movsd  %xmm0,(%rcx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x8(%rax,%rdi,8),%xmm0
movsd  0x8(%rcx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rax,%rdi,8)
movsd  %xmm0,0x8(%rcx,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  0x8(%rsi,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rdi,8)
movsd  %xmm0,0x8(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r14
jne    1480 <Invert_matrix+0x340>
movsd  (%rax,%r8,8),%xmm0
mov    (%r12,%r8,8),%rcx
cmp    $0x2,%r15d
jb     150b <Invert_matrix+0x3cb>
lea    (%rcx,%r14,8),%rdx
cmp    %rdx,%rax
jae    17e0 <Invert_matrix+0x6a0>
lea    (%rax,%r14,8),%rdx
cmp    %rdx,%rcx
jae    17e0 <Invert_matrix+0x6a0>
xor    %edx,%edx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    1510 <Invert_matrix+0x3d0>
lea    (%rax,%r14,8),%rcx
mov    %rcx,0x28(%rsp)
xor    %edx,%edx
jmp    155d <Invert_matrix+0x41d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %r14,%rdx
je     11f0 <Invert_matrix+0xb0>
cmp    %r8,%rdx
je     1550 <Invert_matrix+0x410>
mov    0x0(%r13,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm0
xorpd  %xmm5,%xmm0
mov    (%r12,%r8,8),%rdi
mov    (%r12,%rdx,8),%rcx
cmp    $0x2,%r15d
jae    1590 <Invert_matrix+0x450>
xor    %ebx,%ebx
jmp    1730 <Invert_matrix+0x5f0>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%r14,8),%rbp
lea    (%rcx,%r14,8),%r12
lea    (%rdi,%r14,8),%r9
cmp    %r12,%rsi
setb   0x7(%rsp)
cmp    %rbp,%rcx
setb   %r8b
mov    0x28(%rsp),%rbx
cmp    %rbx,%rsi
setb   %r13b
cmp    %rbp,%rax
setb   %r15b
cmp    %r9,%rsi
setb   %r10b
cmp    %rbp,%rdi
setb   %bpl
cmp    %rbx,%rcx
setb   %r11b
cmp    %r12,%rax
setb   %bl
cmp    %r9,%rcx
setb   %r9b
cmp    %r12,%rdi
setb   %r12b
test   %r8b,0x7(%rsp)
jne    170f <Invert_matrix+0x5cf>
and    %r15b,%r13b
jne    170f <Invert_matrix+0x5cf>
and    %bpl,%r10b
jne    170f <Invert_matrix+0x5cf>
and    %bl,%r11b
mov    0x8(%rsp),%r15d
mov    0x18(%rsp),%r13
jne    1722 <Invert_matrix+0x5e2>
mov    $0x0,%ebx
and    %r12b,%r9b
mov    0x20(%rsp),%r12
mov    0x10(%rsp),%r8
jne    1730 <Invert_matrix+0x5f0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x40(%rsp)
je     1704 <Invert_matrix+0x5c4>
mov    0x30(%rsp),%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd (%rax,%rbp,8),%xmm2
movupd (%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rsi,%rbp,8)
movupd (%rdi,%rbp,8),%xmm2
movupd (%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rcx,%rbp,8)
movupd 0x10(%rax,%rbp,8),%xmm2
movupd 0x10(%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x10(%rsi,%rbp,8)
movupd 0x10(%rdi,%rbp,8),%xmm2
movupd 0x10(%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x10(%rcx,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1650 <Invert_matrix+0x510>
testb  $0x1,0x38(%rsp)
je     16f1 <Invert_matrix+0x5b1>
movupd (%rax,%rbp,8),%xmm2
movupd (%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rsi,%rbp,8)
movupd (%rdi,%rbp,8),%xmm2
movupd (%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rcx,%rbp,8)
mov    0x48(%rsp),%rbp
mov    %rbp,%rbx
cmp    %r14,%rbp
je     1550 <Invert_matrix+0x410>
jmp    1730 <Invert_matrix+0x5f0>
xor    %ebp,%ebp
testb  $0x1,0x38(%rsp)
jne    16c3 <Invert_matrix+0x583>
jmp    16f1 <Invert_matrix+0x5b1>
xor    %ebx,%ebx
mov    0x20(%rsp),%r12
mov    0x8(%rsp),%r15d
mov    0x18(%rsp),%r13
jmp    1729 <Invert_matrix+0x5e9>
xor    %ebx,%ebx
mov    0x20(%rsp),%r12
mov    0x10(%rsp),%r8
xchg   %ax,%ax
mov    %rbx,%rbp
test   $0x1,%r14b
je     1766 <Invert_matrix+0x626>
movsd  (%rax,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rbx,8),%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  (%rdi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    0x50(%rsp),%rbx
je     1550 <Invert_matrix+0x410>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
movsd  (%rdi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movsd  0x8(%rax,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rbp,8)
movsd  0x8(%rdi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    1780 <Invert_matrix+0x640>
jmp    1550 <Invert_matrix+0x410>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x40(%rsp)
je     187f <Invert_matrix+0x73f>
mov    0x30(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdx,8)
movupd (%rcx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
movupd 0x10(%rax,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%rax,%rdx,8)
movupd 0x10(%rcx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1800 <Invert_matrix+0x6c0>
testb  $0x1,0x38(%rsp)
je     1869 <Invert_matrix+0x729>
movupd (%rax,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdx,8)
movupd (%rcx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
mov    0x48(%rsp),%rsi
mov    %rsi,%rdx
cmp    %r14,%rsi
jne    1510 <Invert_matrix+0x3d0>
jmp    1535 <Invert_matrix+0x3f5>
xor    %edx,%edx
testb  $0x1,0x38(%rsp)
jne    184d <Invert_matrix+0x70d>
jmp    1869 <Invert_matrix+0x729>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <deallocateSpace@plt>
jmp    18c7 <Invert_matrix+0x787>
mov    0x2742(%rip),%rax
mov    (%rax),%edi
lea    0x769(%rip),%rsi
call   1050 <fprintf@plt>
jmp    18c4 <Invert_matrix+0x784>
mov    %r12,%rdi
mov    %r15d,%esi
call   1040 <deallocateSpace@plt>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <deallocateSpace@plt>
xor    %r12d,%r12d
mov    %r12,%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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