void copybits(unsigned char *in, int from, short nb) {
  unsigned char *f;
  short bits;
  static unsigned char *out;
  static short x, shift;
  static unsigned char right[9] = {0x00, 0x01, 0x03, 0x07, 0x0f,
                                   0x1f, 0x3f, 0x7f, 0xff};
  if (!nb) {
    if (in)
      out = in;
    else {
      x = (x << (-shift)) | (0);
      shift += (-shift);
      if (shift >= 0) {
        *out++ = x >> shift;
        shift -= 8;
      }
    };
    x = 0;
    shift = -8;
  } else {
    f = in + (from >> 3);
    bits = 8 - (from & 7);
    if (nb >= bits) {
      {
        x = (x << (bits)) | (*f++ & right[bits]);
        shift += (bits);
        if (shift >= 0) {
          *out++ = x >> shift;
          shift -= 8;
        }
      };
      nb -= bits;
    } else {
      {
        x = (x << (nb)) | ((*f >> (bits - nb)) & right[bits]);
        shift += (nb);
        if (shift >= 0) {
          *out++ = x >> shift;
          shift -= 8;
        }
      };
      nb = 0;
    }
    while (nb >= 8) {
      {
        x = (x << (8)) | (*f++);
        shift += (8);
        if (shift >= 0) {
          *out++ = x >> shift;
          shift -= 8;
        }
      };
      nb -= 8;
    }
    if (nb > 0) {
      x = (x << (nb)) | (*f >> (8 - nb));
      shift += (nb);
      if (shift >= 0) {
        *out++ = x >> shift;
        shift -= 8;
      }
    };
  }
}


x86 assembly (clang, -O0):
<copybits>:
push   %rbp
mov    %rsp,%rbp
mov    %dx,%ax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %ax,-0xe(%rbp)
cmpw   $0x0,-0xe(%rbp)
jne    11d7 <copybits+0xd7>
cmpq   $0x0,-0x8(%rbp)
je     1138 <copybits+0x38>
mov    -0x8(%rbp),%rax
mov    %rax,0x2f05(%rip)
jmp    11c0 <copybits+0xc0>
movswl 0x2f01(%rip),%eax
movswl 0x2efc(%rip),%edx
xor    %ecx,%ecx
sub    %edx,%ecx
shl    %cl,%eax
or     $0x0,%eax
mov    %ax,0x2eea(%rip)
movswl 0x2ee5(%rip),%eax
xor    %ecx,%ecx
sub    %eax,%ecx
movswl 0x2eda(%rip),%eax
add    %ecx,%eax
mov    %ax,0x2ed1(%rip)
movswl 0x2eca(%rip),%eax
cmp    $0x0,%eax
jl     11bb <copybits+0xbb>
movswl 0x2eb8(%rip),%eax
movswl 0x2eb3(%rip),%ecx
sar    %cl,%eax
mov    %al,%cl
mov    0x2e9e(%rip),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x2e90(%rip)
mov    %cl,(%rax)
movswl 0x2e91(%rip),%eax
sub    $0x8,%eax
mov    %ax,0x2e87(%rip)
jmp    11c0 <copybits+0xc0>
movw   $0x0,0x2e77(%rip)
movw   $0xfff8,0x2e70(%rip)
f8 ff
jmp    149b <copybits+0x39b>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sar    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0xc(%rbp),%ecx
and    $0x7,%ecx
mov    $0x8,%eax
sub    %ecx,%eax
mov    %ax,-0x1a(%rbp)
movswl -0xe(%rbp),%eax
movswl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jl     12b7 <copybits+0x1b7>
movswl 0x2e2d(%rip),%eax
movswl -0x1a(%rbp),%ecx
shl    %cl,%eax
mov    -0x18(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
movzbl (%rcx),%ecx
movswq -0x1a(%rbp),%rsi
lea    0x2de9(%rip),%rdx
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %ax,0x2dfa(%rip)
movswl -0x1a(%rbp),%ecx
movswl 0x2df1(%rip),%eax
add    %ecx,%eax
mov    %ax,0x2de8(%rip)
movswl 0x2de1(%rip),%eax
cmp    $0x0,%eax
jl     12a4 <copybits+0x1a4>
movswl 0x2dcf(%rip),%eax
movswl 0x2dca(%rip),%ecx
sar    %cl,%eax
mov    %al,%cl
mov    0x2db5(%rip),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x2da7(%rip)
mov    %cl,(%rax)
movswl 0x2da8(%rip),%eax
sub    $0x8,%eax
mov    %ax,0x2d9e(%rip)
movswl -0x1a(%rbp),%ecx
movswl -0xe(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0xe(%rbp)
jmp    1358 <copybits+0x258>
movswl 0x2d82(%rip),%eax
movswl -0xe(%rbp),%ecx
shl    %cl,%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%edx
movswl -0x1a(%rbp),%ecx
movswl -0xe(%rbp),%esi
sub    %esi,%ecx
sar    %cl,%edx
mov    %edx,%ecx
movswq -0x1a(%rbp),%rsi
lea    0x2d3b(%rip),%rdx
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %ax,0x2d4c(%rip)
movswl -0xe(%rbp),%ecx
movswl 0x2d43(%rip),%eax
add    %ecx,%eax
mov    %ax,0x2d3a(%rip)
movswl 0x2d33(%rip),%eax
cmp    $0x0,%eax
jl     1352 <copybits+0x252>
movswl 0x2d21(%rip),%eax
movswl 0x2d1c(%rip),%ecx
sar    %cl,%eax
mov    %al,%cl
mov    0x2d07(%rip),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x2cf9(%rip)
mov    %cl,(%rax)
movswl 0x2cfa(%rip),%eax
sub    $0x8,%eax
mov    %ax,0x2cf0(%rip)
movw   $0x0,-0xe(%rbp)
jmp    135d <copybits+0x25d>
movswl -0xe(%rbp),%eax
cmp    $0x8,%eax
jl     13fa <copybits+0x2fa>
movswl 0x2ccf(%rip),%eax
shl    $0x8,%eax
mov    -0x18(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %ax,0x2cb1(%rip)
movswl 0x2cac(%rip),%eax
add    $0x8,%eax
mov    %ax,0x2ca2(%rip)
movswl 0x2c9b(%rip),%eax
cmp    $0x0,%eax
jl     13ea <copybits+0x2ea>
movswl 0x2c89(%rip),%eax
movswl 0x2c84(%rip),%ecx
sar    %cl,%eax
mov    %al,%cl
mov    0x2c6f(%rip),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x2c61(%rip)
mov    %cl,(%rax)
movswl 0x2c62(%rip),%eax
sub    $0x8,%eax
mov    %ax,0x2c58(%rip)
movswl -0xe(%rbp),%eax
sub    $0x8,%eax
mov    %ax,-0xe(%rbp)
jmp    135d <copybits+0x25d>
movswl -0xe(%rbp),%eax
cmp    $0x0,%eax
jle    1496 <copybits+0x396>
movswl 0x2c32(%rip),%eax
movswl -0xe(%rbp),%ecx
shl    %cl,%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%edx
movswl -0xe(%rbp),%esi
mov    $0x8,%ecx
sub    %esi,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,0x2c0d(%rip)
movswl -0xe(%rbp),%ecx
movswl 0x2c04(%rip),%eax
add    %ecx,%eax
mov    %ax,0x2bfb(%rip)
movswl 0x2bf4(%rip),%eax
cmp    $0x0,%eax
jl     1491 <copybits+0x391>
movswl 0x2be2(%rip),%eax
movswl 0x2bdd(%rip),%ecx
sar    %cl,%eax
mov    %al,%cl
mov    0x2bc8(%rip),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x2bba(%rip)
mov    %cl,(%rax)
movswl 0x2bbb(%rip),%eax
sub    $0x8,%eax
mov    %ax,0x2bb1(%rip)
jmp    1496 <copybits+0x396>
jmp    149b <copybits+0x39b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<copybits>:
test   %dx,%dx
je     1191 <copybits+0x91>
mov    %esi,%eax
sar    $0x3,%eax
cltq
add    %rax,%rdi
and    $0x7,%esi
mov    $0x8,%r9d
sub    %rsi,%r9
movswl %dx,%ecx
mov    %ecx,%eax
movzwl 0x2f04(%rip),%r8d
sub    %r9d,%eax
jge    11a6 <copybits+0xa6>
shl    %cl,%r8d
movzbl (%rdi),%esi
mov    %r9d,%eax
sub    %ecx,%r9d
mov    %r9d,%ecx
shr    %cl,%esi
lea    0xeb7(%rip),%rcx
movzbl (%rax,%rcx,1),%eax
and    %esi,%eax
or     %r8d,%eax
mov    %ax,0x2ed7(%rip)
add    0x2ed2(%rip),%dx
mov    %dx,0x2ecb(%rip)
js     1225 <copybits+0x125>
cwtl
mov    %edx,%ecx
sar    %cl,%eax
mov    0x2eaf(%rip),%rcx
lea    0x1(%rcx),%rsi
mov    %rsi,0x2ea4(%rip)
mov    %al,(%rcx)
lea    -0x8(%rdx),%eax
mov    %ax,0x2ea2(%rip)
ret
test   %rdi,%rdi
je     12da <copybits+0x1da>
mov    %rdi,0x2e87(%rip)
jmp    12ff <copybits+0x1ff>
mov    %r9d,%ecx
shl    %cl,%r8d
movzbl (%rdi),%ecx
lea    0xe4a(%rip),%rdx
movzbl (%r9,%rdx,1),%esi
and    %ecx,%esi
or     %r8d,%esi
mov    %si,0x2e69(%rip)
movzwl 0x2e63(%rip),%r8d
add    %r9w,%r8w
mov    %r8w,0x2e57(%rip)
js     1206 <copybits+0x106>
movswl %si,%edx
mov    %r8d,%ecx
sar    %cl,%edx
mov    0x2e3c(%rip),%r9
lea    0x1(%r9),%rcx
mov    %rcx,0x2e31(%rip)
mov    %dl,(%r9)
add    $0xfffffff8,%r8d
mov    %r8w,0x2e2c(%rip)
add    $0x1,%rdi
mov    0x2e17(%rip),%r9
mov    %eax,%ecx
shl    $0x10,%ecx
movswl %ax,%edx
cmp    $0x70001,%ecx
jge    125e <copybits+0x15e>
test   %ecx,%ecx
jg     128a <copybits+0x18a>
ret
cs nopw 0x0(%rax,%rax,1)
mov    %esi,%eax
sar    %cl,%eax
lea    0x1(%r9),%rcx
mov    %rcx,0x2de9(%rip)
mov    %al,(%r9)
mov    %rcx,%r9
add    $0x1,%rdi
mov    %edx,%eax
add    $0xfffffff8,%eax
mov    %eax,%ecx
shl    $0x10,%ecx
movswl %ax,%edx
cmp    $0x70000,%ecx
jle    1277 <copybits+0x177>
shl    $0x8,%esi
movzbl (%rdi),%eax
movswl %si,%esi
or     %eax,%esi
mov    %r8d,%ecx
add    $0x8,%cx
jns    1230 <copybits+0x130>
mov    %ecx,%r8d
jmp    1245 <copybits+0x145>
mov    %si,0x2db2(%rip)
mov    %r8w,0x2dac(%rip)
test   %ecx,%ecx
jle    1225 <copybits+0x125>
movzwl %si,%r10d
mov    %edx,%ecx
shl    %cl,%r10d
movzbl (%rdi),%esi
mov    $0x8,%cl
sub    %dl,%cl
shr    %cl,%esi
or     %r10d,%esi
mov    %si,0x2d8a(%rip)
add    %ax,%r8w
mov    %r8w,0x2d80(%rip)
js     1225 <copybits+0x125>
movswl %si,%eax
mov    %r8d,%ecx
sar    %cl,%eax
lea    0x1(%r9),%rcx
mov    %rcx,0x2d5d(%rip)
mov    %al,(%r9)
lea    -0x8(%r8),%eax
mov    %ax,0x2d59(%rip)
ret
xor    %ecx,%ecx
sub    0x2d50(%rip),%cl
movzwl 0x2d47(%rip),%eax
shl    %cl,%eax
mov    0x2d36(%rip),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x2d2b(%rip)
mov    %al,(%rcx)
movw   $0x0,0x2d28(%rip)
mov    $0xfff8,%ax
mov    %ax,0x2d1f(%rip)
ret

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

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