#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exit(int);
double fabs(double);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *);
void paw_get_inverse(double **a, int matrix_size) {
  int i, j, l;
  int n;
  int irow;
  double big;
  double temp;
  double pivinv;
  int *index;
  n = matrix_size;
  index = (int *)malloc(n * sizeof(int));
  for (i = 0; i < n; ++i) {
    big = 0.0;
    for (j = i; j < n; ++j) {
      if (fabs(a[j][i]) >= big) {
        big = fabs(a[j][i]);
        irow = j;
      }
    }
    if (big == 0.0) {
      printf("Failed to invert matrix\n");
      exit(99);
    }
    index[i] = irow;
    if (irow != i) {
      for (j = 0; j < n; ++j) {
        temp = a[irow][j];
        a[irow][j] = a[i][j];
        a[i][j] = temp;
      }
    }
    pivinv = 1.0 / a[i][i];
    a[i][i] = 1.0;
    for (j = 0; j < n; ++j)
      a[i][j] *= pivinv;
    for (l = 0; l < n; ++l) {
      if (l != i) {
        temp = a[l][i];
        a[l][i] = 0.0;
        for (j = 0; j < n; ++j)
          a[l][j] -= a[i][j] * temp;
      }
    }
  }
  for (i = n - 1; i >= 0; i--) {
    if (index[i] != i) {
      for (j = 0; j < n; ++j) {
        temp = a[j][index[i]];
        a[j][index[i]] = a[j][i];
        a[j][i] = temp;
      }
    }
  }
}


x86 assembly (clang, -O0):
<paw_get_inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1429 <paw_get_inverse+0x2f9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ee <paw_get_inverse+0xbe>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe6f(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x28(%rbp),%xmm0
jb     11db <paw_get_inverse+0xab>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe44(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    11e0 <paw_get_inverse+0xb0>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1179 <paw_get_inverse+0x49>
movsd  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    121c <paw_get_inverse+0xec>
jp     121c <paw_get_inverse+0xec>
lea    0xe13(%rip),%rdi
call   1030 <printf@plt>
mov    $0x63,%edi
call   1050 <exit@plt>
mov    -0x20(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     12ba <paw_get_inverse+0x18a>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12b5 <paw_get_inverse+0x185>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    123d <paw_get_inverse+0x10d>
jmp    12ba <paw_get_inverse+0x18a>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  0xd2e(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  0xd0c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1339 <paw_get_inverse+0x209>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1300 <paw_get_inverse+0x1d0>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1416 <paw_get_inverse+0x2e6>
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     1403 <paw_get_inverse+0x2d3>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13fe <paw_get_inverse+0x2ce>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%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    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1391 <paw_get_inverse+0x261>
jmp    1403 <paw_get_inverse+0x2d3>
jmp    1408 <paw_get_inverse+0x2d8>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1340 <paw_get_inverse+0x210>
jmp    141b <paw_get_inverse+0x2eb>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    115f <paw_get_inverse+0x2f>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     14f7 <paw_get_inverse+0x3c7>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x10(%rbp),%eax
je     14e4 <paw_get_inverse+0x3b4>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14df <paw_get_inverse+0x3af>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movslq -0x10(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1457 <paw_get_inverse+0x327>
jmp    14e4 <paw_get_inverse+0x3b4>
jmp    14e9 <paw_get_inverse+0x3b9>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1432 <paw_get_inverse+0x302>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_get_inverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%r14d
mov    %rdi,%r12
lea    0x0(,%r14,4),%edi
call   1040 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %r14d,%r14d
jle    16e5 <paw_get_inverse+0x5b5>
mov    %r14d,%ecx
mov    %ecx,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%r11
mov    %r11,0x10(%rsp)
shr    $0x2,%r11
add    $0x1,%r11
lea    -0x1(%rcx),%rax
mov    %rax,0x18(%rsp)
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x8(%rsp)
mov    %rcx,%r13
neg    %r13
xor    %edi,%edi
movapd 0xe61(%rip),%xmm0
xorpd  %xmm8,%xmm8
movsd  0xe63(%rip),%xmm9
jmp    11bd <paw_get_inverse+0x8d>
nop
add    $0x1,%rdi
cmp    %rcx,%rdi
je     1636 <paw_get_inverse+0x506>
mov    %rdi,%rax
xorpd  %xmm4,%xmm4
movapd %xmm4,%xmm3
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rax,8),%rdx
movsd  (%rdx,%rdi,8),%xmm5
andpd  %xmm0,%xmm5
ucomisd %xmm4,%xmm5
cmovae %eax,%ebp
cmpnlesd %xmm5,%xmm3
movapd %xmm3,%xmm6
andnpd %xmm5,%xmm6
andpd  %xmm4,%xmm3
orpd   %xmm6,%xmm3
add    $0x1,%rax
movapd %xmm3,%xmm4
cmp    %rax,%rcx
jne    11d0 <paw_get_inverse+0xa0>
ucomisd %xmm8,%xmm3
jne    1213 <paw_get_inverse+0xe3>
jnp    16f4 <paw_get_inverse+0x5c4>
mov    0x20(%rsp),%rax
mov    %ebp,(%rax,%rdi,4)
mov    %ebp,%eax
cmp    %rax,%rdi
jne    1230 <paw_get_inverse+0x100>
mov    (%r12,%rdi,8),%rsi
jmp    1380 <paw_get_inverse+0x250>
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rax
mov    (%r12,%rax,8),%rdx
mov    (%r12,%rdi,8),%rsi
cmp    $0x4,%r14d
jb     1257 <paw_get_inverse+0x127>
lea    (%rsi,%rcx,8),%rax
cmp    %rax,%rdx
jae    12ca <paw_get_inverse+0x19a>
lea    (%rdx,%rcx,8),%rax
cmp    %rax,%rsi
jae    12ca <paw_get_inverse+0x19a>
xor    %ebx,%ebx
mov    %rbx,%rax
test   $0x1,%cl
je     127c <paw_get_inverse+0x14c>
movsd  (%rdx,%rbx,8),%xmm3
movsd  (%rsi,%rbx,8),%xmm4
movsd  %xmm4,(%rdx,%rbx,8)
movsd  %xmm3,(%rsi,%rbx,8)
mov    %rbx,%rax
or     $0x1,%rax
cmp    %rbx,0x18(%rsp)
je     1380 <paw_get_inverse+0x250>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm3
movsd  (%rsi,%rax,8),%xmm4
movsd  %xmm4,(%rdx,%rax,8)
movsd  %xmm3,(%rsi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm3
movsd  0x8(%rsi,%rax,8),%xmm4
movsd  %xmm4,0x8(%rdx,%rax,8)
movsd  %xmm3,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1290 <paw_get_inverse+0x160>
jmp    1380 <paw_get_inverse+0x250>
cmpq   $0x0,0x10(%rsp)
je     1625 <paw_get_inverse+0x4f5>
mov    0x8(%rsp),%rbx
xor    %eax,%eax
nopl   (%rax)
movups (%rdx,%rax,8),%xmm3
movups 0x10(%rdx,%rax,8),%xmm4
movups (%rsi,%rax,8),%xmm5
movups 0x10(%rsi,%rax,8),%xmm6
movups %xmm5,(%rdx,%rax,8)
movups %xmm6,0x10(%rdx,%rax,8)
movups %xmm3,(%rsi,%rax,8)
movups %xmm4,0x10(%rsi,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm3
movupd 0x30(%rdx,%rax,8),%xmm4
movupd 0x20(%rsi,%rax,8),%xmm5
movupd 0x30(%rsi,%rax,8),%xmm6
movupd %xmm5,0x20(%rdx,%rax,8)
movupd %xmm6,0x30(%rdx,%rax,8)
movupd %xmm3,0x20(%rsi,%rax,8)
movupd %xmm4,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    12e0 <paw_get_inverse+0x1b0>
test   $0x1,%r11b
je     1370 <paw_get_inverse+0x240>
movupd (%rdx,%rax,8),%xmm3
movupd 0x10(%rdx,%rax,8),%xmm4
movupd (%rsi,%rax,8),%xmm5
movupd 0x10(%rsi,%rax,8),%xmm6
movupd %xmm5,(%rdx,%rax,8)
movupd %xmm6,0x10(%rdx,%rax,8)
movupd %xmm3,(%rsi,%rax,8)
movupd %xmm4,0x10(%rsi,%rax,8)
mov    %r10,%rbx
cmp    %rcx,%r10
jne    1259 <paw_get_inverse+0x129>
nopl   0x0(%rax)
movapd %xmm9,%xmm3
divsd  (%rsi,%rdi,8),%xmm3
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rsi,%rdi,8)
cmp    $0x4,%r14d
jae    13b0 <paw_get_inverse+0x280>
xor    %eax,%eax
jmp    1450 <paw_get_inverse+0x320>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x0,0x10(%rsp)
je     1614 <paw_get_inverse+0x4e4>
mov    0x8(%rsp),%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rax,8),%xmm5
movupd 0x10(%rsi,%rax,8),%xmm6
movupd 0x20(%rsi,%rax,8),%xmm7
movupd 0x30(%rsi,%rax,8),%xmm1
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%rsi,%rax,8)
movupd %xmm6,0x10(%rsi,%rax,8)
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm1
movupd %xmm7,0x20(%rsi,%rax,8)
movupd %xmm1,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    13d0 <paw_get_inverse+0x2a0>
test   $0x1,%r11b
je     143c <paw_get_inverse+0x30c>
movupd (%rsi,%rax,8),%xmm1
movupd 0x10(%rsi,%rax,8),%xmm5
mulpd  %xmm4,%xmm1
mulpd  %xmm4,%xmm5
movupd %xmm1,(%rsi,%rax,8)
movupd %xmm5,0x10(%rsi,%rax,8)
mov    %r10,%rax
cmp    %rcx,%r10
je     1467 <paw_get_inverse+0x337>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1450 <paw_get_inverse+0x320>
lea    (%rsi,%rcx,8),%rdx
xor    %r15d,%r15d
jmp    147d <paw_get_inverse+0x34d>
add    $0x1,%r15
cmp    %rcx,%r15
je     11b0 <paw_get_inverse+0x80>
cmp    %rdi,%r15
je     1470 <paw_get_inverse+0x340>
mov    (%r12,%r15,8),%r8
movsd  (%r8,%rdi,8),%xmm3
movq   $0x0,(%r8,%rdi,8)
cmp    $0x4,%r14d
jb     14ac <paw_get_inverse+0x37c>
cmp    %rdx,%r8
jae    1523 <paw_get_inverse+0x3f3>
lea    (%r8,%rcx,8),%rax
cmp    %rax,%rsi
jae    1523 <paw_get_inverse+0x3f3>
xor    %ebx,%ebx
mov    %rbx,%rax
test   $0x1,%cl
je     14d6 <paw_get_inverse+0x3a6>
movsd  (%r8,%rbx,8),%xmm1
movsd  (%rsi,%rbx,8),%xmm2
mulsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%rbx,8)
mov    %rbx,%rax
or     $0x1,%rax
not    %rbx
cmp    %r13,%rbx
je     1470 <paw_get_inverse+0x340>
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r8,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r8,%rax,8),%xmm1
movsd  %xmm2,(%r8,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm2
mulsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r8,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    14e0 <paw_get_inverse+0x3b0>
jmp    1470 <paw_get_inverse+0x340>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x0,0x10(%rsp)
je     1609 <paw_get_inverse+0x4d9>
mov    0x8(%rsp),%rax
xor    %r9d,%r9d
nop
movupd (%rsi,%r9,8),%xmm1
movupd 0x10(%rsi,%r9,8),%xmm5
mulpd  %xmm4,%xmm1
movupd (%r8,%r9,8),%xmm6
subpd  %xmm1,%xmm6
movupd 0x10(%r8,%r9,8),%xmm1
movupd 0x20(%r8,%r9,8),%xmm7
movupd 0x30(%r8,%r9,8),%xmm2
mulpd  %xmm4,%xmm5
subpd  %xmm5,%xmm1
movupd %xmm6,(%r8,%r9,8)
movupd %xmm1,0x10(%r8,%r9,8)
movupd 0x20(%rsi,%r9,8),%xmm1
movupd 0x30(%rsi,%r9,8),%xmm5
mulpd  %xmm4,%xmm1
subpd  %xmm1,%xmm7
mulpd  %xmm4,%xmm5
subpd  %xmm5,%xmm2
movupd %xmm7,0x20(%r8,%r9,8)
movupd %xmm2,0x30(%r8,%r9,8)
add    $0x8,%r9
add    $0xfffffffffffffffe,%rax
jne    1540 <paw_get_inverse+0x410>
test   $0x1,%r11b
je     15f8 <paw_get_inverse+0x4c8>
movupd (%rsi,%r9,8),%xmm1
movupd 0x10(%rsi,%r9,8),%xmm2
movupd (%r8,%r9,8),%xmm5
movupd 0x10(%r8,%r9,8),%xmm6
mulpd  %xmm4,%xmm1
subpd  %xmm1,%xmm5
mulpd  %xmm4,%xmm2
subpd  %xmm2,%xmm6
movupd %xmm5,(%r8,%r9,8)
movupd %xmm6,0x10(%r8,%r9,8)
mov    %r10,%rbx
cmp    %rcx,%r10
je     1470 <paw_get_inverse+0x340>
jmp    14ae <paw_get_inverse+0x37e>
xor    %r9d,%r9d
test   $0x1,%r11b
jne    15c1 <paw_get_inverse+0x491>
jmp    15f8 <paw_get_inverse+0x4c8>
xor    %eax,%eax
test   $0x1,%r11b
jne    141e <paw_get_inverse+0x2ee>
jmp    143c <paw_get_inverse+0x30c>
xor    %eax,%eax
test   $0x1,%r11b
jne    1344 <paw_get_inverse+0x214>
jmp    1370 <paw_get_inverse+0x240>
test   %r14d,%r14d
jle    16e5 <paw_get_inverse+0x5b5>
mov    %ecx,%edx
and    $0xfffffffe,%edx
mov    %rcx,%rax
jmp    165a <paw_get_inverse+0x52a>
nopl   0x0(%rax)
cmp    $0x1,%r8
jle    16e5 <paw_get_inverse+0x5b5>
mov    %rax,%r8
add    $0xffffffffffffffff,%rax
mov    %eax,%edi
mov    0x20(%rsp),%rsi
movslq (%rsi,%rdi,4),%rbp
cmp    %eax,%ebp
je     1650 <paw_get_inverse+0x520>
cmpq   $0x0,0x18(%rsp)
je     16c1 <paw_get_inverse+0x591>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rsi
movsd  (%rsi,%rbp,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
movsd  %xmm0,(%rsi,%rdi,8)
mov    0x8(%r12,%rbx,8),%rsi
movsd  (%rsi,%rbp,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    1680 <paw_get_inverse+0x550>
test   $0x1,%cl
je     1650 <paw_get_inverse+0x520>
jmp    16c8 <paw_get_inverse+0x598>
xor    %ebx,%ebx
test   $0x1,%cl
je     1650 <paw_get_inverse+0x520>
mov    (%r12,%rbx,8),%rsi
movsd  (%rsi,%rbp,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
movsd  %xmm0,(%rsi,%rdi,8)
jmp    1650 <paw_get_inverse+0x520>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x91d(%rip),%rdi
call   1030 <puts@plt>
mov    $0x63,%edi
call   1050 <exit@plt>

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

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