void AddRoundKey(unsigned char state[][4], unsigned long w[]) {
  unsigned char subkey[4];
  subkey[0] = w[0] >> 24;
  subkey[1] = w[0] >> 16;
  subkey[2] = w[0] >> 8;
  subkey[3] = w[0];
  state[0][0] ^= subkey[0];
  state[1][0] ^= subkey[1];
  state[2][0] ^= subkey[2];
  state[3][0] ^= subkey[3];
  subkey[0] = w[1] >> 24;
  subkey[1] = w[1] >> 16;
  subkey[2] = w[1] >> 8;
  subkey[3] = w[1];
  state[0][1] ^= subkey[0];
  state[1][1] ^= subkey[1];
  state[2][1] ^= subkey[2];
  state[3][1] ^= subkey[3];
  subkey[0] = w[2] >> 24;
  subkey[1] = w[2] >> 16;
  subkey[2] = w[2] >> 8;
  subkey[3] = w[2];
  state[0][2] ^= subkey[0];
  state[1][2] ^= subkey[1];
  state[2][2] ^= subkey[2];
  state[3][2] ^= subkey[3];
  subkey[0] = w[3] >> 24;
  subkey[1] = w[3] >> 16;
  subkey[2] = w[3] >> 8;
  subkey[3] = w[3];
  state[0][3] ^= subkey[0];
  state[1][3] ^= subkey[1];
  state[2][3] ^= subkey[2];
  state[3][3] ^= subkey[3];
}


x86 assembly (clang, -O0):
<AddRoundKey>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
shr    $0x18,%rax
mov    %al,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
shr    $0x10,%rax
mov    %al,-0x13(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
shr    $0x8,%rax
mov    %al,-0x12(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %al,-0x11(%rbp)
movzbl -0x14(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl (%rax),%ecx
xor    %edx,%ecx
mov    %cl,(%rax)
movzbl -0x13(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x4(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x4(%rax)
movzbl -0x12(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x8(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x8(%rax)
movzbl -0x11(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0xc(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
shr    $0x18,%rax
mov    %al,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
shr    $0x10,%rax
mov    %al,-0x13(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
shr    $0x8,%rax
mov    %al,-0x12(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %al,-0x11(%rbp)
movzbl -0x14(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x1(%rax)
movzbl -0x13(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x5(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x5(%rax)
movzbl -0x12(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x9(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x9(%rax)
movzbl -0x11(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xd(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
shr    $0x18,%rax
mov    %al,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
shr    $0x10,%rax
mov    %al,-0x13(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
shr    $0x8,%rax
mov    %al,-0x12(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %al,-0x11(%rbp)
movzbl -0x14(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x2(%rax)
movzbl -0x13(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x6(%rax)
movzbl -0x12(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0xa(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xa(%rax)
movzbl -0x11(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0xe(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xe(%rax)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
shr    $0x18,%rax
mov    %al,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
shr    $0x10,%rax
mov    %al,-0x13(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
shr    $0x8,%rax
mov    %al,-0x12(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %al,-0x11(%rbp)
movzbl -0x14(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x3(%rax)
movzbl -0x13(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x7(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x7(%rax)
movzbl -0x12(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0xb(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xb(%rax)
movzbl -0x11(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0xf(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xf(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<AddRoundKey>:
mov    (%rsi),%rax
mov    %rax,%rcx
shr    $0x18,%rcx
xor    %cl,(%rdi)
mov    %rax,%rcx
shr    $0x10,%rcx
xor    %cl,0x4(%rdi)
mov    %rax,%rcx
shr    $0x8,%rcx
xor    %cl,0x8(%rdi)
xor    %al,0xc(%rdi)
mov    0x8(%rsi),%rax
mov    %rax,%rcx
shr    $0x18,%rcx
xor    %cl,0x1(%rdi)
mov    %rax,%rcx
shr    $0x10,%rcx
xor    %cl,0x5(%rdi)
mov    %rax,%rcx
shr    $0x8,%rcx
xor    %cl,0x9(%rdi)
xor    %al,0xd(%rdi)
mov    0x10(%rsi),%rax
mov    %rax,%rcx
shr    $0x18,%rcx
xor    %cl,0x2(%rdi)
mov    %rax,%rcx
shr    $0x10,%rcx
xor    %cl,0x6(%rdi)
mov    %rax,%rcx
shr    $0x8,%rcx
xor    %cl,0xa(%rdi)
xor    %al,0xe(%rdi)
mov    0x18(%rsi),%rax
mov    %rax,%rcx
shr    $0x18,%rcx
xor    %cl,0x3(%rdi)
mov    %rax,%rcx
shr    $0x10,%rcx
xor    %cl,0x7(%rdi)
mov    %rax,%rcx
shr    $0x8,%rcx
xor    %cl,0xb(%rdi)
xor    %al,0xf(%rdi)
ret

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

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