void swapfunc(char *a, char *b, int n, int swaptype) {
  if (swaptype <= 1) {
    long i = (n) / (int)sizeof(long);
    register long *pi = (long *)(a);
    register long *pj = (long *)(b);
    do {
      register long t = *pi;
      *pi++ = *pj;
      *pj++ = t;
    } while (--i > 0);
  } else {
    long i = (n) / (int)sizeof(char);
    register char *pi = (char *)(a);
    register char *pj = (char *)(b);
    do {
      register char t = *pi;
      *pi++ = *pj;
      *pj++ = t;
    } while (--i > 0);
  }
}


x86 assembly (clang, -O0):
<swapfunc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
cmpl   $0x1,-0x18(%rbp)
jg     1192 <swapfunc+0x92>
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cltq
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jg     113d <swapfunc+0x3d>
jmp    1202 <swapfunc+0x102>
mov    -0x14(%rbp),%eax
mov    $0x1,%ecx
cltd
idiv   %ecx
cltq
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x51(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x51(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jg     11b3 <swapfunc+0xb3>
jmp    1202 <swapfunc+0x102>
pop    %rbp
ret

x86 assembly (clang, -O2):
<swapfunc>:
push   %r14
push   %rbx
cmp    $0x1,%ecx
jg     1260 <swapfunc+0x160>
lea    0x7(%rdx),%eax
test   %edx,%edx
cmovns %edx,%eax
sar    $0x3,%eax
movslq %eax,%r11
test   %r11,%r11
mov    $0x1,%edx
cmovle %r11,%rdx
mov    $0x1,%ecx
neg    %rdx
lea    (%r11,%rdx,1),%r10
add    $0x1,%r10
cmp    $0x4,%r10
jb     1234 <swapfunc+0x134>
lea    0x0(,%r11,8),%rdx
test   %r11,%r11
cmovle %r11,%rcx
shl    $0x3,%rcx
sub    %rcx,%rdx
lea    (%rsi,%rdx,1),%rcx
add    $0x8,%rcx
cmp    %rdi,%rcx
jbe    1174 <swapfunc+0x74>
lea    (%rdi,%rdx,1),%rcx
add    $0x8,%rcx
cmp    %rsi,%rcx
ja     1234 <swapfunc+0x134>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1407 <swapfunc+0x307>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movups (%rdi,%rdx,8),%xmm0
movups 0x10(%rdi,%rdx,8),%xmm1
movups (%rsi,%rdx,8),%xmm2
movups 0x10(%rsi,%rdx,8),%xmm3
movups %xmm2,(%rdi,%rdx,8)
movups %xmm3,0x10(%rdi,%rdx,8)
movups %xmm0,(%rsi,%rdx,8)
movups %xmm1,0x10(%rsi,%rdx,8)
movups 0x20(%rdi,%rdx,8),%xmm0
movups 0x30(%rdi,%rdx,8),%xmm1
movups 0x20(%rsi,%rdx,8),%xmm2
movups 0x30(%rsi,%rdx,8),%xmm3
movups %xmm2,0x20(%rdi,%rdx,8)
movups %xmm3,0x30(%rdi,%rdx,8)
movups %xmm0,0x20(%rsi,%rdx,8)
movups %xmm1,0x30(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    11a0 <swapfunc+0xa0>
test   $0x1,%r9b
je     1220 <swapfunc+0x120>
movups (%rdi,%rdx,8),%xmm0
movups 0x10(%rdi,%rdx,8),%xmm1
movups (%rsi,%rdx,8),%xmm2
movups 0x10(%rsi,%rdx,8),%xmm3
movups %xmm2,(%rdi,%rdx,8)
movups %xmm3,0x10(%rdi,%rdx,8)
movups %xmm0,(%rsi,%rdx,8)
movups %xmm1,0x10(%rsi,%rdx,8)
cmp    %r8,%r10
je     12de <swapfunc+0x1de>
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
sub    %r8,%r11
add    $0x1,%r11
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,1),%rdx
mov    (%rsi,%rcx,1),%rax
mov    %rax,(%rdi,%rcx,1)
mov    %rdx,(%rsi,%rcx,1)
add    $0x8,%rcx
add    $0xffffffffffffffff,%r11
cmp    $0x1,%r11
jg     1240 <swapfunc+0x140>
jmp    12de <swapfunc+0x1de>
movslq %edx,%rax
test   %rax,%rax
mov    $0x1,%edx
cmovle %rax,%rdx
mov    $0x1,%ecx
neg    %rdx
lea    (%rax,%rdx,1),%r10
add    $0x1,%r10
cmp    $0x8,%r10
jb     12ac <swapfunc+0x1ac>
test   %rax,%rax
cmovle %rax,%rcx
mov    %rax,%rdx
sub    %rcx,%rdx
lea    (%rsi,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rdi,%rcx
jbe    12e2 <swapfunc+0x1e2>
lea    (%rdi,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    12e2 <swapfunc+0x1e2>
mov    %rdi,%r14
mov    %rsi,%rcx
add    $0x1,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rsi,1),%ebx
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%r14,%rsi,1)
mov    %bl,(%rcx,%rsi,1)
add    $0xffffffffffffffff,%rax
add    $0x1,%rsi
cmp    $0x1,%rax
jg     12c0 <swapfunc+0x1c0>
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r10
jae    12f0 <swapfunc+0x1f0>
xor    %r8d,%r8d
jmp    13af <swapfunc+0x2af>
mov    %r10,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1418 <swapfunc+0x318>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups (%rsi,%rcx,1),%xmm2
movups 0x10(%rsi,%rcx,1),%xmm3
movups %xmm2,(%rdi,%rcx,1)
movups %xmm3,0x10(%rdi,%rcx,1)
movups %xmm0,(%rsi,%rcx,1)
movups %xmm1,0x10(%rsi,%rcx,1)
movups 0x20(%rdi,%rcx,1),%xmm0
movups 0x30(%rdi,%rcx,1),%xmm1
movups 0x20(%rsi,%rcx,1),%xmm2
movups 0x30(%rsi,%rcx,1),%xmm3
movups %xmm2,0x20(%rdi,%rcx,1)
movups %xmm3,0x30(%rdi,%rcx,1)
movups %xmm0,0x20(%rsi,%rcx,1)
movups %xmm1,0x30(%rsi,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1320 <swapfunc+0x220>
test   $0x1,%r9b
je     13a0 <swapfunc+0x2a0>
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups (%rsi,%rcx,1),%xmm2
movups 0x10(%rsi,%rcx,1),%xmm3
movups %xmm2,(%rdi,%rcx,1)
movups %xmm3,0x10(%rdi,%rcx,1)
movups %xmm0,(%rsi,%rcx,1)
movups %xmm1,0x10(%rsi,%rcx,1)
cmp    %r8,%r10
je     12de <swapfunc+0x1de>
test   $0x18,%r10b
je     1429 <swapfunc+0x329>
test   %rax,%rax
mov    $0x1,%ecx
cmovle %rax,%rcx
neg    %rcx
lea    (%rax,%rcx,1),%r9
add    $0x1,%r9
mov    %r9,%r10
and    $0xfffffffffffffff8,%r10
sub    %r10,%rax
lea    (%rdi,%r10,1),%r14
lea    (%rsi,%r10,1),%rcx
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%r8,1),%r11
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rdi,%r8,1)
mov    %r11,(%rsi,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    13e0 <swapfunc+0x2e0>
cmp    %r10,%r9
jne    12b2 <swapfunc+0x1b2>
jmp    12de <swapfunc+0x1de>
xor    %edx,%edx
test   $0x1,%r9b
jne    11fc <swapfunc+0xfc>
jmp    1220 <swapfunc+0x120>
xor    %ecx,%ecx
test   $0x1,%r9b
jne    137c <swapfunc+0x27c>
jmp    13a0 <swapfunc+0x2a0>
add    %r8,%rsi
add    %r8,%rdi
sub    %r8,%rax
jmp    12ac <swapfunc+0x1ac>

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

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