#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 */
typedef int k;
typedef int j;
typedef int i;
typedef int dim;

/* Variables and functions */
scalar_t__ calloc(unsigned int, int);
int /*<<< orphan*/ free(int *);
int MatrixSolve(int dim, double *matrix) {
  register int i, j, k;
  register double temp;
  int *order;
  int singular;
  order = (int *)calloc((unsigned)dim, sizeof(int));
  singular = 0;
  for (i = 0; i < dim; i++)
    order[i] = i;
  for (i = 0; i < dim; i++) {
    temp = ((matrix[dim * (i) + (i)]) < 0.0 ? -(matrix[dim * (i) + (i)])
                                            : (matrix[dim * (i) + (i)]));
    k = i;
    for (j = i; j < dim; j++) {
      if (((matrix[dim * (j) + (i)]) < 0.0
               ? -(matrix[dim * (j) + (i)])
               : (matrix[dim * (j) + (i)])) > temp) {
        temp = ((matrix[dim * (j) + (i)]) < 0.0 ? -(matrix[dim * (j) + (i)])
                                                : (matrix[dim * (j) + (i)]));
        k = j;
      }
    }
    if (i != k)
      for (j = 0; j < dim; j++) {
        temp = matrix[dim * (i) + (j)];
        matrix[dim * (i) + (j)] = matrix[dim * (k) + (j)];
        matrix[dim * (k) + (j)] = temp;
      }
    j = order[i];
    order[i] = order[k];
    order[k] = j;
    if (matrix[dim * (i) + (i)] == 0.0) {
      matrix[dim * (i) + (i)] = 1.0;
      matrix[dim * (dim) + (i)] = 0.0;
      singular++;
    }
    temp = matrix[dim * (i) + (i)];
    for (j = i; j < dim + 1; j++)
      matrix[dim * (j) + (i)] /= temp;
    for (j = 0; j < dim; j++) {
      if (i != j) {
        temp = matrix[dim * (i) + (j)];
        for (k = i; k < dim + 1; k++)
          matrix[dim * (k) + (j)] -= temp * matrix[dim * (k) + (i)];
      }
    }
  }
  for (i = 0; i < dim; i++) {
    for (j = i; j < dim; j++) {
      if (order[j] == i)
        break;
    }
    temp = matrix[dim * (dim) + (i)];
    matrix[dim * (dim) + (i)] = matrix[dim * (dim) + (j)];
    matrix[dim * (dim) + (j)] = temp;
    k = order[i];
    order[i] = order[j];
    order[j] = k;
  }
  (void)free(order);
  return singular;
}


x86 assembly (clang, -O0):
<MatrixSolve>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1176 <MatrixSolve+0x56>
mov    -0x14(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    114e <MatrixSolve+0x2e>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a3 <MatrixSolve+0x483>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    11df <MatrixSolve+0xbf>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11fa <MatrixSolve+0xda>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1331 <MatrixSolve+0x211>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1272 <MatrixSolve+0x152>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    128d <MatrixSolve+0x16d>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    131e <MatrixSolve+0x1fe>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    12f3 <MatrixSolve+0x1d3>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    130e <MatrixSolve+0x1ee>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1323 <MatrixSolve+0x203>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1210 <MatrixSolve+0xf0>
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     13c5 <MatrixSolve+0x2a5>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13c0 <MatrixSolve+0x2a0>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1344 <MatrixSolve+0x224>
jmp    13c5 <MatrixSolve+0x2a5>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1460 <MatrixSolve+0x340>
jp     1460 <MatrixSolve+0x340>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xbc7(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14c4 <MatrixSolve+0x3a4>
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1481 <MatrixSolve+0x361>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1590 <MatrixSolve+0x470>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     157d <MatrixSolve+0x45d>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1578 <MatrixSolve+0x458>
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1504 <MatrixSolve+0x3e4>
jmp    157d <MatrixSolve+0x45d>
jmp    1582 <MatrixSolve+0x462>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14cb <MatrixSolve+0x3ab>
jmp    1595 <MatrixSolve+0x475>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    117d <MatrixSolve+0x5d>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1696 <MatrixSolve+0x576>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15f4 <MatrixSolve+0x4d4>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
jne    15e1 <MatrixSolve+0x4c1>
jmp    15f4 <MatrixSolve+0x4d4>
jmp    15e6 <MatrixSolve+0x4c6>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    15bc <MatrixSolve+0x49c>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15aa <MatrixSolve+0x48a>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatrixSolve>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rsi,%r15
mov    %edi,%ebx
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rbx,%r8
test   %r8d,%r8d
jle    16d1 <MatrixSolve+0x5b1>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    115c <MatrixSolve+0x3c>
xor    %edx,%edx
jmp    12b0 <MatrixSolve+0x190>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rcx
jae    118b <MatrixSolve+0x6b>
movdqa 0xe7c(%rip),%xmm0
xor    %ebp,%ebp
jmp    1258 <MatrixSolve+0x138>
and    $0xfffffffffffffffc,%rdi
movdqa 0xe69(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xe6e(%rip),%xmm8
movdqa 0xe75(%rip),%xmm9
movdqa 0xe7c(%rip),%xmm10
movdqa 0xe84(%rip),%xmm4
movdqa 0xe8c(%rip),%xmm5
movdqa 0xe94(%rip),%xmm6
movdqa 0xe9c(%rip),%xmm7
movdqa 0xea4(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rax,%rbp,4)
movdqu %xmm2,0x10(%rax,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rax,%rbp,4)
movdqu %xmm3,0x30(%rax,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rax,%rbp,4)
movdqu %xmm3,0x50(%rax,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rax,%rbp,4)
movdqu %xmm3,0x70(%rax,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    11e0 <MatrixSolve+0xc0>
test   %rsi,%rsi
je     12a0 <MatrixSolve+0x180>
lea    (%rax,%rbp,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rsi
xor    %edi,%edi
movdqa 0xd9d(%rip),%xmm1
movdqa 0xda5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm3,(%rcx,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1280 <MatrixSolve+0x160>
cmp    %r9,%rdx
je     12bc <MatrixSolve+0x19c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r9
jne    12b0 <MatrixSolve+0x190>
test   %r8d,%r8d
jle    16d1 <MatrixSolve+0x5b1>
mov    %r8d,%ecx
imul   %ecx,%ecx
mov    %rcx,0x20(%rsp)
lea    0x1(%r8),%r13d
lea    (%r15,%r9,8),%rcx
mov    %rcx,0x60(%rsp)
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x50(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x40(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x48(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x38(%rsp)
mov    %r9,%rcx
neg    %rcx
mov    %rcx,0x68(%rsp)
lea    0x0(,%r9,8),%rdi
lea    0x8(,%r9,8),%rcx
mov    %rcx,0x70(%rsp)
lea    0x30(%r15),%r11
lea    0x8(%r15),%r10
xor    %r12d,%r12d
movapd 0xd4a(%rip),%xmm0
pxor   %xmm1,%xmm1
mov    %r15,0x28(%rsp)
mov    %r10,0x58(%rsp)
mov    %r11,0x30(%rsp)
mov    %r15,%rbx
movl   $0x0,0xc(%rsp)
mov    %r8,0x10(%rsp)
jmp    1391 <MatrixSolve+0x271>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    0x70(%rsp),%rbx
add    %rdi,%r11
add    %rdi,%r10
add    $0xffffffffffffffff,%r13
add    %rdi,0x28(%rsp)
cmp    %r9,%r12
je     16d5 <MatrixSolve+0x5b5>
mov    %r12,%rcx
imul   %r9,%rcx
lea    (%r15,%rcx,8),%rdx
mov    %rdx,0x80(%rsp)
add    %r9,%rcx
lea    (%r15,%rcx,8),%rcx
mov    %rcx,0x78(%rsp)
mov    %r12,%r14
imul   %r9,%r14
mov    %r12d,%ecx
imul   %r8d,%ecx
movslq %ecx,%rsi
add    %r12,%rsi
movsd  (%r15,%rsi,8),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm0,%xmm4
movapd %xmm2,%xmm3
cmpltsd %xmm1,%xmm3
andpd  %xmm3,%xmm4
andnpd %xmm2,%xmm3
orpd   %xmm4,%xmm3
mov    %rbx,%rdx
mov    %r12,%r8
mov    %r12d,%ebp
movsd  (%rdx),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm0,%xmm5
movapd %xmm4,%xmm6
cmpltsd %xmm1,%xmm6
andpd  %xmm6,%xmm5
andnpd %xmm4,%xmm6
orpd   %xmm5,%xmm6
ucomisd %xmm3,%xmm6
cmova  %r8d,%ebp
maxsd  %xmm3,%xmm6
add    $0x1,%r8
add    %rdi,%rdx
movapd %xmm6,%xmm3
cmp    %r8,%r9
jne    13f0 <MatrixSolve+0x2d0>
mov    %ebp,%ecx
cmp    %rcx,%r12
mov    0x10(%rsp),%r8
je     1616 <MatrixSolve+0x4f6>
mov    %ebp,%ecx
imul   %r8d,%ecx
movslq %ecx,%rdx
cmp    $0x4,%r8d
mov    %rdx,0x18(%rsp)
jb     1477 <MatrixSolve+0x357>
mov    0x60(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
cmp    %rcx,0x80(%rsp)
jae    151e <MatrixSolve+0x3fe>
lea    (%r15,%rdx,8),%rcx
cmp    0x78(%rsp),%rcx
jae    151e <MatrixSolve+0x3fe>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r9b
je     14b2 <MatrixSolve+0x392>
lea    (%rdx,%r14,1),%r8
movsd  (%r15,%r8,8),%xmm2
mov    0x18(%rsp),%rcx
add    %rdx,%rcx
movsd  (%r15,%rcx,8),%xmm3
movsd  %xmm3,(%r15,%r8,8)
mov    0x10(%rsp),%r8
movsd  %xmm2,(%r15,%rcx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x68(%rsp),%rdx
je     1610 <MatrixSolve+0x4f0>
mov    0x58(%rsp),%rdx
mov    0x18(%rsp),%r8
lea    (%rdx,%r8,8),%rdx
mov    0x10(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%r10,%rcx,8),%xmm2
movsd  -0x8(%rdx,%rcx,8),%xmm3
movsd  %xmm3,-0x8(%r10,%rcx,8)
movsd  %xmm2,-0x8(%rdx,%rcx,8)
movsd  (%r10,%rcx,8),%xmm2
movsd  (%rdx,%rcx,8),%xmm3
movsd  %xmm3,(%r10,%rcx,8)
movsd  %xmm2,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    14e0 <MatrixSolve+0x3c0>
jmp    1610 <MatrixSolve+0x4f0>
cmpq   $0x0,0x50(%rsp)
je     15a8 <MatrixSolve+0x488>
mov    0x30(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x38(%rsp),%r8
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x30(%r11,%rdx,8),%xmm2
movups -0x20(%r11,%rdx,8),%xmm3
movups -0x30(%rcx,%rdx,8),%xmm4
movups -0x20(%rcx,%rdx,8),%xmm5
movups %xmm4,-0x30(%r11,%rdx,8)
movups %xmm5,-0x20(%r11,%rdx,8)
movups %xmm2,-0x30(%rcx,%rdx,8)
movups %xmm3,-0x20(%rcx,%rdx,8)
movupd -0x10(%r11,%rdx,8),%xmm2
movupd (%r11,%rdx,8),%xmm3
movupd -0x10(%rcx,%rdx,8),%xmm4
movupd (%rcx,%rdx,8),%xmm5
movupd %xmm4,-0x10(%r11,%rdx,8)
movupd %xmm5,(%r11,%rdx,8)
movupd %xmm2,-0x10(%rcx,%rdx,8)
movupd %xmm3,(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%r8
jne    1540 <MatrixSolve+0x420>
jmp    15aa <MatrixSolve+0x48a>
xor    %edx,%edx
testb  $0x1,0x48(%rsp)
mov    0x10(%rsp),%r8
je     15f3 <MatrixSolve+0x4d3>
lea    (%rdx,%r14,1),%rcx
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
add    0x18(%rsp),%rdx
movupd (%r15,%rdx,8),%xmm4
movupd 0x10(%r15,%rdx,8),%xmm5
movupd %xmm4,(%r15,%rcx,8)
movupd %xmm5,0x10(%r15,%rcx,8)
movupd %xmm2,(%r15,%rdx,8)
movupd %xmm3,0x10(%r15,%rdx,8)
mov    0x40(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r9,%rcx
jne    1479 <MatrixSolve+0x359>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rsi,8),%xmm2
mov    (%rax,%r12,4),%ecx
movslq %ebp,%rdx
mov    (%rax,%rdx,4),%ebp
mov    %ebp,(%rax,%r12,4)
mov    %ecx,(%rax,%rdx,4)
ucomisd %xmm1,%xmm2
jne    1658 <MatrixSolve+0x538>
jp     1658 <MatrixSolve+0x538>
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r15,%rsi,8)
mov    0x20(%rsp),%rcx
add    %r12d,%ecx
movq   $0x0,(%r15,%rcx,8)
addl   $0x1,0xc(%rsp)
movsd  (%r15,%rsi,8),%xmm2
mov    %r13,%rcx
mov    %rbx,%rdx
xchg   %ax,%ax
movsd  (%rdx),%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,(%rdx)
add    %rdi,%rdx
add    $0xffffffffffffffff,%rcx
jne    1660 <MatrixSolve+0x540>
mov    0x28(%rsp),%rdx
xor    %ebp,%ebp
jmp    1691 <MatrixSolve+0x571>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%rdx
cmp    %r9,%rbp
je     1370 <MatrixSolve+0x250>
cmp    %rbp,%r12
je     1680 <MatrixSolve+0x560>
lea    (%r14,%rbp,1),%rcx
movsd  (%r15,%rcx,8),%xmm2
xorpd  %xmm0,%xmm2
xor    %ecx,%ecx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rsi,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx,%rsi,1),%xmm3
movsd  %xmm3,(%rdx,%rsi,1)
add    %rdi,%rsi
add    $0x1,%rcx
cmp    %rcx,%r13
jne    16b0 <MatrixSolve+0x590>
jmp    1680 <MatrixSolve+0x560>
xor    %ebx,%ebx
jmp    174a <MatrixSolve+0x62a>
test   %r8d,%r8d
jle    1746 <MatrixSolve+0x626>
xor    %edx,%edx
mov    0xc(%rsp),%ebx
jmp    172a <MatrixSolve+0x60a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%rdi
lea    (%rdx,%rdi,1),%rcx
movsd  (%r15,%rcx,8),%xmm0
add    %esi,%edi
movsd  (%r15,%rdi,8),%xmm1
movsd  %xmm1,(%r15,%rcx,8)
movsd  %xmm0,(%r15,%rdi,8)
mov    (%rax,%rdx,4),%ecx
mov    %esi,%esi
mov    (%rax,%rsi,4),%edi
mov    %edi,(%rax,%rdx,4)
mov    %ecx,(%rax,%rsi,4)
add    $0x1,%rdx
cmp    %r9,%rdx
je     174a <MatrixSolve+0x62a>
mov    %rdx,%rsi
nopl   (%rax)
mov    (%rax,%rsi,4),%ecx
cmp    %rcx,%rdx
je     16f0 <MatrixSolve+0x5d0>
add    $0x1,%rsi
cmp    %rsi,%r9
jne    1730 <MatrixSolve+0x610>
mov    %r9d,%esi
jmp    16f0 <MatrixSolve+0x5d0>
mov    0xc(%rsp),%ebx
mov    %rax,%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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