void *memcpy(void *to, const void *from, unsigned int n) {
  void *xto = to;
  unsigned int temp;
  if (!n)
    return xto;
  if ((long)to & 1) {
    char *cto = to;
    const char *cfrom = from;
    *cto++ = *cfrom++;
    to = cto;
    from = cfrom;
    n--;
  }
  if ((long)from & 1) {
    char *cto = to;
    const char *cfrom = from;
    for (; n; n--)
      *cto++ = *cfrom++;
    return xto;
  }
  if (n > 2 && (long)to & 2) {
    short *sto = to;
    const short *sfrom = from;
    *sto++ = *sfrom++;
    to = sto;
    from = sfrom;
    n -= 2;
  }
  if ((long)from & 2) {
    short *sto = to;
    const short *sfrom = from;
    temp = n >> 1;
    for (; temp; temp--)
      *sto++ = *sfrom++;
    to = sto;
    from = sfrom;
    if (n & 1) {
      char *cto = to;
      const char *cfrom = from;
      *cto = *cfrom;
    }
    return xto;
  }
  temp = n >> 2;
  if (temp) {
    long *lto = to;
    const long *lfrom = from;
    for (; temp; temp--)
      *lto++ = *lfrom++;
    to = lto;
    from = lfrom;
  }
  if (n & 2) {
    short *sto = to;
    const short *sfrom = from;
    *sto++ = *sfrom++;
    to = sto;
    from = sfrom;
  }
  if (n & 1) {
    char *cto = to;
    const char *cfrom = from;
    *cto = *cfrom;
  }
  return xto;
}


x86 assembly (clang, -O0):
<memcpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    1132 <memcpy+0x32>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1441 <memcpy+0x341>
mov    -0x10(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     118f <memcpy+0x8f>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11f8 <memcpy+0xf8>
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     11eb <memcpy+0xeb>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b1 <memcpy+0xb1>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1441 <memcpy+0x341>
cmpl   $0x2,-0x1c(%rbp)
jbe    1261 <memcpy+0x161>
mov    -0x10(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     1261 <memcpy+0x161>
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cx
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cx,(%rax)
mov    -0x58(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     1310 <memcpy+0x210>
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     12c8 <memcpy+0x1c8>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x70(%rbp)
mov    (%rax),%cx
mov    -0x68(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x68(%rbp)
mov    %cx,(%rax)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    128c <memcpy+0x18c>
mov    -0x68(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1303 <memcpy+0x203>
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1441 <memcpy+0x341>
mov    -0x1c(%rbp),%eax
shr    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1397 <memcpy+0x297>
mov    -0x10(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1381 <memcpy+0x281>
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
mov    (%rax),%rcx
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x88(%rbp)
mov    %rcx,(%rax)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1339 <memcpy+0x239>
mov    -0x88(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1402 <memcpy+0x302>
mov    -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0xa0(%rbp)
mov    (%rax),%cx
mov    -0x98(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x98(%rbp)
mov    %cx,(%rax)
mov    -0x98(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1439 <memcpy+0x339>
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    (%rax),%cl
mov    -0xa8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rax
test   %edx,%edx
je     1773 <memcpy+0x673>
test   $0x1,%al
jne    11fb <memcpy+0xfb>
mov    %rax,%r10
test   $0x1,%sil
je     1214 <memcpy+0x114>
test   %edx,%edx
je     1773 <memcpy+0x673>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     1159 <memcpy+0x59>
lea    (%rsi,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r10
jae    132b <memcpy+0x22b>
lea    (%r10,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rsi
jae    132b <memcpy+0x22b>
mov    %r10,%r14
mov    %rsi,%rdi
lea    -0x1(%rdx),%r8d
test   $0x7,%dl
je     1188 <memcpy+0x88>
mov    %edx,%esi
and    $0x7,%esi
xor    %ebx,%ebx
nop
movzbl (%rdi,%rbx,1),%ecx
mov    %cl,(%r14,%rbx,1)
add    $0x1,%rbx
cmp    %ebx,%esi
jne    1170 <memcpy+0x70>
sub    %ebx,%edx
add    %rbx,%r14
add    %rbx,%rdi
cmp    $0x7,%r8d
jb     1773 <memcpy+0x673>
mov    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%ecx
mov    %cl,(%r14,%rsi,1)
movzbl 0x1(%rdi,%rsi,1),%ecx
mov    %cl,0x1(%r14,%rsi,1)
movzbl 0x2(%rdi,%rsi,1),%ecx
mov    %cl,0x2(%r14,%rsi,1)
movzbl 0x3(%rdi,%rsi,1),%ecx
mov    %cl,0x3(%r14,%rsi,1)
movzbl 0x4(%rdi,%rsi,1),%ecx
mov    %cl,0x4(%r14,%rsi,1)
movzbl 0x5(%rdi,%rsi,1),%ecx
mov    %cl,0x5(%r14,%rsi,1)
movzbl 0x6(%rdi,%rsi,1),%ecx
mov    %cl,0x6(%r14,%rsi,1)
movzbl 0x7(%rdi,%rsi,1),%ecx
mov    %cl,0x7(%r14,%rsi,1)
add    $0x8,%rsi
cmp    %esi,%edx
jne    11a0 <memcpy+0xa0>
jmp    1773 <memcpy+0x673>
mov    (%rsi),%cl
add    $0x1,%rsi
lea    0x1(%rax),%r10
mov    %cl,(%rax)
add    $0xffffffff,%edx
test   $0x1,%sil
jne    1125 <memcpy+0x25>
cmp    $0x3,%edx
jb     1236 <memcpy+0x136>
mov    %r10d,%ecx
and    $0x2,%ecx
test   %rcx,%rcx
je     1236 <memcpy+0x136>
movzwl (%rsi),%ecx
add    $0x2,%rsi
mov    %cx,(%r10)
add    $0x2,%r10
add    $0xfffffffe,%edx
test   $0x2,%sil
jne    12b4 <memcpy+0x1b4>
cmp    $0x4,%edx
jb     15e1 <memcpy+0x4e1>
mov    %edx,%r11d
shr    $0x2,%r11d
lea    -0x1(%r11),%r9d
cmp    $0x3,%r9d
jb     152f <memcpy+0x42f>
lea    (%rsi,%r9,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r10
jae    1278 <memcpy+0x178>
lea    (%r10,%r9,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%rsi
jb     152f <memcpy+0x42f>
add    $0x1,%r9
movabs $0x1ffffffe0,%r8
or     $0x1c,%r8
and    %r9,%r8
lea    -0x4(%r8),%rdi
mov    %rdi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r14d
and    $0x3,%r14d
cmp    $0xc,%rdi
jae    146f <memcpy+0x36f>
xor    %edi,%edi
jmp    14e0 <memcpy+0x3e0>
cmp    $0x2,%edx
jb     1769 <memcpy+0x669>
mov    %edx,%r11d
shr    %r11d
lea    -0x1(%r11),%r9d
cmp    $0xf,%r9d
jb     16bf <memcpy+0x5bf>
lea    (%rsi,%r9,2),%rcx
add    $0x2,%rcx
cmp    %rcx,%r10
jae    12ef <memcpy+0x1ef>
lea    (%r10,%r9,2),%rcx
add    $0x2,%rcx
cmp    %rcx,%rsi
jb     16bf <memcpy+0x5bf>
add    $0x1,%r9
movabs $0x1ffffffe0,%r8
or     $0x10,%r8
and    %r9,%r8
lea    -0x10(%r8),%rdi
mov    %rdi,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %ecx,%r14d
and    $0x3,%r14d
cmp    $0x30,%rdi
jae    15fe <memcpy+0x4fe>
xor    %edi,%edi
jmp    1670 <memcpy+0x570>
movabs $0x1ffffffe0,%r9
cmp    $0x1f,%r8d
jae    1343 <memcpy+0x243>
xor    %r11d,%r11d
jmp    142e <memcpy+0x32e>
lea    0x1(%r8),%r14
mov    %r14,%r11
and    %r9,%r11
lea    -0x20(%r11),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x60,%rcx
jae    136d <memcpy+0x26d>
xor    %ecx,%ecx
jmp    13e0 <memcpy+0x2e0>
and    $0xfffffffffffffffc,%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%r10,%rcx,1)
movups %xmm1,0x10(%r10,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%r10,%rcx,1)
movups %xmm1,0x30(%r10,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%r10,%rcx,1)
movups %xmm1,0x50(%r10,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%r10,%rcx,1)
movups %xmm1,0x70(%r10,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1380 <memcpy+0x280>
test   %r15,%r15
je     141b <memcpy+0x31b>
lea    (%rsi,%rcx,1),%rbx
add    $0x10,%rbx
add    %r10,%rcx
add    $0x10,%rcx
shl    $0x5,%r15
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rdi,1),%xmm0
movups (%rbx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r15
jne    1400 <memcpy+0x300>
cmp    %r11,%r14
je     1773 <memcpy+0x673>
test   $0x18,%r14b
je     1779 <memcpy+0x679>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
sub    %r9d,%edx
lea    (%r10,%r9,1),%r14
lea    (%rsi,%r9,1),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%r11,1),%rbx
mov    %rbx,(%r10,%r11,1)
add    $0x8,%r11
cmp    %r11,%r9
jne    1450 <memcpy+0x350>
cmp    %r9,%r8
jne    115f <memcpy+0x5f>
jmp    1773 <memcpy+0x673>
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
movups %xmm0,(%r10,%rdi,8)
movups %xmm1,0x10(%r10,%rdi,8)
movups 0x20(%rsi,%rdi,8),%xmm0
movups 0x30(%rsi,%rdi,8),%xmm1
movups %xmm0,0x20(%r10,%rdi,8)
movups %xmm1,0x30(%r10,%rdi,8)
movups 0x40(%rsi,%rdi,8),%xmm0
movups 0x50(%rsi,%rdi,8),%xmm1
movups %xmm0,0x40(%r10,%rdi,8)
movups %xmm1,0x50(%r10,%rdi,8)
movups 0x60(%rsi,%rdi,8),%xmm0
movups 0x70(%rsi,%rdi,8),%xmm1
movups %xmm0,0x60(%r10,%rdi,8)
movups %xmm1,0x70(%r10,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1480 <memcpy+0x380>
test   %r14,%r14
je     151b <memcpy+0x41b>
lea    (%r10,%rdi,8),%rcx
add    $0x10,%rcx
lea    (%rsi,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    1500 <memcpy+0x400>
lea    (%rsi,%r8,8),%rsi
lea    (%r10,%r8,8),%r10
cmp    %r8,%r9
je     15e1 <memcpy+0x4e1>
sub    %r8d,%r11d
lea    -0x1(%r11),%r8d
test   $0x7,%r11b
je     1569 <memcpy+0x469>
mov    %r11d,%ebx
and    $0x7,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%rcx
add    $0x8,%rsi
mov    %rcx,(%r10)
add    $0x8,%r10
add    $0x1,%rdi
cmp    %edi,%ebx
jne    1550 <memcpy+0x450>
sub    %edi,%r11d
cmp    $0x7,%r8d
jb     15e1 <memcpy+0x4e1>
mov    %r11d,%r8d
xor    %ebx,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rbx,8),%rcx
mov    %rcx,(%r10,%rbx,8)
mov    0x8(%rsi,%rbx,8),%rcx
mov    %rcx,0x8(%r10,%rbx,8)
mov    0x10(%rsi,%rbx,8),%rcx
mov    %rcx,0x10(%r10,%rbx,8)
mov    0x18(%rsi,%rbx,8),%rcx
mov    %rcx,0x18(%r10,%rbx,8)
mov    0x20(%rsi,%rbx,8),%rcx
mov    %rcx,0x20(%r10,%rbx,8)
mov    0x28(%rsi,%rbx,8),%rcx
mov    %rcx,0x28(%r10,%rbx,8)
mov    0x30(%rsi,%rbx,8),%rcx
mov    %rcx,0x30(%r10,%rbx,8)
mov    0x38(%rsi,%rbx,8),%rcx
mov    %rcx,0x38(%r10,%rbx,8)
add    $0xffffffffffffffc0,%rdi
add    $0x8,%rbx
cmp    %ebx,%r8d
jne    1580 <memcpy+0x480>
sub    %rdi,%rsi
sub    %rdi,%r10
test   $0x2,%dl
je     1769 <memcpy+0x669>
movzwl (%rsi),%ecx
add    $0x2,%rsi
mov    %cx,(%r10)
add    $0x2,%r10
jmp    1769 <memcpy+0x669>
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rsi,%rdi,2),%xmm0
movups 0x10(%rsi,%rdi,2),%xmm1
movups %xmm0,(%r10,%rdi,2)
movups %xmm1,0x10(%r10,%rdi,2)
movups 0x20(%rsi,%rdi,2),%xmm0
movups 0x30(%rsi,%rdi,2),%xmm1
movups %xmm0,0x20(%r10,%rdi,2)
movups %xmm1,0x30(%r10,%rdi,2)
movups 0x40(%rsi,%rdi,2),%xmm0
movups 0x50(%rsi,%rdi,2),%xmm1
movups %xmm0,0x40(%r10,%rdi,2)
movups %xmm1,0x50(%r10,%rdi,2)
movups 0x60(%rsi,%rdi,2),%xmm0
movups 0x70(%rsi,%rdi,2),%xmm1
movups %xmm0,0x60(%r10,%rdi,2)
movups %xmm1,0x70(%r10,%rdi,2)
add    $0x40,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1610 <memcpy+0x510>
test   %r14,%r14
je     16ab <memcpy+0x5ab>
lea    (%r10,%rdi,2),%rcx
add    $0x10,%rcx
lea    (%rsi,%rdi,2),%rdi
add    $0x10,%rdi
shl    $0x5,%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    1690 <memcpy+0x590>
lea    (%rsi,%r8,2),%rsi
lea    (%r10,%r8,2),%r10
cmp    %r8,%r9
je     1769 <memcpy+0x669>
sub    %r8d,%r11d
lea    -0x1(%r11),%r8d
mov    %r11d,%edi
and    $0x7,%edi
je     16e9 <memcpy+0x5e9>
xor    %ebx,%ebx
nopl   (%rax)
movzwl (%rsi),%ecx
add    $0x2,%rsi
mov    %cx,(%r10)
add    $0x2,%r10
add    $0x1,%ebx
cmp    %ebx,%edi
jne    16d0 <memcpy+0x5d0>
sub    %ebx,%r11d
cmp    $0x7,%r8d
jb     1769 <memcpy+0x669>
mov    %r11d,%r8d
xor    %ecx,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movzwl (%rsi,%rbx,2),%edi
mov    %di,(%r10,%rbx,2)
movzwl 0x2(%rsi,%rbx,2),%edi
mov    %di,0x2(%r10,%rbx,2)
movzwl 0x4(%rsi,%rbx,2),%edi
mov    %di,0x4(%r10,%rbx,2)
movzwl 0x6(%rsi,%rbx,2),%edi
mov    %di,0x6(%r10,%rbx,2)
movzwl 0x8(%rsi,%rbx,2),%edi
mov    %di,0x8(%r10,%rbx,2)
movzwl 0xa(%rsi,%rbx,2),%edi
mov    %di,0xa(%r10,%rbx,2)
movzwl 0xc(%rsi,%rbx,2),%edi
mov    %di,0xc(%r10,%rbx,2)
movzwl 0xe(%rsi,%rbx,2),%edi
mov    %di,0xe(%r10,%rbx,2)
add    $0x8,%rbx
add    $0xfffffffffffffff0,%rcx
cmp    %ebx,%r8d
jne    1700 <memcpy+0x600>
sub    %rcx,%rsi
sub    %rcx,%r10
test   $0x1,%dl
je     1773 <memcpy+0x673>
mov    (%rsi),%cl
mov    %cl,(%r10)
pop    %rbx
pop    %r14
pop    %r15
ret
add    %r11,%rsi
add    %r11,%r10
sub    %r11d,%edx
jmp    1159 <memcpy+0x59>

LLVM IR (-O0):
define i8* @memcpy(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i16*
%15 = alloca i16*
%16 = alloca i16*
%17 = alloca i16*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i64*
%21 = alloca i64*
%22 = alloca i16*
%23 = alloca i16*
%24 = alloca i8*
%25 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
%26 = load i8*, i8** %5
store i8* %26, i8** %8
%27 = load i32, i32* %7
%28 = icmp ne i32 %27, 0
br i1 %28, label %31, label %29
29: ; preds = %3
%30 = load i8*, i8** %8
store i8* %30, i8** %4
br label %191
31: ; preds = %3
%32 = load i8*, i8** %5
%33 = ptrtoint i8* %32 to i64
%34 = and i64 %33, 1
%35 = icmp ne i64 %34, 0
br i1 %35, label %36, label %48
36: ; preds = %31
%37 = load i8*, i8** %5
store i8* %37, i8** %10
%38 = load i8*, i8** %6
store i8* %38, i8** %11
%39 = load i8*, i8** %11
%40 = getelementptr inbounds i8, i8* %39, i32 1
store i8* %40, i8** %11
%41 = load i8, i8* %39
%42 = load i8*, i8** %10
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %10
store i8 %41, i8* %42
%44 = load i8*, i8** %10
store i8* %44, i8** %5
%45 = load i8*, i8** %11
store i8* %45, i8** %6
%46 = load i32, i32* %7
%47 = add i32 %46, -1
store i32 %47, i32* %7
br label %48
48: ; preds = %36, %31
%49 = load i8*, i8** %6
%50 = ptrtoint i8* %49 to i64
%51 = and i64 %50, 1
%52 = icmp ne i64 %51, 0
br i1 %52, label %53, label %70
53: ; preds = %48
%54 = load i8*, i8** %5
store i8* %54, i8** %12
%55 = load i8*, i8** %6
store i8* %55, i8** %13
br label %56
56: ; preds = %65, %53
%57 = load i32, i32* %7
%58 = icmp ne i32 %57, 0
br i1 %58, label %59, label %68
59: ; preds = %56
%60 = load i8*, i8** %13
%61 = getelementptr inbounds i8, i8* %60, i32 1
store i8* %61, i8** %13
%62 = load i8, i8* %60
%63 = load i8*, i8** %12
%64 = getelementptr inbounds i8, i8* %63, i32 1
store i8* %64, i8** %12
store i8 %62, i8* %63
br label %65
65: ; preds = %59
%66 = load i32, i32* %7
%67 = add i32 %66, -1
store i32 %67, i32* %7
br label %56
68: ; preds = %56
%69 = load i8*, i8** %8
store i8* %69, i8** %4
br label %191
70: ; preds = %48
%71 = load i32, i32* %7
%72 = icmp ugt i32 %71, 2
br i1 %72, label %73, label %94
73: ; preds = %70
%74 = load i8*, i8** %5
%75 = ptrtoint i8* %74 to i64
%76 = and i64 %75, 2
%77 = icmp ne i64 %76, 0
br i1 %77, label %78, label %94
78: ; preds = %73
%79 = load i8*, i8** %5
%80 = bitcast i8* %79 to i16*
store i16* %80, i16** %14
%81 = load i8*, i8** %6
%82 = bitcast i8* %81 to i16*
store i16* %82, i16** %15
%83 = load i16*, i16** %15
%84 = getelementptr inbounds i16, i16* %83, i32 1
store i16* %84, i16** %15
%85 = load i16, i16* %83
%86 = load i16*, i16** %14
%87 = getelementptr inbounds i16, i16* %86, i32 1
store i16* %87, i16** %14
store i16 %85, i16* %86
%88 = load i16*, i16** %14
%89 = bitcast i16* %88 to i8*
store i8* %89, i8** %5
%90 = load i16*, i16** %15
%91 = bitcast i16* %90 to i8*
store i8* %91, i8** %6
%92 = load i32, i32* %7
%93 = sub i32 %92, 2
store i32 %93, i32* %7
br label %94
94: ; preds = %78, %73, %70
%95 = load i8*, i8** %6
%96 = ptrtoint i8* %95 to i64
%97 = and i64 %96, 2
%98 = icmp ne i64 %97, 0
br i1 %98, label %99, label %134
99: ; preds = %94
%100 = load i8*, i8** %5
%101 = bitcast i8* %100 to i16*
store i16* %101, i16** %16
%102 = load i8*, i8** %6
%103 = bitcast i8* %102 to i16*
store i16* %103, i16** %17
%104 = load i32, i32* %7
%105 = lshr i32 %104, 1
store i32 %105, i32* %9
br label %106
106: ; preds = %115, %99
%107 = load i32, i32* %9
%108 = icmp ne i32 %107, 0
br i1 %108, label %109, label %118
109: ; preds = %106
%110 = load i16*, i16** %17
%111 = getelementptr inbounds i16, i16* %110, i32 1
store i16* %111, i16** %17
%112 = load i16, i16* %110
%113 = load i16*, i16** %16
%114 = getelementptr inbounds i16, i16* %113, i32 1
store i16* %114, i16** %16
store i16 %112, i16* %113
br label %115
115: ; preds = %109
%116 = load i32, i32* %9
%117 = add i32 %116, -1
store i32 %117, i32* %9
br label %106
118: ; preds = %106
%119 = load i16*, i16** %16
%120 = bitcast i16* %119 to i8*
store i8* %120, i8** %5
%121 = load i16*, i16** %17
%122 = bitcast i16* %121 to i8*
store i8* %122, i8** %6
%123 = load i32, i32* %7
%124 = and i32 %123, 1
%125 = icmp ne i32 %124, 0
br i1 %125, label %126, label %132
126: ; preds = %118
%127 = load i8*, i8** %5
store i8* %127, i8** %18
%128 = load i8*, i8** %6
store i8* %128, i8** %19
%129 = load i8*, i8** %19
%130 = load i8, i8* %129
%131 = load i8*, i8** %18
store i8 %130, i8* %131
br label %132
132: ; preds = %126, %118
%133 = load i8*, i8** %8
store i8* %133, i8** %4
br label %191
134: ; preds = %94
%135 = load i32, i32* %7
%136 = lshr i32 %135, 2
store i32 %136, i32* %9
%137 = load i32, i32* %9
%138 = icmp ne i32 %137, 0
br i1 %138, label %139, label %161
139: ; preds = %134
%140 = load i8*, i8** %5
%141 = bitcast i8* %140 to i64*
store i64* %141, i64** %20
%142 = load i8*, i8** %6
%143 = bitcast i8* %142 to i64*
store i64* %143, i64** %21
br label %144
144: ; preds = %153, %139
%145 = load i32, i32* %9
%146 = icmp ne i32 %145, 0
br i1 %146, label %147, label %156
147: ; preds = %144
%148 = load i64*, i64** %21
%149 = getelementptr inbounds i64, i64* %148, i32 1
store i64* %149, i64** %21
%150 = load i64, i64* %148
%151 = load i64*, i64** %20
%152 = getelementptr inbounds i64, i64* %151, i32 1
store i64* %152, i64** %20
store i64 %150, i64* %151
br label %153
153: ; preds = %147
%154 = load i32, i32* %9
%155 = add i32 %154, -1
store i32 %155, i32* %9
br label %144
156: ; preds = %144
%157 = load i64*, i64** %20
%158 = bitcast i64* %157 to i8*
store i8* %158, i8** %5
%159 = load i64*, i64** %21
%160 = bitcast i64* %159 to i8*
store i8* %160, i8** %6
br label %161
161: ; preds = %156, %134
%162 = load i32, i32* %7
%163 = and i32 %162, 2
%164 = icmp ne i32 %163, 0
br i1 %164, label %165, label %179
165: ; preds = %161
%166 = load i8*, i8** %5
%167 = bitcast i8* %166 to i16*
store i16* %167, i16** %22
%168 = load i8*, i8** %6
%169 = bitcast i8* %168 to i16*
store i16* %169, i16** %23
%170 = load i16*, i16** %23
%171 = getelementptr inbounds i16, i16* %170, i32 1
store i16* %171, i16** %23
%172 = load i16, i16* %170
%173 = load i16*, i16** %22
%174 = getelementptr inbounds i16, i16* %173, i32 1
store i16* %174, i16** %22
store i16 %172, i16* %173
%175 = load i16*, i16** %22
%176 = bitcast i16* %175 to i8*
store i8* %176, i8** %5
%177 = load i16*, i16** %23
%178 = bitcast i16* %177 to i8*
store i8* %178, i8** %6
br label %179
179: ; preds = %165, %161
%180 = load i32, i32* %7
%181 = and i32 %180, 1
%182 = icmp ne i32 %181, 0
br i1 %182, label %183, label %189
183: ; preds = %179
%184 = load i8*, i8** %5
store i8* %184, i8** %24
%185 = load i8*, i8** %6
store i8* %185, i8** %25
%186 = load i8*, i8** %25
%187 = load i8, i8* %186
%188 = load i8*, i8** %24
store i8 %187, i8* %188
br label %189
189: ; preds = %183, %179
%190 = load i8*, i8** %8
store i8* %190, i8** %4
br label %191
191: ; preds = %189, %132, %68, %29
%192 = load i8*, i8** %4
ret i8* %192
}

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