#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 */
typedef int ssize_t;

/* Variables and functions */
void swab(const void *__restrict from, void *__restrict to, ssize_t len) {
  unsigned long temp;
  int n;
  char *fp, *tp;
  if (len <= 0)
    return;
  n = len >> 1;
  fp = (char *)from;
  tp = (char *)to;
  for (; n & 0x7; --n)
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
  for (n >>= 3; n > 0; --n) {
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
    temp = *fp++, *tp++ = *fp++, *tp++ = temp;
  }
}


x86 assembly (clang, -O0):
<swab>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     111e <swab+0x1e>
jmp    1445 <swab+0x345>
mov    -0x14(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
je     11a4 <swab+0xa4>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1137 <swab+0x37>
mov    -0x24(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1445 <swab+0x345>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbq (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11ad <swab+0xad>
pop    %rbp
ret

x86 assembly (clang, -O2):
<swab>:
test   %edx,%edx
jle    1238 <swab+0x138>
mov    %edx,%ecx
shr    %ecx
test   $0xe,%dl
je     11b7 <swab+0xb7>
movzwl (%rdi),%eax
rol    $0x8,%ax
mov    %ax,(%rsi)
lea    -0x1(%rcx),%eax
test   $0x7,%al
je     11bb <swab+0xbb>
movzwl 0x2(%rdi),%eax
rol    $0x8,%ax
mov    %ax,0x2(%rsi)
lea    -0x2(%rcx),%eax
test   $0x7,%al
je     11c5 <swab+0xc5>
movzwl 0x4(%rdi),%eax
rol    $0x8,%ax
mov    %ax,0x4(%rsi)
lea    -0x3(%rcx),%eax
test   $0x7,%al
je     11cf <swab+0xcf>
movzwl 0x6(%rdi),%eax
rol    $0x8,%ax
mov    %ax,0x6(%rsi)
lea    -0x4(%rcx),%eax
test   $0x7,%al
je     11d9 <swab+0xd9>
movzwl 0x8(%rdi),%eax
rol    $0x8,%ax
mov    %ax,0x8(%rsi)
lea    -0x5(%rcx),%eax
test   $0x7,%al
je     11e3 <swab+0xe3>
movzwl 0xa(%rdi),%eax
rol    $0x8,%ax
mov    %ax,0xa(%rsi)
lea    -0x6(%rcx),%eax
test   $0x7,%al
je     11ed <swab+0xed>
movzwl 0xc(%rdi),%eax
rol    $0x8,%ax
mov    %ax,0xc(%rsi)
lea    -0x7(%rcx),%eax
test   $0x7,%al
je     11f7 <swab+0xf7>
movzwl 0xe(%rdi),%eax
rol    $0x8,%ax
add    $0x10,%rdi
mov    %ax,0xe(%rsi)
add    $0x10,%rsi
add    $0xfffffff8,%ecx
mov    %ecx,%eax
jmp    11ff <swab+0xff>
add    $0x2,%rdi
add    $0x2,%rsi
jmp    11ff <swab+0xff>
add    $0x4,%rdi
add    $0x4,%rsi
jmp    11ff <swab+0xff>
add    $0x6,%rdi
add    $0x6,%rsi
jmp    11ff <swab+0xff>
add    $0x8,%rdi
add    $0x8,%rsi
jmp    11ff <swab+0xff>
add    $0xa,%rdi
add    $0xa,%rsi
jmp    11ff <swab+0xff>
add    $0xc,%rdi
add    $0xc,%rsi
jmp    11ff <swab+0xff>
add    $0xe,%rdi
add    $0xe,%rsi
cmp    $0x8,%eax
jl     1238 <swab+0x138>
shr    $0x3,%eax
add    $0x1,%eax
xor    %ecx,%ecx
nopl   0x0(%rax)
movdqu (%rdi,%rcx,1),%xmm0
movdqa %xmm0,%xmm1
psrlw  $0x8,%xmm1
psllw  $0x8,%xmm0
por    %xmm1,%xmm0
movdqu %xmm0,(%rsi,%rcx,1)
add    $0x10,%rcx
add    $0xffffffff,%eax
cmp    $0x1,%eax
ja     1210 <swab+0x110>
ret

LLVM IR (-O0):
define void @swab(i8* noalias %0, i8* noalias %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i64
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%11 = load i32, i32* %6
%12 = icmp sle i32 %11, 0
br i1 %12, label %13, label %14
13: ; preds = %3
br label %154
14: ; preds = %3
%15 = load i32, i32* %6
%16 = ashr i32 %15, 1
store i32 %16, i32* %8
%17 = load i8*, i8** %4
store i8* %17, i8** %9
%18 = load i8*, i8** %5
store i8* %18, i8** %10
br label %19
19: ; preds = %37, %14
%20 = load i32, i32* %8
%21 = and i32 %20, 7
%22 = icmp ne i32 %21, 0
br i1 %22, label %23, label %40
23: ; preds = %19
%24 = load i8*, i8** %9
%25 = getelementptr inbounds i8, i8* %24, i32 1
store i8* %25, i8** %9
%26 = load i8, i8* %24
%27 = sext i8 %26 to i64
store i64 %27, i64* %7
%28 = load i8*, i8** %9
%29 = getelementptr inbounds i8, i8* %28, i32 1
store i8* %29, i8** %9
%30 = load i8, i8* %28
%31 = load i8*, i8** %10
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %10
store i8 %30, i8* %31
%33 = load i64, i64* %7
%34 = trunc i64 %33 to i8
%35 = load i8*, i8** %10
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %10
store i8 %34, i8* %35
br label %37
37: ; preds = %23
%38 = load i32, i32* %8
%39 = add nsw i32 %38, -1
store i32 %39, i32* %8
br label %19
40: ; preds = %19
%41 = load i32, i32* %8
%42 = ashr i32 %41, 3
store i32 %42, i32* %8
br label %43
43: ; preds = %151, %40
%44 = load i32, i32* %8
%45 = icmp sgt i32 %44, 0
br i1 %45, label %46, label %154
46: ; preds = %43
%47 = load i8*, i8** %9
%48 = getelementptr inbounds i8, i8* %47, i32 1
store i8* %48, i8** %9
%49 = load i8, i8* %47
%50 = sext i8 %49 to i64
store i64 %50, i64* %7
%51 = load i8*, i8** %9
%52 = getelementptr inbounds i8, i8* %51, i32 1
store i8* %52, i8** %9
%53 = load i8, i8* %51
%54 = load i8*, i8** %10
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %10
store i8 %53, i8* %54
%56 = load i64, i64* %7
%57 = trunc i64 %56 to i8
%58 = load i8*, i8** %10
%59 = getelementptr inbounds i8, i8* %58, i32 1
store i8* %59, i8** %10
store i8 %57, i8* %58
%60 = load i8*, i8** %9
%61 = getelementptr inbounds i8, i8* %60, i32 1
store i8* %61, i8** %9
%62 = load i8, i8* %60
%63 = sext i8 %62 to i64
store i64 %63, i64* %7
%64 = load i8*, i8** %9
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %9
%66 = load i8, i8* %64
%67 = load i8*, i8** %10
%68 = getelementptr inbounds i8, i8* %67, i32 1
store i8* %68, i8** %10
store i8 %66, i8* %67
%69 = load i64, i64* %7
%70 = trunc i64 %69 to i8
%71 = load i8*, i8** %10
%72 = getelementptr inbounds i8, i8* %71, i32 1
store i8* %72, i8** %10
store i8 %70, i8* %71
%73 = load i8*, i8** %9
%74 = getelementptr inbounds i8, i8* %73, i32 1
store i8* %74, i8** %9
%75 = load i8, i8* %73
%76 = sext i8 %75 to i64
store i64 %76, i64* %7
%77 = load i8*, i8** %9
%78 = getelementptr inbounds i8, i8* %77, i32 1
store i8* %78, i8** %9
%79 = load i8, i8* %77
%80 = load i8*, i8** %10
%81 = getelementptr inbounds i8, i8* %80, i32 1
store i8* %81, i8** %10
store i8 %79, i8* %80
%82 = load i64, i64* %7
%83 = trunc i64 %82 to i8
%84 = load i8*, i8** %10
%85 = getelementptr inbounds i8, i8* %84, i32 1
store i8* %85, i8** %10
store i8 %83, i8* %84
%86 = load i8*, i8** %9
%87 = getelementptr inbounds i8, i8* %86, i32 1
store i8* %87, i8** %9
%88 = load i8, i8* %86
%89 = sext i8 %88 to i64
store i64 %89, i64* %7
%90 = load i8*, i8** %9
%91 = getelementptr inbounds i8, i8* %90, i32 1
store i8* %91, i8** %9
%92 = load i8, i8* %90
%93 = load i8*, i8** %10
%94 = getelementptr inbounds i8, i8* %93, i32 1
store i8* %94, i8** %10
store i8 %92, i8* %93
%95 = load i64, i64* %7
%96 = trunc i64 %95 to i8
%97 = load i8*, i8** %10
%98 = getelementptr inbounds i8, i8* %97, i32 1
store i8* %98, i8** %10
store i8 %96, i8* %97
%99 = load i8*, i8** %9
%100 = getelementptr inbounds i8, i8* %99, i32 1
store i8* %100, i8** %9
%101 = load i8, i8* %99
%102 = sext i8 %101 to i64
store i64 %102, i64* %7
%103 = load i8*, i8** %9
%104 = getelementptr inbounds i8, i8* %103, i32 1
store i8* %104, i8** %9
%105 = load i8, i8* %103
%106 = load i8*, i8** %10
%107 = getelementptr inbounds i8, i8* %106, i32 1
store i8* %107, i8** %10
store i8 %105, i8* %106
%108 = load i64, i64* %7
%109 = trunc i64 %108 to i8
%110 = load i8*, i8** %10
%111 = getelementptr inbounds i8, i8* %110, i32 1
store i8* %111, i8** %10
store i8 %109, i8* %110
%112 = load i8*, i8** %9
%113 = getelementptr inbounds i8, i8* %112, i32 1
store i8* %113, i8** %9
%114 = load i8, i8* %112
%115 = sext i8 %114 to i64
store i64 %115, i64* %7
%116 = load i8*, i8** %9
%117 = getelementptr inbounds i8, i8* %116, i32 1
store i8* %117, i8** %9
%118 = load i8, i8* %116
%119 = load i8*, i8** %10
%120 = getelementptr inbounds i8, i8* %119, i32 1
store i8* %120, i8** %10
store i8 %118, i8* %119
%121 = load i64, i64* %7
%122 = trunc i64 %121 to i8
%123 = load i8*, i8** %10
%124 = getelementptr inbounds i8, i8* %123, i32 1
store i8* %124, i8** %10
store i8 %122, i8* %123
%125 = load i8*, i8** %9
%126 = getelementptr inbounds i8, i8* %125, i32 1
store i8* %126, i8** %9
%127 = load i8, i8* %125
%128 = sext i8 %127 to i64
store i64 %128, i64* %7
%129 = load i8*, i8** %9
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %9
%131 = load i8, i8* %129
%132 = load i8*, i8** %10
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %10
store i8 %131, i8* %132
%134 = load i64, i64* %7
%135 = trunc i64 %134 to i8
%136 = load i8*, i8** %10
%137 = getelementptr inbounds i8, i8* %136, i32 1
store i8* %137, i8** %10
store i8 %135, i8* %136
%138 = load i8*, i8** %9
%139 = getelementptr inbounds i8, i8* %138, i32 1
store i8* %139, i8** %9
%140 = load i8, i8* %138
%141 = sext i8 %140 to i64
store i64 %141, i64* %7
%142 = load i8*, i8** %9
%143 = getelementptr inbounds i8, i8* %142, i32 1
store i8* %143, i8** %9
%144 = load i8, i8* %142
%145 = load i8*, i8** %10
%146 = getelementptr inbounds i8, i8* %145, i32 1
store i8* %146, i8** %10
store i8 %144, i8* %145
%147 = load i64, i64* %7
%148 = trunc i64 %147 to i8
%149 = load i8*, i8** %10
%150 = getelementptr inbounds i8, i8* %149, i32 1
store i8* %150, i8** %10
store i8 %148, i8* %149
br label %151
151: ; preds = %46
%152 = load i32, i32* %8
%153 = add nsw i32 %152, -1
store i32 %153, i32* %8
br label %43
154: ; preds = %13, %43
ret void
}

LLVM IR (-O2):
define void @swab(i8* noalias nocapture %0, i8* noalias nocapture writeonly %1, i32 %2) {
%4 = icmp slt i32 %2, 1
br i1 %4, label %106, label %5
5: ; preds = %3
%6 = lshr i32 %2, 1
%7 = and i32 %2, 14
%8 = icmp eq i32 %7, 0
br i1 %8, label %87, label %9
9: ; preds = %5
%10 = getelementptr inbounds i8, i8* %0, i64 1
%11 = load i8, i8* %0
%12 = getelementptr inbounds i8, i8* %0, i64 2
%13 = load i8, i8* %10
%14 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %13, i8* %1
%15 = getelementptr inbounds i8, i8* %1, i64 2
store i8 %11, i8* %14
%16 = add nsw i32 %6, -1
%17 = and i32 %16, 7
%18 = icmp eq i32 %17, 0
br i1 %18, label %87, label %19
19: ; preds = %9
%20 = getelementptr inbounds i8, i8* %0, i64 3
%21 = load i8, i8* %12
%22 = getelementptr inbounds i8, i8* %0, i64 4
%23 = load i8, i8* %20
%24 = getelementptr inbounds i8, i8* %1, i64 3
store i8 %23, i8* %15
%25 = getelementptr inbounds i8, i8* %1, i64 4
store i8 %21, i8* %24
%26 = add nsw i32 %6, -2
%27 = and i32 %26, 7
%28 = icmp eq i32 %27, 0
br i1 %28, label %87, label %29
29: ; preds = %19
%30 = getelementptr inbounds i8, i8* %0, i64 5
%31 = load i8, i8* %22
%32 = getelementptr inbounds i8, i8* %0, i64 6
%33 = load i8, i8* %30
%34 = getelementptr inbounds i8, i8* %1, i64 5
store i8 %33, i8* %25
%35 = getelementptr inbounds i8, i8* %1, i64 6
store i8 %31, i8* %34
%36 = add nsw i32 %6, -3
%37 = and i32 %36, 7
%38 = icmp eq i32 %37, 0
br i1 %38, label %87, label %39
39: ; preds = %29
%40 = getelementptr inbounds i8, i8* %0, i64 7
%41 = load i8, i8* %32
%42 = getelementptr inbounds i8, i8* %0, i64 8
%43 = load i8, i8* %40
%44 = getelementptr inbounds i8, i8* %1, i64 7
store i8 %43, i8* %35
%45 = getelementptr inbounds i8, i8* %1, i64 8
store i8 %41, i8* %44
%46 = add nsw i32 %6, -4
%47 = and i32 %46, 7
%48 = icmp eq i32 %47, 0
br i1 %48, label %87, label %49
49: ; preds = %39
%50 = getelementptr inbounds i8, i8* %0, i64 9
%51 = load i8, i8* %42
%52 = getelementptr inbounds i8, i8* %0, i64 10
%53 = load i8, i8* %50
%54 = getelementptr inbounds i8, i8* %1, i64 9
store i8 %53, i8* %45
%55 = getelementptr inbounds i8, i8* %1, i64 10
store i8 %51, i8* %54
%56 = add nsw i32 %6, -5
%57 = and i32 %56, 7
%58 = icmp eq i32 %57, 0
br i1 %58, label %87, label %59
59: ; preds = %49
%60 = getelementptr inbounds i8, i8* %0, i64 11
%61 = load i8, i8* %52
%62 = getelementptr inbounds i8, i8* %0, i64 12
%63 = load i8, i8* %60
%64 = getelementptr inbounds i8, i8* %1, i64 11
store i8 %63, i8* %55
%65 = getelementptr inbounds i8, i8* %1, i64 12
store i8 %61, i8* %64
%66 = add nsw i32 %6, -6
%67 = and i32 %66, 7
%68 = icmp eq i32 %67, 0
br i1 %68, label %87, label %69
69: ; preds = %59
%70 = getelementptr inbounds i8, i8* %0, i64 13
%71 = load i8, i8* %62
%72 = getelementptr inbounds i8, i8* %0, i64 14
%73 = load i8, i8* %70
%74 = getelementptr inbounds i8, i8* %1, i64 13
store i8 %73, i8* %65
%75 = getelementptr inbounds i8, i8* %1, i64 14
store i8 %71, i8* %74
%76 = add nsw i32 %6, -7
%77 = and i32 %76, 7
%78 = icmp eq i32 %77, 0
br i1 %78, label %87, label %79
79: ; preds = %69
%80 = getelementptr inbounds i8, i8* %0, i64 15
%81 = load i8, i8* %72
%82 = getelementptr inbounds i8, i8* %0, i64 16
%83 = load i8, i8* %80
%84 = getelementptr inbounds i8, i8* %1, i64 15
store i8 %83, i8* %75
%85 = getelementptr inbounds i8, i8* %1, i64 16
store i8 %81, i8* %84
%86 = add nsw i32 %6, -8
br label %87
87: ; preds = %9, %19, %29, %39, %49, %59, %69, %79, %5
%88 = phi i32 [ %6, %5 ], [ %16, %9 ], [ %26, %19 ], [ %36, %29 ], [ %46, %39 ], [ %56, %49 ], [ %66, %59 ], [ %76, %69 ], [ %86, %79 ]
%89 = phi i8* [ %0, %5 ], [ %12, %9 ], [ %22, %19 ], [ %32, %29 ], [ %42, %39 ], [ %52, %49 ], [ %62, %59 ], [ %72, %69 ], [ %82, %79 ]
%90 = phi i8* [ %1, %5 ], [ %15, %9 ], [ %25, %19 ], [ %35, %29 ], [ %45, %39 ], [ %55, %49 ], [ %65, %59 ], [ %75, %69 ], [ %85, %79 ]
%91 = icmp sgt i32 %88, 7
br i1 %91, label %92, label %106
92: ; preds = %87
%93 = lshr i32 %88, 3
br label %94
94: ; preds = %92, %94
%95 = phi i8* [ %101, %94 ], [ %90, %92 ]
%96 = phi i8* [ %98, %94 ], [ %89, %92 ]
%97 = phi i32 [ %104, %94 ], [ %93, %92 ]
%98 = getelementptr inbounds i8, i8* %96, i64 16
%99 = bitcast i8* %96 to <16 x i8>*
%100 = load <16 x i8>, <16 x i8>* %99
%101 = getelementptr inbounds i8, i8* %95, i64 16
%102 = shufflevector <16 x i8> %100, <16 x i8> poison, <16 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6, i32 9, i32 8, i32 11, i32 10, i32 13, i32 12, i32 15, i32 14>
%103 = bitcast i8* %95 to <16 x i8>*
store <16 x i8> %102, <16 x i8>* %103
%104 = add nsw i32 %97, -1
%105 = icmp ugt i32 %97, 1
br i1 %105, label %94, label %106
106: ; preds = %94, %87, %3
ret void
}