int jerasure_invert_bitmatrix(int *mat, int *inv, int rows) {
  int cols, i, j, k;
  int tmp;
  cols = rows;
  k = 0;
  for (i = 0; i < rows; i++) {
    for (j = 0; j < cols; j++) {
      inv[k] = (i == j) ? 1 : 0;
      k++;
    }
  }
  for (i = 0; i < cols; i++) {
    if ((mat[i * cols + i]) == 0) {
      for (j = i + 1; j < rows && (mat[j * cols + i]) == 0; j++)
        ;
      if (j == rows)
        return -1;
      for (k = 0; k < cols; k++) {
        tmp = mat[i * cols + k];
        mat[i * cols + k] = mat[j * cols + k];
        mat[j * cols + k] = tmp;
        tmp = inv[i * cols + k];
        inv[i * cols + k] = inv[j * cols + k];
        inv[j * cols + k] = tmp;
      }
    }
    for (j = i + 1; j != rows; j++) {
      if (mat[j * cols + i] != 0) {
        for (k = 0; k < cols; k++) {
          mat[j * cols + k] ^= mat[i * cols + k];
          inv[j * cols + k] ^= inv[i * cols + k];
        }
      }
    }
  }
  for (i = rows - 1; i >= 0; i--) {
    for (j = 0; j < i; j++) {
      if (mat[j * cols + i]) {
        for (k = 0; k < cols; k++) {
          mat[j * cols + k] ^= mat[i * cols + k];
          inv[j * cols + k] ^= inv[i * cols + k];
        }
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<jerasure_invert_bitmatrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1189 <jerasure_invert_bitmatrix+0x89>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1176 <jerasure_invert_bitmatrix+0x76>
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%esi
xor    %edx,%edx
mov    $0x1,%eax
cmp    %esi,%ecx
cmove  %eax,%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1136 <jerasure_invert_bitmatrix+0x36>
jmp    117b <jerasure_invert_bitmatrix+0x7b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1123 <jerasure_invert_bitmatrix+0x23>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13cb <jerasure_invert_bitmatrix+0x2cb>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12f9 <jerasure_invert_bitmatrix+0x1f9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x1c(%rbp),%ecx
mov    %al,-0x31(%rbp)
jge    11ec <jerasure_invert_bitmatrix+0xec>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
sete   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    11fc <jerasure_invert_bitmatrix+0xfc>
jmp    120f <jerasure_invert_bitmatrix+0x10f>
jmp    1201 <jerasure_invert_bitmatrix+0x101>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c0 <jerasure_invert_bitmatrix+0xc0>
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1227 <jerasure_invert_bitmatrix+0x127>
movl   $0xffffffff,-0x4(%rbp)
jmp    14b5 <jerasure_invert_bitmatrix+0x3b5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12f4 <jerasure_invert_bitmatrix+0x1f4>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    122e <jerasure_invert_bitmatrix+0x12e>
jmp    12f9 <jerasure_invert_bitmatrix+0x1f9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     13b8 <jerasure_invert_bitmatrix+0x2b8>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13a5 <jerasure_invert_bitmatrix+0x2a5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13a0 <jerasure_invert_bitmatrix+0x2a0>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1330 <jerasure_invert_bitmatrix+0x230>
jmp    13a5 <jerasure_invert_bitmatrix+0x2a5>
jmp    13aa <jerasure_invert_bitmatrix+0x2aa>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1302 <jerasure_invert_bitmatrix+0x202>
jmp    13bd <jerasure_invert_bitmatrix+0x2bd>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1190 <jerasure_invert_bitmatrix+0x90>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     14ae <jerasure_invert_bitmatrix+0x3ae>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    149b <jerasure_invert_bitmatrix+0x39b>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1488 <jerasure_invert_bitmatrix+0x388>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1483 <jerasure_invert_bitmatrix+0x383>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1413 <jerasure_invert_bitmatrix+0x313>
jmp    1488 <jerasure_invert_bitmatrix+0x388>
jmp    148d <jerasure_invert_bitmatrix+0x38d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13e5 <jerasure_invert_bitmatrix+0x2e5>
jmp    14a0 <jerasure_invert_bitmatrix+0x3a0>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    13d4 <jerasure_invert_bitmatrix+0x2d4>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<jerasure_invert_bitmatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
test   %edx,%edx
jle    1e3e <jerasure_invert_bitmatrix+0xd3e>
mov    %edx,%r14d
mov    %rdi,-0x70(%rsp)
lea    -0x1(%r14),%eax
mov    %rax,0x60(%rsp)
lea    0x1(%rax),%r11
mov    %r11,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%r10
mov    %r10,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15,%r9
and    $0xfffffffffffffffe,%r9
lea    0x30(%rsi),%r8
xor    %ebx,%ebx
movdqa 0xea6(%rip),%xmm8
movdqa 0xeae(%rip),%xmm1
movdqa 0xeb6(%rip),%xmm2
movdqa 0xebe(%rip),%xmm3
movdqa 0xec6(%rip),%xmm4
xor    %ebp,%ebp
jmp    118c <jerasure_invert_bitmatrix+0x8c>
xchg   %ax,%ax
add    $0x1,%ebp
cmp    %r14d,%ebp
je     129a <jerasure_invert_bitmatrix+0x19a>
movslq %ebx,%rbx
cmpl   $0x7,0x60(%rsp)
jae    11a0 <jerasure_invert_bitmatrix+0xa0>
xor    %eax,%eax
jmp    1270 <jerasure_invert_bitmatrix+0x170>
nopl   (%rax)
movd   %ebp,%xmm5
pshufd $0x0,%xmm5,%xmm0
test   %r10,%r10
je     128b <jerasure_invert_bitmatrix+0x18b>
lea    (%r8,%rbx,4),%rdx
mov    %r9,%rdi
xor    %eax,%eax
movdqa %xmm8,%xmm6
movdqa %xmm6,%xmm7
paddd  %xmm1,%xmm7
movdqa %xmm0,%xmm5
pcmpeqd %xmm6,%xmm5
psrld  $0x1f,%xmm5
pcmpeqd %xmm0,%xmm7
psrld  $0x1f,%xmm7
movdqu %xmm5,-0x30(%rdx,%rax,4)
movdqu %xmm7,-0x20(%rdx,%rax,4)
movdqa %xmm6,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm6,%xmm7
paddd  %xmm3,%xmm7
pcmpeqd %xmm0,%xmm5
psrld  $0x1f,%xmm5
pcmpeqd %xmm0,%xmm7
psrld  $0x1f,%xmm7
movdqu %xmm5,-0x10(%rdx,%rax,4)
movdqu %xmm7,(%rdx,%rax,4)
add    $0x10,%rax
paddd  %xmm4,%xmm6
add    $0xfffffffffffffffe,%rdi
jne    11c0 <jerasure_invert_bitmatrix+0xc0>
test   $0x1,%r15b
je     1253 <jerasure_invert_bitmatrix+0x153>
add    %rbx,%rax
movdqa %xmm0,%xmm5
pcmpeqd %xmm6,%xmm5
paddd  %xmm1,%xmm6
psrld  $0x1f,%xmm5
pcmpeqd %xmm0,%xmm6
psrld  $0x1f,%xmm6
movdqu %xmm5,(%rsi,%rax,4)
movdqu %xmm6,0x10(%rsi,%rax,4)
add    %rcx,%rbx
mov    %ecx,%eax
cmp    %rcx,%r11
je     1180 <jerasure_invert_bitmatrix+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
cmp    %eax,%ebp
sete   %dl
mov    %edx,(%rsi,%rbx,4)
add    $0x1,%rbx
add    $0x1,%eax
cmp    %eax,%r14d
jne    1270 <jerasure_invert_bitmatrix+0x170>
jmp    1180 <jerasure_invert_bitmatrix+0x80>
xor    %eax,%eax
movdqa %xmm8,%xmm6
test   $0x1,%r15b
jne    122b <jerasure_invert_bitmatrix+0x12b>
jmp    1253 <jerasure_invert_bitmatrix+0x153>
test   %r14d,%r14d
jle    1e3e <jerasure_invert_bitmatrix+0xd3e>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x80(%rsp)
mov    %r14d,%r10d
lea    (%r10,%r10,1),%rax
mov    %rax,0xb8(%rsp)
mov    -0x70(%rsp),%rbp
lea    0x0(,%r10,4),%r8
add    %rbp,%r8
lea    (%rsi,%r10,4),%rdi
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rdi,0xa8(%rsp)
cmp    %rbp,%rdi
seta   %al
cmp    %rsi,%r8
seta   %bl
and    %al,%bl
mov    %bl,-0x61(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x8(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0x50(%rsp)
lea    0x0(,%r10,4),%rax
mov    %rax,-0x28(%rsp)
lea    0x4(,%r10,4),%rax
mov    %rax,0xc0(%rsp)
lea    0x10(%rsi),%rax
lea    0x10(%rbp),%rcx
lea    0x10(%rsi,%r10,4),%rdi
mov    %rdi,0xa0(%rsp)
lea    0x10(%rbp,%r10,4),%rdi
mov    %rdi,0x98(%rsp)
lea    0x4(%rbp,%r10,4),%rdi
mov    %rdi,0x90(%rsp)
lea    (%rsi,%r10,4),%rdi
add    $0x4,%rdi
mov    %rdi,0x88(%rsp)
mov    $0x1,%r12d
xor    %edx,%edx
mov    %rsi,%r15
mov    %rbp,%rdi
mov    %rcx,0x70(%rsp)
mov    %rax,0x78(%rsp)
mov    %rax,%rbx
mov    %r8,0xb0(%rsp)
mov    %r8,%r13
mov    %r10,-0x78(%rsp)
mov    %r14,0x68(%rsp)
mov    %rsi,-0x50(%rsp)
jmp    1428 <jerasure_invert_bitmatrix+0x328>
mov    (%rsp),%r12
add    $0x1,%r12
mov    0x38(%rsp),%r13
add    0xc0(%rsp),%r13
mov    -0x28(%rsp),%rax
mov    -0x20(%rsp),%rbx
add    %rax,%rbx
mov    -0x18(%rsp),%rcx
add    %rax,%rcx
add    %rax,%rdi
add    %rax,%r15
add    %rax,0xa0(%rsp)
add    %rax,0x98(%rsp)
add    %rax,0x90(%rsp)
add    %rax,0x88(%rsp)
mov    0x30(%rsp),%rdx
cmp    %r10,%rdx
mov    0x68(%rsp),%r14
mov    -0x50(%rsp),%rsi
je     1a1b <jerasure_invert_bitmatrix+0x91b>
mov    %rbx,-0x20(%rsp)
mov    %rcx,-0x18(%rsp)
mov    %rdx,%rcx
mov    %rdx,%rax
imul   %r10,%rax
mov    -0x70(%rsp),%rbp
lea    0x0(,%rax,4),%rdx
add    %rbp,%rdx
mov    %rdx,0x28(%rsp)
lea    (%rax,%r10,1),%rdx
lea    0x0(%rbp,%rdx,4),%rbx
mov    %rbx,0x20(%rsp)
mov    %rax,-0x38(%rsp)
lea    (%rsi,%rax,4),%rax
mov    %rax,-0x40(%rsp)
mov    %rdx,0x18(%rsp)
lea    (%rsi,%rdx,4),%rax
mov    %rax,-0x60(%rsp)
cmp    %r12d,%r14d
mov    %r12d,%eax
cmovg  %r14d,%eax
mov    %ecx,%edx
imul   %r14d,%edx
movslq %edx,%rdx
mov    %rcx,-0x58(%rsp)
add    %rcx,%rdx
cmpl   $0x0,0x0(%rbp,%rdx,4)
jne    16d5 <jerasure_invert_bitmatrix+0x5d5>
mov    %r13,%rbp
mov    %r12,%rdx
nopw   0x0(%rax,%rax,1)
cmp    %r10,%rdx
jae    14ce <jerasure_invert_bitmatrix+0x3ce>
add    $0x1,%rdx
cmpl   $0x0,0x0(%rbp)
mov    -0x28(%rsp),%rcx
lea    0x0(%rbp,%rcx,1),%rbp
je     14b0 <jerasure_invert_bitmatrix+0x3b0>
add    $0xffffffff,%edx
mov    %edx,%eax
cmp    %r14d,%eax
mov    -0x70(%rsp),%rcx
je     1e52 <jerasure_invert_bitmatrix+0xd52>
imul   %r14d,%eax
movslq %eax,%r11
cmp    $0x4,%r14d
jae    14f0 <jerasure_invert_bitmatrix+0x3f0>
xor    %eax,%eax
jmp    16a0 <jerasure_invert_bitmatrix+0x5a0>
lea    (%rcx,%r11,4),%rbp
mov    0xb0(%rsp),%rax
lea    (%rax,%r11,4),%rdx
mov    %rdx,-0x10(%rsp)
lea    (%rsi,%r11,4),%rax
mov    %rax,-0x48(%rsp)
mov    0xa8(%rsp),%rax
mov    %r11,-0x30(%rsp)
lea    (%rax,%r11,4),%r11
mov    0x28(%rsp),%rcx
cmp    %rdx,%rcx
setb   %bl
mov    0x20(%rsp),%r8
cmp    %r8,%rbp
setb   %dl
and    %bl,%dl
mov    -0x60(%rsp),%r10
cmp    %r10,%rcx
setb   %bl
mov    -0x40(%rsp),%r9
cmp    %r8,%r9
setb   %al
and    %bl,%al
or     %dl,%al
cmp    %r11,%rcx
setb   %dl
mov    -0x48(%rsp),%rcx
cmp    %r8,%rcx
setb   %bl
and    %dl,%bl
cmp    %r10,%rbp
setb   %bpl
cmp    -0x10(%rsp),%r9
setb   %dl
and    %bpl,%dl
or     %bl,%dl
or     %al,%dl
or     -0x61(%rsp),%dl
cmp    %r11,%r9
setb   %bl
cmp    %r10,%rcx
setb   %r8b
test   %dl,%dl
jne    1685 <jerasure_invert_bitmatrix+0x585>
mov    $0x0,%eax
and    %r8b,%bl
mov    -0x78(%rsp),%r10
mov    -0x30(%rsp),%r11
jne    16a0 <jerasure_invert_bitmatrix+0x5a0>
cmpq   $0x0,0x40(%rsp)
je     1a04 <jerasure_invert_bitmatrix+0x904>
mov    0x78(%rsp),%rax
lea    (%rax,%r11,4),%r8
mov    0x70(%rsp),%rax
lea    (%rax,%r11,4),%rax
mov    -0x8(%rsp),%rbx
xor    %edx,%edx
mov    -0x70(%rsp),%r9
mov    -0x18(%rsp),%rbp
mov    -0x20(%rsp),%rcx
nop
movups -0x10(%rbp,%rdx,4),%xmm0
movups -0x10(%rax,%rdx,4),%xmm1
movups %xmm1,-0x10(%rbp,%rdx,4)
movups %xmm0,-0x10(%rax,%rdx,4)
movups -0x10(%rcx,%rdx,4),%xmm0
movups -0x10(%r8,%rdx,4),%xmm1
movups %xmm1,-0x10(%rcx,%rdx,4)
movups %xmm0,-0x10(%r8,%rdx,4)
movups 0x0(%rbp,%rdx,4),%xmm0
movups (%rax,%rdx,4),%xmm1
movups %xmm1,0x0(%rbp,%rdx,4)
movups %xmm0,(%rax,%rdx,4)
movdqu (%rcx,%rdx,4),%xmm0
movdqu (%r8,%rdx,4),%xmm1
movdqu %xmm1,(%rcx,%rdx,4)
movdqu %xmm0,(%r8,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    15e0 <jerasure_invert_bitmatrix+0x4e0>
testb  $0x1,0x10(%rsp)
je     1676 <jerasure_invert_bitmatrix+0x576>
mov    -0x38(%rsp),%rax
add    %rdx,%rax
movups (%r9,%rax,4),%xmm0
add    %r11,%rdx
movups (%r9,%rdx,4),%xmm1
movups %xmm1,(%r9,%rax,4)
movups %xmm0,(%r9,%rdx,4)
movdqu (%rsi,%rax,4),%xmm0
movdqu (%rsi,%rdx,4),%xmm1
movdqu %xmm1,(%rsi,%rax,4)
movdqu %xmm0,(%rsi,%rdx,4)
mov    0x8(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
jne    16a0 <jerasure_invert_bitmatrix+0x5a0>
jmp    16d5 <jerasure_invert_bitmatrix+0x5d5>
xor    %eax,%eax
mov    -0x78(%rsp),%r10
mov    -0x30(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rcx
lea    (%rcx,%r11,4),%rdx
lea    (%rsi,%r11,4),%rbp
nopl   (%rax)
mov    (%rdi,%rax,4),%ebx
mov    (%rdx,%rax,4),%ecx
mov    %ecx,(%rdi,%rax,4)
mov    %ebx,(%rdx,%rax,4)
mov    (%r15,%rax,4),%ecx
mov    0x0(%rbp,%rax,4),%ebx
mov    %ebx,(%r15,%rax,4)
mov    %ecx,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    16b0 <jerasure_invert_bitmatrix+0x5b0>
mov    %r13,0x38(%rsp)
mov    %r12,(%rsp)
mov    -0x58(%rsp),%r13
lea    0x1(%r13),%rax
mov    %rax,0x30(%rsp)
cmp    %r10,%rax
je     13c0 <jerasure_invert_bitmatrix+0x2c0>
mov    0xb8(%rsp),%rax
mov    -0x38(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x48(%rsp)
mov    0x88(%rsp),%rax
mov    0x90(%rsp),%r14
mov    0x98(%rsp),%r12
mov    0xa0(%rsp),%r9
xor    %ebp,%ebp
mov    (%rsp),%r8
jmp    1762 <jerasure_invert_bitmatrix+0x662>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    $0x1,%rbp
mov    -0x28(%rsp),%rcx
add    %rcx,%r9
add    %rcx,%r12
add    %rcx,%r14
add    %rcx,%rax
cmp    %r10,%r8
je     13c0 <jerasure_invert_bitmatrix+0x2c0>
mov    %r8,%r11
imul   %r10,%r11
lea    (%r11,%r13,1),%rcx
mov    -0x70(%rsp),%rdx
cmpl   $0x0,(%rdx,%rcx,4)
je     1740 <jerasure_invert_bitmatrix+0x640>
cmpl   $0x4,0x68(%rsp)
jae    1790 <jerasure_invert_bitmatrix+0x690>
xor    %ebx,%ebx
jmp    1970 <jerasure_invert_bitmatrix+0x870>
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,-0x48(%rsp)
mov    %rbp,%rcx
imul   %r10,%rcx
mov    0x18(%rsp),%rdx
add    %rcx,%rdx
mov    -0x70(%rsp),%rsi
lea    (%rsi,%rdx,4),%rbp
add    0x48(%rsp),%rcx
lea    (%rsi,%rcx,4),%rbx
mov    -0x50(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
lea    (%rsi,%rcx,4),%rcx
cmp    %rcx,%rbp
setb   -0x30(%rsp)
cmp    %rbx,%rdx
setb   -0x10(%rsp)
mov    0x20(%rsp),%r10
cmp    %r10,%rbp
setb   -0x79(%rsp)
mov    0x28(%rsp),%rsi
cmp    %rbx,%rsi
setb   -0x7a(%rsp)
mov    -0x60(%rsp),%r13
cmp    %r13,%rbp
setb   -0x7b(%rsp)
mov    -0x40(%rsp),%rbp
cmp    %rbx,%rbp
setb   0x58(%rsp)
cmp    %r10,%rdx
setb   %bl
cmp    %rcx,%rsi
setb   %r10b
cmp    %r13,%rdx
setb   %dl
cmp    %rcx,%rbp
setb   %sil
mov    -0x10(%rsp),%cl
test   %cl,-0x30(%rsp)
jne    19ee <jerasure_invert_bitmatrix+0x8ee>
mov    -0x7a(%rsp),%cl
and    %cl,-0x79(%rsp)
jne    19ee <jerasure_invert_bitmatrix+0x8ee>
mov    %r10d,%r13d
mov    0x58(%rsp),%cl
and    %cl,-0x7b(%rsp)
mov    -0x78(%rsp),%r10
mov    -0x58(%rsp),%rcx
mov    -0x48(%rsp),%rbp
jne    18fe <jerasure_invert_bitmatrix+0x7fe>
and    %r13b,%bl
jne    18fe <jerasure_invert_bitmatrix+0x7fe>
mov    $0x0,%ebx
and    %sil,%dl
mov    %rcx,%r13
jne    1970 <jerasure_invert_bitmatrix+0x870>
cmpq   $0x0,0x40(%rsp)
je     1905 <jerasure_invert_bitmatrix+0x805>
mov    -0x8(%rsp),%rdx
xor    %r10d,%r10d
mov    -0x18(%rsp),%rcx
mov    -0x20(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rcx,%r10,4),%xmm0
movups -0x10(%r12,%r10,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,-0x10(%r12,%r10,4)
movups -0x10(%rsi,%r10,4),%xmm0
movups -0x10(%r9,%r10,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,-0x10(%r9,%r10,4)
movups (%rcx,%r10,4),%xmm0
movups (%r12,%r10,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,(%r12,%r10,4)
movdqu (%rsi,%r10,4),%xmm0
movdqu (%r9,%r10,4),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,(%r9,%r10,4)
add    $0x8,%r10
add    $0xfffffffffffffffe,%rdx
jne    18a0 <jerasure_invert_bitmatrix+0x7a0>
jmp    1908 <jerasure_invert_bitmatrix+0x808>
xor    %ebx,%ebx
mov    %rcx,%r13
jmp    1970 <jerasure_invert_bitmatrix+0x870>
xor    %r10d,%r10d
testb  $0x1,0x10(%rsp)
mov    -0x58(%rsp),%r13
je     194f <jerasure_invert_bitmatrix+0x84f>
mov    -0x38(%rsp),%rcx
add    %r10,%rcx
mov    -0x70(%rsp),%rdx
movups (%rdx,%rcx,4),%xmm0
add    %r11,%r10
movups (%rdx,%r10,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,(%rdx,%r10,4)
mov    -0x50(%rsp),%rdx
movdqu (%rdx,%rcx,4),%xmm0
movdqu (%rdx,%r10,4),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,(%rdx,%r10,4)
mov    0x8(%rsp),%rcx
mov    %rcx,%rbx
mov    -0x78(%rsp),%r10
cmp    %r10,%rcx
je     1740 <jerasure_invert_bitmatrix+0x640>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdx
test   $0x1,%r10b
je     19a3 <jerasure_invert_bitmatrix+0x8a3>
mov    -0x38(%rsp),%rcx
add    %rbx,%rcx
mov    -0x70(%rsp),%rsi
mov    (%rsi,%rcx,4),%edx
add    %rbx,%r11
xor    %edx,(%rsi,%r11,4)
mov    -0x50(%rsp),%rdx
mov    (%rdx,%rcx,4),%ecx
xor    %ecx,(%rdx,%r11,4)
mov    %rbx,%rdx
or     $0x1,%rdx
not    %rbx
cmp    0x50(%rsp),%rbx
je     1740 <jerasure_invert_bitmatrix+0x640>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rdx,4),%ecx
xor    %ecx,-0x4(%r14,%rdx,4)
mov    (%r15,%rdx,4),%ecx
xor    %ecx,-0x4(%rax,%rdx,4)
mov    0x4(%rdi,%rdx,4),%ecx
xor    %ecx,(%r14,%rdx,4)
mov    0x4(%r15,%rdx,4),%ecx
xor    %ecx,(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    19c0 <jerasure_invert_bitmatrix+0x8c0>
jmp    1740 <jerasure_invert_bitmatrix+0x640>
xor    %ebx,%ebx
mov    -0x78(%rsp),%r10
mov    -0x58(%rsp),%r13
mov    -0x48(%rsp),%rbp
jmp    1970 <jerasure_invert_bitmatrix+0x870>
xor    %edx,%edx
mov    -0x70(%rsp),%r9
testb  $0x1,0x10(%rsp)
jne    1643 <jerasure_invert_bitmatrix+0x543>
jmp    1676 <jerasure_invert_bitmatrix+0x576>
test   %r14d,%r14d
jle    1e3e <jerasure_invert_bitmatrix+0xd3e>
lea    -0x1(%r10),%rax
imul   %r10,%rax
mov    %rax,0x8(%rsp)
mov    %r10,%rax
imul   %r10,%rax
mov    %rax,(%rsp)
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x48(%rsp)
mov    0x10(%rsp),%rax
and    %rax,0x80(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0x58(%rsp)
lea    -0x1(%r10),%rax
imul   %r10,%rax
mov    %r10,%rcx
lea    (%rsi,%rax,4),%rdi
add    $0x10,%rdi
lea    0x0(,%r10,4),%r8
mov    %r8,%rdx
neg    %rdx
mov    %rdx,0x38(%rsp)
mov    -0x70(%rsp),%rbx
lea    (%rbx,%rax,4),%rbp
add    $0x10,%rbp
lea    0x4(%rbx),%rdx
mov    %rdx,0x30(%rsp)
lea    0x4(%rsi),%rdx
mov    %rdx,-0x8(%rsp)
lea    (%rbx,%rax,4),%r12
lea    (%rsi,%rax,4),%rax
xor    %edx,%edx
mov    %r10,%rbx
mov    %r8,-0x60(%rsp)
jmp    1afb <jerasure_invert_bitmatrix+0x9fb>
nopl   0x0(%rax,%rax,1)
addq   $0xffffffffffffffff,0x60(%rsp)
mov    -0x18(%rsp),%rdx
add    $0x1,%rdx
mov    0x38(%rsp),%rcx
mov    0x18(%rsp),%rdi
add    %rcx,%rdi
add    %rcx,%rbp
add    %rcx,%r12
add    %rcx,%rax
cmpq   $0x2,-0x20(%rsp)
mov    -0x28(%rsp),%rbx
mov    -0x50(%rsp),%rsi
jb     1e3e <jerasure_invert_bitmatrix+0xd3e>
cmp    $0x2,%rbx
jb     1e3e <jerasure_invert_bitmatrix+0xd3e>
mov    %rdi,0x18(%rsp)
mov    %rdx,-0x18(%rsp)
mov    %rdx,%rcx
mov    -0x78(%rsp),%r9
imul   %r9,%rcx
mov    0x8(%rsp),%rdx
sub    %rcx,%rdx
mov    -0x70(%rsp),%r10
lea    (%r10,%rdx,4),%rdi
mov    %rdi,0x50(%rsp)
mov    (%rsp),%rdi
sub    %rcx,%rdi
lea    (%r10,%rdi,4),%rcx
mov    %rcx,-0x38(%rsp)
lea    (%rsi,%rdx,4),%rcx
mov    %rcx,0x28(%rsp)
lea    (%rsi,%rdi,4),%rcx
mov    %rcx,0x20(%rsp)
mov    %rbx,-0x20(%rsp)
lea    -0x1(%rbx),%rdx
mov    %rdx,%rcx
mov    %rdx,-0x28(%rsp)
imul   %r9,%rdx
mov    %rdx,-0x58(%rsp)
mov    -0x8(%rsp),%rbx
mov    0x30(%rsp),%r14
mov    0x70(%rsp),%r9
mov    0x78(%rsp),%r13
xor    %ecx,%ecx
mov    %rbp,-0x40(%rsp)
jmp    1bab <jerasure_invert_bitmatrix+0xaab>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %r8,%r13
add    %r8,%r9
add    %r8,%r14
add    %r8,%rbx
cmp    0x60(%rsp),%rcx
je     1ac0 <jerasure_invert_bitmatrix+0x9c0>
mov    %rcx,%r15
imul   -0x78(%rsp),%r15
mov    -0x28(%rsp),%rdx
add    %r15,%rdx
mov    -0x70(%rsp),%rsi
cmpl   $0x0,(%rsi,%rdx,4)
je     1b90 <jerasure_invert_bitmatrix+0xa90>
cmpl   $0x4,0x68(%rsp)
jae    1be0 <jerasure_invert_bitmatrix+0xae0>
xor    %edx,%edx
mov    -0x78(%rsp),%rdi
jmp    1dc0 <jerasure_invert_bitmatrix+0xcc0>
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rdx
mov    -0x70(%rsp),%rdi
mov    -0x78(%rsp),%rbp
imul   %rbp,%rdx
lea    (%rdi,%rdx,4),%rsi
add    %rdx,%rbp
lea    (%rdi,%rbp,4),%r8
mov    -0x50(%rsp),%rdi
lea    (%rdi,%rdx,4),%rdx
lea    (%rdi,%rbp,4),%rbp
cmp    %rbp,%rsi
setb   -0x30(%rsp)
cmp    %r8,%rdx
setb   -0x10(%rsp)
mov    -0x38(%rsp),%r10
cmp    %r10,%rsi
setb   -0x48(%rsp)
mov    0x50(%rsp),%rdi
cmp    %r8,%rdi
setb   -0x79(%rsp)
mov    0x20(%rsp),%r11
cmp    %r11,%rsi
setb   -0x7a(%rsp)
mov    0x28(%rsp),%rsi
cmp    %r8,%rsi
setb   -0x7b(%rsp)
cmp    %r10,%rdx
setb   %r8b
cmp    %rbp,%rdi
setb   %r10b
cmp    %r11,%rdx
setb   %dil
cmp    %rbp,%rsi
setb   %sil
mov    -0x10(%rsp),%dl
test   %dl,-0x30(%rsp)
jne    1daa <jerasure_invert_bitmatrix+0xcaa>
mov    -0x79(%rsp),%dl
and    %dl,-0x48(%rsp)
jne    1daa <jerasure_invert_bitmatrix+0xcaa>
mov    -0x7b(%rsp),%dl
and    %dl,-0x7a(%rsp)
mov    -0x40(%rsp),%rbp
jne    1d91 <jerasure_invert_bitmatrix+0xc91>
and    %r10b,%r8b
jne    1d91 <jerasure_invert_bitmatrix+0xc91>
mov    $0x0,%edx
and    %sil,%dil
mov    -0x78(%rsp),%rdi
mov    -0x60(%rsp),%r8
jne    1dc0 <jerasure_invert_bitmatrix+0xcc0>
cmpq   $0x0,0x40(%rsp)
je     1d9f <jerasure_invert_bitmatrix+0xc9f>
mov    0x80(%rsp),%rsi
xor    %edx,%edx
mov    0x18(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rbp,%rdx,4),%xmm0
movups -0x10(%r9,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,-0x10(%r9,%rdx,4)
movups -0x10(%rdi,%rdx,4),%xmm0
movups -0x10(%r13,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,-0x10(%r13,%rdx,4)
movups 0x0(%rbp,%rdx,4),%xmm0
movups (%r9,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,(%r9,%rdx,4)
movdqu (%rdi,%rdx,4),%xmm0
movdqu 0x0(%r13,%rdx,4),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,0x0(%r13,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1ce0 <jerasure_invert_bitmatrix+0xbe0>
testb  $0x1,0x10(%rsp)
je     1d79 <jerasure_invert_bitmatrix+0xc79>
mov    -0x58(%rsp),%rsi
add    %rdx,%rsi
mov    -0x70(%rsp),%rdi
movups (%rdi,%rsi,4),%xmm0
add    %r15,%rdx
movups (%rdi,%rdx,4),%xmm1
xorps  %xmm0,%xmm1
movups %xmm1,(%rdi,%rdx,4)
mov    -0x50(%rsp),%rdi
movdqu (%rdi,%rsi,4),%xmm0
movdqu (%rdi,%rdx,4),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,(%rdi,%rdx,4)
mov    0x48(%rsp),%rsi
mov    %rsi,%rdx
mov    -0x78(%rsp),%rdi
cmp    %rdi,%rsi
je     1b90 <jerasure_invert_bitmatrix+0xa90>
jmp    1dc0 <jerasure_invert_bitmatrix+0xcc0>
xor    %edx,%edx
mov    -0x78(%rsp),%rdi
mov    -0x60(%rsp),%r8
jmp    1dc0 <jerasure_invert_bitmatrix+0xcc0>
xor    %edx,%edx
testb  $0x1,0x10(%rsp)
jne    1d42 <jerasure_invert_bitmatrix+0xc42>
jmp    1d79 <jerasure_invert_bitmatrix+0xc79>
xor    %edx,%edx
mov    -0x78(%rsp),%rdi
mov    -0x60(%rsp),%r8
mov    -0x40(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rsi
test   $0x1,%dil
je     1df9 <jerasure_invert_bitmatrix+0xcf9>
mov    -0x58(%rsp),%rsi
add    %rdx,%rsi
mov    -0x70(%rsp),%rdi
mov    (%rdi,%rsi,4),%r10d
add    %rdx,%r15
mov    -0x70(%rsp),%rdi
xor    %r10d,(%rdi,%r15,4)
mov    -0x50(%rsp),%rdi
mov    (%rdi,%rsi,4),%esi
xor    %esi,(%rdi,%r15,4)
mov    %rdx,%rsi
or     $0x1,%rsi
not    %rdx
cmp    0x58(%rsp),%rdx
mov    -0x78(%rsp),%rdi
je     1b90 <jerasure_invert_bitmatrix+0xa90>
nopl   0x0(%rax)
mov    (%r12,%rsi,4),%edx
xor    %edx,-0x4(%r14,%rsi,4)
mov    (%rax,%rsi,4),%edx
xor    %edx,-0x4(%rbx,%rsi,4)
mov    0x4(%r12,%rsi,4),%edx
xor    %edx,(%r14,%rsi,4)
mov    0x4(%rax,%rsi,4),%edx
xor    %edx,(%rbx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    1e10 <jerasure_invert_bitmatrix+0xd10>
jmp    1b90 <jerasure_invert_bitmatrix+0xa90>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%eax
jmp    1e40 <jerasure_invert_bitmatrix+0xd40>

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

LLVM IR (-O2):
define i32 @jerasure_invert_bitmatrix(i32* nocapture %0, i32* nocapture %1, i32 %2) {
%4 = icmp sgt i32 %2, 0
br i1 %4, label %5, label %625
5: ; preds = %3
%6 = add i32 %2, -1
%7 = zext i32 %6 to i64
%8 = add nuw nsw i64 %7, 1
%9 = and i64 %8, 8589934584
%10 = add nsw i64 %9, -8
%11 = lshr exact i64 %10, 3
%12 = add nuw nsw i64 %11, 1
%13 = icmp ult i32 %6, 7
%14 = and i64 %8, 8589934584
%15 = trunc i64 %14 to i32
%16 = and i64 %12, 1
%17 = icmp eq i64 %10, 0
%18 = and i64 %12, 4611686018427387902
%19 = icmp eq i64 %16, 0
%20 = icmp eq i64 %8, %14
br label %21
21: ; preds = %5, %120
%22 = phi i64 [ %121, %120 ], [ 0, %5 ]
%23 = phi i32 [ %122, %120 ], [ 0, %5 ]
%24 = shl i64 %22, 32
%25 = ashr exact i64 %24, 32
br i1 %13, label %77, label %26
26: ; preds = %21
%27 = add nsw i64 %25, %14
%28 = insertelement <4 x i32> poison, i32 %23, i64 0
%29 = shufflevector <4 x i32> %28, <4 x i32> poison, <4 x i32> zeroinitializer
%30 = insertelement <4 x i32> poison, i32 %23, i64 0
%31 = shufflevector <4 x i32> %30, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %17, label %62, label %32
32: ; preds = %26, %32
%33 = phi i64 [ %58, %32 ], [ 0, %26 ]
%34 = phi <4 x i32> [ %59, %32 ], [ <i32 0, i32 1, i32 2, i32 3>, %26 ]
%35 = phi i64 [ %60, %32 ], [ 0, %26 ]
%36 = add i64 %25, %33
%37 = add <4 x i32> %34, <i32 4, i32 4, i32 4, i32 4>
%38 = icmp eq <4 x i32> %29, %34
%39 = icmp eq <4 x i32> %31, %37
%40 = zext <4 x i1> %38 to <4 x i32>
%41 = zext <4 x i1> %39 to <4 x i32>
%42 = getelementptr inbounds i32, i32* %1, i64 %36
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %43
%44 = getelementptr inbounds i32, i32* %42, i64 4
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %45
%46 = or i64 %33, 8
%47 = add <4 x i32> %34, <i32 8, i32 8, i32 8, i32 8>
%48 = add i64 %25, %46
%49 = add <4 x i32> %34, <i32 12, i32 12, i32 12, i32 12>
%50 = icmp eq <4 x i32> %29, %47
%51 = icmp eq <4 x i32> %31, %49
%52 = zext <4 x i1> %50 to <4 x i32>
%53 = zext <4 x i1> %51 to <4 x i32>
%54 = getelementptr inbounds i32, i32* %1, i64 %48
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %55
%56 = getelementptr inbounds i32, i32* %54, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> %53, <4 x i32>* %57
%58 = add nuw i64 %33, 16
%59 = add <4 x i32> %34, <i32 16, i32 16, i32 16, i32 16>
%60 = add i64 %35, 2
%61 = icmp eq i64 %60, %18
br i1 %61, label %62, label %32
62: ; preds = %32, %26
%63 = phi i64 [ 0, %26 ], [ %58, %32 ]
%64 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %26 ], [ %59, %32 ]
br i1 %19, label %76, label %65
65: ; preds = %62
%66 = add i64 %25, %63
%67 = add <4 x i32> %64, <i32 4, i32 4, i32 4, i32 4>
%68 = icmp eq <4 x i32> %29, %64
%69 = icmp eq <4 x i32> %31, %67
%70 = zext <4 x i1> %68 to <4 x i32>
%71 = zext <4 x i1> %69 to <4 x i32>
%72 = getelementptr inbounds i32, i32* %1, i64 %66
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %70, <4 x i32>* %73
%74 = getelementptr inbounds i32, i32* %72, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %75
br label %76
76: ; preds = %62, %65
br i1 %20, label %120, label %77
77: ; preds = %21, %76
%78 = phi i64 [ %25, %21 ], [ %27, %76 ]
%79 = phi i32 [ 0, %21 ], [ %15, %76 ]
br label %111
80: ; preds = %120
br i1 %4, label %81, label %625
81: ; preds = %80
%82 = zext i32 %2 to i64
%83 = zext i32 %2 to i64
%84 = shl nuw nsw i64 %83, 1
%85 = getelementptr i32, i32* %0, i64 %83
%86 = getelementptr i32, i32* %1, i64 %83
%87 = and i64 %83, 4294967292
%88 = add nsw i64 %87, -4
%89 = lshr exact i64 %88, 2
%90 = add nuw nsw i64 %89, 1
%91 = icmp ult i32 %2, 4
%92 = icmp ugt i32* %86, %0
%93 = icmp ugt i32* %85, %1
%94 = and i1 %92, %93
%95 = and i64 %83, 4294967292
%96 = and i64 %90, 1
%97 = icmp eq i64 %88, 0
%98 = and i64 %90, 9223372036854775806
%99 = icmp eq i64 %96, 0
%100 = icmp eq i64 %95, %83
%101 = icmp ult i32 %2, 4
%102 = and i64 %83, 4294967292
%103 = and i64 %90, 1
%104 = icmp eq i64 %88, 0
%105 = and i64 %90, 9223372036854775806
%106 = icmp eq i64 %103, 0
%107 = icmp eq i64 %102, %83
%108 = and i64 %83, 1
%109 = icmp eq i64 %108, 0
%110 = sub nsw i64 0, %83
br label %146
111: ; preds = %77, %111
%112 = phi i64 [ %117, %111 ], [ %78, %77 ]
%113 = phi i32 [ %118, %111 ], [ %79, %77 ]
%114 = icmp eq i32 %23, %113
%115 = zext i1 %114 to i32
%116 = getelementptr inbounds i32, i32* %1, i64 %112
store i32 %115, i32* %116
%117 = add nsw i64 %112, 1
%118 = add nuw nsw i32 %113, 1
%119 = icmp eq i32 %118, %2
br i1 %119, label %120, label %111
120: ; preds = %111, %76
%121 = phi i64 [ %27, %76 ], [ %117, %111 ]
%122 = add nuw nsw i32 %23, 1
%123 = icmp eq i32 %122, %2
br i1 %123, label %80, label %21
124: ; preds = %451, %297
%125 = add nuw nsw i64 %147, 1
%126 = icmp eq i64 %298, %83
br i1 %126, label %127, label %146
127: ; preds = %124
br i1 %4, label %128, label %625
128: ; preds = %127
%129 = zext i32 %2 to i64
%130 = add nsw i32 %2, -1
%131 = zext i32 %130 to i64
%132 = zext i32 %2 to i64
%133 = add nsw i64 %83, -1
%134 = mul i64 %133, %83
%135 = mul nuw i64 %83, %83
%136 = icmp ult i32 %2, 4
%137 = and i64 %83, 4294967292
%138 = and i64 %90, 1
%139 = icmp eq i64 %88, 0
%140 = and i64 %90, 9223372036854775806
%141 = icmp eq i64 %138, 0
%142 = icmp eq i64 %137, %83
%143 = and i64 %129, 1
%144 = icmp eq i64 %143, 0
%145 = sub nsw i64 0, %129
br label %458
146: ; preds = %81, %124
%147 = phi i64 [ 1, %81 ], [ %125, %124 ]
%148 = phi i64 [ 0, %81 ], [ %298, %124 ]
%149 = mul i64 %148, %83
%150 = getelementptr i32, i32* %0, i64 %149
%151 = add i64 %149, %83
%152 = getelementptr i32, i32* %0, i64 %151
%153 = getelementptr i32, i32* %1, i64 %149
%154 = getelementptr i32, i32* %1, i64 %151
%155 = mul i64 %148, %83
%156 = add i64 %155, %83
%157 = add i64 %84, %155
%158 = getelementptr i32, i32* %0, i64 %155
%159 = getelementptr i32, i32* %0, i64 %156
%160 = getelementptr i32, i32* %1, i64 %155
%161 = getelementptr i32, i32* %1, i64 %156
%162 = trunc i64 %148 to i32
%163 = trunc i64 %147 to i32
%164 = call i32 @llvm.smax.i32(i32 %2, i32 %163)
%165 = mul nsw i64 %148, %82
%166 = mul nsw i32 %162, %2
%167 = sext i32 %166 to i64
%168 = add nsw i64 %148, %167
%169 = getelementptr inbounds i32, i32* %0, i64 %168
%170 = load i32, i32* %169
%171 = icmp eq i32 %170, 0
br i1 %171, label %172, label %297
172: ; preds = %146, %176
%173 = phi i64 [ %174, %176 ], [ %148, %146 ]
%174 = add nuw nsw i64 %173, 1
%175 = icmp ult i64 %174, %82
br i1 %175, label %176, label %184
176: ; preds = %172
%177 = mul nsw i64 %174, %82
%178 = add nuw nsw i64 %177, %148
%179 = getelementptr inbounds i32, i32* %0, i64 %178
%180 = load i32, i32* %179
%181 = icmp eq i32 %180, 0
br i1 %181, label %172, label %182
182: ; preds = %176
%183 = trunc i64 %174 to i32
br label %184
184: ; preds = %172, %182
%185 = phi i32 [ %183, %182 ], [ %164, %172 ]
%186 = icmp eq i32 %185, %2
br i1 %186, label %625, label %187
187: ; preds = %184
%188 = mul nsw i32 %185, %2
%189 = sext i32 %188 to i64
br i1 %91, label %281, label %190
190: ; preds = %187
%191 = getelementptr i32, i32* %0, i64 %189
%192 = getelementptr i32, i32* %85, i64 %189
%193 = getelementptr i32, i32* %1, i64 %189
%194 = getelementptr i32, i32* %86, i64 %189
%195 = icmp ult i32* %150, %192
%196 = icmp ult i32* %191, %152
%197 = and i1 %195, %196
%198 = icmp ult i32* %150, %154
%199 = icmp ult i32* %153, %152
%200 = and i1 %198, %199
%201 = or i1 %197, %200
%202 = icmp ult i32* %150, %194
%203 = icmp ult i32* %193, %152
%204 = and i1 %202, %203
%205 = or i1 %201, %204
%206 = icmp ult i32* %191, %154
%207 = icmp ult i32* %153, %192
%208 = and i1 %206, %207
%209 = or i1 %205, %208
%210 = or i1 %209, %94
%211 = icmp ult i32* %153, %194
%212 = icmp ult i32* %193, %154
%213 = and i1 %211, %212
%214 = or i1 %210, %213
br i1 %214, label %281, label %215
215: ; preds = %190
br i1 %97, label %259, label %216
216: ; preds = %215, %216
%217 = phi i64 [ %256, %216 ], [ 0, %215 ]
%218 = phi i64 [ %257, %216 ], [ 0, %215 ]
%219 = add nuw nsw i64 %217, %165
%220 = getelementptr inbounds i32, i32* %0, i64 %219
%221 = bitcast i32* %220 to <4 x i32>*
%222 = load <4 x i32>, <4 x i32>* %221
%223 = add nsw i64 %217, %189
%224 = getelementptr inbounds i32, i32* %0, i64 %223
%225 = bitcast i32* %224 to <4 x i32>*
%226 = load <4 x i32>, <4 x i32>* %225
%227 = bitcast i32* %220 to <4 x i32>*
store <4 x i32> %226, <4 x i32>* %227
%228 = bitcast i32* %224 to <4 x i32>*
store <4 x i32> %222, <4 x i32>* %228
%229 = getelementptr inbounds i32, i32* %1, i64 %219
%230 = bitcast i32* %229 to <4 x i32>*
%231 = load <4 x i32>, <4 x i32>* %230
%232 = getelementptr inbounds i32, i32* %1, i64 %223
%233 = bitcast i32* %232 to <4 x i32>*
%234 = load <4 x i32>, <4 x i32>* %233
%235 = bitcast i32* %229 to <4 x i32>*
store <4 x i32> %234, <4 x i32>* %235
%236 = bitcast i32* %232 to <4 x i32>*
store <4 x i32> %231, <4 x i32>* %236
%237 = or i64 %217, 4
%238 = add nuw nsw i64 %237, %165
%239 = getelementptr inbounds i32, i32* %0, i64 %238
%240 = bitcast i32* %239 to <4 x i32>*
%241 = load <4 x i32>, <4 x i32>* %240
%242 = add nsw i64 %237, %189
%243 = getelementptr inbounds i32, i32* %0, i64 %242
%244 = bitcast i32* %243 to <4 x i32>*
%245 = load <4 x i32>, <4 x i32>* %244
%246 = bitcast i32* %239 to <4 x i32>*
store <4 x i32> %245, <4 x i32>* %246
%247 = bitcast i32* %243 to <4 x i32>*
store <4 x i32> %241, <4 x i32>* %247
%248 = getelementptr inbounds i32, i32* %1, i64 %238
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = getelementptr inbounds i32, i32* %1, i64 %242
%252 = bitcast i32* %251 to <4 x i32>*
%253 = load <4 x i32>, <4 x i32>* %252
%254 = bitcast i32* %248 to <4 x i32>*
store <4 x i32> %253, <4 x i32>* %254
%255 = bitcast i32* %251 to <4 x i32>*
store <4 x i32> %250, <4 x i32>* %255
%256 = add nuw i64 %217, 8
%257 = add i64 %218, 2
%258 = icmp eq i64 %257, %98
br i1 %258, label %259, label %216
259: ; preds = %216, %215
%260 = phi i64 [ 0, %215 ], [ %256, %216 ]
br i1 %99, label %280, label %261
261: ; preds = %259
%262 = add nuw nsw i64 %260, %165
%263 = getelementptr inbounds i32, i32* %0, i64 %262
%264 = bitcast i32* %263 to <4 x i32>*
%265 = load <4 x i32>, <4 x i32>* %264
%266 = add nsw i64 %260, %189
%267 = getelementptr inbounds i32, i32* %0, i64 %266
%268 = bitcast i32* %267 to <4 x i32>*
%269 = load <4 x i32>, <4 x i32>* %268
%270 = bitcast i32* %263 to <4 x i32>*
store <4 x i32> %269, <4 x i32>* %270
%271 = bitcast i32* %267 to <4 x i32>*
store <4 x i32> %265, <4 x i32>* %271
%272 = getelementptr inbounds i32, i32* %1, i64 %262
%273 = bitcast i32* %272 to <4 x i32>*
%274 = load <4 x i32>, <4 x i32>* %273
%275 = getelementptr inbounds i32, i32* %1, i64 %266
%276 = bitcast i32* %275 to <4 x i32>*
%277 = load <4 x i32>, <4 x i32>* %276
%278 = bitcast i32* %272 to <4 x i32>*
store <4 x i32> %277, <4 x i32>* %278
%279 = bitcast i32* %275 to <4 x i32>*
store <4 x i32> %274, <4 x i32>* %279
br label %280
280: ; preds = %259, %261
br i1 %100, label %297, label %281
281: ; preds = %190, %187, %280
%282 = phi i64 [ 0, %190 ], [ 0, %187 ], [ %95, %280 ]
br label %283
283: ; preds = %281, %283
%284 = phi i64 [ %295, %283 ], [ %282, %281 ]
%285 = add nuw nsw i64 %284, %165
%286 = getelementptr inbounds i32, i32* %0, i64 %285
%287 = load i32, i32* %286
%288 = add nsw i64 %284, %189
%289 = getelementptr inbounds i32, i32* %0, i64 %288
%290 = load i32, i32* %289
store i32 %290, i32* %286
store i32 %287, i32* %289
%291 = getelementptr inbounds i32, i32* %1, i64 %285
%292 = load i32, i32* %291
%293 = getelementptr inbounds i32, i32* %1, i64 %288
%294 = load i32, i32* %293
store i32 %294, i32* %291
store i32 %292, i32* %293
%295 = add nuw nsw i64 %284, 1
%296 = icmp eq i64 %295, %83
br i1 %296, label %297, label %283
297: ; preds = %283, %280, %146
%298 = add nuw nsw i64 %148, 1
%299 = icmp eq i64 %298, %83
br i1 %299, label %124, label %300
300: ; preds = %297, %451
%301 = phi i64 [ %454, %451 ], [ 0, %297 ]
%302 = phi i64 [ %452, %451 ], [ %147, %297 ]
%303 = mul i64 %301, %83
%304 = add i64 %156, %303
%305 = getelementptr i32, i32* %0, i64 %304
%306 = add i64 %157, %303
%307 = getelementptr i32, i32* %0, i64 %306
%308 = getelementptr i32, i32* %1, i64 %304
%309 = getelementptr i32, i32* %1, i64 %306
%310 = mul nsw i64 %302, %82
%311 = add nuw nsw i64 %310, %148
%312 = getelementptr inbounds i32, i32* %0, i64 %311
%313 = load i32, i32* %312
%314 = icmp eq i32 %313, 0
br i1 %314, label %451, label %315
315: ; preds = %300
br i1 %101, label %402, label %316
316: ; preds = %315
%317 = icmp ult i32* %305, %309
%318 = icmp ult i32* %308, %307
%319 = and i1 %317, %318
%320 = icmp ult i32* %305, %159
%321 = icmp ult i32* %158, %307
%322 = and i1 %320, %321
%323 = or i1 %319, %322
%324 = icmp ult i32* %305, %161
%325 = icmp ult i32* %160, %307
%326 = and i1 %324, %325
%327 = or i1 %323, %326
%328 = icmp ult i32* %308, %159
%329 = icmp ult i32* %158, %309
%330 = and i1 %328, %329
%331 = or i1 %327, %330
%332 = icmp ult i32* %308, %161
%333 = icmp ult i32* %160, %309
%334 = and i1 %332, %333
%335 = or i1 %331, %334
br i1 %335, label %402, label %336
336: ; preds = %316
br i1 %104, label %380, label %337
337: ; preds = %336, %337
%338 = phi i64 [ %377, %337 ], [ 0, %336 ]
%339 = phi i64 [ %378, %337 ], [ 0, %336 ]
%340 = add nuw nsw i64 %338, %165
%341 = getelementptr inbounds i32, i32* %0, i64 %340
%342 = bitcast i32* %341 to <4 x i32>*
%343 = load <4 x i32>, <4 x i32>* %342
%344 = add nuw nsw i64 %338, %310
%345 = getelementptr inbounds i32, i32* %0, i64 %344
%346 = bitcast i32* %345 to <4 x i32>*
%347 = load <4 x i32>, <4 x i32>* %346
%348 = xor <4 x i32> %347, %343
%349 = bitcast i32* %345 to <4 x i32>*
store <4 x i32> %348, <4 x i32>* %349
%350 = getelementptr inbounds i32, i32* %1, i64 %340
%351 = bitcast i32* %350 to <4 x i32>*
%352 = load <4 x i32>, <4 x i32>* %351
%353 = getelementptr inbounds i32, i32* %1, i64 %344
%354 = bitcast i32* %353 to <4 x i32>*
%355 = load <4 x i32>, <4 x i32>* %354
%356 = xor <4 x i32> %355, %352
%357 = bitcast i32* %353 to <4 x i32>*
store <4 x i32> %356, <4 x i32>* %357
%358 = or i64 %338, 4
%359 = add nuw nsw i64 %358, %165
%360 = getelementptr inbounds i32, i32* %0, i64 %359
%361 = bitcast i32* %360 to <4 x i32>*
%362 = load <4 x i32>, <4 x i32>* %361
%363 = add nuw nsw i64 %358, %310
%364 = getelementptr inbounds i32, i32* %0, i64 %363
%365 = bitcast i32* %364 to <4 x i32>*
%366 = load <4 x i32>, <4 x i32>* %365
%367 = xor <4 x i32> %366, %362
%368 = bitcast i32* %364 to <4 x i32>*
store <4 x i32> %367, <4 x i32>* %368
%369 = getelementptr inbounds i32, i32* %1, i64 %359
%370 = bitcast i32* %369 to <4 x i32>*
%371 = load <4 x i32>, <4 x i32>* %370
%372 = getelementptr inbounds i32, i32* %1, i64 %363
%373 = bitcast i32* %372 to <4 x i32>*
%374 = load <4 x i32>, <4 x i32>* %373
%375 = xor <4 x i32> %374, %371
%376 = bitcast i32* %372 to <4 x i32>*
store <4 x i32> %375, <4 x i32>* %376
%377 = add nuw i64 %338, 8
%378 = add i64 %339, 2
%379 = icmp eq i64 %378, %105
br i1 %379, label %380, label %337
380: ; preds = %337, %336
%381 = phi i64 [ 0, %336 ], [ %377, %337 ]
br i1 %106, label %401, label %382
382: ; preds = %380
%383 = add nuw nsw i64 %381, %165
%384 = getelementptr inbounds i32, i32* %0, i64 %383
%385 = bitcast i32* %384 to <4 x i32>*
%386 = load <4 x i32>, <4 x i32>* %385
%387 = add nuw nsw i64 %381, %310
%388 = getelementptr inbounds i32, i32* %0, i64 %387
%389 = bitcast i32* %388 to <4 x i32>*
%390 = load <4 x i32>, <4 x i32>* %389
%391 = xor <4 x i32> %390, %386
%392 = bitcast i32* %388 to <4 x i32>*
store <4 x i32> %391, <4 x i32>* %392
%393 = getelementptr inbounds i32, i32* %1, i64 %383
%394 = bitcast i32* %393 to <4 x i32>*
%395 = load <4 x i32>, <4 x i32>* %394
%396 = getelementptr inbounds i32, i32* %1, i64 %387
%397 = bitcast i32* %396 to <4 x i32>*
%398 = load <4 x i32>, <4 x i32>* %397
%399 = xor <4 x i32> %398, %395
%400 = bitcast i32* %396 to <4 x i32>*
store <4 x i32> %399, <4 x i32>* %400
br label %401
401: ; preds = %380, %382
br i1 %107, label %451, label %402
402: ; preds = %316, %315, %401
%403 = phi i64 [ 0, %316 ], [ 0, %315 ], [ %102, %401 ]
%404 = xor i64 %403, -1
br i1 %109, label %419, label %405
405: ; preds = %402
%406 = add nuw nsw i64 %403, %165
%407 = getelementptr inbounds i32, i32* %0, i64 %406
%408 = load i32, i32* %407
%409 = add nuw nsw i64 %403, %310
%410 = getelementptr inbounds i32, i32* %0, i64 %409
%411 = load i32, i32* %410
%412 = xor i32 %411, %408
store i32 %412, i32* %410
%413 = getelementptr inbounds i32, i32* %1, i64 %406
%414 = load i32, i32* %413
%415 = getelementptr inbounds i32, i32* %1, i64 %409
%416 = load i32, i32* %415
%417 = xor i32 %416, %414
store i32 %417, i32* %415
%418 = or i64 %403, 1
br label %419
419: ; preds = %405, %402
%420 = phi i64 [ %403, %402 ], [ %418, %405 ]
%421 = icmp eq i64 %404, %110
br i1 %421, label %451, label %422
422: ; preds = %419, %422
%423 = phi i64 [ %449, %422 ], [ %420, %419 ]
%424 = add nuw nsw i64 %423, %165
%425 = getelementptr inbounds i32, i32* %0, i64 %424
%426 = load i32, i32* %425
%427 = add nuw nsw i64 %423, %310
%428 = getelementptr inbounds i32, i32* %0, i64 %427
%429 = load i32, i32* %428
%430 = xor i32 %429, %426
store i32 %430, i32* %428
%431 = getelementptr inbounds i32, i32* %1, i64 %424
%432 = load i32, i32* %431
%433 = getelementptr inbounds i32, i32* %1, i64 %427
%434 = load i32, i32* %433
%435 = xor i32 %434, %432
store i32 %435, i32* %433
%436 = add nuw nsw i64 %423, 1
%437 = add nuw nsw i64 %436, %165
%438 = getelementptr inbounds i32, i32* %0, i64 %437
%439 = load i32, i32* %438
%440 = add nuw nsw i64 %436, %310
%441 = getelementptr inbounds i32, i32* %0, i64 %440
%442 = load i32, i32* %441
%443 = xor i32 %442, %439
store i32 %443, i32* %441
%444 = getelementptr inbounds i32, i32* %1, i64 %437
%445 = load i32, i32* %444
%446 = getelementptr inbounds i32, i32* %1, i64 %440
%447 = load i32, i32* %446
%448 = xor i32 %447, %445
store i32 %448, i32* %446
%449 = add nuw nsw i64 %423, 2
%450 = icmp eq i64 %449, %83
br i1 %450, label %451, label %422
451: ; preds = %419, %422, %401, %300
%452 = add nuw nsw i64 %302, 1
%453 = icmp eq i64 %452, %83
%454 = add i64 %301, 1
br i1 %453, label %124, label %300
455: ; preds = %622
%456 = add nsw i64 %461, -1
%457 = add i64 %459, 1
br i1 %470, label %458, label %625
458: ; preds = %128, %455
%459 = phi i64 [ 0, %128 ], [ %457, %455 ]
%460 = phi i64 [ %129, %128 ], [ %469, %455 ]
%461 = phi i64 [ %131, %128 ], [ %456, %455 ]
%462 = mul i64 %459, %83
%463 = sub i64 %134, %462
%464 = getelementptr i32, i32* %0, i64 %463
%465 = sub i64 %135, %462
%466 = getelementptr i32, i32* %0, i64 %465
%467 = getelementptr i32, i32* %1, i64 %463
%468 = getelementptr i32, i32* %1, i64 %465
%469 = add nsw i64 %460, -1
%470 = icmp ugt i64 %460, 1
br i1 %470, label %471, label %625
471: ; preds = %458
%472 = mul nsw i64 %469, %129
br label %473
473: ; preds = %471, %622
%474 = phi i64 [ 0, %471 ], [ %623, %622 ]
%475 = mul i64 %474, %83
%476 = getelementptr i32, i32* %0, i64 %475
%477 = add i64 %475, %83
%478 = getelementptr i32, i32* %0, i64 %477
%479 = getelementptr i32, i32* %1, i64 %475
%480 = getelementptr i32, i32* %1, i64 %477
%481 = mul nsw i64 %474, %129
%482 = add nsw i64 %481, %469
%483 = getelementptr inbounds i32, i32* %0, i64 %482
%484 = load i32, i32* %483
%485 = icmp eq i32 %484, 0
br i1 %485, label %622, label %486
486: ; preds = %473
br i1 %136, label %573, label %487
487: ; preds = %486
%488 = icmp ult i32* %476, %480
%489 = icmp ult i32* %479, %478
%490 = and i1 %488, %489
%491 = icmp ult i32* %476, %466
%492 = icmp ult i32* %464, %478
%493 = and i1 %491, %492
%494 = or i1 %490, %493
%495 = icmp ult i32* %476, %468
%496 = icmp ult i32* %467, %478
%497 = and i1 %495, %496
%498 = or i1 %494, %497
%499 = icmp ult i32* %479, %466
%500 = icmp ult i32* %464, %480
%501 = and i1 %499, %500
%502 = or i1 %498, %501
%503 = icmp ult i32* %479, %468
%504 = icmp ult i32* %467, %480
%505 = and i1 %503, %504
%506 = or i1 %502, %505
br i1 %506, label %573, label %507
507: ; preds = %487
br i1 %139, label %551, label %508
508: ; preds = %507, %508
%509 = phi i64 [ %548, %508 ], [ 0, %507 ]
%510 = phi i64 [ %549, %508 ], [ 0, %507 ]
%511 = add nsw i64 %509, %472
%512 = getelementptr inbounds i32, i32* %0, i64 %511
%513 = bitcast i32* %512 to <4 x i32>*
%514 = load <4 x i32>, <4 x i32>* %513
%515 = add nuw nsw i64 %509, %481
%516 = getelementptr inbounds i32, i32* %0, i64 %515
%517 = bitcast i32* %516 to <4 x i32>*
%518 = load <4 x i32>, <4 x i32>* %517
%519 = xor <4 x i32> %518, %514
%520 = bitcast i32* %516 to <4 x i32>*
store <4 x i32> %519, <4 x i32>* %520
%521 = getelementptr inbounds i32, i32* %1, i64 %511
%522 = bitcast i32* %521 to <4 x i32>*
%523 = load <4 x i32>, <4 x i32>* %522
%524 = getelementptr inbounds i32, i32* %1, i64 %515
%525 = bitcast i32* %524 to <4 x i32>*
%526 = load <4 x i32>, <4 x i32>* %525
%527 = xor <4 x i32> %526, %523
%528 = bitcast i32* %524 to <4 x i32>*
store <4 x i32> %527, <4 x i32>* %528
%529 = or i64 %509, 4
%530 = add nsw i64 %529, %472
%531 = getelementptr inbounds i32, i32* %0, i64 %530
%532 = bitcast i32* %531 to <4 x i32>*
%533 = load <4 x i32>, <4 x i32>* %532
%534 = add nuw nsw i64 %529, %481
%535 = getelementptr inbounds i32, i32* %0, i64 %534
%536 = bitcast i32* %535 to <4 x i32>*
%537 = load <4 x i32>, <4 x i32>* %536
%538 = xor <4 x i32> %537, %533
%539 = bitcast i32* %535 to <4 x i32>*
store <4 x i32> %538, <4 x i32>* %539
%540 = getelementptr inbounds i32, i32* %1, i64 %530
%541 = bitcast i32* %540 to <4 x i32>*
%542 = load <4 x i32>, <4 x i32>* %541
%543 = getelementptr inbounds i32, i32* %1, i64 %534
%544 = bitcast i32* %543 to <4 x i32>*
%545 = load <4 x i32>, <4 x i32>* %544
%546 = xor <4 x i32> %545, %542
%547 = bitcast i32* %543 to <4 x i32>*
store <4 x i32> %546, <4 x i32>* %547
%548 = add nuw i64 %509, 8
%549 = add i64 %510, 2
%550 = icmp eq i64 %549, %140
br i1 %550, label %551, label %508
551: ; preds = %508, %507
%552 = phi i64 [ 0, %507 ], [ %548, %508 ]
br i1 %141, label %572, label %553
553: ; preds = %551
%554 = add nsw i64 %552, %472
%555 = getelementptr inbounds i32, i32* %0, i64 %554
%556 = bitcast i32* %555 to <4 x i32>*
%557 = load <4 x i32>, <4 x i32>* %556
%558 = add nuw nsw i64 %552, %481
%559 = getelementptr inbounds i32, i32* %0, i64 %558
%560 = bitcast i32* %559 to <4 x i32>*
%561 = load <4 x i32>, <4 x i32>* %560
%562 = xor <4 x i32> %561, %557
%563 = bitcast i32* %559 to <4 x i32>*
store <4 x i32> %562, <4 x i32>* %563
%564 = getelementptr inbounds i32, i32* %1, i64 %554
%565 = bitcast i32* %564 to <4 x i32>*
%566 = load <4 x i32>, <4 x i32>* %565
%567 = getelementptr inbounds i32, i32* %1, i64 %558
%568 = bitcast i32* %567 to <4 x i32>*
%569 = load <4 x i32>, <4 x i32>* %568
%570 = xor <4 x i32> %569, %566
%571 = bitcast i32* %567 to <4 x i32>*
store <4 x i32> %570, <4 x i32>* %571
br label %572
572: ; preds = %551, %553
br i1 %142, label %622, label %573
573: ; preds = %487, %486, %572
%574 = phi i64 [ 0, %487 ], [ 0, %486 ], [ %137, %572 ]
%575 = xor i64 %574, -1
br i1 %144, label %590, label %576
576: ; preds = %573
%577 = add nsw i64 %574, %472
%578 = getelementptr inbounds i32, i32* %0, i64 %577
%579 = load i32, i32* %578
%580 = add nuw nsw i64 %574, %481
%581 = getelementptr inbounds i32, i32* %0, i64 %580
%582 = load i32, i32* %581
%583 = xor i32 %582, %579
store i32 %583, i32* %581
%584 = getelementptr inbounds i32, i32* %1, i64 %577
%585 = load i32, i32* %584
%586 = getelementptr inbounds i32, i32* %1, i64 %580
%587 = load i32, i32* %586
%588 = xor i32 %587, %585
store i32 %588, i32* %586
%589 = or i64 %574, 1
br label %590
590: ; preds = %576, %573
%591 = phi i64 [ %574, %573 ], [ %589, %576 ]
%592 = icmp eq i64 %575, %145
br i1 %592, label %622, label %593
593: ; preds = %590, %593
%594 = phi i64 [ %620, %593 ], [ %591, %590 ]
%595 = add nsw i64 %594, %472
%596 = getelementptr inbounds i32, i32* %0, i64 %595
%597 = load i32, i32* %596
%598 = add nuw nsw i64 %594, %481
%599 = getelementptr inbounds i32, i32* %0, i64 %598
%600 = load i32, i32* %599
%601 = xor i32 %600, %597
store i32 %601, i32* %599
%602 = getelementptr inbounds i32, i32* %1, i64 %595
%603 = load i32, i32* %602
%604 = getelementptr inbounds i32, i32* %1, i64 %598
%605 = load i32, i32* %604
%606 = xor i32 %605, %603
store i32 %606, i32* %604
%607 = add nuw nsw i64 %594, 1
%608 = add nsw i64 %607, %472
%609 = getelementptr inbounds i32, i32* %0, i64 %608
%610 = load i32, i32* %609
%611 = add nuw nsw i64 %607, %481
%612 = getelementptr inbounds i32, i32* %0, i64 %611
%613 = load i32, i32* %612
%614 = xor i32 %613, %610
store i32 %614, i32* %612
%615 = getelementptr inbounds i32, i32* %1, i64 %608
%616 = load i32, i32* %615
%617 = getelementptr inbounds i32, i32* %1, i64 %611
%618 = load i32, i32* %617
%619 = xor i32 %618, %616
store i32 %619, i32* %617
%620 = add nuw nsw i64 %594, 2
%621 = icmp eq i64 %620, %132
br i1 %621, label %622, label %593
622: ; preds = %590, %593, %572, %473
%623 = add nuw nsw i64 %474, 1
%624 = icmp eq i64 %623, %461
br i1 %624, label %455, label %473
625: ; preds = %184, %455, %458, %3, %80, %127
%626 = phi i32 [ 0, %127 ], [ 0, %80 ], [ 0, %3 ], [ 0, %458 ], [ 0, %455 ], [ -1, %184 ]
ret i32 %626
}