#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ _bitcpy_aligned(int *, int const *, int, int const *);
int /*<<< orphan*/ _bitcpy_short(unsigned char *, int, unsigned char *, int,
                                 int);
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ memcpy(void *, void *, int);
void bitcpy(void *dest, int destn, const void *src, int srcn, size_t nbits) {
  assert(dest);
  assert(src);
  assert(0 <= nbits);
  uintptr_t a = (uintptr_t)dest;
  uintptr_t b = (uintptr_t)src;
  a += destn >> 3;
  b += srcn >> 3;
  destn &= 7;
  srcn &= 7;
  if (!destn && !srcn && !(nbits & 7)) {
    memcpy(dest, src, nbits >> 3);
  }
  if (srcn + nbits < 56) {
    _bitcpy_short((unsigned char *)a, destn, (unsigned char *)b, srcn,
                  (int)nbits);
    return;
  }
  if (srcn == destn) {
    int m = 8 - srcn;
    _bitcpy_short((unsigned char *)a, destn, (unsigned char *)b, srcn, m);
    ++a;
    ++b;
    nbits -= m;
    int p = (int)(nbits >> 3);
    memcpy((void *)a, (void *)b, p);
    _bitcpy_short((unsigned char *)a + p, 0, (unsigned char *)b + p, 0,
                  nbits & 7);
  }
  int m = 0;
  if (destn || (a & 3)) {
    m = (int)(32 - (destn + ((a & 3) << 3)));
    assert(m < nbits);
    _bitcpy_short((unsigned char *)a, destn, (unsigned char *)b, srcn, m);
    destn += m;
    srcn += m;
    nbits -= m;
  }
  a += destn >> 3;
  b += srcn >> 3;
  destn = (destn & 7) | (((int)a & 3) << 3);
  srcn = (srcn & 7) | (((int)b & 3) << 3);
  a &= ~3;
  b &= ~3;
  assert(!destn);
  assert((0 <= srcn) && (srcn < 32));
  int p = (int)nbits & ~31;
  if (p) {
    _bitcpy_aligned((int *)a, (const int *)b, srcn,
                    ((const int *)b) + (p >> 5));
  }
  nbits -= p;
  destn += p;
  srcn += p;
  a += destn >> 3;
  b += srcn >> 3;
  destn &= 7;
  srcn &= 7;
  _bitcpy_short((unsigned char *)a, destn, (unsigned char *)b, srcn,
                (int)nbits);
}


x86 assembly (clang, -O0):
<bitcpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %eax,%edi
call   1040 <assert@plt>
mov    -0x18(%rbp),%rax
mov    %eax,%edi
call   1040 <assert@plt>
xor    %eax,%eax
cmp    -0x28(%rbp),%rax
setbe  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x3,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x3,%eax
cltq
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0xc(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1202 <bitcpy+0xc2>
cmpl   $0x0,-0x1c(%rbp)
jne    1202 <bitcpy+0xc2>
mov    -0x28(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1202 <bitcpy+0xc2>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rax
shr    $0x3,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
movslq -0x1c(%rbp),%rax
add    -0x28(%rbp),%rax
cmp    $0x38,%rax
jae    1233 <bitcpy+0xf3>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %eax,%r8d
call   1060 <_bitcpy_short@plt>
jmp    149b <bitcpy+0x35b>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    12cd <bitcpy+0x18d>
mov    $0x8,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
call   1060 <_bitcpy_short@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
movslq -0x3c(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x3,%rax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x30(%rbp),%rdi
movslq -0x40(%rbp),%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rdx
movslq -0x40(%rbp),%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rax
and    $0x7,%rax
mov    %eax,%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   1060 <_bitcpy_short@plt>
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    12f0 <bitcpy+0x1b0>
mov    -0x30(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
je     135b <bitcpy+0x21b>
movslq -0xc(%rbp),%rcx
mov    -0x30(%rbp),%rax
and    $0x3,%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x20,%eax
sub    %rcx,%rax
mov    %eax,-0x44(%rbp)
movslq -0x44(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x44(%rbp),%r8d
call   1060 <_bitcpy_short@plt>
mov    -0x44(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x44(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movslq -0x44(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x3,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x3,%eax
cltq
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
and    $0x7,%eax
mov    -0x30(%rbp),%rcx
and    $0x3,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    %eax,-0xc(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
mov    -0x38(%rbp),%rcx
and    $0x3,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x30(%rbp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0xc(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
xor    %eax,%eax
xor    %ecx,%ecx
cmp    -0x1c(%rbp),%ecx
mov    %al,-0x49(%rbp)
jg     13ea <bitcpy+0x2aa>
cmpl   $0x20,-0x1c(%rbp)
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x28(%rbp),%rax
and    $0xffffffe0,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     142e <bitcpy+0x2ee>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    -0x48(%rbp),%eax
sar    $0x5,%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
call   1030 <_bitcpy_aligned@plt>
movslq -0x48(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x48(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x3,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x3,%eax
cltq
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0xc(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %eax,%r8d
call   1060 <_bitcpy_short@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitcpy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%rbx
mov    %ecx,%r15d
mov    %rdx,%r13
mov    %esi,%r12d
mov    %rdi,%rbp
call   1040 <assert@plt>
mov    %r13d,%edi
call   1040 <assert@plt>
mov    $0x1,%edi
call   1040 <assert@plt>
mov    %r12d,%eax
sar    $0x3,%eax
movslq %eax,%r14
mov    %r15d,%eax
sar    $0x3,%eax
movslq %eax,%rdx
mov    %r15d,%ecx
and    $0x7,%ecx
or     %r12d,%r15d
test   $0x7,%r15b
jne    11c1 <bitcpy+0x81>
mov    %ebx,%eax
and    $0x7,%eax
test   %rax,%rax
jne    11c1 <bitcpy+0x81>
mov    %rdx,0x8(%rsp)
mov    %rbx,%rdx
shr    $0x3,%rdx
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %ecx,%r15d
call   1050 <memcpy@plt>
mov    0x8(%rsp),%rdx
mov    %r15d,%ecx
add    %rbp,%r14
add    %r13,%rdx
and    $0x7,%r12d
mov    %ecx,%eax
add    %rbx,%rax
cmp    $0x37,%rax
ja     11e4 <bitcpy+0xa4>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %ebx,%r8d
jmp    1371 <bitcpy+0x231>
mov    %rbx,%r15
cmp    %r12d,%ecx
mov    %ecx,0x4(%rsp)
jne    1262 <bitcpy+0x122>
mov    $0x8,%ebp
sub    %r12d,%ebp
mov    %r14,%rdi
mov    %r12d,%esi
mov    %rdx,%r13
mov    %r12d,%ecx
mov    %ebp,%r8d
call   1060 <_bitcpy_short@plt>
lea    0x1(%r14),%rdi
mov    %rdi,0x8(%rsp)
lea    0x1(%r13),%rsi
mov    %rsi,0x10(%rsp)
mov    %r15,%rbx
sub    %rbp,%rbx
mov    %rbx,%rbp
shr    $0x3,%rbp
mov    %ebp,%edx
call   1050 <memcpy@plt>
movslq %ebp,%rax
lea    (%r14,%rax,1),%rdi
add    $0x1,%rdi
lea    (%rax,%r13,1),%rdx
add    $0x1,%rdx
mov    %rbx,%r15
mov    %ebx,%r8d
and    $0x7,%r8d
xor    %esi,%esi
xor    %ecx,%ecx
call   1060 <_bitcpy_short@plt>
mov    0x8(%rsp),%r14
mov    0x10(%rsp),%rdx
test   %r12d,%r12d
jne    127a <bitcpy+0x13a>
mov    %r14d,%eax
and    $0x3,%eax
xor    %esi,%esi
test   %rax,%rax
jne    127a <bitcpy+0x13a>
mov    0x4(%rsp),%ecx
jmp    12c0 <bitcpy+0x180>
mov    %r14d,%eax
and    $0x3,%eax
lea    (%r12,%rax,8),%eax
mov    $0x20,%ebp
sub    %eax,%ebp
xor    %edi,%edi
sub    %rbp,%r15
seta   %dil
mov    %rdx,%r13
call   1040 <assert@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r13,%rdx
mov    0x4(%rsp),%ebx
mov    %ebx,%ecx
mov    %ebp,%r8d
call   1060 <_bitcpy_short@plt>
mov    %r13,%rdx
add    %ebp,%r12d
add    %ebx,%ebp
mov    %ebp,%ecx
mov    %r12d,%esi
mov    %esi,%eax
shr    $0x3,%eax
add    %rax,%r14
mov    %ecx,%eax
shr    $0x3,%eax
add    %rax,%rdx
and    $0x7,%esi
lea    0x0(,%r14,8),%ebx
and    $0x18,%ebx
and    $0x7,%ecx
mov    %ecx,0x4(%rsp)
lea    0x0(,%rdx,8),%ebp
and    $0x18,%ebp
and    $0xfffffffffffffffc,%r14
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
mov    %ebx,%eax
mov    %esi,0x8(%rsp)
or     %esi,%eax
sete   %dil
mov    %rdx,%r13
call   1040 <assert@plt>
mov    $0x1,%edi
call   1040 <assert@plt>
mov    %r15,%r12
and    $0xffffffe0,%r15d
je     1344 <bitcpy+0x204>
mov    %ebp,%edx
or     0x4(%rsp),%edx
mov    %r12d,%eax
sar    $0x5,%eax
cltq
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
mov    %r14,%rdi
mov    %r13,%rsi
call   1030 <_bitcpy_aligned@plt>
or     %r15d,%ebx
or     %r15d,%ebp
sar    $0x3,%ebx
movslq %ebx,%rax
add    %rax,%r14
sar    $0x3,%ebp
movslq %ebp,%rax
add    %rax,%r13
and    $0x1f,%r12d
mov    %r14,%rdi
mov    0x8(%rsp),%esi
mov    %r13,%rdx
mov    0x4(%rsp),%ecx
mov    %r12d,%r8d
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <_bitcpy_short@plt>

LLVM IR (-O0):
define void @bitcpy(i8* %0, i32 %1, i8* %2, i32 %3, i64 %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
store i64 %4, i64* %10
%17 = load i8*, i8** %6
%18 = ptrtoint i8* %17 to i32
%19 = call i32 @assert(i32 %18)
%20 = load i8*, i8** %8
%21 = ptrtoint i8* %20 to i32
%22 = call i32 @assert(i32 %21)
%23 = load i64, i64* %10
%24 = icmp ule i64 0, %23
%25 = zext i1 %24 to i32
%26 = call i32 @assert(i32 %25)
%27 = load i8*, i8** %6
%28 = ptrtoint i8* %27 to i64
store i64 %28, i64* %11
%29 = load i8*, i8** %8
%30 = ptrtoint i8* %29 to i64
store i64 %30, i64* %12
%31 = load i32, i32* %7
%32 = ashr i32 %31, 3
%33 = sext i32 %32 to i64
%34 = load i64, i64* %11
%35 = add i64 %34, %33
store i64 %35, i64* %11
%36 = load i32, i32* %9
%37 = ashr i32 %36, 3
%38 = sext i32 %37 to i64
%39 = load i64, i64* %12
%40 = add i64 %39, %38
store i64 %40, i64* %12
%41 = load i32, i32* %7
%42 = and i32 %41, 7
store i32 %42, i32* %7
%43 = load i32, i32* %9
%44 = and i32 %43, 7
store i32 %44, i32* %9
%45 = load i32, i32* %7
%46 = icmp ne i32 %45, 0
br i1 %46, label %61, label %47
47: ; preds = %5
%48 = load i32, i32* %9
%49 = icmp ne i32 %48, 0
br i1 %49, label %61, label %50
50: ; preds = %47
%51 = load i64, i64* %10
%52 = and i64 %51, 7
%53 = icmp ne i64 %52, 0
br i1 %53, label %61, label %54
54: ; preds = %50
%55 = load i8*, i8** %6
%56 = load i8*, i8** %8
%57 = load i64, i64* %10
%58 = lshr i64 %57, 3
%59 = trunc i64 %58 to i32
%60 = call i32 @memcpy(i8* %55, i8* %56, i32 %59)
br label %61
61: ; preds = %54, %50, %47, %5
%62 = load i32, i32* %9
%63 = sext i32 %62 to i64
%64 = load i64, i64* %10
%65 = add i64 %63, %64
%66 = icmp ult i64 %65, 56
br i1 %66, label %67, label %77
67: ; preds = %61
%68 = load i64, i64* %11
%69 = inttoptr i64 %68 to i8*
%70 = load i32, i32* %7
%71 = load i64, i64* %12
%72 = inttoptr i64 %71 to i8*
%73 = load i32, i32* %9
%74 = load i64, i64* %10
%75 = trunc i64 %74 to i32
%76 = call i32 @_bitcpy_short(i8* %69, i32 %70, i8* %72, i32 %73, i32 %75)
br label %258
77: ; preds = %61
%78 = load i32, i32* %9
%79 = load i32, i32* %7
%80 = icmp eq i32 %78, %79
br i1 %80, label %81, label %123
81: ; preds = %77
%82 = load i32, i32* %9
%83 = sub nsw i32 8, %82
store i32 %83, i32* %13
%84 = load i64, i64* %11
%85 = inttoptr i64 %84 to i8*
%86 = load i32, i32* %7
%87 = load i64, i64* %12
%88 = inttoptr i64 %87 to i8*
%89 = load i32, i32* %9
%90 = load i32, i32* %13
%91 = call i32 @_bitcpy_short(i8* %85, i32 %86, i8* %88, i32 %89, i32 %90)
%92 = load i64, i64* %11
%93 = add i64 %92, 1
store i64 %93, i64* %11
%94 = load i64, i64* %12
%95 = add i64 %94, 1
store i64 %95, i64* %12
%96 = load i32, i32* %13
%97 = sext i32 %96 to i64
%98 = load i64, i64* %10
%99 = sub i64 %98, %97
store i64 %99, i64* %10
%100 = load i64, i64* %10
%101 = lshr i64 %100, 3
%102 = trunc i64 %101 to i32
store i32 %102, i32* %14
%103 = load i64, i64* %11
%104 = inttoptr i64 %103 to i8*
%105 = load i64, i64* %12
%106 = inttoptr i64 %105 to i8*
%107 = load i32, i32* %14
%108 = call i32 @memcpy(i8* %104, i8* %106, i32 %107)
%109 = load i64, i64* %11
%110 = inttoptr i64 %109 to i8*
%111 = load i32, i32* %14
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %110, i64 %112
%114 = load i64, i64* %12
%115 = inttoptr i64 %114 to i8*
%116 = load i32, i32* %14
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %115, i64 %117
%119 = load i64, i64* %10
%120 = and i64 %119, 7
%121 = trunc i64 %120 to i32
%122 = call i32 @_bitcpy_short(i8* %113, i32 0, i8* %118, i32 0, i32 %121)
br label %123
123: ; preds = %81, %77
store i32 0, i32* %15
%124 = load i32, i32* %7
%125 = icmp ne i32 %124, 0
br i1 %125, label %130, label %126
126: ; preds = %123
%127 = load i64, i64* %11
%128 = and i64 %127, 3
%129 = icmp ne i64 %128, 0
br i1 %129, label %130, label %163
130: ; preds = %126, %123
%131 = load i32, i32* %7
%132 = sext i32 %131 to i64
%133 = load i64, i64* %11
%134 = and i64 %133, 3
%135 = shl i64 %134, 3
%136 = add i64 %132, %135
%137 = sub i64 32, %136
%138 = trunc i64 %137 to i32
store i32 %138, i32* %15
%139 = load i32, i32* %15
%140 = sext i32 %139 to i64
%141 = load i64, i64* %10
%142 = icmp ult i64 %140, %141
%143 = zext i1 %142 to i32
%144 = call i32 @assert(i32 %143)
%145 = load i64, i64* %11
%146 = inttoptr i64 %145 to i8*
%147 = load i32, i32* %7
%148 = load i64, i64* %12
%149 = inttoptr i64 %148 to i8*
%150 = load i32, i32* %9
%151 = load i32, i32* %15
%152 = call i32 @_bitcpy_short(i8* %146, i32 %147, i8* %149, i32 %150, i32 %151)
%153 = load i32, i32* %15
%154 = load i32, i32* %7
%155 = add nsw i32 %154, %153
store i32 %155, i32* %7
%156 = load i32, i32* %15
%157 = load i32, i32* %9
%158 = add nsw i32 %157, %156
store i32 %158, i32* %9
%159 = load i32, i32* %15
%160 = sext i32 %159 to i64
%161 = load i64, i64* %10
%162 = sub i64 %161, %160
store i64 %162, i64* %10
br label %163
163: ; preds = %130, %126
%164 = load i32, i32* %7
%165 = ashr i32 %164, 3
%166 = sext i32 %165 to i64
%167 = load i64, i64* %11
%168 = add i64 %167, %166
store i64 %168, i64* %11
%169 = load i32, i32* %9
%170 = ashr i32 %169, 3
%171 = sext i32 %170 to i64
%172 = load i64, i64* %12
%173 = add i64 %172, %171
store i64 %173, i64* %12
%174 = load i32, i32* %7
%175 = and i32 %174, 7
%176 = load i64, i64* %11
%177 = trunc i64 %176 to i32
%178 = and i32 %177, 3
%179 = shl i32 %178, 3
%180 = or i32 %175, %179
store i32 %180, i32* %7
%181 = load i32, i32* %9
%182 = and i32 %181, 7
%183 = load i64, i64* %12
%184 = trunc i64 %183 to i32
%185 = and i32 %184, 3
%186 = shl i32 %185, 3
%187 = or i32 %182, %186
store i32 %187, i32* %9
%188 = load i64, i64* %11
%189 = and i64 %188, -4
store i64 %189, i64* %11
%190 = load i64, i64* %12
%191 = and i64 %190, -4
store i64 %191, i64* %12
%192 = load i32, i32* %7
%193 = icmp ne i32 %192, 0
%194 = xor i1 %193, true
%195 = zext i1 %194 to i32
%196 = call i32 @assert(i32 %195)
%197 = load i32, i32* %9
%198 = icmp sle i32 0, %197
br i1 %198, label %199, label %202
199: ; preds = %163
%200 = load i32, i32* %9
%201 = icmp slt i32 %200, 32
br label %202
202: ; preds = %199, %163
%203 = phi i1 [ false, %163 ], [ %201, %199 ]
%204 = zext i1 %203 to i32
%205 = call i32 @assert(i32 %204)
%206 = load i64, i64* %10
%207 = trunc i64 %206 to i32
%208 = and i32 %207, -32
store i32 %208, i32* %16
%209 = load i32, i32* %16
%210 = icmp ne i32 %209, 0
br i1 %210, label %211, label %224
211: ; preds = %202
%212 = load i64, i64* %11
%213 = inttoptr i64 %212 to i32*
%214 = load i64, i64* %12
%215 = inttoptr i64 %214 to i32*
%216 = load i32, i32* %9
%217 = load i64, i64* %12
%218 = inttoptr i64 %217 to i32*
%219 = load i32, i32* %16
%220 = ashr i32 %219, 5
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32, i32* %218, i64 %221
%223 = call i32 @_bitcpy_aligned(i32* %213, i32* %215, i32 %216, i32* %222)
br label %224
224: ; preds = %211, %202
%225 = load i32, i32* %16
%226 = sext i32 %225 to i64
%227 = load i64, i64* %10
%228 = sub i64 %227, %226
store i64 %228, i64* %10
%229 = load i32, i32* %16
%230 = load i32, i32* %7
%231 = add nsw i32 %230, %229
store i32 %231, i32* %7
%232 = load i32, i32* %16
%233 = load i32, i32* %9
%234 = add nsw i32 %233, %232
store i32 %234, i32* %9
%235 = load i32, i32* %7
%236 = ashr i32 %235, 3
%237 = sext i32 %236 to i64
%238 = load i64, i64* %11
%239 = add i64 %238, %237
store i64 %239, i64* %11
%240 = load i32, i32* %9
%241 = ashr i32 %240, 3
%242 = sext i32 %241 to i64
%243 = load i64, i64* %12
%244 = add i64 %243, %242
store i64 %244, i64* %12
%245 = load i32, i32* %7
%246 = and i32 %245, 7
store i32 %246, i32* %7
%247 = load i32, i32* %9
%248 = and i32 %247, 7
store i32 %248, i32* %9
%249 = load i64, i64* %11
%250 = inttoptr i64 %249 to i8*
%251 = load i32, i32* %7
%252 = load i64, i64* %12
%253 = inttoptr i64 %252 to i8*
%254 = load i32, i32* %9
%255 = load i64, i64* %10
%256 = trunc i64 %255 to i32
%257 = call i32 @_bitcpy_short(i8* %250, i32 %251, i8* %253, i32 %254, i32 %256)
br label %258
258: ; preds = %224, %67
ret void
}

LLVM IR (-O2):
define void @bitcpy(i8* %0, i32 %1, i8* %2, i32 %3, i64 %4) {
%6 = ptrtoint i8* %0 to i64
%7 = trunc i64 %6 to i32
%8 = tail call i32 @assert(i32 %7)
%9 = ptrtoint i8* %2 to i64
%10 = trunc i64 %9 to i32
%11 = tail call i32 @assert(i32 %10)
%12 = tail call i32 @assert(i32 1)
%13 = ashr i32 %1, 3
%14 = sext i32 %13 to i64
%15 = add i64 %14, %6
%16 = ashr i32 %3, 3
%17 = sext i32 %16 to i64
%18 = add i64 %17, %9
%19 = and i32 %1, 7
%20 = and i32 %3, 7
%21 = icmp eq i32 %19, 0
%22 = or i32 %3, %1
%23 = and i32 %22, 7
%24 = icmp eq i32 %23, 0
%25 = and i64 %4, 7
%26 = icmp eq i64 %25, 0
%27 = and i1 %24, %26
br i1 %27, label %28, label %32
28: ; preds = %5
%29 = lshr i64 %4, 3
%30 = trunc i64 %29 to i32
%31 = tail call i32 @memcpy(i8* %0, i8* %2, i32 %30)
br label %32
32: ; preds = %28, %5
%33 = zext i32 %20 to i64
%34 = add i64 %33, %4
%35 = icmp ult i64 %34, 56
br i1 %35, label %36, label %41
36: ; preds = %32
%37 = inttoptr i64 %15 to i8*
%38 = inttoptr i64 %18 to i8*
%39 = trunc i64 %4 to i32
%40 = tail call i32 @_bitcpy_short(i8* %37, i32 %19, i8* %38, i32 %20, i32 %39)
br label %136
41: ; preds = %32
%42 = icmp eq i32 %20, %19
br i1 %42, label %43, label %64
43: ; preds = %41
%44 = sub nuw nsw i32 8, %19
%45 = inttoptr i64 %15 to i8*
%46 = inttoptr i64 %18 to i8*
%47 = tail call i32 @_bitcpy_short(i8* %45, i32 %19, i8* %46, i32 %19, i32 %44)
%48 = add i64 %15, 1
%49 = add i64 %18, 1
%50 = zext i32 %44 to i64
%51 = sub i64 %4, %50
%52 = lshr i64 %51, 3
%53 = trunc i64 %52 to i32
%54 = inttoptr i64 %48 to i8*
%55 = inttoptr i64 %49 to i8*
%56 = tail call i32 @memcpy(i8* %54, i8* %55, i32 %53)
%57 = shl i64 %52, 32
%58 = ashr exact i64 %57, 32
%59 = getelementptr inbounds i8, i8* %54, i64 %58
%60 = getelementptr inbounds i8, i8* %55, i64 %58
%61 = trunc i64 %51 to i32
%62 = and i32 %61, 7
%63 = tail call i32 @_bitcpy_short(i8* %59, i32 0, i8* %60, i32 0, i32 %62)
br label %64
64: ; preds = %43, %41
%65 = phi i64 [ %48, %43 ], [ %15, %41 ]
%66 = phi i64 [ %49, %43 ], [ %18, %41 ]
%67 = phi i64 [ %51, %43 ], [ %4, %41 ]
%68 = and i64 %65, 3
%69 = icmp eq i64 %68, 0
%70 = and i1 %21, %69
br i1 %70, label %87, label %71
71: ; preds = %64
%72 = trunc i64 %65 to i32
%73 = shl i32 %72, 3
%74 = and i32 %73, 24
%75 = or i32 %74, %19
%76 = sub nuw nsw i32 32, %75
%77 = zext i32 %76 to i64
%78 = icmp ugt i64 %67, %77
%79 = zext i1 %78 to i32
%80 = tail call i32 @assert(i32 %79)
%81 = inttoptr i64 %65 to i8*
%82 = inttoptr i64 %66 to i8*
%83 = tail call i32 @_bitcpy_short(i8* %81, i32 %19, i8* %82, i32 %20, i32 %76)
%84 = add nuw nsw i32 %76, %19
%85 = add nuw nsw i32 %76, %20
%86 = sub i64 %67, %77
br label %87
87: ; preds = %64, %71
%88 = phi i64 [ %86, %71 ], [ %67, %64 ]
%89 = phi i32 [ %85, %71 ], [ %20, %64 ]
%90 = phi i32 [ %84, %71 ], [ 0, %64 ]
%91 = lshr i32 %90, 3
%92 = zext i32 %91 to i64
%93 = add i64 %65, %92
%94 = lshr i32 %89, 3
%95 = zext i32 %94 to i64
%96 = add i64 %66, %95
%97 = and i32 %90, 7
%98 = trunc i64 %93 to i32
%99 = shl i32 %98, 3
%100 = and i32 %99, 24
%101 = or i32 %100, %97
%102 = and i32 %89, 7
%103 = trunc i64 %96 to i32
%104 = shl i32 %103, 3
%105 = and i32 %104, 24
%106 = and i64 %93, -4
%107 = and i64 %96, -4
%108 = icmp eq i32 %101, 0
%109 = zext i1 %108 to i32
%110 = tail call i32 @assert(i32 %109)
%111 = tail call i32 @assert(i32 1)
%112 = trunc i64 %88 to i32
%113 = and i32 %112, -32
%114 = icmp eq i32 %113, 0
br i1 %114, label %123, label %115
115: ; preds = %87
%116 = or i32 %105, %102
%117 = inttoptr i64 %106 to i32*
%118 = inttoptr i64 %107 to i32*
%119 = ashr i32 %112, 5
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %118, i64 %120
%122 = tail call i32 @_bitcpy_aligned(i32* %117, i32* %118, i32 %116, i32* %121)
br label %123
123: ; preds = %115, %87
%124 = or i32 %100, %113
%125 = or i32 %105, %113
%126 = ashr exact i32 %124, 3
%127 = sext i32 %126 to i64
%128 = add i64 %106, %127
%129 = ashr exact i32 %125, 3
%130 = sext i32 %129 to i64
%131 = add i64 %107, %130
%132 = inttoptr i64 %128 to i8*
%133 = inttoptr i64 %131 to i8*
%134 = and i32 %112, 31
%135 = tail call i32 @_bitcpy_short(i8* %132, i32 %97, i8* %133, i32 %102, i32 %134)
br label %136
136: ; preds = %123, %36
ret void
}