#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*/ free(int *);
unsigned char inv(unsigned char);
scalar_t__ malloc(int);
unsigned char mul(unsigned char, unsigned char);
int /*<<< orphan*/ printf(char *);
int matrixinv(unsigned char a[], int n) {
  int *is, *js, i, j, k, l, u, v;
  unsigned char d, p;
  is = (int *)malloc(n * sizeof(int));
  js = (int *)malloc(n * sizeof(int));
  for (k = 0; k <= n - 1; k++) {
    d = 0;
    for (i = k; i <= n - 1; i++) {
      for (j = k; j <= n - 1; j++) {
        l = i * n + j;
        p = (a[l]);
        if (p > d) {
          d = p;
          is[k] = i;
          js[k] = j;
        }
      }
    }
    if (d == 0) {
      free(is);
      free(js);
      printf("err**not inv\n");
      return (0);
    }
    if (is[k] != k) {
      for (j = 0; j <= n - 1; j++) {
        u = k * n + j;
        v = is[k] * n + j;
        p = a[u];
        a[u] = a[v];
        a[v] = p;
      }
    }
    if (js[k] != k) {
      for (i = 0; i <= n - 1; i++) {
        u = i * n + k;
        v = i * n + js[k];
        p = a[u];
        a[u] = a[v];
        a[v] = p;
      }
    }
    l = k * n + k;
    a[l] = inv(a[l]);
    for (j = 0; j <= n - 1; j++) {
      if (j != k) {
        u = k * n + j;
        a[u] = mul(a[u], a[l]);
      }
    }
    for (i = 0; i <= n - 1; i++) {
      if (i != k) {
        for (j = 0; j <= n - 1; j++) {
          if (j != k) {
            u = i * n + j;
            a[u] = a[u] ^ (mul(a[i * n + k], a[k * n + j]));
          }
        }
      }
    }
    for (i = 0; i <= n - 1; i++) {
      if (i != k) {
        u = i * n + k;
        a[u] = mul(a[u], a[l]);
      }
    }
  }
  for (k = n - 1; k >= 0; k--) {
    if (js[k] != k) {
      for (j = 0; j <= n - 1; j++) {
        u = k * n + j;
        v = js[k] * n + j;
        p = a[u];
        a[u] = a[v];
        a[v] = p;
      }
    }
    if (is[k] != k) {
      for (i = 0; i <= n - 1; i++) {
        u = i * n + k;
        v = i * n + is[k];
        p = a[u];
        a[u] = a[v];
        a[v] = p;
      }
    }
  }
  free(is);
  free(js);
  return (1);
}


x86 assembly (clang, -O0):
<matrixinv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1594 <matrixinv+0x444>
movb   $0x0,-0x41(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1242 <matrixinv+0xf2>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     122f <matrixinv+0xdf>
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x42(%rbp)
movzbl -0x42(%rbp),%eax
movzbl -0x41(%rbp),%ecx
cmp    %ecx,%eax
jle    121c <matrixinv+0xcc>
mov    -0x42(%rbp),%al
mov    %al,-0x41(%rbp)
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1221 <matrixinv+0xd1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11be <matrixinv+0x6e>
jmp    1234 <matrixinv+0xe4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a7 <matrixinv+0x57>
movzbl -0x41(%rbp),%eax
cmp    $0x0,%eax
jne    1279 <matrixinv+0x129>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
lea    0xd98(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    16f9 <matrixinv+0x5a9>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
je     130c <matrixinv+0x1bc>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1307 <matrixinv+0x1b7>
mov    -0x34(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x42(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x42(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1294 <matrixinv+0x144>
jmp    130c <matrixinv+0x1bc>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
je     139f <matrixinv+0x24f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     139a <matrixinv+0x24a>
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x42(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x42(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1327 <matrixinv+0x1d7>
jmp    139f <matrixinv+0x24f>
mov    -0x34(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1050 <inv@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     143a <matrixinv+0x2ea>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     1427 <matrixinv+0x2d7>
mov    -0x34(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1070 <mul@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    142c <matrixinv+0x2dc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13d1 <matrixinv+0x281>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1511 <matrixinv+0x3c1>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     14fe <matrixinv+0x3ae>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     14f9 <matrixinv+0x3a9>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     14e6 <matrixinv+0x396>
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1070 <mul@plt>
mov    %al,%cl
mov    -0x48(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    14eb <matrixinv+0x39b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1465 <matrixinv+0x315>
jmp    14fe <matrixinv+0x3ae>
jmp    1503 <matrixinv+0x3b3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1441 <matrixinv+0x2f1>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1581 <matrixinv+0x431>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     156e <matrixinv+0x41e>
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1070 <mul@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1573 <matrixinv+0x423>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1518 <matrixinv+0x3c8>
jmp    1586 <matrixinv+0x436>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118c <matrixinv+0x3c>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     16e0 <matrixinv+0x590>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
je     163a <matrixinv+0x4ea>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1635 <matrixinv+0x4e5>
mov    -0x34(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x14(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x42(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x42(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15c2 <matrixinv+0x472>
jmp    163a <matrixinv+0x4ea>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
je     16cd <matrixinv+0x57d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     16c8 <matrixinv+0x578>
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x42(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x42(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1655 <matrixinv+0x505>
jmp    16cd <matrixinv+0x57d>
jmp    16d2 <matrixinv+0x582>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    159d <matrixinv+0x44d>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrixinv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %esi,%ebx
mov    %rdi,0x8(%rsp)
lea    0x0(,%rbx,4),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r12
mov    %rbx,0x10(%rsp)
test   %ebx,%ebx
jle    1815 <matrixinv+0x6c5>
mov    0x10(%rsp),%r8d
lea    -0x1(%r8),%rcx
lea    -0x2(%r8),%rax
mov    %rax,0x30(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
mov    %rcx,%r14
and    $0xfffffffffffffffe,%r14
lea    0x1(%r8),%rax
mov    %rax,0x80(%rsp)
lea    (%r8,%r8,1),%rax
mov    %rax,0x38(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r8,2),%rcx
mov    %rcx,0x78(%rsp)
lea    (%rax,%r8,1),%rcx
mov    %rcx,0x70(%rsp)
mov    %r14,%r15
neg    %r15
mov    $0x2,%ecx
xor    %r13d,%r13d
mov    %rax,0x40(%rsp)
mov    %r12,0x88(%rsp)
mov    %r8,0x18(%rsp)
mov    %r14,0x50(%rsp)
mov    %r15,0x48(%rsp)
jmp    123a <matrixinv+0xea>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    0x90(%rsp),%rax
add    0x80(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %r8,%rcx
add    %r8,0x40(%rsp)
cmp    %r8,%r13
je     15d2 <matrixinv+0x482>
mov    %rcx,0x60(%rsp)
xor    %ecx,%ecx
mov    %rax,0x90(%rsp)
mov    %r13,%rdx
mov    0x28(%rsp),%rdi
jmp    126c <matrixinv+0x11c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    %r8,%rax
cmp    %r8,%rdx
je     12a0 <matrixinv+0x150>
mov    %rax,%rsi
mov    %r13,%rbp
jmp    128d <matrixinv+0x13d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x1,%rsi
cmp    %rbp,%r8
je     1260 <matrixinv+0x110>
movzbl (%rsi),%ebx
cmp    %cl,%bl
jbe    1280 <matrixinv+0x130>
mov    %edx,(%rdi,%r13,4)
mov    %ebp,(%r12,%r13,4)
mov    %ebx,%ecx
jmp    1280 <matrixinv+0x130>
test   %cl,%cl
je     15b2 <matrixinv+0x462>
mov    (%rdi,%r13,4),%ecx
movslq 0x10(%rsp),%r9
cmp    %rcx,%r13
je     1390 <matrixinv+0x240>
mov    %r13,%r10
imul   %r8,%r10
mov    0x10(%rsp),%rsi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    0x8(%rsp),%rax
mov    (%rax,%r10,1),%dl
mov    (%rax,%rcx,1),%bl
mov    %bl,(%rax,%r10,1)
mov    %dl,(%rax,%rcx,1)
cmp    $0x1,%esi
je     1390 <matrixinv+0x240>
cmpq   $0x0,0x30(%rsp)
je     1588 <matrixinv+0x438>
mov    $0xffffffffffffffff,%rcx
mov    0x8(%rsp),%rdx
mov    0x60(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%rdi,%r13,4),%rsi
imul   %r9,%rsi
movzbl -0x1(%rdx,%rbp,1),%ebx
movzbl 0x1(%rdx,%rsi,1),%eax
mov    %al,-0x1(%rdx,%rbp,1)
mov    %bl,0x1(%rdx,%rsi,1)
movslq (%rdi,%r13,4),%rax
imul   %r9,%rax
movzbl (%rdx,%rbp,1),%esi
movzbl 0x2(%rdx,%rax,1),%ebx
mov    %bl,(%rdx,%rbp,1)
mov    %sil,0x2(%rdx,%rax,1)
add    $0x2,%rdx
lea    (%r14,%rcx,1),%rax
add    $0xfffffffffffffffe,%rax
add    $0xfffffffffffffffe,%rcx
cmp    $0xffffffffffffffff,%rax
jne    1310 <matrixinv+0x1c0>
neg    %rcx
testb  $0x1,0x20(%rsp)
je     1390 <matrixinv+0x240>
movslq (%rdi,%r13,4),%rax
add    %rcx,%r10
imul   %r9,%rax
add    %rcx,%rax
mov    0x8(%rsp),%rsi
mov    (%rsi,%r10,1),%cl
mov    (%rsi,%rax,1),%dl
mov    %dl,(%rsi,%r10,1)
mov    %cl,(%rsi,%rax,1)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%r13,4),%eax
cmp    %rax,%r13
mov    0x38(%rsp),%rbp
je     1450 <matrixinv+0x300>
cltq
mov    0x8(%rsp),%rsi
mov    (%rsi,%r13,1),%cl
mov    (%rsi,%rax,1),%dl
mov    %dl,(%rsi,%r13,1)
mov    %cl,(%rsi,%rax,1)
cmpl   $0x1,0x10(%rsp)
je     1450 <matrixinv+0x300>
cmpq   $0x0,0x30(%rsp)
je     159d <matrixinv+0x44d>
mov    $0x1,%eax
mov    0x70(%rsp),%rcx
mov    0x78(%rsp),%rdx
nopl   (%rax)
movslq (%r12,%r13,4),%rsi
movzbl (%rcx,%r13,1),%edi
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%rcx,%r13,1)
mov    %dil,(%rcx,%rsi,1)
movslq (%r12,%r13,4),%rsi
movzbl (%rdx,%r13,1),%edi
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,(%rdx,%r13,1)
mov    %dil,(%rdx,%rsi,1)
add    %rbp,%rdx
add    %rbp,%rcx
lea    (%r15,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
jne    13e0 <matrixinv+0x290>
testb  $0x1,0x20(%rsp)
je     1450 <matrixinv+0x300>
movslq (%r12,%r13,4),%rcx
imul   %r8,%rax
lea    (%rax,%r13,1),%rdx
add    %rcx,%rax
mov    0x8(%rsp),%rsi
mov    (%rsi,%rdx,1),%cl
mov    (%rsi,%rax,1),%bl
mov    %bl,(%rsi,%rdx,1)
mov    %cl,(%rsi,%rax,1)
nopl   0x0(%rax)
mov    %r9,0x58(%rsp)
mov    %r13,%rbp
imul   %r8,%rbp
add    %r13,%rbp
mov    0x8(%rsp),%rbx
movzbl (%rbx,%rbp,1),%edi
call   1050 <inv@plt>
mov    0x18(%rsp),%r8
mov    %rbp,0x68(%rsp)
mov    %al,(%rbx,%rbp,1)
xor    %ebx,%ebx
jmp    1489 <matrixinv+0x339>
xchg   %ax,%ax
add    $0x1,%rbx
cmp    %rbx,%r8
je     14c0 <matrixinv+0x370>
cmp    %rbx,%r13
je     1480 <matrixinv+0x330>
mov    0x40(%rsp),%rbp
movzbl 0x0(%rbp,%rbx,1),%edi
mov    0x8(%rsp),%rax
mov    0x68(%rsp),%rcx
movzbl (%rax,%rcx,1),%esi
call   1070 <mul@plt>
mov    0x18(%rsp),%r8
mov    %al,0x0(%rbp,%rbx,1)
jmp    1480 <matrixinv+0x330>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%r14
xor    %r12d,%r12d
jmp    14dc <matrixinv+0x38c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    %r8,%r14
cmp    %r8,%r12
je     1530 <matrixinv+0x3e0>
cmp    %r13,%r12
je     14d0 <matrixinv+0x380>
mov    %r12,%r15
imul   %r8,%r15
add    %r13,%r15
xor    %ebx,%ebx
jmp    14f9 <matrixinv+0x3a9>
nop
add    $0x1,%rbx
cmp    %rbx,%r8
je     14d0 <matrixinv+0x380>
cmp    %rbx,%r13
je     14f0 <matrixinv+0x3a0>
movzbl (%r14,%rbx,1),%ebp
mov    0x8(%rsp),%rax
movzbl (%rax,%r15,1),%edi
mov    0x40(%rsp),%rax
movzbl (%rax,%rbx,1),%esi
call   1070 <mul@plt>
mov    0x18(%rsp),%r8
xor    %bpl,%al
mov    %al,(%r14,%rbx,1)
jmp    14f0 <matrixinv+0x3a0>
nopl   0x0(%rax)
mov    0x8(%rsp),%rbx
xor    %ebp,%ebp
mov    0x88(%rsp),%r12
mov    0x50(%rsp),%r14
mov    0x48(%rsp),%r15
jmp    1560 <matrixinv+0x410>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    %r8,%rbx
cmp    %rbp,%r8
je     1210 <matrixinv+0xc0>
cmp    %rbp,%r13
je     1550 <matrixinv+0x400>
movzbl (%rbx,%r13,1),%edi
mov    0x8(%rsp),%rax
mov    0x68(%rsp),%rcx
movzbl (%rax,%rcx,1),%esi
call   1070 <mul@plt>
mov    0x18(%rsp),%r8
mov    %al,(%rbx,%r13,1)
jmp    1550 <matrixinv+0x400>
mov    $0x1,%ecx
testb  $0x1,0x20(%rsp)
jne    1363 <matrixinv+0x213>
jmp    1390 <matrixinv+0x240>
mov    $0x1,%eax
testb  $0x1,0x20(%rsp)
jne    1429 <matrixinv+0x2d9>
jmp    1450 <matrixinv+0x300>
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
lea    0xa3a(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
jmp    182c <matrixinv+0x6dc>
cmpl   $0x0,0x10(%rsp)
mov    0x38(%rsp),%rbp
jle    1815 <matrixinv+0x6c5>
mov    0x20(%rsp),%r14
imul   %r8,%r14
add    $0x2,%r14
lea    (%r8,%r8,2),%r10
add    $0xffffffffffffffff,%r10
lea    (%r8,%r8,1),%r11
add    $0xffffffffffffffff,%r11
jmp    1625 <matrixinv+0x4d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
sub    %r9,%r14
add    $0xffffffffffffffff,%r10
add    $0xffffffffffffffff,%r11
cmp    $0x1,%r15
jle    1815 <matrixinv+0x6c5>
mov    %r8,%r15
add    $0xffffffffffffffff,%r8
mov    -0x4(%r12,%r15,4),%ecx
cmp    %rcx,%r8
je     1710 <matrixinv+0x5c0>
mov    %r8,%r9
imul   0x18(%rsp),%r9
mov    0x10(%rsp),%rdx
imul   %edx,%ecx
movslq %ecx,%rcx
mov    0x8(%rsp),%rax
mov    (%rax,%r9,1),%dil
mov    (%rax,%rcx,1),%bl
mov    %bl,(%rax,%r9,1)
mov    %dil,(%rax,%rcx,1)
cmp    $0x1,%edx
je     1710 <matrixinv+0x5c0>
cmpq   $0x0,0x30(%rsp)
je     17b7 <matrixinv+0x667>
mov    $0xffffffffffffffff,%rdi
mov    0x8(%rsp),%rcx
mov    0x50(%rsp),%r13
mov    0x58(%rsp),%rsi
nopl   (%rax)
movslq (%r12,%r8,4),%rbp
imul   %rsi,%rbp
movzbl -0x1(%rcx,%r14,1),%ebx
movzbl 0x1(%rcx,%rbp,1),%edx
mov    %dl,-0x1(%rcx,%r14,1)
mov    %bl,0x1(%rcx,%rbp,1)
movslq (%r12,%r8,4),%rdx
imul   %rsi,%rdx
movzbl (%rcx,%r14,1),%ebx
movzbl 0x2(%rcx,%rdx,1),%eax
mov    %al,(%rcx,%r14,1)
mov    %bl,0x2(%rcx,%rdx,1)
add    $0x2,%rcx
lea    (%rdi,%r13,1),%rax
add    $0xfffffffffffffffe,%rax
add    $0xfffffffffffffffe,%rdi
cmp    $0xffffffffffffffff,%rax
jne    1690 <matrixinv+0x540>
neg    %rdi
mov    0x38(%rsp),%rbp
testb  $0x1,0x20(%rsp)
je     1710 <matrixinv+0x5c0>
movslq (%r12,%r8,4),%rax
add    %rdi,%r9
imul   0x58(%rsp),%rax
add    %rdi,%rax
mov    0x8(%rsp),%rdi
mov    (%rdi,%r9,1),%cl
mov    (%rdi,%rax,1),%dl
mov    %dl,(%rdi,%r9,1)
mov    %cl,(%rdi,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rax
mov    (%rax,%r8,4),%ecx
cmp    %rcx,%r8
mov    0x18(%rsp),%r9
je     1610 <matrixinv+0x4c0>
movslq %ecx,%rax
mov    0x8(%rsp),%rdi
mov    (%rdi,%r8,1),%cl
mov    (%rdi,%rax,1),%dl
mov    %dl,(%rdi,%r8,1)
mov    %cl,(%rdi,%rax,1)
cmp    $0x1,%r9d
je     1610 <matrixinv+0x4c0>
cmpq   $0x0,0x30(%rsp)
je     17cc <matrixinv+0x67c>
mov    $0x1,%edi
mov    0x8(%rsp),%rcx
mov    %rbp,%rsi
mov    0x28(%rsp),%rbp
mov    0x48(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
movslq 0x0(%rbp,%r8,4),%rax
movzbl (%rcx,%r11,1),%edx
add    %r9,%rax
movzbl (%rcx,%rax,1),%ebx
mov    %bl,(%rcx,%r11,1)
mov    %dl,(%rcx,%rax,1)
movslq 0x0(%rbp,%r8,4),%rax
movzbl (%rcx,%r10,1),%edx
add    %rsi,%rax
movzbl (%rcx,%rax,1),%ebx
mov    %bl,(%rcx,%r10,1)
mov    %dl,(%rcx,%rax,1)
add    %rsi,%rcx
lea    (%rdi,%r13,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
jne    1770 <matrixinv+0x620>
jmp    17d4 <matrixinv+0x684>
mov    $0x1,%edi
testb  $0x1,0x20(%rsp)
jne    16eb <matrixinv+0x59b>
jmp    1710 <matrixinv+0x5c0>
mov    $0x1,%edi
mov    %rbp,%rsi
testb  $0x1,0x20(%rsp)
mov    %rsi,%rbp
je     1610 <matrixinv+0x4c0>
mov    0x28(%rsp),%rax
movslq (%rax,%r8,4),%rax
imul   %r9,%rdi
lea    (%rdi,%r8,1),%rcx
add    %rax,%rdi
mov    0x8(%rsp),%rbp
mov    0x0(%rbp,%rcx,1),%al
mov    0x0(%rbp,%rdi,1),%dl
mov    %dl,0x0(%rbp,%rcx,1)
mov    %al,0x0(%rbp,%rdi,1)
mov    0x38(%rsp),%rbp
jmp    1610 <matrixinv+0x4c0>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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