void fgen_copy_partial_bitstring(const unsigned char *src, unsigned char *dest,
                                 int bitoffset, int number_of_bits) {
  int i, offset;
  if (number_of_bits == 0)
    return;
  offset = bitoffset / 8;
  if ((bitoffset & 7) != 0) {
    for (i = bitoffset & 7; i < 8; i++) {
      dest[offset] &= ~(1 << i);
      dest[offset] |= src[offset] & (1 << i);
      number_of_bits--;
      if (number_of_bits == 0)
        return;
    }
    offset++;
  }
  while (number_of_bits >= 8 && (((unsigned int)(&dest[offset])) & 3) != 0) {
    dest[offset] = src[offset];
    number_of_bits -= 8;
    offset++;
  }
  while (number_of_bits >= 32) {
    *(unsigned int *)&dest[offset] = *(unsigned int *)&src[offset];
    number_of_bits -= 32;
    offset += 4;
  }
  while (number_of_bits >= 8) {
    dest[offset] = src[offset];
    number_of_bits -= 8;
    offset++;
  }
  for (i = 0; i < number_of_bits; i++) {
    dest[offset] &= ~(1 << i);
    dest[offset] |= src[offset] & (1 << i);
  }
}


x86 assembly (clang, -O0):
<fgen_copy_partial_bitstring>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    1121 <fgen_copy_partial_bitstring+0x21>
jmp    1314 <fgen_copy_partial_bitstring+0x214>
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
and    $0x7,%eax
cmp    $0x0,%eax
je     11cc <fgen_copy_partial_bitstring+0xcc>
mov    -0x14(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x8,-0x1c(%rbp)
jge    11c3 <fgen_copy_partial_bitstring+0xc3>
mov    -0x1c(%rbp),%ecx
mov    $0x1,%esi
shl    %cl,%esi
xor    $0xffffffff,%esi
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x1c(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
and    %eax,%esi
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    11b0 <fgen_copy_partial_bitstring+0xb0>
jmp    1314 <fgen_copy_partial_bitstring+0x214>
jmp    11b5 <fgen_copy_partial_bitstring+0xb5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1147 <fgen_copy_partial_bitstring+0x47>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d1 <fgen_copy_partial_bitstring+0xd1>
xor    %eax,%eax
cmpl   $0x8,-0x18(%rbp)
mov    %al,-0x21(%rbp)
jl     11f7 <fgen_copy_partial_bitstring+0xf7>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
add    %rcx,%rax
and    $0x3,%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
test   $0x1,%al
jne    1207 <fgen_copy_partial_bitstring+0x107>
jmp    1234 <fgen_copy_partial_bitstring+0x134>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d1 <fgen_copy_partial_bitstring+0xd1>
jmp    1239 <fgen_copy_partial_bitstring+0x139>
cmpl   $0x20,-0x18(%rbp)
jl     1270 <fgen_copy_partial_bitstring+0x170>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%edx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
sub    $0x20,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x20(%rbp)
jmp    1239 <fgen_copy_partial_bitstring+0x139>
jmp    1275 <fgen_copy_partial_bitstring+0x175>
cmpl   $0x8,-0x18(%rbp)
jl     12ac <fgen_copy_partial_bitstring+0x1ac>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1275 <fgen_copy_partial_bitstring+0x175>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1314 <fgen_copy_partial_bitstring+0x214>
mov    -0x1c(%rbp),%ecx
mov    $0x1,%esi
shl    %cl,%esi
xor    $0xffffffff,%esi
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x1c(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
and    %eax,%esi
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12b3 <fgen_copy_partial_bitstring+0x1b3>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fgen_copy_partial_bitstring>:
push   %rbp
push   %r14
push   %rbx
test   %ecx,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
mov    %ecx,%r8d
lea    0x7(%rdx),%r14d
test   %edx,%edx
cmovns %edx,%r14d
sar    $0x3,%r14d
and    $0x7,%edx
je     1292 <fgen_copy_partial_bitstring+0x192>
mov    $0x1,%ebx
mov    %edx,%ecx
shl    %cl,%ebx
movslq %r14d,%r9
mov    %ebx,%eax
not    %al
and    (%rsi,%r9,1),%al
mov    %al,(%rsi,%r9,1)
and    (%rdi,%r9,1),%bl
or     %al,%bl
mov    %bl,(%rsi,%r9,1)
mov    %r8d,%ecx
add    $0xffffffff,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
cmp    $0x7,%edx
je     128b <fgen_copy_partial_bitstring+0x18b>
mov    $0x2,%r10d
mov    %edx,%ecx
shl    %cl,%r10d
mov    %r10d,%eax
not    %al
and    %al,%bl
mov    %bl,(%rsi,%r9,1)
and    (%rdi,%r9,1),%r10b
or     %bl,%r10b
mov    %r10b,(%rsi,%r9,1)
mov    %r8d,%ecx
add    $0xfffffffe,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
cmp    $0x6,%edx
je     128b <fgen_copy_partial_bitstring+0x18b>
mov    $0x4,%ebx
mov    %edx,%ecx
shl    %cl,%ebx
mov    %ebx,%eax
not    %al
and    %al,%r10b
mov    %r10b,(%rsi,%r9,1)
and    (%rdi,%r9,1),%bl
or     %r10b,%bl
mov    %bl,(%rsi,%r9,1)
mov    %r8d,%ecx
add    $0xfffffffd,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
cmp    $0x5,%edx
je     128b <fgen_copy_partial_bitstring+0x18b>
mov    $0x8,%r10d
mov    %edx,%ecx
shl    %cl,%r10d
mov    %r10d,%eax
not    %al
and    %al,%bl
mov    %bl,(%rsi,%r9,1)
and    (%rdi,%r9,1),%r10b
or     %bl,%r10b
mov    %r10b,(%rsi,%r9,1)
mov    %r8d,%ecx
add    $0xfffffffc,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
cmp    $0x4,%edx
je     128b <fgen_copy_partial_bitstring+0x18b>
mov    $0x10,%ebx
mov    %edx,%ecx
shl    %cl,%ebx
mov    %ebx,%eax
not    %al
and    %al,%r10b
mov    %r10b,(%rsi,%r9,1)
and    (%rdi,%r9,1),%bl
or     %r10b,%bl
mov    %bl,(%rsi,%r9,1)
mov    %r8d,%ecx
add    $0xfffffffb,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
cmp    $0x3,%edx
je     128b <fgen_copy_partial_bitstring+0x18b>
mov    $0x20,%r10d
mov    %edx,%ecx
shl    %cl,%r10d
mov    %r10d,%eax
not    %al
and    %al,%bl
mov    %bl,(%rsi,%r9,1)
and    (%rdi,%r9,1),%r10b
or     %bl,%r10b
mov    %r10b,(%rsi,%r9,1)
mov    %r8d,%ecx
add    $0xfffffffa,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
cmp    $0x2,%edx
je     128b <fgen_copy_partial_bitstring+0x18b>
mov    $0x40,%eax
mov    %edx,%ecx
shl    %cl,%eax
mov    %eax,%ecx
not    %cl
and    %cl,%r10b
mov    %r10b,(%rsi,%r9,1)
and    (%rdi,%r9,1),%al
or     %r10b,%al
mov    %al,(%rsi,%r9,1)
add    $0xfffffff9,%r8d
mov    %r8d,%ecx
je     1645 <fgen_copy_partial_bitstring+0x545>
add    $0x1,%r14d
mov    %ecx,%r8d
cmp    $0x8,%r8d
jl     15bb <fgen_copy_partial_bitstring+0x4bb>
movslq %r14d,%rdx
lea    (%rsi,%rdx,1),%rax
test   $0x3,%al
je     1316 <fgen_copy_partial_bitstring+0x216>
mov    (%rdi,%rdx,1),%cl
mov    %cl,(%rax)
lea    -0x8(%r8),%ebp
lea    0x1(%rdx),%r14
cmp    $0x10,%r8d
jl     130e <fgen_copy_partial_bitstring+0x20e>
lea    (%rsi,%r14,1),%rax
test   $0x3,%al
je     131c <fgen_copy_partial_bitstring+0x21c>
mov    0x1(%rdi,%rdx,1),%cl
mov    %cl,(%rax)
lea    -0x10(%r8),%ebp
lea    0x2(%rdx),%r14
cmp    $0x18,%r8d
jl     130e <fgen_copy_partial_bitstring+0x20e>
lea    (%rsi,%r14,1),%rax
test   $0x3,%al
je     131c <fgen_copy_partial_bitstring+0x21c>
mov    0x2(%rdi,%rdx,1),%cl
mov    %cl,(%rax)
lea    -0x18(%r8),%ebp
lea    0x3(%rdx),%r14
cmp    $0x20,%r8d
jl     130e <fgen_copy_partial_bitstring+0x20e>
lea    (%rsi,%r14,1),%rax
test   $0x3,%al
je     131c <fgen_copy_partial_bitstring+0x21c>
mov    0x3(%rdi,%rdx,1),%cl
mov    %cl,(%rax)
add    $0xffffffe0,%r8d
add    $0x4,%rdx
mov    %r8d,%ebp
mov    %rdx,%r14
mov    %ebp,%r8d
jmp    15bb <fgen_copy_partial_bitstring+0x4bb>
mov    %rdx,%r14
mov    %r8d,%ebp
cmp    $0x20,%ebp
jb     1452 <fgen_copy_partial_bitstring+0x352>
xor    %ecx,%ecx
mov    %ebp,%r10d
sub    $0x3f,%r10d
cmovb  %ecx,%r10d
add    $0x1f,%r10d
cmp    $0xe0,%r10d
jb     1420 <fgen_copy_partial_bitstring+0x320>
lea    (%rsi,%r14,1),%rdx
mov    %ebp,%eax
sub    $0x3f,%eax
cmovb  %ecx,%eax
add    $0x1f,%eax
shr    $0x3,%eax
and    $0xfffffffc,%eax
add    %r14,%rax
lea    (%rdi,%rax,1),%rcx
add    $0x4,%rcx
cmp    %rcx,%rdx
jae    137c <fgen_copy_partial_bitstring+0x27c>
add    %rsi,%rax
add    $0x4,%rax
lea    (%rdi,%r14,1),%rcx
cmp    %rax,%rcx
jb     1420 <fgen_copy_partial_bitstring+0x320>
shr    $0x5,%r10d
add    $0x1,%r10d
mov    %r10d,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     13f2 <fgen_copy_partial_bitstring+0x2f2>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rsi,%r14,1),%rcx
add    $0x30,%rcx
lea    (%rdi,%r14,1),%rdx
add    $0x30,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rbx,1),%xmm0
movups -0x20(%rdx,%rbx,1),%xmm1
movups %xmm0,-0x30(%rcx,%rbx,1)
movups %xmm1,-0x20(%rcx,%rbx,1)
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rax
jne    13c0 <fgen_copy_partial_bitstring+0x2c0>
jmp    13f4 <fgen_copy_partial_bitstring+0x2f4>
xor    %ebx,%ebx
mov    %r8d,%eax
shl    $0x5,%eax
test   $0x1,%r9b
je     1415 <fgen_copy_partial_bitstring+0x315>
add    %r14,%rbx
movups (%rdi,%rbx,1),%xmm0
movups 0x10(%rdi,%rbx,1),%xmm1
movups %xmm0,(%rsi,%rbx,1)
movups %xmm1,0x10(%rsi,%rbx,1)
lea    (%r14,%r8,4),%r14
sub    %eax,%ebp
cmp    %r10,%r8
je     1446 <fgen_copy_partial_bitstring+0x346>
mov    %ebp,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%r14,1),%ecx
mov    %ecx,(%rsi,%r14,1)
lea    -0x20(%rax),%ebp
add    $0x4,%r14
cmp    $0x3f,%eax
mov    %ebp,%eax
ja     1430 <fgen_copy_partial_bitstring+0x330>
mov    %ebp,%r8d
cmp    $0x8,%ebp
jb     15bb <fgen_copy_partial_bitstring+0x4bb>
movslq %r14d,%rdx
xor    %ecx,%ecx
mov    %ebp,%r8d
sub    $0xf,%r8d
cmovb  %ecx,%r8d
add    $0x7,%r8d
cmp    $0xf8,%r8d
jb     1596 <fgen_copy_partial_bitstring+0x496>
lea    (%rsi,%r14,1),%rbx
mov    %ebp,%eax
sub    $0xf,%eax
cmovb  %ecx,%eax
add    $0x7,%eax
shr    $0x3,%eax
add    %r14,%rax
lea    (%rdi,%rax,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rbx
jae    14a9 <fgen_copy_partial_bitstring+0x3a9>
add    %rsi,%rax
add    $0x1,%rax
lea    (%rdi,%r14,1),%rcx
cmp    %rax,%rcx
jb     1596 <fgen_copy_partial_bitstring+0x496>
shr    $0x3,%r8d
add    $0x1,%r8d
mov    %r8d,%r9d
and    $0xffffffe0,%r9d
lea    -0x20(%r9),%rax
mov    %rax,%r11
shr    $0x5,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x60,%rax
jae    14d8 <fgen_copy_partial_bitstring+0x3d8>
xor    %ebx,%ebx
jmp    1548 <fgen_copy_partial_bitstring+0x448>
and    $0xfffffffffffffffc,%r11
lea    (%rsi,%r14,1),%rax
add    $0x70,%rax
lea    (%rdi,%r14,1),%rcx
add    $0x70,%rcx
xor    %ebx,%ebx
xchg   %ax,%ax
movups -0x70(%rcx,%rbx,1),%xmm0
movups -0x60(%rcx,%rbx,1),%xmm1
movups %xmm0,-0x70(%rax,%rbx,1)
movups %xmm1,-0x60(%rax,%rbx,1)
movups -0x50(%rcx,%rbx,1),%xmm0
movups -0x40(%rcx,%rbx,1),%xmm1
movups %xmm0,-0x50(%rax,%rbx,1)
movups %xmm1,-0x40(%rax,%rbx,1)
movups -0x30(%rcx,%rbx,1),%xmm0
movups -0x20(%rcx,%rbx,1),%xmm1
movups %xmm0,-0x30(%rax,%rbx,1)
movups %xmm1,-0x20(%rax,%rbx,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rax,%rbx,1)
movups %xmm1,(%rax,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%r11
jne    14f0 <fgen_copy_partial_bitstring+0x3f0>
lea    0x0(,%r9,8),%r11d
test   %r10,%r10
je     158b <fgen_copy_partial_bitstring+0x48b>
add    %rbx,%r14
lea    (%rsi,%r14,1),%rcx
add    $0x10,%rcx
lea    (%rdi,%r14,1),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %eax,%eax
xchg   %ax,%ax
movups -0x10(%rbx,%rax,1),%xmm0
movups (%rbx,%rax,1),%xmm1
movups %xmm0,-0x10(%rcx,%rax,1)
movups %xmm1,(%rcx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r10
jne    1570 <fgen_copy_partial_bitstring+0x470>
add    %r9,%rdx
sub    %r11d,%ebp
cmp    %r8,%r9
je     15b5 <fgen_copy_partial_bitstring+0x4b5>
mov    %ebp,%eax
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ecx
mov    %cl,(%rsi,%rdx,1)
lea    -0x8(%rax),%ebp
add    $0x1,%rdx
cmp    $0xf,%eax
mov    %ebp,%eax
ja     15a0 <fgen_copy_partial_bitstring+0x4a0>
mov    %ebp,%r8d
mov    %edx,%r14d
test   %r8d,%r8d
jle    1645 <fgen_copy_partial_bitstring+0x545>
movslq %r14d,%r9
mov    (%rsi,%r9,1),%al
xor    %edx,%edx
cmp    $0x1,%r8d
je     1621 <fgen_copy_partial_bitstring+0x521>
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
xor    %edx,%edx
nopl   0x0(%rax)
mov    $0x1,%ebp
mov    %edx,%ecx
shl    %cl,%ebp
mov    %ebp,%ecx
not    %cl
and    %al,%cl
mov    %cl,(%rsi,%r9,1)
and    (%rdi,%r9,1),%bpl
or     %cl,%bpl
lea    0x1(%rdx),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
not    %cl
and    %bpl,%cl
mov    %cl,(%rsi,%r9,1)
and    (%rdi,%r9,1),%al
or     %cl,%al
mov    %al,(%rsi,%r9,1)
add    $0x2,%edx
cmp    %r10d,%edx
jne    15e0 <fgen_copy_partial_bitstring+0x4e0>
test   $0x1,%r8b
je     1645 <fgen_copy_partial_bitstring+0x545>
mov    $0x1,%ebp
mov    %edx,%ecx
shl    %cl,%ebp
mov    %ebp,%ecx
not    %cl
and    %cl,%al
mov    %al,(%rsi,%r9,1)
and    (%rdi,%r9,1),%bpl
or     %al,%bpl
mov    %bpl,(%rsi,%r9,1)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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