#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 *memmove(void *a, const void *b, size_t n) {
  if ((((int)a | (int)b | (int)n) & 3) == 0) {
    int *wa, *wb;
    n >>= 2;
    if (a < (void *)b)
      for (wa = (int *)a, wb = (int *)b; n-- > 0;)
        *wa++ = *wb++;
    else
      for (wa = n + (int *)a, wb = n + (int *)b; n-- > 0;)
        *--wa = *--wb;
  } else {
    char *ca, *cb;
    if (a < (void *)b)
      for (ca = (char *)a, cb = (char *)b; n-- > 0;)
        *ca++ = *cb++;
    else
      for (ca = n + (char *)a, cb = n + (char *)b; n-- > 0;)
        *--ca = *--cb;
  }
  return a;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
or     %ecx,%eax
mov    -0x18(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    120d <memmove+0x10d>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    119b <memmove+0x9b>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jbe    1196 <memmove+0x96>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%ecx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x20(%rbp)
mov    %ecx,(%rax)
jmp    1156 <memmove+0x56>
jmp    1208 <memmove+0x108>
mov    -0x18(%rbp),%rcx
mov    -0x8(%rbp),%rax
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jbe    1203 <memmove+0x103>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x28(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x4(%rax)
jmp    11c1 <memmove+0xc1>
jmp    1208 <memmove+0x108>
jmp    12d4 <memmove+0x1d4>
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1270 <memmove+0x170>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jbe    126b <memmove+0x16b>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    122b <memmove+0x12b>
jmp    12cf <memmove+0x1cf>
mov    -0x18(%rbp),%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jbe    12ca <memmove+0x1ca>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x1(%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,-0x1(%rax)
jmp    1288 <memmove+0x188>
jmp    12cf <memmove+0x1cf>
jmp    12d4 <memmove+0x1d4>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rax
mov    %esi,%ecx
or     %eax,%ecx
mov    %edx,%edi
or     %ecx,%edi
test   $0x3,%dil
je     11f4 <memmove+0xf4>
cmp    %rsi,%rax
jae    12cc <memmove+0x1cc>
test   %rdx,%rdx
je     1879 <memmove+0x779>
cmp    $0x8,%rdx
jb     114b <memmove+0x4b>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    144c <memmove+0x34c>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    144c <memmove+0x34c>
mov    %rsi,%rdi
mov    %rax,%rcx
mov    %rdx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%rbx
and    $0x7,%rbx
je     1189 <memmove+0x89>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1170 <memmove+0x70>
add    %rsi,%rdi
add    %rsi,%rcx
sub    %rsi,%r9
cmp    $0x7,%r8
jb     1879 <memmove+0x779>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
movzbl 0x1(%rdi,%rdx,1),%ebx
mov    %bl,0x1(%rcx,%rdx,1)
movzbl 0x2(%rdi,%rdx,1),%ebx
mov    %bl,0x2(%rcx,%rdx,1)
movzbl 0x3(%rdi,%rdx,1),%ebx
mov    %bl,0x3(%rcx,%rdx,1)
movzbl 0x4(%rdi,%rdx,1),%ebx
mov    %bl,0x4(%rcx,%rdx,1)
movzbl 0x5(%rdi,%rdx,1),%ebx
mov    %bl,0x5(%rcx,%rdx,1)
movzbl 0x6(%rdi,%rdx,1),%ebx
mov    %bl,0x6(%rcx,%rdx,1)
movzbl 0x7(%rdi,%rdx,1),%ebx
mov    %bl,0x7(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    11a0 <memmove+0xa0>
jmp    1879 <memmove+0x779>
mov    %rdx,%r8
shr    $0x2,%r8
cmp    %rsi,%rax
jae    1396 <memmove+0x296>
cmp    $0x4,%rdx
jb     1879 <memmove+0x779>
cmp    $0x20,%rdx
jb     1231 <memmove+0x131>
and    $0xfffffffffffffffc,%rdx
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    14bf <memmove+0x3bf>
add    %rax,%rdx
cmp    %rsi,%rdx
jbe    14bf <memmove+0x3bf>
mov    %rax,%rcx
lea    -0x1(%r8),%r9
mov    %r8,%rdi
and    $0x7,%rdi
je     1268 <memmove+0x168>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi),%ebx
add    $0x4,%rsi
mov    %ebx,(%rcx)
add    $0x4,%rcx
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1250 <memmove+0x150>
sub    %rdx,%r8
cmp    $0x7,%r9
jb     1879 <memmove+0x779>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%rdx,4),%edi
mov    %edi,(%rcx,%rdx,4)
mov    0x4(%rsi,%rdx,4),%edi
mov    %edi,0x4(%rcx,%rdx,4)
mov    0x8(%rsi,%rdx,4),%edi
mov    %edi,0x8(%rcx,%rdx,4)
mov    0xc(%rsi,%rdx,4),%edi
mov    %edi,0xc(%rcx,%rdx,4)
mov    0x10(%rsi,%rdx,4),%edi
mov    %edi,0x10(%rcx,%rdx,4)
mov    0x14(%rsi,%rdx,4),%edi
mov    %edi,0x14(%rcx,%rdx,4)
mov    0x18(%rsi,%rdx,4),%edi
mov    %edi,0x18(%rcx,%rdx,4)
mov    0x1c(%rsi,%rdx,4),%edi
mov    %edi,0x1c(%rcx,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r8
jne    1280 <memmove+0x180>
jmp    1879 <memmove+0x779>
test   %rdx,%rdx
je     1879 <memmove+0x779>
lea    (%rsi,%rdx,1),%r9
lea    (%rax,%rdx,1),%r8
cmp    $0x4,%rdx
jb     12f5 <memmove+0x1f5>
cmp    %rax,%r9
jbe    145a <memmove+0x35a>
cmp    %rsi,%r8
jbe    145a <memmove+0x35a>
mov    %r9,%rsi
mov    %r8,%rdi
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rdx
and    $0x7,%rdx
je     132b <memmove+0x22b>
xor    %ecx,%ecx
nopl   (%rax)
movzbl -0x1(%rsi),%ebx
add    $0xffffffffffffffff,%rsi
mov    %bl,-0x1(%rdi)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1310 <memmove+0x210>
sub    %rcx,%r10
cmp    $0x7,%r8
jb     1879 <memmove+0x779>
neg    %r10
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rsi,%rcx,1),%edx
mov    %dl,-0x1(%rdi,%rcx,1)
movzbl -0x2(%rsi,%rcx,1),%edx
mov    %dl,-0x2(%rdi,%rcx,1)
movzbl -0x3(%rsi,%rcx,1),%edx
mov    %dl,-0x3(%rdi,%rcx,1)
movzbl -0x4(%rsi,%rcx,1),%edx
mov    %dl,-0x4(%rdi,%rcx,1)
movzbl -0x5(%rsi,%rcx,1),%edx
mov    %dl,-0x5(%rdi,%rcx,1)
movzbl -0x6(%rsi,%rcx,1),%edx
mov    %dl,-0x6(%rdi,%rcx,1)
movzbl -0x7(%rsi,%rcx,1),%edx
mov    %dl,-0x7(%rdi,%rcx,1)
movzbl -0x8(%rsi,%rcx,1),%edx
mov    %dl,-0x8(%rdi,%rcx,1)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%r10
jne    1340 <memmove+0x240>
jmp    1879 <memmove+0x779>
cmp    $0x4,%rdx
jb     1879 <memmove+0x779>
lea    (%rsi,%r8,4),%rdi
lea    (%rax,%r8,4),%rcx
cmp    $0x20,%rdx
jb     17e4 <memmove+0x6e4>
and    $0xfffffffffffffffc,%rdx
lea    (%rsi,%rdx,1),%rbx
cmp    %rax,%rbx
jbe    13cb <memmove+0x2cb>
add    %rax,%rdx
cmp    %rsi,%rdx
ja     17e4 <memmove+0x6e4>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdx
mov    %rdx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     17a5 <memmove+0x6a5>
movabs $0x3ffffffffffffff8,%rdx
ff ff 3f
add    $0x6,%rdx
and    %r10,%rdx
lea    (%rax,%r8,4),%r11
add    $0xfffffffffffffff0,%r11
lea    (%rsi,%r8,4),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %esi,%esi
nopl   (%rax)
movups -0x10(%rbx,%rsi,4),%xmm0
movups (%rbx,%rsi,4),%xmm1
movups %xmm1,(%r11,%rsi,4)
movups %xmm0,-0x10(%r11,%rsi,4)
movups -0x30(%rbx,%rsi,4),%xmm0
movups -0x20(%rbx,%rsi,4),%xmm1
movups %xmm1,-0x20(%r11,%rsi,4)
movups %xmm0,-0x30(%r11,%rsi,4)
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1410 <memmove+0x310>
neg    %rsi
jmp    17a7 <memmove+0x6a7>
cmp    $0x20,%rdx
jae    1467 <memmove+0x367>
xor    %r8d,%r8d
jmp    15ad <memmove+0x4ad>
cmp    $0x10,%rdx
jae    1491 <memmove+0x391>
xor    %ecx,%ecx
jmp    1687 <memmove+0x587>
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rcx
jae    14eb <memmove+0x3eb>
xor    %ecx,%ecx
jmp    1558 <memmove+0x458>
mov    %rdx,%rcx
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rdi
mov    %rdi,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x30,%rdi
jae    15ef <memmove+0x4ef>
xor    %edi,%edi
jmp    1637 <memmove+0x537>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rcx
jae    16d1 <memmove+0x5d1>
xor    %ecx,%ecx
jmp    1748 <memmove+0x648>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1500 <memmove+0x400>
test   %r9,%r9
je     159b <memmove+0x49b>
lea    (%rax,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1580 <memmove+0x480>
cmp    %rdx,%r8
je     1879 <memmove+0x779>
test   $0x18,%dl
je     187e <memmove+0x77e>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rsi,%r10,1),%rdi
lea    (%rax,%r10,1),%rcx
mov    %edx,%r9d
and    $0x7,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    15d0 <memmove+0x4d0>
cmp    %rdx,%r10
jne    1154 <memmove+0x54>
jmp    1879 <memmove+0x779>
and    $0xfffffffffffffffc,%r11
lea    -0x10(%r9),%r14
lea    -0x10(%r8),%rbx
xor    %edi,%edi
nopl   (%rax)
movups (%r14,%rdi,1),%xmm0
movups %xmm0,(%rbx,%rdi,1)
movups -0x10(%r14,%rdi,1),%xmm0
movups %xmm0,-0x10(%rbx,%rdi,1)
movups -0x20(%r14,%rdi,1),%xmm0
movups %xmm0,-0x20(%rbx,%rdi,1)
movups -0x30(%r14,%rdi,1),%xmm0
movups %xmm0,-0x30(%rbx,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%r11
jne    1600 <memmove+0x500>
neg    %rdi
test   %r10,%r10
je     1675 <memmove+0x575>
mov    %rdx,%rbx
sub    %rdi,%rbx
lea    (%rax,%rbx,1),%r11
add    $0xfffffffffffffff0,%r11
add    %rbx,%rsi
add    $0xfffffffffffffff0,%rsi
shl    $0x4,%r10
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%r11,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r10,%rdi
add    %rbx,%rdi
jne    1660 <memmove+0x560>
cmp    %rdx,%rcx
je     1879 <memmove+0x779>
test   $0xc,%dl
je     1890 <memmove+0x790>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%rbx
neg    %rbx
mov    %r9,%rsi
sub    %r11,%rsi
mov    %r8,%rdi
sub    %r11,%rdi
mov    %edx,%r10d
and    $0x3,%r10d
neg    %rcx
nopw   0x0(%rax,%rax,1)
mov    -0x4(%r9,%rcx,1),%ebp
mov    %ebp,-0x4(%r8,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%rbx
jne    16b0 <memmove+0x5b0>
cmp    %rdx,%r11
jne    12fe <memmove+0x1fe>
jmp    1879 <memmove+0x779>
movabs $0x3ffffffffffffff8,%rcx
ff ff 3f
add    $0x4,%rcx
and    %rcx,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups %xmm0,(%rax,%rcx,4)
movups %xmm1,0x10(%rax,%rcx,4)
movups 0x20(%rsi,%rcx,4),%xmm0
movups 0x30(%rsi,%rcx,4),%xmm1
movups %xmm0,0x20(%rax,%rcx,4)
movups %xmm1,0x30(%rax,%rcx,4)
movups 0x40(%rsi,%rcx,4),%xmm0
movups 0x50(%rsi,%rcx,4),%xmm1
movups %xmm0,0x40(%rax,%rcx,4)
movups %xmm1,0x50(%rax,%rcx,4)
movups 0x60(%rsi,%rcx,4),%xmm0
movups 0x70(%rsi,%rcx,4),%xmm1
movups %xmm0,0x60(%rax,%rcx,4)
movups %xmm1,0x70(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    16f0 <memmove+0x5f0>
test   %rdx,%rdx
je     178b <memmove+0x68b>
lea    (%rax,%rcx,4),%rdi
add    $0x10,%rdi
lea    (%rsi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rdx
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(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    1770 <memmove+0x670>
cmp    %r9,%r8
je     1879 <memmove+0x779>
and    $0x7,%r8d
lea    (%rsi,%r9,4),%rsi
lea    (%rax,%r9,4),%rcx
jmp    1234 <memmove+0x134>
xor    %esi,%esi
test   $0x1,%r10b
je     17cd <memmove+0x6cd>
shl    $0x2,%rsi
mov    %rdi,%rdx
sub    %rsi,%rdx
mov    %rcx,%rbx
sub    %rsi,%rbx
movups -0x20(%rdx),%xmm0
movups -0x10(%rdx),%xmm1
movups %xmm1,-0x10(%rbx)
movups %xmm0,-0x20(%rbx)
cmp    %r9,%r8
je     1879 <memmove+0x779>
shl    $0x2,%r9
and    $0x7,%r8d
sub    %r9,%rdi
sub    %r9,%rcx
lea    -0x1(%r8),%r9
mov    %r8,%rsi
and    $0x7,%rsi
je     181a <memmove+0x71a>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x4(%rdi),%ebx
add    $0xfffffffffffffffc,%rdi
mov    %ebx,-0x4(%rcx)
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1800 <memmove+0x700>
sub    %rdx,%r8
cmp    $0x7,%r9
jb     1879 <memmove+0x779>
neg    %r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x4(%rdi,%rdx,4),%esi
mov    %esi,-0x4(%rcx,%rdx,4)
mov    -0x8(%rdi,%rdx,4),%esi
mov    %esi,-0x8(%rcx,%rdx,4)
mov    -0xc(%rdi,%rdx,4),%esi
mov    %esi,-0xc(%rcx,%rdx,4)
mov    -0x10(%rdi,%rdx,4),%esi
mov    %esi,-0x10(%rcx,%rdx,4)
mov    -0x14(%rdi,%rdx,4),%esi
mov    %esi,-0x14(%rcx,%rdx,4)
mov    -0x18(%rdi,%rdx,4),%esi
mov    %esi,-0x18(%rcx,%rdx,4)
mov    -0x1c(%rdi,%rdx,4),%esi
mov    %esi,-0x1c(%rcx,%rdx,4)
mov    -0x20(%rdi,%rdx,4),%esi
mov    %esi,-0x20(%rcx,%rdx,4)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%r8
jne    1830 <memmove+0x730>
pop    %rbx
pop    %r14
pop    %rbp
ret
and    $0x1f,%edx
lea    (%rax,%r8,1),%rcx
add    %r8,%rsi
mov    %rsi,%rdi
jmp    1151 <memmove+0x51>
and    $0xf,%edx
sub    %rcx,%r8
sub    %rcx,%r9
jmp    12f5 <memmove+0x1f5>

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

LLVM IR (-O2):
define i8* @memmove(i8* returned %0, i8* %1, i64 %2) {
%4 = ptrtoint i8* %0 to i64
%5 = ptrtoint i8* %1 to i64
%6 = or i64 %5, %4
%7 = or i64 %6, %2
%8 = and i64 %7, 3
%9 = icmp eq i64 %8, 0
br i1 %9, label %10, label %308
10: ; preds = %3
%11 = lshr i64 %2, 2
%12 = icmp ult i8* %0, %1
%13 = icmp ult i64 %2, 4
br i1 %12, label %14, label %161
14: ; preds = %10
br i1 %13, label %656, label %15
15: ; preds = %14
%16 = bitcast i8* %1 to i32*
%17 = bitcast i8* %0 to i32*
%18 = icmp ult i64 %2, 32
br i1 %18, label %108, label %19
19: ; preds = %15
%20 = and i64 %2, -4
%21 = getelementptr i8, i8* %0, i64 %20
%22 = getelementptr i8, i8* %1, i64 %20
%23 = icmp ugt i8* %22, %0
%24 = icmp ugt i8* %21, %1
%25 = and i1 %23, %24
br i1 %25, label %108, label %26
26: ; preds = %19
%27 = and i64 %11, 4611686018427387896
%28 = getelementptr i32, i32* %16, i64 %27
%29 = getelementptr i32, i32* %17, i64 %27
%30 = and i64 %11, 7
%31 = add nsw i64 %27, -8
%32 = lshr exact i64 %31, 3
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 3
%35 = icmp ult i64 %31, 24
br i1 %35, label %87, label %36
36: ; preds = %26
%37 = and i64 %33, 4611686018427387900
br label %38
38: ; preds = %38, %36
%39 = phi i64 [ 0, %36 ], [ %84, %38 ]
%40 = phi i64 [ 0, %36 ], [ %85, %38 ]
%41 = getelementptr i32, i32* %16, i64 %39
%42 = getelementptr i32, i32* %17, i64 %39
%43 = bitcast i32* %41 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = getelementptr i32, i32* %41, i64 4
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %44, <4 x i32>* %48
%49 = getelementptr i32, i32* %42, i64 4
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %50
%51 = or i64 %39, 8
%52 = getelementptr i32, i32* %16, i64 %51
%53 = getelementptr i32, i32* %17, i64 %51
%54 = bitcast i32* %52 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = getelementptr i32, i32* %52, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %59
%60 = getelementptr i32, i32* %53, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %61
%62 = or i64 %39, 16
%63 = getelementptr i32, i32* %16, i64 %62
%64 = getelementptr i32, i32* %17, i64 %62
%65 = bitcast i32* %63 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = getelementptr i32, i32* %63, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
%69 = load <4 x i32>, <4 x i32>* %68
%70 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %70
%71 = getelementptr i32, i32* %64, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %69, <4 x i32>* %72
%73 = or i64 %39, 24
%74 = getelementptr i32, i32* %16, i64 %73
%75 = getelementptr i32, i32* %17, i64 %73
%76 = bitcast i32* %74 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = getelementptr i32, i32* %74, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %77, <4 x i32>* %81
%82 = getelementptr i32, i32* %75, i64 4
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %83
%84 = add nuw i64 %39, 32
%85 = add i64 %40, 4
%86 = icmp eq i64 %85, %37
br i1 %86, label %87, label %38
87: ; preds = %38, %26
%88 = phi i64 [ 0, %26 ], [ %84, %38 ]
%89 = icmp eq i64 %34, 0
br i1 %89, label %106, label %90
90: ; preds = %87, %90
%91 = phi i64 [ %103, %90 ], [ %88, %87 ]
%92 = phi i64 [ %104, %90 ], [ 0, %87 ]
%93 = getelementptr i32, i32* %16, i64 %91
%94 = getelementptr i32, i32* %17, i64 %91
%95 = bitcast i32* %93 to <4 x i32>*
%96 = load <4 x i32>, <4 x i32>* %95
%97 = getelementptr i32, i32* %93, i64 4
%98 = bitcast i32* %97 to <4 x i32>*
%99 = load <4 x i32>, <4 x i32>* %98
%100 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> %96, <4 x i32>* %100
%101 = getelementptr i32, i32* %94, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> %99, <4 x i32>* %102
%103 = add nuw i64 %91, 8
%104 = add i64 %92, 1
%105 = icmp eq i64 %104, %34
br i1 %105, label %106, label %90
106: ; preds = %90, %87
%107 = icmp eq i64 %11, %27
br i1 %107, label %656, label %108
108: ; preds = %19, %15, %106
%109 = phi i32* [ %16, %19 ], [ %16, %15 ], [ %28, %106 ]
%110 = phi i32* [ %17, %19 ], [ %17, %15 ], [ %29, %106 ]
%111 = phi i64 [ %11, %19 ], [ %11, %15 ], [ %30, %106 ]
%112 = add nsw i64 %111, -1
%113 = and i64 %111, 7
%114 = icmp eq i64 %113, 0
br i1 %114, label %126, label %115
115: ; preds = %108, %115
%116 = phi i32* [ %121, %115 ], [ %109, %108 ]
%117 = phi i32* [ %123, %115 ], [ %110, %108 ]
%118 = phi i64 [ %120, %115 ], [ %111, %108 ]
%119 = phi i64 [ %124, %115 ], [ 0, %108 ]
%120 = add nsw i64 %118, -1
%121 = getelementptr inbounds i32, i32* %116, i64 1
%122 = load i32, i32* %116
%123 = getelementptr inbounds i32, i32* %117, i64 1
store i32 %122, i32* %117
%124 = add i64 %119, 1
%125 = icmp eq i64 %124, %113
br i1 %125, label %126, label %115
126: ; preds = %115, %108
%127 = phi i32* [ %109, %108 ], [ %121, %115 ]
%128 = phi i32* [ %110, %108 ], [ %123, %115 ]
%129 = phi i64 [ %111, %108 ], [ %120, %115 ]
%130 = icmp ult i64 %112, 7
br i1 %130, label %656, label %131
131: ; preds = %126, %131
%132 = phi i32* [ %157, %131 ], [ %127, %126 ]
%133 = phi i32* [ %159, %131 ], [ %128, %126 ]
%134 = phi i64 [ %156, %131 ], [ %129, %126 ]
%135 = getelementptr inbounds i32, i32* %132, i64 1
%136 = load i32, i32* %132
%137 = getelementptr inbounds i32, i32* %133, i64 1
store i32 %136, i32* %133
%138 = getelementptr inbounds i32, i32* %132, i64 2
%139 = load i32, i32* %135
%140 = getelementptr inbounds i32, i32* %133, i64 2
store i32 %139, i32* %137
%141 = getelementptr inbounds i32, i32* %132, i64 3
%142 = load i32, i32* %138
%143 = getelementptr inbounds i32, i32* %133, i64 3
store i32 %142, i32* %140
%144 = getelementptr inbounds i32, i32* %132, i64 4
%145 = load i32, i32* %141
%146 = getelementptr inbounds i32, i32* %133, i64 4
store i32 %145, i32* %143
%147 = getelementptr inbounds i32, i32* %132, i64 5
%148 = load i32, i32* %144
%149 = getelementptr inbounds i32, i32* %133, i64 5
store i32 %148, i32* %146
%150 = getelementptr inbounds i32, i32* %132, i64 6
%151 = load i32, i32* %147
%152 = getelementptr inbounds i32, i32* %133, i64 6
store i32 %151, i32* %149
%153 = getelementptr inbounds i32, i32* %132, i64 7
%154 = load i32, i32* %150
%155 = getelementptr inbounds i32, i32* %133, i64 7
store i32 %154, i32* %152
%156 = add nsw i64 %134, -8
%157 = getelementptr inbounds i32, i32* %132, i64 8
%158 = load i32, i32* %153
%159 = getelementptr inbounds i32, i32* %133, i64 8
store i32 %158, i32* %155
%160 = icmp eq i64 %156, 0
br i1 %160, label %656, label %131
161: ; preds = %10
br i1 %13, label %656, label %162
162: ; preds = %161
%163 = bitcast i8* %1 to i32*
%164 = getelementptr inbounds i32, i32* %163, i64 %11
%165 = bitcast i8* %0 to i32*
%166 = getelementptr inbounds i32, i32* %165, i64 %11
%167 = icmp ult i64 %2, 32
br i1 %167, label %255, label %168
168: ; preds = %162
%169 = and i64 %2, -4
%170 = getelementptr i8, i8* %0, i64 %169
%171 = getelementptr i8, i8* %1, i64 %169
%172 = icmp ugt i8* %171, %0
%173 = icmp ugt i8* %170, %1
%174 = and i1 %172, %173
br i1 %174, label %255, label %175
175: ; preds = %168
%176 = and i64 %11, 4611686018427387896
%177 = sub nsw i64 0, %176
%178 = getelementptr i32, i32* %164, i64 %177
%179 = sub nsw i64 0, %176
%180 = getelementptr i32, i32* %166, i64 %179
%181 = and i64 %11, 7
%182 = add nsw i64 %176, -8
%183 = lshr exact i64 %182, 3
%184 = add nuw nsw i64 %183, 1
%185 = and i64 %184, 1
%186 = icmp eq i64 %182, 0
br i1 %186, label %231, label %187
187: ; preds = %175
%188 = and i64 %184, 4611686018427387902
%189 = getelementptr i32, i32* %164, i64 -1
%190 = getelementptr i32, i32* %166, i64 -1
%191 = getelementptr i32, i32* %164, i64 -1
%192 = getelementptr i32, i32* %166, i64 -1
br label %193
193: ; preds = %193, %187
%194 = phi i64 [ 0, %187 ], [ %228, %193 ]
%195 = phi i64 [ 0, %187 ], [ %229, %193 ]
%196 = sub i64 0, %194
%197 = sub i64 0, %194
%198 = getelementptr inbounds i32, i32* %189, i64 %196
%199 = getelementptr inbounds i32, i32* %198, i64 -3
%200 = bitcast i32* %199 to <4 x i32>*
%201 = load <4 x i32>, <4 x i32>* %200
%202 = getelementptr inbounds i32, i32* %198, i64 -4
%203 = getelementptr inbounds i32, i32* %202, i64 -3
%204 = bitcast i32* %203 to <4 x i32>*
%205 = load <4 x i32>, <4 x i32>* %204
%206 = getelementptr inbounds i32, i32* %190, i64 %197
%207 = getelementptr inbounds i32, i32* %206, i64 -3
%208 = bitcast i32* %207 to <4 x i32>*
store <4 x i32> %201, <4 x i32>* %208
%209 = getelementptr inbounds i32, i32* %206, i64 -4
%210 = getelementptr inbounds i32, i32* %209, i64 -3
%211 = bitcast i32* %210 to <4 x i32>*
store <4 x i32> %205, <4 x i32>* %211
%212 = sub nuw nsw i64 -8, %194
%213 = sub nuw nsw i64 -8, %194
%214 = getelementptr inbounds i32, i32* %191, i64 %212
%215 = getelementptr inbounds i32, i32* %214, i64 -3
%216 = bitcast i32* %215 to <4 x i32>*
%217 = load <4 x i32>, <4 x i32>* %216
%218 = getelementptr inbounds i32, i32* %214, i64 -4
%219 = getelementptr inbounds i32, i32* %218, i64 -3
%220 = bitcast i32* %219 to <4 x i32>*
%221 = load <4 x i32>, <4 x i32>* %220
%222 = getelementptr inbounds i32, i32* %192, i64 %213
%223 = getelementptr inbounds i32, i32* %222, i64 -3
%224 = bitcast i32* %223 to <4 x i32>*
store <4 x i32> %217, <4 x i32>* %224
%225 = getelementptr inbounds i32, i32* %222, i64 -4
%226 = getelementptr inbounds i32, i32* %225, i64 -3
%227 = bitcast i32* %226 to <4 x i32>*
store <4 x i32> %221, <4 x i32>* %227
%228 = add nuw i64 %194, 16
%229 = add i64 %195, 2
%230 = icmp eq i64 %229, %188
br i1 %230, label %231, label %193
231: ; preds = %193, %175
%232 = phi i64 [ 0, %175 ], [ %228, %193 ]
%233 = icmp eq i64 %185, 0
br i1 %233, label %253, label %234
234: ; preds = %231
%235 = sub i64 0, %232
%236 = getelementptr i32, i32* %164, i64 -1
%237 = sub i64 0, %232
%238 = getelementptr i32, i32* %166, i64 -1
%239 = getelementptr inbounds i32, i32* %236, i64 %235
%240 = getelementptr inbounds i32, i32* %239, i64 -3
%241 = bitcast i32* %240 to <4 x i32>*
%242 = load <4 x i32>, <4 x i32>* %241
%243 = getelementptr inbounds i32, i32* %239, i64 -4
%244 = getelementptr inbounds i32, i32* %243, i64 -3
%245 = bitcast i32* %244 to <4 x i32>*
%246 = load <4 x i32>, <4 x i32>* %245
%247 = getelementptr inbounds i32, i32* %238, i64 %237
%248 = getelementptr inbounds i32, i32* %247, i64 -3
%249 = bitcast i32* %248 to <4 x i32>*
store <4 x i32> %242, <4 x i32>* %249
%250 = getelementptr inbounds i32, i32* %247, i64 -4
%251 = getelementptr inbounds i32, i32* %250, i64 -3
%252 = bitcast i32* %251 to <4 x i32>*
store <4 x i32> %246, <4 x i32>* %252
br label %253
253: ; preds = %231, %234
%254 = icmp eq i64 %11, %176
br i1 %254, label %656, label %255
255: ; preds = %168, %162, %253
%256 = phi i32* [ %164, %168 ], [ %164, %162 ], [ %178, %253 ]
%257 = phi i32* [ %166, %168 ], [ %166, %162 ], [ %180, %253 ]
%258 = phi i64 [ %11, %168 ], [ %11, %162 ], [ %181, %253 ]
%259 = add nsw i64 %258, -1
%260 = and i64 %258, 7
%261 = icmp eq i64 %260, 0
br i1 %261, label %273, label %262
262: ; preds = %255, %262
%263 = phi i32* [ %268, %262 ], [ %256, %255 ]
%264 = phi i32* [ %270, %262 ], [ %257, %255 ]
%265 = phi i64 [ %267, %262 ], [ %258, %255 ]
%266 = phi i64 [ %271, %262 ], [ 0, %255 ]
%267 = add nsw i64 %265, -1
%268 = getelementptr inbounds i32, i32* %263, i64 -1
%269 = load i32, i32* %268
%270 = getelementptr inbounds i32, i32* %264, i64 -1
store i32 %269, i32* %270
%271 = add i64 %266, 1
%272 = icmp eq i64 %271, %260
br i1 %272, label %273, label %262
273: ; preds = %262, %255
%274 = phi i32* [ %256, %255 ], [ %268, %262 ]
%275 = phi i32* [ %257, %255 ], [ %270, %262 ]
%276 = phi i64 [ %258, %255 ], [ %267, %262 ]
%277 = icmp ult i64 %259, 7
br i1 %277, label %656, label %278
278: ; preds = %273, %278
%279 = phi i32* [ %304, %278 ], [ %274, %273 ]
%280 = phi i32* [ %306, %278 ], [ %275, %273 ]
%281 = phi i64 [ %303, %278 ], [ %276, %273 ]
%282 = getelementptr inbounds i32, i32* %279, i64 -1
%283 = load i32, i32* %282
%284 = getelementptr inbounds i32, i32* %280, i64 -1
store i32 %283, i32* %284
%285 = getelementptr inbounds i32, i32* %279, i64 -2
%286 = load i32, i32* %285
%287 = getelementptr inbounds i32, i32* %280, i64 -2
store i32 %286, i32* %287
%288 = getelementptr inbounds i32, i32* %279, i64 -3
%289 = load i32, i32* %288
%290 = getelementptr inbounds i32, i32* %280, i64 -3
store i32 %289, i32* %290
%291 = getelementptr inbounds i32, i32* %279, i64 -4
%292 = load i32, i32* %291
%293 = getelementptr inbounds i32, i32* %280, i64 -4
store i32 %292, i32* %293
%294 = getelementptr inbounds i32, i32* %279, i64 -5
%295 = load i32, i32* %294
%296 = getelementptr inbounds i32, i32* %280, i64 -5
store i32 %295, i32* %296
%297 = getelementptr inbounds i32, i32* %279, i64 -6
%298 = load i32, i32* %297
%299 = getelementptr inbounds i32, i32* %280, i64 -6
store i32 %298, i32* %299
%300 = getelementptr inbounds i32, i32* %279, i64 -7
%301 = load i32, i32* %300
%302 = getelementptr inbounds i32, i32* %280, i64 -7
store i32 %301, i32* %302
%303 = add nsw i64 %281, -8
%304 = getelementptr inbounds i32, i32* %279, i64 -8
%305 = load i32, i32* %304
%306 = getelementptr inbounds i32, i32* %280, i64 -8
store i32 %305, i32* %306
%307 = icmp eq i64 %303, 0
br i1 %307, label %656, label %278
308: ; preds = %3
%309 = icmp ult i8* %0, %1
%310 = icmp eq i64 %2, 0
br i1 %309, label %311, label %477
311: ; preds = %308
br i1 %310, label %656, label %312
312: ; preds = %311
%313 = icmp ult i64 %2, 8
br i1 %313, label %424, label %314
314: ; preds = %312
%315 = getelementptr i8, i8* %0, i64 %2
%316 = getelementptr i8, i8* %1, i64 %2
%317 = icmp ugt i8* %316, %0
%318 = icmp ugt i8* %315, %1
%319 = and i1 %317, %318
br i1 %319, label %424, label %320
320: ; preds = %314
%321 = icmp ult i64 %2, 32
br i1 %321, label %407, label %322
322: ; preds = %320
%323 = and i64 %2, -32
%324 = add i64 %323, -32
%325 = lshr exact i64 %324, 5
%326 = add nuw nsw i64 %325, 1
%327 = and i64 %326, 3
%328 = icmp ult i64 %324, 96
br i1 %328, label %380, label %329
329: ; preds = %322
%330 = and i64 %326, 1152921504606846972
br label %331
331: ; preds = %331, %329
%332 = phi i64 [ 0, %329 ], [ %377, %331 ]
%333 = phi i64 [ 0, %329 ], [ %378, %331 ]
%334 = getelementptr i8, i8* %1, i64 %332
%335 = getelementptr i8, i8* %0, i64 %332
%336 = bitcast i8* %334 to <16 x i8>*
%337 = load <16 x i8>, <16 x i8>* %336
%338 = getelementptr i8, i8* %334, i64 16
%339 = bitcast i8* %338 to <16 x i8>*
%340 = load <16 x i8>, <16 x i8>* %339
%341 = bitcast i8* %335 to <16 x i8>*
store <16 x i8> %337, <16 x i8>* %341
%342 = getelementptr i8, i8* %335, i64 16
%343 = bitcast i8* %342 to <16 x i8>*
store <16 x i8> %340, <16 x i8>* %343
%344 = or i64 %332, 32
%345 = getelementptr i8, i8* %1, i64 %344
%346 = getelementptr i8, i8* %0, i64 %344
%347 = bitcast i8* %345 to <16 x i8>*
%348 = load <16 x i8>, <16 x i8>* %347
%349 = getelementptr i8, i8* %345, i64 16
%350 = bitcast i8* %349 to <16 x i8>*
%351 = load <16 x i8>, <16 x i8>* %350
%352 = bitcast i8* %346 to <16 x i8>*
store <16 x i8> %348, <16 x i8>* %352
%353 = getelementptr i8, i8* %346, i64 16
%354 = bitcast i8* %353 to <16 x i8>*
store <16 x i8> %351, <16 x i8>* %354
%355 = or i64 %332, 64
%356 = getelementptr i8, i8* %1, i64 %355
%357 = getelementptr i8, i8* %0, i64 %355
%358 = bitcast i8* %356 to <16 x i8>*
%359 = load <16 x i8>, <16 x i8>* %358
%360 = getelementptr i8, i8* %356, i64 16
%361 = bitcast i8* %360 to <16 x i8>*
%362 = load <16 x i8>, <16 x i8>* %361
%363 = bitcast i8* %357 to <16 x i8>*
store <16 x i8> %359, <16 x i8>* %363
%364 = getelementptr i8, i8* %357, i64 16
%365 = bitcast i8* %364 to <16 x i8>*
store <16 x i8> %362, <16 x i8>* %365
%366 = or i64 %332, 96
%367 = getelementptr i8, i8* %1, i64 %366
%368 = getelementptr i8, i8* %0, i64 %366
%369 = bitcast i8* %367 to <16 x i8>*
%370 = load <16 x i8>, <16 x i8>* %369
%371 = getelementptr i8, i8* %367, i64 16
%372 = bitcast i8* %371 to <16 x i8>*
%373 = load <16 x i8>, <16 x i8>* %372
%374 = bitcast i8* %368 to <16 x i8>*
store <16 x i8> %370, <16 x i8>* %374
%375 = getelementptr i8, i8* %368, i64 16
%376 = bitcast i8* %375 to <16 x i8>*
store <16 x i8> %373, <16 x i8>* %376
%377 = add nuw i64 %332, 128
%378 = add i64 %333, 4
%379 = icmp eq i64 %378, %330
br i1 %379, label %380, label %331
380: ; preds = %331, %322
%381 = phi i64 [ 0, %322 ], [ %377, %331 ]
%382 = icmp eq i64 %327, 0
br i1 %382, label %399, label %383
383: ; preds = %380, %383
%384 = phi i64 [ %396, %383 ], [ %381, %380 ]
%385 = phi i64 [ %397, %383 ], [ 0, %380 ]
%386 = getelementptr i8, i8* %1, i64 %384
%387 = getelementptr i8, i8* %0, i64 %384
%388 = bitcast i8* %386 to <16 x i8>*
%389 = load <16 x i8>, <16 x i8>* %388
%390 = getelementptr i8, i8* %386, i64 16
%391 = bitcast i8* %390 to <16 x i8>*
%392 = load <16 x i8>, <16 x i8>* %391
%393 = bitcast i8* %387 to <16 x i8>*
store <16 x i8> %389, <16 x i8>* %393
%394 = getelementptr i8, i8* %387, i64 16
%395 = bitcast i8* %394 to <16 x i8>*
store <16 x i8> %392, <16 x i8>* %395
%396 = add nuw i64 %384, 32
%397 = add i64 %385, 1
%398 = icmp eq i64 %397, %327
br i1 %398, label %399, label %383
399: ; preds = %383, %380
%400 = icmp eq i64 %323, %2
br i1 %400, label %656, label %401
401: ; preds = %399
%402 = and i64 %2, 31
%403 = getelementptr i8, i8* %0, i64 %323
%404 = getelementptr i8, i8* %1, i64 %323
%405 = and i64 %2, 24
%406 = icmp eq i64 %405, 0
br i1 %406, label %424, label %407
407: ; preds = %320, %401
%408 = phi i64 [ %323, %401 ], [ 0, %320 ]
%409 = and i64 %2, -8
%410 = getelementptr i8, i8* %1, i64 %409
%411 = getelementptr i8, i8* %0, i64 %409
%412 = and i64 %2, 7
br label %413
413: ; preds = %413, %407
%414 = phi i64 [ %408, %407 ], [ %420, %413 ]
%415 = getelementptr i8, i8* %1, i64 %414
%416 = getelementptr i8, i8* %0, i64 %414
%417 = bitcast i8* %415 to <8 x i8>*
%418 = load <8 x i8>, <8 x i8>* %417
%419 = bitcast i8* %416 to <8 x i8>*
store <8 x i8> %418, <8 x i8>* %419
%420 = add nuw i64 %414, 8
%421 = icmp eq i64 %420, %409
br i1 %421, label %422, label %413
422: ; preds = %413
%423 = icmp eq i64 %409, %2
br i1 %423, label %656, label %424
424: ; preds = %314, %312, %401, %422
%425 = phi i8* [ %1, %312 ], [ %1, %314 ], [ %404, %401 ], [ %410, %422 ]
%426 = phi i8* [ %0, %312 ], [ %0, %314 ], [ %403, %401 ], [ %411, %422 ]
%427 = phi i64 [ %2, %312 ], [ %2, %314 ], [ %402, %401 ], [ %412, %422 ]
%428 = add i64 %427, -1
%429 = and i64 %427, 7
%430 = icmp eq i64 %429, 0
br i1 %430, label %442, label %431
431: ; preds = %424, %431
%432 = phi i8* [ %437, %431 ], [ %425, %424 ]
%433 = phi i8* [ %439, %431 ], [ %426, %424 ]
%434 = phi i64 [ %436, %431 ], [ %427, %424 ]
%435 = phi i64 [ %440, %431 ], [ 0, %424 ]
%436 = add i64 %434, -1
%437 = getelementptr inbounds i8, i8* %432, i64 1
%438 = load i8, i8* %432
%439 = getelementptr inbounds i8, i8* %433, i64 1
store i8 %438, i8* %433
%440 = add i64 %435, 1
%441 = icmp eq i64 %440, %429
br i1 %441, label %442, label %431
442: ; preds = %431, %424
%443 = phi i8* [ %425, %424 ], [ %437, %431 ]
%444 = phi i8* [ %426, %424 ], [ %439, %431 ]
%445 = phi i64 [ %427, %424 ], [ %436, %431 ]
%446 = icmp ult i64 %428, 7
br i1 %446, label %656, label %447
447: ; preds = %442, %447
%448 = phi i8* [ %473, %447 ], [ %443, %442 ]
%449 = phi i8* [ %475, %447 ], [ %444, %442 ]
%450 = phi i64 [ %472, %447 ], [ %445, %442 ]
%451 = getelementptr inbounds i8, i8* %448, i64 1
%452 = load i8, i8* %448
%453 = getelementptr inbounds i8, i8* %449, i64 1
store i8 %452, i8* %449
%454 = getelementptr inbounds i8, i8* %448, i64 2
%455 = load i8, i8* %451
%456 = getelementptr inbounds i8, i8* %449, i64 2
store i8 %455, i8* %453
%457 = getelementptr inbounds i8, i8* %448, i64 3
%458 = load i8, i8* %454
%459 = getelementptr inbounds i8, i8* %449, i64 3
store i8 %458, i8* %456
%460 = getelementptr inbounds i8, i8* %448, i64 4
%461 = load i8, i8* %457
%462 = getelementptr inbounds i8, i8* %449, i64 4
store i8 %461, i8* %459
%463 = getelementptr inbounds i8, i8* %448, i64 5
%464 = load i8, i8* %460
%465 = getelementptr inbounds i8, i8* %449, i64 5
store i8 %464, i8* %462
%466 = getelementptr inbounds i8, i8* %448, i64 6
%467 = load i8, i8* %463
%468 = getelementptr inbounds i8, i8* %449, i64 6
store i8 %467, i8* %465
%469 = getelementptr inbounds i8, i8* %448, i64 7
%470 = load i8, i8* %466
%471 = getelementptr inbounds i8, i8* %449, i64 7
store i8 %470, i8* %468
%472 = add i64 %450, -8
%473 = getelementptr inbounds i8, i8* %448, i64 8
%474 = load i8, i8* %469
%475 = getelementptr inbounds i8, i8* %449, i64 8
store i8 %474, i8* %471
%476 = icmp eq i64 %472, 0
br i1 %476, label %656, label %447
477: ; preds = %308
br i1 %310, label %656, label %478
478: ; preds = %477
%479 = getelementptr i8, i8* %1, i64 %2
%480 = getelementptr i8, i8* %0, i64 %2
%481 = icmp ult i64 %2, 4
br i1 %481, label %603, label %482
482: ; preds = %478
%483 = icmp ugt i8* %479, %0
%484 = icmp ugt i8* %480, %1
%485 = and i1 %483, %484
br i1 %485, label %603, label %486
486: ; preds = %482
%487 = icmp ult i64 %2, 16
br i1 %487, label %578, label %488
488: ; preds = %486
%489 = and i64 %2, -16
%490 = add i64 %489, -16
%491 = lshr exact i64 %490, 4
%492 = add nuw nsw i64 %491, 1
%493 = and i64 %492, 3
%494 = icmp ult i64 %490, 48
br i1 %494, label %547, label %495
495: ; preds = %488
%496 = and i64 %492, 2305843009213693948
%497 = getelementptr i8, i8* %479, i64 -1
%498 = getelementptr i8, i8* %480, i64 -1
%499 = getelementptr inbounds i8, i8* %497, i64 -15
%500 = getelementptr inbounds i8, i8* %498, i64 -15
%501 = getelementptr i8, i8* %479, i64 -1
%502 = getelementptr i8, i8* %480, i64 -1
%503 = getelementptr inbounds i8, i8* %501, i64 -15
%504 = getelementptr inbounds i8, i8* %502, i64 -15
%505 = getelementptr i8, i8* %479, i64 -1
%506 = getelementptr i8, i8* %480, i64 -1
%507 = getelementptr inbounds i8, i8* %505, i64 -15
%508 = getelementptr inbounds i8, i8* %506, i64 -15
%509 = getelementptr i8, i8* %479, i64 -1
%510 = getelementptr i8, i8* %480, i64 -1
%511 = getelementptr inbounds i8, i8* %509, i64 -15
%512 = getelementptr inbounds i8, i8* %510, i64 -15
br label %513
513: ; preds = %513, %495
%514 = phi i64 [ 0, %495 ], [ %544, %513 ]
%515 = phi i64 [ 0, %495 ], [ %545, %513 ]
%516 = sub i64 0, %514
%517 = sub i64 0, %514
%518 = getelementptr inbounds i8, i8* %499, i64 %516
%519 = bitcast i8* %518 to <16 x i8>*
%520 = load <16 x i8>, <16 x i8>* %519
%521 = getelementptr inbounds i8, i8* %500, i64 %517
%522 = bitcast i8* %521 to <16 x i8>*
store <16 x i8> %520, <16 x i8>* %522
%523 = sub nuw nsw i64 -16, %514
%524 = sub nuw nsw i64 -16, %514
%525 = getelementptr inbounds i8, i8* %503, i64 %523
%526 = bitcast i8* %525 to <16 x i8>*
%527 = load <16 x i8>, <16 x i8>* %526
%528 = getelementptr inbounds i8, i8* %504, i64 %524
%529 = bitcast i8* %528 to <16 x i8>*
store <16 x i8> %527, <16 x i8>* %529
%530 = sub nuw nsw i64 -32, %514
%531 = sub nuw nsw i64 -32, %514
%532 = getelementptr inbounds i8, i8* %507, i64 %530
%533 = bitcast i8* %532 to <16 x i8>*
%534 = load <16 x i8>, <16 x i8>* %533
%535 = getelementptr inbounds i8, i8* %508, i64 %531
%536 = bitcast i8* %535 to <16 x i8>*
store <16 x i8> %534, <16 x i8>* %536
%537 = sub nuw nsw i64 -48, %514
%538 = sub nuw nsw i64 -48, %514
%539 = getelementptr inbounds i8, i8* %511, i64 %537
%540 = bitcast i8* %539 to <16 x i8>*
%541 = load <16 x i8>, <16 x i8>* %540
%542 = getelementptr inbounds i8, i8* %512, i64 %538
%543 = bitcast i8* %542 to <16 x i8>*
store <16 x i8> %541, <16 x i8>* %543
%544 = add nuw i64 %514, 64
%545 = add i64 %515, 4
%546 = icmp eq i64 %545, %496
br i1 %546, label %547, label %513
547: ; preds = %513, %488
%548 = phi i64 [ 0, %488 ], [ %544, %513 ]
%549 = icmp eq i64 %493, 0
br i1 %549, label %568, label %550
550: ; preds = %547
%551 = getelementptr i8, i8* %479, i64 -1
%552 = getelementptr i8, i8* %480, i64 -1
%553 = getelementptr inbounds i8, i8* %551, i64 -15
%554 = getelementptr inbounds i8, i8* %552, i64 -15
br label %555
555: ; preds = %555, %550
%556 = phi i64 [ %548, %550 ], [ %565, %555 ]
%557 = phi i64 [ 0, %550 ], [ %566, %555 ]
%558 = sub i64 0, %556
%559 = sub i64 0, %556
%560 = getelementptr inbounds i8, i8* %553, i64 %558
%561 = bitcast i8* %560 to <16 x i8>*
%562 = load <16 x i8>, <16 x i8>* %561
%563 = getelementptr inbounds i8, i8* %554, i64 %559
%564 = bitcast i8* %563 to <16 x i8>*
store <16 x i8> %562, <16 x i8>* %564
%565 = add nuw i64 %556, 16
%566 = add i64 %557, 1
%567 = icmp eq i64 %566, %493
br i1 %567, label %568, label %555
568: ; preds = %555, %547
%569 = icmp eq i64 %489, %2
br i1 %569, label %656, label %570
570: ; preds = %568
%571 = and i64 %2, 15
%572 = sub i64 0, %489
%573 = getelementptr i8, i8* %480, i64 %572
%574 = sub i64 0, %489
%575 = getelementptr i8, i8* %479, i64 %574
%576 = and i64 %2, 12
%577 = icmp eq i64 %576, 0
br i1 %577, label %603, label %578
578: ; preds = %486, %570
%579 = phi i64 [ %489, %570 ], [ 0, %486 ]
%580 = and i64 %2, -4
%581 = sub i64 0, %580
%582 = getelementptr i8, i8* %479, i64 %581
%583 = sub i64 0, %580
%584 = getelementptr i8, i8* %480, i64 %583
%585 = and i64 %2, 3
%586 = getelementptr i8, i8* %479, i64 -1
%587 = getelementptr i8, i8* %480, i64 -1
%588 = getelementptr inbounds i8, i8* %586, i64 -3
%589 = getelementptr inbounds i8, i8* %587, i64 -3
br label %590
590: ; preds = %590, %578
%591 = phi i64 [ %579, %578 ], [ %599, %590 ]
%592 = sub i64 0, %591
%593 = sub i64 0, %591
%594 = getelementptr inbounds i8, i8* %588, i64 %592
%595 = bitcast i8* %594 to <4 x i8>*
%596 = load <4 x i8>, <4 x i8>* %595
%597 = getelementptr inbounds i8, i8* %589, i64 %593
%598 = bitcast i8* %597 to <4 x i8>*
store <4 x i8> %596, <4 x i8>* %598
%599 = add nuw i64 %591, 4
%600 = icmp eq i64 %599, %580
br i1 %600, label %601, label %590
601: ; preds = %590
%602 = icmp eq i64 %580, %2
br i1 %602, label %656, label %603
603: ; preds = %482, %478, %570, %601
%604 = phi i8* [ %479, %478 ], [ %479, %482 ], [ %575, %570 ], [ %582, %601 ]
%605 = phi i8* [ %480, %478 ], [ %480, %482 ], [ %573, %570 ], [ %584, %601 ]
%606 = phi i64 [ %2, %478 ], [ %2, %482 ], [ %571, %570 ], [ %585, %601 ]
%607 = add i64 %606, -1
%608 = and i64 %606, 7
%609 = icmp eq i64 %608, 0
br i1 %609, label %621, label %610
610: ; preds = %603, %610
%611 = phi i8* [ %616, %610 ], [ %604, %603 ]
%612 = phi i8* [ %618, %610 ], [ %605, %603 ]
%613 = phi i64 [ %615, %610 ], [ %606, %603 ]
%614 = phi i64 [ %619, %610 ], [ 0, %603 ]
%615 = add i64 %613, -1
%616 = getelementptr inbounds i8, i8* %611, i64 -1
%617 = load i8, i8* %616
%618 = getelementptr inbounds i8, i8* %612, i64 -1
store i8 %617, i8* %618
%619 = add i64 %614, 1
%620 = icmp eq i64 %619, %608
br i1 %620, label %621, label %610
621: ; preds = %610, %603
%622 = phi i8* [ %604, %603 ], [ %616, %610 ]
%623 = phi i8* [ %605, %603 ], [ %618, %610 ]
%624 = phi i64 [ %606, %603 ], [ %615, %610 ]
%625 = icmp ult i64 %607, 7
br i1 %625, label %656, label %626
626: ; preds = %621, %626
%627 = phi i8* [ %652, %626 ], [ %622, %621 ]
%628 = phi i8* [ %654, %626 ], [ %623, %621 ]
%629 = phi i64 [ %651, %626 ], [ %624, %621 ]
%630 = getelementptr inbounds i8, i8* %627, i64 -1
%631 = load i8, i8* %630
%632 = getelementptr inbounds i8, i8* %628, i64 -1
store i8 %631, i8* %632
%633 = getelementptr inbounds i8, i8* %627, i64 -2
%634 = load i8, i8* %633
%635 = getelementptr inbounds i8, i8* %628, i64 -2
store i8 %634, i8* %635
%636 = getelementptr inbounds i8, i8* %627, i64 -3
%637 = load i8, i8* %636
%638 = getelementptr inbounds i8, i8* %628, i64 -3
store i8 %637, i8* %638
%639 = getelementptr inbounds i8, i8* %627, i64 -4
%640 = load i8, i8* %639
%641 = getelementptr inbounds i8, i8* %628, i64 -4
store i8 %640, i8* %641
%642 = getelementptr inbounds i8, i8* %627, i64 -5
%643 = load i8, i8* %642
%644 = getelementptr inbounds i8, i8* %628, i64 -5
store i8 %643, i8* %644
%645 = getelementptr inbounds i8, i8* %627, i64 -6
%646 = load i8, i8* %645
%647 = getelementptr inbounds i8, i8* %628, i64 -6
store i8 %646, i8* %647
%648 = getelementptr inbounds i8, i8* %627, i64 -7
%649 = load i8, i8* %648
%650 = getelementptr inbounds i8, i8* %628, i64 -7
store i8 %649, i8* %650
%651 = add i64 %629, -8
%652 = getelementptr inbounds i8, i8* %627, i64 -8
%653 = load i8, i8* %652
%654 = getelementptr inbounds i8, i8* %628, i64 -8
store i8 %653, i8* %654
%655 = icmp eq i64 %651, 0
br i1 %655, label %656, label %626
656: ; preds = %621, %626, %442, %447, %273, %278, %126, %131, %568, %601, %399, %422, %253, %106, %477, %311, %161, %14
ret i8* %0
}