#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 */
void swap(const void *lhs, const void *rhs, size_t length) {
  unsigned char *p_lhs = (unsigned char *)lhs;
  unsigned char *p_rhs = (unsigned char *)rhs;
  size_t i;
  for (i = 0; i < length; i++) {
    p_lhs[i] ^= p_rhs[i];
  }
  for (i = 0; i < length; i++) {
    p_rhs[i] ^= p_lhs[i];
  }
  for (i = 0; i < length; i++) {
    p_lhs[i] ^= p_rhs[i];
  }
}


x86 assembly (clang, -O0):
<swap>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1164 <swap+0x64>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1128 <swap+0x28>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11a8 <swap+0xa8>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    116c <swap+0x6c>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11ec <swap+0xec>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11b0 <swap+0xb0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<swap>:
test   %rdx,%rdx
je     12d3 <swap+0x1d3>
cmp    $0x8,%rdx
jb     1129 <swap+0x29>
lea    (%rsi,%rdx,1),%rax
cmp    %rdi,%rax
jbe    12d4 <swap+0x1d4>
lea    (%rdi,%rdx,1),%rax
cmp    %rsi,%rax
jbe    12d4 <swap+0x1d4>
xor    %r10d,%r10d
mov    %r10,%r8
not    %r8
add    %rdx,%r8
mov    %rdx,%rcx
and    $0x3,%rcx
je     1153 <swap+0x53>
xchg   %ax,%ax
movzbl (%rsi,%r10,1),%eax
xor    %al,(%rdi,%r10,1)
add    $0x1,%r10
add    $0xffffffffffffffff,%rcx
jne    1140 <swap+0x40>
cmp    $0x3,%r8
jb     1193 <swap+0x93>
nopl   0x0(%rax)
movzbl (%rsi,%r10,1),%eax
xor    %al,(%rdi,%r10,1)
movzbl 0x1(%rsi,%r10,1),%eax
xor    %al,0x1(%rdi,%r10,1)
movzbl 0x2(%rsi,%r10,1),%eax
xor    %al,0x2(%rdi,%r10,1)
movzbl 0x3(%rsi,%r10,1),%eax
xor    %al,0x3(%rdi,%r10,1)
add    $0x4,%r10
cmp    %r10,%rdx
jne    1160 <swap+0x60>
test   %rdx,%rdx
je     12d3 <swap+0x1d3>
cmp    $0x8,%rdx
jb     11bc <swap+0xbc>
lea    (%rdi,%rdx,1),%rax
cmp    %rsi,%rax
jbe    12e2 <swap+0x1e2>
lea    (%rsi,%rdx,1),%rax
cmp    %rdi,%rax
jbe    12e2 <swap+0x1e2>
xor    %r10d,%r10d
mov    %r10,%r8
not    %r8
add    %rdx,%r8
mov    %rdx,%rcx
and    $0x3,%rcx
je     11f3 <swap+0xf3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%r10,1),%eax
xor    %al,(%rsi,%r10,1)
add    $0x1,%r10
add    $0xffffffffffffffff,%rcx
jne    11e0 <swap+0xe0>
cmp    $0x3,%r8
jb     1233 <swap+0x133>
nopl   0x0(%rax)
movzbl (%rdi,%r10,1),%eax
xor    %al,(%rsi,%r10,1)
movzbl 0x1(%rdi,%r10,1),%eax
xor    %al,0x1(%rsi,%r10,1)
movzbl 0x2(%rdi,%r10,1),%eax
xor    %al,0x2(%rsi,%r10,1)
movzbl 0x3(%rdi,%r10,1),%eax
xor    %al,0x3(%rsi,%r10,1)
add    $0x4,%r10
cmp    %r10,%rdx
jne    1200 <swap+0x100>
test   %rdx,%rdx
je     12d3 <swap+0x1d3>
cmp    $0x8,%rdx
jb     125c <swap+0x15c>
lea    (%rsi,%rdx,1),%rax
cmp    %rdi,%rax
jbe    13df <swap+0x2df>
lea    (%rdi,%rdx,1),%rax
cmp    %rsi,%rax
jbe    13df <swap+0x2df>
xor    %r10d,%r10d
mov    %r10,%r8
not    %r8
add    %rdx,%r8
mov    %rdx,%rcx
and    $0x3,%rcx
je     1293 <swap+0x193>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%r10,1),%eax
xor    %al,(%rdi,%r10,1)
add    $0x1,%r10
add    $0xffffffffffffffff,%rcx
jne    1280 <swap+0x180>
cmp    $0x3,%r8
jb     12d3 <swap+0x1d3>
nopl   0x0(%rax)
movzbl (%rsi,%r10,1),%eax
xor    %al,(%rdi,%r10,1)
movzbl 0x1(%rsi,%r10,1),%eax
xor    %al,0x1(%rdi,%r10,1)
movzbl 0x2(%rsi,%r10,1),%eax
xor    %al,0x2(%rdi,%r10,1)
movzbl 0x3(%rsi,%r10,1),%eax
xor    %al,0x3(%rdi,%r10,1)
add    $0x4,%r10
cmp    %r10,%rdx
jne    12a0 <swap+0x1a0>
ret
cmp    $0x20,%rdx
jae    12f4 <swap+0x1f4>
xor    %r10d,%r10d
jmp    13a8 <swap+0x2a8>
cmp    $0x20,%rdx
jae    13f1 <swap+0x2f1>
xor    %r10d,%r10d
jmp    14a8 <swap+0x3a8>
mov    %rdx,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1561 <swap+0x461>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
nopl   0x0(%rax)
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 0x20(%rdi,%rcx,1),%xmm1
movups 0x30(%rdi,%rcx,1),%xmm3
movups %xmm2,(%rdi,%rcx,1)
movups %xmm0,0x10(%rdi,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rdi,%rcx,1)
movups %xmm1,0x30(%rdi,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%r9
jne    1320 <swap+0x220>
test   $0x1,%r8b
je     1396 <swap+0x296>
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,(%rdi,%rcx,1)
movups %xmm0,0x10(%rdi,%rcx,1)
cmp    %rdx,%r10
je     1193 <swap+0x93>
test   $0x18,%dl
je     112c <swap+0x2c>
mov    %r10,%r8
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%r8,1),%rcx
xor    %rcx,(%rdi,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    13c0 <swap+0x2c0>
cmp    %rdx,%r10
je     1193 <swap+0x93>
jmp    112c <swap+0x2c>
cmp    $0x20,%rdx
jae    14df <swap+0x3df>
xor    %r10d,%r10d
jmp    15be <swap+0x4be>
mov    %rdx,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1572 <swap+0x472>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups (%rsi,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rsi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rsi,%rcx,1),%xmm1
movups 0x30(%rsi,%rcx,1),%xmm3
movups %xmm2,(%rsi,%rcx,1)
movups %xmm0,0x10(%rsi,%rcx,1)
movups 0x20(%rdi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%rdi,%rcx,1),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rsi,%rcx,1)
movups %xmm1,0x30(%rsi,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%r9
jne    1420 <swap+0x320>
test   $0x1,%r8b
je     1496 <swap+0x396>
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups (%rsi,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rsi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rcx,1)
movups %xmm0,0x10(%rsi,%rcx,1)
cmp    %rdx,%r10
je     1233 <swap+0x133>
test   $0x18,%dl
je     11bf <swap+0xbf>
mov    %r10,%r8
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%r8,1),%rcx
xor    %rcx,(%rsi,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    14c0 <swap+0x3c0>
cmp    %rdx,%r10
je     1233 <swap+0x133>
jmp    11bf <swap+0xbf>
mov    %rdx,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1583 <swap+0x483>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
nopw   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 0x20(%rdi,%rcx,1),%xmm1
movups 0x30(%rdi,%rcx,1),%xmm3
movups %xmm2,(%rdi,%rcx,1)
movups %xmm0,0x10(%rdi,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rdi,%rcx,1)
movups %xmm1,0x30(%rdi,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%r9
jne    1510 <swap+0x410>
jmp    1585 <swap+0x485>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1375 <swap+0x275>
jmp    1396 <swap+0x296>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1475 <swap+0x375>
jmp    1496 <swap+0x396>
xor    %ecx,%ecx
test   $0x1,%r8b
je     15ac <swap+0x4ac>
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,(%rdi,%rcx,1)
movups %xmm0,0x10(%rdi,%rcx,1)
cmp    %rdx,%r10
je     12d3 <swap+0x1d3>
test   $0x18,%dl
je     125f <swap+0x15f>
mov    %r10,%r8
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%r8,1),%rcx
xor    %rcx,(%rdi,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    15d0 <swap+0x4d0>
cmp    %rdx,%r10
je     12d3 <swap+0x1d3>
jmp    125f <swap+0x15f>

LLVM IR (-O0):
define void @swap(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i64
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%10 = load i8*, i8** %4
store i8* %10, i8** %7
%11 = load i8*, i8** %5
store i8* %11, i8** %8
store i64 0, i64* %9
br label %12
12: ; preds = %29, %3
%13 = load i64, i64* %9
%14 = load i64, i64* %6
%15 = icmp ult i64 %13, %14
br i1 %15, label %16, label %32
16: ; preds = %12
%17 = load i8*, i8** %8
%18 = load i64, i64* %9
%19 = getelementptr inbounds i8, i8* %17, i64 %18
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = load i8*, i8** %7
%23 = load i64, i64* %9
%24 = getelementptr inbounds i8, i8* %22, i64 %23
%25 = load i8, i8* %24
%26 = zext i8 %25 to i32
%27 = xor i32 %26, %21
%28 = trunc i32 %27 to i8
store i8 %28, i8* %24
br label %29
29: ; preds = %16
%30 = load i64, i64* %9
%31 = add i64 %30, 1
store i64 %31, i64* %9
br label %12
32: ; preds = %12
store i64 0, i64* %9
br label %33
33: ; preds = %50, %32
%34 = load i64, i64* %9
%35 = load i64, i64* %6
%36 = icmp ult i64 %34, %35
br i1 %36, label %37, label %53
37: ; preds = %33
%38 = load i8*, i8** %7
%39 = load i64, i64* %9
%40 = getelementptr inbounds i8, i8* %38, i64 %39
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = load i8*, i8** %8
%44 = load i64, i64* %9
%45 = getelementptr inbounds i8, i8* %43, i64 %44
%46 = load i8, i8* %45
%47 = zext i8 %46 to i32
%48 = xor i32 %47, %42
%49 = trunc i32 %48 to i8
store i8 %49, i8* %45
br label %50
50: ; preds = %37
%51 = load i64, i64* %9
%52 = add i64 %51, 1
store i64 %52, i64* %9
br label %33
53: ; preds = %33
store i64 0, i64* %9
br label %54
54: ; preds = %71, %53
%55 = load i64, i64* %9
%56 = load i64, i64* %6
%57 = icmp ult i64 %55, %56
br i1 %57, label %58, label %74
58: ; preds = %54
%59 = load i8*, i8** %8
%60 = load i64, i64* %9
%61 = getelementptr inbounds i8, i8* %59, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i32
%64 = load i8*, i8** %7
%65 = load i64, i64* %9
%66 = getelementptr inbounds i8, i8* %64, i64 %65
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = xor i32 %68, %63
%70 = trunc i32 %69 to i8
store i8 %70, i8* %66
br label %71
71: ; preds = %58
%72 = load i64, i64* %9
%73 = add i64 %72, 1
store i64 %73, i64* %9
br label %54
74: ; preds = %54
ret void
}

LLVM IR (-O2):
define void @swap(i8* nocapture %0, i8* nocapture %1, i64 %2) {
%4 = icmp eq i64 %2, 0
br i1 %4, label %448, label %5
5: ; preds = %3
%6 = icmp ult i64 %2, 8
br i1 %6, label %105, label %7
7: ; preds = %5
%8 = getelementptr i8, i8* %0, i64 %2
%9 = getelementptr i8, i8* %1, i64 %2
%10 = icmp ugt i8* %9, %0
%11 = icmp ugt i8* %8, %1
%12 = and i1 %10, %11
br i1 %12, label %105, label %13
13: ; preds = %7
%14 = icmp ult i64 %2, 32
br i1 %14, label %88, label %15
15: ; preds = %13
%16 = and i64 %2, -32
%17 = add i64 %16, -32
%18 = lshr exact i64 %17, 5
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 1
%21 = icmp eq i64 %17, 0
br i1 %21, label %63, label %22
22: ; preds = %15
%23 = and i64 %19, 1152921504606846974
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %60, %24 ]
%26 = phi i64 [ 0, %22 ], [ %61, %24 ]
%27 = getelementptr inbounds i8, i8* %1, i64 %25
%28 = bitcast i8* %27 to <16 x i8>*
%29 = load <16 x i8>, <16 x i8>* %28
%30 = getelementptr inbounds i8, i8* %27, i64 16
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = getelementptr inbounds i8, i8* %0, i64 %25
%34 = bitcast i8* %33 to <16 x i8>*
%35 = load <16 x i8>, <16 x i8>* %34
%36 = getelementptr inbounds i8, i8* %33, i64 16
%37 = bitcast i8* %36 to <16 x i8>*
%38 = load <16 x i8>, <16 x i8>* %37
%39 = xor <16 x i8> %35, %29
%40 = xor <16 x i8> %38, %32
%41 = bitcast i8* %33 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %41
%42 = bitcast i8* %36 to <16 x i8>*
store <16 x i8> %40, <16 x i8>* %42
%43 = or i64 %25, 32
%44 = getelementptr inbounds i8, i8* %1, i64 %43
%45 = bitcast i8* %44 to <16 x i8>*
%46 = load <16 x i8>, <16 x i8>* %45
%47 = getelementptr inbounds i8, i8* %44, i64 16
%48 = bitcast i8* %47 to <16 x i8>*
%49 = load <16 x i8>, <16 x i8>* %48
%50 = getelementptr inbounds i8, i8* %0, i64 %43
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr inbounds i8, i8* %50, i64 16
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = xor <16 x i8> %52, %46
%57 = xor <16 x i8> %55, %49
%58 = bitcast i8* %50 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %58
%59 = bitcast i8* %53 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %59
%60 = add nuw i64 %25, 64
%61 = add i64 %26, 2
%62 = icmp eq i64 %61, %23
br i1 %62, label %63, label %24
63: ; preds = %24, %15
%64 = phi i64 [ 0, %15 ], [ %60, %24 ]
%65 = icmp eq i64 %20, 0
br i1 %65, label %83, label %66
66: ; preds = %63
%67 = getelementptr inbounds i8, i8* %1, i64 %64
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds i8, i8* %67, i64 16
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = getelementptr inbounds i8, i8* %0, i64 %64
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = getelementptr inbounds i8, i8* %73, i64 16
%77 = bitcast i8* %76 to <16 x i8>*
%78 = load <16 x i8>, <16 x i8>* %77
%79 = xor <16 x i8> %75, %69
%80 = xor <16 x i8> %78, %72
%81 = bitcast i8* %73 to <16 x i8>*
store <16 x i8> %79, <16 x i8>* %81
%82 = bitcast i8* %76 to <16 x i8>*
store <16 x i8> %80, <16 x i8>* %82
br label %83
83: ; preds = %63, %66
%84 = icmp eq i64 %16, %2
br i1 %84, label %125, label %85
85: ; preds = %83
%86 = and i64 %2, 24
%87 = icmp eq i64 %86, 0
br i1 %87, label %105, label %88
88: ; preds = %13, %85
%89 = phi i64 [ %16, %85 ], [ 0, %13 ]
%90 = and i64 %2, -8
br label %91
91: ; preds = %91, %88
%92 = phi i64 [ %89, %88 ], [ %101, %91 ]
%93 = getelementptr inbounds i8, i8* %1, i64 %92
%94 = bitcast i8* %93 to <8 x i8>*
%95 = load <8 x i8>, <8 x i8>* %94
%96 = getelementptr inbounds i8, i8* %0, i64 %92
%97 = bitcast i8* %96 to <8 x i8>*
%98 = load <8 x i8>, <8 x i8>* %97
%99 = xor <8 x i8> %98, %95
%100 = bitcast i8* %96 to <8 x i8>*
store <8 x i8> %99, <8 x i8>* %100
%101 = add nuw i64 %92, 8
%102 = icmp eq i64 %101, %90
br i1 %102, label %103, label %91
103: ; preds = %91
%104 = icmp eq i64 %90, %2
br i1 %104, label %125, label %105
105: ; preds = %7, %5, %85, %103
%106 = phi i64 [ 0, %5 ], [ 0, %7 ], [ %16, %85 ], [ %90, %103 ]
%107 = xor i64 %106, -1
%108 = add i64 %107, %2
%109 = and i64 %2, 3
%110 = icmp eq i64 %109, 0
br i1 %110, label %122, label %111
111: ; preds = %105, %111
%112 = phi i64 [ %119, %111 ], [ %106, %105 ]
%113 = phi i64 [ %120, %111 ], [ 0, %105 ]
%114 = getelementptr inbounds i8, i8* %1, i64 %112
%115 = load i8, i8* %114
%116 = getelementptr inbounds i8, i8* %0, i64 %112
%117 = load i8, i8* %116
%118 = xor i8 %117, %115
store i8 %118, i8* %116
%119 = add nuw i64 %112, 1
%120 = add i64 %113, 1
%121 = icmp eq i64 %120, %109
br i1 %121, label %122, label %111
122: ; preds = %111, %105
%123 = phi i64 [ %106, %105 ], [ %119, %111 ]
%124 = icmp ult i64 %108, 3
br i1 %124, label %125, label %246
125: ; preds = %122, %246, %103, %83
br i1 %4, label %448, label %126
126: ; preds = %125
%127 = icmp ult i64 %2, 8
br i1 %127, label %226, label %128
128: ; preds = %126
%129 = getelementptr i8, i8* %1, i64 %2
%130 = getelementptr i8, i8* %0, i64 %2
%131 = icmp ugt i8* %130, %1
%132 = icmp ugt i8* %129, %0
%133 = and i1 %131, %132
br i1 %133, label %226, label %134
134: ; preds = %128
%135 = icmp ult i64 %2, 32
br i1 %135, label %209, label %136
136: ; preds = %134
%137 = and i64 %2, -32
%138 = add i64 %137, -32
%139 = lshr exact i64 %138, 5
%140 = add nuw nsw i64 %139, 1
%141 = and i64 %140, 1
%142 = icmp eq i64 %138, 0
br i1 %142, label %184, label %143
143: ; preds = %136
%144 = and i64 %140, 1152921504606846974
br label %145
145: ; preds = %145, %143
%146 = phi i64 [ 0, %143 ], [ %181, %145 ]
%147 = phi i64 [ 0, %143 ], [ %182, %145 ]
%148 = getelementptr inbounds i8, i8* %0, i64 %146
%149 = bitcast i8* %148 to <16 x i8>*
%150 = load <16 x i8>, <16 x i8>* %149
%151 = getelementptr inbounds i8, i8* %148, i64 16
%152 = bitcast i8* %151 to <16 x i8>*
%153 = load <16 x i8>, <16 x i8>* %152
%154 = getelementptr inbounds i8, i8* %1, i64 %146
%155 = bitcast i8* %154 to <16 x i8>*
%156 = load <16 x i8>, <16 x i8>* %155
%157 = getelementptr inbounds i8, i8* %154, i64 16
%158 = bitcast i8* %157 to <16 x i8>*
%159 = load <16 x i8>, <16 x i8>* %158
%160 = xor <16 x i8> %156, %150
%161 = xor <16 x i8> %159, %153
%162 = bitcast i8* %154 to <16 x i8>*
store <16 x i8> %160, <16 x i8>* %162
%163 = bitcast i8* %157 to <16 x i8>*
store <16 x i8> %161, <16 x i8>* %163
%164 = or i64 %146, 32
%165 = getelementptr inbounds i8, i8* %0, i64 %164
%166 = bitcast i8* %165 to <16 x i8>*
%167 = load <16 x i8>, <16 x i8>* %166
%168 = getelementptr inbounds i8, i8* %165, i64 16
%169 = bitcast i8* %168 to <16 x i8>*
%170 = load <16 x i8>, <16 x i8>* %169
%171 = getelementptr inbounds i8, i8* %1, i64 %164
%172 = bitcast i8* %171 to <16 x i8>*
%173 = load <16 x i8>, <16 x i8>* %172
%174 = getelementptr inbounds i8, i8* %171, i64 16
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = xor <16 x i8> %173, %167
%178 = xor <16 x i8> %176, %170
%179 = bitcast i8* %171 to <16 x i8>*
store <16 x i8> %177, <16 x i8>* %179
%180 = bitcast i8* %174 to <16 x i8>*
store <16 x i8> %178, <16 x i8>* %180
%181 = add nuw i64 %146, 64
%182 = add i64 %147, 2
%183 = icmp eq i64 %182, %144
br i1 %183, label %184, label %145
184: ; preds = %145, %136
%185 = phi i64 [ 0, %136 ], [ %181, %145 ]
%186 = icmp eq i64 %141, 0
br i1 %186, label %204, label %187
187: ; preds = %184
%188 = getelementptr inbounds i8, i8* %0, i64 %185
%189 = bitcast i8* %188 to <16 x i8>*
%190 = load <16 x i8>, <16 x i8>* %189
%191 = getelementptr inbounds i8, i8* %188, i64 16
%192 = bitcast i8* %191 to <16 x i8>*
%193 = load <16 x i8>, <16 x i8>* %192
%194 = getelementptr inbounds i8, i8* %1, i64 %185
%195 = bitcast i8* %194 to <16 x i8>*
%196 = load <16 x i8>, <16 x i8>* %195
%197 = getelementptr inbounds i8, i8* %194, i64 16
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = xor <16 x i8> %196, %190
%201 = xor <16 x i8> %199, %193
%202 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %200, <16 x i8>* %202
%203 = bitcast i8* %197 to <16 x i8>*
store <16 x i8> %201, <16 x i8>* %203
br label %204
204: ; preds = %184, %187
%205 = icmp eq i64 %137, %2
br i1 %205, label %273, label %206
206: ; preds = %204
%207 = and i64 %2, 24
%208 = icmp eq i64 %207, 0
br i1 %208, label %226, label %209
209: ; preds = %134, %206
%210 = phi i64 [ %137, %206 ], [ 0, %134 ]
%211 = and i64 %2, -8
br label %212
212: ; preds = %212, %209
%213 = phi i64 [ %210, %209 ], [ %222, %212 ]
%214 = getelementptr inbounds i8, i8* %0, i64 %213
%215 = bitcast i8* %214 to <8 x i8>*
%216 = load <8 x i8>, <8 x i8>* %215
%217 = getelementptr inbounds i8, i8* %1, i64 %213
%218 = bitcast i8* %217 to <8 x i8>*
%219 = load <8 x i8>, <8 x i8>* %218
%220 = xor <8 x i8> %219, %216
%221 = bitcast i8* %217 to <8 x i8>*
store <8 x i8> %220, <8 x i8>* %221
%222 = add nuw i64 %213, 8
%223 = icmp eq i64 %222, %211
br i1 %223, label %224, label %212
224: ; preds = %212
%225 = icmp eq i64 %211, %2
br i1 %225, label %273, label %226
226: ; preds = %128, %126, %206, %224
%227 = phi i64 [ 0, %126 ], [ 0, %128 ], [ %137, %206 ], [ %211, %224 ]
%228 = xor i64 %227, -1
%229 = add i64 %228, %2
%230 = and i64 %2, 3
%231 = icmp eq i64 %230, 0
br i1 %231, label %243, label %232
232: ; preds = %226, %232
%233 = phi i64 [ %240, %232 ], [ %227, %226 ]
%234 = phi i64 [ %241, %232 ], [ 0, %226 ]
%235 = getelementptr inbounds i8, i8* %0, i64 %233
%236 = load i8, i8* %235
%237 = getelementptr inbounds i8, i8* %1, i64 %233
%238 = load i8, i8* %237
%239 = xor i8 %238, %236
store i8 %239, i8* %237
%240 = add nuw i64 %233, 1
%241 = add i64 %234, 1
%242 = icmp eq i64 %241, %230
br i1 %242, label %243, label %232
243: ; preds = %232, %226
%244 = phi i64 [ %227, %226 ], [ %240, %232 ]
%245 = icmp ult i64 %229, 3
br i1 %245, label %273, label %394
246: ; preds = %122, %246
%247 = phi i64 [ %271, %246 ], [ %123, %122 ]
%248 = getelementptr inbounds i8, i8* %1, i64 %247
%249 = load i8, i8* %248
%250 = getelementptr inbounds i8, i8* %0, i64 %247
%251 = load i8, i8* %250
%252 = xor i8 %251, %249
store i8 %252, i8* %250
%253 = add nuw i64 %247, 1
%254 = getelementptr inbounds i8, i8* %1, i64 %253
%255 = load i8, i8* %254
%256 = getelementptr inbounds i8, i8* %0, i64 %253
%257 = load i8, i8* %256
%258 = xor i8 %257, %255
store i8 %258, i8* %256
%259 = add nuw i64 %247, 2
%260 = getelementptr inbounds i8, i8* %1, i64 %259
%261 = load i8, i8* %260
%262 = getelementptr inbounds i8, i8* %0, i64 %259
%263 = load i8, i8* %262
%264 = xor i8 %263, %261
store i8 %264, i8* %262
%265 = add nuw i64 %247, 3
%266 = getelementptr inbounds i8, i8* %1, i64 %265
%267 = load i8, i8* %266
%268 = getelementptr inbounds i8, i8* %0, i64 %265
%269 = load i8, i8* %268
%270 = xor i8 %269, %267
store i8 %270, i8* %268
%271 = add nuw i64 %247, 4
%272 = icmp eq i64 %271, %2
br i1 %272, label %125, label %246
273: ; preds = %243, %394, %224, %204
br i1 %4, label %448, label %274
274: ; preds = %273
%275 = icmp ult i64 %2, 8
br i1 %275, label %374, label %276
276: ; preds = %274
%277 = getelementptr i8, i8* %0, i64 %2
%278 = getelementptr i8, i8* %1, i64 %2
%279 = icmp ugt i8* %278, %0
%280 = icmp ugt i8* %277, %1
%281 = and i1 %279, %280
br i1 %281, label %374, label %282
282: ; preds = %276
%283 = icmp ult i64 %2, 32
br i1 %283, label %357, label %284
284: ; preds = %282
%285 = and i64 %2, -32
%286 = add i64 %285, -32
%287 = lshr exact i64 %286, 5
%288 = add nuw nsw i64 %287, 1
%289 = and i64 %288, 1
%290 = icmp eq i64 %286, 0
br i1 %290, label %332, label %291
291: ; preds = %284
%292 = and i64 %288, 1152921504606846974
br label %293
293: ; preds = %293, %291
%294 = phi i64 [ 0, %291 ], [ %329, %293 ]
%295 = phi i64 [ 0, %291 ], [ %330, %293 ]
%296 = getelementptr inbounds i8, i8* %1, i64 %294
%297 = bitcast i8* %296 to <16 x i8>*
%298 = load <16 x i8>, <16 x i8>* %297
%299 = getelementptr inbounds i8, i8* %296, i64 16
%300 = bitcast i8* %299 to <16 x i8>*
%301 = load <16 x i8>, <16 x i8>* %300
%302 = getelementptr inbounds i8, i8* %0, i64 %294
%303 = bitcast i8* %302 to <16 x i8>*
%304 = load <16 x i8>, <16 x i8>* %303
%305 = getelementptr inbounds i8, i8* %302, i64 16
%306 = bitcast i8* %305 to <16 x i8>*
%307 = load <16 x i8>, <16 x i8>* %306
%308 = xor <16 x i8> %304, %298
%309 = xor <16 x i8> %307, %301
%310 = bitcast i8* %302 to <16 x i8>*
store <16 x i8> %308, <16 x i8>* %310
%311 = bitcast i8* %305 to <16 x i8>*
store <16 x i8> %309, <16 x i8>* %311
%312 = or i64 %294, 32
%313 = getelementptr inbounds i8, i8* %1, i64 %312
%314 = bitcast i8* %313 to <16 x i8>*
%315 = load <16 x i8>, <16 x i8>* %314
%316 = getelementptr inbounds i8, i8* %313, i64 16
%317 = bitcast i8* %316 to <16 x i8>*
%318 = load <16 x i8>, <16 x i8>* %317
%319 = getelementptr inbounds i8, i8* %0, i64 %312
%320 = bitcast i8* %319 to <16 x i8>*
%321 = load <16 x i8>, <16 x i8>* %320
%322 = getelementptr inbounds i8, i8* %319, i64 16
%323 = bitcast i8* %322 to <16 x i8>*
%324 = load <16 x i8>, <16 x i8>* %323
%325 = xor <16 x i8> %321, %315
%326 = xor <16 x i8> %324, %318
%327 = bitcast i8* %319 to <16 x i8>*
store <16 x i8> %325, <16 x i8>* %327
%328 = bitcast i8* %322 to <16 x i8>*
store <16 x i8> %326, <16 x i8>* %328
%329 = add nuw i64 %294, 64
%330 = add i64 %295, 2
%331 = icmp eq i64 %330, %292
br i1 %331, label %332, label %293
332: ; preds = %293, %284
%333 = phi i64 [ 0, %284 ], [ %329, %293 ]
%334 = icmp eq i64 %289, 0
br i1 %334, label %352, label %335
335: ; preds = %332
%336 = getelementptr inbounds i8, i8* %1, i64 %333
%337 = bitcast i8* %336 to <16 x i8>*
%338 = load <16 x i8>, <16 x i8>* %337
%339 = getelementptr inbounds i8, i8* %336, i64 16
%340 = bitcast i8* %339 to <16 x i8>*
%341 = load <16 x i8>, <16 x i8>* %340
%342 = getelementptr inbounds i8, i8* %0, i64 %333
%343 = bitcast i8* %342 to <16 x i8>*
%344 = load <16 x i8>, <16 x i8>* %343
%345 = getelementptr inbounds i8, i8* %342, i64 16
%346 = bitcast i8* %345 to <16 x i8>*
%347 = load <16 x i8>, <16 x i8>* %346
%348 = xor <16 x i8> %344, %338
%349 = xor <16 x i8> %347, %341
%350 = bitcast i8* %342 to <16 x i8>*
store <16 x i8> %348, <16 x i8>* %350
%351 = bitcast i8* %345 to <16 x i8>*
store <16 x i8> %349, <16 x i8>* %351
br label %352
352: ; preds = %332, %335
%353 = icmp eq i64 %285, %2
br i1 %353, label %448, label %354
354: ; preds = %352
%355 = and i64 %2, 24
%356 = icmp eq i64 %355, 0
br i1 %356, label %374, label %357
357: ; preds = %282, %354
%358 = phi i64 [ %285, %354 ], [ 0, %282 ]
%359 = and i64 %2, -8
br label %360
360: ; preds = %360, %357
%361 = phi i64 [ %358, %357 ], [ %370, %360 ]
%362 = getelementptr inbounds i8, i8* %1, i64 %361
%363 = bitcast i8* %362 to <8 x i8>*
%364 = load <8 x i8>, <8 x i8>* %363
%365 = getelementptr inbounds i8, i8* %0, i64 %361
%366 = bitcast i8* %365 to <8 x i8>*
%367 = load <8 x i8>, <8 x i8>* %366
%368 = xor <8 x i8> %367, %364
%369 = bitcast i8* %365 to <8 x i8>*
store <8 x i8> %368, <8 x i8>* %369
%370 = add nuw i64 %361, 8
%371 = icmp eq i64 %370, %359
br i1 %371, label %372, label %360
372: ; preds = %360
%373 = icmp eq i64 %359, %2
br i1 %373, label %448, label %374
374: ; preds = %276, %274, %354, %372
%375 = phi i64 [ 0, %274 ], [ 0, %276 ], [ %285, %354 ], [ %359, %372 ]
%376 = xor i64 %375, -1
%377 = add i64 %376, %2
%378 = and i64 %2, 3
%379 = icmp eq i64 %378, 0
br i1 %379, label %391, label %380
380: ; preds = %374, %380
%381 = phi i64 [ %388, %380 ], [ %375, %374 ]
%382 = phi i64 [ %389, %380 ], [ 0, %374 ]
%383 = getelementptr inbounds i8, i8* %1, i64 %381
%384 = load i8, i8* %383
%385 = getelementptr inbounds i8, i8* %0, i64 %381
%386 = load i8, i8* %385
%387 = xor i8 %386, %384
store i8 %387, i8* %385
%388 = add nuw i64 %381, 1
%389 = add i64 %382, 1
%390 = icmp eq i64 %389, %378
br i1 %390, label %391, label %380
391: ; preds = %380, %374
%392 = phi i64 [ %375, %374 ], [ %388, %380 ]
%393 = icmp ult i64 %377, 3
br i1 %393, label %448, label %421
394: ; preds = %243, %394
%395 = phi i64 [ %419, %394 ], [ %244, %243 ]
%396 = getelementptr inbounds i8, i8* %0, i64 %395
%397 = load i8, i8* %396
%398 = getelementptr inbounds i8, i8* %1, i64 %395
%399 = load i8, i8* %398
%400 = xor i8 %399, %397
store i8 %400, i8* %398
%401 = add nuw i64 %395, 1
%402 = getelementptr inbounds i8, i8* %0, i64 %401
%403 = load i8, i8* %402
%404 = getelementptr inbounds i8, i8* %1, i64 %401
%405 = load i8, i8* %404
%406 = xor i8 %405, %403
store i8 %406, i8* %404
%407 = add nuw i64 %395, 2
%408 = getelementptr inbounds i8, i8* %0, i64 %407
%409 = load i8, i8* %408
%410 = getelementptr inbounds i8, i8* %1, i64 %407
%411 = load i8, i8* %410
%412 = xor i8 %411, %409
store i8 %412, i8* %410
%413 = add nuw i64 %395, 3
%414 = getelementptr inbounds i8, i8* %0, i64 %413
%415 = load i8, i8* %414
%416 = getelementptr inbounds i8, i8* %1, i64 %413
%417 = load i8, i8* %416
%418 = xor i8 %417, %415
store i8 %418, i8* %416
%419 = add nuw i64 %395, 4
%420 = icmp eq i64 %419, %2
br i1 %420, label %273, label %394
421: ; preds = %391, %421
%422 = phi i64 [ %446, %421 ], [ %392, %391 ]
%423 = getelementptr inbounds i8, i8* %1, i64 %422
%424 = load i8, i8* %423
%425 = getelementptr inbounds i8, i8* %0, i64 %422
%426 = load i8, i8* %425
%427 = xor i8 %426, %424
store i8 %427, i8* %425
%428 = add nuw i64 %422, 1
%429 = getelementptr inbounds i8, i8* %1, i64 %428
%430 = load i8, i8* %429
%431 = getelementptr inbounds i8, i8* %0, i64 %428
%432 = load i8, i8* %431
%433 = xor i8 %432, %430
store i8 %433, i8* %431
%434 = add nuw i64 %422, 2
%435 = getelementptr inbounds i8, i8* %1, i64 %434
%436 = load i8, i8* %435
%437 = getelementptr inbounds i8, i8* %0, i64 %434
%438 = load i8, i8* %437
%439 = xor i8 %438, %436
store i8 %439, i8* %437
%440 = add nuw i64 %422, 3
%441 = getelementptr inbounds i8, i8* %1, i64 %440
%442 = load i8, i8* %441
%443 = getelementptr inbounds i8, i8* %0, i64 %440
%444 = load i8, i8* %443
%445 = xor i8 %444, %442
store i8 %445, i8* %443
%446 = add nuw i64 %422, 4
%447 = icmp eq i64 %446, %2
br i1 %447, label %448, label %421
448: ; preds = %391, %421, %352, %372, %3, %125, %273
ret void
}