int AddRoundKey_InversMixColumn(int statemt[32], int word[4][120], int nb,
                                int n) {
  int ret[8 * 4], i, j;
  int x;
#pragma unroll
  for (j = 0; j < nb; ++j) {
    statemt[j * 4] ^= word[0][j + nb * n];
    statemt[1 + j * 4] ^= word[1][j + nb * n];
    statemt[2 + j * 4] ^= word[2][j + nb * n];
    statemt[3 + j * 4] ^= word[3][j + nb * n];
  }
  for (j = 0; j < nb; ++j)
    for (i = 0; i < 4; ++i) {
      x = (statemt[i + j * 4] << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[i + j * 4];
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[i + j * 4];
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      ret[i + j * 4] = x;
      x = (statemt[(i + 1) % 4 + j * 4] << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[(i + 1) % 4 + j * 4];
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[(i + 1) % 4 + j * 4];
      ret[i + j * 4] ^= x;
      x = (statemt[(i + 2) % 4 + j * 4] << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[(i + 2) % 4 + j * 4];
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[(i + 2) % 4 + j * 4];
      ret[i + j * 4] ^= x;
      x = (statemt[(i + 3) % 4 + j * 4] << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x = (x << 1);
      if ((x >> 8) == 1)
        x ^= 283;
      x ^= statemt[(i + 3) % 4 + j * 4];
      ret[i + j * 4] ^= x;
    }
#pragma unroll
  for (i = 0; i < nb; ++i) {
    statemt[i * 4] = ret[i * 4];
    statemt[1 + i * 4] = ret[1 + i * 4];
    statemt[2 + i * 4] = ret[2 + i * 4];
    statemt[3 + i * 4] = ret[3 + i * 4];
  }
  return 0;
}


x86 assembly (clang, -O0):
<AddRoundKey_InversMixColumn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1214 <AddRoundKey_InversMixColumn+0x114>
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    0x1e0(%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    0x3c0(%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    0x5a0(%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1120 <AddRoundKey_InversMixColumn+0x20>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    178b <AddRoundKey_InversMixColumn+0x68b>
movl   $0x0,-0xa4(%rbp)
cmpl   $0x4,-0xa4(%rbp)
jge    1772 <AddRoundKey_InversMixColumn+0x672>
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    128b <AddRoundKey_InversMixColumn+0x18b>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    12e4 <AddRoundKey_InversMixColumn+0x1e4>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    133d <AddRoundKey_InversMixColumn+0x23d>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%eax
cltq
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xb8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    13bd <AddRoundKey_InversMixColumn+0x2bd>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    13ef <AddRoundKey_InversMixColumn+0x2ef>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xc0(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1461 <AddRoundKey_InversMixColumn+0x361>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xd0(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x2,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xc8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1528 <AddRoundKey_InversMixColumn+0x428>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x2,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xd8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    159a <AddRoundKey_InversMixColumn+0x49a>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    15cc <AddRoundKey_InversMixColumn+0x4cc>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x2,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xe8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x3,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xe0(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1693 <AddRoundKey_InversMixColumn+0x593>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    16c5 <AddRoundKey_InversMixColumn+0x5c5>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    16f7 <AddRoundKey_InversMixColumn+0x5f7>
mov    -0xac(%rbp),%eax
xor    $0x11b,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x3,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    -0xf0(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%edx
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1237 <AddRoundKey_InversMixColumn+0x137>
jmp    1777 <AddRoundKey_InversMixColumn+0x677>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    121e <AddRoundKey_InversMixColumn+0x11e>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    185e <AddRoundKey_InversMixColumn+0x75e>
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1795 <AddRoundKey_InversMixColumn+0x695>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AddRoundKey_InversMixColumn>:
push   %rax
test   %edx,%edx
jle    1453 <AddRoundKey_InversMixColumn+0x353>
imul   %edx,%ecx
movslq %ecx,%rax
mov    %edx,%r8d
lea    (%rsi,%rax,4),%rax
lea    0x0(,%r8,4),%r9
xor    %esi,%esi
mov    (%rax,%rsi,1),%ecx
xor    %ecx,(%rdi,%rsi,4)
mov    0x1e0(%rax,%rsi,1),%ecx
xor    %ecx,0x4(%rdi,%rsi,4)
mov    0x3c0(%rax,%rsi,1),%ecx
xor    %ecx,0x8(%rdi,%rsi,4)
mov    0x5a0(%rax,%rsi,1),%ecx
xor    %ecx,0xc(%rdi,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1120 <AddRoundKey_InversMixColumn+0x20>
test   %edx,%edx
jle    1453 <AddRoundKey_InversMixColumn+0x353>
xor    %eax,%eax
movdqa 0xe9d(%rip),%xmm8
movdqa 0xea4(%rip),%xmm9
movdqa 0xeab(%rip),%xmm10
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%esi
and    $0xfffffffc,%esi
movdqu (%rdi,%rax,4),%xmm3
movdqa %xmm3,%xmm4
paddd  %xmm3,%xmm4
movdqa %xmm3,%xmm5
pand   %xmm8,%xmm5
pcmpeqd %xmm9,%xmm5
movdqa %xmm5,%xmm6
pandn  %xmm4,%xmm6
pxor   %xmm10,%xmm4
pand   %xmm5,%xmm4
por    %xmm6,%xmm4
pxor   %xmm3,%xmm4
movdqa %xmm4,%xmm5
paddd  %xmm4,%xmm5
pand   %xmm8,%xmm4
pcmpeqd %xmm9,%xmm4
movdqa %xmm4,%xmm6
pandn  %xmm5,%xmm6
pxor   %xmm10,%xmm5
pand   %xmm4,%xmm5
por    %xmm6,%xmm5
pxor   %xmm3,%xmm5
movdqa %xmm5,%xmm3
paddd  %xmm5,%xmm3
pand   %xmm8,%xmm5
pcmpeqd %xmm9,%xmm5
movdqa %xmm5,%xmm4
pandn  %xmm3,%xmm4
pxor   %xmm10,%xmm3
pand   %xmm5,%xmm3
por    %xmm4,%xmm3
movdqu (%rdi,%rsi,4),%xmm5
pshufd $0x39,%xmm5,%xmm1
pshufd $0x4e,%xmm5,%xmm6
pshufd $0x93,%xmm5,%xmm7
paddd  %xmm5,%xmm5
pshufd $0x39,%xmm5,%xmm0
movdqa %xmm1,%xmm4
pand   %xmm8,%xmm4
pcmpeqd %xmm9,%xmm4
movdqa %xmm4,%xmm2
pandn  %xmm0,%xmm2
pxor   %xmm10,%xmm0
pand   %xmm4,%xmm0
por    %xmm2,%xmm0
movdqa %xmm0,%xmm2
paddd  %xmm0,%xmm2
pand   %xmm8,%xmm0
pcmpeqd %xmm9,%xmm0
movdqa %xmm0,%xmm4
pandn  %xmm2,%xmm4
pxor   %xmm10,%xmm2
pand   %xmm0,%xmm2
por    %xmm4,%xmm2
pxor   %xmm1,%xmm2
movdqa %xmm2,%xmm0
paddd  %xmm2,%xmm0
pand   %xmm8,%xmm2
pcmpeqd %xmm9,%xmm2
movdqa %xmm2,%xmm4
pandn  %xmm0,%xmm4
pxor   %xmm10,%xmm0
pand   %xmm2,%xmm0
por    %xmm4,%xmm0
pxor   %xmm1,%xmm3
pxor   %xmm0,%xmm3
pshufd $0x4e,%xmm5,%xmm0
movdqa %xmm6,%xmm1
pand   %xmm8,%xmm1
pcmpeqd %xmm9,%xmm1
movdqa %xmm1,%xmm2
pandn  %xmm0,%xmm2
pxor   %xmm10,%xmm0
pand   %xmm1,%xmm0
por    %xmm2,%xmm0
pxor   %xmm6,%xmm0
movdqa %xmm0,%xmm1
paddd  %xmm0,%xmm1
pand   %xmm8,%xmm0
pcmpeqd %xmm9,%xmm0
movdqa %xmm0,%xmm2
pandn  %xmm1,%xmm2
pxor   %xmm10,%xmm1
pand   %xmm0,%xmm1
por    %xmm2,%xmm1
movdqa %xmm1,%xmm0
paddd  %xmm1,%xmm0
pand   %xmm8,%xmm1
pcmpeqd %xmm9,%xmm1
movdqa %xmm1,%xmm2
pandn  %xmm0,%xmm2
pxor   %xmm10,%xmm0
pand   %xmm1,%xmm0
por    %xmm2,%xmm0
pxor   %xmm6,%xmm0
pxor   %xmm3,%xmm0
pshufd $0x93,%xmm5,%xmm1
movdqa %xmm7,%xmm2
pand   %xmm8,%xmm2
pcmpeqd %xmm9,%xmm2
movdqa %xmm2,%xmm3
pandn  %xmm1,%xmm3
pxor   %xmm10,%xmm1
pand   %xmm2,%xmm1
por    %xmm3,%xmm1
movdqa %xmm1,%xmm2
paddd  %xmm1,%xmm2
pand   %xmm8,%xmm1
pcmpeqd %xmm9,%xmm1
movdqa %xmm1,%xmm3
pandn  %xmm2,%xmm3
pxor   %xmm10,%xmm2
pand   %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm2,%xmm1
paddd  %xmm2,%xmm1
pand   %xmm8,%xmm2
pcmpeqd %xmm9,%xmm2
movdqa %xmm2,%xmm3
pandn  %xmm1,%xmm3
pxor   %xmm10,%xmm1
pand   %xmm2,%xmm1
por    %xmm3,%xmm1
pxor   %xmm7,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm1,-0x80(%rsp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r9
jne    1180 <AddRoundKey_InversMixColumn+0x80>
test   %edx,%edx
jle    1453 <AddRoundKey_InversMixColumn+0x353>
lea    -0x1(%r8),%rax
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    13d4 <AddRoundKey_InversMixColumn+0x2d4>
xor    %eax,%eax
jmp    141f <AddRoundKey_InversMixColumn+0x31f>
and    $0xfffffffc,%r8d
mov    $0x30,%edx
xor    %eax,%eax
nop
movaps -0xb0(%rsp,%rdx,1),%xmm0
ff
movups %xmm0,-0x30(%rdi,%rdx,1)
movaps -0xa0(%rsp,%rdx,1),%xmm0
ff
movups %xmm0,-0x20(%rdi,%rdx,1)
movaps -0x90(%rsp,%rdx,1),%xmm0
ff
movups %xmm0,-0x10(%rdi,%rdx,1)
movdqa -0x80(%rsp,%rdx,1),%xmm0
movdqu %xmm0,(%rdi,%rdx,1)
add    $0x4,%rax
add    $0x40,%rdx
cmp    %rax,%r8
jne    13e0 <AddRoundKey_InversMixColumn+0x2e0>
test   %rcx,%rcx
je     1453 <AddRoundKey_InversMixColumn+0x353>
shl    $0x4,%rax
add    %rax,%rdi
add    %rsp,%rax
add    $0xffffffffffffff80,%rax
shl    $0x4,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqa (%rax,%rdx,1),%xmm0
movdqu %xmm0,(%rdi,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    1440 <AddRoundKey_InversMixColumn+0x340>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
define i32 @AddRoundKey_InversMixColumn(i32* nocapture %0, [120 x i32]* nocapture %1, i32 %2, i32 %3) {
%5 = alloca [32 x i32]
%6 = bitcast [32 x i32]* %5 to i8*
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %194
8: ; preds = %4
%9 = mul nsw i32 %3, %2
%10 = sext i32 %9 to i64
%11 = zext i32 %2 to i64
br label %15
12: ; preds = %15
br i1 %7, label %13, label %194
13: ; preds = %12
%14 = zext i32 %2 to i64
br label %44
15: ; preds = %8, %15
%16 = phi i64 [ 0, %8 ], [ %42, %15 ]
%17 = add nsw i64 %16, %10
%18 = getelementptr inbounds [120 x i32], [120 x i32]* %1, i64 0, i64 %17
%19 = load i32, i32* %18
%20 = shl nsw i64 %16, 2
%21 = getelementptr inbounds i32, i32* %0, i64 %20
%22 = load i32, i32* %21
%23 = xor i32 %22, %19
store i32 %23, i32* %21
%24 = getelementptr inbounds [120 x i32], [120 x i32]* %1, i64 1, i64 %17
%25 = load i32, i32* %24
%26 = or i64 %20, 1
%27 = getelementptr inbounds i32, i32* %0, i64 %26
%28 = load i32, i32* %27
%29 = xor i32 %28, %25
store i32 %29, i32* %27
%30 = getelementptr inbounds [120 x i32], [120 x i32]* %1, i64 2, i64 %17
%31 = load i32, i32* %30
%32 = or i64 %20, 2
%33 = getelementptr inbounds i32, i32* %0, i64 %32
%34 = load i32, i32* %33
%35 = xor i32 %34, %31
store i32 %35, i32* %33
%36 = getelementptr inbounds [120 x i32], [120 x i32]* %1, i64 3, i64 %17
%37 = load i32, i32* %36
%38 = or i64 %20, 3
%39 = getelementptr inbounds i32, i32* %0, i64 %38
%40 = load i32, i32* %39
%41 = xor i32 %40, %37
store i32 %41, i32* %39
%42 = add nuw nsw i64 %16, 1
%43 = icmp eq i64 %42, %11
br i1 %43, label %12, label %15
44: ; preds = %13, %44
%45 = phi i64 [ 0, %13 ], [ %137, %44 ]
%46 = shl nsw i64 %45, 2
%47 = and i64 %46, 4294967292
%48 = and i64 %46, 4294967292
%49 = and i64 %46, 4294967292
%50 = getelementptr inbounds i32, i32* %0, i64 %46
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = shl <4 x i32> %52, <i32 1, i32 1, i32 1, i32 1>
%54 = and <4 x i32> %52, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%55 = icmp eq <4 x i32> %54, <i32 128, i32 128, i32 128, i32 128>
%56 = xor <4 x i32> %53, <i32 283, i32 283, i32 283, i32 283>
%57 = select <4 x i1> %55, <4 x i32> %56, <4 x i32> %53
%58 = xor <4 x i32> %57, %52
%59 = shl <4 x i32> %58, <i32 1, i32 1, i32 1, i32 1>
%60 = and <4 x i32> %58, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%61 = icmp eq <4 x i32> %60, <i32 128, i32 128, i32 128, i32 128>
%62 = xor <4 x i32> %59, <i32 283, i32 283, i32 283, i32 283>
%63 = select <4 x i1> %61, <4 x i32> %62, <4 x i32> %59
%64 = xor <4 x i32> %63, %52
%65 = shl <4 x i32> %64, <i32 1, i32 1, i32 1, i32 1>
%66 = and <4 x i32> %64, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%67 = icmp eq <4 x i32> %66, <i32 128, i32 128, i32 128, i32 128>
%68 = xor <4 x i32> %65, <i32 283, i32 283, i32 283, i32 283>
%69 = select <4 x i1> %67, <4 x i32> %68, <4 x i32> %65
%70 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %46
%71 = getelementptr inbounds i32, i32* %0, i64 %49
%72 = bitcast i32* %71 to <4 x i32>*
%73 = load <4 x i32>, <4 x i32>* %72
%74 = shufflevector <4 x i32> %73, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
%75 = shl <4 x i32> %74, <i32 1, i32 1, i32 1, i32 1>
%76 = and <4 x i32> %74, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%77 = icmp eq <4 x i32> %76, <i32 128, i32 128, i32 128, i32 128>
%78 = xor <4 x i32> %75, <i32 283, i32 283, i32 283, i32 283>
%79 = select <4 x i1> %77, <4 x i32> %78, <4 x i32> %75
%80 = shl <4 x i32> %79, <i32 1, i32 1, i32 1, i32 1>
%81 = and <4 x i32> %79, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%82 = icmp eq <4 x i32> %81, <i32 128, i32 128, i32 128, i32 128>
%83 = xor <4 x i32> %80, <i32 283, i32 283, i32 283, i32 283>
%84 = select <4 x i1> %82, <4 x i32> %83, <4 x i32> %80
%85 = xor <4 x i32> %84, %74
%86 = shl <4 x i32> %85, <i32 1, i32 1, i32 1, i32 1>
%87 = and <4 x i32> %85, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%88 = icmp eq <4 x i32> %87, <i32 128, i32 128, i32 128, i32 128>
%89 = xor <4 x i32> %86, <i32 283, i32 283, i32 283, i32 283>
%90 = select <4 x i1> %88, <4 x i32> %89, <4 x i32> %86
%91 = xor <4 x i32> %69, %74
%92 = xor <4 x i32> %91, %90
%93 = getelementptr inbounds i32, i32* %0, i64 %48
%94 = bitcast i32* %93 to <4 x i32>*
%95 = load <4 x i32>, <4 x i32>* %94
%96 = shufflevector <4 x i32> %95, <4 x i32> poison, <4 x i32> <i32 2, i32 3, i32 0, i32 1>
%97 = shl <4 x i32> %96, <i32 1, i32 1, i32 1, i32 1>
%98 = and <4 x i32> %96, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%99 = icmp eq <4 x i32> %98, <i32 128, i32 128, i32 128, i32 128>
%100 = xor <4 x i32> %97, <i32 283, i32 283, i32 283, i32 283>
%101 = select <4 x i1> %99, <4 x i32> %100, <4 x i32> %97
%102 = xor <4 x i32> %101, %96
%103 = shl <4 x i32> %102, <i32 1, i32 1, i32 1, i32 1>
%104 = and <4 x i32> %102, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%105 = icmp eq <4 x i32> %104, <i32 128, i32 128, i32 128, i32 128>
%106 = xor <4 x i32> %103, <i32 283, i32 283, i32 283, i32 283>
%107 = select <4 x i1> %105, <4 x i32> %106, <4 x i32> %103
%108 = shl <4 x i32> %107, <i32 1, i32 1, i32 1, i32 1>
%109 = and <4 x i32> %107, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%110 = icmp eq <4 x i32> %109, <i32 128, i32 128, i32 128, i32 128>
%111 = xor <4 x i32> %108, <i32 283, i32 283, i32 283, i32 283>
%112 = select <4 x i1> %110, <4 x i32> %111, <4 x i32> %108
%113 = xor <4 x i32> %112, %96
%114 = xor <4 x i32> %113, %92
%115 = getelementptr inbounds i32, i32* %0, i64 %47
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = shufflevector <4 x i32> %117, <4 x i32> poison, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%119 = shl <4 x i32> %118, <i32 1, i32 1, i32 1, i32 1>
%120 = and <4 x i32> %118, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%121 = icmp eq <4 x i32> %120, <i32 128, i32 128, i32 128, i32 128>
%122 = xor <4 x i32> %119, <i32 283, i32 283, i32 283, i32 283>
%123 = select <4 x i1> %121, <4 x i32> %122, <4 x i32> %119
%124 = shl <4 x i32> %123, <i32 1, i32 1, i32 1, i32 1>
%125 = and <4 x i32> %123, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%126 = icmp eq <4 x i32> %125, <i32 128, i32 128, i32 128, i32 128>
%127 = xor <4 x i32> %124, <i32 283, i32 283, i32 283, i32 283>
%128 = select <4 x i1> %126, <4 x i32> %127, <4 x i32> %124
%129 = shl <4 x i32> %128, <i32 1, i32 1, i32 1, i32 1>
%130 = and <4 x i32> %128, <i32 2147483520, i32 2147483520, i32 2147483520, i32 2147483520>
%131 = icmp eq <4 x i32> %130, <i32 128, i32 128, i32 128, i32 128>
%132 = xor <4 x i32> %129, <i32 283, i32 283, i32 283, i32 283>
%133 = select <4 x i1> %131, <4 x i32> %132, <4 x i32> %129
%134 = xor <4 x i32> %133, %118
%135 = xor <4 x i32> %134, %114
%136 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %135, <4 x i32>* %136
%137 = add nuw nsw i64 %45, 1
%138 = icmp eq i64 %137, %14
br i1 %138, label %139, label %44
139: ; preds = %44
br i1 %7, label %140, label %194
140: ; preds = %139
%141 = add nsw i64 %11, -1
%142 = and i64 %11, 3
%143 = icmp ult i64 %141, 3
br i1 %143, label %179, label %144
144: ; preds = %140
%145 = and i64 %11, 4294967292
br label %146
146: ; preds = %146, %144
%147 = phi i64 [ 0, %144 ], [ %176, %146 ]
%148 = phi i64 [ 0, %144 ], [ %177, %146 ]
%149 = shl nsw i64 %147, 2
%150 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %149
%151 = getelementptr inbounds i32, i32* %0, i64 %149
%152 = bitcast i32* %150 to <4 x i32>*
%153 = load <4 x i32>, <4 x i32>* %152
%154 = bitcast i32* %151 to <4 x i32>*
store <4 x i32> %153, <4 x i32>* %154
%155 = shl i64 %147, 2
%156 = or i64 %155, 4
%157 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %156
%158 = getelementptr inbounds i32, i32* %0, i64 %156
%159 = bitcast i32* %157 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = bitcast i32* %158 to <4 x i32>*
store <4 x i32> %160, <4 x i32>* %161
%162 = shl i64 %147, 2
%163 = or i64 %162, 8
%164 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %163
%165 = getelementptr inbounds i32, i32* %0, i64 %163
%166 = bitcast i32* %164 to <4 x i32>*
%167 = load <4 x i32>, <4 x i32>* %166
%168 = bitcast i32* %165 to <4 x i32>*
store <4 x i32> %167, <4 x i32>* %168
%169 = shl i64 %147, 2
%170 = or i64 %169, 12
%171 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %170
%172 = getelementptr inbounds i32, i32* %0, i64 %170
%173 = bitcast i32* %171 to <4 x i32>*
%174 = load <4 x i32>, <4 x i32>* %173
%175 = bitcast i32* %172 to <4 x i32>*
store <4 x i32> %174, <4 x i32>* %175
%176 = add nuw nsw i64 %147, 4
%177 = add i64 %148, 4
%178 = icmp eq i64 %177, %145
br i1 %178, label %179, label %146
179: ; preds = %146, %140
%180 = phi i64 [ 0, %140 ], [ %176, %146 ]
%181 = icmp eq i64 %142, 0
br i1 %181, label %194, label %182
182: ; preds = %179, %182
%183 = phi i64 [ %191, %182 ], [ %180, %179 ]
%184 = phi i64 [ %192, %182 ], [ 0, %179 ]
%185 = shl nsw i64 %183, 2
%186 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %185
%187 = getelementptr inbounds i32, i32* %0, i64 %185
%188 = bitcast i32* %186 to <4 x i32>*
%189 = load <4 x i32>, <4 x i32>* %188
%190 = bitcast i32* %187 to <4 x i32>*
store <4 x i32> %189, <4 x i32>* %190
%191 = add nuw nsw i64 %183, 1
%192 = add i64 %184, 1
%193 = icmp eq i64 %192, %142
br i1 %193, label %194, label %182
194: ; preds = %179, %182, %4, %12, %139
ret i32 0
}