void swapfunc(void *a, void *b, int n, int swaptype) {
  if (swaptype <= 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 {
    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)
cmpl   $0x1,-0x18(%rbp)
jg     118d <swapfunc+0x8d>
movslq -0x14(%rbp),%rax
shr    $0x3,%rax
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     1138 <swapfunc+0x38>
jmp    11f8 <swapfunc+0xf8>
movslq -0x14(%rbp),%rax
shr    $0x0,%rax
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     11a9 <swapfunc+0xa9>
jmp    11f8 <swapfunc+0xf8>
pop    %rbp
ret

x86 assembly (clang, -O2):
<swapfunc>:
push   %r14
push   %rbx
movslq %edx,%rax
cmp    $0x2,%ecx
jge    1250 <swapfunc+0x150>
mov    %rax,%rcx
shr    $0x3,%rcx
cmp    $0x8,%eax
mov    %rcx,%r10
adc    $0xffffffffffffffff,%r10
add    $0x1,%r10
cmp    $0x4,%r10
jb     1224 <swapfunc+0x124>
lea    0x8(%rax),%rdx
and    $0xfffffffffffffff8,%rdx
xor    %ebx,%ebx
cmp    $0x8,%eax
setb   %bl
lea    (%rdx,%rbx,8),%rax
lea    (%rsi,%rax,1),%rdx
add    $0xfffffffffffffff8,%rdx
cmp    %rdi,%rdx
jbe    115f <swapfunc+0x5f>
add    %rdi,%rax
add    $0xfffffffffffffff8,%rax
cmp    %rsi,%rax
ja     1224 <swapfunc+0x124>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     13f7 <swapfunc+0x2f7>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rax,8),%xmm0
movups 0x10(%rdi,%rax,8),%xmm1
movups (%rsi,%rax,8),%xmm2
movups 0x10(%rsi,%rax,8),%xmm3
movups %xmm2,(%rdi,%rax,8)
movups %xmm3,0x10(%rdi,%rax,8)
movups %xmm0,(%rsi,%rax,8)
movups %xmm1,0x10(%rsi,%rax,8)
movups 0x20(%rdi,%rax,8),%xmm0
movups 0x30(%rdi,%rax,8),%xmm1
movups 0x20(%rsi,%rax,8),%xmm2
movups 0x30(%rsi,%rax,8),%xmm3
movups %xmm2,0x20(%rdi,%rax,8)
movups %xmm3,0x30(%rdi,%rax,8)
movups %xmm0,0x20(%rsi,%rax,8)
movups %xmm1,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1190 <swapfunc+0x90>
test   $0x1,%r9b
je     1210 <swapfunc+0x110>
movups (%rdi,%rax,8),%xmm0
movups 0x10(%rdi,%rax,8),%xmm1
movups (%rsi,%rax,8),%xmm2
movups 0x10(%rsi,%rax,8),%xmm3
movups %xmm2,(%rdi,%rax,8)
movups %xmm3,0x10(%rdi,%rax,8)
movups %xmm0,(%rsi,%rax,8)
movups %xmm1,0x10(%rsi,%rax,8)
cmp    %r8,%r10
je     12ce <swapfunc+0x1ce>
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
sub    %r8,%rcx
add    $0x1,%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,1),%rdx
mov    (%rsi,%rax,1),%rbx
mov    %rbx,(%rdi,%rax,1)
mov    %rdx,(%rsi,%rax,1)
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     1230 <swapfunc+0x130>
jmp    12ce <swapfunc+0x1ce>
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     1299 <swapfunc+0x199>
test   %rax,%rax
cmovle %rax,%rcx
mov    %rax,%rdx
sub    %rcx,%rdx
lea    (%rsi,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rdi,%rcx
jbe    12d2 <swapfunc+0x1d2>
lea    (%rdi,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    12d2 <swapfunc+0x1d2>
mov    %rdi,%r14
mov    %rsi,%rcx
add    $0x1,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
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     12b0 <swapfunc+0x1b0>
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r10
jae    12e0 <swapfunc+0x1e0>
xor    %r8d,%r8d
jmp    139f <swapfunc+0x29f>
mov    %r10,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1408 <swapfunc+0x308>
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    1310 <swapfunc+0x210>
test   $0x1,%r9b
je     1390 <swapfunc+0x290>
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     12ce <swapfunc+0x1ce>
test   $0x18,%r10b
je     1419 <swapfunc+0x319>
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    13d0 <swapfunc+0x2d0>
cmp    %r10,%r9
jne    129f <swapfunc+0x19f>
jmp    12ce <swapfunc+0x1ce>
xor    %eax,%eax
test   $0x1,%r9b
jne    11ec <swapfunc+0xec>
jmp    1210 <swapfunc+0x110>
xor    %ecx,%ecx
test   $0x1,%r9b
jne    136c <swapfunc+0x26c>
jmp    1390 <swapfunc+0x290>
add    %r8,%rsi
add    %r8,%rdi
sub    %r8,%rax
jmp    1299 <swapfunc+0x199>

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