void byte_copy(void *out, unsigned int len, const void *in) {
  register char *s = out;
  register const char *t = in;
  register const char *u = t + len;
  if (len > 127) {
    while ((unsigned long)s & (sizeof(unsigned long) - 1)) {
      if (t == u)
        break;
      *s = *t;
      ++s;
      ++t;
    }
    if (!((unsigned long)t & (sizeof(unsigned long) - 1)))
      while (t + sizeof(unsigned long) <= u) {
        *(unsigned long *)s = *(unsigned long *)t;
        s += sizeof(unsigned long);
        t += sizeof(unsigned long);
      }
  }
  for (;;) {
    if (t == u)
      break;
    *s = *t;
    ++s;
    ++t;
    if (t == u)
      break;
    *s = *t;
    ++s;
    ++t;
    if (t == u)
      break;
    *s = *t;
    ++s;
    ++t;
    if (t == u)
      break;
    *s = *t;
    ++s;
    ++t;
  }
}


x86 assembly (clang, -O0):
<byte_copy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x7f,-0xc(%rbp)
jbe    11e8 <byte_copy+0xe8>
jmp    113c <byte_copy+0x3c>
mov    -0x20(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
je     118a <byte_copy+0x8a>
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1161 <byte_copy+0x61>
jmp    118a <byte_copy+0x8a>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    113c <byte_copy+0x3c>
mov    -0x28(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    11e3 <byte_copy+0xe3>
jmp    11a1 <byte_copy+0xa1>
mov    -0x28(%rbp),%rax
add    $0x8,%rax
cmp    -0x30(%rbp),%rax
ja     11de <byte_copy+0xde>
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
jmp    11a1 <byte_copy+0xa1>
jmp    11e3 <byte_copy+0xe3>
jmp    11e8 <byte_copy+0xe8>
jmp    11ed <byte_copy+0xed>
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1200 <byte_copy+0x100>
jmp    12ce <byte_copy+0x1ce>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1237 <byte_copy+0x137>
jmp    12ce <byte_copy+0x1ce>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    126e <byte_copy+0x16e>
jmp    12ce <byte_copy+0x1ce>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    12a5 <byte_copy+0x1a5>
jmp    12ce <byte_copy+0x1ce>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11ed <byte_copy+0xed>
pop    %rbp
ret

x86 assembly (clang, -O2):
<byte_copy>:
push   %rbx
mov    %esi,%r9d
lea    (%rdx,%r9,1),%r8
cmp    $0x80,%esi
jb     11ec <byte_copy+0xec>
test   $0x7,%dil
je     11fd <byte_copy+0xfd>
mov    (%rdx),%al
mov    %al,(%rdi)
lea    0x1(%rdi),%rbx
lea    0x1(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x1,%esi
je     1203 <byte_copy+0x103>
mov    0x1(%rdx),%al
mov    %al,0x1(%rdi)
lea    0x2(%rdi),%rbx
lea    0x2(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x2,%esi
je     1203 <byte_copy+0x103>
mov    0x2(%rdx),%al
mov    %al,0x2(%rdi)
lea    0x3(%rdi),%rbx
lea    0x3(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x3,%esi
je     1203 <byte_copy+0x103>
mov    0x3(%rdx),%al
mov    %al,0x3(%rdi)
lea    0x4(%rdi),%rbx
lea    0x4(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x4,%esi
je     1203 <byte_copy+0x103>
mov    0x4(%rdx),%al
mov    %al,0x4(%rdi)
lea    0x5(%rdi),%rbx
lea    0x5(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x5,%esi
je     1203 <byte_copy+0x103>
mov    0x5(%rdx),%al
mov    %al,0x5(%rdi)
lea    0x6(%rdi),%rbx
lea    0x6(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x6,%esi
je     1203 <byte_copy+0x103>
mov    0x6(%rdx),%al
mov    %al,0x6(%rdi)
lea    0x7(%rdi),%rbx
lea    0x7(%rdx),%rax
test   $0x7,%bl
je     1203 <byte_copy+0x103>
cmp    $0x7,%esi
je     1203 <byte_copy+0x103>
mov    0x7(%rdx),%al
mov    %al,0x7(%rdi)
add    $0x8,%rdi
lea    0x8(%rdx),%rax
jmp    1200 <byte_copy+0x100>
mov    %rdi,%rbx
cmp    %r8,%rdx
jne    1342 <byte_copy+0x242>
jmp    1398 <byte_copy+0x298>
mov    %rdx,%rax
mov    %rdi,%rbx
test   $0x7,%al
jne    12ff <byte_copy+0x1ff>
lea    0x8(%rax),%rsi
cmp    %r8,%rsi
ja     12ff <byte_copy+0x1ff>
lea    (%rdx,%r9,1),%rdi
add    $0x1,%rdi
lea    0x10(%rax),%rdx
cmp    %rdx,%rdi
mov    %rdx,%r11
cmova  %rdi,%r11
sub    %rax,%r11
add    $0xfffffffffffffff7,%r11
cmp    $0x18,%r11
jb     1320 <byte_copy+0x220>
cmp    %rdx,%rdi
cmova  %rdi,%rdx
mov    %rax,%rdi
not    %rdi
add    %rdx,%rdi
and    $0xfffffffffffffff8,%rdi
lea    (%rax,%rdi,1),%rdx
cmp    %rdx,%rbx
jae    1268 <byte_copy+0x168>
add    %rbx,%rdi
cmp    %rdi,%rax
jb     1320 <byte_copy+0x220>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdx
mov    %rdx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     139a <byte_copy+0x29a>
mov    %r10,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
movups 0x20(%rax,%rdi,1),%xmm0
movups 0x30(%rax,%rdi,1),%xmm1
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm1,0x30(%rbx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rdx
jne    12a0 <byte_copy+0x1a0>
test   $0x1,%r10b
je     12e8 <byte_copy+0x1e8>
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
lea    (%rbx,%r9,8),%rbx
cmp    %r9,%r11
jne    130c <byte_copy+0x20c>
lea    (%rax,%r9,8),%rdx
cmp    %r8,%rdx
jne    1342 <byte_copy+0x242>
jmp    1398 <byte_copy+0x298>
mov    %rax,%rdx
cmp    %r8,%rdx
jne    1342 <byte_copy+0x242>
jmp    1398 <byte_copy+0x298>
lea    (%rsi,%r9,8),%rsi
lea    (%rax,%r9,8),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax),%rax
mov    %rax,(%rbx)
add    $0x8,%rbx
mov    %rsi,%rax
add    $0x8,%rsi
cmp    %r8,%rsi
jbe    1320 <byte_copy+0x220>
add    $0xfffffffffffffff8,%rsi
mov    %rsi,%rdx
cmp    %r8,%rdx
je     1398 <byte_copy+0x298>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdx,%rax,1),%ecx
mov    %cl,(%rbx,%rax,1)
lea    (%rdx,%rax,1),%rsi
add    $0x1,%rsi
cmp    %r8,%rsi
je     1398 <byte_copy+0x298>
movzbl (%rsi),%ecx
mov    %cl,0x1(%rbx,%rax,1)
add    $0x1,%rsi
cmp    %r8,%rsi
je     1398 <byte_copy+0x298>
movzbl (%rsi),%ecx
mov    %cl,0x2(%rbx,%rax,1)
add    $0x1,%rsi
cmp    %r8,%rsi
je     1398 <byte_copy+0x298>
movzbl (%rsi),%ecx
mov    %cl,0x3(%rbx,%rax,1)
add    $0x4,%rax
add    $0x1,%rsi
cmp    %r8,%rsi
jne    1350 <byte_copy+0x250>
pop    %rbx
ret
xor    %edi,%edi
test   $0x1,%r10b
jne    12d6 <byte_copy+0x1d6>
jmp    12e8 <byte_copy+0x1e8>

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

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