void randomize_by_xor(const unsigned char *p_random_data,
                      const unsigned char *p_src, unsigned char *p_dst,
                      int length) {
  int i;
  const int aligned_mask = sizeof(unsigned int) - 1;
  ;
  ;
  ;
  ;
  if ((0 == ((int)p_random_data & aligned_mask)) &&
      (0 == ((int)p_src & aligned_mask)) &&
      (0 == ((int)p_dst & aligned_mask)) && (0 == (length & aligned_mask))) {
    const unsigned int *p_random_data_32 = (const unsigned int *)p_random_data;
    const unsigned int *p_src_32 = (const unsigned int *)p_src;
    unsigned int *p_dst_32 = (unsigned int *)p_dst;
    int length_32 = length / sizeof(*p_random_data_32);
    for (i = 0; i < length_32; i++) {
      p_dst_32[i] = p_src_32[i] ^ p_random_data_32[i];
    }
  } else {
    for (i = 0; i < length; i++) {
      p_dst[i] = p_src[i] ^ p_random_data[i];
    }
  }
}


x86 assembly (clang, -O0):
<randomize_by_xor>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x3,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    11cd <randomize_by_xor+0xcd>
mov    -0x10(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    11cd <randomize_by_xor+0xcd>
mov    -0x18(%rbp),%rax
mov    %eax,%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    11cd <randomize_by_xor+0xcd>
mov    -0x1c(%rbp),%ecx
and    $0x3,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    11cd <randomize_by_xor+0xcd>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
movslq -0x1c(%rbp),%rax
shr    $0x2,%rax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    11c8 <randomize_by_xor+0xc8>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
xor    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118d <randomize_by_xor+0x8d>
jmp    121a <randomize_by_xor+0x11a>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1215 <randomize_by_xor+0x115>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d4 <randomize_by_xor+0xd4>
jmp    121a <randomize_by_xor+0x11a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<randomize_by_xor>:
push   %rbx
test   $0x3,%cl
jne    1139 <randomize_by_xor+0x39>
mov    %esi,%r8d
or     %edi,%r8d
mov    %edx,%eax
or     %r8d,%eax
and    $0x3,%eax
test   %rax,%rax
jne    1139 <randomize_by_xor+0x39>
cmp    $0x4,%ecx
jl     1356 <randomize_by_xor+0x256>
mov    %ecx,%r8d
shr    $0x2,%r8d
cmp    $0x20,%ecx
jae    120a <randomize_by_xor+0x10a>
xor    %ecx,%ecx
jmp    12eb <randomize_by_xor+0x1eb>
test   %ecx,%ecx
jle    1356 <randomize_by_xor+0x256>
mov    %ecx,%r8d
cmp    $0x8,%ecx
jae    11bf <randomize_by_xor+0xbf>
xor    %eax,%eax
mov    %rax,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rcx
and    $0x3,%rcx
je     1174 <randomize_by_xor+0x74>
nopl   (%rax)
movzbl (%rdi,%rax,1),%ebx
xor    (%rsi,%rax,1),%bl
mov    %bl,(%rdx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1160 <randomize_by_xor+0x60>
cmp    $0x3,%r9
jb     1356 <randomize_by_xor+0x256>
xchg   %ax,%ax
movzbl (%rdi,%rax,1),%ecx
xor    (%rsi,%rax,1),%cl
mov    %cl,(%rdx,%rax,1)
movzbl 0x1(%rdi,%rax,1),%ecx
xor    0x1(%rsi,%rax,1),%cl
mov    %cl,0x1(%rdx,%rax,1)
movzbl 0x2(%rdi,%rax,1),%ecx
xor    0x2(%rsi,%rax,1),%cl
mov    %cl,0x2(%rdx,%rax,1)
movzbl 0x3(%rdi,%rax,1),%ecx
xor    0x3(%rsi,%rax,1),%cl
mov    %cl,0x3(%rdx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r8
jne    1180 <randomize_by_xor+0x80>
jmp    1356 <randomize_by_xor+0x256>
lea    (%rdx,%r8,1),%r10
lea    (%rsi,%r8,1),%rax
cmp    %rdx,%rax
seta   %r11b
lea    (%rdi,%r8,1),%rax
cmp    %rsi,%r10
seta   %bl
cmp    %rdx,%rax
seta   %r9b
cmp    %rdi,%r10
seta   %r10b
xor    %eax,%eax
test   %bl,%r11b
jne    114b <randomize_by_xor+0x4b>
and    %r10b,%r9b
jne    114b <randomize_by_xor+0x4b>
cmp    $0x20,%ecx
jae    1358 <randomize_by_xor+0x258>
xor    %eax,%eax
jmp    141e <randomize_by_xor+0x31e>
lea    (%rdx,%r8,4),%rcx
lea    (%rsi,%r8,4),%rax
cmp    %rdx,%rax
seta   %r10b
lea    (%rdi,%r8,4),%rax
cmp    %rsi,%rcx
seta   %bl
cmp    %rdx,%rax
seta   %al
cmp    %rdi,%rcx
seta   %r9b
xor    %ecx,%ecx
test   %bl,%r10b
jne    12eb <randomize_by_xor+0x1eb>
and    %r9b,%al
jne    12eb <randomize_by_xor+0x1eb>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     13d1 <randomize_by_xor+0x2d1>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups (%rdi,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdi,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rax,4)
movups %xmm0,0x10(%rdx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups 0x20(%rdi,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movups 0x30(%rdi,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x20(%rdx,%rax,4)
movups %xmm0,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%r10
jne    1270 <randomize_by_xor+0x170>
test   $0x1,%r9b
je     12e6 <randomize_by_xor+0x1e6>
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups (%rdi,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdi,%rax,4),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rax,4)
movups %xmm0,0x10(%rdx,%rax,4)
cmp    %r8,%rcx
je     1356 <randomize_by_xor+0x256>
mov    %rcx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rax
and    $0x3,%rax
je     1313 <randomize_by_xor+0x213>
nopl   (%rax)
mov    (%rdi,%rcx,4),%ebx
xor    (%rsi,%rcx,4),%ebx
mov    %ebx,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1300 <randomize_by_xor+0x200>
cmp    $0x3,%r9
jb     1356 <randomize_by_xor+0x256>
nopl   0x0(%rax)
mov    (%rdi,%rcx,4),%eax
xor    (%rsi,%rcx,4),%eax
mov    %eax,(%rdx,%rcx,4)
mov    0x4(%rdi,%rcx,4),%eax
xor    0x4(%rsi,%rcx,4),%eax
mov    %eax,0x4(%rdx,%rcx,4)
mov    0x8(%rdi,%rcx,4),%eax
xor    0x8(%rsi,%rcx,4),%eax
mov    %eax,0x8(%rdx,%rcx,4)
mov    0xc(%rdi,%rcx,4),%eax
xor    0xc(%rsi,%rcx,4),%eax
mov    %eax,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1320 <randomize_by_xor+0x220>
pop    %rbx
ret
mov    %r8d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     13e2 <randomize_by_xor+0x2e2>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups (%rdi,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rcx,1)
movups %xmm0,0x10(%rdx,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups 0x20(%rdi,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x30(%rdi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x20(%rdx,%rcx,1)
movups %xmm0,0x30(%rdx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%r10
jne    1380 <randomize_by_xor+0x280>
jmp    13e4 <randomize_by_xor+0x2e4>
xor    %eax,%eax
test   $0x1,%r9b
jne    12c5 <randomize_by_xor+0x1c5>
jmp    12e6 <randomize_by_xor+0x1e6>
xor    %ecx,%ecx
test   $0x1,%r9b
je     140b <randomize_by_xor+0x30b>
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups (%rdi,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rcx,1)
movups %xmm0,0x10(%rdx,%rcx,1)
cmp    %r8,%rax
je     1356 <randomize_by_xor+0x256>
test   $0x18,%r8b
je     114b <randomize_by_xor+0x4b>
mov    %rax,%rcx
mov    %r8d,%eax
and    $0xfffffff8,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,1),%rbx
xor    (%rsi,%rcx,1),%rbx
mov    %rbx,(%rdx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1430 <randomize_by_xor+0x330>
cmp    %r8,%rax
jne    114b <randomize_by_xor+0x4b>
jmp    1356 <randomize_by_xor+0x256>

LLVM IR (-O0):
define void @randomize_by_xor(i8* %0, i8* %1, i8* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i32 %3, i32* %8
store i32 3, i32* %10
%15 = load i8*, i8** %5
%16 = ptrtoint i8* %15 to i32
%17 = and i32 %16, 3
%18 = icmp eq i32 0, %17
br i1 %18, label %19, label %68
19: ; preds = %4
%20 = load i8*, i8** %6
%21 = ptrtoint i8* %20 to i32
%22 = and i32 %21, 3
%23 = icmp eq i32 0, %22
br i1 %23, label %24, label %68
24: ; preds = %19
%25 = load i8*, i8** %7
%26 = ptrtoint i8* %25 to i32
%27 = and i32 %26, 3
%28 = icmp eq i32 0, %27
br i1 %28, label %29, label %68
29: ; preds = %24
%30 = load i32, i32* %8
%31 = and i32 %30, 3
%32 = icmp eq i32 0, %31
br i1 %32, label %33, label %68
33: ; preds = %29
%34 = load i8*, i8** %5
%35 = bitcast i8* %34 to i32*
store i32* %35, i32** %11
%36 = load i8*, i8** %6
%37 = bitcast i8* %36 to i32*
store i32* %37, i32** %12
%38 = load i8*, i8** %7
%39 = bitcast i8* %38 to i32*
store i32* %39, i32** %13
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = udiv i64 %41, 4
%43 = trunc i64 %42 to i32
store i32 %43, i32* %14
store i32 0, i32* %9
br label %44
44: ; preds = %64, %33
%45 = load i32, i32* %9
%46 = load i32, i32* %14
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %67
48: ; preds = %44
%49 = load i32*, i32** %12
%50 = load i32, i32* %9
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %49, i64 %51
%53 = load i32, i32* %52
%54 = load i32*, i32** %11
%55 = load i32, i32* %9
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %54, i64 %56
%58 = load i32, i32* %57
%59 = xor i32 %53, %58
%60 = load i32*, i32** %13
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %60, i64 %62
store i32 %59, i32* %63
br label %64
64: ; preds = %48
%65 = load i32, i32* %9
%66 = add nsw i32 %65, 1
store i32 %66, i32* %9
br label %44
67: ; preds = %44
br label %96
68: ; preds = %29, %24, %19, %4
store i32 0, i32* %9
br label %69
69: ; preds = %92, %68
%70 = load i32, i32* %9
%71 = load i32, i32* %8
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %95
73: ; preds = %69
%74 = load i8*, i8** %6
%75 = load i32, i32* %9
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
%78 = load i8, i8* %77
%79 = zext i8 %78 to i32
%80 = load i8*, i8** %5
%81 = load i32, i32* %9
%82 = sext i32 %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 %79, %85
%87 = trunc i32 %86 to i8
%88 = load i8*, i8** %7
%89 = load i32, i32* %9
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
store i8 %87, i8* %91
br label %92
92: ; preds = %73
%93 = load i32, i32* %9
%94 = add nsw i32 %93, 1
store i32 %94, i32* %9
br label %69
95: ; preds = %69
br label %96
96: ; preds = %95, %67
ret void
}

LLVM IR (-O2):
define void @randomize_by_xor(i8* %0, i8* %1, i8* %2, i32 %3) {
%5 = ptrtoint i8* %0 to i64
%6 = ptrtoint i8* %1 to i64
%7 = or i64 %6, %5
%8 = ptrtoint i8* %2 to i64
%9 = or i64 %7, %8
%10 = and i64 %9, 3
%11 = icmp eq i64 %10, 0
%12 = and i32 %3, 3
%13 = icmp eq i32 %12, 0
%14 = and i1 %13, %11
br i1 %14, label %151, label %15
15: ; preds = %4
%16 = icmp sgt i32 %3, 0
br i1 %16, label %17, label %331
17: ; preds = %15
%18 = zext i32 %3 to i64
%19 = icmp ult i32 %3, 8
br i1 %19, label %130, label %20
20: ; preds = %17
%21 = getelementptr i8, i8* %2, i64 %18
%22 = getelementptr i8, i8* %1, i64 %18
%23 = getelementptr i8, i8* %0, i64 %18
%24 = icmp ugt i8* %22, %2
%25 = icmp ugt i8* %21, %1
%26 = and i1 %24, %25
%27 = icmp ugt i8* %23, %2
%28 = icmp ugt i8* %21, %0
%29 = and i1 %27, %28
%30 = or i1 %26, %29
br i1 %30, label %130, label %31
31: ; preds = %20
%32 = icmp ult i32 %3, 32
br i1 %32, label %112, label %33
33: ; preds = %31
%34 = and i64 %18, 4294967264
%35 = add nsw i64 %34, -32
%36 = lshr exact i64 %35, 5
%37 = add nuw nsw i64 %36, 1
%38 = and i64 %37, 1
%39 = icmp eq i64 %35, 0
br i1 %39, label %85, label %40
40: ; preds = %33
%41 = and i64 %37, 1152921504606846974
br label %42
42: ; preds = %42, %40
%43 = phi i64 [ 0, %40 ], [ %82, %42 ]
%44 = phi i64 [ 0, %40 ], [ %83, %42 ]
%45 = getelementptr inbounds i8, i8* %1, i64 %43
%46 = bitcast i8* %45 to <16 x i8>*
%47 = load <16 x i8>, <16 x i8>* %46
%48 = getelementptr inbounds i8, i8* %45, i64 16
%49 = bitcast i8* %48 to <16 x i8>*
%50 = load <16 x i8>, <16 x i8>* %49
%51 = getelementptr inbounds i8, i8* %0, i64 %43
%52 = bitcast i8* %51 to <16 x i8>*
%53 = load <16 x i8>, <16 x i8>* %52
%54 = getelementptr inbounds i8, i8* %51, i64 16
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = xor <16 x i8> %53, %47
%58 = xor <16 x i8> %56, %50
%59 = getelementptr inbounds i8, i8* %2, i64 %43
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %60
%61 = getelementptr inbounds i8, i8* %59, i64 16
%62 = bitcast i8* %61 to <16 x i8>*
store <16 x i8> %58, <16 x i8>* %62
%63 = or i64 %43, 32
%64 = getelementptr inbounds i8, i8* %1, i64 %63
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds i8, i8* %0, i64 %63
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = getelementptr inbounds i8, i8* %70, i64 16
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = xor <16 x i8> %72, %66
%77 = xor <16 x i8> %75, %69
%78 = getelementptr inbounds i8, i8* %2, i64 %63
%79 = bitcast i8* %78 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %79
%80 = getelementptr inbounds i8, i8* %78, i64 16
%81 = bitcast i8* %80 to <16 x i8>*
store <16 x i8> %77, <16 x i8>* %81
%82 = add nuw i64 %43, 64
%83 = add i64 %44, 2
%84 = icmp eq i64 %83, %41
br i1 %84, label %85, label %42
85: ; preds = %42, %33
%86 = phi i64 [ 0, %33 ], [ %82, %42 ]
%87 = icmp eq i64 %38, 0
br i1 %87, label %107, label %88
88: ; preds = %85
%89 = getelementptr inbounds i8, i8* %1, i64 %86
%90 = bitcast i8* %89 to <16 x i8>*
%91 = load <16 x i8>, <16 x i8>* %90
%92 = getelementptr inbounds i8, i8* %89, i64 16
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr inbounds i8, i8* %0, i64 %86
%96 = bitcast i8* %95 to <16 x i8>*
%97 = load <16 x i8>, <16 x i8>* %96
%98 = getelementptr inbounds i8, i8* %95, i64 16
%99 = bitcast i8* %98 to <16 x i8>*
%100 = load <16 x i8>, <16 x i8>* %99
%101 = xor <16 x i8> %97, %91
%102 = xor <16 x i8> %100, %94
%103 = getelementptr inbounds i8, i8* %2, i64 %86
%104 = bitcast i8* %103 to <16 x i8>*
store <16 x i8> %101, <16 x i8>* %104
%105 = getelementptr inbounds i8, i8* %103, i64 16
%106 = bitcast i8* %105 to <16 x i8>*
store <16 x i8> %102, <16 x i8>* %106
br label %107
107: ; preds = %85, %88
%108 = icmp eq i64 %34, %18
br i1 %108, label %331, label %109
109: ; preds = %107
%110 = and i64 %18, 24
%111 = icmp eq i64 %110, 0
br i1 %111, label %130, label %112
112: ; preds = %31, %109
%113 = phi i64 [ %34, %109 ], [ 0, %31 ]
%114 = and i64 %18, 4294967288
br label %115
115: ; preds = %115, %112
%116 = phi i64 [ %113, %112 ], [ %126, %115 ]
%117 = getelementptr inbounds i8, i8* %1, i64 %116
%118 = bitcast i8* %117 to <8 x i8>*
%119 = load <8 x i8>, <8 x i8>* %118
%120 = getelementptr inbounds i8, i8* %0, i64 %116
%121 = bitcast i8* %120 to <8 x i8>*
%122 = load <8 x i8>, <8 x i8>* %121
%123 = xor <8 x i8> %122, %119
%124 = getelementptr inbounds i8, i8* %2, i64 %116
%125 = bitcast i8* %124 to <8 x i8>*
store <8 x i8> %123, <8 x i8>* %125
%126 = add nuw i64 %116, 8
%127 = icmp eq i64 %126, %114
br i1 %127, label %128, label %115
128: ; preds = %115
%129 = icmp eq i64 %114, %18
br i1 %129, label %331, label %130
130: ; preds = %20, %17, %109, %128
%131 = phi i64 [ 0, %17 ], [ 0, %20 ], [ %34, %109 ], [ %114, %128 ]
%132 = xor i64 %131, -1
%133 = add nsw i64 %132, %18
%134 = and i64 %18, 3
%135 = icmp eq i64 %134, 0
br i1 %135, label %148, label %136
136: ; preds = %130, %136
%137 = phi i64 [ %145, %136 ], [ %131, %130 ]
%138 = phi i64 [ %146, %136 ], [ 0, %130 ]
%139 = getelementptr inbounds i8, i8* %1, i64 %137
%140 = load i8, i8* %139
%141 = getelementptr inbounds i8, i8* %0, i64 %137
%142 = load i8, i8* %141
%143 = xor i8 %142, %140
%144 = getelementptr inbounds i8, i8* %2, i64 %137
store i8 %143, i8* %144
%145 = add nuw nsw i64 %137, 1
%146 = add i64 %138, 1
%147 = icmp eq i64 %146, %134
br i1 %147, label %148, label %136
148: ; preds = %136, %130
%149 = phi i64 [ %131, %130 ], [ %145, %136 ]
%150 = icmp ult i64 %133, 3
br i1 %150, label %331, label %300
151: ; preds = %4
%152 = bitcast i8* %0 to i32*
%153 = bitcast i8* %1 to i32*
%154 = bitcast i8* %2 to i32*
%155 = icmp sgt i32 %3, 3
br i1 %155, label %156, label %331
156: ; preds = %151
%157 = lshr i32 %3, 2
%158 = zext i32 %157 to i64
%159 = icmp ult i32 %3, 32
br i1 %159, label %248, label %160
160: ; preds = %156
%161 = shl nuw nsw i64 %158, 2
%162 = getelementptr i8, i8* %2, i64 %161
%163 = getelementptr i8, i8* %1, i64 %161
%164 = getelementptr i8, i8* %0, i64 %161
%165 = icmp ugt i8* %163, %2
%166 = icmp ugt i8* %162, %1
%167 = and i1 %165, %166
%168 = icmp ugt i8* %164, %2
%169 = icmp ugt i8* %162, %0
%170 = and i1 %168, %169
%171 = or i1 %167, %170
br i1 %171, label %248, label %172
172: ; preds = %160
%173 = and i64 %158, 1073741816
%174 = add nsw i64 %173, -8
%175 = lshr exact i64 %174, 3
%176 = add nuw nsw i64 %175, 1
%177 = and i64 %176, 1
%178 = icmp eq i64 %174, 0
br i1 %178, label %224, label %179
179: ; preds = %172
%180 = and i64 %176, 4611686018427387902
br label %181
181: ; preds = %181, %179
%182 = phi i64 [ 0, %179 ], [ %221, %181 ]
%183 = phi i64 [ 0, %179 ], [ %222, %181 ]
%184 = getelementptr inbounds i32, i32* %153, i64 %182
%185 = bitcast i32* %184 to <4 x i32>*
%186 = load <4 x i32>, <4 x i32>* %185
%187 = getelementptr inbounds i32, i32* %184, i64 4
%188 = bitcast i32* %187 to <4 x i32>*
%189 = load <4 x i32>, <4 x i32>* %188
%190 = getelementptr inbounds i32, i32* %152, i64 %182
%191 = bitcast i32* %190 to <4 x i32>*
%192 = load <4 x i32>, <4 x i32>* %191
%193 = getelementptr inbounds i32, i32* %190, i64 4
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = xor <4 x i32> %192, %186
%197 = xor <4 x i32> %195, %189
%198 = getelementptr inbounds i32, i32* %154, i64 %182
%199 = bitcast i32* %198 to <4 x i32>*
store <4 x i32> %196, <4 x i32>* %199
%200 = getelementptr inbounds i32, i32* %198, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
store <4 x i32> %197, <4 x i32>* %201
%202 = or i64 %182, 8
%203 = getelementptr inbounds i32, i32* %153, i64 %202
%204 = bitcast i32* %203 to <4 x i32>*
%205 = load <4 x i32>, <4 x i32>* %204
%206 = getelementptr inbounds i32, i32* %203, i64 4
%207 = bitcast i32* %206 to <4 x i32>*
%208 = load <4 x i32>, <4 x i32>* %207
%209 = getelementptr inbounds i32, i32* %152, i64 %202
%210 = bitcast i32* %209 to <4 x i32>*
%211 = load <4 x i32>, <4 x i32>* %210
%212 = getelementptr inbounds i32, i32* %209, i64 4
%213 = bitcast i32* %212 to <4 x i32>*
%214 = load <4 x i32>, <4 x i32>* %213
%215 = xor <4 x i32> %211, %205
%216 = xor <4 x i32> %214, %208
%217 = getelementptr inbounds i32, i32* %154, i64 %202
%218 = bitcast i32* %217 to <4 x i32>*
store <4 x i32> %215, <4 x i32>* %218
%219 = getelementptr inbounds i32, i32* %217, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
store <4 x i32> %216, <4 x i32>* %220
%221 = add nuw i64 %182, 16
%222 = add i64 %183, 2
%223 = icmp eq i64 %222, %180
br i1 %223, label %224, label %181
224: ; preds = %181, %172
%225 = phi i64 [ 0, %172 ], [ %221, %181 ]
%226 = icmp eq i64 %177, 0
br i1 %226, label %246, label %227
227: ; preds = %224
%228 = getelementptr inbounds i32, i32* %153, i64 %225
%229 = bitcast i32* %228 to <4 x i32>*
%230 = load <4 x i32>, <4 x i32>* %229
%231 = getelementptr inbounds i32, i32* %228, i64 4
%232 = bitcast i32* %231 to <4 x i32>*
%233 = load <4 x i32>, <4 x i32>* %232
%234 = getelementptr inbounds i32, i32* %152, i64 %225
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = getelementptr inbounds i32, i32* %234, i64 4
%238 = bitcast i32* %237 to <4 x i32>*
%239 = load <4 x i32>, <4 x i32>* %238
%240 = xor <4 x i32> %236, %230
%241 = xor <4 x i32> %239, %233
%242 = getelementptr inbounds i32, i32* %154, i64 %225
%243 = bitcast i32* %242 to <4 x i32>*
store <4 x i32> %240, <4 x i32>* %243
%244 = getelementptr inbounds i32, i32* %242, i64 4
%245 = bitcast i32* %244 to <4 x i32>*
store <4 x i32> %241, <4 x i32>* %245
br label %246
246: ; preds = %224, %227
%247 = icmp eq i64 %173, %158
br i1 %247, label %331, label %248
248: ; preds = %160, %156, %246
%249 = phi i64 [ 0, %160 ], [ 0, %156 ], [ %173, %246 ]
%250 = xor i64 %249, -1
%251 = add nsw i64 %250, %158
%252 = and i64 %158, 3
%253 = icmp eq i64 %252, 0
br i1 %253, label %266, label %254
254: ; preds = %248, %254
%255 = phi i64 [ %263, %254 ], [ %249, %248 ]
%256 = phi i64 [ %264, %254 ], [ 0, %248 ]
%257 = getelementptr inbounds i32, i32* %153, i64 %255
%258 = load i32, i32* %257
%259 = getelementptr inbounds i32, i32* %152, i64 %255
%260 = load i32, i32* %259
%261 = xor i32 %260, %258
%262 = getelementptr inbounds i32, i32* %154, i64 %255
store i32 %261, i32* %262
%263 = add nuw nsw i64 %255, 1
%264 = add i64 %256, 1
%265 = icmp eq i64 %264, %252
br i1 %265, label %266, label %254
266: ; preds = %254, %248
%267 = phi i64 [ %249, %248 ], [ %263, %254 ]
%268 = icmp ult i64 %251, 3
br i1 %268, label %331, label %269
269: ; preds = %266, %269
%270 = phi i64 [ %298, %269 ], [ %267, %266 ]
%271 = getelementptr inbounds i32, i32* %153, i64 %270
%272 = load i32, i32* %271
%273 = getelementptr inbounds i32, i32* %152, i64 %270
%274 = load i32, i32* %273
%275 = xor i32 %274, %272
%276 = getelementptr inbounds i32, i32* %154, i64 %270
store i32 %275, i32* %276
%277 = add nuw nsw i64 %270, 1
%278 = getelementptr inbounds i32, i32* %153, i64 %277
%279 = load i32, i32* %278
%280 = getelementptr inbounds i32, i32* %152, i64 %277
%281 = load i32, i32* %280
%282 = xor i32 %281, %279
%283 = getelementptr inbounds i32, i32* %154, i64 %277
store i32 %282, i32* %283
%284 = add nuw nsw i64 %270, 2
%285 = getelementptr inbounds i32, i32* %153, i64 %284
%286 = load i32, i32* %285
%287 = getelementptr inbounds i32, i32* %152, i64 %284
%288 = load i32, i32* %287
%289 = xor i32 %288, %286
%290 = getelementptr inbounds i32, i32* %154, i64 %284
store i32 %289, i32* %290
%291 = add nuw nsw i64 %270, 3
%292 = getelementptr inbounds i32, i32* %153, i64 %291
%293 = load i32, i32* %292
%294 = getelementptr inbounds i32, i32* %152, i64 %291
%295 = load i32, i32* %294
%296 = xor i32 %295, %293
%297 = getelementptr inbounds i32, i32* %154, i64 %291
store i32 %296, i32* %297
%298 = add nuw nsw i64 %270, 4
%299 = icmp eq i64 %298, %158
br i1 %299, label %331, label %269
300: ; preds = %148, %300
%301 = phi i64 [ %329, %300 ], [ %149, %148 ]
%302 = getelementptr inbounds i8, i8* %1, i64 %301
%303 = load i8, i8* %302
%304 = getelementptr inbounds i8, i8* %0, i64 %301
%305 = load i8, i8* %304
%306 = xor i8 %305, %303
%307 = getelementptr inbounds i8, i8* %2, i64 %301
store i8 %306, i8* %307
%308 = add nuw nsw i64 %301, 1
%309 = getelementptr inbounds i8, i8* %1, i64 %308
%310 = load i8, i8* %309
%311 = getelementptr inbounds i8, i8* %0, i64 %308
%312 = load i8, i8* %311
%313 = xor i8 %312, %310
%314 = getelementptr inbounds i8, i8* %2, i64 %308
store i8 %313, i8* %314
%315 = add nuw nsw i64 %301, 2
%316 = getelementptr inbounds i8, i8* %1, i64 %315
%317 = load i8, i8* %316
%318 = getelementptr inbounds i8, i8* %0, i64 %315
%319 = load i8, i8* %318
%320 = xor i8 %319, %317
%321 = getelementptr inbounds i8, i8* %2, i64 %315
store i8 %320, i8* %321
%322 = add nuw nsw i64 %301, 3
%323 = getelementptr inbounds i8, i8* %1, i64 %322
%324 = load i8, i8* %323
%325 = getelementptr inbounds i8, i8* %0, i64 %322
%326 = load i8, i8* %325
%327 = xor i8 %326, %324
%328 = getelementptr inbounds i8, i8* %2, i64 %322
store i8 %327, i8* %328
%329 = add nuw nsw i64 %301, 4
%330 = icmp eq i64 %329, %18
br i1 %330, label %331, label %300
331: ; preds = %148, %300, %266, %269, %107, %128, %246, %15, %151
ret void
}