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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned char galois_mult_by_eleven(unsigned char);
unsigned char galois_mult_by_fourteen(unsigned char);
unsigned char galois_mult_by_nine(unsigned char);
unsigned char galois_mult_by_thirteen(unsigned char);
void aes_128_inv_mix_columns(unsigned char *state) {
  unsigned j;
  unsigned char tmp_col[4] = {0};
  for (j = 0; j < 4; j++) {
    tmp_col[0] = galois_mult_by_fourteen(state[4 * j]) ^
                 galois_mult_by_eleven(state[4 * j + 1]) ^
                 galois_mult_by_thirteen(state[4 * j + 2]) ^
                 galois_mult_by_nine(state[4 * j + 3]);
    tmp_col[1] = galois_mult_by_fourteen(state[4 * j + 1]) ^
                 galois_mult_by_eleven(state[4 * j + 2]) ^
                 galois_mult_by_thirteen(state[4 * j + 3]) ^
                 galois_mult_by_nine(state[4 * j]);
    tmp_col[2] = galois_mult_by_fourteen(state[4 * j + 2]) ^
                 galois_mult_by_eleven(state[4 * j + 3]) ^
                 galois_mult_by_thirteen(state[4 * j]) ^
                 galois_mult_by_nine(state[4 * j + 1]);
    tmp_col[3] = galois_mult_by_fourteen(state[4 * j + 3]) ^
                 galois_mult_by_eleven(state[4 * j]) ^
                 galois_mult_by_thirteen(state[4 * j + 1]) ^
                 galois_mult_by_nine(state[4 * j + 2]);
    state[4 * j] = tmp_col[0];
    state[4 * j + 1] = tmp_col[1];
    state[4 * j + 2] = tmp_col[2];
    state[4 * j + 3] = tmp_col[3];
  }
}


x86 assembly (clang, -O0):
<aes_128_inv_mix_columns>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x10(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jae    1404 <aes_128_inv_mix_columns+0x2b4>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1050 <galois_mult_by_fourteen@plt>
movzbl %al,%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1040 <galois_mult_by_eleven@plt>
mov    %al,%cl
mov    -0x40(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1060 <galois_mult_by_thirteen@plt>
mov    %al,%cl
mov    -0x3c(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1070 <galois_mult_by_nine@plt>
mov    %al,%cl
mov    -0x38(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %al,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1050 <galois_mult_by_fourteen@plt>
movzbl %al,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1040 <galois_mult_by_eleven@plt>
mov    %al,%cl
mov    -0x34(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1060 <galois_mult_by_thirteen@plt>
mov    %al,%cl
mov    -0x30(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1070 <galois_mult_by_nine@plt>
mov    %al,%cl
mov    -0x2c(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %al,-0xf(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1050 <galois_mult_by_fourteen@plt>
movzbl %al,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1040 <galois_mult_by_eleven@plt>
mov    %al,%cl
mov    -0x28(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1060 <galois_mult_by_thirteen@plt>
mov    %al,%cl
mov    -0x24(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1070 <galois_mult_by_nine@plt>
mov    %al,%cl
mov    -0x20(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %al,-0xe(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1050 <galois_mult_by_fourteen@plt>
movzbl %al,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1040 <galois_mult_by_eleven@plt>
mov    %al,%cl
mov    -0x1c(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1060 <galois_mult_by_thirteen@plt>
mov    %al,%cl
mov    -0x18(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edi
call   1070 <galois_mult_by_nine@plt>
mov    %al,%cl
mov    -0x14(%rbp),%eax
movzbl %cl,%ecx
xor    %ecx,%eax
mov    %al,-0xd(%rbp)
mov    -0x10(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0xf(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0xe(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0xd(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1173 <aes_128_inv_mix_columns+0x23>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aes_128_inv_mix_columns>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbx
xor    %ebp,%ebp
movzbl (%rbx,%rbp,4),%edi
call   1040 <galois_mult_by_fourteen@plt>
mov    %eax,%r15d
movzbl 0x1(%rbx,%rbp,4),%edi
call   1030 <galois_mult_by_eleven@plt>
mov    %eax,%r14d
xor    %r15b,%r14b
movzbl 0x2(%rbx,%rbp,4),%edi
call   1050 <galois_mult_by_thirteen@plt>
mov    %eax,%r15d
movzbl 0x3(%rbx,%rbp,4),%edi
call   1060 <galois_mult_by_nine@plt>
xor    %r15b,%al
xor    %r14b,%al
mov    %al,0x7(%rsp)
movzbl 0x1(%rbx,%rbp,4),%edi
call   1040 <galois_mult_by_fourteen@plt>
mov    %eax,%r14d
movzbl 0x2(%rbx,%rbp,4),%edi
call   1030 <galois_mult_by_eleven@plt>
mov    %eax,%r15d
xor    %r14b,%r15b
movzbl 0x3(%rbx,%rbp,4),%edi
call   1050 <galois_mult_by_thirteen@plt>
mov    %eax,%r12d
movzbl (%rbx,%rbp,4),%edi
call   1060 <galois_mult_by_nine@plt>
mov    %eax,%r14d
xor    %r12b,%r14b
xor    %r15b,%r14b
movzbl 0x2(%rbx,%rbp,4),%edi
call   1040 <galois_mult_by_fourteen@plt>
mov    %eax,%r15d
movzbl 0x3(%rbx,%rbp,4),%edi
call   1030 <galois_mult_by_eleven@plt>
mov    %eax,%r12d
xor    %r15b,%r12b
movzbl (%rbx,%rbp,4),%edi
call   1050 <galois_mult_by_thirteen@plt>
mov    %eax,%r13d
movzbl 0x1(%rbx,%rbp,4),%edi
call   1060 <galois_mult_by_nine@plt>
mov    %eax,%r15d
xor    %r13b,%r15b
xor    %r12b,%r15b
movzbl 0x3(%rbx,%rbp,4),%edi
call   1040 <galois_mult_by_fourteen@plt>
mov    %eax,%r12d
movzbl (%rbx,%rbp,4),%edi
call   1030 <galois_mult_by_eleven@plt>
mov    %eax,%r13d
xor    %r12b,%r13b
movzbl 0x1(%rbx,%rbp,4),%edi
call   1050 <galois_mult_by_thirteen@plt>
mov    %eax,%r12d
movzbl 0x2(%rbx,%rbp,4),%edi
call   1060 <galois_mult_by_nine@plt>
xor    %r12b,%al
xor    %r13b,%al
movzbl 0x7(%rsp),%ecx
mov    %cl,(%rbx,%rbp,4)
mov    %r14b,0x1(%rbx,%rbp,4)
mov    %r15b,0x2(%rbx,%rbp,4)
mov    %al,0x3(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    $0x4,%rbp
jne    1150 <aes_128_inv_mix_columns+0x10>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @aes_128_inv_mix_columns(i8* nocapture %0) {
br label %2
2: ; preds = %1, %2
%3 = phi i64 [ 0, %1 ], [ %56, %2 ]
%4 = shl nuw nsw i64 %3, 2
%5 = getelementptr inbounds i8, i8* %0, i64 %4
%6 = load i8, i8* %5
%7 = tail call zeroext i8 @galois_mult_by_fourteen(i8 zeroext %6)
%8 = or i64 %4, 1
%9 = getelementptr inbounds i8, i8* %0, i64 %8
%10 = load i8, i8* %9
%11 = tail call zeroext i8 @galois_mult_by_eleven(i8 zeroext %10)
%12 = xor i8 %11, %7
%13 = or i64 %4, 2
%14 = getelementptr inbounds i8, i8* %0, i64 %13
%15 = load i8, i8* %14
%16 = tail call zeroext i8 @galois_mult_by_thirteen(i8 zeroext %15)
%17 = xor i8 %12, %16
%18 = or i64 %4, 3
%19 = getelementptr inbounds i8, i8* %0, i64 %18
%20 = load i8, i8* %19
%21 = tail call zeroext i8 @galois_mult_by_nine(i8 zeroext %20)
%22 = xor i8 %17, %21
%23 = load i8, i8* %9
%24 = tail call zeroext i8 @galois_mult_by_fourteen(i8 zeroext %23)
%25 = load i8, i8* %14
%26 = tail call zeroext i8 @galois_mult_by_eleven(i8 zeroext %25)
%27 = xor i8 %26, %24
%28 = load i8, i8* %19
%29 = tail call zeroext i8 @galois_mult_by_thirteen(i8 zeroext %28)
%30 = xor i8 %27, %29
%31 = load i8, i8* %5
%32 = tail call zeroext i8 @galois_mult_by_nine(i8 zeroext %31)
%33 = xor i8 %30, %32
%34 = load i8, i8* %14
%35 = tail call zeroext i8 @galois_mult_by_fourteen(i8 zeroext %34)
%36 = load i8, i8* %19
%37 = tail call zeroext i8 @galois_mult_by_eleven(i8 zeroext %36)
%38 = xor i8 %37, %35
%39 = load i8, i8* %5
%40 = tail call zeroext i8 @galois_mult_by_thirteen(i8 zeroext %39)
%41 = xor i8 %38, %40
%42 = load i8, i8* %9
%43 = tail call zeroext i8 @galois_mult_by_nine(i8 zeroext %42)
%44 = xor i8 %41, %43
%45 = load i8, i8* %19
%46 = tail call zeroext i8 @galois_mult_by_fourteen(i8 zeroext %45)
%47 = load i8, i8* %5
%48 = tail call zeroext i8 @galois_mult_by_eleven(i8 zeroext %47)
%49 = xor i8 %48, %46
%50 = load i8, i8* %9
%51 = tail call zeroext i8 @galois_mult_by_thirteen(i8 zeroext %50)
%52 = xor i8 %49, %51
%53 = load i8, i8* %14
%54 = tail call zeroext i8 @galois_mult_by_nine(i8 zeroext %53)
%55 = xor i8 %52, %54
store i8 %22, i8* %5
store i8 %33, i8* %9
store i8 %44, i8* %14
store i8 %55, i8* %19
%56 = add nuw nsw i64 %3, 1
%57 = icmp eq i64 %56, 4
br i1 %57, label %58, label %2
58: ; preds = %2
ret void
}