void gbyte(char *inchar, unsigned long *iout, unsigned long *iskip,
           unsigned long nbits) {
  long masks[32];
  long icon, index, ii, mover, movel;
  unsigned long temp, mask, inlong;
  masks[0] = 1;
  masks[1] = 3;
  masks[2] = 7;
  masks[3] = 15;
  masks[4] = 31;
  masks[5] = 63;
  masks[6] = 127;
  masks[7] = 255;
  masks[8] = 511;
  masks[9] = 1023;
  masks[10] = 2047;
  masks[11] = 4095;
  masks[12] = 8191;
  masks[13] = 16383;
  masks[14] = 32767;
  masks[15] = 65535;
  masks[16] = 131071;
  masks[17] = 262143;
  masks[18] = 524287;
  masks[19] = 1048575;
  masks[20] = 2097151;
  masks[21] = 4194303;
  masks[22] = 8388607;
  masks[23] = 16777215;
  masks[24] = 33554431;
  masks[25] = 67108863;
  masks[26] = 134217727;
  masks[27] = 268435455;
  masks[28] = 536870911;
  masks[29] = 1073741823;
  masks[30] = 2147483647;
  masks[31] = -1;
  icon = 32 - nbits;
  if (icon < 0) {
    return;
  }
  mask = masks[nbits - 1];
  index = *iskip / 32;
  ii = *iskip % 32;
  mover = icon - ii;
  if (mover > 0) {
    {
      unsigned long l0, l1, l2, l3;
      l0 = (unsigned long)inchar[index * 4] << 24;
      l1 = (unsigned long)(0x000000FF & inchar[index * 4 + 1]) << 16;
      l2 = (unsigned long)(0x000000FF & inchar[index * 4 + 2]) << 8;
      l3 = (unsigned long)(0x000000FF & inchar[index * 4 + 3]);
      inlong = l0 + l1 + l2 + l3;
    }
    *iout = inlong >> mover;
    *iout = (*iout & mask);
  } else if (mover < 0) {
    movel = -mover;
    mover = 32 - movel;
    {
      unsigned long l0, l1, l2, l3;
      l0 = (unsigned long)(0x000000FF & inchar[index * 4]) << 24;
      l1 = (unsigned long)(0x000000FF & inchar[index * 4 + 1]) << 16;
      l2 = (unsigned long)(0x000000FF & inchar[index * 4 + 2]) << 8;
      l3 = (unsigned long)(0x000000FF & inchar[index * 4 + 3]);
      inlong = l0 + l1 + l2 + l3;
    }
    *iout = inlong << movel;
    {
      unsigned long l0, l1, l2, l3;
      l0 = (unsigned long)(0x000000FF & inchar[index * 4 + 4]) << 24;
      l1 = (unsigned long)(0x000000FF & inchar[index * 4 + 5]) << 16;
      l2 = (unsigned long)(0x000000FF & inchar[index * 4 + 6]) << 8;
      l3 = (unsigned long)(0x000000FF & inchar[index * 4 + 7]);
      inlong = l0 + l1 + l2 + l3;
    }
    temp = inlong >> mover;
    *iout = *iout | temp;
    *iout &= mask;
  } else {
    {
      unsigned long l0, l1, l2, l3;
      l0 = (unsigned long)(0x000000FF & inchar[index * 4]) << 24;
      l1 = (unsigned long)(0x000000FF & inchar[index * 4 + 1]) << 16;
      l2 = (unsigned long)(0x000000FF & inchar[index * 4 + 2]) << 8;
      l3 = (unsigned long)(0x000000FF & inchar[index * 4 + 3]);
      inlong = l0 + l1 + l2 + l3;
    }
    *iout = inlong & mask;
  }
  {};
  *iskip += nbits;
}


x86 assembly (clang, -O0):
<gbyte>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x1,-0x120(%rbp)
movq   $0x3,-0x118(%rbp)
movq   $0x7,-0x110(%rbp)
movq   $0xf,-0x108(%rbp)
movq   $0x1f,-0x100(%rbp)
movq   $0x3f,-0xf8(%rbp)
movq   $0x7f,-0xf0(%rbp)
movq   $0xff,-0xe8(%rbp)
movq   $0x1ff,-0xe0(%rbp)
movq   $0x3ff,-0xd8(%rbp)
movq   $0x7ff,-0xd0(%rbp)
movq   $0xfff,-0xc8(%rbp)
movq   $0x1fff,-0xc0(%rbp)
movq   $0x3fff,-0xb8(%rbp)
movq   $0x7fff,-0xb0(%rbp)
movq   $0xffff,-0xa8(%rbp)
movq   $0x1ffff,-0xa0(%rbp)
movq   $0x3ffff,-0x98(%rbp)
movq   $0x7ffff,-0x90(%rbp)
movq   $0xfffff,-0x88(%rbp)
movq   $0x1fffff,-0x80(%rbp)
movq   $0x3fffff,-0x78(%rbp)
movq   $0x7fffff,-0x70(%rbp)
movq   $0xffffff,-0x68(%rbp)
movq   $0x1ffffff,-0x60(%rbp)
01
movq   $0x3ffffff,-0x58(%rbp)
03
movq   $0x7ffffff,-0x50(%rbp)
07
movq   $0xfffffff,-0x48(%rbp)
0f
movq   $0x1fffffff,-0x40(%rbp)
1f
movq   $0x3fffffff,-0x38(%rbp)
3f
movq   $0x7fffffff,-0x30(%rbp)
7f
movq   $0xffffffffffffffff,-0x28(%rbp)
ff
mov    $0x20,%eax
sub    -0x20(%rbp),%rax
mov    %rax,-0x128(%rbp)
cmpq   $0x0,-0x128(%rbp)
jge    127a <gbyte+0x17a>
jmp    1697 <gbyte+0x597>
mov    -0x20(%rbp),%rax
sub    $0x1,%rax
mov    -0x120(%rbp,%rax,8),%rax
ff
mov    %rax,-0x158(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
shr    $0x5,%rax
mov    %rax,-0x130(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
and    $0x1f,%rax
mov    %rax,-0x138(%rbp)
mov    -0x128(%rbp),%rax
sub    -0x138(%rbp),%rax
mov    %rax,-0x140(%rbp)
cmpq   $0x0,-0x140(%rbp)
jle    13bd <gbyte+0x2bd>
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbq (%rax,%rcx,1),%rax
shl    $0x18,%rax
mov    %rax,-0x168(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x1(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x10,%rax
mov    %rax,-0x170(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x2(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x8,%rax
mov    %rax,-0x178(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x3(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
mov    %rax,-0x180(%rbp)
mov    -0x168(%rbp),%rax
add    -0x170(%rbp),%rax
add    -0x178(%rbp),%rax
add    -0x180(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    -0x140(%rbp),%rcx
shr    %cl,%rax
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
and    -0x158(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
jmp    1689 <gbyte+0x589>
cmpq   $0x0,-0x140(%rbp)
jge    15b9 <gbyte+0x4b9>
xor    %eax,%eax
sub    -0x140(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    $0x20,%eax
sub    -0x148(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x18,%rax
mov    %rax,-0x188(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x1(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x10,%rax
mov    %rax,-0x190(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x2(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x8,%rax
mov    %rax,-0x198(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x3(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
mov    %rax,-0x1a0(%rbp)
mov    -0x188(%rbp),%rax
add    -0x190(%rbp),%rax
add    -0x198(%rbp),%rax
add    -0x1a0(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    -0x148(%rbp),%rcx
shl    %cl,%rax
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x4(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x18,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x5(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x10,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x6(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x8,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x7(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
mov    %rax,-0x1c0(%rbp)
mov    -0x1a8(%rbp),%rax
add    -0x1b0(%rbp),%rax
add    -0x1b8(%rbp),%rax
add    -0x1c0(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    -0x140(%rbp),%rcx
shr    %cl,%rax
mov    %rax,-0x150(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
or     -0x150(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x158(%rbp),%rcx
mov    -0x10(%rbp),%rax
and    (%rax),%rcx
mov    %rcx,(%rax)
jmp    1684 <gbyte+0x584>
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x18,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x1(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x10,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x2(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
shl    $0x8,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x130(%rbp),%rcx
shl    $0x2,%rcx
movsbl 0x3(%rax,%rcx,1),%eax
and    $0xff,%eax
cltq
mov    %rax,-0x1e0(%rbp)
mov    -0x1c8(%rbp),%rax
add    -0x1d0(%rbp),%rax
add    -0x1d8(%rbp),%rax
add    -0x1e0(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rcx
and    -0x158(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
jmp    1689 <gbyte+0x589>
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gbyte>:
push   %rbx
sub    $0x80,%rsp
movaps 0xef1(%rip),%xmm0
movaps %xmm0,-0x80(%rsp)
movaps 0xef5(%rip),%xmm0
movaps %xmm0,-0x70(%rsp)
movaps 0xef9(%rip),%xmm0
movaps %xmm0,-0x60(%rsp)
movaps 0xefd(%rip),%xmm0
movaps %xmm0,-0x50(%rsp)
movaps 0xf01(%rip),%xmm0
movaps %xmm0,-0x40(%rsp)
movaps 0xf05(%rip),%xmm0
movaps %xmm0,-0x30(%rsp)
movaps 0xf09(%rip),%xmm0
movaps %xmm0,-0x20(%rsp)
movaps 0xf0d(%rip),%xmm0
movaps %xmm0,-0x10(%rsp)
movaps 0xf11(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0xf16(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xf1a(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xf1e(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xf22(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xf26(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xf2a(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xf2e(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
mov    $0x20,%ebx
sub    %rcx,%rbx
js     1269 <gbyte+0x169>
mov    %rcx,%r8
mov    -0x88(%rsp,%rcx,8),%r9
ff
mov    (%rdx),%rcx
mov    %rcx,%r10
shr    $0x5,%r10
and    $0x1f,%ecx
sub    %rcx,%rbx
jle    1225 <gbyte+0x125>
movsbq (%rdi,%r10,4),%r11
shl    $0x18,%r11
movzbl 0x1(%rdi,%r10,4),%ecx
shl    $0x10,%rcx
or     %r11,%rcx
movzbl 0x2(%rdi,%r10,4),%eax
shl    $0x8,%rax
or     %rcx,%rax
movzbl 0x3(%rdi,%r10,4),%edi
or     %rax,%rdi
mov    %ebx,%ecx
shr    %cl,%rdi
jmp    1260 <gbyte+0x160>
js     1234 <gbyte+0x134>
mov    (%rdi,%r10,4),%edi
shl    $0x20,%rdi
bswap  %rdi
jmp    1260 <gbyte+0x160>
mov    (%rdi,%r10,4),%eax
shl    $0x20,%rax
bswap  %rax
mov    %ebx,%ecx
neg    %cl
shl    %cl,%rax
mov    %rax,(%rsi)
mov    0x4(%rdi,%r10,4),%edi
shl    $0x20,%rdi
bswap  %rdi
add    $0x20,%bl
mov    %ebx,%ecx
shr    %cl,%rdi
or     %rax,%rdi
and    %r9,%rdi
mov    %rdi,(%rsi)
add    %r8,(%rdx)
add    $0x80,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @gbyte(i8* %0, i64* %1, i64* %2, i64 %3) {
%5 = alloca i8*
%6 = alloca i64*
%7 = alloca i64*
%8 = alloca i64
%9 = alloca [32 x i64]
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca i64
%33 = alloca i64
store i8* %0, i8** %5
store i64* %1, i64** %6
store i64* %2, i64** %7
store i64 %3, i64* %8
%34 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 0
store i64 1, i64* %34
%35 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 1
store i64 3, i64* %35
%36 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 2
store i64 7, i64* %36
%37 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 3
store i64 15, i64* %37
%38 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 4
store i64 31, i64* %38
%39 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 5
store i64 63, i64* %39
%40 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 6
store i64 127, i64* %40
%41 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 7
store i64 255, i64* %41
%42 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 8
store i64 511, i64* %42
%43 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 9
store i64 1023, i64* %43
%44 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 10
store i64 2047, i64* %44
%45 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 11
store i64 4095, i64* %45
%46 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 12
store i64 8191, i64* %46
%47 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 13
store i64 16383, i64* %47
%48 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 14
store i64 32767, i64* %48
%49 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 15
store i64 65535, i64* %49
%50 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 16
store i64 131071, i64* %50
%51 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 17
store i64 262143, i64* %51
%52 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 18
store i64 524287, i64* %52
%53 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 19
store i64 1048575, i64* %53
%54 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 20
store i64 2097151, i64* %54
%55 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 21
store i64 4194303, i64* %55
%56 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 22
store i64 8388607, i64* %56
%57 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 23
store i64 16777215, i64* %57
%58 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 24
store i64 33554431, i64* %58
%59 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 25
store i64 67108863, i64* %59
%60 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 26
store i64 134217727, i64* %60
%61 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 27
store i64 268435455, i64* %61
%62 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 28
store i64 536870911, i64* %62
%63 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 29
store i64 1073741823, i64* %63
%64 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 30
store i64 2147483647, i64* %64
%65 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 31
store i64 -1, i64* %65
%66 = load i64, i64* %8
%67 = sub i64 32, %66
store i64 %67, i64* %10
%68 = load i64, i64* %10
%69 = icmp slt i64 %68, 0
br i1 %69, label %70, label %71
70: ; preds = %4
br label %311
71: ; preds = %4
%72 = load i64, i64* %8
%73 = sub i64 %72, 1
%74 = getelementptr inbounds [32 x i64], [32 x i64]* %9, i64 0, i64 %73
%75 = load i64, i64* %74
store i64 %75, i64* %16
%76 = load i64*, i64** %7
%77 = load i64, i64* %76
%78 = udiv i64 %77, 32
store i64 %78, i64* %11
%79 = load i64*, i64** %7
%80 = load i64, i64* %79
%81 = urem i64 %80, 32
store i64 %81, i64* %12
%82 = load i64, i64* %10
%83 = load i64, i64* %12
%84 = sub nsw i64 %82, %83
store i64 %84, i64* %13
%85 = load i64, i64* %13
%86 = icmp sgt i64 %85, 0
br i1 %86, label %87, label %140
87: ; preds = %71
%88 = load i8*, i8** %5
%89 = load i64, i64* %11
%90 = mul nsw i64 %89, 4
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i64
%94 = shl i64 %93, 24
store i64 %94, i64* %18
%95 = load i8*, i8** %5
%96 = load i64, i64* %11
%97 = mul nsw i64 %96, 4
%98 = add nsw i64 %97, 1
%99 = getelementptr inbounds i8, i8* %95, i64 %98
%100 = load i8, i8* %99
%101 = sext i8 %100 to i32
%102 = and i32 255, %101
%103 = sext i32 %102 to i64
%104 = shl i64 %103, 16
store i64 %104, i64* %19
%105 = load i8*, i8** %5
%106 = load i64, i64* %11
%107 = mul nsw i64 %106, 4
%108 = add nsw i64 %107, 2
%109 = getelementptr inbounds i8, i8* %105, i64 %108
%110 = load i8, i8* %109
%111 = sext i8 %110 to i32
%112 = and i32 255, %111
%113 = sext i32 %112 to i64
%114 = shl i64 %113, 8
store i64 %114, i64* %20
%115 = load i8*, i8** %5
%116 = load i64, i64* %11
%117 = mul nsw i64 %116, 4
%118 = add nsw i64 %117, 3
%119 = getelementptr inbounds i8, i8* %115, i64 %118
%120 = load i8, i8* %119
%121 = sext i8 %120 to i32
%122 = and i32 255, %121
%123 = sext i32 %122 to i64
store i64 %123, i64* %21
%124 = load i64, i64* %18
%125 = load i64, i64* %19
%126 = add i64 %124, %125
%127 = load i64, i64* %20
%128 = add i64 %126, %127
%129 = load i64, i64* %21
%130 = add i64 %128, %129
store i64 %130, i64* %17
%131 = load i64, i64* %17
%132 = load i64, i64* %13
%133 = lshr i64 %131, %132
%134 = load i64*, i64** %6
store i64 %133, i64* %134
%135 = load i64*, i64** %6
%136 = load i64, i64* %135
%137 = load i64, i64* %16
%138 = and i64 %136, %137
%139 = load i64*, i64** %6
store i64 %138, i64* %139
br label %306
140: ; preds = %71
%141 = load i64, i64* %13
%142 = icmp slt i64 %141, 0
br i1 %142, label %143, label %255
143: ; preds = %140
%144 = load i64, i64* %13
%145 = sub nsw i64 0, %144
store i64 %145, i64* %14
%146 = load i64, i64* %14
%147 = sub nsw i64 32, %146
store i64 %147, i64* %13
%148 = load i8*, i8** %5
%149 = load i64, i64* %11
%150 = mul nsw i64 %149, 4
%151 = getelementptr inbounds i8, i8* %148, i64 %150
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = and i32 255, %153
%155 = sext i32 %154 to i64
%156 = shl i64 %155, 24
store i64 %156, i64* %22
%157 = load i8*, i8** %5
%158 = load i64, i64* %11
%159 = mul nsw i64 %158, 4
%160 = add nsw i64 %159, 1
%161 = getelementptr inbounds i8, i8* %157, i64 %160
%162 = load i8, i8* %161
%163 = sext i8 %162 to i32
%164 = and i32 255, %163
%165 = sext i32 %164 to i64
%166 = shl i64 %165, 16
store i64 %166, i64* %23
%167 = load i8*, i8** %5
%168 = load i64, i64* %11
%169 = mul nsw i64 %168, 4
%170 = add nsw i64 %169, 2
%171 = getelementptr inbounds i8, i8* %167, i64 %170
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = and i32 255, %173
%175 = sext i32 %174 to i64
%176 = shl i64 %175, 8
store i64 %176, i64* %24
%177 = load i8*, i8** %5
%178 = load i64, i64* %11
%179 = mul nsw i64 %178, 4
%180 = add nsw i64 %179, 3
%181 = getelementptr inbounds i8, i8* %177, i64 %180
%182 = load i8, i8* %181
%183 = sext i8 %182 to i32
%184 = and i32 255, %183
%185 = sext i32 %184 to i64
store i64 %185, i64* %25
%186 = load i64, i64* %22
%187 = load i64, i64* %23
%188 = add i64 %186, %187
%189 = load i64, i64* %24
%190 = add i64 %188, %189
%191 = load i64, i64* %25
%192 = add i64 %190, %191
store i64 %192, i64* %17
%193 = load i64, i64* %17
%194 = load i64, i64* %14
%195 = shl i64 %193, %194
%196 = load i64*, i64** %6
store i64 %195, i64* %196
%197 = load i8*, i8** %5
%198 = load i64, i64* %11
%199 = mul nsw i64 %198, 4
%200 = add nsw i64 %199, 4
%201 = getelementptr inbounds i8, i8* %197, i64 %200
%202 = load i8, i8* %201
%203 = sext i8 %202 to i32
%204 = and i32 255, %203
%205 = sext i32 %204 to i64
%206 = shl i64 %205, 24
store i64 %206, i64* %26
%207 = load i8*, i8** %5
%208 = load i64, i64* %11
%209 = mul nsw i64 %208, 4
%210 = add nsw i64 %209, 5
%211 = getelementptr inbounds i8, i8* %207, i64 %210
%212 = load i8, i8* %211
%213 = sext i8 %212 to i32
%214 = and i32 255, %213
%215 = sext i32 %214 to i64
%216 = shl i64 %215, 16
store i64 %216, i64* %27
%217 = load i8*, i8** %5
%218 = load i64, i64* %11
%219 = mul nsw i64 %218, 4
%220 = add nsw i64 %219, 6
%221 = getelementptr inbounds i8, i8* %217, i64 %220
%222 = load i8, i8* %221
%223 = sext i8 %222 to i32
%224 = and i32 255, %223
%225 = sext i32 %224 to i64
%226 = shl i64 %225, 8
store i64 %226, i64* %28
%227 = load i8*, i8** %5
%228 = load i64, i64* %11
%229 = mul nsw i64 %228, 4
%230 = add nsw i64 %229, 7
%231 = getelementptr inbounds i8, i8* %227, i64 %230
%232 = load i8, i8* %231
%233 = sext i8 %232 to i32
%234 = and i32 255, %233
%235 = sext i32 %234 to i64
store i64 %235, i64* %29
%236 = load i64, i64* %26
%237 = load i64, i64* %27
%238 = add i64 %236, %237
%239 = load i64, i64* %28
%240 = add i64 %238, %239
%241 = load i64, i64* %29
%242 = add i64 %240, %241
store i64 %242, i64* %17
%243 = load i64, i64* %17
%244 = load i64, i64* %13
%245 = lshr i64 %243, %244
store i64 %245, i64* %15
%246 = load i64*, i64** %6
%247 = load i64, i64* %246
%248 = load i64, i64* %15
%249 = or i64 %247, %248
%250 = load i64*, i64** %6
store i64 %249, i64* %250
%251 = load i64, i64* %16
%252 = load i64*, i64** %6
%253 = load i64, i64* %252
%254 = and i64 %253, %251
store i64 %254, i64* %252
br label %305
255: ; preds = %140
%256 = load i8*, i8** %5
%257 = load i64, i64* %11
%258 = mul nsw i64 %257, 4
%259 = getelementptr inbounds i8, i8* %256, i64 %258
%260 = load i8, i8* %259
%261 = sext i8 %260 to i32
%262 = and i32 255, %261
%263 = sext i32 %262 to i64
%264 = shl i64 %263, 24
store i64 %264, i64* %30
%265 = load i8*, i8** %5
%266 = load i64, i64* %11
%267 = mul nsw i64 %266, 4
%268 = add nsw i64 %267, 1
%269 = getelementptr inbounds i8, i8* %265, i64 %268
%270 = load i8, i8* %269
%271 = sext i8 %270 to i32
%272 = and i32 255, %271
%273 = sext i32 %272 to i64
%274 = shl i64 %273, 16
store i64 %274, i64* %31
%275 = load i8*, i8** %5
%276 = load i64, i64* %11
%277 = mul nsw i64 %276, 4
%278 = add nsw i64 %277, 2
%279 = getelementptr inbounds i8, i8* %275, i64 %278
%280 = load i8, i8* %279
%281 = sext i8 %280 to i32
%282 = and i32 255, %281
%283 = sext i32 %282 to i64
%284 = shl i64 %283, 8
store i64 %284, i64* %32
%285 = load i8*, i8** %5
%286 = load i64, i64* %11
%287 = mul nsw i64 %286, 4
%288 = add nsw i64 %287, 3
%289 = getelementptr inbounds i8, i8* %285, i64 %288
%290 = load i8, i8* %289
%291 = sext i8 %290 to i32
%292 = and i32 255, %291
%293 = sext i32 %292 to i64
store i64 %293, i64* %33
%294 = load i64, i64* %30
%295 = load i64, i64* %31
%296 = add i64 %294, %295
%297 = load i64, i64* %32
%298 = add i64 %296, %297
%299 = load i64, i64* %33
%300 = add i64 %298, %299
store i64 %300, i64* %17
%301 = load i64, i64* %17
%302 = load i64, i64* %16
%303 = and i64 %301, %302
%304 = load i64*, i64** %6
store i64 %303, i64* %304
br label %305
305: ; preds = %255, %143
br label %306
306: ; preds = %305, %87
%307 = load i64, i64* %8
%308 = load i64*, i64** %7
%309 = load i64, i64* %308
%310 = add i64 %309, %307
store i64 %310, i64* %308
br label %311
311: ; preds = %306, %70
ret void
}

LLVM IR (-O2):
define void @gbyte(i8* nocapture %0, i64* nocapture writeonly %1, i64* nocapture %2, i64 %3) {
%5 = alloca [32 x i64]
%6 = bitcast [32 x i64]* %5 to i8*
%7 = bitcast [32 x i64]* %5 to <2 x i64>*
store <2 x i64> <i64 1, i64 3>, <2 x i64>* %7
%8 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 2
%9 = bitcast i64* %8 to <2 x i64>*
store <2 x i64> <i64 7, i64 15>, <2 x i64>* %9
%10 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 4
%11 = bitcast i64* %10 to <2 x i64>*
store <2 x i64> <i64 31, i64 63>, <2 x i64>* %11
%12 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 6
%13 = bitcast i64* %12 to <2 x i64>*
store <2 x i64> <i64 127, i64 255>, <2 x i64>* %13
%14 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 8
%15 = bitcast i64* %14 to <2 x i64>*
store <2 x i64> <i64 511, i64 1023>, <2 x i64>* %15
%16 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 10
%17 = bitcast i64* %16 to <2 x i64>*
store <2 x i64> <i64 2047, i64 4095>, <2 x i64>* %17
%18 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 12
%19 = bitcast i64* %18 to <2 x i64>*
store <2 x i64> <i64 8191, i64 16383>, <2 x i64>* %19
%20 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 14
%21 = bitcast i64* %20 to <2 x i64>*
store <2 x i64> <i64 32767, i64 65535>, <2 x i64>* %21
%22 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 16
%23 = bitcast i64* %22 to <2 x i64>*
store <2 x i64> <i64 131071, i64 262143>, <2 x i64>* %23
%24 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 18
%25 = bitcast i64* %24 to <2 x i64>*
store <2 x i64> <i64 524287, i64 1048575>, <2 x i64>* %25
%26 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 20
%27 = bitcast i64* %26 to <2 x i64>*
store <2 x i64> <i64 2097151, i64 4194303>, <2 x i64>* %27
%28 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 22
%29 = bitcast i64* %28 to <2 x i64>*
store <2 x i64> <i64 8388607, i64 16777215>, <2 x i64>* %29
%30 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 24
%31 = bitcast i64* %30 to <2 x i64>*
store <2 x i64> <i64 33554431, i64 67108863>, <2 x i64>* %31
%32 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 26
%33 = bitcast i64* %32 to <2 x i64>*
store <2 x i64> <i64 134217727, i64 268435455>, <2 x i64>* %33
%34 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 28
%35 = bitcast i64* %34 to <2 x i64>*
store <2 x i64> <i64 536870911, i64 1073741823>, <2 x i64>* %35
%36 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 30
%37 = bitcast i64* %36 to <2 x i64>*
store <2 x i64> <i64 2147483647, i64 -1>, <2 x i64>* %37
%38 = sub i64 32, %3
%39 = icmp slt i64 %38, 0
br i1 %39, label %153, label %40
40: ; preds = %4
%41 = add i64 %3, -1
%42 = getelementptr inbounds [32 x i64], [32 x i64]* %5, i64 0, i64 %41
%43 = load i64, i64* %42
%44 = load i64, i64* %2
%45 = lshr i64 %44, 5
%46 = and i64 %44, 31
%47 = sub nsw i64 %38, %46
%48 = icmp sgt i64 %47, 0
br i1 %48, label %49, label %73
49: ; preds = %40
%50 = shl nuw nsw i64 %45, 2
%51 = getelementptr inbounds i8, i8* %0, i64 %50
%52 = load i8, i8* %51
%53 = sext i8 %52 to i64
%54 = shl nsw i64 %53, 24
%55 = or i64 %50, 1
%56 = getelementptr inbounds i8, i8* %0, i64 %55
%57 = load i8, i8* %56
%58 = zext i8 %57 to i64
%59 = shl nuw nsw i64 %58, 16
%60 = or i64 %50, 2
%61 = getelementptr inbounds i8, i8* %0, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i64
%64 = shl nuw nsw i64 %63, 8
%65 = or i64 %50, 3
%66 = getelementptr inbounds i8, i8* %0, i64 %65
%67 = load i8, i8* %66
%68 = zext i8 %67 to i64
%69 = or i64 %59, %54
%70 = or i64 %69, %64
%71 = or i64 %70, %68
%72 = lshr i64 %71, %47
br label %148
73: ; preds = %40
%74 = icmp slt i64 %47, 0
br i1 %74, label %75, label %125
75: ; preds = %73
%76 = sub nsw i64 0, %47
%77 = add nsw i64 %47, 32
%78 = shl nuw nsw i64 %45, 2
%79 = getelementptr inbounds i8, i8* %0, i64 %78
%80 = load i8, i8* %79
%81 = zext i8 %80 to i64
%82 = shl nuw nsw i64 %81, 24
%83 = or i64 %78, 1
%84 = getelementptr inbounds i8, i8* %0, i64 %83
%85 = load i8, i8* %84
%86 = zext i8 %85 to i64
%87 = shl nuw nsw i64 %86, 16
%88 = or i64 %78, 2
%89 = getelementptr inbounds i8, i8* %0, i64 %88
%90 = load i8, i8* %89
%91 = zext i8 %90 to i64
%92 = shl nuw nsw i64 %91, 8
%93 = or i64 %78, 3
%94 = getelementptr inbounds i8, i8* %0, i64 %93
%95 = load i8, i8* %94
%96 = zext i8 %95 to i64
%97 = or i64 %87, %82
%98 = or i64 %97, %92
%99 = or i64 %98, %96
%100 = shl i64 %99, %76
store i64 %100, i64* %1
%101 = add nuw nsw i64 %78, 4
%102 = getelementptr inbounds i8, i8* %0, i64 %101
%103 = load i8, i8* %102
%104 = zext i8 %103 to i64
%105 = shl nuw nsw i64 %104, 24
%106 = add nuw nsw i64 %78, 5
%107 = getelementptr inbounds i8, i8* %0, i64 %106
%108 = load i8, i8* %107
%109 = zext i8 %108 to i64
%110 = shl nuw nsw i64 %109, 16
%111 = add nuw nsw i64 %78, 6
%112 = getelementptr inbounds i8, i8* %0, i64 %111
%113 = load i8, i8* %112
%114 = zext i8 %113 to i64
%115 = shl nuw nsw i64 %114, 8
%116 = add nuw nsw i64 %78, 7
%117 = getelementptr inbounds i8, i8* %0, i64 %116
%118 = load i8, i8* %117
%119 = zext i8 %118 to i64
%120 = or i64 %110, %105
%121 = or i64 %120, %115
%122 = or i64 %121, %119
%123 = lshr i64 %122, %77
%124 = or i64 %123, %100
br label %148
125: ; preds = %73
%126 = shl nuw nsw i64 %45, 2
%127 = getelementptr inbounds i8, i8* %0, i64 %126
%128 = load i8, i8* %127
%129 = zext i8 %128 to i64
%130 = shl nuw nsw i64 %129, 24
%131 = or i64 %126, 1
%132 = getelementptr inbounds i8, i8* %0, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i64
%135 = shl nuw nsw i64 %134, 16
%136 = or i64 %126, 2
%137 = getelementptr inbounds i8, i8* %0, i64 %136
%138 = load i8, i8* %137
%139 = zext i8 %138 to i64
%140 = shl nuw nsw i64 %139, 8
%141 = or i64 %126, 3
%142 = getelementptr inbounds i8, i8* %0, i64 %141
%143 = load i8, i8* %142
%144 = zext i8 %143 to i64
%145 = or i64 %135, %130
%146 = or i64 %145, %140
%147 = or i64 %146, %144
br label %148
148: ; preds = %75, %125, %49
%149 = phi i64 [ %124, %75 ], [ %147, %125 ], [ %72, %49 ]
%150 = and i64 %149, %43
store i64 %150, i64* %1
%151 = load i64, i64* %2
%152 = add i64 %151, %3
store i64 %152, i64* %2
br label %153
153: ; preds = %4, %148
ret void
}