#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 */
typedef int uint8_t;

/* Variables and functions */
void copy_and_key(void *d, const void *s, const void *k) {
  ((uint8_t *)d)[0] = ((uint8_t *)s)[0] ^ ((uint8_t *)k)[0];
  ((uint8_t *)d)[1] = ((uint8_t *)s)[1] ^ ((uint8_t *)k)[1];
  ((uint8_t *)d)[2] = ((uint8_t *)s)[2] ^ ((uint8_t *)k)[2];
  ((uint8_t *)d)[3] = ((uint8_t *)s)[3] ^ ((uint8_t *)k)[3];
  ((uint8_t *)d)[4] = ((uint8_t *)s)[4] ^ ((uint8_t *)k)[4];
  ((uint8_t *)d)[5] = ((uint8_t *)s)[5] ^ ((uint8_t *)k)[5];
  ((uint8_t *)d)[6] = ((uint8_t *)s)[6] ^ ((uint8_t *)k)[6];
  ((uint8_t *)d)[7] = ((uint8_t *)s)[7] ^ ((uint8_t *)k)[7];
  ((uint8_t *)d)[8] = ((uint8_t *)s)[8] ^ ((uint8_t *)k)[8];
  ((uint8_t *)d)[9] = ((uint8_t *)s)[9] ^ ((uint8_t *)k)[9];
  ((uint8_t *)d)[10] = ((uint8_t *)s)[10] ^ ((uint8_t *)k)[10];
  ((uint8_t *)d)[11] = ((uint8_t *)s)[11] ^ ((uint8_t *)k)[11];
  ((uint8_t *)d)[12] = ((uint8_t *)s)[12] ^ ((uint8_t *)k)[12];
  ((uint8_t *)d)[13] = ((uint8_t *)s)[13] ^ ((uint8_t *)k)[13];
  ((uint8_t *)d)[14] = ((uint8_t *)s)[14] ^ ((uint8_t *)k)[14];
  ((uint8_t *)d)[15] = ((uint8_t *)s)[15] ^ ((uint8_t *)k)[15];
}


x86 assembly (clang, -O0):
<copy_and_key>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rax
xor    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x4(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x10(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x20(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x20(%rax)
mov    -0x10(%rbp),%rax
mov    0x24(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x24(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x24(%rax)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x28(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x28(%rax)
mov    -0x10(%rbp),%rax
mov    0x2c(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x2c(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x2c(%rax)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x30(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x30(%rax)
mov    -0x10(%rbp),%rax
mov    0x34(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x34(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x34(%rax)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x38(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x38(%rax)
mov    -0x10(%rbp),%rax
mov    0x3c(%rax),%ecx
mov    -0x18(%rbp),%rax
xor    0x3c(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<copy_and_key>:
mov    (%rdx),%eax
xor    (%rsi),%eax
mov    %eax,(%rdi)
mov    0x4(%rdx),%eax
xor    0x4(%rsi),%eax
mov    %eax,0x4(%rdi)
mov    0x8(%rdx),%eax
xor    0x8(%rsi),%eax
mov    %eax,0x8(%rdi)
mov    0xc(%rdx),%eax
xor    0xc(%rsi),%eax
mov    %eax,0xc(%rdi)
mov    0x10(%rdx),%eax
xor    0x10(%rsi),%eax
mov    %eax,0x10(%rdi)
mov    0x14(%rdx),%eax
xor    0x14(%rsi),%eax
mov    %eax,0x14(%rdi)
mov    0x18(%rdx),%eax
xor    0x18(%rsi),%eax
mov    %eax,0x18(%rdi)
mov    0x1c(%rdx),%eax
xor    0x1c(%rsi),%eax
mov    %eax,0x1c(%rdi)
mov    0x20(%rdx),%eax
xor    0x20(%rsi),%eax
mov    %eax,0x20(%rdi)
mov    0x24(%rdx),%eax
xor    0x24(%rsi),%eax
mov    %eax,0x24(%rdi)
mov    0x28(%rdx),%eax
xor    0x28(%rsi),%eax
mov    %eax,0x28(%rdi)
mov    0x2c(%rdx),%eax
xor    0x2c(%rsi),%eax
mov    %eax,0x2c(%rdi)
mov    0x30(%rdx),%eax
xor    0x30(%rsi),%eax
mov    %eax,0x30(%rdi)
mov    0x34(%rdx),%eax
xor    0x34(%rsi),%eax
mov    %eax,0x34(%rdi)
mov    0x38(%rdx),%eax
xor    0x38(%rsi),%eax
mov    %eax,0x38(%rdi)
mov    0x3c(%rdx),%eax
xor    0x3c(%rsi),%eax
mov    %eax,0x3c(%rdi)
ret

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

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