void reverse_memcpy(void *dst, const void *src, unsigned int size) {
  const unsigned char *src_p;
  unsigned char *dst_p;
  if ((size >= 4) && !((dst - src) & 3)) {
    const unsigned int *src_p32;
    unsigned int *dst_p32;
    unsigned int endDst = ((unsigned int)dst) + size;
    unsigned int endRest = endDst & 3;
    if (endRest) {
      src_p = ((const unsigned char *)(src + size)) - 1;
      dst_p = ((unsigned char *)endDst) - 1;
      size -= endRest;
      while (endRest--)
        *dst_p-- = *src_p--;
    }
    src_p32 = ((const unsigned int *)(src + size)) - 1;
    dst_p32 = ((unsigned int *)(dst + size)) - 1;
    unsigned int size32 = size >> 5;
    if (size32) {
      size &= 0x1F;
      while (size32--) {
        src_p32 -= 8;
        dst_p32 -= 8;
        dst_p32[8] = src_p32[8];
        dst_p32[7] = src_p32[7];
        dst_p32[6] = src_p32[6];
        dst_p32[5] = src_p32[5];
        dst_p32[4] = src_p32[4];
        dst_p32[3] = src_p32[3];
        dst_p32[2] = src_p32[2];
        dst_p32[1] = src_p32[1];
      }
    }
    unsigned int size4 = size >> 2;
    if (size4) {
      size &= 3;
      while (size4--)
        *dst_p32-- = *src_p32--;
    }
    dst_p = ((unsigned char *)dst_p32) + 3;
    src_p = ((const unsigned char *)src_p32) + 3;
  } else {
    dst_p = ((unsigned char *)dst) + size - 1;
    src_p = ((const unsigned char *)src) + size - 1;
  }
  while (size--)
    *dst_p-- = *src_p--;
}


x86 assembly (clang, -O0):
<reverse_memcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jb     1316 <reverse_memcpy+0x216>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
and    $0x3,%rax
cmp    $0x0,%rax
jne    1316 <reverse_memcpy+0x216>
mov    -0x8(%rbp),%rax
add    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
and    $0x3,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     11b7 <reverse_memcpy+0xb7>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x40(%rbp)
cmp    $0x0,%eax
je     11b2 <reverse_memcpy+0xb2>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1177 <reverse_memcpy+0x77>
jmp    11b7 <reverse_memcpy+0xb7>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
shr    $0x5,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     129d <reverse_memcpy+0x19d>
mov    -0x14(%rbp),%eax
and    $0x1f,%eax
mov    %eax,-0x14(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     1298 <reverse_memcpy+0x198>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    0x20(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x20(%rax)
mov    -0x30(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x30(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x30(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x30(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    11f7 <reverse_memcpy+0xf7>
jmp    129d <reverse_memcpy+0x19d>
mov    -0x14(%rbp),%eax
shr    $0x2,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     12f9 <reverse_memcpy+0x1f9>
mov    -0x14(%rbp),%eax
and    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x48(%rbp)
cmp    $0x0,%eax
je     12f4 <reverse_memcpy+0x1f4>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
jmp    12b9 <reverse_memcpy+0x1b9>
jmp    12f9 <reverse_memcpy+0x1f9>
mov    -0x38(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x20(%rbp)
jmp    133a <reverse_memcpy+0x23a>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    133f <reverse_memcpy+0x23f>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     137a <reverse_memcpy+0x27a>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    133f <reverse_memcpy+0x23f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse_memcpy>:
push   %r15
push   %r14
push   %rbx
cmp    $0x4,%edx
jb     1116 <reverse_memcpy+0x16>
mov    %edi,%eax
sub    %esi,%eax
test   $0x3,%al
je     1203 <reverse_memcpy+0x103>
mov    %edx,%ecx
lea    (%rdi,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
lea    (%rsi,%rcx,1),%r11
add    $0xffffffffffffffff,%r11
test   %edx,%edx
je     1588 <reverse_memcpy+0x488>
lea    -0x1(%rdx),%r9d
cmp    $0x3,%r9d
jb     1160 <reverse_memcpy+0x60>
mov    %rax,%rcx
sub    %r9,%rcx
lea    0x1(%r11),%rsi
cmp    %rsi,%rcx
jae    1250 <reverse_memcpy+0x150>
lea    0x1(%rax),%rcx
mov    %r11,%rsi
sub    %r9,%rsi
cmp    %rcx,%rsi
jae    1250 <reverse_memcpy+0x150>
mov    %rax,%rcx
mov    %r11,%rsi
lea    -0x1(%rdx),%r8d
test   $0x7,%dl
je     1197 <reverse_memcpy+0x97>
mov    %edx,%ebx
and    $0x7,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rsi),%eax
add    $0xffffffffffffffff,%rsi
mov    %al,(%rcx)
add    $0xffffffffffffffff,%rcx
add    $0x1,%rdi
cmp    %edi,%ebx
jne    1180 <reverse_memcpy+0x80>
sub    %edi,%edx
cmp    $0x7,%r8d
jb     1588 <reverse_memcpy+0x488>
neg    %edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi,%rax,1),%ebx
mov    %bl,(%rcx,%rax,1)
movzbl -0x1(%rsi,%rax,1),%ebx
mov    %bl,-0x1(%rcx,%rax,1)
movzbl -0x2(%rsi,%rax,1),%ebx
mov    %bl,-0x2(%rcx,%rax,1)
movzbl -0x3(%rsi,%rax,1),%ebx
mov    %bl,-0x3(%rcx,%rax,1)
movzbl -0x4(%rsi,%rax,1),%ebx
mov    %bl,-0x4(%rcx,%rax,1)
movzbl -0x5(%rsi,%rax,1),%ebx
mov    %bl,-0x5(%rcx,%rax,1)
movzbl -0x6(%rsi,%rax,1),%ebx
mov    %bl,-0x6(%rcx,%rax,1)
movzbl -0x7(%rsi,%rax,1),%ebx
mov    %bl,-0x7(%rcx,%rax,1)
add    $0xfffffffffffffff8,%rax
cmp    %eax,%edx
jne    11b0 <reverse_memcpy+0xb0>
jmp    1588 <reverse_memcpy+0x488>
lea    (%rdi,%rdx,1),%ecx
mov    %ecx,%eax
and    $0x3,%eax
je     1236 <reverse_memcpy+0x136>
mov    %ecx,%r8d
mov    %edx,%ebx
mov    -0x1(%rsi,%rbx,1),%cl
mov    %cl,-0x1(%r8)
cmp    $0x1,%eax
je     1234 <reverse_memcpy+0x134>
mov    -0x2(%rsi,%rbx,1),%cl
mov    %cl,-0x2(%r8)
cmp    $0x2,%eax
je     1234 <reverse_memcpy+0x134>
mov    -0x3(%rsi,%rbx,1),%cl
mov    %cl,-0x3(%r8)
sub    %eax,%edx
mov    %edx,%eax
lea    (%rsi,%rax,1),%r11
add    $0xfffffffffffffffc,%r11
add    %rdi,%rax
add    $0xfffffffffffffffc,%rax
cmp    $0x20,%edx
jae    126f <reverse_memcpy+0x16f>
mov    %edx,%ecx
jmp    12c3 <reverse_memcpy+0x1c3>
lea    0x1(%r9),%r10
movabs $0x1fffffff0,%r8
cmp    $0xf,%r9d
jae    138e <reverse_memcpy+0x28e>
xor    %edi,%edi
jmp    1444 <reverse_memcpy+0x344>
mov    %edx,%ecx
and    $0x1f,%ecx
shr    $0x5,%edx
nopw   0x0(%rax,%rax,1)
mov    (%r11),%esi
mov    %esi,(%rax)
mov    -0x4(%r11),%esi
mov    %esi,-0x4(%rax)
mov    -0x8(%r11),%esi
mov    %esi,-0x8(%rax)
mov    -0xc(%r11),%esi
mov    %esi,-0xc(%rax)
mov    -0x10(%r11),%esi
mov    %esi,-0x10(%rax)
mov    -0x14(%r11),%esi
mov    %esi,-0x14(%rax)
mov    -0x18(%r11),%esi
mov    %esi,-0x18(%rax)
mov    -0x1c(%r11),%esi
add    $0xffffffffffffffe0,%r11
mov    %esi,-0x1c(%rax)
add    $0xffffffffffffffe0,%rax
add    $0xffffffff,%edx
jne    1280 <reverse_memcpy+0x180>
cmp    $0x4,%ecx
jae    12cf <reverse_memcpy+0x1cf>
mov    %ecx,%edx
jmp    1578 <reverse_memcpy+0x478>
mov    %ecx,%edx
and    $0x3,%edx
shr    $0x2,%ecx
lea    -0x1(%rcx),%r10d
cmp    $0x7,%r10d
jb     14df <reverse_memcpy+0x3df>
lea    0x0(,%r10,4),%rdi
mov    %rax,%rbx
sub    %rdi,%rbx
lea    0x4(%r11),%rsi
cmp    %rsi,%rbx
jae    130f <reverse_memcpy+0x20f>
lea    0x4(%rax),%rsi
mov    %r11,%rbx
sub    %rdi,%rbx
cmp    %rsi,%rbx
jb     14df <reverse_memcpy+0x3df>
add    $0x1,%r10
movabs $0x1fffffff0,%r8
or     $0x8,%r8
and    %r10,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     149d <reverse_memcpy+0x39d>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x1c(%r11,%rdi,4),%xmm0
movups -0xc(%r11,%rdi,4),%xmm1
movups %xmm1,-0xc(%rax,%rdi,4)
movups %xmm0,-0x1c(%rax,%rdi,4)
movups -0x3c(%r11,%rdi,4),%xmm0
movups -0x2c(%r11,%rdi,4),%xmm1
movups %xmm1,-0x2c(%rax,%rdi,4)
movups %xmm0,-0x3c(%rax,%rdi,4)
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1350 <reverse_memcpy+0x250>
neg    %rdi
jmp    149f <reverse_memcpy+0x39f>
mov    %r10,%rdi
and    %r8,%rdi
lea    -0x10(%rdi),%rcx
mov    %rcx,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r14d
and    $0x3,%r14d
cmp    $0x30,%rcx
jae    13b4 <reverse_memcpy+0x2b4>
xor    %esi,%esi
jmp    13f9 <reverse_memcpy+0x2f9>
and    $0xfffffffffffffffc,%rbx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0xf(%r11,%rsi,1),%xmm0
movups %xmm0,-0xf(%rax,%rsi,1)
movups -0x1f(%r11,%rsi,1),%xmm0
movups %xmm0,-0x1f(%rax,%rsi,1)
movups -0x2f(%r11,%rsi,1),%xmm0
movups %xmm0,-0x2f(%rax,%rsi,1)
movups -0x3f(%r11,%rsi,1),%xmm0
movups %xmm0,-0x3f(%rax,%rsi,1)
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rbx
jne    13c0 <reverse_memcpy+0x2c0>
neg    %rsi
test   %r14,%r14
je     1435 <reverse_memcpy+0x335>
mov    $0xfffffffffffffff1,%rbx
sub    %rsi,%rbx
lea    (%r11,%rbx,1),%r15
add    %rax,%rbx
shl    $0x4,%r14
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r15,%rcx,1),%xmm0
movups %xmm0,(%rbx,%rcx,1)
add    $0xfffffffffffffff0,%rcx
mov    %r14,%rsi
add    %rcx,%rsi
jne    1420 <reverse_memcpy+0x320>
cmp    %rdi,%r10
je     1588 <reverse_memcpy+0x488>
test   $0xc,%r10b
je     1490 <reverse_memcpy+0x390>
add    $0x1,%r9
add    $0xc,%r8
and    %r9,%r8
sub    %r8d,%edx
mov    %rax,%rcx
sub    %r8,%rcx
mov    %r11,%rsi
sub    %r8,%rsi
neg    %rdi
and    $0xfffffffffffffffc,%r10
neg    %r10
nopl   0x0(%rax,%rax,1)
mov    -0x3(%r11,%rdi,1),%ebx
mov    %ebx,-0x3(%rax,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r10
jne    1470 <reverse_memcpy+0x370>
cmp    %r8,%r9
jne    1166 <reverse_memcpy+0x66>
jmp    1588 <reverse_memcpy+0x488>
sub    %rdi,%r11
sub    %rdi,%rax
sub    %edi,%edx
jmp    1160 <reverse_memcpy+0x60>
xor    %edi,%edi
lea    0x0(,%r8,4),%r14
test   $0x1,%r9b
je     14cd <reverse_memcpy+0x3cd>
shl    $0x2,%rdi
mov    %rax,%rsi
sub    %rdi,%rsi
mov    %r11,%rbx
sub    %rdi,%rbx
movups -0x1c(%rbx),%xmm0
movups -0xc(%rbx),%xmm1
movups %xmm1,-0xc(%rsi)
movups %xmm0,-0x1c(%rsi)
sub    %r14,%rax
sub    %r14,%r11
cmp    %r8,%r10
je     1578 <reverse_memcpy+0x478>
sub    %r8d,%ecx
lea    -0x1(%rcx),%r8d
mov    %ecx,%edi
and    $0x7,%edi
je     1506 <reverse_memcpy+0x406>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r11),%esi
add    $0xfffffffffffffffc,%r11
mov    %esi,(%rax)
add    $0xfffffffffffffffc,%rax
add    $0x1,%ebx
cmp    %ebx,%edi
jne    14f0 <reverse_memcpy+0x3f0>
sub    %ebx,%ecx
cmp    $0x7,%r8d
jb     1578 <reverse_memcpy+0x478>
neg    %ecx
xor    %esi,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r11,%rdi,4),%ebx
mov    %ebx,(%rax,%rdi,4)
mov    -0x4(%r11,%rdi,4),%ebx
mov    %ebx,-0x4(%rax,%rdi,4)
mov    -0x8(%r11,%rdi,4),%ebx
mov    %ebx,-0x8(%rax,%rdi,4)
mov    -0xc(%r11,%rdi,4),%ebx
mov    %ebx,-0xc(%rax,%rdi,4)
mov    -0x10(%r11,%rdi,4),%ebx
mov    %ebx,-0x10(%rax,%rdi,4)
mov    -0x14(%r11,%rdi,4),%ebx
mov    %ebx,-0x14(%rax,%rdi,4)
mov    -0x18(%r11,%rdi,4),%ebx
mov    %ebx,-0x18(%rax,%rdi,4)
mov    -0x1c(%r11,%rdi,4),%ebx
mov    %ebx,-0x1c(%rax,%rdi,4)
add    $0xfffffffffffffff8,%rdi
add    $0x20,%rsi
cmp    %edi,%ecx
jne    1520 <reverse_memcpy+0x420>
sub    %rsi,%rax
sub    %rsi,%r11
add    $0x3,%rax
add    $0x3,%r11
test   %edx,%edx
jne    1130 <reverse_memcpy+0x30>
pop    %rbx
pop    %r14
pop    %r15
ret

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

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