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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ inverseOfMatrix(double **, double **, int);
void shiftedInverseMatrix(double arr[][20], double shifted[][20], int size) {
  int i = 0;
  int j = 0;
  int m = 0;
  int n = 0;
  double arr1[10][20];
  double inverse[20][20];
  if (size == 2) {
    for (i = 0; i < size; i++) {
      for (j = 0; j < size; j++)
        shifted[i][j] = 1 / arr[i][j];
    }
  } else {
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    inverseOfMatrix(arr1, inverse, size / 2);
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        shifted[i][j] = inverse[m][n];
        n++;
      }
      m++;
    }
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    inverseOfMatrix(arr1, inverse, size / 2);
    m = 0;
    for (i = 0; i < size / 2; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        shifted[i][j] = inverse[m][n];
        n++;
      }
      m++;
    }
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    inverseOfMatrix(arr1, inverse, size / 2);
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = 0; j < size / 2; j++) {
        shifted[i][j] = inverse[m][n];
        n++;
      }
      m++;
    }
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        arr1[m][n] = arr[i][j];
        n++;
      }
      m++;
    }
    inverseOfMatrix(arr1, inverse, size / 2);
    m = 0;
    for (i = size / 2; i < size; i++) {
      n = 0;
      for (j = size / 2; j < size; j++) {
        shifted[i][j] = inverse[m][n];
        n++;
      }
      m++;
    }
  }
}


x86 assembly (clang, -O0):
<shiftedInverseMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1310,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x14(%rbp)
jne    11d6 <shiftedInverseMatrix+0xc6>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d1 <shiftedInverseMatrix+0xc1>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11be <shiftedInverseMatrix+0xae>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  0xe70(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1166 <shiftedInverseMatrix+0x56>
jmp    11c3 <shiftedInverseMatrix+0xb3>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1153 <shiftedInverseMatrix+0x43>
jmp    182b <shiftedInverseMatrix+0x71b>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x12f4(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x12f4(%rbp),%eax
cmp    %ecx,%eax
jge    12a1 <shiftedInverseMatrix+0x191>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x12f8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x12f8(%rbp),%eax
cmp    %ecx,%eax
jge    128a <shiftedInverseMatrix+0x17a>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1216 <shiftedInverseMatrix+0x106>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11e4 <shiftedInverseMatrix+0xd4>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <inverseOfMatrix@plt>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x12fc(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x12fc(%rbp),%eax
cmp    %ecx,%eax
jge    138c <shiftedInverseMatrix+0x27c>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x1300(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1300(%rbp),%eax
cmp    %ecx,%eax
jge    1375 <shiftedInverseMatrix+0x265>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1301 <shiftedInverseMatrix+0x1f1>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12cf <shiftedInverseMatrix+0x1bf>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1304(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1304(%rbp),%eax
cmp    %ecx,%eax
jge    1446 <shiftedInverseMatrix+0x336>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    142f <shiftedInverseMatrix+0x31f>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13d3 <shiftedInverseMatrix+0x2c3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    139a <shiftedInverseMatrix+0x28a>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <inverseOfMatrix@plt>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1308(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1308(%rbp),%eax
cmp    %ecx,%eax
jge    1520 <shiftedInverseMatrix+0x410>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1509 <shiftedInverseMatrix+0x3f9>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14ad <shiftedInverseMatrix+0x39d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1474 <shiftedInverseMatrix+0x364>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15da <shiftedInverseMatrix+0x4ca>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x130c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x130c(%rbp),%eax
cmp    %ecx,%eax
jge    15c3 <shiftedInverseMatrix+0x4b3>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    154f <shiftedInverseMatrix+0x43f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1535 <shiftedInverseMatrix+0x425>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <inverseOfMatrix@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16b4 <shiftedInverseMatrix+0x5a4>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x1310(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1310(%rbp),%eax
cmp    %ecx,%eax
jge    169d <shiftedInverseMatrix+0x58d>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1629 <shiftedInverseMatrix+0x519>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    160f <shiftedInverseMatrix+0x4ff>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    175d <shiftedInverseMatrix+0x64d>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1746 <shiftedInverseMatrix+0x636>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x670(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16ea <shiftedInverseMatrix+0x5da>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    16c9 <shiftedInverseMatrix+0x5b9>
lea    -0x670(%rbp),%rdi
lea    -0x12f0(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1030 <inverseOfMatrix@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1826 <shiftedInverseMatrix+0x716>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    180f <shiftedInverseMatrix+0x6ff>
movslq -0x20(%rbp),%rcx
lea    -0x12f0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17b3 <shiftedInverseMatrix+0x6a3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1792 <shiftedInverseMatrix+0x682>
jmp    182b <shiftedInverseMatrix+0x71b>
add    $0x1310,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shiftedInverseMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1318,%rsp
cmp    $0x2,%edx
jne    1181 <shiftedInverseMatrix+0x61>
movsd  0xec2(%rip),%xmm0
movapd %xmm0,%xmm1
divsd  (%rdi),%xmm1
movsd  %xmm1,(%rsi)
movapd %xmm0,%xmm1
divsd  0x8(%rdi),%xmm1
movsd  %xmm1,0x8(%rsi)
movapd %xmm0,%xmm1
divsd  0xa0(%rdi),%xmm1
movsd  %xmm1,0xa0(%rsi)
divsd  0xa8(%rdi),%xmm0
movsd  %xmm0,0xa8(%rsi)
jmp    16c2 <shiftedInverseMatrix+0x5a2>
mov    %edx,%r12d
mov    %rdi,0x28(%rsp)
mov    %edx,%ebp
shr    $0x1f,%ebp
add    %edx,%ebp
sar    %ebp
cmp    $0x1,%edx
mov    %rsi,0x30(%rsp)
mov    %rbp,0x18(%rsp)
jle    1224 <shiftedInverseMatrix+0x104>
lea    -0x1(%rbp),%ecx
lea    0x8(,%rcx,8),%r15
mov    %ebp,%r14d
mov    %r14,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x20(%rsp)
mov    %r14,0x10(%rsp)
mov    %rcx,0x8(%rsp)
je     123d <shiftedInverseMatrix+0x11d>
and    $0xfffffffe,%r14d
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    0x28(%rsp),%r13
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%r13,1),%rsi
lea    (%rsp,%rbx,1),%rdi
add    $0x50,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
lea    (%rbx,%r13,1),%rsi
add    $0xa0,%rsi
lea    (%rsp,%rbx,1),%rdi
add    $0xf0,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%rbx
cmp    %rbp,%r14
jne    11e0 <shiftedInverseMatrix+0xc0>
jmp    123f <shiftedInverseMatrix+0x11f>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
jmp    13f3 <shiftedInverseMatrix+0x2d3>
xor    %ebp,%ebp
mov    0x10(%rsp),%r14
test   $0x1,%r14b
je     1272 <shiftedInverseMatrix+0x152>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    0x18(%rsp),%rbp
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
cmp    $0x2,%r12d
jl     13f3 <shiftedInverseMatrix+0x2d3>
mov    0x8(%rsp),%rax
lea    0x8(,%rax,8),%r15
cmpq   $0x0,0x20(%rsp)
je     1307 <shiftedInverseMatrix+0x1e7>
and    $0xfffffffe,%r14d
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    0x30(%rsp),%r13
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rsi
add    $0x690,%rsi
lea    (%rbx,%r13,1),%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
lea    (%rsp,%rbx,1),%rsi
add    $0x730,%rsi
lea    (%rbx,%r13,1),%rdi
add    $0xa0,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%rbx
cmp    %rbp,%r14
jne    12c0 <shiftedInverseMatrix+0x1a0>
jmp    130e <shiftedInverseMatrix+0x1ee>
xor    %ebp,%ebp
mov    0x30(%rsp),%r13
mov    0x10(%rsp),%rbx
test   $0x1,%bl
je     133d <shiftedInverseMatrix+0x21d>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rdi
add    %rbp,%rdi
lea    (%rsp,%rdi,1),%rsi
add    $0x690,%rsi
add    %r13,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
cmp    $0x2,%r12d
mov    0x18(%rsp),%rbp
jl     13f3 <shiftedInverseMatrix+0x2d3>
movslq %ebp,%rcx
not    %ebp
add    %r12d,%ebp
lea    0x8(,%rbp,8),%rax
mov    %rax,0x8(%rsp)
cmpq   $0x0,0x20(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rbp,0x40(%rsp)
je     17b7 <shiftedInverseMatrix+0x697>
mov    %ebx,%r15d
and    $0xfffffffe,%r15d
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rbp
mov    $0xa0,%r14d
xor    %ebx,%ebx
mov    0x18(%rsp),%r13
jmp    13b4 <shiftedInverseMatrix+0x294>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x140,%r14
cmp    %rbx,%r15
je     17b9 <shiftedInverseMatrix+0x699>
cmp    %r12d,%r13d
jge    13d6 <shiftedInverseMatrix+0x2b6>
lea    (%r14,%rbp,1),%rsi
add    $0xffffffffffffff60,%rsi
lea    (%rsp,%r14,1),%rdi
add    $0xffffffffffffffb0,%rdi
mov    0x8(%rsp),%rdx
call   1040 <memcpy@plt>
cmp    %r12d,%r13d
jge    13a0 <shiftedInverseMatrix+0x280>
lea    (%r14,%rbp,1),%rsi
lea    (%rsp,%r14,1),%rdi
add    $0x50,%rdi
mov    0x8(%rsp),%rdx
call   1040 <memcpy@plt>
jmp    13a0 <shiftedInverseMatrix+0x280>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
cmp    %r12d,%ebp
jge    169a <shiftedInverseMatrix+0x57a>
movslq %ebp,%rax
lea    -0x1(%rbp),%ecx
mov    %rcx,0x20(%rsp)
lea    0x8(,%rcx,8),%rbx
mov    %r12d,%r13d
sub    %ebp,%r13d
cmp    $0x1,%r13d
mov    %r13,0x10(%rsp)
mov    %rax,0x8(%rsp)
jne    16d4 <shiftedInverseMatrix+0x5b4>
xor    %r14d,%r14d
mov    0x10(%rsp),%r13
test   $0x1,%r13b
je     147e <shiftedInverseMatrix+0x35e>
cmp    $0x2,%r12d
jl     147e <shiftedInverseMatrix+0x35e>
mov    0x8(%rsp),%rax
add    %r14,%rax
lea    (%rax,%rax,4),%rsi
shl    $0x5,%rsi
add    0x28(%rsp),%rsi
lea    (%r14,%r14,4),%rax
shl    $0x5,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    0x18(%rsp),%rbp
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
cmp    %r12d,%ebp
mov    0x30(%rsp),%rax
jge    16ae <shiftedInverseMatrix+0x58e>
mov    0x20(%rsp),%rcx
lea    0x8(,%rcx,8),%r14
cmp    $0x1,%r13d
jne    1741 <shiftedInverseMatrix+0x621>
xor    %ebx,%ebx
mov    0x10(%rsp),%r15
test   $0x1,%r15b
mov    0x30(%rsp),%rcx
je     14ff <shiftedInverseMatrix+0x3df>
cmp    $0x2,%r12d
jl     14ff <shiftedInverseMatrix+0x3df>
lea    (%rbx,%rbx,4),%rax
shl    $0x5,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x690,%rsi
add    0x8(%rsp),%rbx
lea    (%rbx,%rbx,4),%rdi
shl    $0x5,%rdi
add    %rcx,%rdi
mov    %r14,%rdx
call   1040 <memcpy@plt>
mov    0x18(%rsp),%rbp
cmp    %r12d,%ebp
jge    16ae <shiftedInverseMatrix+0x58e>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,4),%rax
lea    (%rcx,%rax,4),%rcx
not    %ebp
mov    %r12d,0x38(%rsp)
add    %r12d,%ebp
lea    0x8(,%rbp,8),%r12
mov    %r15,%rax
add    $0xffffffffffffffff,%rax
mov    %rcx,0x20(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rax,0x48(%rsp)
je     18a9 <shiftedInverseMatrix+0x789>
and    $0xfffffffe,%r15d
mov    %r15,0x8(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%r15
mov    $0xa0,%r13d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%r13,1),%rbx
lea    (%r15,%r13,1),%rsi
add    $0xffffffffffffff60,%rsi
lea    (%rsp,%r13,1),%r14
add    $0x50,%r14
lea    (%rsp,%r13,1),%rdi
add    $0xffffffffffffffb0,%rdi
mov    %r12,%rdx
call   1040 <memcpy@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%r13
cmp    %rbp,0x8(%rsp)
jne    1570 <shiftedInverseMatrix+0x450>
testb  $0x1,0x10(%rsp)
je     15ee <shiftedInverseMatrix+0x4ce>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
mov    0x28(%rsp),%rcx
add    %rax,%rcx
mov    0x20(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    %r12,%rdx
call   1040 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    0x18(%rsp),%rbx
mov    %ebx,%edx
call   1030 <inverseOfMatrix@plt>
cmp    0x38(%rsp),%ebx
mov    0x30(%rsp),%r13
jge    16c2 <shiftedInverseMatrix+0x5a2>
mov    0x40(%rsp),%rax
lea    0x8(,%rax,8),%r15
cmpq   $0x0,0x48(%rsp)
je     18bb <shiftedInverseMatrix+0x79b>
mov    0x10(%rsp),%r14
and    $0xfffffffe,%r14d
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%r12
add    %r13,%r12
xor    %ebx,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rsi
add    $0x690,%rsi
lea    (%r12,%rbx,1),%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
lea    (%rsp,%rbx,1),%rsi
add    $0x730,%rsi
lea    (%r12,%rbx,1),%rdi
add    $0xa0,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
add    $0x2,%rbp
add    $0x140,%rbx
cmp    %rbp,%r14
jne    1650 <shiftedInverseMatrix+0x530>
jmp    18bd <shiftedInverseMatrix+0x79d>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
add    $0x1318,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffe,%r13d
lea    (%rax,%rax,4),%r15
shl    $0x5,%r15
add    0x28(%rsp),%r15
mov    $0xa0,%ebp
xor    %r14d,%r14d
jmp    1704 <shiftedInverseMatrix+0x5e4>
nop
add    $0x2,%r14
add    $0x140,%rbp
cmp    %r14,%r13
je     1440 <shiftedInverseMatrix+0x320>
cmp    $0x2,%r12d
jl     1725 <shiftedInverseMatrix+0x605>
lea    (%r15,%rbp,1),%rsi
add    $0xffffffffffffff60,%rsi
lea    (%rsp,%rbp,1),%rdi
add    $0xffffffffffffffb0,%rdi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
cmp    $0x2,%r12d
jl     16f0 <shiftedInverseMatrix+0x5d0>
lea    (%r15,%rbp,1),%rsi
lea    (%rsp,%rbp,1),%rdi
add    $0x50,%rdi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
jmp    16f0 <shiftedInverseMatrix+0x5d0>
and    $0xfffffffe,%r13d
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,4),%r15
shl    $0x5,%r15
add    %rax,%r15
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    1774 <shiftedInverseMatrix+0x654>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x140,%rbp
cmp    %rbx,%r13
je     14be <shiftedInverseMatrix+0x39e>
cmp    $0x2,%r12d
jl     1791 <shiftedInverseMatrix+0x671>
lea    (%rsp,%rbp,1),%rsi
add    $0x690,%rsi
lea    (%r15,%rbp,1),%rdi
mov    %r14,%rdx
call   1040 <memcpy@plt>
cmp    $0x2,%r12d
jl     1760 <shiftedInverseMatrix+0x640>
lea    (%rsp,%rbp,1),%rsi
add    $0x730,%rsi
lea    (%r15,%rbp,1),%rdi
add    $0xa0,%rdi
mov    %r14,%rdx
call   1040 <memcpy@plt>
jmp    1760 <shiftedInverseMatrix+0x640>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
test   $0x1,%r14b
mov    0x18(%rsp),%rbp
je     17f9 <shiftedInverseMatrix+0x6d9>
cmp    %r12d,%ebp
jge    17f9 <shiftedInverseMatrix+0x6d9>
shl    $0x5,%rbx
lea    (%rbx,%rbx,4),%rax
mov    0x28(%rsp),%rcx
add    %rax,%rcx
mov    0x38(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
lea    (%rsp,%rax,1),%rdi
add    $0x50,%rdi
mov    0x8(%rsp),%rdx
call   1040 <memcpy@plt>
lea    0x50(%rsp),%rdi
lea    0x690(%rsp),%rsi
mov    %ebp,%edx
call   1030 <inverseOfMatrix@plt>
cmp    $0x2,%r12d
jl     1407 <shiftedInverseMatrix+0x2e7>
mov    0x40(%rsp),%rax
lea    0x8(,%rax,8),%r13
cmpq   $0x0,0x20(%rsp)
je     1902 <shiftedInverseMatrix+0x7e2>
and    $0xfffffffe,%r14d
mov    0x30(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rax,%rcx,8),%r15
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    1864 <shiftedInverseMatrix+0x744>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x140,%rbp
cmp    %rbx,%r14
je     1904 <shiftedInverseMatrix+0x7e4>
cmp    %r12d,0x18(%rsp)
jge    1882 <shiftedInverseMatrix+0x762>
lea    (%rsp,%rbp,1),%rsi
add    $0x690,%rsi
lea    (%r15,%rbp,1),%rdi
mov    %r13,%rdx
call   1040 <memcpy@plt>
cmp    %r12d,0x18(%rsp)
jge    1850 <shiftedInverseMatrix+0x730>
lea    (%rsp,%rbp,1),%rsi
add    $0x730,%rsi
lea    (%r15,%rbp,1),%rdi
add    $0xa0,%rdi
mov    %r13,%rdx
call   1040 <memcpy@plt>
jmp    1850 <shiftedInverseMatrix+0x730>
xor    %ebp,%ebp
testb  $0x1,0x10(%rsp)
jne    15be <shiftedInverseMatrix+0x49e>
jmp    15ee <shiftedInverseMatrix+0x4ce>
xor    %ebp,%ebp
testb  $0x1,0x10(%rsp)
je     16c2 <shiftedInverseMatrix+0x5a2>
shl    $0x5,%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x690,%rsi
add    %rax,%r13
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
mov    %r15,%rdx
call   1040 <memcpy@plt>
jmp    16c2 <shiftedInverseMatrix+0x5a2>
xor    %ebx,%ebx
testb  $0x1,0x10(%rsp)
mov    0x18(%rsp),%rbp
je     1407 <shiftedInverseMatrix+0x2e7>
cmp    %r12d,%ebp
jge    1407 <shiftedInverseMatrix+0x2e7>
shl    $0x5,%rbx
lea    (%rbx,%rbx,4),%rax
lea    (%rsp,%rax,1),%rsi
add    $0x690,%rsi
add    0x30(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rax,%rcx,8),%rdi
mov    %r13,%rdx
call   1040 <memcpy@plt>
jmp    1407 <shiftedInverseMatrix+0x2e7>

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

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