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

/* Forward declarations */

/* Type definitions */
typedef int uint8_t;

/* Variables and functions */
int gf_inv(int);
int gf_mul(int, int);
int gf_invert_matrix(uint8_t *in_mat, uint8_t *out_mat, const int n) {
  int i, j, k;
  uint8_t temp;
  for (i = 0; i < n * n; i++)
    out_mat[i] = 0;
  for (i = 0; i < n; i++)
    out_mat[i * n + i] = 1;
  for (i = 0; i < n; i++) {
    if (in_mat[i * n + i] == 0) {
      for (j = i + 1; j < n; j++)
        if (in_mat[j * n + i])
          break;
      if (j == n)
        return -1;
      for (k = 0; k < n; k++) {
        temp = in_mat[i * n + k];
        in_mat[i * n + k] = in_mat[j * n + k];
        in_mat[j * n + k] = temp;
        temp = out_mat[i * n + k];
        out_mat[i * n + k] = out_mat[j * n + k];
        out_mat[j * n + k] = temp;
      }
    }
    temp = gf_inv(in_mat[i * n + i]);
    for (j = 0; j < n; j++) {
      in_mat[i * n + j] = gf_mul(in_mat[i * n + j], temp);
      out_mat[i * n + j] = gf_mul(out_mat[i * n + j], temp);
    }
    for (j = 0; j < n; j++) {
      if (j == i)
        continue;
      temp = in_mat[j * n + i];
      for (k = 0; k < n; k++) {
        out_mat[j * n + k] ^= gf_mul(temp, out_mat[i * n + k]);
        in_mat[j * n + k] ^= gf_mul(temp, in_mat[i * n + k]);
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<gf_invert_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1169 <gf_invert_matrix+0x49>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113a <gf_invert_matrix+0x1a>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11a2 <gf_invert_matrix+0x82>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1170 <gf_invert_matrix+0x50>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    148f <gf_invert_matrix+0x36f>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1302 <gf_invert_matrix+0x1e2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1218 <gf_invert_matrix+0xf8>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1205 <gf_invert_matrix+0xe5>
jmp    1218 <gf_invert_matrix+0xf8>
jmp    120a <gf_invert_matrix+0xea>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11d9 <gf_invert_matrix+0xb9>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1230 <gf_invert_matrix+0x110>
movl   $0xffffffff,-0x4(%rbp)
jmp    1496 <gf_invert_matrix+0x376>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12fd <gf_invert_matrix+0x1dd>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1237 <gf_invert_matrix+0x117>
jmp    1302 <gf_invert_matrix+0x1e2>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <gf_inv@plt>
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13a3 <gf_invert_matrix+0x283>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x2c(%rbp),%esi
call   1040 <gf_mul@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x2c(%rbp),%esi
call   1040 <gf_mul@plt>
mov    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1325 <gf_invert_matrix+0x205>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    147c <gf_invert_matrix+0x35c>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jne    13c7 <gf_invert_matrix+0x2a7>
jmp    146e <gf_invert_matrix+0x34e>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1469 <gf_invert_matrix+0x349>
mov    -0x2c(%rbp),%edi
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
call   1040 <gf_mul@plt>
mov    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edi
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
call   1040 <gf_mul@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13e5 <gf_invert_matrix+0x2c5>
jmp    146e <gf_invert_matrix+0x34e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13aa <gf_invert_matrix+0x28a>
jmp    1481 <gf_invert_matrix+0x361>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11a9 <gf_invert_matrix+0x89>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gf_invert_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %edx,%ebp
mov    %rsi,%r12
mov    %rdi,0x8(%rsp)
mov    %edx,%eax
imul   %edx,%eax
test   %eax,%eax
je     1164 <gf_invert_matrix+0x34>
mov    %eax,%edx
shl    $0x2,%rdx
mov    %r12,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
test   %ebp,%ebp
jle    171f <gf_invert_matrix+0x5ef>
mov    %ebp,%r10d
lea    -0x1(%r10),%rax
mov    %r10d,%r13d
and    $0x3,%r13d
xor    %ecx,%ecx
cmp    $0x3,%rax
mov    %rbp,0x50(%rsp)
mov    %r10,0x38(%rsp)
jb     1240 <gf_invert_matrix+0x110>
lea    0x0(%rbp,%rbp,1),%edx
lea    0x0(,%rbp,4),%r9d
lea    0x0(%rbp,%rbp,2),%edi
mov    %r10d,%r8d
and    $0xfffffffc,%r8d
neg    %r8
mov    $0x2,%r11d
mov    $0x1,%r14d
mov    $0x3,%r15d
xor    %esi,%esi
mov    %ebp,%eax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %edx,%rdx
cltq
movslq %ecx,%rcx
lea    (%rcx,%rbp,1),%rbx
movl   $0x1,(%r12,%rbx,4)
lea    (%r14,%rax,1),%rbx
movl   $0x1,(%r12,%rbx,4)
lea    (%r11,%rdx,1),%rbx
movslq %edi,%rdi
movl   $0x1,(%r12,%rbx,4)
lea    (%r15,%rdi,1),%rbx
movl   $0x1,(%r12,%rbx,4)
add    $0x4,%rbp
add    %r9d,%ecx
add    $0x4,%r11
add    %r9d,%edx
add    $0x4,%r14
add    %r9d,%eax
add    $0x4,%r15
add    %r9d,%edi
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%r8
jne    11d0 <gf_invert_matrix+0xa0>
neg    %rsi
mov    %rsi,%rcx
mov    0x50(%rsp),%rbp
mov    0x38(%rsp),%r10
test   %r13,%r13
je     126a <gf_invert_matrix+0x13a>
mov    %ebp,%eax
imul   %ecx,%eax
nopw   0x0(%rax,%rax,1)
cltq
lea    (%rcx,%rax,1),%rdx
movl   $0x1,(%r12,%rdx,4)
add    $0x1,%rcx
add    %ebp,%eax
add    $0xffffffffffffffff,%r13
jne    1250 <gf_invert_matrix+0x120>
test   %ebp,%ebp
jle    171f <gf_invert_matrix+0x5ef>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r10,4),%rdx
lea    (%r12,%r10,4),%rax
mov    %r10d,%esi
and    $0xfffffffc,%esi
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x90(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rax,0x98(%rsp)
cmp    %rcx,%rax
seta   %al
mov    %rdx,0xa0(%rsp)
cmp    %r12,%rdx
seta   %dl
and    %al,%dl
mov    %dl,0x7(%rsp)
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x80(%rsp)
mov    %rsi,%rax
mov    %rsi,0x88(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x78(%rsp)
lea    (%rcx,%r10,4),%rax
lea    0x0(,%r10,4),%rdx
mov    %rdx,0x40(%rsp)
lea    0x4(,%r10,4),%rdx
mov    %rdx,0xa8(%rsp)
lea    0x10(%r12),%rdx
lea    0x10(%rcx),%rsi
mov    $0x1,%r9d
xor    %r14d,%r14d
mov    %r12,0x28(%rsp)
mov    %r12,%r13
mov    %rax,%r12
mov    %rcx,0x10(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rdx,0x70(%rsp)
jmp    1382 <gf_invert_matrix+0x252>
nopl   0x0(%rax)
mov    0x48(%rsp),%r14
add    $0x1,%r14
mov    0xb0(%rsp),%r9
add    $0x1,%r9
mov    0x30(%rsp),%r12
add    0xa8(%rsp),%r12
mov    0x40(%rsp),%rax
mov    0x58(%rsp),%rdx
add    %rax,%rdx
mov    0x60(%rsp),%rsi
add    %rax,%rsi
add    %rax,0x10(%rsp)
mov    0x18(%rsp),%r13
add    %rax,%r13
cmp    %r10,%r14
mov    0x50(%rsp),%rbp
je     171f <gf_invert_matrix+0x5ef>
mov    %rdx,0x58(%rsp)
mov    %rsi,0x60(%rsp)
cmp    %r9d,%ebp
mov    %r9d,%edx
cmovg  %ebp,%edx
mov    %r14d,%eax
imul   %ebp,%eax
movslq %eax,%r11
add    %r14,%r11
mov    0x8(%rsp),%rcx
mov    (%rcx,%r11,4),%edi
test   %edi,%edi
mov    %r13,0x18(%rsp)
mov    %r14,0x48(%rsp)
jne    163d <gf_invert_matrix+0x50d>
mov    %r14,%rsi
imul   %r10,%rsi
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,4),%r8
lea    (%rsi,%r10,1),%rdi
lea    (%rcx,%rdi,4),%r15
mov    0x28(%rsp),%rcx
lea    (%rcx,%rsi,4),%r13
lea    (%rcx,%rdi,4),%rax
mov    %r14,%rbx
imul   %r10,%rbx
mov    %r12,%rsi
mov    %r9,%rcx
xchg   %ax,%ax
cmp    %r10,%rcx
jae    140c <gf_invert_matrix+0x2dc>
add    $0x1,%rcx
cmpl   $0x0,(%rsi)
mov    0x40(%rsp),%rdi
lea    (%rsi,%rdi,1),%rsi
je     13f0 <gf_invert_matrix+0x2c0>
add    $0xffffffff,%ecx
mov    %ecx,%edx
cmp    %ebp,%edx
je     1733 <gf_invert_matrix+0x603>
imul   %ebp,%edx
movslq %edx,%rdi
cmp    $0x4,%ebp
jae    1430 <gf_invert_matrix+0x300>
xor    %ecx,%ecx
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rbx
jmp    15f0 <gf_invert_matrix+0x4c0>
mov    %rbx,0x30(%rsp)
mov    %r9,%rbp
mov    0x8(%rsp),%rcx
lea    (%rcx,%rdi,4),%rsi
mov    0xa0(%rsp),%rcx
mov    %rdi,%rdx
lea    (%rcx,%rdi,4),%rdi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rdx,4),%r9
mov    0x98(%rsp),%rcx
mov    %rdx,0x20(%rsp)
lea    (%rcx,%rdx,4),%r14
cmp    %rdi,%r8
setb   %bl
cmp    %r15,%rsi
setb   %cl
and    %bl,%cl
cmp    %rax,%r8
setb   %bl
cmp    %r15,%r13
setb   %dl
and    %bl,%dl
or     %cl,%dl
cmp    %r14,%r8
setb   %cl
cmp    %r15,%r9
setb   %bl
and    %cl,%bl
cmp    %rax,%rsi
setb   %sil
cmp    %rdi,%r13
setb   %cl
and    %sil,%cl
or     %bl,%cl
or     %dl,%cl
or     0x7(%rsp),%cl
cmp    %r14,%r13
setb   %bl
cmp    %rax,%r9
setb   %sil
test   %cl,%cl
jne    1574 <gf_invert_matrix+0x444>
mov    $0x0,%ecx
and    %sil,%bl
mov    0x38(%rsp),%r10
mov    %rbp,%r9
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rbx
mov    0x20(%rsp),%rdi
jne    15f0 <gf_invert_matrix+0x4c0>
cmpq   $0x0,0x90(%rsp)
mov    0x60(%rsp),%rax
mov    0x58(%rsp),%rdx
je     158f <gf_invert_matrix+0x45f>
mov    0x70(%rsp),%rcx
lea    (%rcx,%rdi,4),%rsi
mov    0x68(%rsp),%rcx
lea    (%rcx,%rdi,4),%rdi
mov    0x78(%rsp),%rbp
xor    %ecx,%ecx
mov    0x30(%rsp),%rbx
nop
movups -0x10(%rax,%rcx,4),%xmm0
movups -0x10(%rdi,%rcx,4),%xmm1
movups %xmm1,-0x10(%rax,%rcx,4)
movups %xmm0,-0x10(%rdi,%rcx,4)
movups -0x10(%rdx,%rcx,4),%xmm0
movups -0x10(%rsi,%rcx,4),%xmm1
movups %xmm1,-0x10(%rdx,%rcx,4)
movups %xmm0,-0x10(%rsi,%rcx,4)
movups (%rax,%rcx,4),%xmm0
movups (%rdi,%rcx,4),%xmm1
movups %xmm1,(%rax,%rcx,4)
movups %xmm0,(%rdi,%rcx,4)
movups (%rdx,%rcx,4),%xmm0
movups (%rsi,%rcx,4),%xmm1
movups %xmm1,(%rdx,%rcx,4)
movups %xmm0,(%rsi,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1520 <gf_invert_matrix+0x3f0>
jmp    1596 <gf_invert_matrix+0x466>
xor    %ecx,%ecx
mov    0x38(%rsp),%r10
mov    %rbp,%r9
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rbx
mov    0x20(%rsp),%rdi
jmp    15f0 <gf_invert_matrix+0x4c0>
xor    %ecx,%ecx
mov    0x30(%rsp),%rbx
testb  $0x1,0x88(%rsp)
01
mov    0x20(%rsp),%rdi
je     15d5 <gf_invert_matrix+0x4a5>
add    %rcx,%rbx
mov    0x8(%rsp),%rdx
movups (%rdx,%rbx,4),%xmm0
add    %rdi,%rcx
movups (%rdx,%rcx,4),%xmm1
movups %xmm1,(%rdx,%rbx,4)
movups %xmm0,(%rdx,%rcx,4)
mov    0x28(%rsp),%rdx
movups (%rdx,%rbx,4),%xmm0
movups (%rdx,%rcx,4),%xmm1
movups %xmm1,(%rdx,%rbx,4)
movups %xmm0,(%rdx,%rcx,4)
mov    0x80(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r10,%rdx
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rbx
je     1631 <gf_invert_matrix+0x501>
nop
mov    0x8(%rsp),%rdx
lea    (%rdx,%rdi,4),%rsi
mov    0x28(%rsp),%rdx
lea    (%rdx,%rdi,4),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,4),%edi
mov    (%rsi,%rcx,4),%ebp
mov    %ebp,(%rbx,%rcx,4)
mov    %edi,(%rsi,%rcx,4)
mov    (%rax,%rcx,4),%edi
mov    (%rdx,%rcx,4),%ebp
mov    %ebp,(%rax,%rcx,4)
mov    %edi,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1610 <gf_invert_matrix+0x4e0>
mov    0x8(%rsp),%rcx
mov    (%rcx,%r11,4),%edi
mov    %rax,%r13
mov    %r9,0xb0(%rsp)
mov    %r12,0x30(%rsp)
mov    %r10,%r15
call   1040 <gf_inv@plt>
mov    %eax,%r14d
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
nopl   0x0(%rax)
mov    0x0(%rbp,%rbx,4),%edi
mov    %r14d,%esi
call   1050 <gf_mul@plt>
mov    %eax,0x0(%rbp,%rbx,4)
mov    0x0(%r13,%rbx,4),%edi
mov    %r14d,%esi
call   1050 <gf_mul@plt>
mov    %eax,0x0(%r13,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1660 <gf_invert_matrix+0x530>
mov    0x8(%rsp),%r13
mov    0x28(%rsp),%r14
xor    %ecx,%ecx
mov    %r15,%r10
jmp    16bd <gf_invert_matrix+0x58d>
nopl   0x0(%rax)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0x40(%rsp),%rax
add    %rax,%r14
add    %rax,%r13
cmp    %r10,%rcx
je     1330 <gf_invert_matrix+0x200>
mov    %rcx,0x20(%rsp)
cmp    0x48(%rsp),%rcx
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%rbx
je     16a0 <gf_invert_matrix+0x570>
mov    0x20(%rsp),%rax
imul   %r10,%rax
add    0x48(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,4),%ebp
xor    %r15d,%r15d
nopl   0x0(%rax)
mov    (%r12,%r15,4),%esi
mov    %ebp,%edi
call   1050 <gf_mul@plt>
xor    %eax,(%r14,%r15,4)
mov    (%rbx,%r15,4),%esi
mov    %ebp,%edi
call   1050 <gf_mul@plt>
mov    0x38(%rsp),%r10
xor    %eax,0x0(%r13,%r15,4)
add    $0x1,%r15
cmp    %r15,%r10
jne    16f0 <gf_invert_matrix+0x5c0>
jmp    16a0 <gf_invert_matrix+0x570>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%eax
jmp    1721 <gf_invert_matrix+0x5f1>

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

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