#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 bcopy(char *src, char *dest, int len) {
  if (dest < src)
    while (len--) {
      *dest = *src;
      dest++;
      src++;
    }
  else {
    char *lasts = src + (len - 1);
    char *lastd = dest + (len - 1);
    while (len--)
      *(char *)lastd-- = *(char *)lasts--;
  }
}


x86 assembly (clang, -O0):
<bcopy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1164 <bcopy+0x64>
jmp    1122 <bcopy+0x22>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     115f <bcopy+0x5f>
mov    -0x8(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1122 <bcopy+0x22>
jmp    11cc <bcopy+0xcc>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     11c7 <bcopy+0xc7>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    118c <bcopy+0x8c>
jmp    11cc <bcopy+0xcc>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bcopy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    %rdi,%rsi
jae    11e3 <bcopy+0xe3>
test   %edx,%edx
je     12be <bcopy+0x1be>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     1147 <bcopy+0x47>
lea    (%rdi,%r8,1),%rax
add    $0x1,%rax
cmp    %rsi,%rax
jbe    12c9 <bcopy+0x1c9>
lea    (%rsi,%r8,1),%rax
add    $0x1,%rax
cmp    %rdi,%rax
jbe    12c9 <bcopy+0x1c9>
mov    %rsi,%rcx
mov    %rdi,%rax
lea    -0x1(%rdx),%esi
test   $0x7,%dl
je     1177 <bcopy+0x77>
mov    %edx,%ebp
and    $0x7,%ebp
xor    %edi,%edi
nopl   0x0(%rax)
movzbl (%rax,%rdi,1),%ebx
mov    %bl,(%rcx,%rdi,1)
add    $0x1,%rdi
cmp    %edi,%ebp
jne    1160 <bcopy+0x60>
sub    %edi,%edx
add    %rdi,%rcx
add    %rdi,%rax
cmp    $0x7,%esi
jb     12be <bcopy+0x1be>
mov    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rax,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
movzbl 0x1(%rax,%rsi,1),%ebx
mov    %bl,0x1(%rcx,%rsi,1)
movzbl 0x2(%rax,%rsi,1),%ebx
mov    %bl,0x2(%rcx,%rsi,1)
movzbl 0x3(%rax,%rsi,1),%ebx
mov    %bl,0x3(%rcx,%rsi,1)
movzbl 0x4(%rax,%rsi,1),%ebx
mov    %bl,0x4(%rcx,%rsi,1)
movzbl 0x5(%rax,%rsi,1),%ebx
mov    %bl,0x5(%rcx,%rsi,1)
movzbl 0x6(%rax,%rsi,1),%ebx
mov    %bl,0x6(%rcx,%rsi,1)
movzbl 0x7(%rax,%rsi,1),%ebx
mov    %bl,0x7(%rcx,%rsi,1)
add    $0x8,%rsi
cmp    %esi,%edx
jne    1190 <bcopy+0x90>
jmp    12be <bcopy+0x1be>
test   %edx,%edx
je     12be <bcopy+0x1be>
lea    -0x1(%rdx),%eax
movslq %eax,%r15
lea    (%rsi,%r15,1),%r11
lea    (%rdi,%r15,1),%r9
cmp    $0x3,%eax
jb     1234 <bcopy+0x134>
movabs $0xffffffff00000000,%rcx
ff ff ff
and    %r15,%rcx
lea    (%rsi,%rcx,1),%rbp
lea    (%rdi,%r15,1),%rbx
add    $0x1,%rbx
cmp    %rbx,%rbp
jae    12e1 <bcopy+0x1e1>
lea    (%rsi,%r15,1),%rbp
add    $0x1,%rbp
add    %rdi,%rcx
cmp    %rbp,%rcx
jae    12e1 <bcopy+0x1e1>
mov    %r11,%rsi
mov    %r9,%rdi
lea    -0x1(%rdx),%ebp
test   $0x7,%dl
je     1267 <bcopy+0x167>
mov    %edx,%ebx
and    $0x7,%ebx
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl (%rdi),%eax
add    $0xffffffffffffffff,%rdi
mov    %al,(%rsi)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rcx
cmp    %ecx,%ebx
jne    1250 <bcopy+0x150>
sub    %ecx,%edx
cmp    $0x7,%ebp
jb     12be <bcopy+0x1be>
neg    %edx
xor    %eax,%eax
movzbl (%rdi,%rax,1),%ecx
mov    %cl,(%rsi,%rax,1)
movzbl -0x1(%rdi,%rax,1),%ecx
mov    %cl,-0x1(%rsi,%rax,1)
movzbl -0x2(%rdi,%rax,1),%ecx
mov    %cl,-0x2(%rsi,%rax,1)
movzbl -0x3(%rdi,%rax,1),%ecx
mov    %cl,-0x3(%rsi,%rax,1)
movzbl -0x4(%rdi,%rax,1),%ecx
mov    %cl,-0x4(%rsi,%rax,1)
movzbl -0x5(%rdi,%rax,1),%ecx
mov    %cl,-0x5(%rsi,%rax,1)
movzbl -0x6(%rdi,%rax,1),%ecx
mov    %cl,-0x6(%rsi,%rax,1)
movzbl -0x7(%rdi,%rax,1),%ecx
mov    %cl,-0x7(%rsi,%rax,1)
add    $0xfffffffffffffff8,%rax
cmp    %eax,%edx
jne    1270 <bcopy+0x170>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%r9
cmp    $0x1f,%r8d
jae    12fe <bcopy+0x1fe>
xor    %r10d,%r10d
jmp    140e <bcopy+0x30e>
mov    %eax,%r8d
lea    0x1(%r8),%r12
movabs $0x1ffffffe0,%r10
cmp    $0xf,%eax
jae    1329 <bcopy+0x229>
xor    %eax,%eax
jmp    14e3 <bcopy+0x3e3>
lea    0x1(%r8),%r11
mov    %r11,%r10
and    %r9,%r10
lea    -0x20(%r10),%rax
mov    %rax,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%ebx
and    $0x3,%ebx
cmp    $0x60,%rax
jae    1357 <bcopy+0x257>
xor    %eax,%eax
jmp    13b8 <bcopy+0x2b8>
lea    0x10(%r10),%rax
and    %r12,%rax
lea    -0x10(%rax),%rcx
mov    %rcx,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r14d
and    $0x3,%r14d
cmp    $0x30,%rcx
jae    144f <bcopy+0x34f>
xor    %ecx,%ecx
jmp    1499 <bcopy+0x399>
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   (%rax)
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups %xmm0,(%rsi,%rax,1)
movups %xmm1,0x10(%rsi,%rax,1)
movups 0x20(%rdi,%rax,1),%xmm0
movups 0x30(%rdi,%rax,1),%xmm1
movups %xmm0,0x20(%rsi,%rax,1)
movups %xmm1,0x30(%rsi,%rax,1)
movups 0x40(%rdi,%rax,1),%xmm0
movups 0x50(%rdi,%rax,1),%xmm1
movups %xmm0,0x40(%rsi,%rax,1)
movups %xmm1,0x50(%rsi,%rax,1)
movups 0x60(%rdi,%rax,1),%xmm0
movups 0x70(%rdi,%rax,1),%xmm1
movups %xmm0,0x60(%rsi,%rax,1)
movups %xmm1,0x70(%rsi,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    1360 <bcopy+0x260>
test   %rbx,%rbx
je     13fb <bcopy+0x2fb>
lea    (%rdi,%rax,1),%rcx
add    $0x10,%rcx
add    %rsi,%rax
add    $0x10,%rax
shl    $0x5,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rcx,%rbp,1),%xmm0
movups (%rcx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    13e0 <bcopy+0x2e0>
cmp    %r10,%r11
je     12be <bcopy+0x1be>
test   $0x18,%r11b
je     1531 <bcopy+0x431>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
sub    %r9d,%edx
lea    (%rsi,%r9,1),%rcx
lea    (%rdi,%r9,1),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%r10,1),%rbp
mov    %rbp,(%rsi,%r10,1)
add    $0x8,%r10
cmp    %r10,%r9
jne    1430 <bcopy+0x330>
cmp    %r9,%r8
jne    114d <bcopy+0x4d>
jmp    12be <bcopy+0x1be>
and    $0xfffffffffffffffc,%rbx
lea    -0xf(%r11),%r13
lea    -0xf(%r9),%rbp
xor    %ecx,%ecx
nopl   (%rax)
movups 0x0(%rbp,%rcx,1),%xmm0
movups %xmm0,0x0(%r13,%rcx,1)
movups -0x10(%rbp,%rcx,1),%xmm0
movups %xmm0,-0x10(%r13,%rcx,1)
movups -0x20(%rbp,%rcx,1),%xmm0
movups %xmm0,-0x20(%r13,%rcx,1)
movups -0x30(%rbp,%rcx,1),%xmm0
movups %xmm0,-0x30(%r13,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1460 <bcopy+0x360>
neg    %rcx
test   %r14,%r14
je     14d4 <bcopy+0x3d4>
sub    %rcx,%r15
lea    (%rdi,%r15,1),%rcx
add    $0xfffffffffffffff1,%rcx
add    %r15,%rsi
add    $0xfffffffffffffff1,%rsi
shl    $0x4,%r14
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups (%rcx,%rdi,1),%xmm0
movups %xmm0,(%rsi,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r14,%rbx
add    %rdi,%rbx
jne    14c0 <bcopy+0x3c0>
cmp    %rax,%r12
je     12be <bcopy+0x1be>
test   $0xc,%r12b
je     153f <bcopy+0x43f>
add    $0x1,%r8
add    $0x1c,%r10
and    %r8,%r10
mov    %r11,%rsi
sub    %r10,%rsi
mov    %r9,%rdi
sub    %r10,%rdi
sub    %r10d,%edx
neg    %rax
and    $0xfffffffffffffffc,%r12
neg    %r12
nopw   0x0(%rax,%rax,1)
mov    -0x3(%r9,%rax,1),%ecx
mov    %ecx,-0x3(%r11,%rax,1)
add    $0xfffffffffffffffc,%rax
cmp    %rax,%r12
jne    1510 <bcopy+0x410>
cmp    %r10,%r8
jne    123a <bcopy+0x13a>
jmp    12be <bcopy+0x1be>
add    %r10,%rdi
add    %r10,%rsi
sub    %r10d,%edx
jmp    1147 <bcopy+0x47>
sub    %eax,%edx
sub    %rax,%r9
sub    %rax,%r11
jmp    1234 <bcopy+0x134>

LLVM IR (-O0):
define void @bcopy(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%9 = load i8*, i8** %5
%10 = load i8*, i8** %4
%11 = icmp ult i8* %9, %10
br i1 %11, label %12, label %26
12: ; preds = %3
br label %13
13: ; preds = %17, %12
%14 = load i32, i32* %6
%15 = add nsw i32 %14, -1
store i32 %15, i32* %6
%16 = icmp ne i32 %14, 0
br i1 %16, label %17, label %25
17: ; preds = %13
%18 = load i8*, i8** %4
%19 = load i8, i8* %18
%20 = load i8*, i8** %5
store i8 %19, i8* %20
%21 = load i8*, i8** %5
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %5
%23 = load i8*, i8** %4
%24 = getelementptr inbounds i8, i8* %23, i32 1
store i8* %24, i8** %4
br label %13
25: ; preds = %13
br label %48
26: ; preds = %3
%27 = load i8*, i8** %4
%28 = load i32, i32* %6
%29 = sub nsw i32 %28, 1
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %27, i64 %30
store i8* %31, i8** %7
%32 = load i8*, i8** %5
%33 = load i32, i32* %6
%34 = sub nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8, i8* %32, i64 %35
store i8* %36, i8** %8
br label %37
37: ; preds = %41, %26
%38 = load i32, i32* %6
%39 = add nsw i32 %38, -1
store i32 %39, i32* %6
%40 = icmp ne i32 %38, 0
br i1 %40, label %41, label %47
41: ; preds = %37
%42 = load i8*, i8** %7
%43 = getelementptr inbounds i8, i8* %42, i32 -1
store i8* %43, i8** %7
%44 = load i8, i8* %42
%45 = load i8*, i8** %8
%46 = getelementptr inbounds i8, i8* %45, i32 -1
store i8* %46, i8** %8
store i8 %44, i8* %45
br label %37
47: ; preds = %37
br label %48
48: ; preds = %47, %25
ret void
}

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