#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 ssize_t;

/* Variables and functions */
double *alloc_matrix(int, int const);
int /*<<< orphan*/ free_matrix(double *);
int /*<<< orphan*/ memcpy(double *, double const *, int);
int invert_matrix(ssize_t n, const double m[], double mi[]) {
  const ssize_t n2 = 2 * n;
  ssize_t i, j, k;
  int status = 0;
  const ssize_t lda = n2;
  const ssize_t ldm = n;
  double *a = 0;
  if (!(a = alloc_matrix(n, n2))) {
    return (status = 1);
  }
  for (i = 0; i < n; ++i) {
    memcpy(a + i * lda, m + i * ldm, n * sizeof(double));
  }
  for (i = 0; i < n; ++i) {
    a[i * lda + n + i] = 1;
  }
  for (i = 0; i < n; ++i) {
    k = i;
    while (k < n && a[k * lda + i] == 0) {
      ++k;
    }
    if (k == n) {
      break;
    }
    if (k != i) {
      for (j = 0; j < n2; ++j) {
        double temp = a[k * lda + j];
        a[k * lda + j] = a[i * lda + j];
        a[i * lda + j] = temp;
      }
    }
    for (j = n2 - 1; j >= i; --j) {
      a[i * lda + j] /= a[i * lda + i];
    }
    for (k = 0; k < n; ++k) {
      if (k != i) {
        for (j = n2 - 1; j >= i; --j) {
          a[k * lda + j] = a[k * lda + j] - a[i * lda + j] * a[k * lda + i];
        }
      }
    }
  }
  if (i != n) {
    status = 2;
  } else {
    for (i = 0; i < n; ++i) {
      memcpy(mi + i * ldm, a + i * lda + n, n * sizeof(double));
    }
  }
  free_matrix(a);
  return status;
}


x86 assembly (clang, -O0):
<invert_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x1c(%rbp),%esi
call   1040 <alloc_matrix@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    1193 <invert_matrix+0x63>
movl   $0x1,-0x2c(%rbp)
movl   $0x1,-0x4(%rbp)
jmp    150d <invert_matrix+0x3dd>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11eb <invert_matrix+0xbb>
mov    -0x40(%rbp),%rdi
mov    -0x20(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    119a <invert_matrix+0x6a>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    122d <invert_matrix+0xfd>
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xde6(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11f2 <invert_matrix+0xc2>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    147e <invert_matrix+0x34e>
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x8(%rbp),%ecx
mov    %al,-0x49(%rbp)
jge    127f <invert_matrix+0x14f>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
sete   %al
setnp  %cl
and    %cl,%al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    128f <invert_matrix+0x15f>
jmp    129d <invert_matrix+0x16d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1246 <invert_matrix+0x116>
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    12ae <invert_matrix+0x17e>
jmp    147e <invert_matrix+0x34e>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1342 <invert_matrix+0x212>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133d <invert_matrix+0x20d>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12c1 <invert_matrix+0x191>
jmp    1342 <invert_matrix+0x212>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     139a <invert_matrix+0x26a>
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    134b <invert_matrix+0x21b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    146b <invert_matrix+0x33b>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1458 <invert_matrix+0x328>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     1453 <invert_matrix+0x323>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    13c2 <invert_matrix+0x292>
jmp    1458 <invert_matrix+0x328>
jmp    145d <invert_matrix+0x32d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13a1 <invert_matrix+0x271>
jmp    1470 <invert_matrix+0x340>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1234 <invert_matrix+0x104>
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
je     1496 <invert_matrix+0x366>
movl   $0x2,-0x2c(%rbp)
jmp    14fe <invert_matrix+0x3ce>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14f9 <invert_matrix+0x3c9>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x40(%rbp),%rsi
mov    -0x20(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    149d <invert_matrix+0x36d>
jmp    14fe <invert_matrix+0x3ce>
mov    -0x40(%rbp),%rdi
call   1030 <free_matrix@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rdx,%r14
mov    %rsi,%rbp
mov    %edi,%r13d
lea    0x0(%r13,%r13,1),%ebx
mov    %ebx,%esi
call   1040 <alloc_matrix@plt>
test   %rax,%rax
je     185b <invert_matrix+0x72b>
mov    %rax,%r9
mov    %r14,0x110(%rsp)
xor    %r14d,%r14d
movslq %ebx,%r15
mov    %r13d,%r12d
test   %r13d,%r13d
mov    %rax,0x50(%rsp)
jle    18f0 <invert_matrix+0x7c0>
mov    %ebx,0x1c(%rsp)
mov    %r13,0x78(%rsp)
mov    %r15,%rax
lea    0x0(,%r13,8),%r15d
mov    %r12,%rbx
lea    0x0(,%r12,8),%r12
mov    %rax,0x8(%rsp)
lea    0x0(,%rax,8),%rsi
mov    %rbx,0x10(%rsp)
mov    %r9,%r13
mov    %rsi,0x28(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r15d,%edx
call   1050 <memcpy@plt>
mov    0x28(%rsp),%rsi
add    %r12,%rbp
add    %rsi,%r13
add    $0xffffffffffffffff,%rbx
jne    11c0 <invert_matrix+0x90>
mov    0x78(%rsp),%r13
test   %r13d,%r13d
mov    0x50(%rsp),%r9
mov    0x8(%rsp),%r15
mov    0x10(%rsp),%r12
jle    18f0 <invert_matrix+0x7c0>
xor    %eax,%eax
cmp    $0x1,%r13d
mov    0x1c(%rsp),%ebx
jne    1871 <invert_matrix+0x741>
test   $0x1,%r12b
jne    18ca <invert_matrix+0x79a>
test   %r13d,%r13d
jle    18ed <invert_matrix+0x7bd>
cmp    $0x2,%ebx
mov    $0x1,%eax
cmovge %ebx,%eax
lea    -0x1(%r15),%r11
mov    %rsi,%rbx
or     $0x8,%rbx
lea    (%r9,%rax,8),%rcx
mov    %rcx,0xb0(%rsp)
mov    %eax,%ecx
and    $0x7ffffffc,%ecx
mov    %rcx,0xa8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xa0(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x98(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x90(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0xc0(%rsp)
lea    0x8(,%r15,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    0x30(%r9),%r10
lea    0x8(%r9),%rdx
lea    -0x8(%r9),%rbp
lea    (%r9,%r15,8),%r8
add    $0xfffffffffffffff0,%r8
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
movapd 0xd41(%rip),%xmm1
mov    %r9,%r12
mov    %r8,0xc8(%rsp)
mov    %r15,%r14
mov    %rdx,0xb8(%rsp)
mov    %rdx,0x38(%rsp)
mov    %r10,0x88(%rsp)
mov    %r10,0x60(%rsp)
mov    %r15,%r10
mov    %r9,%rdi
xor    %r14d,%r14d
mov    %rax,0x68(%rsp)
mov    %r11,0x20(%rsp)
mov    %rbx,0xd8(%rsp)
mov    %rbp,0x70(%rsp)
mov    %rcx,%rbp
mov    %r10,0xf0(%rsp)
and    $0xfffffffffffffffc,%r10
neg    %r10
mov    %r11,%rcx
mov    %r14,%r11
imul   %r15,%r11
lea    (%r9,%r11,8),%rdx
mov    %rdx,0x30(%rsp)
mov    %r11,%rdx
add    %r11,%rax
lea    (%r9,%rax,8),%rax
mov    %rax,0x40(%rsp)
mov    %r15,%rax
sub    %r14,%rax
mov    %rax,0x58(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x80(%rsp)
imul   %r14,%rbx
add    %r9,%rbx
mov    %rbx,0x108(%rsp)
lea    (%r11,%r15,1),%rax
lea    (%r9,%rax,8),%rax
mov    %rax,0x100(%rsp)
mov    %rcx,%rax
sub    %r14,%rax
add    %r11,%rcx
lea    (%r9,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
mov    %rdi,0xe8(%rsp)
mov    %rbp,0xf8(%rsp)
mov    %ebp,%ecx
mov    %r14,%rbx
mov    0x38(%rsp),%rbp
mov    0x1c(%rsp),%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi),%xmm2
ucomisd %xmm0,%xmm2
jne    13d2 <invert_matrix+0x2a2>
jp     13d2 <invert_matrix+0x2a2>
add    $0x1,%rbx
add    %r11d,%ecx
add    %rsi,%rdi
cmp    %rbx,0x10(%rsp)
jne    13b0 <invert_matrix+0x280>
jmp    1865 <invert_matrix+0x735>
cmp    %ebx,0x10(%rsp)
je     1865 <invert_matrix+0x735>
mov    %ebx,%edi
cmp    %rdi,%r14
mov    0x68(%rsp),%r13
je     15a6 <invert_matrix+0x476>
movslq %ecx,%rcx
cmp    $0x4,%r13d
jb     141b <invert_matrix+0x2eb>
lea    (%r9,%rcx,8),%rdi
cmp    0x40(%rsp),%rdi
jae    14ac <invert_matrix+0x37c>
mov    0xb0(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdi
cmp    %rdi,0x30(%rsp)
jae    14ac <invert_matrix+0x37c>
xor    %ebx,%ebx
mov    %rbx,%rdi
test   $0x1,%r13b
je     144c <invert_matrix+0x31c>
lea    (%rbx,%rcx,1),%rdi
movsd  (%r9,%rdi,8),%xmm2
add    %rbx,%rdx
movsd  (%r9,%rdx,8),%xmm3
movsd  %xmm3,(%r9,%rdi,8)
movsd  %xmm2,(%r9,%rdx,8)
mov    %rbx,%rdi
or     $0x1,%rdi
not    %rbx
cmp    0xc0(%rsp),%rbx
je     15a6 <invert_matrix+0x476>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rdi,8),%xmm2
movsd  -0x8(%rbp,%rdi,8),%xmm3
movsd  %xmm3,-0x8(%rcx,%rdi,8)
movsd  %xmm2,-0x8(%rbp,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm2
movsd  0x0(%rbp,%rdi,8),%xmm3
movsd  %xmm3,(%rcx,%rdi,8)
movsd  %xmm2,0x0(%rbp,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    1470 <invert_matrix+0x340>
jmp    15a6 <invert_matrix+0x476>
cmpq   $0x0,0xa0(%rsp)
je     1540 <invert_matrix+0x410>
mov    0x88(%rsp),%rdi
mov    %rcx,%r15
lea    (%rdi,%rcx,8),%rbx
mov    0x90(%rsp),%rbp
xor    %edi,%edi
mov    0x60(%rsp),%rcx
nopl   0x0(%rax)
movups -0x30(%rbx,%rdi,8),%xmm2
movups -0x20(%rbx,%rdi,8),%xmm3
movups -0x30(%rcx,%rdi,8),%xmm4
movups -0x20(%rcx,%rdi,8),%xmm5
movups %xmm4,-0x30(%rbx,%rdi,8)
movups %xmm5,-0x20(%rbx,%rdi,8)
movups %xmm2,-0x30(%rcx,%rdi,8)
movups %xmm3,-0x20(%rcx,%rdi,8)
movupd -0x10(%rbx,%rdi,8),%xmm2
movupd (%rbx,%rdi,8),%xmm3
movupd -0x10(%rcx,%rdi,8),%xmm4
movupd (%rcx,%rdi,8),%xmm5
movupd %xmm4,-0x10(%rbx,%rdi,8)
movupd %xmm5,(%rbx,%rdi,8)
movupd %xmm2,-0x10(%rcx,%rdi,8)
movupd %xmm3,(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    14e0 <invert_matrix+0x3b0>
jmp    1545 <invert_matrix+0x415>
mov    %rcx,%r15
xor    %edi,%edi
testb  $0x1,0x98(%rsp)
01
mov    %r15,%rcx
je     158d <invert_matrix+0x45d>
lea    (%rdi,%rcx,1),%rbx
movupd (%r9,%rbx,8),%xmm2
movupd 0x10(%r9,%rbx,8),%xmm3
add    %rdx,%rdi
movupd (%r9,%rdi,8),%xmm4
movupd 0x10(%r9,%rdi,8),%xmm5
movupd %xmm4,(%r9,%rbx,8)
movupd %xmm5,0x10(%r9,%rbx,8)
movupd %xmm2,(%r9,%rdi,8)
movupd %xmm3,0x10(%r9,%rdi,8)
mov    0xa8(%rsp),%rdi
mov    %rdi,%rbx
cmp    %r13,%rdi
mov    0x38(%rsp),%rbp
jne    141d <invert_matrix+0x2ed>
mov    0x8(%rsp),%rdx
cmp    %rdx,%r14
mov    0x70(%rsp),%rdi
jge    15e9 <invert_matrix+0x4b9>
mov    %r11d,%ecx
imul   %r14d,%ecx
movslq %ecx,%rcx
add    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rdx,8),%xmm2
divsd  (%r9,%rcx,8),%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
add    $0xffffffffffffffff,%rdx
cmp    %r14,%rdx
jg     15d0 <invert_matrix+0x4a0>
mov    $0x8,%ecx
mul    %rcx
seto   %bl
mov    0x48(%rsp),%rdx
mov    %rdx,%rcx
sub    %rax,%rcx
neg    %rax
cmp    %rdx,%rcx
seta   %cl
mov    %bl,0x48(%rsp)
or     %bl,%cl
mov    %cl,0x40(%rsp)
mov    0x58(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    0x20(%rsp),%rdx
mov    %rcx,0x30(%rsp)
sub    %rcx,%rdx
mov    %rdx,0xe0(%rsp)
mov    %r9,%r15
mov    0xc8(%rsp),%rcx
xor    %edi,%edi
jmp    1655 <invert_matrix+0x525>
nop
add    $0x1,%rdi
add    %rsi,%rcx
add    %rsi,%r15
cmp    0x10(%rsp),%rdi
je     17d5 <invert_matrix+0x6a5>
cmp    %r14,%rdi
je     1640 <invert_matrix+0x510>
cmp    0x8(%rsp),%r14
jge    1640 <invert_matrix+0x510>
mov    %rdi,%rbp
imul   0x8(%rsp),%rbp
lea    (%r14,%rbp,1),%rdx
mov    0x20(%rsp),%rbx
cmpq   $0x4,0x58(%rsp)
jb     16a6 <invert_matrix+0x576>
mov    0x20(%rsp),%r13
mov    %r13,%rbx
add    %rbp,%rbx
lea    (%r9,%rbx,8),%rbx
lea    (%rbx,%rax,1),%rsi
cmp    %rbx,%rsi
mov    0x28(%rsp),%rsi
seta   %bl
or     0x48(%rsp),%bl
or     0x40(%rsp),%bl
mov    %r13,%rbx
je     16dd <invert_matrix+0x5ad>
add    $0x1,%rbx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rbx,8),%xmm2
movsd  -0x8(%r12,%rbx,8),%xmm3
mulsd  (%r9,%rdx,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,-0x8(%r15,%rbx,8)
add    $0xffffffffffffffff,%rbx
cmp    %r14,%rbx
jg     16b0 <invert_matrix+0x580>
jmp    1640 <invert_matrix+0x510>
lea    (%r9,%rdx,8),%rsi
mov    0x80(%rsp),%rbx
add    %rbp,%rbx
lea    (%r9,%rbx,8),%r13
add    0x8(%rsp),%rbp
lea    (%r9,%rbp,8),%rbx
cmp    %rbx,%rsi
setb   %r9b
cmp    %r13,%rsi
setb   %r11b
cmp    0x100(%rsp),%rsi
mov    0x28(%rsp),%rsi
setb   %bpl
cmp    %rbx,0x108(%rsp)
setb   %r13b
mov    0x20(%rsp),%rbx
test   %r11b,%r9b
mov    0x1c(%rsp),%r11d
mov    0x50(%rsp),%r9
jne    16a6 <invert_matrix+0x576>
mov    0x20(%rsp),%rbx
and    %r13b,%bpl
jne    16a6 <invert_matrix+0x576>
movsd  (%r9,%rdx,8),%xmm2
unpcklpd %xmm2,%xmm2
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rbx,8),%xmm3
movupd (%rcx,%rbx,8),%xmm4
movupd -0x10(%r8,%rbx,8),%xmm5
movupd (%r8,%rbx,8),%xmm6
shufpd $0x1,%xmm6,%xmm6
shufpd $0x1,%xmm5,%xmm5
xorpd  %xmm1,%xmm6
xorpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm6
mulpd  %xmm2,%xmm5
shufpd $0x1,%xmm6,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%rcx,%rbx,8)
shufpd $0x1,%xmm5,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,-0x10(%rcx,%rbx,8)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%r10
jne    1760 <invert_matrix+0x630>
mov    0xe0(%rsp),%rbx
mov    0x30(%rsp),%rbp
cmp    %rbp,0x58(%rsp)
je     1640 <invert_matrix+0x510>
jmp    16a6 <invert_matrix+0x576>
mov    0xf8(%rsp),%rcx
add    %r11d,%ecx
mov    0xe8(%rsp),%rdi
add    0xd0(%rsp),%rdi
add    %rsi,0x60(%rsp)
add    %rsi,0x38(%rsp)
mov    0x70(%rsp),%rbp
add    %rsi,%rbp
mov    0xf0(%rsp),%r10
add    $0xffffffffffffffff,%r10
add    %rsi,%r8
add    %rsi,%r12
mov    0x80(%rsp),%rax
mov    %rax,%r14
cmp    0x10(%rsp),%rax
mov    0x78(%rsp),%r13
mov    0x8(%rsp),%r15
mov    0x68(%rsp),%rax
mov    0x20(%rsp),%r11
mov    0xd8(%rsp),%rbx
jne    1302 <invert_matrix+0x1d2>
test   %r13d,%r13d
mov    0x10(%rsp),%r12
jg     1905 <invert_matrix+0x7d5>
xor    %ebp,%ebp
jmp    1951 <invert_matrix+0x821>
mov    $0x1,%ebp
jmp    1959 <invert_matrix+0x829>
mov    0x8(%rsp),%r15
mov    0x10(%rsp),%r12
jmp    18f0 <invert_matrix+0x7c0>
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
lea    0x1(%r13,%r13,2),%edx
lea    0x2(,%r13,4),%esi
xor    %eax,%eax
movabs $0x3ff0000000000000,%rdi
mov    %r13d,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ebp,%rbp
mov    %rdi,(%r9,%rbp,8)
movslq %edx,%rdx
mov    %rdi,(%r9,%rdx,8)
add    $0x2,%rax
add    %esi,%edx
add    %esi,%ebp
cmp    %rax,%rcx
jne    18a0 <invert_matrix+0x770>
mov    0x28(%rsp),%rsi
test   $0x1,%r12b
je     1216 <invert_matrix+0xe6>
mov    %ebx,%ecx
imul   %eax,%ecx
add    %r13d,%eax
add    %ecx,%eax
cltq
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r9,%rax,8)
test   %r13d,%r13d
jg     121f <invert_matrix+0xef>
xor    %r14d,%r14d
xor    %ebp,%ebp
cmp    %r13d,%r14d
setne  %bpl
add    %ebp,%ebp
cmp    %r13d,%r14d
jne    1951 <invert_matrix+0x821>
test   %r13d,%r13d
jle    1951 <invert_matrix+0x821>
shl    $0x3,%r13d
lea    (%r9,%r12,8),%rbx
shl    $0x3,%r15
lea    0x0(,%r12,8),%r14
mov    0x110(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13d,%edx
call   1050 <memcpy@plt>
add    %r15,%rbx
add    %r14,%rbp
add    $0xffffffffffffffff,%r12
jne    1930 <invert_matrix+0x800>
xor    %ebp,%ebp
mov    0x50(%rsp),%r9
mov    %r9,%rdi
call   1030 <free_matrix@plt>
mov    %ebp,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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