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


x86 assembly (clang, -O0):
<MixColumn_AddRoundKey>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16c1 <MixColumn_AddRoundKey+0x5c1>
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1194 <MixColumn_AddRoundKey+0x94>
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%ecx
xor    $0x11b,%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1,%eax
xor    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1201 <MixColumn_AddRoundKey+0x101>
mov    -0xa8(%rbp),%ecx
xor    $0x11b,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
jmp    1220 <MixColumn_AddRoundKey+0x120>
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%edx
shl    $0x2,%edx
add    $0x3,%edx
movslq %edx,%rdx
xor    (%rax,%rdx,4),%ecx
mov    -0x18(%rbp),%rax
mov    -0xa4(%rbp),%edx
mov    -0xc(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
xor    (%rax,%rdx,4),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    12ef <MixColumn_AddRoundKey+0x1ef>
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%ecx
xor    $0x11b,%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1,%eax
xor    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    135f <MixColumn_AddRoundKey+0x25f>
mov    -0xa8(%rbp),%ecx
xor    $0x11b,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
jmp    1381 <MixColumn_AddRoundKey+0x281>
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%edx
shl    $0x2,%edx
movslq %edx,%rdx
xor    (%rax,%rdx,4),%ecx
mov    -0x18(%rbp),%rax
mov    -0xa4(%rbp),%edx
mov    -0xc(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
xor    0x1e0(%rax,%rdx,4),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1454 <MixColumn_AddRoundKey+0x354>
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%ecx
xor    $0x11b,%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1,%eax
xor    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    14c4 <MixColumn_AddRoundKey+0x3c4>
mov    -0xa8(%rbp),%ecx
xor    $0x11b,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
jmp    14e6 <MixColumn_AddRoundKey+0x3e6>
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%edx
shl    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rdx
xor    (%rax,%rdx,4),%ecx
mov    -0x18(%rbp),%rax
mov    -0xa4(%rbp),%edx
mov    -0xc(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
xor    0x3c0(%rax,%rdx,4),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    15b9 <MixColumn_AddRoundKey+0x4b9>
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
mov    -0xa0(%rbp,%rax,4),%ecx
xor    $0x11b,%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1,%eax
xor    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
sar    $0x8,%eax
cmp    $0x1,%eax
jne    1626 <MixColumn_AddRoundKey+0x526>
mov    -0xa8(%rbp),%ecx
xor    $0x11b,%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
jmp    1648 <MixColumn_AddRoundKey+0x548>
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
xor    -0xa0(%rbp,%rax,4),%ecx
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%edx
shl    $0x2,%edx
add    $0x2,%edx
movslq %edx,%rdx
xor    (%rax,%rdx,4),%ecx
mov    -0x18(%rbp),%rax
mov    -0xa4(%rbp),%edx
mov    -0xc(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
xor    0x5a0(%rax,%rdx,4),%ecx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%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    1120 <MixColumn_AddRoundKey+0x20>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1794 <MixColumn_AddRoundKey+0x694>
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    16cb <MixColumn_AddRoundKey+0x5cb>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MixColumn_AddRoundKey>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %esi,%esi
jle    15f3 <MixColumn_AddRoundKey+0x4f3>
imul   %esi,%ecx
movslq %ecx,%r8
mov    %esi,%r9d
cmp    $0x4,%esi
jae    1129 <MixColumn_AddRoundKey+0x29>
xor    %r14d,%r14d
jmp    13ee <MixColumn_AddRoundKey+0x2ee>
mov    %r9d,%r14d
and    $0xfffffffc,%r14d
lea    (%rdx,%r8,4),%r11
lea    0x0(,%r9,4),%r10
and    $0xfffffffffffffff0,%r10
xor    %eax,%eax
movdqa 0xeb5(%rip),%xmm9
movdqa 0xebc(%rip),%xmm12
movdqa 0xec3(%rip),%xmm10
nopl   (%rax)
movdqu (%rdi,%rax,4),%xmm5
movdqu 0x10(%rdi,%rax,4),%xmm0
movdqu 0x20(%rdi,%rax,4),%xmm2
movdqu 0x30(%rdi,%rax,4),%xmm3
movdqa %xmm2,%xmm4
punpckldq %xmm3,%xmm4
movdqa %xmm5,%xmm1
punpckldq %xmm0,%xmm1
movdqa %xmm1,%xmm13
punpcklqdq %xmm4,%xmm13
punpckhqdq %xmm4,%xmm1
punpckhdq %xmm3,%xmm2
punpckhdq %xmm0,%xmm5
movdqa %xmm5,%xmm14
punpcklqdq %xmm2,%xmm14
punpckhqdq %xmm2,%xmm5
movdqa %xmm13,%xmm6
paddd  %xmm13,%xmm6
movdqa %xmm13,%xmm2
pand   %xmm9,%xmm2
pcmpeqd %xmm12,%xmm2
movdqa %xmm6,%xmm0
pxor   %xmm10,%xmm0
pand   %xmm2,%xmm0
pandn  %xmm6,%xmm2
por    %xmm0,%xmm2
movdqa %xmm1,%xmm0
paddd  %xmm1,%xmm0
movdqa %xmm0,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm4,%xmm3
movdqa 0xe3a(%rip),%xmm11
pand   %xmm11,%xmm3
movdqa 0xe3c(%rip),%xmm11
pcmpeqd %xmm11,%xmm3
pxor   %xmm2,%xmm4
movdqa %xmm3,%xmm2
pandn  %xmm4,%xmm2
pxor   %xmm10,%xmm4
pand   %xmm3,%xmm4
por    %xmm2,%xmm4
movdqa %xmm5,%xmm2
pxor   %xmm14,%xmm2
movdqu (%r11,%rax,1),%xmm3
pxor   %xmm2,%xmm3
pxor   %xmm4,%xmm3
movdqa %xmm14,%xmm2
paddd  %xmm14,%xmm2
movdqa %xmm2,%xmm7
pxor   %xmm14,%xmm7
movdqa %xmm14,%xmm4
movdqa %xmm1,%xmm15
pxor   %xmm1,%xmm14
pand   %xmm9,%xmm1
pcmpeqd %xmm12,%xmm1
movdqa %xmm1,%xmm8
pandn  %xmm0,%xmm8
pxor   %xmm10,%xmm0
pand   %xmm1,%xmm0
por    %xmm8,%xmm0
movdqa %xmm7,%xmm1
movdqa 0xda6(%rip),%xmm8
pand   %xmm8,%xmm1
pcmpeqd %xmm11,%xmm1
pxor   %xmm0,%xmm7
movdqa %xmm1,%xmm0
pandn  %xmm7,%xmm0
pxor   %xmm10,%xmm7
pand   %xmm1,%xmm7
movdqu 0x1e0(%r11,%rax,1),%xmm1
por    %xmm0,%xmm7
movdqa %xmm5,%xmm0
pxor   %xmm13,%xmm0
pxor   %xmm1,%xmm0
pxor   %xmm7,%xmm0
pand   %xmm9,%xmm4
pcmpeqd %xmm12,%xmm4
movdqa %xmm4,%xmm1
pandn  %xmm2,%xmm1
pxor   %xmm10,%xmm2
pand   %xmm4,%xmm2
por    %xmm1,%xmm2
movdqa %xmm5,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm1,%xmm4
pxor   %xmm5,%xmm4
movdqa %xmm4,%xmm7
pand   %xmm8,%xmm7
pcmpeqd %xmm11,%xmm7
pxor   %xmm2,%xmm4
movdqa %xmm7,%xmm2
pandn  %xmm4,%xmm2
pxor   %xmm10,%xmm4
pand   %xmm7,%xmm4
por    %xmm2,%xmm4
pxor   %xmm13,%xmm15
movdqu 0x3c0(%r11,%rax,1),%xmm2
pxor   %xmm15,%xmm2
pxor   %xmm4,%xmm2
pand   %xmm9,%xmm5
pcmpeqd %xmm12,%xmm5
movdqa %xmm5,%xmm4
pandn  %xmm1,%xmm4
pxor   %xmm10,%xmm1
pand   %xmm5,%xmm1
por    %xmm4,%xmm1
pxor   %xmm13,%xmm6
pxor   %xmm6,%xmm1
pand   %xmm8,%xmm6
pcmpeqd %xmm11,%xmm6
movdqa %xmm6,%xmm4
pandn  %xmm1,%xmm4
pxor   %xmm10,%xmm1
pand   %xmm6,%xmm1
por    %xmm4,%xmm1
movdqu 0x5a0(%r11,%rax,1),%xmm4
pxor   %xmm14,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm2,%xmm1
punpckldq %xmm4,%xmm1
movdqa %xmm3,%xmm5
punpckldq %xmm0,%xmm5
movdqa %xmm5,%xmm6
punpckhqdq %xmm1,%xmm6
punpcklqdq %xmm1,%xmm5
punpckhdq %xmm4,%xmm2
punpckhdq %xmm0,%xmm3
movdqa %xmm3,%xmm0
punpckhqdq %xmm2,%xmm0
punpcklqdq %xmm2,%xmm3
movdqa %xmm3,-0x60(%rsp,%rax,4)
movdqa %xmm0,-0x50(%rsp,%rax,4)
movdqa %xmm5,-0x80(%rsp,%rax,4)
movdqa %xmm6,-0x70(%rsp,%rax,4)
add    $0x10,%rax
cmp    %rax,%r10
jne    1160 <MixColumn_AddRoundKey+0x60>
cmp    %r9,%r14
je     1559 <MixColumn_AddRoundKey+0x459>
lea    (%rdx,%r8,4),%r8
mov    %r9,%r10
sub    %r14,%r10
shl    $0x2,%r14
nopl   0x0(%rax)
mov    (%rdi,%r14,4),%r15d
mov    0x4(%rdi,%r14,4),%r11d
lea    (%r15,%r15,1),%r12d
mov    %r15d,%ecx
and    $0x7fffff80,%ecx
mov    %r12d,%ebx
xor    $0x11b,%ebx
cmp    $0x80,%ecx
cmovne %r12d,%ebx
lea    (%r11,%r11,1),%ebp
mov    %ebp,%ecx
xor    %r11d,%ecx
mov    %ecx,%eax
and    $0xffffff00,%eax
xor    %ebx,%ecx
mov    %ecx,%edx
xor    $0x11b,%edx
cmp    $0x100,%eax
cmovne %ecx,%edx
mov    0x8(%rdi,%r14,4),%ebx
mov    0xc(%rdi,%r14,4),%ecx
mov    %ecx,%eax
xor    %ebx,%eax
xor    (%r8,%r14,1),%eax
xor    %edx,%eax
mov    %eax,-0x80(%rsp,%r14,4)
mov    %r11d,%eax
and    $0x7fffff80,%eax
mov    %ebp,%edx
xor    $0x11b,%edx
cmp    $0x80,%eax
cmovne %ebp,%edx
lea    (%rbx,%rbx,1),%r13d
mov    %r13d,%ebp
xor    %ebx,%ebp
mov    %ebp,%eax
and    $0xffffff00,%eax
xor    %edx,%ebp
mov    %ebp,%edx
xor    $0x11b,%edx
cmp    $0x100,%eax
cmovne %ebp,%edx
mov    %ecx,%eax
xor    %r15d,%eax
xor    %edx,%eax
xor    0x1e0(%r8,%r14,1),%eax
mov    %eax,-0x7c(%rsp,%r14,4)
mov    %ebx,%eax
and    $0x7fffff80,%eax
mov    %r13d,%edx
xor    $0x11b,%edx
cmp    $0x80,%eax
cmovne %r13d,%edx
lea    (%rcx,%rcx,1),%r13d
mov    %r13d,%ebp
xor    %ecx,%ebp
mov    %ebp,%eax
and    $0xffffff00,%eax
xor    %edx,%ebp
mov    %ebp,%edx
xor    $0x11b,%edx
cmp    $0x100,%eax
cmovne %ebp,%edx
mov    %r11d,%eax
xor    %r15d,%eax
xor    %edx,%eax
xor    0x3c0(%r8,%r14,1),%eax
and    $0x7fffff80,%ecx
mov    %r13d,%edx
xor    $0x11b,%edx
cmp    $0x80,%ecx
cmovne %r13d,%edx
mov    %eax,-0x78(%rsp,%r14,4)
xor    %r15d,%r12d
xor    %r12d,%edx
and    $0xffffff00,%r12d
mov    %edx,%eax
xor    $0x11b,%eax
cmp    $0x100,%r12d
cmovne %edx,%eax
xor    %r11d,%ebx
xor    %eax,%ebx
xor    0x5a0(%r8,%r14,1),%ebx
mov    %ebx,-0x74(%rsp,%r14,4)
add    $0x4,%r14
add    $0xffffffffffffffff,%r10
jne    1400 <MixColumn_AddRoundKey+0x300>
test   %esi,%esi
jle    15f3 <MixColumn_AddRoundKey+0x4f3>
lea    -0x1(%r9),%rcx
mov    %r9d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1575 <MixColumn_AddRoundKey+0x475>
xor    %ecx,%ecx
jmp    15bf <MixColumn_AddRoundKey+0x4bf>
and    $0xfffffffc,%r9d
mov    $0x30,%edx
xor    %ecx,%ecx
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,%rcx
add    $0x40,%rdx
cmp    %rcx,%r9
jne    1580 <MixColumn_AddRoundKey+0x480>
test   %rax,%rax
je     15f3 <MixColumn_AddRoundKey+0x4f3>
shl    $0x4,%rcx
add    %rcx,%rdi
add    %rsp,%rcx
add    $0xffffffffffffff80,%rcx
shl    $0x4,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqa (%rcx,%rdx,1),%xmm0
movdqu %xmm0,(%rdi,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rax
jne    15e0 <MixColumn_AddRoundKey+0x4e0>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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