#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 rj_sbox(unsigned char);
void aes_expandEncKey(unsigned char *k, unsigned char *rc) {
  register unsigned char i;
  k[0] ^= rj_sbox(k[29]) ^ (*rc);
  k[1] ^= rj_sbox(k[30]);
  k[2] ^= rj_sbox(k[31]);
  k[3] ^= rj_sbox(k[28]);
  *rc = (((*rc) << 1) ^ ((((*rc) >> 7) & 1) * 0x1b));
  for (i = 4; i < 16; i += 4)
    k[i] ^= k[i - 4], k[i + 1] ^= k[i - 3], k[i + 2] ^= k[i - 2],
        k[i + 3] ^= k[i - 1];
  k[16] ^= rj_sbox(k[12]);
  k[17] ^= rj_sbox(k[13]);
  k[18] ^= rj_sbox(k[14]);
  k[19] ^= rj_sbox(k[15]);
  for (i = 20; i < 32; i += 4)
    k[i] ^= k[i - 4], k[i + 1] ^= k[i - 3], k[i + 2] ^= k[i - 2],
        k[i + 3] ^= k[i - 1];
}


x86 assembly (clang, -O0):
<aes_expandEncKey>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1d(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
xor    %eax,%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
xor    %edx,%ecx
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1e(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1f(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1c(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x3(%rax)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
movzbl (%rcx),%ecx
sar    $0x7,%ecx
and    $0x1,%ecx
imul   $0x1b,%ecx,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
movb   $0x4,-0x11(%rbp)
movzbl -0x11(%rbp),%eax
cmp    $0x10,%eax
jge    127d <aes_expandEncKey+0x16d>
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x11(%rbp),%eax
add    $0x4,%eax
mov    %al,-0x11(%rbp)
jmp    11c3 <aes_expandEncKey+0xb3>
mov    -0x8(%rbp),%rax
movzbl 0xc(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x10(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x10(%rax)
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x11(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x11(%rax)
mov    -0x8(%rbp),%rax
movzbl 0xe(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x12(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x12(%rax)
mov    -0x8(%rbp),%rax
movzbl 0xf(%rax),%edi
call   1030 <rj_sbox@plt>
movzbl %al,%edx
mov    -0x8(%rbp),%rax
movzbl 0x13(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x13(%rax)
movb   $0x14,-0x11(%rbp)
movzbl -0x11(%rbp),%eax
cmp    $0x20,%eax
jge    13af <aes_expandEncKey+0x29f>
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x8(%rbp),%rax
movzbl -0x11(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x11(%rbp),%eax
add    $0x4,%eax
mov    %al,-0x11(%rbp)
jmp    12f5 <aes_expandEncKey+0x1e5>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aes_expandEncKey>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
movzbl 0x1d(%rdi),%edi
call   1030 <rj_sbox@plt>
xor    (%r14),%al
xor    %al,(%rbx)
movzbl 0x1e(%rbx),%edi
call   1030 <rj_sbox@plt>
xor    %al,0x1(%rbx)
movzbl 0x1f(%rbx),%edi
call   1030 <rj_sbox@plt>
xor    %al,0x2(%rbx)
movzbl 0x1c(%rbx),%edi
call   1030 <rj_sbox@plt>
xor    %al,0x3(%rbx)
mov    (%r14),%al
lea    (%rax,%rax,1),%ecx
sar    $0x7,%al
and    $0x1b,%al
xor    %cl,%al
mov    %al,(%r14)
mov    0x4(%rbx),%al
xor    (%rbx),%al
mov    0x5(%rbx),%sil
mov    %al,0x4(%rbx)
xor    0x1(%rbx),%sil
mov    %sil,0x5(%rbx)
mov    0x6(%rbx),%dl
xor    0x2(%rbx),%dl
mov    %dl,0x6(%rbx)
mov    0x7(%rbx),%cl
xor    0x3(%rbx),%cl
mov    %cl,0x7(%rbx)
xor    0x8(%rbx),%al
mov    %al,0x8(%rbx)
xor    0x9(%rbx),%sil
mov    %sil,0x9(%rbx)
xor    0xa(%rbx),%dl
mov    %dl,0xa(%rbx)
xor    0xb(%rbx),%cl
mov    %cl,0xb(%rbx)
xor    0xc(%rbx),%al
mov    %al,0xc(%rbx)
xor    %sil,0xd(%rbx)
xor    %dl,0xe(%rbx)
xor    %cl,0xf(%rbx)
movzbl %al,%edi
call   1030 <rj_sbox@plt>
xor    %al,0x10(%rbx)
movzbl 0xd(%rbx),%edi
call   1030 <rj_sbox@plt>
xor    %al,0x11(%rbx)
movzbl 0xe(%rbx),%edi
call   1030 <rj_sbox@plt>
xor    %al,0x12(%rbx)
movzbl 0xf(%rbx),%edi
call   1030 <rj_sbox@plt>
xor    0x13(%rbx),%al
mov    %al,0x13(%rbx)
mov    0x14(%rbx),%sil
xor    0x10(%rbx),%sil
mov    0x15(%rbx),%dl
mov    %sil,0x14(%rbx)
xor    0x11(%rbx),%dl
mov    %dl,0x15(%rbx)
mov    0x16(%rbx),%cl
xor    0x12(%rbx),%cl
mov    %cl,0x16(%rbx)
xor    0x17(%rbx),%al
mov    %al,0x17(%rbx)
xor    0x18(%rbx),%sil
mov    %sil,0x18(%rbx)
xor    0x19(%rbx),%dl
mov    %dl,0x19(%rbx)
xor    0x1a(%rbx),%cl
mov    %cl,0x1a(%rbx)
xor    0x1b(%rbx),%al
mov    %al,0x1b(%rbx)
xor    %sil,0x1c(%rbx)
xor    %dl,0x1d(%rbx)
xor    %cl,0x1e(%rbx)
xor    %al,0x1f(%rbx)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @aes_expandEncKey(i8* %0, i8* nocapture %1) {
%3 = getelementptr inbounds i8, i8* %0, i64 29
%4 = load i8, i8* %3
%5 = tail call zeroext i8 @rj_sbox(i8 zeroext %4)
%6 = load i8, i8* %1
%7 = xor i8 %6, %5
%8 = load i8, i8* %0
%9 = xor i8 %7, %8
store i8 %9, i8* %0
%10 = getelementptr inbounds i8, i8* %0, i64 30
%11 = load i8, i8* %10
%12 = tail call zeroext i8 @rj_sbox(i8 zeroext %11)
%13 = getelementptr inbounds i8, i8* %0, i64 1
%14 = load i8, i8* %13
%15 = xor i8 %14, %12
store i8 %15, i8* %13
%16 = getelementptr inbounds i8, i8* %0, i64 31
%17 = load i8, i8* %16
%18 = tail call zeroext i8 @rj_sbox(i8 zeroext %17)
%19 = getelementptr inbounds i8, i8* %0, i64 2
%20 = load i8, i8* %19
%21 = xor i8 %20, %18
store i8 %21, i8* %19
%22 = getelementptr inbounds i8, i8* %0, i64 28
%23 = load i8, i8* %22
%24 = tail call zeroext i8 @rj_sbox(i8 zeroext %23)
%25 = getelementptr inbounds i8, i8* %0, i64 3
%26 = load i8, i8* %25
%27 = xor i8 %26, %24
store i8 %27, i8* %25
%28 = load i8, i8* %1
%29 = shl i8 %28, 1
%30 = icmp slt i8 %28, 0
%31 = select i1 %30, i8 27, i8 0
%32 = xor i8 %31, %29
store i8 %32, i8* %1
%33 = load i8, i8* %0
%34 = getelementptr inbounds i8, i8* %0, i64 4
%35 = load i8, i8* %34
%36 = xor i8 %35, %33
store i8 %36, i8* %34
%37 = load i8, i8* %13
%38 = getelementptr inbounds i8, i8* %0, i64 5
%39 = load i8, i8* %38
%40 = xor i8 %39, %37
store i8 %40, i8* %38
%41 = load i8, i8* %19
%42 = getelementptr inbounds i8, i8* %0, i64 6
%43 = load i8, i8* %42
%44 = xor i8 %43, %41
store i8 %44, i8* %42
%45 = load i8, i8* %25
%46 = getelementptr inbounds i8, i8* %0, i64 7
%47 = load i8, i8* %46
%48 = xor i8 %47, %45
store i8 %48, i8* %46
%49 = getelementptr inbounds i8, i8* %0, i64 8
%50 = load i8, i8* %49
%51 = xor i8 %50, %36
store i8 %51, i8* %49
%52 = getelementptr inbounds i8, i8* %0, i64 9
%53 = load i8, i8* %52
%54 = xor i8 %53, %40
store i8 %54, i8* %52
%55 = getelementptr inbounds i8, i8* %0, i64 10
%56 = load i8, i8* %55
%57 = xor i8 %56, %44
store i8 %57, i8* %55
%58 = getelementptr inbounds i8, i8* %0, i64 11
%59 = load i8, i8* %58
%60 = xor i8 %59, %48
store i8 %60, i8* %58
%61 = getelementptr inbounds i8, i8* %0, i64 12
%62 = load i8, i8* %61
%63 = xor i8 %62, %51
store i8 %63, i8* %61
%64 = getelementptr inbounds i8, i8* %0, i64 13
%65 = load i8, i8* %64
%66 = xor i8 %65, %54
store i8 %66, i8* %64
%67 = getelementptr inbounds i8, i8* %0, i64 14
%68 = load i8, i8* %67
%69 = xor i8 %68, %57
store i8 %69, i8* %67
%70 = getelementptr inbounds i8, i8* %0, i64 15
%71 = load i8, i8* %70
%72 = xor i8 %71, %60
store i8 %72, i8* %70
%73 = tail call zeroext i8 @rj_sbox(i8 zeroext %63)
%74 = getelementptr inbounds i8, i8* %0, i64 16
%75 = load i8, i8* %74
%76 = xor i8 %75, %73
store i8 %76, i8* %74
%77 = load i8, i8* %64
%78 = tail call zeroext i8 @rj_sbox(i8 zeroext %77)
%79 = getelementptr inbounds i8, i8* %0, i64 17
%80 = load i8, i8* %79
%81 = xor i8 %80, %78
store i8 %81, i8* %79
%82 = load i8, i8* %67
%83 = tail call zeroext i8 @rj_sbox(i8 zeroext %82)
%84 = getelementptr inbounds i8, i8* %0, i64 18
%85 = load i8, i8* %84
%86 = xor i8 %85, %83
store i8 %86, i8* %84
%87 = load i8, i8* %70
%88 = tail call zeroext i8 @rj_sbox(i8 zeroext %87)
%89 = getelementptr inbounds i8, i8* %0, i64 19
%90 = load i8, i8* %89
%91 = xor i8 %90, %88
store i8 %91, i8* %89
%92 = load i8, i8* %74
%93 = getelementptr inbounds i8, i8* %0, i64 20
%94 = load i8, i8* %93
%95 = xor i8 %94, %92
store i8 %95, i8* %93
%96 = load i8, i8* %79
%97 = getelementptr inbounds i8, i8* %0, i64 21
%98 = load i8, i8* %97
%99 = xor i8 %98, %96
store i8 %99, i8* %97
%100 = load i8, i8* %84
%101 = getelementptr inbounds i8, i8* %0, i64 22
%102 = load i8, i8* %101
%103 = xor i8 %102, %100
store i8 %103, i8* %101
%104 = getelementptr inbounds i8, i8* %0, i64 23
%105 = load i8, i8* %104
%106 = xor i8 %105, %91
store i8 %106, i8* %104
%107 = getelementptr inbounds i8, i8* %0, i64 24
%108 = load i8, i8* %107
%109 = xor i8 %108, %95
store i8 %109, i8* %107
%110 = getelementptr inbounds i8, i8* %0, i64 25
%111 = load i8, i8* %110
%112 = xor i8 %111, %99
store i8 %112, i8* %110
%113 = getelementptr inbounds i8, i8* %0, i64 26
%114 = load i8, i8* %113
%115 = xor i8 %114, %103
store i8 %115, i8* %113
%116 = getelementptr inbounds i8, i8* %0, i64 27
%117 = load i8, i8* %116
%118 = xor i8 %117, %106
store i8 %118, i8* %116
%119 = load i8, i8* %22
%120 = xor i8 %119, %109
store i8 %120, i8* %22
%121 = load i8, i8* %3
%122 = xor i8 %121, %112
store i8 %122, i8* %3
%123 = load i8, i8* %10
%124 = xor i8 %123, %115
store i8 %124, i8* %10
%125 = load i8, i8* %16
%126 = xor i8 %125, %118
store i8 %126, i8* %16
ret void
}