void __aeabi_memcpy(void *dst0, const void *src0, unsigned long len) {
  char *dst = dst0;
  const char *src = src0;
  long *aligned_dst;
  const long *aligned_src;
  if (!((len) < (sizeof(long) << 2)) &&
      !(((long)src & (sizeof(long) - 1)) | ((long)dst & (sizeof(long) - 1)))) {
    aligned_dst = (long *)dst;
    aligned_src = (const long *)src;
    while (len >= (sizeof(long) << 2)) {
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      len -= (sizeof(long) << 2);
    }
    while (len >= (sizeof(long))) {
      *aligned_dst++ = *aligned_src++;
      len -= (sizeof(long));
    }
    dst = (char *)aligned_dst;
    src = (const char *)aligned_src;
  }
  while (len--)
    *dst++ = *src++;
}


x86 assembly (clang, -O0):
<__aeabi_memcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x20,-0x18(%rbp)
jb     1259 <__aeabi_memcpy+0x159>
mov    -0x28(%rbp),%rax
and    $0x7,%rax
mov    -0x20(%rbp),%rcx
and    $0x7,%rcx
or     %rcx,%rax
cmp    $0x0,%rax
jne    1259 <__aeabi_memcpy+0x159>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x20,-0x18(%rbp)
jb     1204 <__aeabi_memcpy+0x104>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x20,%rax
mov    %rax,-0x18(%rbp)
jmp    1158 <__aeabi_memcpy+0x58>
jmp    1209 <__aeabi_memcpy+0x109>
cmpq   $0x8,-0x18(%rbp)
jb     1249 <__aeabi_memcpy+0x149>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
jmp    1209 <__aeabi_memcpy+0x109>
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    125e <__aeabi_memcpy+0x15e>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     129e <__aeabi_memcpy+0x19e>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    125e <__aeabi_memcpy+0x15e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__aeabi_memcpy>:
push   %rbx
cmp    $0x20,%rdx
jb     12fb <__aeabi_memcpy+0x1fb>
mov    %esi,%eax
or     %edi,%eax
test   $0x7,%al
jne    1304 <__aeabi_memcpy+0x204>
lea    -0x20(%rdx),%rax
test   $0x20,%al
jne    1150 <__aeabi_memcpy+0x50>
mov    (%rsi),%rcx
mov    %rcx,(%rdi)
mov    0x8(%rsi),%rcx
mov    %rcx,0x8(%rdi)
mov    0x10(%rsi),%rcx
mov    %rcx,0x10(%rdi)
mov    0x18(%rsi),%rcx
add    $0x20,%rsi
mov    %rcx,0x18(%rdi)
add    $0x20,%rdi
mov    %rax,%rcx
cmp    $0x20,%rax
jae    1160 <__aeabi_memcpy+0x60>
jmp    11b7 <__aeabi_memcpy+0xb7>
mov    %rdx,%rcx
cmp    $0x20,%rax
jb     11b7 <__aeabi_memcpy+0xb7>
nopl   0x0(%rax)
mov    (%rsi),%rax
mov    %rax,(%rdi)
mov    0x8(%rsi),%rax
mov    %rax,0x8(%rdi)
mov    0x10(%rsi),%rax
mov    %rax,0x10(%rdi)
mov    0x18(%rsi),%rax
mov    %rax,0x18(%rdi)
mov    0x20(%rsi),%rax
mov    %rax,0x20(%rdi)
mov    0x28(%rsi),%rax
mov    %rax,0x28(%rdi)
mov    0x30(%rsi),%rax
mov    %rax,0x30(%rdi)
mov    0x38(%rsi),%rax
add    $0x40,%rsi
mov    %rax,0x38(%rdi)
add    $0x40,%rdi
add    $0xffffffffffffffc0,%rcx
cmp    $0x1f,%rcx
ja     1160 <__aeabi_memcpy+0x60>
lea    0x20(%rcx),%rdx
mov    %rcx,%rax
cmp    $0x8,%rax
jb     12f8 <__aeabi_memcpy+0x1f8>
add    $0xffffffffffffffd8,%rdx
cmp    $0x18,%rdx
jb     12e0 <__aeabi_memcpy+0x1e0>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rsi,%rcx,1),%rbx
add    $0x8,%rbx
cmp    %rbx,%rdi
jae    11f3 <__aeabi_memcpy+0xf3>
add    %rdi,%rcx
add    $0x8,%rcx
cmp    %rcx,%rsi
jb     12e0 <__aeabi_memcpy+0x1e0>
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0xc,%rcx
jae    1222 <__aeabi_memcpy+0x122>
xor    %ecx,%ecx
jmp    1288 <__aeabi_memcpy+0x188>
and    $0xfffffffffffffffc,%r10
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rcx,8),%xmm0
movups 0x10(%rsi,%rcx,8),%xmm1
movups %xmm0,(%rdi,%rcx,8)
movups %xmm1,0x10(%rdi,%rcx,8)
movups 0x20(%rsi,%rcx,8),%xmm0
movups 0x30(%rsi,%rcx,8),%xmm1
movups %xmm0,0x20(%rdi,%rcx,8)
movups %xmm1,0x30(%rdi,%rcx,8)
movups 0x40(%rsi,%rcx,8),%xmm0
movups 0x50(%rsi,%rcx,8),%xmm1
movups %xmm0,0x40(%rdi,%rcx,8)
movups %xmm1,0x50(%rdi,%rcx,8)
movups 0x60(%rsi,%rcx,8),%xmm0
movups 0x70(%rsi,%rcx,8),%xmm1
movups %xmm0,0x60(%rdi,%rcx,8)
movups %xmm1,0x70(%rdi,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%r10
jne    1230 <__aeabi_memcpy+0x130>
lea    0x0(,%r8,8),%r10
test   %r9,%r9
je     12cd <__aeabi_memcpy+0x1cd>
lea    (%rdi,%rcx,8),%r11
add    $0x10,%r11
lea    (%rsi,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%r11,%rbx,1)
movups %xmm1,(%r11,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    12b0 <__aeabi_memcpy+0x1b0>
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
sub    %r10,%rax
cmp    %r8,%rdx
je     12f8 <__aeabi_memcpy+0x1f8>
nopl   (%rax)
mov    (%rsi),%rcx
add    $0x8,%rsi
mov    %rcx,(%rdi)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rax
cmp    $0x7,%rax
ja     12e0 <__aeabi_memcpy+0x1e0>
mov    %rax,%rdx
test   %rdx,%rdx
je     13bf <__aeabi_memcpy+0x2bf>
cmp    $0x8,%rdx
jb     1324 <__aeabi_memcpy+0x224>
lea    (%rsi,%rdx,1),%rax
cmp    %rax,%rdi
jae    13c1 <__aeabi_memcpy+0x2c1>
lea    (%rdi,%rdx,1),%rax
cmp    %rax,%rsi
jae    13c1 <__aeabi_memcpy+0x2c1>
mov    %rsi,%rcx
mov    %rdi,%rax
mov    %rdx,%r9
lea    -0x1(%r9),%rdx
mov    %r9,%rdi
and    $0x7,%rdi
je     1359 <__aeabi_memcpy+0x259>
xor    %esi,%esi
nopl   0x0(%rax)
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1340 <__aeabi_memcpy+0x240>
add    %rsi,%rcx
add    %rsi,%rax
sub    %rsi,%r9
cmp    $0x7,%rdx
jb     13bf <__aeabi_memcpy+0x2bf>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,(%rax,%rdx,1)
movzbl 0x1(%rcx,%rdx,1),%ebx
mov    %bl,0x1(%rax,%rdx,1)
movzbl 0x2(%rcx,%rdx,1),%ebx
mov    %bl,0x2(%rax,%rdx,1)
movzbl 0x3(%rcx,%rdx,1),%ebx
mov    %bl,0x3(%rax,%rdx,1)
movzbl 0x4(%rcx,%rdx,1),%ebx
mov    %bl,0x4(%rax,%rdx,1)
movzbl 0x5(%rcx,%rdx,1),%ebx
mov    %bl,0x5(%rax,%rdx,1)
movzbl 0x6(%rcx,%rdx,1),%ebx
mov    %bl,0x6(%rax,%rdx,1)
movzbl 0x7(%rcx,%rdx,1),%ebx
mov    %bl,0x7(%rax,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1370 <__aeabi_memcpy+0x270>
pop    %rbx
ret
cmp    $0x20,%rdx
jae    13cf <__aeabi_memcpy+0x2cf>
xor    %r8d,%r8d
jmp    14a9 <__aeabi_memcpy+0x3a9>
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rax
mov    %rax,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%r9d
and    $0x3,%r9d
cmp    $0x60,%rax
jae    13f6 <__aeabi_memcpy+0x2f6>
xor    %eax,%eax
jmp    1458 <__aeabi_memcpy+0x358>
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rsi,%rax,1),%xmm0
movups 0x10(%rsi,%rax,1),%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
movups 0x20(%rsi,%rax,1),%xmm0
movups 0x30(%rsi,%rax,1),%xmm1
movups %xmm0,0x20(%rdi,%rax,1)
movups %xmm1,0x30(%rdi,%rax,1)
movups 0x40(%rsi,%rax,1),%xmm0
movups 0x50(%rsi,%rax,1),%xmm1
movups %xmm0,0x40(%rdi,%rax,1)
movups %xmm1,0x50(%rdi,%rax,1)
movups 0x60(%rsi,%rax,1),%xmm0
movups 0x70(%rsi,%rax,1),%xmm1
movups %xmm0,0x60(%rdi,%rax,1)
movups %xmm1,0x70(%rdi,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    1400 <__aeabi_memcpy+0x300>
test   %r9,%r9
je     149b <__aeabi_memcpy+0x39b>
lea    (%rdi,%rax,1),%rcx
add    $0x10,%rcx
add    %rsi,%rax
add    $0x10,%rax
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1480 <__aeabi_memcpy+0x380>
cmp    %r8,%rdx
je     13bf <__aeabi_memcpy+0x2bf>
test   $0x18,%dl
je     14df <__aeabi_memcpy+0x3df>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rsi,%r10,1),%rcx
lea    (%rdi,%r10,1),%rax
mov    %edx,%r9d
and    $0x7,%r9d
nop
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rdi,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    14c0 <__aeabi_memcpy+0x3c0>
cmp    %r10,%rdx
jne    132d <__aeabi_memcpy+0x22d>
jmp    13bf <__aeabi_memcpy+0x2bf>
and    $0x1f,%edx
add    %r8,%rdi
add    %r8,%rsi
jmp    1324 <__aeabi_memcpy+0x224>

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

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