void IntegerUnpacker_8(void *stream, void *dst, int nbits, int nbitt, int n,
                       int offset) {
  unsigned int *packed = (unsigned int *)stream;
  char *unpacked = (char *)dst;
  unsigned long long temp;
  unsigned int token, token1, token2, token3;
  int bleft;
  int signed_offset = 0;
  if (nbits > 8 || nbitt > nbits)
    return;
  packed += offset / 32;
  bleft = 32 - (offset % 32);
  token = *packed++;
  if (nbits == -1)
    signed_offset = -(1 << (nbitt - 1));
  if (bleft == 32) {
    if (nbits == 8) {
      while (n > 7) {
        *unpacked++ = ((token >> 24));
        *unpacked++ = ((token >> 16) & 0xFF);
        *unpacked++ = ((token >> 8) & 0xFF);
        *unpacked++ = (token & 0xFF);
        token = *packed++;
        *unpacked++ = ((token >> 24));
        *unpacked++ = ((token >> 16) & 0xFF);
        *unpacked++ = ((token >> 8) & 0xFF);
        *unpacked++ = (token & 0xFF);
        token = *packed++;
        n -= 8;
      }
    }
    if (nbits == 6) {
      while (n > 15) {
        token2 = *packed++;
        token3 = *packed++;
        token1 = *packed++;
        *unpacked++ = ((token >> 26));
        *unpacked++ = ((token >> 20) & 0x3F);
        *unpacked++ = ((token >> 14) & 0x3F);
        *unpacked++ = ((token >> 8) & 0x3F);
        *unpacked++ = ((token >> 2) & 0x3F);
        *unpacked++ = (((token & 0x3) << 4) | (token2 >> 28));
        *unpacked++ = ((token2 >> 22) & 0x3F);
        *unpacked++ = ((token2 >> 16) & 0x3F);
        *unpacked++ = ((token2 >> 10) & 0x3F);
        *unpacked++ = ((token2 >> 4) & 0x3F);
        *unpacked++ = (((token2 & 0xF) << 2) | (token3 >> 30));
        *unpacked++ = ((token3 >> 24) & 0x3F);
        *unpacked++ = ((token3 >> 18) & 0x3F);
        *unpacked++ = ((token3 >> 12) & 0x3F);
        *unpacked++ = ((token3 >> 6) & 0x3F);
        *unpacked++ = (token3 & 0x3F);
        token = token1;
        n -= 16;
      }
    }
    if (nbits == 4) {
      while (n > 7) {
        *unpacked++ = ((token >> 28));
        *unpacked++ = ((token >> 24) & 0xF);
        *unpacked++ = ((token >> 20) & 0xF);
        *unpacked++ = ((token >> 16) & 0xF);
        *unpacked++ = ((token >> 12) & 0xF);
        *unpacked++ = ((token >> 8) & 0xF);
        *unpacked++ = ((token >> 4) & 0xF);
        *unpacked++ = (token & 0xF);
        token = *packed++;
        n -= 8;
      }
    }
    if (nbits == 2) {
      while (n > 15) {
        *unpacked++ = ((token >> 30));
        *unpacked++ = ((token >> 28) & 0x3);
        *unpacked++ = ((token >> 26) & 0x3);
        *unpacked++ = ((token >> 24) & 0x3);
        *unpacked++ = ((token >> 22) & 0x3);
        *unpacked++ = ((token >> 20) & 0x3);
        *unpacked++ = ((token >> 18) & 0x3);
        *unpacked++ = ((token >> 16) & 0x3);
        *unpacked++ = ((token >> 14) & 0x3);
        *unpacked++ = ((token >> 12) & 0x3);
        *unpacked++ = ((token >> 10) & 0x3);
        *unpacked++ = ((token >> 8) & 0x3);
        *unpacked++ = ((token >> 6) & 0x3);
        *unpacked++ = ((token >> 4) & 0x3);
        *unpacked++ = ((token >> 2) & 0x3);
        *unpacked++ = (token & 0x3);
        token = *packed++;
        n -= 16;
      }
    }
    if (nbits == 1) {
      while (n > 31) {
        *unpacked++ = ((token >> 31) & 1);
        *unpacked++ = ((token >> 30) & 1);
        *unpacked++ = ((token >> 29) & 1);
        *unpacked++ = ((token >> 28) & 1);
        *unpacked++ = ((token >> 27) & 1);
        *unpacked++ = ((token >> 26) & 1);
        *unpacked++ = ((token >> 25) & 1);
        *unpacked++ = ((token >> 24) & 1);
        *unpacked++ = ((token >> 23) & 1);
        *unpacked++ = ((token >> 22) & 1);
        *unpacked++ = ((token >> 21) & 1);
        *unpacked++ = ((token >> 20) & 1);
        *unpacked++ = ((token >> 19) & 1);
        *unpacked++ = ((token >> 18) & 1);
        *unpacked++ = ((token >> 17) & 1);
        *unpacked++ = ((token >> 16) & 1);
        *unpacked++ = ((token >> 15) & 1);
        *unpacked++ = ((token >> 14) & 1);
        *unpacked++ = ((token >> 13) & 1);
        *unpacked++ = ((token >> 12) & 1);
        *unpacked++ = ((token >> 11) & 1);
        *unpacked++ = ((token >> 10) & 1);
        *unpacked++ = ((token >> 9) & 1);
        *unpacked++ = ((token >> 8) & 1);
        *unpacked++ = ((token >> 7) & 1);
        *unpacked++ = ((token >> 6) & 1);
        *unpacked++ = ((token >> 5) & 1);
        *unpacked++ = ((token >> 4) & 1);
        *unpacked++ = ((token >> 3) & 1);
        *unpacked++ = ((token >> 2) & 1);
        *unpacked++ = ((token >> 1) & 1);
        *unpacked++ = (token & 1);
        token = *packed++;
        n -= 32;
      }
    }
  }
  temp = token;
  temp <<= 32;
  temp |= *packed++;
  if (bleft < 32)
    temp <<= (32 - bleft);
  while (n > 3) {
    *unpacked++ = (temp >> (64 - nbits));
    temp <<= nbits;
    bleft -= nbits;
    *unpacked++ = (temp >> (64 - nbits));
    temp <<= nbits;
    bleft -= nbits;
    *unpacked++ = (temp >> (64 - nbits));
    temp <<= nbits;
    bleft -= nbits;
    *unpacked++ = (temp >> (64 - nbits));
    temp <<= nbits;
    bleft -= nbits;
    if (bleft <= 0) {
      token = *packed++;
      if (bleft == 0) {
        temp |= token;
      } else {
        temp = temp >> (-bleft);
        temp |= token;
        temp <<= (-bleft);
      }
      bleft += 32;
    }
    n -= 4;
  }
  while (n-- > 0) {
    *unpacked++ = (temp >> (64 - nbits));
    temp <<= nbits;
    bleft -= nbits;
    if (bleft <= 0) {
      token = *packed++;
      if (bleft == 0) {
        temp |= token;
      } else {
        temp = temp >> (-bleft);
        temp |= token;
        temp <<= (-bleft);
      }
      bleft += 32;
    }
  }
}


x86 assembly (clang, -O0):
<IntegerUnpacker_8>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x8,-0x14(%rbp)
jg     1147 <IntegerUnpacker_8+0x47>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    114c <IntegerUnpacker_8+0x4c>
jmp    1ea1 <IntegerUnpacker_8+0xda1>
mov    -0x20(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    $0x20,%eax
sub    %edx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0xffffffff,-0x14(%rbp)
jne    11b4 <IntegerUnpacker_8+0xb4>
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x20,-0x4c(%rbp)
jne    1c00 <IntegerUnpacker_8+0xb00>
cmpl   $0x8,-0x14(%rbp)
jne    12f2 <IntegerUnpacker_8+0x1f2>
jmp    11cd <IntegerUnpacker_8+0xcd>
cmpl   $0x7,-0x1c(%rbp)
jle    12ed <IntegerUnpacker_8+0x1ed>
mov    -0x3c(%rbp),%eax
shr    $0x18,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shr    $0x18,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x1c(%rbp)
jmp    11cd <IntegerUnpacker_8+0xcd>
jmp    12f2 <IntegerUnpacker_8+0x1f2>
cmpl   $0x6,-0x14(%rbp)
jne    152a <IntegerUnpacker_8+0x42a>
jmp    1301 <IntegerUnpacker_8+0x201>
cmpl   $0xf,-0x1c(%rbp)
jle    1525 <IntegerUnpacker_8+0x425>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
shr    $0x1a,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x14,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xe,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x2,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
and    $0x3,%eax
shl    $0x4,%eax
mov    -0x44(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
shr    $0x16,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
shr    $0x10,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
shr    $0xa,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
shr    $0x4,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
and    $0xf,%eax
shl    $0x2,%eax
mov    -0x48(%rbp),%ecx
shr    $0x1e,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
shr    $0x18,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
shr    $0x12,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
shr    $0xc,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
shr    $0x6,%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
and    $0x3f,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x1c(%rbp)
jmp    1301 <IntegerUnpacker_8+0x201>
jmp    152a <IntegerUnpacker_8+0x42a>
cmpl   $0x4,-0x14(%rbp)
jne    1644 <IntegerUnpacker_8+0x544>
jmp    1539 <IntegerUnpacker_8+0x439>
cmpl   $0x7,-0x1c(%rbp)
jle    163f <IntegerUnpacker_8+0x53f>
mov    -0x3c(%rbp),%eax
shr    $0x1c,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x18,%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x14,%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x10,%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xc,%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x4,%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
and    $0xf,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x1c(%rbp)
jmp    1539 <IntegerUnpacker_8+0x439>
jmp    1644 <IntegerUnpacker_8+0x544>
cmpl   $0x2,-0x14(%rbp)
jne    183e <IntegerUnpacker_8+0x73e>
jmp    1653 <IntegerUnpacker_8+0x553>
cmpl   $0xf,-0x1c(%rbp)
jle    1839 <IntegerUnpacker_8+0x739>
mov    -0x3c(%rbp),%eax
shr    $0x1e,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1c,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1a,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x18,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x16,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x14,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x12,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x10,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xe,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xc,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xa,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x6,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x4,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x2,%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
and    $0x3,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x1c(%rbp)
jmp    1653 <IntegerUnpacker_8+0x553>
jmp    183e <IntegerUnpacker_8+0x73e>
cmpl   $0x1,-0x14(%rbp)
jne    1bfb <IntegerUnpacker_8+0xafb>
jmp    184d <IntegerUnpacker_8+0x74d>
cmpl   $0x1f,-0x1c(%rbp)
jle    1bf6 <IntegerUnpacker_8+0xaf6>
mov    -0x3c(%rbp),%eax
shr    $0x1f,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1e,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1d,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1c,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1b,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1a,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x19,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x18,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x17,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x16,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x15,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x14,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x13,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x12,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x11,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x10,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xf,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xe,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xd,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xc,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xb,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0xa,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x9,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x7,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x6,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x5,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x4,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x3,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x2,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x1,%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
and    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x20,%eax
mov    %eax,-0x1c(%rbp)
jmp    184d <IntegerUnpacker_8+0x74d>
jmp    1bfb <IntegerUnpacker_8+0xafb>
jmp    1c00 <IntegerUnpacker_8+0xb00>
mov    -0x3c(%rbp),%eax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x20,-0x4c(%rbp)
jge    1c4b <IntegerUnpacker_8+0xb4b>
mov    $0x20,%ecx
sub    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
jmp    1c50 <IntegerUnpacker_8+0xb50>
cmpl   $0x3,-0x1c(%rbp)
jle    1dd4 <IntegerUnpacker_8+0xcd4>
mov    -0x38(%rbp),%rax
mov    $0x40,%ecx
sub    -0x14(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x38(%rbp),%rax
mov    $0x40,%ecx
sub    -0x14(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x38(%rbp),%rax
mov    $0x40,%ecx
sub    -0x14(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x38(%rbp),%rax
mov    $0x40,%ecx
sub    -0x14(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jg     1dc6 <IntegerUnpacker_8+0xcc6>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1d8e <IntegerUnpacker_8+0xc8e>
mov    -0x3c(%rbp),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1dbd <IntegerUnpacker_8+0xcbd>
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x4c(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
xor    %ecx,%ecx
sub    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    1c50 <IntegerUnpacker_8+0xb50>
jmp    1dd9 <IntegerUnpacker_8+0xcd9>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1ea1 <IntegerUnpacker_8+0xda1>
mov    -0x38(%rbp),%rax
mov    $0x40,%ecx
sub    -0x14(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jg     1e9c <IntegerUnpacker_8+0xd9c>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1e64 <IntegerUnpacker_8+0xd64>
mov    -0x3c(%rbp),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1e93 <IntegerUnpacker_8+0xd93>
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x4c(%rbp),%ecx
mov    %ecx,%ecx
shr    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
xor    %ecx,%ecx
sub    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x4c(%rbp)
jmp    1dd9 <IntegerUnpacker_8+0xcd9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<IntegerUnpacker_8>:
push   %rbp
push   %r14
push   %rbx
cmp    $0x8,%edx
jg     16c2 <IntegerUnpacker_8+0x5c2>
cmp    %edx,%ecx
jg     16c2 <IntegerUnpacker_8+0x5c2>
lea    0x1f(%r9),%ecx
test   %r9d,%r9d
cmovns %r9d,%ecx
mov    %ecx,%eax
sar    $0x5,%eax
cltq
and    $0xffffffe0,%ecx
lea    (%rdi,%rax,4),%r10
add    $0x4,%r10
mov    (%rdi,%rax,4),%eax
mov    $0x20,%r11d
sub    %ecx,%r9d
jne    158c <IntegerUnpacker_8+0x48c>
cmp    $0x8,%edx
jne    1179 <IntegerUnpacker_8+0x79>
cmp    $0x8,%r8d
jl     1179 <IntegerUnpacker_8+0x79>
nop
mov    %r8d,%ecx
bswap  %eax
mov    %eax,(%rsi)
mov    (%r10),%eax
bswap  %eax
mov    %eax,0x4(%rsi)
add    $0x8,%rsi
mov    0x4(%r10),%eax
add    $0x8,%r10
lea    -0x8(%rcx),%r8d
cmp    $0xf,%ecx
ja     1150 <IntegerUnpacker_8+0x50>
jmp    158c <IntegerUnpacker_8+0x48c>
cmp    $0x6,%edx
jne    1263 <IntegerUnpacker_8+0x163>
cmp    $0x10,%r8d
jl     1263 <IntegerUnpacker_8+0x163>
nopl   0x0(%rax)
mov    %r8d,%r14d
mov    %eax,%edi
mov    (%r10),%ebp
mov    0x4(%r10),%r8d
mov    0x8(%r10),%eax
add    $0xc,%r10
mov    %edi,%ebx
shr    $0x1a,%ebx
mov    %bl,(%rsi)
mov    %edi,%ecx
shr    $0x14,%ecx
and    $0x3f,%cl
mov    %cl,0x1(%rsi)
mov    %edi,%ecx
shr    $0xe,%ecx
and    $0x3f,%cl
mov    %cl,0x2(%rsi)
mov    %edi,%ecx
shr    $0x8,%ecx
and    $0x3f,%cl
mov    %cl,0x3(%rsi)
mov    %edi,%ecx
shr    $0x2,%cl
shld   $0x4,%ebp,%edi
mov    %cl,0x4(%rsi)
and    $0x3f,%dil
mov    %dil,0x5(%rsi)
mov    %ebp,%ecx
shr    $0x16,%ecx
and    $0x3f,%cl
mov    %cl,0x6(%rsi)
mov    %ebp,%ecx
shr    $0x10,%ecx
and    $0x3f,%cl
mov    %cl,0x7(%rsi)
mov    %ebp,%ecx
shr    $0xa,%ecx
and    $0x3f,%cl
mov    %cl,0x8(%rsi)
mov    %ebp,%ecx
shr    $0x4,%ecx
and    $0x3f,%cl
shld   $0x2,%r8d,%ebp
mov    %cl,0x9(%rsi)
and    $0x3f,%bpl
mov    %bpl,0xa(%rsi)
mov    %r8d,%ecx
shr    $0x18,%ecx
and    $0x3f,%cl
mov    %cl,0xb(%rsi)
mov    %r8d,%ecx
shr    $0x12,%ecx
and    $0x3f,%cl
mov    %cl,0xc(%rsi)
mov    %r8d,%ecx
shr    $0xc,%ecx
and    $0x3f,%cl
mov    %cl,0xd(%rsi)
mov    %r8d,%ecx
shr    $0x6,%ecx
and    $0x3f,%cl
mov    %cl,0xe(%rsi)
and    $0x3f,%r8b
mov    %r8b,0xf(%rsi)
add    $0x10,%rsi
lea    -0x10(%r14),%r8d
cmp    $0x1f,%r14d
ja     1190 <IntegerUnpacker_8+0x90>
cmp    $0x4,%edx
jne    12e2 <IntegerUnpacker_8+0x1e2>
cmp    $0x8,%r8d
jl     12e2 <IntegerUnpacker_8+0x1e2>
xchg   %ax,%ax
mov    %r8d,%ecx
mov    %eax,%edi
shr    $0x1c,%edi
mov    %dil,(%rsi)
mov    %eax,%edi
shr    $0x18,%edi
and    $0xf,%dil
mov    %dil,0x1(%rsi)
mov    %eax,%edi
shr    $0x14,%edi
and    $0xf,%dil
mov    %dil,0x2(%rsi)
mov    %eax,%edi
shr    $0x10,%edi
and    $0xf,%dil
mov    %dil,0x3(%rsi)
mov    %eax,%edi
shr    $0xc,%edi
and    $0xf,%dil
mov    %dil,0x4(%rsi)
mov    %eax,%edi
shr    $0x8,%edi
and    $0xf,%dil
mov    %dil,0x5(%rsi)
mov    %eax,%ebx
shr    $0x4,%bl
mov    %bl,0x6(%rsi)
and    $0xf,%al
mov    %al,0x7(%rsi)
add    $0x8,%rsi
mov    (%r10),%eax
add    $0x4,%r10
lea    -0x8(%rcx),%r8d
cmp    $0xf,%ecx
ja     1270 <IntegerUnpacker_8+0x170>
jmp    158c <IntegerUnpacker_8+0x48c>
cmp    $0x2,%edx
jne    13da <IntegerUnpacker_8+0x2da>
cmp    $0x10,%r8d
jl     13da <IntegerUnpacker_8+0x2da>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8d,%ecx
mov    %eax,%edi
shr    $0x1e,%edi
mov    %dil,(%rsi)
mov    %eax,%edi
shr    $0x1c,%edi
and    $0x3,%dil
mov    %dil,0x1(%rsi)
mov    %eax,%edi
shr    $0x1a,%edi
and    $0x3,%dil
mov    %dil,0x2(%rsi)
mov    %eax,%edi
shr    $0x18,%edi
and    $0x3,%dil
mov    %dil,0x3(%rsi)
mov    %eax,%edi
shr    $0x16,%edi
and    $0x3,%dil
mov    %dil,0x4(%rsi)
mov    %eax,%edi
shr    $0x14,%edi
and    $0x3,%dil
mov    %dil,0x5(%rsi)
mov    %eax,%edi
shr    $0x12,%edi
and    $0x3,%dil
mov    %dil,0x6(%rsi)
mov    %eax,%edi
shr    $0x10,%edi
and    $0x3,%dil
mov    %dil,0x7(%rsi)
mov    %eax,%edi
shr    $0xe,%edi
and    $0x3,%dil
mov    %dil,0x8(%rsi)
mov    %eax,%edi
shr    $0xc,%edi
and    $0x3,%dil
mov    %dil,0x9(%rsi)
mov    %eax,%edi
shr    $0xa,%edi
and    $0x3,%dil
mov    %dil,0xa(%rsi)
mov    %eax,%edi
shr    $0x8,%edi
and    $0x3,%dil
mov    %dil,0xb(%rsi)
mov    %eax,%ebx
shr    $0x6,%bl
mov    %bl,0xc(%rsi)
mov    %eax,%ebx
shr    $0x4,%bl
and    $0x3,%bl
mov    %bl,0xd(%rsi)
mov    %eax,%ebx
shr    $0x2,%bl
and    $0x3,%bl
mov    %bl,0xe(%rsi)
and    $0x3,%al
mov    %al,0xf(%rsi)
add    $0x10,%rsi
mov    (%r10),%eax
add    $0x4,%r10
lea    -0x10(%rcx),%r8d
cmp    $0x1f,%ecx
ja     1300 <IntegerUnpacker_8+0x200>
jmp    158c <IntegerUnpacker_8+0x48c>
cmp    $0x1,%edx
jne    158c <IntegerUnpacker_8+0x48c>
cmp    $0x20,%r8d
jl     158c <IntegerUnpacker_8+0x48c>
mov    %r8d,%ecx
mov    %eax,%edi
shr    $0x1f,%edi
mov    %dil,(%rsi)
mov    %eax,%edi
shr    $0x1e,%edi
and    $0x1,%dil
mov    %dil,0x1(%rsi)
mov    %eax,%edi
shr    $0x1d,%edi
and    $0x1,%dil
mov    %dil,0x2(%rsi)
mov    %eax,%edi
shr    $0x1c,%edi
and    $0x1,%dil
mov    %dil,0x3(%rsi)
mov    %eax,%edi
shr    $0x1b,%edi
and    $0x1,%dil
mov    %dil,0x4(%rsi)
mov    %eax,%edi
shr    $0x1a,%edi
and    $0x1,%dil
mov    %dil,0x5(%rsi)
mov    %eax,%edi
shr    $0x19,%edi
and    $0x1,%dil
mov    %dil,0x6(%rsi)
mov    %eax,%edi
shr    $0x18,%edi
and    $0x1,%dil
mov    %dil,0x7(%rsi)
mov    %eax,%edi
shr    $0x17,%edi
and    $0x1,%dil
mov    %dil,0x8(%rsi)
mov    %eax,%edi
shr    $0x16,%edi
and    $0x1,%dil
mov    %dil,0x9(%rsi)
mov    %eax,%edi
shr    $0x15,%edi
and    $0x1,%dil
mov    %dil,0xa(%rsi)
mov    %eax,%edi
shr    $0x14,%edi
and    $0x1,%dil
mov    %dil,0xb(%rsi)
mov    %eax,%edi
shr    $0x13,%edi
and    $0x1,%dil
mov    %dil,0xc(%rsi)
mov    %eax,%edi
shr    $0x12,%edi
and    $0x1,%dil
mov    %dil,0xd(%rsi)
mov    %eax,%edi
shr    $0x11,%edi
and    $0x1,%dil
mov    %dil,0xe(%rsi)
mov    %eax,%edi
shr    $0x10,%edi
and    $0x1,%dil
mov    %dil,0xf(%rsi)
mov    %eax,%edi
shr    $0xf,%edi
and    $0x1,%dil
mov    %dil,0x10(%rsi)
mov    %eax,%edi
shr    $0xe,%edi
and    $0x1,%dil
mov    %dil,0x11(%rsi)
mov    %eax,%edi
shr    $0xd,%edi
and    $0x1,%dil
mov    %dil,0x12(%rsi)
mov    %eax,%edi
shr    $0xc,%edi
and    $0x1,%dil
mov    %dil,0x13(%rsi)
mov    %eax,%edi
shr    $0xb,%edi
and    $0x1,%dil
mov    %dil,0x14(%rsi)
mov    %eax,%edi
shr    $0xa,%edi
and    $0x1,%dil
mov    %dil,0x15(%rsi)
mov    %eax,%edi
shr    $0x9,%edi
and    $0x1,%dil
mov    %dil,0x16(%rsi)
mov    %eax,%edi
shr    $0x8,%edi
and    $0x1,%dil
mov    %dil,0x17(%rsi)
mov    %eax,%ebx
shr    $0x7,%bl
mov    %bl,0x18(%rsi)
mov    %eax,%ebx
shr    $0x6,%bl
and    $0x1,%bl
mov    %bl,0x19(%rsi)
mov    %eax,%ebx
shr    $0x5,%bl
and    $0x1,%bl
mov    %bl,0x1a(%rsi)
mov    %eax,%ebx
shr    $0x4,%bl
and    $0x1,%bl
mov    %bl,0x1b(%rsi)
mov    %eax,%ebx
shr    $0x3,%bl
and    $0x1,%bl
mov    %bl,0x1c(%rsi)
mov    %eax,%ebx
shr    $0x2,%bl
and    $0x1,%bl
mov    %bl,0x1d(%rsi)
mov    %eax,%ebx
shr    %bl
and    $0x1,%bl
mov    %bl,0x1e(%rsi)
and    $0x1,%al
mov    %al,0x1f(%rsi)
add    $0x20,%rsi
mov    (%r10),%eax
add    $0x4,%r10
lea    -0x20(%rcx),%r8d
cmp    $0x3f,%ecx
mov    %r8d,%ecx
ja     13f0 <IntegerUnpacker_8+0x2f0>
sub    %r9d,%r11d
shl    $0x20,%rax
mov    (%r10),%edi
add    $0x4,%r10
or     %rax,%rdi
xor    %ecx,%ecx
test   %r9d,%r9d
cmovg  %r9d,%ecx
shl    %cl,%rdi
mov    %edx,%r9d
cmp    $0x4,%r8d
jl     164f <IntegerUnpacker_8+0x54f>
mov    $0x40,%ebx
sub    %edx,%ebx
lea    0x0(,%rdx,4),%r14d
neg    %r14d
jmp    15f7 <IntegerUnpacker_8+0x4f7>
nopw   0x0(%rax,%rax,1)
mov    %r11d,%ecx
neg    %cl
shr    %cl,%rdi
or     %rax,%rdi
shl    %cl,%rdi
add    $0x4,%r10
add    $0x20,%r11d
lea    -0x4(%r8),%eax
lea    0x4(%rbp),%rsi
cmp    $0x7,%r8d
mov    %eax,%r8d
jbe    1658 <IntegerUnpacker_8+0x558>
mov    %rdi,%rax
mov    %ebx,%ecx
shr    %cl,%rax
mov    %rsi,%rbp
mov    %r9d,%ecx
shl    %cl,%rdi
mov    %al,(%rsi)
mov    %rdi,%rax
mov    %ebx,%ecx
shr    %cl,%rax
add    %r14d,%r11d
mov    %r9d,%ecx
shl    %cl,%rdi
mov    %al,0x1(%rsi)
mov    %rdi,%rax
mov    %ebx,%ecx
shr    %cl,%rax
mov    %al,0x2(%rsi)
mov    %r9d,%ecx
shl    %cl,%rdi
mov    %rdi,%rax
mov    %ebx,%ecx
shr    %cl,%rax
mov    %al,0x3(%rsi)
mov    %r9d,%ecx
shl    %cl,%rdi
test   %r11d,%r11d
jg     15e6 <IntegerUnpacker_8+0x4e6>
mov    (%r10),%eax
jne    15d0 <IntegerUnpacker_8+0x4d0>
or     %rax,%rdi
jmp    15de <IntegerUnpacker_8+0x4de>
mov    %r8d,%eax
test   %eax,%eax
jg     1663 <IntegerUnpacker_8+0x563>
jmp    16c2 <IntegerUnpacker_8+0x5c2>
add    $0x4,%rbp
mov    %rbp,%rsi
test   %eax,%eax
jle    16c2 <IntegerUnpacker_8+0x5c2>
mov    $0x40,%r8d
sub    %edx,%r8d
add    $0x1,%eax
jmp    16a2 <IntegerUnpacker_8+0x5a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11d,%ecx
neg    %cl
shr    %cl,%rdi
or     %rbp,%rdi
shl    %cl,%rdi
add    $0x4,%r10
add    $0x20,%r11d
add    $0x1,%rsi
add    $0xffffffff,%eax
cmp    $0x1,%eax
jbe    16c2 <IntegerUnpacker_8+0x5c2>
mov    %rdi,%rbx
mov    %r8d,%ecx
shr    %cl,%rbx
mov    %bl,(%rsi)
mov    %r9d,%ecx
shl    %cl,%rdi
sub    %edx,%r11d
jg     1696 <IntegerUnpacker_8+0x596>
mov    (%r10),%ebp
jne    1680 <IntegerUnpacker_8+0x580>
or     %rbp,%rdi
jmp    168e <IntegerUnpacker_8+0x58e>
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @IntegerUnpacker_8(i8* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
%14 = alloca i8*
%15 = alloca i64
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store i8* %0, i8** %7
store i8* %1, i8** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%22 = load i8*, i8** %7
%23 = bitcast i8* %22 to i32*
store i32* %23, i32** %13
%24 = load i8*, i8** %8
store i8* %24, i8** %14
store i32 0, i32* %21
%25 = load i32, i32* %9
%26 = icmp sgt i32 %25, 8
br i1 %26, label %31, label %27
27: ; preds = %6
%28 = load i32, i32* %10
%29 = load i32, i32* %9
%30 = icmp sgt i32 %28, %29
br i1 %30, label %31, label %32
31: ; preds = %27, %6
br label %781
32: ; preds = %27
%33 = load i32, i32* %12
%34 = sdiv i32 %33, 32
%35 = load i32*, i32** %13
%36 = sext i32 %34 to i64
%37 = getelementptr inbounds i32, i32* %35, i64 %36
store i32* %37, i32** %13
%38 = load i32, i32* %12
%39 = srem i32 %38, 32
%40 = sub nsw i32 32, %39
store i32 %40, i32* %20
%41 = load i32*, i32** %13
%42 = getelementptr inbounds i32, i32* %41, i32 1
store i32* %42, i32** %13
%43 = load i32, i32* %41
store i32 %43, i32* %16
%44 = load i32, i32* %9
%45 = icmp eq i32 %44, -1
br i1 %45, label %46, label %51
46: ; preds = %32
%47 = load i32, i32* %10
%48 = sub nsw i32 %47, 1
%49 = shl i32 1, %48
%50 = sub nsw i32 0, %49
store i32 %50, i32* %21
br label %51
51: ; preds = %46, %32
%52 = load i32, i32* %20
%53 = icmp eq i32 %52, 32
br i1 %53, label %54, label %610
54: ; preds = %51
%55 = load i32, i32* %9
%56 = icmp eq i32 %55, 8
br i1 %56, label %57, label %115
57: ; preds = %54
br label %58
58: ; preds = %61, %57
%59 = load i32, i32* %11
%60 = icmp sgt i32 %59, 7
br i1 %60, label %61, label %114
61: ; preds = %58
%62 = load i32, i32* %16
%63 = lshr i32 %62, 24
%64 = trunc i32 %63 to i8
%65 = load i8*, i8** %14
%66 = getelementptr inbounds i8, i8* %65, i32 1
store i8* %66, i8** %14
store i8 %64, i8* %65
%67 = load i32, i32* %16
%68 = lshr i32 %67, 16
%69 = and i32 %68, 255
%70 = trunc i32 %69 to i8
%71 = load i8*, i8** %14
%72 = getelementptr inbounds i8, i8* %71, i32 1
store i8* %72, i8** %14
store i8 %70, i8* %71
%73 = load i32, i32* %16
%74 = lshr i32 %73, 8
%75 = and i32 %74, 255
%76 = trunc i32 %75 to i8
%77 = load i8*, i8** %14
%78 = getelementptr inbounds i8, i8* %77, i32 1
store i8* %78, i8** %14
store i8 %76, i8* %77
%79 = load i32, i32* %16
%80 = and i32 %79, 255
%81 = trunc i32 %80 to i8
%82 = load i8*, i8** %14
%83 = getelementptr inbounds i8, i8* %82, i32 1
store i8* %83, i8** %14
store i8 %81, i8* %82
%84 = load i32*, i32** %13
%85 = getelementptr inbounds i32, i32* %84, i32 1
store i32* %85, i32** %13
%86 = load i32, i32* %84
store i32 %86, i32* %16
%87 = load i32, i32* %16
%88 = lshr i32 %87, 24
%89 = trunc i32 %88 to i8
%90 = load i8*, i8** %14
%91 = getelementptr inbounds i8, i8* %90, i32 1
store i8* %91, i8** %14
store i8 %89, i8* %90
%92 = load i32, i32* %16
%93 = lshr i32 %92, 16
%94 = and i32 %93, 255
%95 = trunc i32 %94 to i8
%96 = load i8*, i8** %14
%97 = getelementptr inbounds i8, i8* %96, i32 1
store i8* %97, i8** %14
store i8 %95, i8* %96
%98 = load i32, i32* %16
%99 = lshr i32 %98, 8
%100 = and i32 %99, 255
%101 = trunc i32 %100 to i8
%102 = load i8*, i8** %14
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %14
store i8 %101, i8* %102
%104 = load i32, i32* %16
%105 = and i32 %104, 255
%106 = trunc i32 %105 to i8
%107 = load i8*, i8** %14
%108 = getelementptr inbounds i8, i8* %107, i32 1
store i8* %108, i8** %14
store i8 %106, i8* %107
%109 = load i32*, i32** %13
%110 = getelementptr inbounds i32, i32* %109, i32 1
store i32* %110, i32** %13
%111 = load i32, i32* %109
store i32 %111, i32* %16
%112 = load i32, i32* %11
%113 = sub nsw i32 %112, 8
store i32 %113, i32* %11
br label %58
114: ; preds = %58
br label %115
115: ; preds = %114, %54
%116 = load i32, i32* %9
%117 = icmp eq i32 %116, 6
br i1 %117, label %118, label %236
118: ; preds = %115
br label %119
119: ; preds = %122, %118
%120 = load i32, i32* %11
%121 = icmp sgt i32 %120, 15
br i1 %121, label %122, label %235
122: ; preds = %119
%123 = load i32*, i32** %13
%124 = getelementptr inbounds i32, i32* %123, i32 1
store i32* %124, i32** %13
%125 = load i32, i32* %123
store i32 %125, i32* %18
%126 = load i32*, i32** %13
%127 = getelementptr inbounds i32, i32* %126, i32 1
store i32* %127, i32** %13
%128 = load i32, i32* %126
store i32 %128, i32* %19
%129 = load i32*, i32** %13
%130 = getelementptr inbounds i32, i32* %129, i32 1
store i32* %130, i32** %13
%131 = load i32, i32* %129
store i32 %131, i32* %17
%132 = load i32, i32* %16
%133 = lshr i32 %132, 26
%134 = trunc i32 %133 to i8
%135 = load i8*, i8** %14
%136 = getelementptr inbounds i8, i8* %135, i32 1
store i8* %136, i8** %14
store i8 %134, i8* %135
%137 = load i32, i32* %16
%138 = lshr i32 %137, 20
%139 = and i32 %138, 63
%140 = trunc i32 %139 to i8
%141 = load i8*, i8** %14
%142 = getelementptr inbounds i8, i8* %141, i32 1
store i8* %142, i8** %14
store i8 %140, i8* %141
%143 = load i32, i32* %16
%144 = lshr i32 %143, 14
%145 = and i32 %144, 63
%146 = trunc i32 %145 to i8
%147 = load i8*, i8** %14
%148 = getelementptr inbounds i8, i8* %147, i32 1
store i8* %148, i8** %14
store i8 %146, i8* %147
%149 = load i32, i32* %16
%150 = lshr i32 %149, 8
%151 = and i32 %150, 63
%152 = trunc i32 %151 to i8
%153 = load i8*, i8** %14
%154 = getelementptr inbounds i8, i8* %153, i32 1
store i8* %154, i8** %14
store i8 %152, i8* %153
%155 = load i32, i32* %16
%156 = lshr i32 %155, 2
%157 = and i32 %156, 63
%158 = trunc i32 %157 to i8
%159 = load i8*, i8** %14
%160 = getelementptr inbounds i8, i8* %159, i32 1
store i8* %160, i8** %14
store i8 %158, i8* %159
%161 = load i32, i32* %16
%162 = and i32 %161, 3
%163 = shl i32 %162, 4
%164 = load i32, i32* %18
%165 = lshr i32 %164, 28
%166 = or i32 %163, %165
%167 = trunc i32 %166 to i8
%168 = load i8*, i8** %14
%169 = getelementptr inbounds i8, i8* %168, i32 1
store i8* %169, i8** %14
store i8 %167, i8* %168
%170 = load i32, i32* %18
%171 = lshr i32 %170, 22
%172 = and i32 %171, 63
%173 = trunc i32 %172 to i8
%174 = load i8*, i8** %14
%175 = getelementptr inbounds i8, i8* %174, i32 1
store i8* %175, i8** %14
store i8 %173, i8* %174
%176 = load i32, i32* %18
%177 = lshr i32 %176, 16
%178 = and i32 %177, 63
%179 = trunc i32 %178 to i8
%180 = load i8*, i8** %14
%181 = getelementptr inbounds i8, i8* %180, i32 1
store i8* %181, i8** %14
store i8 %179, i8* %180
%182 = load i32, i32* %18
%183 = lshr i32 %182, 10
%184 = and i32 %183, 63
%185 = trunc i32 %184 to i8
%186 = load i8*, i8** %14
%187 = getelementptr inbounds i8, i8* %186, i32 1
store i8* %187, i8** %14
store i8 %185, i8* %186
%188 = load i32, i32* %18
%189 = lshr i32 %188, 4
%190 = and i32 %189, 63
%191 = trunc i32 %190 to i8
%192 = load i8*, i8** %14
%193 = getelementptr inbounds i8, i8* %192, i32 1
store i8* %193, i8** %14
store i8 %191, i8* %192
%194 = load i32, i32* %18
%195 = and i32 %194, 15
%196 = shl i32 %195, 2
%197 = load i32, i32* %19
%198 = lshr i32 %197, 30
%199 = or i32 %196, %198
%200 = trunc i32 %199 to i8
%201 = load i8*, i8** %14
%202 = getelementptr inbounds i8, i8* %201, i32 1
store i8* %202, i8** %14
store i8 %200, i8* %201
%203 = load i32, i32* %19
%204 = lshr i32 %203, 24
%205 = and i32 %204, 63
%206 = trunc i32 %205 to i8
%207 = load i8*, i8** %14
%208 = getelementptr inbounds i8, i8* %207, i32 1
store i8* %208, i8** %14
store i8 %206, i8* %207
%209 = load i32, i32* %19
%210 = lshr i32 %209, 18
%211 = and i32 %210, 63
%212 = trunc i32 %211 to i8
%213 = load i8*, i8** %14
%214 = getelementptr inbounds i8, i8* %213, i32 1
store i8* %214, i8** %14
store i8 %212, i8* %213
%215 = load i32, i32* %19
%216 = lshr i32 %215, 12
%217 = and i32 %216, 63
%218 = trunc i32 %217 to i8
%219 = load i8*, i8** %14
%220 = getelementptr inbounds i8, i8* %219, i32 1
store i8* %220, i8** %14
store i8 %218, i8* %219
%221 = load i32, i32* %19
%222 = lshr i32 %221, 6
%223 = and i32 %222, 63
%224 = trunc i32 %223 to i8
%225 = load i8*, i8** %14
%226 = getelementptr inbounds i8, i8* %225, i32 1
store i8* %226, i8** %14
store i8 %224, i8* %225
%227 = load i32, i32* %19
%228 = and i32 %227, 63
%229 = trunc i32 %228 to i8
%230 = load i8*, i8** %14
%231 = getelementptr inbounds i8, i8* %230, i32 1
store i8* %231, i8** %14
store i8 %229, i8* %230
%232 = load i32, i32* %17
store i32 %232, i32* %16
%233 = load i32, i32* %11
%234 = sub nsw i32 %233, 16
store i32 %234, i32* %11
br label %119
235: ; preds = %119
br label %236
236: ; preds = %235, %115
%237 = load i32, i32* %9
%238 = icmp eq i32 %237, 4
br i1 %238, label %239, label %296
239: ; preds = %236
br label %240
240: ; preds = %243, %239
%241 = load i32, i32* %11
%242 = icmp sgt i32 %241, 7
br i1 %242, label %243, label %295
243: ; preds = %240
%244 = load i32, i32* %16
%245 = lshr i32 %244, 28
%246 = trunc i32 %245 to i8
%247 = load i8*, i8** %14
%248 = getelementptr inbounds i8, i8* %247, i32 1
store i8* %248, i8** %14
store i8 %246, i8* %247
%249 = load i32, i32* %16
%250 = lshr i32 %249, 24
%251 = and i32 %250, 15
%252 = trunc i32 %251 to i8
%253 = load i8*, i8** %14
%254 = getelementptr inbounds i8, i8* %253, i32 1
store i8* %254, i8** %14
store i8 %252, i8* %253
%255 = load i32, i32* %16
%256 = lshr i32 %255, 20
%257 = and i32 %256, 15
%258 = trunc i32 %257 to i8
%259 = load i8*, i8** %14
%260 = getelementptr inbounds i8, i8* %259, i32 1
store i8* %260, i8** %14
store i8 %258, i8* %259
%261 = load i32, i32* %16
%262 = lshr i32 %261, 16
%263 = and i32 %262, 15
%264 = trunc i32 %263 to i8
%265 = load i8*, i8** %14
%266 = getelementptr inbounds i8, i8* %265, i32 1
store i8* %266, i8** %14
store i8 %264, i8* %265
%267 = load i32, i32* %16
%268 = lshr i32 %267, 12
%269 = and i32 %268, 15
%270 = trunc i32 %269 to i8
%271 = load i8*, i8** %14
%272 = getelementptr inbounds i8, i8* %271, i32 1
store i8* %272, i8** %14
store i8 %270, i8* %271
%273 = load i32, i32* %16
%274 = lshr i32 %273, 8
%275 = and i32 %274, 15
%276 = trunc i32 %275 to i8
%277 = load i8*, i8** %14
%278 = getelementptr inbounds i8, i8* %277, i32 1
store i8* %278, i8** %14
store i8 %276, i8* %277
%279 = load i32, i32* %16
%280 = lshr i32 %279, 4
%281 = and i32 %280, 15
%282 = trunc i32 %281 to i8
%283 = load i8*, i8** %14
%284 = getelementptr inbounds i8, i8* %283, i32 1
store i8* %284, i8** %14
store i8 %282, i8* %283
%285 = load i32, i32* %16
%286 = and i32 %285, 15
%287 = trunc i32 %286 to i8
%288 = load i8*, i8** %14
%289 = getelementptr inbounds i8, i8* %288, i32 1
store i8* %289, i8** %14
store i8 %287, i8* %288
%290 = load i32*, i32** %13
%291 = getelementptr inbounds i32, i32* %290, i32 1
store i32* %291, i32** %13
%292 = load i32, i32* %290
store i32 %292, i32* %16
%293 = load i32, i32* %11
%294 = sub nsw i32 %293, 8
store i32 %294, i32* %11
br label %240
295: ; preds = %240
br label %296
296: ; preds = %295, %236
%297 = load i32, i32* %9
%298 = icmp eq i32 %297, 2
br i1 %298, label %299, label %404
299: ; preds = %296
br label %300
300: ; preds = %303, %299
%301 = load i32, i32* %11
%302 = icmp sgt i32 %301, 15
br i1 %302, label %303, label %403
303: ; preds = %300
%304 = load i32, i32* %16
%305 = lshr i32 %304, 30
%306 = trunc i32 %305 to i8
%307 = load i8*, i8** %14
%308 = getelementptr inbounds i8, i8* %307, i32 1
store i8* %308, i8** %14
store i8 %306, i8* %307
%309 = load i32, i32* %16
%310 = lshr i32 %309, 28
%311 = and i32 %310, 3
%312 = trunc i32 %311 to i8
%313 = load i8*, i8** %14
%314 = getelementptr inbounds i8, i8* %313, i32 1
store i8* %314, i8** %14
store i8 %312, i8* %313
%315 = load i32, i32* %16
%316 = lshr i32 %315, 26
%317 = and i32 %316, 3
%318 = trunc i32 %317 to i8
%319 = load i8*, i8** %14
%320 = getelementptr inbounds i8, i8* %319, i32 1
store i8* %320, i8** %14
store i8 %318, i8* %319
%321 = load i32, i32* %16
%322 = lshr i32 %321, 24
%323 = and i32 %322, 3
%324 = trunc i32 %323 to i8
%325 = load i8*, i8** %14
%326 = getelementptr inbounds i8, i8* %325, i32 1
store i8* %326, i8** %14
store i8 %324, i8* %325
%327 = load i32, i32* %16
%328 = lshr i32 %327, 22
%329 = and i32 %328, 3
%330 = trunc i32 %329 to i8
%331 = load i8*, i8** %14
%332 = getelementptr inbounds i8, i8* %331, i32 1
store i8* %332, i8** %14
store i8 %330, i8* %331
%333 = load i32, i32* %16
%334 = lshr i32 %333, 20
%335 = and i32 %334, 3
%336 = trunc i32 %335 to i8
%337 = load i8*, i8** %14
%338 = getelementptr inbounds i8, i8* %337, i32 1
store i8* %338, i8** %14
store i8 %336, i8* %337
%339 = load i32, i32* %16
%340 = lshr i32 %339, 18
%341 = and i32 %340, 3
%342 = trunc i32 %341 to i8
%343 = load i8*, i8** %14
%344 = getelementptr inbounds i8, i8* %343, i32 1
store i8* %344, i8** %14
store i8 %342, i8* %343
%345 = load i32, i32* %16
%346 = lshr i32 %345, 16
%347 = and i32 %346, 3
%348 = trunc i32 %347 to i8
%349 = load i8*, i8** %14
%350 = getelementptr inbounds i8, i8* %349, i32 1
store i8* %350, i8** %14
store i8 %348, i8* %349
%351 = load i32, i32* %16
%352 = lshr i32 %351, 14
%353 = and i32 %352, 3
%354 = trunc i32 %353 to i8
%355 = load i8*, i8** %14
%356 = getelementptr inbounds i8, i8* %355, i32 1
store i8* %356, i8** %14
store i8 %354, i8* %355
%357 = load i32, i32* %16
%358 = lshr i32 %357, 12
%359 = and i32 %358, 3
%360 = trunc i32 %359 to i8
%361 = load i8*, i8** %14
%362 = getelementptr inbounds i8, i8* %361, i32 1
store i8* %362, i8** %14
store i8 %360, i8* %361
%363 = load i32, i32* %16
%364 = lshr i32 %363, 10
%365 = and i32 %364, 3
%366 = trunc i32 %365 to i8
%367 = load i8*, i8** %14
%368 = getelementptr inbounds i8, i8* %367, i32 1
store i8* %368, i8** %14
store i8 %366, i8* %367
%369 = load i32, i32* %16
%370 = lshr i32 %369, 8
%371 = and i32 %370, 3
%372 = trunc i32 %371 to i8
%373 = load i8*, i8** %14
%374 = getelementptr inbounds i8, i8* %373, i32 1
store i8* %374, i8** %14
store i8 %372, i8* %373
%375 = load i32, i32* %16
%376 = lshr i32 %375, 6
%377 = and i32 %376, 3
%378 = trunc i32 %377 to i8
%379 = load i8*, i8** %14
%380 = getelementptr inbounds i8, i8* %379, i32 1
store i8* %380, i8** %14
store i8 %378, i8* %379
%381 = load i32, i32* %16
%382 = lshr i32 %381, 4
%383 = and i32 %382, 3
%384 = trunc i32 %383 to i8
%385 = load i8*, i8** %14
%386 = getelementptr inbounds i8, i8* %385, i32 1
store i8* %386, i8** %14
store i8 %384, i8* %385
%387 = load i32, i32* %16
%388 = lshr i32 %387, 2
%389 = and i32 %388, 3
%390 = trunc i32 %389 to i8
%391 = load i8*, i8** %14
%392 = getelementptr inbounds i8, i8* %391, i32 1
store i8* %392, i8** %14
store i8 %390, i8* %391
%393 = load i32, i32* %16
%394 = and i32 %393, 3
%395 = trunc i32 %394 to i8
%396 = load i8*, i8** %14
%397 = getelementptr inbounds i8, i8* %396, i32 1
store i8* %397, i8** %14
store i8 %395, i8* %396
%398 = load i32*, i32** %13
%399 = getelementptr inbounds i32, i32* %398, i32 1
store i32* %399, i32** %13
%400 = load i32, i32* %398
store i32 %400, i32* %16
%401 = load i32, i32* %11
%402 = sub nsw i32 %401, 16
store i32 %402, i32* %11
br label %300
403: ; preds = %300
br label %404
404: ; preds = %403, %296
%405 = load i32, i32* %9
%406 = icmp eq i32 %405, 1
br i1 %406, label %407, label %609
407: ; preds = %404
br label %408
408: ; preds = %411, %407
%409 = load i32, i32* %11
%410 = icmp sgt i32 %409, 31
br i1 %410, label %411, label %608
411: ; preds = %408
%412 = load i32, i32* %16
%413 = lshr i32 %412, 31
%414 = and i32 %413, 1
%415 = trunc i32 %414 to i8
%416 = load i8*, i8** %14
%417 = getelementptr inbounds i8, i8* %416, i32 1
store i8* %417, i8** %14
store i8 %415, i8* %416
%418 = load i32, i32* %16
%419 = lshr i32 %418, 30
%420 = and i32 %419, 1
%421 = trunc i32 %420 to i8
%422 = load i8*, i8** %14
%423 = getelementptr inbounds i8, i8* %422, i32 1
store i8* %423, i8** %14
store i8 %421, i8* %422
%424 = load i32, i32* %16
%425 = lshr i32 %424, 29
%426 = and i32 %425, 1
%427 = trunc i32 %426 to i8
%428 = load i8*, i8** %14
%429 = getelementptr inbounds i8, i8* %428, i32 1
store i8* %429, i8** %14
store i8 %427, i8* %428
%430 = load i32, i32* %16
%431 = lshr i32 %430, 28
%432 = and i32 %431, 1
%433 = trunc i32 %432 to i8
%434 = load i8*, i8** %14
%435 = getelementptr inbounds i8, i8* %434, i32 1
store i8* %435, i8** %14
store i8 %433, i8* %434
%436 = load i32, i32* %16
%437 = lshr i32 %436, 27
%438 = and i32 %437, 1
%439 = trunc i32 %438 to i8
%440 = load i8*, i8** %14
%441 = getelementptr inbounds i8, i8* %440, i32 1
store i8* %441, i8** %14
store i8 %439, i8* %440
%442 = load i32, i32* %16
%443 = lshr i32 %442, 26
%444 = and i32 %443, 1
%445 = trunc i32 %444 to i8
%446 = load i8*, i8** %14
%447 = getelementptr inbounds i8, i8* %446, i32 1
store i8* %447, i8** %14
store i8 %445, i8* %446
%448 = load i32, i32* %16
%449 = lshr i32 %448, 25
%450 = and i32 %449, 1
%451 = trunc i32 %450 to i8
%452 = load i8*, i8** %14
%453 = getelementptr inbounds i8, i8* %452, i32 1
store i8* %453, i8** %14
store i8 %451, i8* %452
%454 = load i32, i32* %16
%455 = lshr i32 %454, 24
%456 = and i32 %455, 1
%457 = trunc i32 %456 to i8
%458 = load i8*, i8** %14
%459 = getelementptr inbounds i8, i8* %458, i32 1
store i8* %459, i8** %14
store i8 %457, i8* %458
%460 = load i32, i32* %16
%461 = lshr i32 %460, 23
%462 = and i32 %461, 1
%463 = trunc i32 %462 to i8
%464 = load i8*, i8** %14
%465 = getelementptr inbounds i8, i8* %464, i32 1
store i8* %465, i8** %14
store i8 %463, i8* %464
%466 = load i32, i32* %16
%467 = lshr i32 %466, 22
%468 = and i32 %467, 1
%469 = trunc i32 %468 to i8
%470 = load i8*, i8** %14
%471 = getelementptr inbounds i8, i8* %470, i32 1
store i8* %471, i8** %14
store i8 %469, i8* %470
%472 = load i32, i32* %16
%473 = lshr i32 %472, 21
%474 = and i32 %473, 1
%475 = trunc i32 %474 to i8
%476 = load i8*, i8** %14
%477 = getelementptr inbounds i8, i8* %476, i32 1
store i8* %477, i8** %14
store i8 %475, i8* %476
%478 = load i32, i32* %16
%479 = lshr i32 %478, 20
%480 = and i32 %479, 1
%481 = trunc i32 %480 to i8
%482 = load i8*, i8** %14
%483 = getelementptr inbounds i8, i8* %482, i32 1
store i8* %483, i8** %14
store i8 %481, i8* %482
%484 = load i32, i32* %16
%485 = lshr i32 %484, 19
%486 = and i32 %485, 1
%487 = trunc i32 %486 to i8
%488 = load i8*, i8** %14
%489 = getelementptr inbounds i8, i8* %488, i32 1
store i8* %489, i8** %14
store i8 %487, i8* %488
%490 = load i32, i32* %16
%491 = lshr i32 %490, 18
%492 = and i32 %491, 1
%493 = trunc i32 %492 to i8
%494 = load i8*, i8** %14
%495 = getelementptr inbounds i8, i8* %494, i32 1
store i8* %495, i8** %14
store i8 %493, i8* %494
%496 = load i32, i32* %16
%497 = lshr i32 %496, 17
%498 = and i32 %497, 1
%499 = trunc i32 %498 to i8
%500 = load i8*, i8** %14
%501 = getelementptr inbounds i8, i8* %500, i32 1
store i8* %501, i8** %14
store i8 %499, i8* %500
%502 = load i32, i32* %16
%503 = lshr i32 %502, 16
%504 = and i32 %503, 1
%505 = trunc i32 %504 to i8
%506 = load i8*, i8** %14
%507 = getelementptr inbounds i8, i8* %506, i32 1
store i8* %507, i8** %14
store i8 %505, i8* %506
%508 = load i32, i32* %16
%509 = lshr i32 %508, 15
%510 = and i32 %509, 1
%511 = trunc i32 %510 to i8
%512 = load i8*, i8** %14
%513 = getelementptr inbounds i8, i8* %512, i32 1
store i8* %513, i8** %14
store i8 %511, i8* %512
%514 = load i32, i32* %16
%515 = lshr i32 %514, 14
%516 = and i32 %515, 1
%517 = trunc i32 %516 to i8
%518 = load i8*, i8** %14
%519 = getelementptr inbounds i8, i8* %518, i32 1
store i8* %519, i8** %14
store i8 %517, i8* %518
%520 = load i32, i32* %16
%521 = lshr i32 %520, 13
%522 = and i32 %521, 1
%523 = trunc i32 %522 to i8
%524 = load i8*, i8** %14
%525 = getelementptr inbounds i8, i8* %524, i32 1
store i8* %525, i8** %14
store i8 %523, i8* %524
%526 = load i32, i32* %16
%527 = lshr i32 %526, 12
%528 = and i32 %527, 1
%529 = trunc i32 %528 to i8
%530 = load i8*, i8** %14
%531 = getelementptr inbounds i8, i8* %530, i32 1
store i8* %531, i8** %14
store i8 %529, i8* %530
%532 = load i32, i32* %16
%533 = lshr i32 %532, 11
%534 = and i32 %533, 1
%535 = trunc i32 %534 to i8
%536 = load i8*, i8** %14
%537 = getelementptr inbounds i8, i8* %536, i32 1
store i8* %537, i8** %14
store i8 %535, i8* %536
%538 = load i32, i32* %16
%539 = lshr i32 %538, 10
%540 = and i32 %539, 1
%541 = trunc i32 %540 to i8
%542 = load i8*, i8** %14
%543 = getelementptr inbounds i8, i8* %542, i32 1
store i8* %543, i8** %14
store i8 %541, i8* %542
%544 = load i32, i32* %16
%545 = lshr i32 %544, 9
%546 = and i32 %545, 1
%547 = trunc i32 %546 to i8
%548 = load i8*, i8** %14
%549 = getelementptr inbounds i8, i8* %548, i32 1
store i8* %549, i8** %14
store i8 %547, i8* %548
%550 = load i32, i32* %16
%551 = lshr i32 %550, 8
%552 = and i32 %551, 1
%553 = trunc i32 %552 to i8
%554 = load i8*, i8** %14
%555 = getelementptr inbounds i8, i8* %554, i32 1
store i8* %555, i8** %14
store i8 %553, i8* %554
%556 = load i32, i32* %16
%557 = lshr i32 %556, 7
%558 = and i32 %557, 1
%559 = trunc i32 %558 to i8
%560 = load i8*, i8** %14
%561 = getelementptr inbounds i8, i8* %560, i32 1
store i8* %561, i8** %14
store i8 %559, i8* %560
%562 = load i32, i32* %16
%563 = lshr i32 %562, 6
%564 = and i32 %563, 1
%565 = trunc i32 %564 to i8
%566 = load i8*, i8** %14
%567 = getelementptr inbounds i8, i8* %566, i32 1
store i8* %567, i8** %14
store i8 %565, i8* %566
%568 = load i32, i32* %16
%569 = lshr i32 %568, 5
%570 = and i32 %569, 1
%571 = trunc i32 %570 to i8
%572 = load i8*, i8** %14
%573 = getelementptr inbounds i8, i8* %572, i32 1
store i8* %573, i8** %14
store i8 %571, i8* %572
%574 = load i32, i32* %16
%575 = lshr i32 %574, 4
%576 = and i32 %575, 1
%577 = trunc i32 %576 to i8
%578 = load i8*, i8** %14
%579 = getelementptr inbounds i8, i8* %578, i32 1
store i8* %579, i8** %14
store i8 %577, i8* %578
%580 = load i32, i32* %16
%581 = lshr i32 %580, 3
%582 = and i32 %581, 1
%583 = trunc i32 %582 to i8
%584 = load i8*, i8** %14
%585 = getelementptr inbounds i8, i8* %584, i32 1
store i8* %585, i8** %14
store i8 %583, i8* %584
%586 = load i32, i32* %16
%587 = lshr i32 %586, 2
%588 = and i32 %587, 1
%589 = trunc i32 %588 to i8
%590 = load i8*, i8** %14
%591 = getelementptr inbounds i8, i8* %590, i32 1
store i8* %591, i8** %14
store i8 %589, i8* %590
%592 = load i32, i32* %16
%593 = lshr i32 %592, 1
%594 = and i32 %593, 1
%595 = trunc i32 %594 to i8
%596 = load i8*, i8** %14
%597 = getelementptr inbounds i8, i8* %596, i32 1
store i8* %597, i8** %14
store i8 %595, i8* %596
%598 = load i32, i32* %16
%599 = and i32 %598, 1
%600 = trunc i32 %599 to i8
%601 = load i8*, i8** %14
%602 = getelementptr inbounds i8, i8* %601, i32 1
store i8* %602, i8** %14
store i8 %600, i8* %601
%603 = load i32*, i32** %13
%604 = getelementptr inbounds i32, i32* %603, i32 1
store i32* %604, i32** %13
%605 = load i32, i32* %603
store i32 %605, i32* %16
%606 = load i32, i32* %11
%607 = sub nsw i32 %606, 32
store i32 %607, i32* %11
br label %408
608: ; preds = %408
br label %609
609: ; preds = %608, %404
br label %610
610: ; preds = %609, %51
%611 = load i32, i32* %16
%612 = zext i32 %611 to i64
store i64 %612, i64* %15
%613 = load i64, i64* %15
%614 = shl i64 %613, 32
store i64 %614, i64* %15
%615 = load i32*, i32** %13
%616 = getelementptr inbounds i32, i32* %615, i32 1
store i32* %616, i32** %13
%617 = load i32, i32* %615
%618 = zext i32 %617 to i64
%619 = load i64, i64* %15
%620 = or i64 %619, %618
store i64 %620, i64* %15
%621 = load i32, i32* %20
%622 = icmp slt i32 %621, 32
br i1 %622, label %623, label %629
623: ; preds = %610
%624 = load i32, i32* %20
%625 = sub nsw i32 32, %624
%626 = load i64, i64* %15
%627 = zext i32 %625 to i64
%628 = shl i64 %626, %627
store i64 %628, i64* %15
br label %629
629: ; preds = %623, %610
br label %630
630: ; preds = %725, %629
%631 = load i32, i32* %11
%632 = icmp sgt i32 %631, 3
br i1 %632, label %633, label %728
633: ; preds = %630
%634 = load i64, i64* %15
%635 = load i32, i32* %9
%636 = sub nsw i32 64, %635
%637 = zext i32 %636 to i64
%638 = lshr i64 %634, %637
%639 = trunc i64 %638 to i8
%640 = load i8*, i8** %14
%641 = getelementptr inbounds i8, i8* %640, i32 1
store i8* %641, i8** %14
store i8 %639, i8* %640
%642 = load i32, i32* %9
%643 = load i64, i64* %15
%644 = zext i32 %642 to i64
%645 = shl i64 %643, %644
store i64 %645, i64* %15
%646 = load i32, i32* %9
%647 = load i32, i32* %20
%648 = sub nsw i32 %647, %646
store i32 %648, i32* %20
%649 = load i64, i64* %15
%650 = load i32, i32* %9
%651 = sub nsw i32 64, %650
%652 = zext i32 %651 to i64
%653 = lshr i64 %649, %652
%654 = trunc i64 %653 to i8
%655 = load i8*, i8** %14
%656 = getelementptr inbounds i8, i8* %655, i32 1
store i8* %656, i8** %14
store i8 %654, i8* %655
%657 = load i32, i32* %9
%658 = load i64, i64* %15
%659 = zext i32 %657 to i64
%660 = shl i64 %658, %659
store i64 %660, i64* %15
%661 = load i32, i32* %9
%662 = load i32, i32* %20
%663 = sub nsw i32 %662, %661
store i32 %663, i32* %20
%664 = load i64, i64* %15
%665 = load i32, i32* %9
%666 = sub nsw i32 64, %665
%667 = zext i32 %666 to i64
%668 = lshr i64 %664, %667
%669 = trunc i64 %668 to i8
%670 = load i8*, i8** %14
%671 = getelementptr inbounds i8, i8* %670, i32 1
store i8* %671, i8** %14
store i8 %669, i8* %670
%672 = load i32, i32* %9
%673 = load i64, i64* %15
%674 = zext i32 %672 to i64
%675 = shl i64 %673, %674
store i64 %675, i64* %15
%676 = load i32, i32* %9
%677 = load i32, i32* %20
%678 = sub nsw i32 %677, %676
store i32 %678, i32* %20
%679 = load i64, i64* %15
%680 = load i32, i32* %9
%681 = sub nsw i32 64, %680
%682 = zext i32 %681 to i64
%683 = lshr i64 %679, %682
%684 = trunc i64 %683 to i8
%685 = load i8*, i8** %14
%686 = getelementptr inbounds i8, i8* %685, i32 1
store i8* %686, i8** %14
store i8 %684, i8* %685
%687 = load i32, i32* %9
%688 = load i64, i64* %15
%689 = zext i32 %687 to i64
%690 = shl i64 %688, %689
store i64 %690, i64* %15
%691 = load i32, i32* %9
%692 = load i32, i32* %20
%693 = sub nsw i32 %692, %691
store i32 %693, i32* %20
%694 = load i32, i32* %20
%695 = icmp sle i32 %694, 0
br i1 %695, label %696, label %725
696: ; preds = %633
%697 = load i32*, i32** %13
%698 = getelementptr inbounds i32, i32* %697, i32 1
store i32* %698, i32** %13
%699 = load i32, i32* %697
store i32 %699, i32* %16
%700 = load i32, i32* %20
%701 = icmp eq i32 %700, 0
br i1 %701, label %702, label %707
702: ; preds = %696
%703 = load i32, i32* %16
%704 = zext i32 %703 to i64
%705 = load i64, i64* %15
%706 = or i64 %705, %704
store i64 %706, i64* %15
br label %722
707: ; preds = %696
%708 = load i64, i64* %15
%709 = load i32, i32* %20
%710 = sub nsw i32 0, %709
%711 = zext i32 %710 to i64
%712 = lshr i64 %708, %711
store i64 %712, i64* %15
%713 = load i32, i32* %16
%714 = zext i32 %713 to i64
%715 = load i64, i64* %15
%716 = or i64 %715, %714
store i64 %716, i64* %15
%717 = load i32, i32* %20
%718 = sub nsw i32 0, %717
%719 = load i64, i64* %15
%720 = zext i32 %718 to i64
%721 = shl i64 %719, %720
store i64 %721, i64* %15
br label %722
722: ; preds = %707, %702
%723 = load i32, i32* %20
%724 = add nsw i32 %723, 32
store i32 %724, i32* %20
br label %725
725: ; preds = %722, %633
%726 = load i32, i32* %11
%727 = sub nsw i32 %726, 4
store i32 %727, i32* %11
br label %630
728: ; preds = %630
br label %729
729: ; preds = %780, %728
%730 = load i32, i32* %11
%731 = add nsw i32 %730, -1
store i32 %731, i32* %11
%732 = icmp sgt i32 %730, 0
br i1 %732, label %733, label %781
733: ; preds = %729
%734 = load i64, i64* %15
%735 = load i32, i32* %9
%736 = sub nsw i32 64, %735
%737 = zext i32 %736 to i64
%738 = lshr i64 %734, %737
%739 = trunc i64 %738 to i8
%740 = load i8*, i8** %14
%741 = getelementptr inbounds i8, i8* %740, i32 1
store i8* %741, i8** %14
store i8 %739, i8* %740
%742 = load i32, i32* %9
%743 = load i64, i64* %15
%744 = zext i32 %742 to i64
%745 = shl i64 %743, %744
store i64 %745, i64* %15
%746 = load i32, i32* %9
%747 = load i32, i32* %20
%748 = sub nsw i32 %747, %746
store i32 %748, i32* %20
%749 = load i32, i32* %20
%750 = icmp sle i32 %749, 0
br i1 %750, label %751, label %780
751: ; preds = %733
%752 = load i32*, i32** %13
%753 = getelementptr inbounds i32, i32* %752, i32 1
store i32* %753, i32** %13
%754 = load i32, i32* %752
store i32 %754, i32* %16
%755 = load i32, i32* %20
%756 = icmp eq i32 %755, 0
br i1 %756, label %757, label %762
757: ; preds = %751
%758 = load i32, i32* %16
%759 = zext i32 %758 to i64
%760 = load i64, i64* %15
%761 = or i64 %760, %759
store i64 %761, i64* %15
br label %777
762: ; preds = %751
%763 = load i64, i64* %15
%764 = load i32, i32* %20
%765 = sub nsw i32 0, %764
%766 = zext i32 %765 to i64
%767 = lshr i64 %763, %766
store i64 %767, i64* %15
%768 = load i32, i32* %16
%769 = zext i32 %768 to i64
%770 = load i64, i64* %15
%771 = or i64 %770, %769
store i64 %771, i64* %15
%772 = load i32, i32* %20
%773 = sub nsw i32 0, %772
%774 = load i64, i64* %15
%775 = zext i32 %773 to i64
%776 = shl i64 %774, %775
store i64 %776, i64* %15
br label %777
777: ; preds = %762, %757
%778 = load i32, i32* %20
%779 = add nsw i32 %778, 32
store i32 %779, i32* %20
br label %780
780: ; preds = %777, %733
br label %729
781: ; preds = %31, %729
ret void
}

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