void swapfunc(char *a, char *b, int n, int swaptype_long, int swaptype_int) {
  if (swaptype_long <= 1) {
    long i = (n) / sizeof(long);
    long *pi = (long *)(a);
    long *pj = (long *)(b);
    do {
      long t = *pi;
      *pi++ = *pj;
      *pj++ = t;
    } while (--i > 0);
  } else if (swaptype_int <= 1) {
    long i = (n) / sizeof(int);
    int *pi = (int *)(a);
    int *pj = (int *)(b);
    do {
      int t = *pi;
      *pi++ = *pj;
      *pj++ = t;
    } while (--i > 0);
  } else {
    long i = (n) / sizeof(char);
    char *pi = (char *)(a);
    char *pj = (char *)(b);
    do {
      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)
mov    %r8d,-0x1c(%rbp)
cmpl   $0x1,-0x18(%rbp)
jg     1191 <swapfunc+0x91>
movslq -0x14(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jg     113c <swapfunc+0x3c>
jmp    1276 <swapfunc+0x176>
cmpl   $0x1,-0x1c(%rbp)
jg     1206 <swapfunc+0x106>
movslq -0x14(%rbp),%rax
shr    $0x2,%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x50(%rbp)
mov    %ecx,(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x58(%rbp)
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jg     11b7 <swapfunc+0xb7>
jmp    1271 <swapfunc+0x171>
movslq -0x14(%rbp),%rax
shr    $0x0,%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x79(%rbp)
mov    -0x78(%rbp),%rax
mov    (%rax),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,(%rax)
mov    -0x79(%rbp),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jg     1222 <swapfunc+0x122>
jmp    1271 <swapfunc+0x171>
jmp    1276 <swapfunc+0x176>
pop    %rbp
ret

x86 assembly (clang, -O2):
<swapfunc>:
push   %r14
push   %rbx
cmp    $0x1,%ecx
jg     1253 <swapfunc+0x153>
movslq %edx,%rcx
mov    %rcx,%r11
shr    $0x3,%r11
cmp    $0x8,%edx
mov    %r11,%r10
adc    $0xffffffffffffffff,%r10
add    $0x1,%r10
cmp    $0x4,%r10
jb     1224 <swapfunc+0x124>
add    $0x8,%rcx
and    $0xfffffffffffffff8,%rcx
xor    %r8d,%r8d
cmp    $0x8,%edx
setb   %r8b
lea    (%rcx,%r8,8),%rcx
lea    (%rsi,%rcx,1),%rdx
add    $0xfffffffffffffff8,%rdx
cmp    %rdi,%rdx
jbe    1161 <swapfunc+0x61>
add    %rdi,%rcx
add    $0xfffffffffffffff8,%rcx
cmp    %rsi,%rcx
ja     1224 <swapfunc+0x124>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1430 <swapfunc+0x330>
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    1190 <swapfunc+0x90>
test   $0x1,%r9b
je     1210 <swapfunc+0x110>
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     141e <swapfunc+0x31e>
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
ja     1230 <swapfunc+0x130>
jmp    141e <swapfunc+0x31e>
movslq %edx,%rax
cmp    $0x2,%r8d
jge    139f <swapfunc+0x29f>
mov    %rax,%rcx
shr    $0x2,%rcx
cmp    $0x4,%eax
mov    %rcx,%r10
adc    $0xffffffffffffffff,%r10
add    $0x1,%r10
cmp    $0x8,%r10
jb     1374 <swapfunc+0x274>
lea    0x4(%rax),%rdx
and    $0xfffffffffffffffc,%rdx
xor    %ebx,%ebx
cmp    $0x4,%eax
setb   %bl
lea    (%rdx,%rbx,4),%rax
lea    (%rsi,%rax,1),%rdx
add    $0xfffffffffffffffc,%rdx
cmp    %rdi,%rdx
jbe    12b0 <swapfunc+0x1b0>
add    %rdi,%rax
add    $0xfffffffffffffffc,%rax
cmp    %rsi,%rax
ja     1374 <swapfunc+0x274>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     14c8 <swapfunc+0x3c8>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups (%rsi,%rax,4),%xmm2
movups 0x10(%rsi,%rax,4),%xmm3
movups %xmm2,(%rdi,%rax,4)
movups %xmm3,0x10(%rdi,%rax,4)
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
movups 0x20(%rsi,%rax,4),%xmm2
movups 0x30(%rsi,%rax,4),%xmm3
movups %xmm2,0x20(%rdi,%rax,4)
movups %xmm3,0x30(%rdi,%rax,4)
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    12e0 <swapfunc+0x1e0>
test   $0x1,%r9b
je     1360 <swapfunc+0x260>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups (%rsi,%rax,4),%xmm2
movups 0x10(%rsi,%rax,4),%xmm3
movups %xmm2,(%rdi,%rax,4)
movups %xmm3,0x10(%rdi,%rax,4)
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
cmp    %r8,%r10
je     141e <swapfunc+0x31e>
sub    %r8,%rcx
lea    (%rdi,%r8,4),%rdi
lea    (%rsi,%r8,4),%rsi
add    $0x1,%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,1),%edx
mov    (%rsi,%rax,1),%ebx
mov    %ebx,(%rdi,%rax,1)
mov    %edx,(%rsi,%rax,1)
add    $0xffffffffffffffff,%rcx
add    $0x4,%rax
cmp    $0x1,%rcx
ja     1380 <swapfunc+0x280>
jmp    141e <swapfunc+0x31e>
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     13e8 <swapfunc+0x2e8>
test   %rax,%rax
cmovle %rax,%rcx
mov    %rax,%rdx
sub    %rcx,%rdx
lea    (%rsi,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rdi,%rcx
jbe    1422 <swapfunc+0x322>
lea    (%rdi,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    1422 <swapfunc+0x322>
mov    %rdi,%r14
mov    %rsi,%rcx
add    $0x1,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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     1400 <swapfunc+0x300>
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r10
jae    1441 <swapfunc+0x341>
xor    %r8d,%r8d
jmp    1514 <swapfunc+0x414>
xor    %edx,%edx
test   $0x1,%r9b
jne    11ec <swapfunc+0xec>
jmp    1210 <swapfunc+0x110>
mov    %r10,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     14d9 <swapfunc+0x3d9>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
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    1470 <swapfunc+0x370>
jmp    14db <swapfunc+0x3db>
xor    %eax,%eax
test   $0x1,%r9b
jne    133c <swapfunc+0x23c>
jmp    1360 <swapfunc+0x260>
xor    %ecx,%ecx
test   $0x1,%r9b
je     1505 <swapfunc+0x405>
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     141e <swapfunc+0x31e>
test   $0x18,%r10b
je     1567 <swapfunc+0x467>
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   (%rax)
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    1540 <swapfunc+0x440>
cmp    %r10,%r9
jne    13ee <swapfunc+0x2ee>
jmp    141e <swapfunc+0x31e>
add    %r8,%rsi
add    %r8,%rdi
sub    %r8,%rax
jmp    13e8 <swapfunc+0x2e8>

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

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