void InvMixColumn(unsigned char *column) {
  unsigned char r0, r1, r2, r3;
  r0 = column[1] ^ column[2] ^ column[3];
  r1 = column[0] ^ column[2] ^ column[3];
  r2 = column[0] ^ column[1] ^ column[3];
  r3 = column[0] ^ column[1] ^ column[2];
  column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? 0x1b : 0);
  column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? 0x1b : 0);
  column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? 0x1b : 0);
  column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? 0x1b : 0);
  r0 ^= column[0] ^ column[1];
  r1 ^= column[1] ^ column[2];
  r2 ^= column[2] ^ column[3];
  r3 ^= column[0] ^ column[3];
  column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? 0x1b : 0);
  column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? 0x1b : 0);
  column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? 0x1b : 0);
  column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? 0x1b : 0);
  r0 ^= column[0] ^ column[2];
  r1 ^= column[1] ^ column[3];
  r2 ^= column[0] ^ column[2];
  r3 ^= column[1] ^ column[3];
  column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? 0x1b : 0);
  column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? 0x1b : 0);
  column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? 0x1b : 0);
  column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? 0x1b : 0);
  column[0] ^= column[1] ^ column[2] ^ column[3];
  r0 ^= column[0];
  r1 ^= column[0];
  r2 ^= column[0];
  r3 ^= column[0];
  column[0] = r0;
  column[1] = r1;
  column[2] = r2;
  column[3] = r3;
}


x86 assembly (clang, -O0):
<InvMixColumn>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
xor    %ecx,%eax
mov    %al,-0xa(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
xor    %ecx,%eax
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
xor    %ecx,%eax
mov    %al,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
xor    %eax,%ecx
movzbl -0x9(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
xor    %eax,%ecx
movzbl -0xa(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xa(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
xor    %eax,%ecx
movzbl -0xb(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
xor    %eax,%ecx
movzbl -0xc(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
xor    %eax,%ecx
movzbl -0x9(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
xor    %eax,%ecx
movzbl -0xa(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xa(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
xor    %eax,%ecx
movzbl -0xb(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%ecx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
xor    %eax,%ecx
movzbl -0xc(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%esi
and    $0x80,%esi
xor    %ecx,%ecx
mov    $0x1b,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
xor    %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
xor    %eax,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
xor    %edx,%ecx
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0x9(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0xa(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xa(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0xb(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
movzbl -0xc(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0xc(%rbp)
mov    -0x9(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0xa(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0xb(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0xc(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x3(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<InvMixColumn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,-0x10(%rsp)
mov    (%rdi),%r15b
mov    0x1(%rdi),%r11b
mov    0x2(%rdi),%r9b
mov    0x3(%rdi),%al
lea    (%r15,%r15,1),%esi
mov    %r15d,%r10d
sar    $0x7,%r10b
and    $0x1b,%r10b
xor    %sil,%r10b
lea    (%r11,%r11,1),%ebx
mov    %r11d,%r8d
sar    $0x7,%r8b
and    $0x1b,%r8b
xor    %bl,%r8b
lea    (%r9,%r9,1),%ebp
mov    %rax,%r14
mov    %rax,-0x8(%rsp)
lea    (%rax,%rax,1),%edx
sar    $0x7,%r14b
and    $0x1b,%r14b
xor    %dl,%r14b
lea    (%r10,%r10,1),%edi
sar    $0x7,%sil
and    $0x1b,%sil
xor    %dil,%sil
lea    (%r8,%r8,1),%ecx
sar    $0x7,%bl
and    $0x1b,%bl
xor    %cl,%bl
mov    %esi,%r12d
add    %sil,%sil
sar    $0x7,%dil
and    $0x1b,%dil
xor    %sil,%dil
lea    (%r14,%r14,1),%esi
sar    $0x7,%dl
and    $0x1b,%dl
xor    %sil,%dl
mov    %edx,%r13d
xor    %bl,%r13b
add    %bl,%bl
sar    $0x7,%cl
and    $0x1b,%cl
xor    %bl,%cl
mov    %r9d,%ebx
sar    $0x7,%bl
and    $0x1b,%bl
xor    %bpl,%bl
sar    $0x7,%bpl
and    $0x1b,%bpl
lea    (%rbx,%rbx,1),%eax
xor    %al,%bpl
xor    %bpl,%r12b
add    %bpl,%bpl
sar    $0x7,%al
and    $0x1b,%al
xor    %bpl,%al
xor    %cl,%al
add    %dl,%dl
sar    $0x7,%sil
and    $0x1b,%sil
xor    %dl,%sil
xor    %dil,%sil
xor    %al,%sil
mov    %r15d,%eax
xor    %r11b,%al
xor    %r9b,%r11b
xor    %r8b,%r11b
xor    %r9b,%r15b
xor    %r8b,%r15b
xor    %r10b,%r11b
xor    %r12b,%r11b
xor    %bl,%r15b
xor    %al,%bl
xor    %r14b,%bl
xor    %r12b,%bl
mov    -0x8(%rsp),%rdx
xor    %sil,%dl
xor    %dl,%r11b
xor    %r13b,%r15b
xor    %dl,%r15b
xor    %dl,%bl
xor    %r9b,%al
xor    %r14b,%al
xor    %r10b,%al
xor    %r13b,%al
xor    %sil,%al
mov    -0x10(%rsp),%rcx
mov    %r11b,(%rcx)
mov    %r15b,0x1(%rcx)
mov    %bl,0x2(%rcx)
mov    %al,0x3(%rcx)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @InvMixColumn(i8* nocapture %0) {
%2 = getelementptr inbounds i8, i8* %0, i64 1
%3 = load i8, i8* %2
%4 = getelementptr inbounds i8, i8* %0, i64 2
%5 = load i8, i8* %4
%6 = getelementptr inbounds i8, i8* %0, i64 3
%7 = load i8, i8* %6
%8 = load i8, i8* %0
%9 = xor i8 %8, %3
%10 = shl i8 %8, 1
%11 = icmp slt i8 %8, 0
%12 = select i1 %11, i8 27, i8 0
%13 = xor i8 %12, %10
%14 = shl i8 %3, 1
%15 = icmp slt i8 %3, 0
%16 = select i1 %15, i8 27, i8 0
%17 = xor i8 %16, %14
%18 = shl i8 %5, 1
%19 = icmp slt i8 %5, 0
%20 = select i1 %19, i8 27, i8 0
%21 = xor i8 %20, %18
%22 = shl i8 %7, 1
%23 = icmp slt i8 %7, 0
%24 = select i1 %23, i8 27, i8 0
%25 = xor i8 %24, %22
%26 = shl i8 %13, 1
%27 = icmp slt i8 %13, 0
%28 = select i1 %27, i8 27, i8 0
%29 = xor i8 %28, %26
%30 = shl i8 %17, 1
%31 = icmp slt i8 %17, 0
%32 = select i1 %31, i8 27, i8 0
%33 = xor i8 %32, %30
%34 = shl i8 %21, 1
%35 = icmp slt i8 %21, 0
%36 = select i1 %35, i8 27, i8 0
%37 = xor i8 %36, %34
%38 = shl i8 %25, 1
%39 = icmp slt i8 %25, 0
%40 = select i1 %39, i8 27, i8 0
%41 = xor i8 %40, %38
%42 = xor i8 %29, %37
%43 = xor i8 %41, %33
%44 = shl i8 %29, 1
%45 = icmp slt i8 %29, 0
%46 = select i1 %45, i8 27, i8 0
%47 = xor i8 %46, %44
%48 = shl i8 %33, 1
%49 = icmp slt i8 %33, 0
%50 = select i1 %49, i8 27, i8 0
%51 = xor i8 %50, %48
%52 = shl i8 %37, 1
%53 = icmp slt i8 %37, 0
%54 = select i1 %53, i8 27, i8 0
%55 = xor i8 %54, %52
%56 = shl i8 %41, 1
%57 = icmp slt i8 %41, 0
%58 = select i1 %57, i8 27, i8 0
%59 = xor i8 %58, %56
%60 = xor i8 %55, %51
%61 = xor i8 %60, %59
%62 = xor i8 %61, %47
%63 = xor i8 %62, %7
%64 = xor i8 %63, %3
%65 = xor i8 %64, %5
%66 = xor i8 %65, %17
%67 = xor i8 %66, %13
%68 = xor i8 %67, %42
%69 = xor i8 %63, %5
%70 = xor i8 %69, %8
%71 = xor i8 %70, %17
%72 = xor i8 %71, %21
%73 = xor i8 %72, %43
%74 = xor i8 %63, %9
%75 = xor i8 %74, %21
%76 = xor i8 %75, %25
%77 = xor i8 %76, %42
%78 = xor i8 %62, %5
%79 = xor i8 %78, %9
%80 = xor i8 %79, %25
%81 = xor i8 %80, %13
%82 = xor i8 %81, %43
store i8 %68, i8* %0
store i8 %73, i8* %2
store i8 %77, i8* %4
store i8 %82, i8* %6
ret void
}