#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(const char *source, char *destination, int nbytes) {
  register char *dstend;
  register long *src;
  register long *dst;
  int tmp = destination - source;
  if (tmp <= 0 || tmp >= nbytes) {
    dstend = destination + nbytes;
    if (nbytes < 10 || (((int)destination ^ (int)source) & 3))
      goto byte_copy_fwd;
    while ((int)destination & 3)
      *destination++ = *source++;
    src = (long *)source;
    dst = (long *)destination;
    do {
      *dst++ = *src++;
    } while (((char *)dst + sizeof(long)) <= dstend);
    destination = (char *)dst;
    source = (char *)src;
  byte_copy_fwd:
    while (destination < dstend)
      *destination++ = *source++;
  } else {
    dstend = destination;
    destination += nbytes;
    source += nbytes;
    if (nbytes < 10 || (((int)destination ^ (int)source) & 3))
      goto byte_copy_bwd;
    while ((int)destination & 3)
      *--destination = *--source;
    src = (long *)source;
    dst = (long *)destination;
    do {
      *--dst = *--src;
    } while (((char *)dst - sizeof(long)) >= dstend);
    destination = (char *)dst;
    source = (char *)src;
  byte_copy_bwd:
    while (destination > dstend)
      *--destination = *--source;
  }
}


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
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    1133 <bcopy+0x33>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1238 <bcopy+0x138>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
cmpl   $0xa,-0x14(%rbp)
jl     1162 <bcopy+0x62>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
xor    %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
je     1167 <bcopy+0x67>
jmp    11f9 <bcopy+0xf9>
jmp    116c <bcopy+0x6c>
mov    -0x10(%rbp),%rax
and    $0x3,%eax
cmp    $0x0,%eax
je     11a3 <bcopy+0xa3>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    116c <bcopy+0x6c>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
cmp    -0x20(%rbp),%rax
jbe    11b3 <bcopy+0xb3>
mov    -0x30(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    11fe <bcopy+0xfe>
mov    -0x10(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1233 <bcopy+0x133>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    11fe <bcopy+0xfe>
jmp    135e <bcopy+0x25e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0xa,-0x14(%rbp)
jl     1282 <bcopy+0x182>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
xor    %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
je     1287 <bcopy+0x187>
jmp    131d <bcopy+0x21d>
jmp    128c <bcopy+0x18c>
mov    -0x10(%rbp),%rax
and    $0x3,%eax
cmp    $0x0,%eax
je     12c5 <bcopy+0x1c5>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
jmp    128c <bcopy+0x18c>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x28(%rbp)
mov    -0x8(%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x8(%rax)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
cmp    -0x20(%rbp),%rax
jae    12d5 <bcopy+0x1d5>
mov    -0x30(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1322 <bcopy+0x222>
mov    -0x10(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1359 <bcopy+0x259>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
jmp    1322 <bcopy+0x222>
jmp    135e <bcopy+0x25e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bcopy>:
push   %r14
push   %rbx
mov    %esi,%eax
sub    %edi,%eax
movslq %edx,%r8
lea    (%rsi,%r8,1),%r11
test   %eax,%eax
jle    11e5 <bcopy+0xe5>
cmp    %edx,%eax
jge    11e5 <bcopy+0xe5>
add    %r8,%rdi
cmp    $0xa,%edx
jl     1198 <bcopy+0x98>
mov    %r11d,%eax
xor    %edi,%eax
test   $0x3,%al
jne    1198 <bcopy+0x98>
test   $0x3,%r11b
je     116e <bcopy+0x6e>
mov    -0x1(%rdi),%al
add    $0xffffffffffffffff,%rdi
mov    %al,-0x1(%r11)
add    $0xffffffffffffffff,%r11
test   $0x3,%r11b
je     116e <bcopy+0x6e>
mov    -0x1(%rdi),%al
add    $0xffffffffffffffff,%rdi
mov    %al,-0x1(%r11)
add    $0xffffffffffffffff,%r11
test   $0x3,%r11b
je     116e <bcopy+0x6e>
mov    -0x1(%rdi),%al
add    $0xffffffffffffffff,%rdi
mov    %al,-0x1(%r11)
add    $0xffffffffffffffff,%r11
add    $0xfffffffffffffff8,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%rdi),%rax
add    $0xfffffffffffffff8,%rdi
mov    %rax,(%r11)
add    $0xfffffffffffffff8,%r11
cmp    %rsi,%r11
jae    1180 <bcopy+0x80>
add    $0x8,%r11
mov    %r11,%r9
sub    %rsi,%r9
jbe    1242 <bcopy+0x142>
cmp    $0x4,%r9
jb     11c5 <bcopy+0xc5>
cmp    %rdi,%rsi
jae    1296 <bcopy+0x196>
mov    %rsi,%rax
sub    %r11,%rax
add    %rdi,%rax
cmp    %r11,%rax
jae    1296 <bcopy+0x196>
mov    %rdi,%rcx
mov    %r11,%rax
add    $0xffffffffffffffff,%rcx
nop
movzbl (%rcx),%edx
mov    %dl,-0x1(%rax)
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rcx
cmp    %rsi,%rax
ja     11d0 <bcopy+0xd0>
jmp    1242 <bcopy+0x142>
cmp    $0xa,%edx
jl     11f2 <bcopy+0xf2>
mov    %esi,%eax
xor    %edi,%eax
test   $0x3,%al
je     1246 <bcopy+0x146>
mov    %rsi,%rdx
cmp    %r11,%rdx
jae    1242 <bcopy+0x142>
add    %r8,%rsi
mov    %rsi,%r9
sub    %rdx,%r9
cmp    $0x8,%r9
jb     121f <bcopy+0x11f>
lea    (%rdi,%r9,1),%rax
cmp    %rax,%rdx
jae    12a3 <bcopy+0x1a3>
cmp    %rsi,%rdi
jae    12a3 <bcopy+0x1a3>
mov    %rdi,%rax
mov    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax),%edx
add    $0x1,%rax
mov    %dl,(%rcx)
add    $0x1,%rcx
cmp    %r11,%rcx
jb     1230 <bcopy+0x130>
pop    %rbx
pop    %r14
ret
test   $0x3,%sil
je     12b0 <bcopy+0x1b0>
mov    (%rdi),%al
lea    0x1(%rsi),%rdx
mov    %al,(%rsi)
test   $0x3,%dl
je     130d <bcopy+0x20d>
mov    0x1(%rdi),%al
lea    0x2(%rsi),%rdx
mov    %al,0x1(%rsi)
test   $0x3,%dl
je     14df <bcopy+0x3df>
mov    0x2(%rdi),%al
lea    0x3(%rsi),%rdx
mov    %al,0x2(%rsi)
test   $0x3,%dl
je     14e5 <bcopy+0x3e5>
mov    0x3(%rdi),%al
add    $0x4,%rdi
lea    0x4(%rsi),%rdx
mov    %al,0x3(%rsi)
jmp    14e9 <bcopy+0x3e9>
cmp    $0x10,%r9
jae    12b8 <bcopy+0x1b8>
xor    %edx,%edx
jmp    13a8 <bcopy+0x2a8>
cmp    $0x20,%r9
jae    12df <bcopy+0x1df>
xor    %esi,%esi
jmp    14ae <bcopy+0x3ae>
mov    %rsi,%rdx
jmp    14e9 <bcopy+0x3e9>
mov    %r9,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rax
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %ecx,%r8d
and    $0x3,%r8d
cmp    $0x30,%rax
jae    1316 <bcopy+0x216>
xor    %eax,%eax
jmp    1359 <bcopy+0x259>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x60,%rcx
jae    13f0 <bcopy+0x2f0>
xor    %ebx,%ebx
jmp    1458 <bcopy+0x358>
add    $0x1,%rdi
jmp    14e9 <bcopy+0x3e9>
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups -0x10(%rdi,%rax,1),%xmm0
movups %xmm0,-0x10(%r11,%rax,1)
movups -0x20(%rdi,%rax,1),%xmm0
movups %xmm0,-0x20(%r11,%rax,1)
movups -0x30(%rdi,%rax,1),%xmm0
movups %xmm0,-0x30(%r11,%rax,1)
movups -0x40(%rdi,%rax,1),%xmm0
movups %xmm0,-0x40(%r11,%rax,1)
add    $0xffffffffffffffc0,%rax
add    $0xfffffffffffffffc,%rcx
jne    1320 <bcopy+0x220>
neg    %rax
test   %r8,%r8
je     1395 <bcopy+0x295>
mov    $0xfffffffffffffff0,%rcx
sub    %rax,%rcx
lea    (%r11,%rcx,1),%r10
add    %rdi,%rcx
shl    $0x4,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rcx,%rbx,1),%xmm0
movups %xmm0,(%r10,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r8,%rax
add    %rbx,%rax
jne    1380 <bcopy+0x280>
cmp    %rdx,%r9
je     1242 <bcopy+0x142>
test   $0xc,%r9b
je     163f <bcopy+0x53f>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
mov    %rdi,%rcx
sub    %r8,%rcx
mov    %r11,%rax
sub    %r8,%rax
neg    %rdx
mov    %r8,%r10
neg    %r10
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x4(%rdi,%rdx,1),%ebx
mov    %ebx,-0x4(%r11,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%r10
jne    13d0 <bcopy+0x2d0>
cmp    %r8,%r9
jne    11cb <bcopy+0xcb>
jmp    1242 <bcopy+0x142>
and    $0xfffffffffffffffc,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rbx,1),%xmm0
movups 0x10(%rdi,%rbx,1),%xmm1
movups %xmm0,(%rdx,%rbx,1)
movups %xmm1,0x10(%rdx,%rbx,1)
movups 0x20(%rdi,%rbx,1),%xmm0
movups 0x30(%rdi,%rbx,1),%xmm1
movups %xmm0,0x20(%rdx,%rbx,1)
movups %xmm1,0x30(%rdx,%rbx,1)
movups 0x40(%rdi,%rbx,1),%xmm0
movups 0x50(%rdi,%rbx,1),%xmm1
movups %xmm0,0x40(%rdx,%rbx,1)
movups %xmm1,0x50(%rdx,%rbx,1)
movups 0x60(%rdi,%rbx,1),%xmm0
movups 0x70(%rdi,%rbx,1),%xmm1
movups %xmm0,0x60(%rdx,%rbx,1)
movups %xmm1,0x70(%rdx,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rax
jne    1400 <bcopy+0x300>
test   %r8,%r8
je     149b <bcopy+0x39b>
lea    (%rdx,%rbx,1),%rax
add    $0x10,%rax
lea    (%rdi,%rbx,1),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rax,%rbx,1)
movups %xmm1,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1480 <bcopy+0x380>
cmp    %rsi,%r9
je     1242 <bcopy+0x142>
test   $0x18,%r9b
je     164a <bcopy+0x54a>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%rdi,%r8,1),%rax
lea    (%rdx,%r8,1),%rcx
nopl   (%rax)
mov    (%rdi,%rsi,1),%rbx
mov    %rbx,(%rdx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r8
jne    14c0 <bcopy+0x3c0>
cmp    %r8,%r9
jne    1230 <bcopy+0x130>
jmp    1242 <bcopy+0x142>
add    $0x2,%rdi
jmp    14e9 <bcopy+0x3e9>
add    $0x3,%rdi
lea    (%rsi,%r8,1),%rcx
add    $0x1,%rcx
lea    0x10(%rdx),%rax
cmp    %rax,%rcx
mov    %rax,%r14
cmova  %rcx,%r14
sub    %rdx,%r14
add    $0xfffffffffffffff7,%r14
cmp    $0x18,%r14
jb     1620 <bcopy+0x520>
cmp    %rax,%rcx
cmova  %rcx,%rax
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rdi,%rcx,1),%rax
cmp    %rax,%rdx
jae    1539 <bcopy+0x439>
add    %rdx,%rcx
cmp    %rcx,%rdi
jb     1620 <bcopy+0x520>
shr    $0x3,%r14
add    $0x1,%r14
mov    %r14,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
cmp    $0xc,%rcx
jae    1568 <bcopy+0x468>
xor    %ebx,%ebx
jmp    15c8 <bcopy+0x4c8>
and    $0xfffffffffffffffc,%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movups (%rdi,%rbx,8),%xmm0
movups 0x10(%rdi,%rbx,8),%xmm1
movups %xmm0,(%rdx,%rbx,8)
movups %xmm1,0x10(%rdx,%rbx,8)
movups 0x20(%rdi,%rbx,8),%xmm0
movups 0x30(%rdi,%rbx,8),%xmm1
movups %xmm0,0x20(%rdx,%rbx,8)
movups %xmm1,0x30(%rdx,%rbx,8)
movups 0x40(%rdi,%rbx,8),%xmm0
movups 0x50(%rdi,%rbx,8),%xmm1
movups %xmm0,0x40(%rdx,%rbx,8)
movups %xmm1,0x50(%rdx,%rbx,8)
movups 0x60(%rdi,%rbx,8),%xmm0
movups 0x70(%rdi,%rbx,8),%xmm1
movups %xmm0,0x60(%rdx,%rbx,8)
movups %xmm1,0x70(%rdx,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rax
jne    1570 <bcopy+0x470>
test   %r10,%r10
je     160b <bcopy+0x50b>
lea    (%rdx,%rbx,8),%rax
add    $0x10,%rax
lea    (%rdi,%rbx,8),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbx,%rcx,1),%xmm0
movups (%rbx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rax,%rcx,1)
movups %xmm1,(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    15f0 <bcopy+0x4f0>
lea    (%rdi,%r9,8),%rdi
lea    (%rdx,%r9,8),%rdx
cmp    %r9,%r14
je     11f5 <bcopy+0xf5>
nopl   0x0(%rax)
mov    %rdx,%rax
mov    (%rdi),%rcx
add    $0x8,%rdi
add    $0x8,%rdx
mov    %rcx,(%rax)
add    $0x10,%rax
cmp    %rax,%r11
jae    1620 <bcopy+0x520>
jmp    11f5 <bcopy+0xf5>
sub    %rdx,%r11
sub    %rdx,%rdi
jmp    11c5 <bcopy+0xc5>
add    %rsi,%rdx
add    %rsi,%rdi
jmp    121f <bcopy+0x11f>

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

LLVM IR (-O2):
define void @bcopy(i8* %0, i8* %1, i32 %2) {
%4 = ptrtoint i8* %1 to i64
%5 = ptrtoint i8* %0 to i64
%6 = sub i64 %4, %5
%7 = trunc i64 %6 to i32
%8 = icmp sgt i32 %7, 0
%9 = icmp slt i32 %7, %2
%10 = and i1 %8, %9
%11 = sext i32 %2 to i64
%12 = getelementptr inbounds i8, i8* %1, i64 %11
br i1 %10, label %305, label %13
13: ; preds = %3
%14 = icmp slt i32 %2, 10
br i1 %14, label %174, label %15
15: ; preds = %13
%16 = xor i64 %4, %5
%17 = and i64 %16, 3
%18 = icmp eq i64 %17, 0
br i1 %18, label %19, label %174
19: ; preds = %15
%20 = and i64 %4, 3
%21 = icmp eq i64 %20, 0
br i1 %21, label %47, label %22
22: ; preds = %19
%23 = getelementptr inbounds i8, i8* %0, i64 1
%24 = load i8, i8* %0
%25 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %24, i8* %1
%26 = ptrtoint i8* %25 to i64
%27 = and i64 %26, 3
%28 = icmp eq i64 %27, 0
br i1 %28, label %47, label %29
29: ; preds = %22
%30 = getelementptr inbounds i8, i8* %0, i64 2
%31 = load i8, i8* %23
%32 = getelementptr inbounds i8, i8* %1, i64 2
store i8 %31, i8* %25
%33 = ptrtoint i8* %32 to i64
%34 = and i64 %33, 3
%35 = icmp eq i64 %34, 0
br i1 %35, label %47, label %36
36: ; preds = %29
%37 = getelementptr inbounds i8, i8* %0, i64 3
%38 = load i8, i8* %30
%39 = getelementptr inbounds i8, i8* %1, i64 3
store i8 %38, i8* %32
%40 = ptrtoint i8* %39 to i64
%41 = and i64 %40, 3
%42 = icmp eq i64 %41, 0
br i1 %42, label %47, label %43
43: ; preds = %36
%44 = getelementptr inbounds i8, i8* %0, i64 4
%45 = load i8, i8* %37
%46 = getelementptr inbounds i8, i8* %1, i64 4
store i8 %45, i8* %39
br label %47
47: ; preds = %22, %29, %36, %43, %19
%48 = phi i8* [ %1, %19 ], [ %25, %22 ], [ %32, %29 ], [ %39, %36 ], [ %46, %43 ]
%49 = phi i8* [ %0, %19 ], [ %23, %22 ], [ %30, %29 ], [ %37, %36 ], [ %44, %43 ]
%50 = ptrtoint i8* %48 to i64
%51 = bitcast i8* %49 to i64*
%52 = bitcast i8* %48 to i64*
%53 = add i64 %4, %11
%54 = add i64 %53, 1
%55 = add i64 %50, 16
%56 = call i64 @llvm.umax.i64(i64 %54, i64 %55)
%57 = add i64 %56, -9
%58 = sub i64 %57, %50
%59 = lshr i64 %58, 3
%60 = add nuw nsw i64 %59, 1
%61 = icmp ult i64 %58, 24
br i1 %61, label %157, label %62
62: ; preds = %47
%63 = add i64 %4, %11
%64 = add i64 %63, 1
%65 = add i64 %50, 16
%66 = call i64 @llvm.umax.i64(i64 %64, i64 %65)
%67 = add i64 %66, -9
%68 = sub i64 %67, %50
%69 = add i64 %68, 8
%70 = and i64 %69, -8
%71 = getelementptr i8, i8* %48, i64 %70
%72 = getelementptr i8, i8* %49, i64 %70
%73 = icmp ult i8* %48, %72
%74 = icmp ult i8* %49, %71
%75 = and i1 %73, %74
br i1 %75, label %157, label %76
76: ; preds = %62
%77 = and i64 %60, 4611686018427387900
%78 = getelementptr i64, i64* %51, i64 %77
%79 = getelementptr i64, i64* %52, i64 %77
%80 = add nsw i64 %77, -4
%81 = lshr exact i64 %80, 2
%82 = add nuw nsw i64 %81, 1
%83 = and i64 %82, 3
%84 = icmp ult i64 %80, 12
br i1 %84, label %136, label %85
85: ; preds = %76
%86 = and i64 %82, 9223372036854775804
br label %87
87: ; preds = %87, %85
%88 = phi i64 [ 0, %85 ], [ %133, %87 ]
%89 = phi i64 [ 0, %85 ], [ %134, %87 ]
%90 = getelementptr i64, i64* %51, i64 %88
%91 = getelementptr i64, i64* %52, i64 %88
%92 = bitcast i64* %90 to <2 x i64>*
%93 = load <2 x i64>, <2 x i64>* %92
%94 = getelementptr i64, i64* %90, i64 2
%95 = bitcast i64* %94 to <2 x i64>*
%96 = load <2 x i64>, <2 x i64>* %95
%97 = bitcast i64* %91 to <2 x i64>*
store <2 x i64> %93, <2 x i64>* %97
%98 = getelementptr i64, i64* %91, i64 2
%99 = bitcast i64* %98 to <2 x i64>*
store <2 x i64> %96, <2 x i64>* %99
%100 = or i64 %88, 4
%101 = getelementptr i64, i64* %51, i64 %100
%102 = getelementptr i64, i64* %52, i64 %100
%103 = bitcast i64* %101 to <2 x i64>*
%104 = load <2 x i64>, <2 x i64>* %103
%105 = getelementptr i64, i64* %101, i64 2
%106 = bitcast i64* %105 to <2 x i64>*
%107 = load <2 x i64>, <2 x i64>* %106
%108 = bitcast i64* %102 to <2 x i64>*
store <2 x i64> %104, <2 x i64>* %108
%109 = getelementptr i64, i64* %102, i64 2
%110 = bitcast i64* %109 to <2 x i64>*
store <2 x i64> %107, <2 x i64>* %110
%111 = or i64 %88, 8
%112 = getelementptr i64, i64* %51, i64 %111
%113 = getelementptr i64, i64* %52, i64 %111
%114 = bitcast i64* %112 to <2 x i64>*
%115 = load <2 x i64>, <2 x i64>* %114
%116 = getelementptr i64, i64* %112, i64 2
%117 = bitcast i64* %116 to <2 x i64>*
%118 = load <2 x i64>, <2 x i64>* %117
%119 = bitcast i64* %113 to <2 x i64>*
store <2 x i64> %115, <2 x i64>* %119
%120 = getelementptr i64, i64* %113, i64 2
%121 = bitcast i64* %120 to <2 x i64>*
store <2 x i64> %118, <2 x i64>* %121
%122 = or i64 %88, 12
%123 = getelementptr i64, i64* %51, i64 %122
%124 = getelementptr i64, i64* %52, i64 %122
%125 = bitcast i64* %123 to <2 x i64>*
%126 = load <2 x i64>, <2 x i64>* %125
%127 = getelementptr i64, i64* %123, i64 2
%128 = bitcast i64* %127 to <2 x i64>*
%129 = load <2 x i64>, <2 x i64>* %128
%130 = bitcast i64* %124 to <2 x i64>*
store <2 x i64> %126, <2 x i64>* %130
%131 = getelementptr i64, i64* %124, i64 2
%132 = bitcast i64* %131 to <2 x i64>*
store <2 x i64> %129, <2 x i64>* %132
%133 = add nuw i64 %88, 16
%134 = add nuw i64 %89, 4
%135 = icmp eq i64 %134, %86
br i1 %135, label %136, label %87
136: ; preds = %87, %76
%137 = phi i64 [ 0, %76 ], [ %133, %87 ]
%138 = icmp eq i64 %83, 0
br i1 %138, label %155, label %139
139: ; preds = %136, %139
%140 = phi i64 [ %152, %139 ], [ %137, %136 ]
%141 = phi i64 [ %153, %139 ], [ 0, %136 ]
%142 = getelementptr i64, i64* %51, i64 %140
%143 = getelementptr i64, i64* %52, i64 %140
%144 = bitcast i64* %142 to <2 x i64>*
%145 = load <2 x i64>, <2 x i64>* %144
%146 = getelementptr i64, i64* %142, i64 2
%147 = bitcast i64* %146 to <2 x i64>*
%148 = load <2 x i64>, <2 x i64>* %147
%149 = bitcast i64* %143 to <2 x i64>*
store <2 x i64> %145, <2 x i64>* %149
%150 = getelementptr i64, i64* %143, i64 2
%151 = bitcast i64* %150 to <2 x i64>*
store <2 x i64> %148, <2 x i64>* %151
%152 = add nuw i64 %140, 4
%153 = add i64 %141, 1
%154 = icmp eq i64 %153, %83
br i1 %154, label %155, label %139
155: ; preds = %139, %136
%156 = icmp eq i64 %60, %77
br i1 %156, label %169, label %157
157: ; preds = %62, %47, %155
%158 = phi i64* [ %51, %62 ], [ %51, %47 ], [ %78, %155 ]
%159 = phi i64* [ %52, %62 ], [ %52, %47 ], [ %79, %155 ]
br label %160
160: ; preds = %157, %160
%161 = phi i64* [ %163, %160 ], [ %158, %157 ]
%162 = phi i64* [ %165, %160 ], [ %159, %157 ]
%163 = getelementptr inbounds i64, i64* %161, i64 1
%164 = load i64, i64* %161
%165 = getelementptr inbounds i64, i64* %162, i64 1
store i64 %164, i64* %162
%166 = getelementptr inbounds i64, i64* %162, i64 2
%167 = bitcast i64* %166 to i8*
%168 = icmp ult i8* %12, %167
br i1 %168, label %169, label %160
169: ; preds = %160, %155
%170 = phi i64* [ %78, %155 ], [ %163, %160 ]
%171 = phi i64* [ %79, %155 ], [ %165, %160 ]
%172 = bitcast i64* %171 to i8*
%173 = bitcast i64* %170 to i8*
br label %174
174: ; preds = %13, %15, %169
%175 = phi i8* [ %1, %13 ], [ %1, %15 ], [ %172, %169 ]
%176 = phi i8* [ %0, %13 ], [ %0, %15 ], [ %173, %169 ]
%177 = ptrtoint i8* %175 to i64
%178 = icmp ult i8* %175, %12
br i1 %178, label %179, label %481
179: ; preds = %174
%180 = add i64 %4, %11
%181 = sub i64 %180, %177
%182 = icmp ult i64 %181, 8
br i1 %182, label %295, label %183
183: ; preds = %179
%184 = add i64 %4, %11
%185 = sub i64 %184, %177
%186 = getelementptr i8, i8* %175, i64 %185
%187 = getelementptr i8, i8* %176, i64 %185
%188 = icmp ult i8* %175, %187
%189 = icmp ult i8* %176, %186
%190 = and i1 %188, %189
br i1 %190, label %295, label %191
191: ; preds = %183
%192 = icmp ult i64 %181, 32
br i1 %192, label %277, label %193
193: ; preds = %191
%194 = and i64 %181, -32
%195 = add i64 %194, -32
%196 = lshr exact i64 %195, 5
%197 = add nuw nsw i64 %196, 1
%198 = and i64 %197, 3
%199 = icmp ult i64 %195, 96
br i1 %199, label %251, label %200
200: ; preds = %193
%201 = and i64 %197, 1152921504606846972
br label %202
202: ; preds = %202, %200
%203 = phi i64 [ 0, %200 ], [ %248, %202 ]
%204 = phi i64 [ 0, %200 ], [ %249, %202 ]
%205 = getelementptr i8, i8* %176, i64 %203
%206 = getelementptr i8, i8* %175, i64 %203
%207 = bitcast i8* %205 to <16 x i8>*
%208 = load <16 x i8>, <16 x i8>* %207
%209 = getelementptr i8, i8* %205, i64 16
%210 = bitcast i8* %209 to <16 x i8>*
%211 = load <16 x i8>, <16 x i8>* %210
%212 = bitcast i8* %206 to <16 x i8>*
store <16 x i8> %208, <16 x i8>* %212
%213 = getelementptr i8, i8* %206, i64 16
%214 = bitcast i8* %213 to <16 x i8>*
store <16 x i8> %211, <16 x i8>* %214
%215 = or i64 %203, 32
%216 = getelementptr i8, i8* %176, i64 %215
%217 = getelementptr i8, i8* %175, i64 %215
%218 = bitcast i8* %216 to <16 x i8>*
%219 = load <16 x i8>, <16 x i8>* %218
%220 = getelementptr i8, i8* %216, i64 16
%221 = bitcast i8* %220 to <16 x i8>*
%222 = load <16 x i8>, <16 x i8>* %221
%223 = bitcast i8* %217 to <16 x i8>*
store <16 x i8> %219, <16 x i8>* %223
%224 = getelementptr i8, i8* %217, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
store <16 x i8> %222, <16 x i8>* %225
%226 = or i64 %203, 64
%227 = getelementptr i8, i8* %176, i64 %226
%228 = getelementptr i8, i8* %175, i64 %226
%229 = bitcast i8* %227 to <16 x i8>*
%230 = load <16 x i8>, <16 x i8>* %229
%231 = getelementptr i8, i8* %227, i64 16
%232 = bitcast i8* %231 to <16 x i8>*
%233 = load <16 x i8>, <16 x i8>* %232
%234 = bitcast i8* %228 to <16 x i8>*
store <16 x i8> %230, <16 x i8>* %234
%235 = getelementptr i8, i8* %228, i64 16
%236 = bitcast i8* %235 to <16 x i8>*
store <16 x i8> %233, <16 x i8>* %236
%237 = or i64 %203, 96
%238 = getelementptr i8, i8* %176, i64 %237
%239 = getelementptr i8, i8* %175, i64 %237
%240 = bitcast i8* %238 to <16 x i8>*
%241 = load <16 x i8>, <16 x i8>* %240
%242 = getelementptr i8, i8* %238, i64 16
%243 = bitcast i8* %242 to <16 x i8>*
%244 = load <16 x i8>, <16 x i8>* %243
%245 = bitcast i8* %239 to <16 x i8>*
store <16 x i8> %241, <16 x i8>* %245
%246 = getelementptr i8, i8* %239, i64 16
%247 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %244, <16 x i8>* %247
%248 = add nuw i64 %203, 128
%249 = add i64 %204, 4
%250 = icmp eq i64 %249, %201
br i1 %250, label %251, label %202
251: ; preds = %202, %193
%252 = phi i64 [ 0, %193 ], [ %248, %202 ]
%253 = icmp eq i64 %198, 0
br i1 %253, label %270, label %254
254: ; preds = %251, %254
%255 = phi i64 [ %267, %254 ], [ %252, %251 ]
%256 = phi i64 [ %268, %254 ], [ 0, %251 ]
%257 = getelementptr i8, i8* %176, i64 %255
%258 = getelementptr i8, i8* %175, i64 %255
%259 = bitcast i8* %257 to <16 x i8>*
%260 = load <16 x i8>, <16 x i8>* %259
%261 = getelementptr i8, i8* %257, i64 16
%262 = bitcast i8* %261 to <16 x i8>*
%263 = load <16 x i8>, <16 x i8>* %262
%264 = bitcast i8* %258 to <16 x i8>*
store <16 x i8> %260, <16 x i8>* %264
%265 = getelementptr i8, i8* %258, i64 16
%266 = bitcast i8* %265 to <16 x i8>*
store <16 x i8> %263, <16 x i8>* %266
%267 = add nuw i64 %255, 32
%268 = add i64 %256, 1
%269 = icmp eq i64 %268, %198
br i1 %269, label %270, label %254
270: ; preds = %254, %251
%271 = icmp eq i64 %181, %194
br i1 %271, label %481, label %272
272: ; preds = %270
%273 = getelementptr i8, i8* %175, i64 %194
%274 = getelementptr i8, i8* %176, i64 %194
%275 = and i64 %181, 24
%276 = icmp eq i64 %275, 0
br i1 %276, label %295, label %277
277: ; preds = %191, %272
%278 = phi i64 [ %194, %272 ], [ 0, %191 ]
%279 = add i64 %4, %11
%280 = sub i64 %279, %177
%281 = and i64 %280, -8
%282 = getelementptr i8, i8* %176, i64 %281
%283 = getelementptr i8, i8* %175, i64 %281
br label %284
284: ; preds = %284, %277
%285 = phi i64 [ %278, %277 ], [ %291, %284 ]
%286 = getelementptr i8, i8* %176, i64 %285
%287 = getelementptr i8, i8* %175, i64 %285
%288 = bitcast i8* %286 to <8 x i8>*
%289 = load <8 x i8>, <8 x i8>* %288
%290 = bitcast i8* %287 to <8 x i8>*
store <8 x i8> %289, <8 x i8>* %290
%291 = add nuw i64 %285, 8
%292 = icmp eq i64 %291, %281
br i1 %292, label %293, label %284
293: ; preds = %284
%294 = icmp eq i64 %280, %281
br i1 %294, label %481, label %295
295: ; preds = %183, %179, %272, %293
%296 = phi i8* [ %176, %179 ], [ %176, %183 ], [ %274, %272 ], [ %282, %293 ]
%297 = phi i8* [ %175, %179 ], [ %175, %183 ], [ %273, %272 ], [ %283, %293 ]
br label %298
298: ; preds = %295, %298
%299 = phi i8* [ %301, %298 ], [ %296, %295 ]
%300 = phi i8* [ %303, %298 ], [ %297, %295 ]
%301 = getelementptr inbounds i8, i8* %299, i64 1
%302 = load i8, i8* %299
%303 = getelementptr inbounds i8, i8* %300, i64 1
store i8 %302, i8* %300
%304 = icmp ult i8* %303, %12
br i1 %304, label %298, label %481
305: ; preds = %3
%306 = getelementptr inbounds i8, i8* %0, i64 %11
%307 = icmp slt i32 %2, 10
br i1 %307, label %352, label %308
308: ; preds = %305
%309 = ptrtoint i8* %12 to i64
%310 = ptrtoint i8* %306 to i64
%311 = xor i64 %309, %310
%312 = and i64 %311, 3
%313 = icmp eq i64 %312, 0
br i1 %313, label %314, label %352
314: ; preds = %308
%315 = and i64 %309, 3
%316 = icmp eq i64 %315, 0
br i1 %316, label %335, label %317
317: ; preds = %314
%318 = getelementptr inbounds i8, i8* %306, i64 -1
%319 = load i8, i8* %318
%320 = getelementptr inbounds i8, i8* %12, i64 -1
store i8 %319, i8* %320
%321 = ptrtoint i8* %320 to i64
%322 = and i64 %321, 3
%323 = icmp eq i64 %322, 0
br i1 %323, label %335, label %324
324: ; preds = %317
%325 = getelementptr inbounds i8, i8* %318, i64 -1
%326 = load i8, i8* %325
%327 = getelementptr inbounds i8, i8* %320, i64 -1
store i8 %326, i8* %327
%328 = ptrtoint i8* %327 to i64
%329 = and i64 %328, 3
%330 = icmp eq i64 %329, 0
br i1 %330, label %335, label %331
331: ; preds = %324
%332 = getelementptr inbounds i8, i8* %325, i64 -1
%333 = load i8, i8* %332
%334 = getelementptr inbounds i8, i8* %327, i64 -1
store i8 %333, i8* %334
br label %335
335: ; preds = %317, %324, %331, %314
%336 = phi i8* [ %12, %314 ], [ %320, %317 ], [ %327, %324 ], [ %334, %331 ]
%337 = phi i8* [ %306, %314 ], [ %318, %317 ], [ %325, %324 ], [ %332, %331 ]
%338 = bitcast i8* %337 to i64*
%339 = bitcast i8* %336 to i64*
br label %340
340: ; preds = %340, %335
%341 = phi i64* [ %338, %335 ], [ %343, %340 ]
%342 = phi i64* [ %339, %335 ], [ %345, %340 ]
%343 = getelementptr inbounds i64, i64* %341, i64 -1
%344 = load i64, i64* %343
%345 = getelementptr inbounds i64, i64* %342, i64 -1
store i64 %344, i64* %345
%346 = getelementptr inbounds i64, i64* %342, i64 -2
%347 = bitcast i64* %346 to i8*
%348 = icmp ult i8* %347, %1
br i1 %348, label %349, label %340
349: ; preds = %340
%350 = bitcast i64* %345 to i8*
%351 = bitcast i64* %343 to i8*
br label %352
352: ; preds = %305, %308, %349
%353 = phi i8* [ %12, %305 ], [ %12, %308 ], [ %350, %349 ]
%354 = phi i8* [ %306, %305 ], [ %306, %308 ], [ %351, %349 ]
%355 = ptrtoint i8* %353 to i64
%356 = icmp ugt i8* %353, %1
br i1 %356, label %357, label %481
357: ; preds = %352
%358 = sub i64 %355, %4
%359 = icmp ult i64 %358, 4
br i1 %359, label %471, label %360
360: ; preds = %357
%361 = sub i64 %4, %355
%362 = getelementptr i8, i8* %353, i64 %361
%363 = getelementptr i8, i8* %354, i64 %361
%364 = icmp ult i8* %362, %354
%365 = icmp ult i8* %363, %353
%366 = and i1 %364, %365
br i1 %366, label %471, label %367
367: ; preds = %360
%368 = icmp ult i64 %358, 16
br i1 %368, label %448, label %369
369: ; preds = %367
%370 = and i64 %358, -16
%371 = add i64 %370, -16
%372 = lshr exact i64 %371, 4
%373 = add nuw nsw i64 %372, 1
%374 = and i64 %373, 3
%375 = icmp ult i64 %371, 48
br i1 %375, label %420, label %376
376: ; preds = %369
%377 = and i64 %373, 2305843009213693948
%378 = getelementptr i8, i8* %354, i64 -16
%379 = getelementptr i8, i8* %353, i64 -16
%380 = getelementptr i8, i8* %354, i64 -16
%381 = getelementptr i8, i8* %353, i64 -16
%382 = getelementptr i8, i8* %354, i64 -16
%383 = getelementptr i8, i8* %353, i64 -16
%384 = getelementptr i8, i8* %354, i64 -16
%385 = getelementptr i8, i8* %353, i64 -16
br label %386
386: ; preds = %386, %376
%387 = phi i64 [ 0, %376 ], [ %417, %386 ]
%388 = phi i64 [ 0, %376 ], [ %418, %386 ]
%389 = sub i64 0, %387
%390 = sub i64 0, %387
%391 = getelementptr inbounds i8, i8* %378, i64 %389
%392 = bitcast i8* %391 to <16 x i8>*
%393 = load <16 x i8>, <16 x i8>* %392
%394 = getelementptr inbounds i8, i8* %379, i64 %390
%395 = bitcast i8* %394 to <16 x i8>*
store <16 x i8> %393, <16 x i8>* %395
%396 = sub nuw nsw i64 -16, %387
%397 = sub nuw nsw i64 -16, %387
%398 = getelementptr inbounds i8, i8* %380, i64 %396
%399 = bitcast i8* %398 to <16 x i8>*
%400 = load <16 x i8>, <16 x i8>* %399
%401 = getelementptr inbounds i8, i8* %381, i64 %397
%402 = bitcast i8* %401 to <16 x i8>*
store <16 x i8> %400, <16 x i8>* %402
%403 = sub nuw nsw i64 -32, %387
%404 = sub nuw nsw i64 -32, %387
%405 = getelementptr inbounds i8, i8* %382, i64 %403
%406 = bitcast i8* %405 to <16 x i8>*
%407 = load <16 x i8>, <16 x i8>* %406
%408 = getelementptr inbounds i8, i8* %383, i64 %404
%409 = bitcast i8* %408 to <16 x i8>*
store <16 x i8> %407, <16 x i8>* %409
%410 = sub nuw nsw i64 -48, %387
%411 = sub nuw nsw i64 -48, %387
%412 = getelementptr inbounds i8, i8* %384, i64 %410
%413 = bitcast i8* %412 to <16 x i8>*
%414 = load <16 x i8>, <16 x i8>* %413
%415 = getelementptr inbounds i8, i8* %385, i64 %411
%416 = bitcast i8* %415 to <16 x i8>*
store <16 x i8> %414, <16 x i8>* %416
%417 = add nuw i64 %387, 64
%418 = add i64 %388, 4
%419 = icmp eq i64 %418, %377
br i1 %419, label %420, label %386
420: ; preds = %386, %369
%421 = phi i64 [ 0, %369 ], [ %417, %386 ]
%422 = icmp eq i64 %374, 0
br i1 %422, label %439, label %423
423: ; preds = %420
%424 = getelementptr i8, i8* %354, i64 -16
%425 = getelementptr i8, i8* %353, i64 -16
br label %426
426: ; preds = %426, %423
%427 = phi i64 [ %421, %423 ], [ %436, %426 ]
%428 = phi i64 [ 0, %423 ], [ %437, %426 ]
%429 = sub i64 0, %427
%430 = sub i64 0, %427
%431 = getelementptr inbounds i8, i8* %424, i64 %429
%432 = bitcast i8* %431 to <16 x i8>*
%433 = load <16 x i8>, <16 x i8>* %432
%434 = getelementptr inbounds i8, i8* %425, i64 %430
%435 = bitcast i8* %434 to <16 x i8>*
store <16 x i8> %433, <16 x i8>* %435
%436 = add nuw i64 %427, 16
%437 = add i64 %428, 1
%438 = icmp eq i64 %437, %374
br i1 %438, label %439, label %426
439: ; preds = %426, %420
%440 = icmp eq i64 %358, %370
br i1 %440, label %481, label %441
441: ; preds = %439
%442 = sub i64 0, %370
%443 = getelementptr i8, i8* %353, i64 %442
%444 = sub i64 0, %370
%445 = getelementptr i8, i8* %354, i64 %444
%446 = and i64 %358, 12
%447 = icmp eq i64 %446, 0
br i1 %447, label %471, label %448
448: ; preds = %367, %441
%449 = phi i64 [ %370, %441 ], [ 0, %367 ]
%450 = sub i64 %355, %4
%451 = and i64 %450, -4
%452 = sub i64 0, %451
%453 = getelementptr i8, i8* %354, i64 %452
%454 = sub i64 0, %451
%455 = getelementptr i8, i8* %353, i64 %454
%456 = getelementptr i8, i8* %354, i64 -4
%457 = getelementptr i8, i8* %353, i64 -4
br label %458
458: ; preds = %458, %448
%459 = phi i64 [ %449, %448 ], [ %467, %458 ]
%460 = sub i64 0, %459
%461 = sub i64 0, %459
%462 = getelementptr inbounds i8, i8* %456, i64 %460
%463 = bitcast i8* %462 to <4 x i8>*
%464 = load <4 x i8>, <4 x i8>* %463
%465 = getelementptr inbounds i8, i8* %457, i64 %461
%466 = bitcast i8* %465 to <4 x i8>*
store <4 x i8> %464, <4 x i8>* %466
%467 = add nuw i64 %459, 4
%468 = icmp eq i64 %467, %451
br i1 %468, label %469, label %458
469: ; preds = %458
%470 = icmp eq i64 %450, %451
br i1 %470, label %481, label %471
471: ; preds = %360, %357, %441, %469
%472 = phi i8* [ %354, %357 ], [ %354, %360 ], [ %445, %441 ], [ %453, %469 ]
%473 = phi i8* [ %353, %357 ], [ %353, %360 ], [ %443, %441 ], [ %455, %469 ]
br label %474
474: ; preds = %471, %474
%475 = phi i8* [ %477, %474 ], [ %472, %471 ]
%476 = phi i8* [ %479, %474 ], [ %473, %471 ]
%477 = getelementptr inbounds i8, i8* %475, i64 -1
%478 = load i8, i8* %477
%479 = getelementptr inbounds i8, i8* %476, i64 -1
store i8 %478, i8* %479
%480 = icmp ugt i8* %479, %1
br i1 %480, label %474, label %481
481: ; preds = %298, %474, %270, %293, %439, %469, %174, %352
ret void
}