void IntegerPacker_8(void *stream, void *src, int nbits, int nbitt, int n,
                     int offset) {
  unsigned int *packed = (unsigned int *)stream;
  unsigned char *unpacked = (unsigned char *)src;
  unsigned long long temp;
  unsigned int mask, token, token1, token2, token3, token4, token5, token6,
      token7, token8;
  int bleft, i;
  if (nbits > 8 || nbitt > nbits)
    return;
  packed += offset / 32;
  bleft = 32 - (offset % 32);
  temp = 0;
  mask = ~(0xFFFFFFFF << nbitt);
  if (bleft == 32) {
    if (nbits == 8) {
      while (n > 7) {
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        *packed++ = (token1 << 24) | (token2 << 16) | (token3 << 8) | token4;
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        *packed++ = (token1 << 24) | (token2 << 16) | (token3 << 8) | token4;
        n -= 8;
      }
    }
    if (nbits == 6) {
      while (n > 15) {
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        token5 = (*unpacked++) & mask;
        token6 = (*unpacked++) & mask;
        token7 = (*unpacked++) & mask;
        token8 = (*unpacked++) & mask;
        *packed++ = (token1 << 26) | (token2 << 20) | (token3 << 14) |
                    (token4 << 8) | (token5 << 2) | (token6 >> 4);
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        *packed++ = (token6 << 28) | (token7 << 22) | (token8 << 16) |
                    (token1 << 10) | (token2 << 4) | (token3 >> 2);
        token4 = (*unpacked++) & mask;
        token5 = (*unpacked++) & mask;
        token6 = (*unpacked++) & mask;
        token7 = (*unpacked++) & mask;
        token8 = (*unpacked++) & mask;
        *packed++ = (token3 << 30) | (token4 << 24) | (token5 << 18) |
                    (token6 << 12) | (token7 << 6) | token8;
        n -= 16;
      }
    }
    if (nbits == 4) {
      while (n > 7) {
        token = (*unpacked++) & mask;
        token = (token << 4) | ((*unpacked++) & mask);
        token = (token << 4) | ((*unpacked++) & mask);
        token = (token << 4) | ((*unpacked++) & mask);
        token = (token << 4) | ((*unpacked++) & mask);
        token = (token << 4) | ((*unpacked++) & mask);
        token = (token << 4) | ((*unpacked++) & mask);
        *packed++ = (token << 4) | ((*unpacked++) & mask);
        n -= 8;
      }
    }
    if (nbits == 2) {
      while (n > 15) {
        token = (*unpacked++) & mask;
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        token = (token << 2) | ((*unpacked++) & mask);
        *packed++ = (token << 2) | ((*unpacked++) & mask);
        n -= 16;
      }
    }
    if (nbits == 1) {
      while (n > 31) {
        token = 0;
        i = 8;
        while (i-- != 0) {
          token = (token << 1) | ((*unpacked++) & 1);
          token = (token << 1) | ((*unpacked++) & 1);
          token = (token << 1) | ((*unpacked++) & 1);
          token = (token << 1) | ((*unpacked++) & 1);
        }
        *packed++ = token;
        n -= 32;
      }
    }
  }
  if (bleft < 32)
    temp = *packed >> bleft;
  while (n > 2) {
    token = (*unpacked++) & mask;
    bleft -= nbits;
    temp = (temp << nbits) | token;
    if (bleft <= 0) {
      if (bleft < 0)
        temp >>= (-bleft);
      *packed++ = temp;
      bleft += 32;
      temp = token;
    }
    token = (*unpacked++) & mask;
    bleft -= nbits;
    temp = (temp << nbits) | token;
    if (bleft <= 0) {
      if (bleft < 0)
        temp >>= (-bleft);
      *packed++ = temp;
      bleft += 32;
      temp = token;
    }
    n -= 2;
  }
  while (n-- > 0) {
    token = (*unpacked++) & mask;
    bleft -= nbits;
    temp = (temp << nbits) | token;
    if (bleft <= 0) {
      if (bleft < 0)
        temp >>= (-bleft);
      *packed++ = temp;
      bleft += 32;
      temp = token;
    }
  }
  if (bleft < 32)
    *packed = (temp << bleft);
}


x86 assembly (clang, -O0):
<IntegerPacker_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)
cmpl   $0x8,-0x14(%rbp)
jg     1140 <IntegerPacker_8+0x40>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1145 <IntegerPacker_8+0x45>
jmp    1b8d <IntegerPacker_8+0xa8d>
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,-0x64(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x18(%rbp),%ecx
mov    $0xffffffff,%eax
shl    %cl,%eax
xor    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x20,-0x64(%rbp)
jne    198f <IntegerPacker_8+0x88f>
cmpl   $0x8,-0x14(%rbp)
jne    12db <IntegerPacker_8+0x1db>
jmp    11aa <IntegerPacker_8+0xaa>
cmpl   $0x7,-0x1c(%rbp)
jle    12d6 <IntegerPacker_8+0x1d6>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x18,%ecx
mov    -0x48(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x4c(%rbp),%eax
shl    $0x8,%eax
or     %eax,%ecx
or     -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x18,%ecx
mov    -0x48(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x4c(%rbp),%eax
shl    $0x8,%eax
or     %eax,%ecx
or     -0x50(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x1c(%rbp)
jmp    11aa <IntegerPacker_8+0xaa>
jmp    12db <IntegerPacker_8+0x1db>
cmpl   $0x6,-0x14(%rbp)
jne    153f <IntegerPacker_8+0x43f>
jmp    12ea <IntegerPacker_8+0x1ea>
cmpl   $0xf,-0x1c(%rbp)
jle    153a <IntegerPacker_8+0x43a>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x1a,%ecx
mov    -0x48(%rbp),%eax
shl    $0x14,%eax
or     %eax,%ecx
mov    -0x4c(%rbp),%eax
shl    $0xe,%eax
or     %eax,%ecx
mov    -0x50(%rbp),%eax
shl    $0x8,%eax
or     %eax,%ecx
mov    -0x54(%rbp),%eax
shl    $0x2,%eax
or     %eax,%ecx
mov    -0x58(%rbp),%eax
shr    $0x4,%eax
or     %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x58(%rbp),%ecx
shl    $0x1c,%ecx
mov    -0x5c(%rbp),%eax
shl    $0x16,%eax
or     %eax,%ecx
mov    -0x60(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x44(%rbp),%eax
shl    $0xa,%eax
or     %eax,%ecx
mov    -0x48(%rbp),%eax
shl    $0x4,%eax
or     %eax,%ecx
mov    -0x4c(%rbp),%eax
shr    $0x2,%eax
or     %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x4c(%rbp),%ecx
shl    $0x1e,%ecx
mov    -0x50(%rbp),%eax
shl    $0x18,%eax
or     %eax,%ecx
mov    -0x54(%rbp),%eax
shl    $0x12,%eax
or     %eax,%ecx
mov    -0x58(%rbp),%eax
shl    $0xc,%eax
or     %eax,%ecx
mov    -0x5c(%rbp),%eax
shl    $0x6,%eax
or     %eax,%ecx
or     -0x60(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x1c(%rbp)
jmp    12ea <IntegerPacker_8+0x1ea>
jmp    153f <IntegerPacker_8+0x43f>
cmpl   $0x4,-0x14(%rbp)
jne    1671 <IntegerPacker_8+0x571>
jmp    154e <IntegerPacker_8+0x44e>
cmpl   $0x7,-0x1c(%rbp)
jle    166c <IntegerPacker_8+0x56c>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
shl    $0x4,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
or     %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x1c(%rbp)
jmp    154e <IntegerPacker_8+0x44e>
jmp    1671 <IntegerPacker_8+0x571>
cmpl   $0x2,-0x14(%rbp)
jne    18a3 <IntegerPacker_8+0x7a3>
jmp    1680 <IntegerPacker_8+0x580>
cmpl   $0xf,-0x1c(%rbp)
jle    189e <IntegerPacker_8+0x79e>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
or     %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x1c(%rbp)
jmp    1680 <IntegerPacker_8+0x580>
jmp    18a3 <IntegerPacker_8+0x7a3>
cmpl   $0x1,-0x14(%rbp)
jne    198a <IntegerPacker_8+0x88a>
jmp    18b2 <IntegerPacker_8+0x7b2>
cmpl   $0x1f,-0x1c(%rbp)
jle    1985 <IntegerPacker_8+0x885>
movl   $0x0,-0x40(%rbp)
movl   $0x8,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x68(%rbp)
cmp    $0x0,%eax
je     1963 <IntegerPacker_8+0x863>
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rcx),%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
jmp    18ca <IntegerPacker_8+0x7ca>
mov    -0x40(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
sub    $0x20,%eax
mov    %eax,-0x1c(%rbp)
jmp    18b2 <IntegerPacker_8+0x7b2>
jmp    198a <IntegerPacker_8+0x88a>
jmp    198f <IntegerPacker_8+0x88f>
cmpl   $0x20,-0x64(%rbp)
jge    19aa <IntegerPacker_8+0x8aa>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    -0x64(%rbp),%ecx
shr    %cl,%eax
mov    %eax,%eax
mov    %rax,-0x38(%rbp)
jmp    19af <IntegerPacker_8+0x8af>
cmpl   $0x2,-0x1c(%rbp)
jle    1acf <IntegerPacker_8+0x9cf>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x64(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    %cl,%rax
mov    -0x40(%rbp),%ecx
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x64(%rbp)
jg     1a3d <IntegerPacker_8+0x93d>
cmpl   $0x0,-0x64(%rbp)
jge    1a16 <IntegerPacker_8+0x916>
xor    %ecx,%ecx
sub    -0x64(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shr    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x64(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x64(%rbp)
mov    -0x40(%rbp),%eax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x64(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    %cl,%rax
mov    -0x40(%rbp),%ecx
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x64(%rbp)
jg     1ac1 <IntegerPacker_8+0x9c1>
cmpl   $0x0,-0x64(%rbp)
jge    1a9a <IntegerPacker_8+0x99a>
xor    %ecx,%ecx
sub    -0x64(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shr    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x64(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x64(%rbp)
mov    -0x40(%rbp),%eax
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    19af <IntegerPacker_8+0x8af>
jmp    1ad4 <IntegerPacker_8+0x9d4>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1b71 <IntegerPacker_8+0xa71>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x64(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    %cl,%rax
mov    -0x40(%rbp),%ecx
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x64(%rbp)
jg     1b6c <IntegerPacker_8+0xa6c>
cmpl   $0x0,-0x64(%rbp)
jge    1b45 <IntegerPacker_8+0xa45>
xor    %ecx,%ecx
sub    -0x64(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shr    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x64(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x64(%rbp)
mov    -0x40(%rbp),%eax
mov    %rax,-0x38(%rbp)
jmp    1ad4 <IntegerPacker_8+0x9d4>
cmpl   $0x20,-0x64(%rbp)
jge    1b8d <IntegerPacker_8+0xa8d>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    %cl,%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<IntegerPacker_8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x8,%edx
jg     16a4 <IntegerPacker_8+0x5a4>
cmp    %edx,%ecx
jg     16a4 <IntegerPacker_8+0x5a4>
lea    0x1f(%r9),%ebp
test   %r9d,%r9d
cmovns %r9d,%ebp
mov    %ebp,%eax
sar    $0x5,%eax
cltq
lea    (%rdi,%rax,4),%r10
and    $0xffffffe0,%ebp
mov    $0xffffffff,%r14d
shl    %cl,%r14d
sub    %ebp,%r9d
mov    $0x20,%r15d
not    %r14d
test   %r9d,%r9d
jne    1669 <IntegerPacker_8+0x569>
cmp    $0x8,%edx
jne    11e5 <IntegerPacker_8+0xe5>
cmp    $0x8,%r8d
jl     11e5 <IntegerPacker_8+0xe5>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8d,%ecx
movzbl (%rsi),%eax
and    %r14d,%eax
movzbl 0x1(%rsi),%edi
and    %r14d,%edi
movzbl 0x2(%rsi),%ebp
and    %r14d,%ebp
movzbl 0x3(%rsi),%ebx
and    %r14d,%ebx
shl    $0x18,%eax
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%ebp
or     %edi,%ebp
or     %ebx,%ebp
mov    %ebp,(%r10)
movzbl 0x4(%rsi),%eax
and    %r14d,%eax
movzbl 0x5(%rsi),%edi
and    %r14d,%edi
movzbl 0x6(%rsi),%ebp
and    %r14d,%ebp
movzbl 0x7(%rsi),%ebx
add    $0x8,%rsi
and    %r14d,%ebx
shl    $0x18,%eax
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%ebp
or     %edi,%ebp
or     %ebx,%ebp
mov    %ebp,0x4(%r10)
add    $0x8,%r10
lea    -0x8(%rcx),%r8d
cmp    $0xf,%ecx
ja     1170 <IntegerPacker_8+0x70>
jmp    1669 <IntegerPacker_8+0x569>
cmp    $0x6,%edx
jne    12f7 <IntegerPacker_8+0x1f7>
cmp    $0x10,%r8d
jl     12f7 <IntegerPacker_8+0x1f7>
mov    %r9,%r13
nopl   0x0(%rax,%rax,1)
mov    %r8d,%r9d
movzbl (%rsi),%ebp
and    %r14d,%ebp
movzbl 0x1(%rsi),%ecx
and    %r14d,%ecx
movzbl 0x2(%rsi),%eax
and    %r14d,%eax
movzbl 0x3(%rsi),%edi
and    %r14d,%edi
movzbl 0x4(%rsi),%ebx
and    %r14d,%ebx
movzbl 0x5(%rsi),%r11d
and    %r14d,%r11d
movzbl 0x6(%rsi),%r12d
and    %r14d,%r12d
movzbl 0x7(%rsi),%r8d
and    %r14d,%r8d
shl    $0x1a,%ebp
shl    $0x14,%ecx
or     %ebp,%ecx
shl    $0xe,%eax
shl    $0x8,%edi
or     %eax,%edi
or     %ecx,%edi
shl    $0x2,%ebx
mov    %r11d,%eax
shr    $0x4,%eax
or     %ebx,%eax
or     %edi,%eax
mov    %eax,(%r10)
movzbl 0x8(%rsi),%eax
and    %r14d,%eax
movzbl 0x9(%rsi),%ecx
and    %r14d,%ecx
movzbl 0xa(%rsi),%ebx
and    %r14d,%ebx
shl    $0x1c,%r11d
shl    $0x16,%r12d
or     %r11d,%r12d
shl    $0x10,%r8d
shl    $0xa,%eax
or     %r8d,%eax
or     %r12d,%eax
shl    $0x4,%ecx
mov    %ebx,%edi
shr    $0x2,%edi
or     %ecx,%edi
or     %eax,%edi
mov    %edi,0x4(%r10)
movzbl 0xb(%rsi),%eax
and    %r14d,%eax
movzbl 0xc(%rsi),%ecx
and    %r14d,%ecx
movzbl 0xd(%rsi),%edi
and    %r14d,%edi
movzbl 0xe(%rsi),%ebp
and    %r14d,%ebp
movzbl 0xf(%rsi),%r8d
add    $0x10,%rsi
and    %r14d,%r8d
shl    $0x1e,%ebx
shl    $0x18,%eax
or     %ebx,%eax
shl    $0x12,%ecx
shl    $0xc,%edi
or     %ecx,%edi
or     %eax,%edi
shl    $0x6,%ebp
or     %r8d,%ebp
or     %edi,%ebp
mov    %ebp,0x8(%r10)
add    $0xc,%r10
lea    -0x10(%r9),%r8d
cmp    $0x1f,%r9d
ja     1200 <IntegerPacker_8+0x100>
mov    %r13,%r9
cmp    $0x4,%edx
jne    1386 <IntegerPacker_8+0x286>
cmp    $0x8,%r8d
jl     1386 <IntegerPacker_8+0x286>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%ecx
movzbl (%rsi),%eax
and    %r14d,%eax
movzbl 0x1(%rsi),%edi
and    %r14d,%edi
shl    $0x8,%eax
shl    $0x4,%edi
or     %eax,%edi
movzbl 0x2(%rsi),%eax
and    %r14d,%eax
or     %edi,%eax
movzbl 0x3(%rsi),%edi
and    %r14d,%edi
movzbl 0x4(%rsi),%ebp
and    %r14d,%ebp
movzbl 0x5(%rsi),%ebx
and    %r14d,%ebx
shl    $0x10,%eax
shl    $0xc,%edi
shl    $0x8,%ebp
or     %edi,%ebp
or     %eax,%ebp
shl    $0x4,%ebx
movzbl 0x6(%rsi),%eax
and    %r14d,%eax
or     %ebx,%eax
or     %ebp,%eax
shl    $0x4,%eax
movzbl 0x7(%rsi),%edi
add    $0x8,%rsi
and    %r14d,%edi
or     %eax,%edi
mov    %edi,(%r10)
add    $0x4,%r10
lea    -0x8(%rcx),%r8d
cmp    $0xf,%ecx
ja     1310 <IntegerPacker_8+0x210>
jmp    1669 <IntegerPacker_8+0x569>
cmp    $0x2,%edx
jne    147a <IntegerPacker_8+0x37a>
cmp    $0x10,%r8d
jl     147a <IntegerPacker_8+0x37a>
nopl   0x0(%rax)
mov    %r8d,%ecx
movzbl (%rsi),%eax
and    %r14d,%eax
movzbl 0x1(%rsi),%edi
and    %r14d,%edi
shl    $0x4,%eax
shl    $0x2,%edi
or     %eax,%edi
movzbl 0x2(%rsi),%eax
and    %r14d,%eax
or     %edi,%eax
movzbl 0x3(%rsi),%edi
and    %r14d,%edi
movzbl 0x4(%rsi),%ebp
and    %r14d,%ebp
movzbl 0x5(%rsi),%ebx
and    %r14d,%ebx
shl    $0x8,%eax
shl    $0x6,%edi
shl    $0x4,%ebp
or     %edi,%ebp
or     %eax,%ebp
shl    $0x2,%ebx
movzbl 0x6(%rsi),%eax
and    %r14d,%eax
or     %ebx,%eax
or     %ebp,%eax
movzbl 0x7(%rsi),%edi
and    %r14d,%edi
movzbl 0x8(%rsi),%ebp
and    %r14d,%ebp
movzbl 0x9(%rsi),%ebx
and    %r14d,%ebx
shl    $0x8,%eax
shl    $0x6,%edi
shl    $0x4,%ebp
or     %edi,%ebp
or     %eax,%ebp
shl    $0x2,%ebx
movzbl 0xa(%rsi),%eax
and    %r14d,%eax
or     %ebx,%eax
or     %ebp,%eax
movzbl 0xb(%rsi),%edi
and    %r14d,%edi
movzbl 0xc(%rsi),%ebp
and    %r14d,%ebp
movzbl 0xd(%rsi),%ebx
and    %r14d,%ebx
shl    $0x8,%eax
shl    $0x6,%edi
shl    $0x4,%ebp
or     %edi,%ebp
or     %eax,%ebp
shl    $0x2,%ebx
movzbl 0xe(%rsi),%eax
and    %r14d,%eax
or     %ebx,%eax
or     %ebp,%eax
shl    $0x2,%eax
movzbl 0xf(%rsi),%edi
add    $0x10,%rsi
and    %r14d,%edi
or     %eax,%edi
mov    %edi,(%r10)
add    $0x4,%r10
lea    -0x10(%rcx),%r8d
cmp    $0x1f,%ecx
ja     13a0 <IntegerPacker_8+0x2a0>
jmp    1669 <IntegerPacker_8+0x569>
cmp    $0x1,%edx
jne    1669 <IntegerPacker_8+0x569>
cmp    $0x20,%r8d
jl     1669 <IntegerPacker_8+0x569>
xor    %ecx,%ecx
mov    %r8d,%edi
sub    $0x3f,%edi
cmovb  %ecx,%edi
add    $0x1f,%edi
cmp    $0x60,%edi
jb     14d7 <IntegerPacker_8+0x3d7>
mov    %r8d,%eax
sub    $0x3f,%eax
cmovb  %ecx,%eax
add    $0x1f,%eax
shr    $0x5,%eax
mov    %rax,%rcx
shl    $0x5,%rcx
add    %rsi,%rcx
add    $0x20,%rcx
cmp    %r10,%rcx
jbe    1782 <IntegerPacker_8+0x682>
lea    (%r10,%rax,4),%rax
add    $0x4,%rax
cmp    %rax,%rsi
jae    1782 <IntegerPacker_8+0x682>
mov    %rsi,%r13
mov    %r10,%r11
mov    %r8d,%ecx
movzbl 0x0(%r13),%eax
and    $0x1,%eax
movzbl 0x1(%r13),%esi
and    $0x1,%esi
lea    (%rsi,%rax,2),%eax
movzbl 0x2(%r13),%esi
and    $0x1,%esi
add    %esi,%esi
lea    (%rsi,%rax,4),%eax
movzbl 0x3(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x4(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x5(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x6(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x7(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x8(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x9(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0xa(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0xb(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0xc(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0xd(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0xe(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0xf(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x10(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x11(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x12(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x13(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x14(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x15(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x16(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x17(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x18(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x19(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x1a(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x1b(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x1c(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x1d(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
movzbl 0x1e(%r13),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzbl 0x1f(%r13),%esi
and    $0x1,%esi
or     %eax,%esi
add    $0x20,%r13
mov    %esi,(%r11)
add    $0x4,%r11
lea    -0x20(%rcx),%r8d
cmp    $0x3f,%ecx
mov    %r8d,%ecx
ja     14e0 <IntegerPacker_8+0x3e0>
jmp    166f <IntegerPacker_8+0x56f>
mov    %rsi,%r13
mov    %r10,%r11
sub    %r9d,%r15d
test   %r9d,%r9d
jle    1682 <IntegerPacker_8+0x582>
mov    (%r11),%edi
mov    %r15d,%ecx
shr    %cl,%rdi
jmp    1684 <IntegerPacker_8+0x584>
xor    %edi,%edi
mov    %edx,%esi
cmp    $0x3,%r8d
jge    16d4 <IntegerPacker_8+0x5d4>
test   %r8d,%r8d
jg     1736 <IntegerPacker_8+0x636>
cmp    $0x1f,%r15d
jg     16a4 <IntegerPacker_8+0x5a4>
mov    %r15d,%ecx
shl    %cl,%rdi
mov    %edi,(%r11)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
nop
mov    %r15d,%ecx
neg    %cl
shr    %cl,%rax
mov    %eax,(%r11)
add    $0x4,%r11
add    $0x20,%r15d
lea    -0x2(%r8),%eax
lea    0x2(%rbx),%r13
cmp    $0x4,%r8d
mov    %eax,%r8d
jbe    172c <IntegerPacker_8+0x62c>
mov    %r13,%rbx
mov    %esi,%ecx
shl    %cl,%rdi
movzbl 0x0(%r13),%eax
and    %r14d,%eax
or     %rax,%rdi
sub    %edx,%r15d
jle    1700 <IntegerPacker_8+0x600>
mov    %rdi,%rax
jmp    1713 <IntegerPacker_8+0x613>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15d,%ecx
neg    %cl
shr    %cl,%rdi
mov    %edi,(%r11)
add    $0x4,%r11
add    $0x20,%r15d
mov    %esi,%ecx
shl    %cl,%rax
movzbl 0x1(%rbx),%edi
and    %r14d,%edi
or     %rdi,%rax
sub    %edx,%r15d
jle    16b0 <IntegerPacker_8+0x5b0>
mov    %rax,%rdi
jmp    16c3 <IntegerPacker_8+0x5c3>
add    $0x2,%rbx
mov    %eax,%r8d
mov    %rbx,%r13
add    $0x1,%r8d
mov    %rdi,%rbp
jmp    1768 <IntegerPacker_8+0x668>
nop
mov    %r15d,%ecx
neg    %cl
shr    %cl,%rbp
mov    %ebp,(%r11)
add    $0x4,%r11
add    $0x20,%r15d
mov    %rdi,%rbp
add    $0x1,%r13
add    $0xffffffff,%r8d
cmp    $0x1,%r8d
jbe    1695 <IntegerPacker_8+0x595>
mov    %esi,%ecx
shl    %cl,%rbp
movzbl 0x0(%r13),%edi
and    %r14d,%edi
or     %rdi,%rbp
sub    %edx,%r15d
jle    1740 <IntegerPacker_8+0x640>
mov    %rbp,%rdi
jmp    1756 <IntegerPacker_8+0x656>
mov    %r9,-0x10(%rsp)
shr    $0x5,%edi
add    $0x1,%edi
mov    %rdi,-0x18(%rsp)
and    $0xfffffffc,%edi
mov    %rdi,%r13
shl    $0x5,%r13
add    %rsi,%r13
lea    (%r10,%rdi,4),%r11
mov    %rdi,-0x20(%rsp)
mov    %edi,%eax
shl    $0x5,%eax
sub    %eax,%r8d
add    $0x7f,%rsi
xor    %eax,%eax
pxor   %xmm14,%xmm14
mov    %rax,-0x8(%rsp)
movzbl -0x7f(%rsi),%eax
movzbl -0x3f(%rsi),%ecx
movzbl -0x1f(%rsi),%edi
shl    $0x8,%edi
movzbl -0x5f(%rsi),%ebp
or     %ecx,%edi
mov    %edi,-0x38(%rsp)
shl    $0x8,%ebp
mov    %ebp,%edi
movzbl -0x7e(%rsi),%ecx
movzbl -0x3e(%rsi),%ebp
or     %eax,%edi
mov    %edi,-0x68(%rsp)
movzbl -0x1e(%rsi),%eax
shl    $0x8,%eax
movzbl -0x5e(%rsi),%edi
or     %ebp,%eax
mov    %eax,-0x48(%rsp)
shl    $0x8,%edi
movzbl -0x7d(%rsi),%r9d
movzbl -0x3d(%rsi),%ebp
or     %ecx,%edi
mov    %edi,-0x64(%rsp)
movzbl -0x1d(%rsi),%eax
shl    $0x8,%eax
movzbl -0x5d(%rsi),%r12d
or     %ebp,%eax
mov    %eax,-0x58(%rsp)
shl    $0x8,%r12d
movzbl -0x7c(%rsi),%ecx
movzbl -0x3c(%rsi),%eax
or     %r9d,%r12d
movzbl -0x1c(%rsi),%edi
shl    $0x8,%edi
movzbl -0x5c(%rsi),%ebp
or     %eax,%edi
mov    %edi,-0x5c(%rsp)
shl    $0x8,%ebp
movzbl -0x7b(%rsi),%eax
mov    %eax,-0x6c(%rsp)
movzbl -0x3b(%rsi),%eax
or     %ecx,%ebp
movzbl -0x1b(%rsi),%ecx
shl    $0x8,%ecx
movzbl -0x5b(%rsi),%r9d
or     %eax,%ecx
mov    %ecx,-0x60(%rsp)
shl    $0x8,%r9d
movzbl -0x7a(%rsi),%ebx
movzbl -0x3a(%rsi),%edi
add    -0x6c(%rsp),%r9d
movzbl -0x1a(%rsi),%ecx
shl    $0x8,%ecx
movzbl -0x5a(%rsi),%eax
or     %edi,%ecx
mov    %ecx,-0x6c(%rsp)
shl    $0x8,%eax
or     %ebx,%eax
movzbl -0x79(%rsi),%ecx
movd   -0x68(%rsp),%xmm8
movzbl -0x39(%rsi),%edi
movzbl -0x19(%rsi),%ebx
shl    $0x8,%ebx
movd   -0x64(%rsp),%xmm1
or     %edi,%ebx
mov    %ebx,-0x68(%rsp)
movzbl -0x59(%rsi),%edi
shl    $0x8,%edi
movd   %r12d,%xmm11
or     %ecx,%edi
movzbl -0x78(%rsi),%ecx
movzbl -0x38(%rsi),%ebx
movd   %ebp,%xmm2
movzbl -0x18(%rsi),%ebp
shl    $0x8,%ebp
or     %ebx,%ebp
movd   %r9d,%xmm9
movzbl -0x58(%rsi),%ebx
shl    $0x8,%ebx
or     %ecx,%ebx
movd   %eax,%xmm3
movzbl -0x77(%rsi),%r9d
movzbl -0x37(%rsi),%eax
movzbl -0x17(%rsi),%ecx
movd   %edi,%xmm7
shl    $0x8,%ecx
or     %eax,%ecx
movzbl -0x57(%rsi),%eax
movd   %ebx,%xmm13
shl    $0x8,%eax
or     %r9d,%eax
pinsrw $0x1,-0x38(%rsp),%xmm8
01
movd   %eax,%xmm4
movzbl -0x36(%rsi),%eax
pinsrw $0x1,-0x48(%rsp),%xmm1
movzbl -0x16(%rsi),%edi
shl    $0x8,%edi
pinsrw $0x1,-0x58(%rsp),%xmm11
01
or     %eax,%edi
movzbl -0x76(%rsi),%eax
pinsrw $0x1,-0x5c(%rsp),%xmm2
movdqa %xmm2,%xmm5
movzbl -0x56(%rsi),%ebx
shl    $0x8,%ebx
pinsrw $0x1,-0x60(%rsp),%xmm9
01
or     %eax,%ebx
movd   %ebx,%xmm2
pinsrw $0x1,-0x6c(%rsp),%xmm3
movdqa %xmm3,%xmm6
movzbl -0x75(%rsi),%r9d
movzbl -0x35(%rsi),%ebx
pinsrw $0x1,-0x68(%rsp),%xmm7
movzbl -0x15(%rsi),%eax
shl    $0x8,%eax
pinsrw $0x1,%ebp,%xmm13
or     %ebx,%eax
movzbl -0x55(%rsi),%ebx
pinsrw $0x1,%ecx,%xmm4
shl    $0x8,%ebx
or     %r9d,%ebx
pinsrw $0x1,%edi,%xmm2
movd   %ebx,%xmm3
pinsrw $0x1,%eax,%xmm3
paddb  %xmm8,%xmm8
movdqa 0x1659(%rip),%xmm0
pand   %xmm0,%xmm1
movdqa %xmm1,-0x58(%rsp)
movdqa %xmm0,%xmm1
movzbl -0x74(%rsi),%eax
movzbl -0x34(%rsi),%ecx
paddb  %xmm11,%xmm11
movzbl -0x14(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
pand   %xmm0,%xmm5
movdqa %xmm5,-0x38(%rsp)
movzbl -0x54(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
paddb  %xmm9,%xmm9
movd   %ecx,%xmm0
pinsrw $0x1,%edi,%xmm0
pand   %xmm1,%xmm6
movdqa %xmm6,-0x48(%rsp)
paddb  %xmm7,%xmm7
movzbl -0x73(%rsi),%eax
movzbl -0x33(%rsi),%ecx
pand   %xmm1,%xmm13
movzbl -0x13(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
paddb  %xmm4,%xmm4
movzbl -0x53(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
pand   %xmm1,%xmm2
movdqa %xmm1,%xmm6
movd   %ecx,%xmm10
pinsrw $0x1,%edi,%xmm10
paddb  %xmm3,%xmm3
movzbl -0x72(%rsi),%eax
movzbl -0x32(%rsi),%ecx
movzbl -0x12(%rsi),%edi
pand   %xmm1,%xmm0
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x52(%rsi),%ecx
paddb  %xmm10,%xmm10
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm1
movdqa 0x15ad(%rip),%xmm5
pand   %xmm5,%xmm8
pinsrw $0x1,%edi,%xmm1
pand   %xmm6,%xmm1
pand   %xmm5,%xmm11
movzbl -0x71(%rsi),%eax
movzbl -0x31(%rsi),%ecx
movzbl -0x11(%rsi),%edi
pand   %xmm5,%xmm9
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x51(%rsi),%ecx
pand   %xmm5,%xmm7
movdqa %xmm5,%xmm12
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm15
punpcklbw %xmm14,%xmm13
pinsrw $0x1,%edi,%xmm15
paddb  %xmm15,%xmm15
pand   %xmm5,%xmm4
movzbl -0x70(%rsi),%eax
movzbl -0x30(%rsi),%ecx
movzbl -0x10(%rsi),%edi
punpcklbw %xmm14,%xmm2
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x50(%rsi),%ecx
pand   %xmm5,%xmm3
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm5
punpcklbw %xmm14,%xmm0
pinsrw $0x1,%edi,%xmm5
pand   %xmm6,%xmm5
pand   %xmm12,%xmm10
movdqa %xmm12,%xmm6
movzbl -0x6f(%rsi),%eax
movzbl -0x2f(%rsi),%ecx
movzbl -0xf(%rsi),%edi
punpcklbw %xmm14,%xmm1
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x4f(%rsi),%ecx
movdqa -0x58(%rsp),%xmm12
por    %xmm8,%xmm12
movdqa %xmm12,-0x58(%rsp)
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm8
pand   %xmm6,%xmm15
pinsrw $0x1,%edi,%xmm8
paddb  %xmm8,%xmm8
punpcklbw %xmm14,%xmm5
pand   %xmm6,%xmm8
movdqa %xmm6,%xmm12
movzbl -0x6e(%rsi),%eax
movzbl -0x2e(%rsi),%ecx
movdqa -0x38(%rsp),%xmm6
por    %xmm11,%xmm6
movdqa %xmm6,-0x38(%rsp)
movzbl -0xe(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
movdqa -0x48(%rsp),%xmm6
por    %xmm9,%xmm6
movdqa %xmm6,-0x48(%rsp)
movzbl -0x4e(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
punpcklbw %xmm14,%xmm7
movd   %ecx,%xmm9
pinsrw $0x1,%edi,%xmm9
punpcklwd %xmm14,%xmm13
movdqa 0x145a(%rip),%xmm11
pand   %xmm11,%xmm9
movzbl -0x6d(%rsi),%eax
movzbl -0x2d(%rsi),%ecx
punpcklbw %xmm14,%xmm4
movzbl -0xd(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
punpcklwd %xmm14,%xmm2
movzbl -0x4d(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
punpcklbw %xmm14,%xmm3
movd   %ecx,%xmm6
pinsrw $0x1,%edi,%xmm6
punpcklwd %xmm14,%xmm0
punpcklbw %xmm14,%xmm9
paddb  %xmm6,%xmm6
pand   %xmm12,%xmm6
punpcklbw %xmm14,%xmm10
movzbl -0x6c(%rsi),%eax
movzbl -0x2c(%rsi),%ecx
movzbl -0xc(%rsi),%edi
punpcklwd %xmm14,%xmm7
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x4c(%rsi),%ecx
por    %xmm7,%xmm13
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm7
punpcklwd %xmm14,%xmm1
pinsrw $0x1,%edi,%xmm7
pand   %xmm11,%xmm7
punpcklbw %xmm14,%xmm15
punpcklbw %xmm14,%xmm7
movzbl -0x6b(%rsi),%eax
movzbl -0x2b(%rsi),%ecx
punpcklwd %xmm14,%xmm5
movzbl -0xb(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
punpcklwd %xmm14,%xmm4
movzbl -0x4b(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
por    %xmm4,%xmm2
movd   %ecx,%xmm11
pinsrw $0x1,%edi,%xmm11
punpcklbw %xmm14,%xmm8
paddb  %xmm11,%xmm11
movzbl -0x6a(%rsi),%eax
movzbl -0x2a(%rsi),%ecx
punpcklwd %xmm14,%xmm9
movzbl -0xa(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
punpcklwd %xmm14,%xmm3
movzbl -0x4a(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
por    %xmm3,%xmm0
movd   %ecx,%xmm3
pinsrw $0x1,%edi,%xmm3
punpcklbw %xmm14,%xmm6
pand   %xmm12,%xmm11
movdqa 0x134a(%rip),%xmm4
pand   %xmm4,%xmm3
punpcklbw %xmm14,%xmm3
punpcklwd %xmm14,%xmm7
movzbl -0x69(%rsi),%eax
movzbl -0x29(%rsi),%ecx
movzbl -0x9(%rsi),%edi
punpcklwd %xmm14,%xmm10
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x49(%rsi),%ecx
por    %xmm10,%xmm1
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm4
punpcklbw %xmm14,%xmm11
pinsrw $0x1,%edi,%xmm4
paddb  %xmm4,%xmm4
punpcklwd %xmm14,%xmm3
pand   %xmm12,%xmm4
movzbl -0x68(%rsi),%eax
movzbl -0x28(%rsi),%ecx
movdqa -0x58(%rsp),%xmm12
psllw  $0x2,%xmm12
movzbl -0x8(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
punpcklwd %xmm14,%xmm15
movzbl -0x48(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
por    %xmm15,%xmm5
movd   %ecx,%xmm10
pinsrw $0x1,%edi,%xmm10
punpcklwd %xmm14,%xmm8
punpcklbw %xmm14,%xmm4
pand   0x12ad(%rip),%xmm10
punpcklbw %xmm14,%xmm10
punpcklwd %xmm14,%xmm6
punpcklwd %xmm14,%xmm10
movzbl -0x67(%rsi),%eax
movzbl -0x27(%rsi),%ecx
punpcklwd %xmm14,%xmm11
movzbl -0x7(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
punpcklwd %xmm14,%xmm4
movzbl -0x47(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
por    %xmm8,%xmm9
movd   %ecx,%xmm8
pinsrw $0x1,%edi,%xmm8
por    %xmm6,%xmm7
paddb  %xmm8,%xmm8
pand   0x1268(%rip),%xmm8
punpcklbw %xmm14,%xmm8
por    %xmm11,%xmm3
punpcklwd %xmm14,%xmm8
movzbl -0x66(%rsi),%eax
movzbl -0x26(%rsi),%ecx
por    %xmm4,%xmm10
movzbl -0x6(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
movdqa 0x124a(%rip),%xmm15
pand   %xmm15,%xmm12
movzbl -0x46(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movdqa -0x38(%rsp),%xmm4
por    %xmm12,%xmm4
movd   %ecx,%xmm11
pinsrw $0x1,%edi,%xmm11
psllw  $0x2,%xmm4
pand   0x11f8(%rip),%xmm11
punpcklbw %xmm14,%xmm11
punpcklwd %xmm14,%xmm11
pand   %xmm15,%xmm4
movzbl -0x65(%rsi),%eax
movzbl -0x25(%rsi),%ecx
movzbl -0x5(%rsi),%edi
movdqa -0x48(%rsp),%xmm6
por    %xmm4,%xmm6
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x45(%rsi),%ecx
punpcklbw %xmm14,%xmm6
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm4
punpcklwd %xmm14,%xmm6
pinsrw $0x1,%edi,%xmm4
paddb  %xmm4,%xmm4
pslld  $0x2,%xmm6
movdqa 0x11b0(%rip),%xmm12
pand   %xmm12,%xmm4
punpcklbw %xmm14,%xmm4
punpcklwd %xmm14,%xmm4
por    %xmm6,%xmm13
movzbl -0x64(%rsi),%eax
movzbl -0x24(%rsi),%ecx
movzbl -0x4(%rsi),%edi
pslld  $0x2,%xmm13
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x44(%rsi),%ecx
por    %xmm13,%xmm2
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm6
pslld  $0x2,%xmm2
pinsrw $0x1,%edi,%xmm6
movdqa 0x1150(%rip),%xmm13
pand   %xmm13,%xmm6
por    %xmm2,%xmm0
punpcklbw %xmm14,%xmm6
movzbl -0x63(%rsi),%eax
movzbl -0x23(%rsi),%ecx
pslld  $0x2,%xmm0
movzbl -0x3(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
por    %xmm0,%xmm1
movzbl -0x43(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
pslld  $0x2,%xmm1
movd   %ecx,%xmm2
pinsrw $0x1,%edi,%xmm2
por    %xmm8,%xmm11
punpcklwd %xmm14,%xmm6
paddb  %xmm2,%xmm2
pand   %xmm12,%xmm2
por    %xmm4,%xmm6
punpcklbw %xmm14,%xmm2
movzbl -0x62(%rsi),%eax
movzbl -0x22(%rsi),%ecx
por    %xmm1,%xmm5
movzbl -0x2(%rsi),%edi
shl    $0x8,%edi
or     %ecx,%edi
pslld  $0x2,%xmm5
movzbl -0x42(%rsi),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
por    %xmm5,%xmm9
movd   %ecx,%xmm0
pinsrw $0x1,%edi,%xmm0
pslld  $0x2,%xmm9
punpcklwd %xmm14,%xmm2
pand   %xmm13,%xmm0
punpcklbw %xmm14,%xmm0
por    %xmm9,%xmm7
punpcklwd %xmm14,%xmm0
por    %xmm2,%xmm0
pslld  $0x2,%xmm7
por    %xmm7,%xmm3
movzbl -0x61(%rsi),%eax
movzbl -0x21(%rsi),%ecx
movzbl -0x1(%rsi),%edi
pslld  $0x2,%xmm3
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x41(%rsi),%ecx
por    %xmm3,%xmm10
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm1
pslld  $0x2,%xmm10
pinsrw $0x1,%edi,%xmm1
paddb  %xmm1,%xmm1
por    %xmm10,%xmm11
pand   %xmm12,%xmm1
punpcklbw %xmm14,%xmm1
punpcklwd %xmm14,%xmm1
pslld  $0x2,%xmm11
movzbl -0x60(%rsi),%eax
movzbl -0x20(%rsi),%ecx
movzbl (%rsi),%edi
por    %xmm11,%xmm6
shl    $0x8,%edi
or     %ecx,%edi
movzbl -0x40(%rsi),%ecx
pslld  $0x2,%xmm6
shl    $0x8,%ecx
or     %eax,%ecx
mov    -0x8(%rsp),%rax
movd   %ecx,%xmm2
por    %xmm6,%xmm0
pinsrw $0x1,%edi,%xmm2
pand   %xmm13,%xmm2
pslld  $0x2,%xmm0
punpcklbw %xmm14,%xmm2
punpcklwd %xmm14,%xmm2
por    %xmm1,%xmm2
por    %xmm0,%xmm2
movdqu %xmm2,(%r10,%rax,4)
add    $0x4,%rax
sub    $0xffffffffffffff80,%rsi
cmp    %rax,-0x20(%rsp)
jne    17bb <IntegerPacker_8+0x6bb>
mov    -0x20(%rsp),%rax
cmp    -0x18(%rsp),%rax
mov    -0x10(%rsp),%r9
jne    14dd <IntegerPacker_8+0x3dd>
jmp    166f <IntegerPacker_8+0x56f>

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

LLVM IR (-O2):
define void @IntegerPacker_8(i8* nocapture %0, i8* nocapture %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 %1210, 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 = shl nsw i32 -1, %3
%18 = xor i32 %17, -1
%19 = icmp eq i32 %15, 0
br i1 %19, label %20, label %1102
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 %76
24: ; preds = %20, %24
%25 = phi i8* [ %63, %24 ], [ %1, %20 ]
%26 = phi i32* [ %73, %24 ], [ %14, %20 ]
%27 = phi i32 [ %74, %24 ], [ %4, %20 ]
%28 = getelementptr inbounds i8, i8* %25, i64 1
%29 = load i8, i8* %25
%30 = zext i8 %29 to i32
%31 = and i32 %30, %18
%32 = getelementptr inbounds i8, i8* %25, i64 2
%33 = load i8, i8* %28
%34 = zext i8 %33 to i32
%35 = and i32 %34, %18
%36 = getelementptr inbounds i8, i8* %25, i64 3
%37 = load i8, i8* %32
%38 = zext i8 %37 to i32
%39 = and i32 %38, %18
%40 = getelementptr inbounds i8, i8* %25, i64 4
%41 = load i8, i8* %36
%42 = zext i8 %41 to i32
%43 = and i32 %42, %18
%44 = shl nuw i32 %31, 24
%45 = shl nuw nsw i32 %35, 16
%46 = or i32 %45, %44
%47 = shl nuw nsw i32 %39, 8
%48 = or i32 %46, %47
%49 = or i32 %48, %43
%50 = getelementptr inbounds i32, i32* %26, i64 1
store i32 %49, i32* %26
%51 = getelementptr inbounds i8, i8* %25, i64 5
%52 = load i8, i8* %40
%53 = zext i8 %52 to i32
%54 = and i32 %53, %18
%55 = getelementptr inbounds i8, i8* %25, i64 6
%56 = load i8, i8* %51
%57 = zext i8 %56 to i32
%58 = and i32 %57, %18
%59 = getelementptr inbounds i8, i8* %25, i64 7
%60 = load i8, i8* %55
%61 = zext i8 %60 to i32
%62 = and i32 %61, %18
%63 = getelementptr inbounds i8, i8* %25, i64 8
%64 = load i8, i8* %59
%65 = zext i8 %64 to i32
%66 = and i32 %65, %18
%67 = shl nuw i32 %54, 24
%68 = shl nuw nsw i32 %58, 16
%69 = or i32 %68, %67
%70 = shl nuw nsw i32 %62, 8
%71 = or i32 %69, %70
%72 = or i32 %71, %66
%73 = getelementptr inbounds i32, i32* %26, i64 2
store i32 %72, i32* %50
%74 = add nsw i32 %27, -8
%75 = icmp ugt i32 %27, 15
br i1 %75, label %24, label %1102
76: ; preds = %20
%77 = icmp eq i32 %2, 6
%78 = icmp sgt i32 %4, 15
%79 = and i1 %77, %78
br i1 %79, label %80, label %185
80: ; preds = %76, %80
%81 = phi i8* [ %168, %80 ], [ %1, %76 ]
%82 = phi i32* [ %182, %80 ], [ %14, %76 ]
%83 = phi i32 [ %183, %80 ], [ %4, %76 ]
%84 = getelementptr inbounds i8, i8* %81, i64 1
%85 = load i8, i8* %81
%86 = zext i8 %85 to i32
%87 = and i32 %86, %18
%88 = getelementptr inbounds i8, i8* %81, i64 2
%89 = load i8, i8* %84
%90 = zext i8 %89 to i32
%91 = and i32 %90, %18
%92 = getelementptr inbounds i8, i8* %81, i64 3
%93 = load i8, i8* %88
%94 = zext i8 %93 to i32
%95 = and i32 %94, %18
%96 = getelementptr inbounds i8, i8* %81, i64 4
%97 = load i8, i8* %92
%98 = zext i8 %97 to i32
%99 = and i32 %98, %18
%100 = getelementptr inbounds i8, i8* %81, i64 5
%101 = load i8, i8* %96
%102 = zext i8 %101 to i32
%103 = and i32 %102, %18
%104 = getelementptr inbounds i8, i8* %81, i64 6
%105 = load i8, i8* %100
%106 = zext i8 %105 to i32
%107 = and i32 %106, %18
%108 = getelementptr inbounds i8, i8* %81, i64 7
%109 = load i8, i8* %104
%110 = zext i8 %109 to i32
%111 = and i32 %110, %18
%112 = getelementptr inbounds i8, i8* %81, i64 8
%113 = load i8, i8* %108
%114 = zext i8 %113 to i32
%115 = and i32 %114, %18
%116 = shl i32 %87, 26
%117 = shl nuw nsw i32 %91, 20
%118 = or i32 %117, %116
%119 = shl nuw nsw i32 %95, 14
%120 = or i32 %118, %119
%121 = shl nuw nsw i32 %99, 8
%122 = or i32 %120, %121
%123 = shl nuw nsw i32 %103, 2
%124 = or i32 %122, %123
%125 = lshr i32 %107, 4
%126 = or i32 %124, %125
%127 = getelementptr inbounds i32, i32* %82, i64 1
store i32 %126, i32* %82
%128 = getelementptr inbounds i8, i8* %81, i64 9
%129 = load i8, i8* %112
%130 = zext i8 %129 to i32
%131 = and i32 %130, %18
%132 = getelementptr inbounds i8, i8* %81, i64 10
%133 = load i8, i8* %128
%134 = zext i8 %133 to i32
%135 = and i32 %134, %18
%136 = getelementptr inbounds i8, i8* %81, i64 11
%137 = load i8, i8* %132
%138 = zext i8 %137 to i32
%139 = and i32 %138, %18
%140 = shl i32 %107, 28
%141 = shl nuw nsw i32 %111, 22
%142 = or i32 %141, %140
%143 = shl nuw nsw i32 %115, 16
%144 = or i32 %142, %143
%145 = shl nuw nsw i32 %131, 10
%146 = or i32 %144, %145
%147 = shl nuw nsw i32 %135, 4
%148 = or i32 %146, %147
%149 = lshr i32 %139, 2
%150 = or i32 %148, %149
%151 = getelementptr inbounds i32, i32* %82, i64 2
store i32 %150, i32* %127
%152 = getelementptr inbounds i8, i8* %81, i64 12
%153 = load i8, i8* %136
%154 = zext i8 %153 to i32
%155 = and i32 %154, %18
%156 = getelementptr inbounds i8, i8* %81, i64 13
%157 = load i8, i8* %152
%158 = zext i8 %157 to i32
%159 = and i32 %158, %18
%160 = getelementptr inbounds i8, i8* %81, i64 14
%161 = load i8, i8* %156
%162 = zext i8 %161 to i32
%163 = and i32 %162, %18
%164 = getelementptr inbounds i8, i8* %81, i64 15
%165 = load i8, i8* %160
%166 = zext i8 %165 to i32
%167 = and i32 %166, %18
%168 = getelementptr inbounds i8, i8* %81, i64 16
%169 = load i8, i8* %164
%170 = zext i8 %169 to i32
%171 = and i32 %170, %18
%172 = shl i32 %139, 30
%173 = shl nuw i32 %155, 24
%174 = or i32 %173, %172
%175 = shl nuw nsw i32 %159, 18
%176 = or i32 %174, %175
%177 = shl nuw nsw i32 %163, 12
%178 = or i32 %176, %177
%179 = shl nuw nsw i32 %167, 6
%180 = or i32 %178, %179
%181 = or i32 %180, %171
%182 = getelementptr inbounds i32, i32* %82, i64 3
store i32 %181, i32* %151
%183 = add nsw i32 %83, -16
%184 = icmp ugt i32 %83, 31
br i1 %184, label %80, label %185
185: ; preds = %80, %76
%186 = phi i8* [ %1, %76 ], [ %168, %80 ]
%187 = phi i32* [ %14, %76 ], [ %182, %80 ]
%188 = phi i32 [ %4, %76 ], [ %183, %80 ]
%189 = bitcast i32* %187 to i8*
%190 = icmp eq i32 %2, 4
%191 = icmp sgt i32 %188, 7
%192 = select i1 %190, i1 %191, i1 false
br i1 %192, label %193, label %246
193: ; preds = %185, %193
%194 = phi i8* [ %238, %193 ], [ %186, %185 ]
%195 = phi i32* [ %243, %193 ], [ %187, %185 ]
%196 = phi i32 [ %244, %193 ], [ %188, %185 ]
%197 = getelementptr inbounds i8, i8* %194, i64 1
%198 = load i8, i8* %194
%199 = zext i8 %198 to i32
%200 = and i32 %199, %18
%201 = getelementptr inbounds i8, i8* %194, i64 2
%202 = load i8, i8* %197
%203 = zext i8 %202 to i32
%204 = and i32 %203, %18
%205 = shl nuw nsw i32 %200, 8
%206 = shl nuw nsw i32 %204, 4
%207 = or i32 %206, %205
%208 = getelementptr inbounds i8, i8* %194, i64 3
%209 = load i8, i8* %201
%210 = zext i8 %209 to i32
%211 = and i32 %210, %18
%212 = or i32 %207, %211
%213 = getelementptr inbounds i8, i8* %194, i64 4
%214 = load i8, i8* %208
%215 = zext i8 %214 to i32
%216 = and i32 %215, %18
%217 = getelementptr inbounds i8, i8* %194, i64 5
%218 = load i8, i8* %213
%219 = zext i8 %218 to i32
%220 = and i32 %219, %18
%221 = getelementptr inbounds i8, i8* %194, i64 6
%222 = load i8, i8* %217
%223 = zext i8 %222 to i32
%224 = and i32 %223, %18
%225 = shl nuw i32 %212, 16
%226 = shl nuw nsw i32 %216, 12
%227 = shl nuw nsw i32 %220, 8
%228 = or i32 %226, %227
%229 = or i32 %225, %228
%230 = shl nuw nsw i32 %224, 4
%231 = getelementptr inbounds i8, i8* %194, i64 7
%232 = load i8, i8* %221
%233 = zext i8 %232 to i32
%234 = and i32 %233, %18
%235 = or i32 %234, %230
%236 = or i32 %235, %229
%237 = shl i32 %236, 4
%238 = getelementptr inbounds i8, i8* %194, i64 8
%239 = load i8, i8* %231
%240 = zext i8 %239 to i32
%241 = and i32 %240, %18
%242 = or i32 %237, %241
%243 = getelementptr inbounds i32, i32* %195, i64 1
store i32 %242, i32* %195
%244 = add nsw i32 %196, -8
%245 = icmp ugt i32 %196, 15
br i1 %245, label %193, label %1102
246: ; preds = %185
%247 = icmp eq i32 %2, 2
%248 = icmp sgt i32 %188, 15
%249 = select i1 %247, i1 %248, i1 false
br i1 %249, label %250, label %351
250: ; preds = %246, %250
%251 = phi i8* [ %343, %250 ], [ %186, %246 ]
%252 = phi i32* [ %348, %250 ], [ %187, %246 ]
%253 = phi i32 [ %349, %250 ], [ %188, %246 ]
%254 = getelementptr inbounds i8, i8* %251, i64 1
%255 = load i8, i8* %251
%256 = zext i8 %255 to i32
%257 = and i32 %256, %18
%258 = getelementptr inbounds i8, i8* %251, i64 2
%259 = load i8, i8* %254
%260 = zext i8 %259 to i32
%261 = and i32 %260, %18
%262 = shl nuw nsw i32 %257, 4
%263 = shl nuw nsw i32 %261, 2
%264 = or i32 %263, %262
%265 = getelementptr inbounds i8, i8* %251, i64 3
%266 = load i8, i8* %258
%267 = zext i8 %266 to i32
%268 = and i32 %267, %18
%269 = or i32 %264, %268
%270 = getelementptr inbounds i8, i8* %251, i64 4
%271 = load i8, i8* %265
%272 = zext i8 %271 to i32
%273 = and i32 %272, %18
%274 = getelementptr inbounds i8, i8* %251, i64 5
%275 = load i8, i8* %270
%276 = zext i8 %275 to i32
%277 = and i32 %276, %18
%278 = getelementptr inbounds i8, i8* %251, i64 6
%279 = load i8, i8* %274
%280 = zext i8 %279 to i32
%281 = and i32 %280, %18
%282 = shl nuw nsw i32 %269, 8
%283 = shl nuw nsw i32 %273, 6
%284 = shl nuw nsw i32 %277, 4
%285 = or i32 %283, %284
%286 = or i32 %282, %285
%287 = shl nuw nsw i32 %281, 2
%288 = getelementptr inbounds i8, i8* %251, i64 7
%289 = load i8, i8* %278
%290 = zext i8 %289 to i32
%291 = and i32 %290, %18
%292 = or i32 %291, %287
%293 = or i32 %292, %286
%294 = getelementptr inbounds i8, i8* %251, i64 8
%295 = load i8, i8* %288
%296 = zext i8 %295 to i32
%297 = and i32 %296, %18
%298 = getelementptr inbounds i8, i8* %251, i64 9
%299 = load i8, i8* %294
%300 = zext i8 %299 to i32
%301 = and i32 %300, %18
%302 = getelementptr inbounds i8, i8* %251, i64 10
%303 = load i8, i8* %298
%304 = zext i8 %303 to i32
%305 = and i32 %304, %18
%306 = shl i32 %293, 8
%307 = shl nuw nsw i32 %297, 6
%308 = shl nuw nsw i32 %301, 4
%309 = or i32 %307, %308
%310 = or i32 %306, %309
%311 = shl nuw nsw i32 %305, 2
%312 = getelementptr inbounds i8, i8* %251, i64 11
%313 = load i8, i8* %302
%314 = zext i8 %313 to i32
%315 = and i32 %314, %18
%316 = or i32 %315, %311
%317 = or i32 %316, %310
%318 = getelementptr inbounds i8, i8* %251, i64 12
%319 = load i8, i8* %312
%320 = zext i8 %319 to i32
%321 = and i32 %320, %18
%322 = getelementptr inbounds i8, i8* %251, i64 13
%323 = load i8, i8* %318
%324 = zext i8 %323 to i32
%325 = and i32 %324, %18
%326 = getelementptr inbounds i8, i8* %251, i64 14
%327 = load i8, i8* %322
%328 = zext i8 %327 to i32
%329 = and i32 %328, %18
%330 = shl i32 %317, 8
%331 = shl nuw nsw i32 %321, 6
%332 = shl nuw nsw i32 %325, 4
%333 = or i32 %331, %332
%334 = or i32 %330, %333
%335 = shl nuw nsw i32 %329, 2
%336 = getelementptr inbounds i8, i8* %251, i64 15
%337 = load i8, i8* %326
%338 = zext i8 %337 to i32
%339 = and i32 %338, %18
%340 = or i32 %339, %335
%341 = or i32 %340, %334
%342 = shl i32 %341, 2
%343 = getelementptr inbounds i8, i8* %251, i64 16
%344 = load i8, i8* %336
%345 = zext i8 %344 to i32
%346 = and i32 %345, %18
%347 = or i32 %342, %346
%348 = getelementptr inbounds i32, i32* %252, i64 1
store i32 %347, i32* %252
%349 = add nsw i32 %253, -16
%350 = icmp ugt i32 %253, 31
br i1 %350, label %250, label %1102
351: ; preds = %246
%352 = icmp eq i32 %2, 1
%353 = icmp sgt i32 %188, 31
%354 = select i1 %352, i1 %353, i1 false
br i1 %354, label %355, label %1102
355: ; preds = %351
%356 = add i32 %188, 31
%357 = call i32 @llvm.umin.i32(i32 %188, i32 63)
%358 = sub i32 %356, %357
%359 = lshr i32 %358, 5
%360 = add nuw nsw i32 %359, 1
%361 = zext i32 %360 to i64
%362 = icmp ult i32 %358, 96
br i1 %362, label %906, label %363
363: ; preds = %355
%364 = add i32 %188, 31
%365 = call i32 @llvm.umin.i32(i32 %188, i32 63)
%366 = sub i32 %364, %365
%367 = lshr i32 %366, 5
%368 = zext i32 %367 to i64
%369 = add nuw nsw i64 %368, 1
%370 = getelementptr i32, i32* %187, i64 %369
%371 = bitcast i32* %370 to i8*
%372 = shl nuw nsw i64 %368, 5
%373 = add nuw nsw i64 %372, 32
%374 = getelementptr i8, i8* %186, i64 %373
%375 = icmp ugt i8* %374, %189
%376 = icmp ult i8* %186, %371
%377 = and i1 %375, %376
br i1 %377, label %906, label %378
378: ; preds = %363
%379 = and i64 %361, 268435452
%380 = shl nuw nsw i64 %379, 5
%381 = getelementptr i8, i8* %186, i64 %380
%382 = getelementptr i32, i32* %187, i64 %379
%383 = trunc i64 %379 to i32
%384 = mul i32 %383, -32
%385 = add i32 %188, %384
br label %386
386: ; preds = %386, %378
%387 = phi i64 [ 0, %378 ], [ %902, %386 ]
%388 = shl i64 %387, 5
%389 = getelementptr i8, i8* %186, i64 %388
%390 = shl i64 %387, 5
%391 = or i64 %390, 32
%392 = getelementptr i8, i8* %186, i64 %391
%393 = shl i64 %387, 5
%394 = or i64 %393, 64
%395 = getelementptr i8, i8* %186, i64 %394
%396 = shl i64 %387, 5
%397 = or i64 %396, 96
%398 = getelementptr i8, i8* %186, i64 %397
%399 = getelementptr i32, i32* %187, i64 %387
%400 = getelementptr inbounds i8, i8* %389, i64 1
%401 = getelementptr inbounds i8, i8* %392, i64 1
%402 = getelementptr inbounds i8, i8* %395, i64 1
%403 = getelementptr inbounds i8, i8* %398, i64 1
%404 = load i8, i8* %389
%405 = load i8, i8* %392
%406 = load i8, i8* %395
%407 = load i8, i8* %398
%408 = insertelement <4 x i8> poison, i8 %404, i64 0
%409 = insertelement <4 x i8> %408, i8 %405, i64 1
%410 = insertelement <4 x i8> %409, i8 %406, i64 2
%411 = insertelement <4 x i8> %410, i8 %407, i64 3
%412 = shl <4 x i8> %411, <i8 1, i8 1, i8 1, i8 1>
%413 = and <4 x i8> %412, <i8 2, i8 2, i8 2, i8 2>
%414 = getelementptr inbounds i8, i8* %389, i64 2
%415 = getelementptr inbounds i8, i8* %392, i64 2
%416 = getelementptr inbounds i8, i8* %395, i64 2
%417 = getelementptr inbounds i8, i8* %398, i64 2
%418 = load i8, i8* %400
%419 = load i8, i8* %401
%420 = load i8, i8* %402
%421 = load i8, i8* %403
%422 = insertelement <4 x i8> poison, i8 %418, i64 0
%423 = insertelement <4 x i8> %422, i8 %419, i64 1
%424 = insertelement <4 x i8> %423, i8 %420, i64 2
%425 = insertelement <4 x i8> %424, i8 %421, i64 3
%426 = and <4 x i8> %425, <i8 1, i8 1, i8 1, i8 1>
%427 = or <4 x i8> %413, %426
%428 = getelementptr inbounds i8, i8* %389, i64 3
%429 = getelementptr inbounds i8, i8* %392, i64 3
%430 = getelementptr inbounds i8, i8* %395, i64 3
%431 = getelementptr inbounds i8, i8* %398, i64 3
%432 = load i8, i8* %414
%433 = load i8, i8* %415
%434 = load i8, i8* %416
%435 = load i8, i8* %417
%436 = insertelement <4 x i8> poison, i8 %432, i64 0
%437 = insertelement <4 x i8> %436, i8 %433, i64 1
%438 = insertelement <4 x i8> %437, i8 %434, i64 2
%439 = insertelement <4 x i8> %438, i8 %435, i64 3
%440 = shl nuw nsw <4 x i8> %427, <i8 2, i8 2, i8 2, i8 2>
%441 = shl <4 x i8> %439, <i8 1, i8 1, i8 1, i8 1>
%442 = and <4 x i8> %441, <i8 2, i8 2, i8 2, i8 2>
%443 = or <4 x i8> %440, %442
%444 = getelementptr inbounds i8, i8* %389, i64 4
%445 = getelementptr inbounds i8, i8* %392, i64 4
%446 = getelementptr inbounds i8, i8* %395, i64 4
%447 = getelementptr inbounds i8, i8* %398, i64 4
%448 = load i8, i8* %428
%449 = load i8, i8* %429
%450 = load i8, i8* %430
%451 = load i8, i8* %431
%452 = insertelement <4 x i8> poison, i8 %448, i64 0
%453 = insertelement <4 x i8> %452, i8 %449, i64 1
%454 = insertelement <4 x i8> %453, i8 %450, i64 2
%455 = insertelement <4 x i8> %454, i8 %451, i64 3
%456 = and <4 x i8> %455, <i8 1, i8 1, i8 1, i8 1>
%457 = or <4 x i8> %443, %456
%458 = getelementptr inbounds i8, i8* %389, i64 5
%459 = getelementptr inbounds i8, i8* %392, i64 5
%460 = getelementptr inbounds i8, i8* %395, i64 5
%461 = getelementptr inbounds i8, i8* %398, i64 5
%462 = load i8, i8* %444
%463 = load i8, i8* %445
%464 = load i8, i8* %446
%465 = load i8, i8* %447
%466 = insertelement <4 x i8> poison, i8 %462, i64 0
%467 = insertelement <4 x i8> %466, i8 %463, i64 1
%468 = insertelement <4 x i8> %467, i8 %464, i64 2
%469 = insertelement <4 x i8> %468, i8 %465, i64 3
%470 = shl nuw nsw <4 x i8> %457, <i8 2, i8 2, i8 2, i8 2>
%471 = shl <4 x i8> %469, <i8 1, i8 1, i8 1, i8 1>
%472 = and <4 x i8> %471, <i8 2, i8 2, i8 2, i8 2>
%473 = or <4 x i8> %470, %472
%474 = getelementptr inbounds i8, i8* %389, i64 6
%475 = getelementptr inbounds i8, i8* %392, i64 6
%476 = getelementptr inbounds i8, i8* %395, i64 6
%477 = getelementptr inbounds i8, i8* %398, i64 6
%478 = load i8, i8* %458
%479 = load i8, i8* %459
%480 = load i8, i8* %460
%481 = load i8, i8* %461
%482 = insertelement <4 x i8> poison, i8 %478, i64 0
%483 = insertelement <4 x i8> %482, i8 %479, i64 1
%484 = insertelement <4 x i8> %483, i8 %480, i64 2
%485 = insertelement <4 x i8> %484, i8 %481, i64 3
%486 = and <4 x i8> %485, <i8 1, i8 1, i8 1, i8 1>
%487 = or <4 x i8> %473, %486
%488 = zext <4 x i8> %487 to <4 x i32>
%489 = getelementptr inbounds i8, i8* %389, i64 7
%490 = getelementptr inbounds i8, i8* %392, i64 7
%491 = getelementptr inbounds i8, i8* %395, i64 7
%492 = getelementptr inbounds i8, i8* %398, i64 7
%493 = load i8, i8* %474
%494 = load i8, i8* %475
%495 = load i8, i8* %476
%496 = load i8, i8* %477
%497 = insertelement <4 x i8> poison, i8 %493, i64 0
%498 = insertelement <4 x i8> %497, i8 %494, i64 1
%499 = insertelement <4 x i8> %498, i8 %495, i64 2
%500 = insertelement <4 x i8> %499, i8 %496, i64 3
%501 = shl nuw nsw <4 x i32> %488, <i32 2, i32 2, i32 2, i32 2>
%502 = shl <4 x i8> %500, <i8 1, i8 1, i8 1, i8 1>
%503 = and <4 x i8> %502, <i8 2, i8 2, i8 2, i8 2>
%504 = zext <4 x i8> %503 to <4 x i32>
%505 = or <4 x i32> %501, %504
%506 = getelementptr inbounds i8, i8* %389, i64 8
%507 = getelementptr inbounds i8, i8* %392, i64 8
%508 = getelementptr inbounds i8, i8* %395, i64 8
%509 = getelementptr inbounds i8, i8* %398, i64 8
%510 = load i8, i8* %489
%511 = load i8, i8* %490
%512 = load i8, i8* %491
%513 = load i8, i8* %492
%514 = insertelement <4 x i8> poison, i8 %510, i64 0
%515 = insertelement <4 x i8> %514, i8 %511, i64 1
%516 = insertelement <4 x i8> %515, i8 %512, i64 2
%517 = insertelement <4 x i8> %516, i8 %513, i64 3
%518 = and <4 x i8> %517, <i8 1, i8 1, i8 1, i8 1>
%519 = zext <4 x i8> %518 to <4 x i32>
%520 = or <4 x i32> %505, %519
%521 = getelementptr inbounds i8, i8* %389, i64 9
%522 = getelementptr inbounds i8, i8* %392, i64 9
%523 = getelementptr inbounds i8, i8* %395, i64 9
%524 = getelementptr inbounds i8, i8* %398, i64 9
%525 = load i8, i8* %506
%526 = load i8, i8* %507
%527 = load i8, i8* %508
%528 = load i8, i8* %509
%529 = insertelement <4 x i8> poison, i8 %525, i64 0
%530 = insertelement <4 x i8> %529, i8 %526, i64 1
%531 = insertelement <4 x i8> %530, i8 %527, i64 2
%532 = insertelement <4 x i8> %531, i8 %528, i64 3
%533 = shl nuw nsw <4 x i32> %520, <i32 2, i32 2, i32 2, i32 2>
%534 = shl <4 x i8> %532, <i8 1, i8 1, i8 1, i8 1>
%535 = and <4 x i8> %534, <i8 2, i8 2, i8 2, i8 2>
%536 = zext <4 x i8> %535 to <4 x i32>
%537 = or <4 x i32> %533, %536
%538 = getelementptr inbounds i8, i8* %389, i64 10
%539 = getelementptr inbounds i8, i8* %392, i64 10
%540 = getelementptr inbounds i8, i8* %395, i64 10
%541 = getelementptr inbounds i8, i8* %398, i64 10
%542 = load i8, i8* %521
%543 = load i8, i8* %522
%544 = load i8, i8* %523
%545 = load i8, i8* %524
%546 = insertelement <4 x i8> poison, i8 %542, i64 0
%547 = insertelement <4 x i8> %546, i8 %543, i64 1
%548 = insertelement <4 x i8> %547, i8 %544, i64 2
%549 = insertelement <4 x i8> %548, i8 %545, i64 3
%550 = and <4 x i8> %549, <i8 1, i8 1, i8 1, i8 1>
%551 = zext <4 x i8> %550 to <4 x i32>
%552 = or <4 x i32> %537, %551
%553 = getelementptr inbounds i8, i8* %389, i64 11
%554 = getelementptr inbounds i8, i8* %392, i64 11
%555 = getelementptr inbounds i8, i8* %395, i64 11
%556 = getelementptr inbounds i8, i8* %398, i64 11
%557 = load i8, i8* %538
%558 = load i8, i8* %539
%559 = load i8, i8* %540
%560 = load i8, i8* %541
%561 = insertelement <4 x i8> poison, i8 %557, i64 0
%562 = insertelement <4 x i8> %561, i8 %558, i64 1
%563 = insertelement <4 x i8> %562, i8 %559, i64 2
%564 = insertelement <4 x i8> %563, i8 %560, i64 3
%565 = shl <4 x i32> %552, <i32 2, i32 2, i32 2, i32 2>
%566 = shl <4 x i8> %564, <i8 1, i8 1, i8 1, i8 1>
%567 = and <4 x i8> %566, <i8 2, i8 2, i8 2, i8 2>
%568 = zext <4 x i8> %567 to <4 x i32>
%569 = or <4 x i32> %565, %568
%570 = getelementptr inbounds i8, i8* %389, i64 12
%571 = getelementptr inbounds i8, i8* %392, i64 12
%572 = getelementptr inbounds i8, i8* %395, i64 12
%573 = getelementptr inbounds i8, i8* %398, i64 12
%574 = load i8, i8* %553
%575 = load i8, i8* %554
%576 = load i8, i8* %555
%577 = load i8, i8* %556
%578 = insertelement <4 x i8> poison, i8 %574, i64 0
%579 = insertelement <4 x i8> %578, i8 %575, i64 1
%580 = insertelement <4 x i8> %579, i8 %576, i64 2
%581 = insertelement <4 x i8> %580, i8 %577, i64 3
%582 = and <4 x i8> %581, <i8 1, i8 1, i8 1, i8 1>
%583 = zext <4 x i8> %582 to <4 x i32>
%584 = or <4 x i32> %569, %583
%585 = getelementptr inbounds i8, i8* %389, i64 13
%586 = getelementptr inbounds i8, i8* %392, i64 13
%587 = getelementptr inbounds i8, i8* %395, i64 13
%588 = getelementptr inbounds i8, i8* %398, i64 13
%589 = load i8, i8* %570
%590 = load i8, i8* %571
%591 = load i8, i8* %572
%592 = load i8, i8* %573
%593 = insertelement <4 x i8> poison, i8 %589, i64 0
%594 = insertelement <4 x i8> %593, i8 %590, i64 1
%595 = insertelement <4 x i8> %594, i8 %591, i64 2
%596 = insertelement <4 x i8> %595, i8 %592, i64 3
%597 = shl <4 x i32> %584, <i32 2, i32 2, i32 2, i32 2>
%598 = shl <4 x i8> %596, <i8 1, i8 1, i8 1, i8 1>
%599 = and <4 x i8> %598, <i8 2, i8 2, i8 2, i8 2>
%600 = zext <4 x i8> %599 to <4 x i32>
%601 = or <4 x i32> %597, %600
%602 = getelementptr inbounds i8, i8* %389, i64 14
%603 = getelementptr inbounds i8, i8* %392, i64 14
%604 = getelementptr inbounds i8, i8* %395, i64 14
%605 = getelementptr inbounds i8, i8* %398, i64 14
%606 = load i8, i8* %585
%607 = load i8, i8* %586
%608 = load i8, i8* %587
%609 = load i8, i8* %588
%610 = insertelement <4 x i8> poison, i8 %606, i64 0
%611 = insertelement <4 x i8> %610, i8 %607, i64 1
%612 = insertelement <4 x i8> %611, i8 %608, i64 2
%613 = insertelement <4 x i8> %612, i8 %609, i64 3
%614 = and <4 x i8> %613, <i8 1, i8 1, i8 1, i8 1>
%615 = zext <4 x i8> %614 to <4 x i32>
%616 = or <4 x i32> %601, %615
%617 = getelementptr inbounds i8, i8* %389, i64 15
%618 = getelementptr inbounds i8, i8* %392, i64 15
%619 = getelementptr inbounds i8, i8* %395, i64 15
%620 = getelementptr inbounds i8, i8* %398, i64 15
%621 = load i8, i8* %602
%622 = load i8, i8* %603
%623 = load i8, i8* %604
%624 = load i8, i8* %605
%625 = insertelement <4 x i8> poison, i8 %621, i64 0
%626 = insertelement <4 x i8> %625, i8 %622, i64 1
%627 = insertelement <4 x i8> %626, i8 %623, i64 2
%628 = insertelement <4 x i8> %627, i8 %624, i64 3
%629 = shl <4 x i32> %616, <i32 2, i32 2, i32 2, i32 2>
%630 = shl <4 x i8> %628, <i8 1, i8 1, i8 1, i8 1>
%631 = and <4 x i8> %630, <i8 2, i8 2, i8 2, i8 2>
%632 = zext <4 x i8> %631 to <4 x i32>
%633 = or <4 x i32> %629, %632
%634 = getelementptr inbounds i8, i8* %389, i64 16
%635 = getelementptr inbounds i8, i8* %392, i64 16
%636 = getelementptr inbounds i8, i8* %395, i64 16
%637 = getelementptr inbounds i8, i8* %398, i64 16
%638 = load i8, i8* %617
%639 = load i8, i8* %618
%640 = load i8, i8* %619
%641 = load i8, i8* %620
%642 = insertelement <4 x i8> poison, i8 %638, i64 0
%643 = insertelement <4 x i8> %642, i8 %639, i64 1
%644 = insertelement <4 x i8> %643, i8 %640, i64 2
%645 = insertelement <4 x i8> %644, i8 %641, i64 3
%646 = and <4 x i8> %645, <i8 1, i8 1, i8 1, i8 1>
%647 = zext <4 x i8> %646 to <4 x i32>
%648 = or <4 x i32> %633, %647
%649 = getelementptr inbounds i8, i8* %389, i64 17
%650 = getelementptr inbounds i8, i8* %392, i64 17
%651 = getelementptr inbounds i8, i8* %395, i64 17
%652 = getelementptr inbounds i8, i8* %398, i64 17
%653 = load i8, i8* %634
%654 = load i8, i8* %635
%655 = load i8, i8* %636
%656 = load i8, i8* %637
%657 = insertelement <4 x i8> poison, i8 %653, i64 0
%658 = insertelement <4 x i8> %657, i8 %654, i64 1
%659 = insertelement <4 x i8> %658, i8 %655, i64 2
%660 = insertelement <4 x i8> %659, i8 %656, i64 3
%661 = shl <4 x i32> %648, <i32 2, i32 2, i32 2, i32 2>
%662 = shl <4 x i8> %660, <i8 1, i8 1, i8 1, i8 1>
%663 = and <4 x i8> %662, <i8 2, i8 2, i8 2, i8 2>
%664 = zext <4 x i8> %663 to <4 x i32>
%665 = or <4 x i32> %661, %664
%666 = getelementptr inbounds i8, i8* %389, i64 18
%667 = getelementptr inbounds i8, i8* %392, i64 18
%668 = getelementptr inbounds i8, i8* %395, i64 18
%669 = getelementptr inbounds i8, i8* %398, i64 18
%670 = load i8, i8* %649
%671 = load i8, i8* %650
%672 = load i8, i8* %651
%673 = load i8, i8* %652
%674 = insertelement <4 x i8> poison, i8 %670, i64 0
%675 = insertelement <4 x i8> %674, i8 %671, i64 1
%676 = insertelement <4 x i8> %675, i8 %672, i64 2
%677 = insertelement <4 x i8> %676, i8 %673, i64 3
%678 = and <4 x i8> %677, <i8 1, i8 1, i8 1, i8 1>
%679 = zext <4 x i8> %678 to <4 x i32>
%680 = or <4 x i32> %665, %679
%681 = getelementptr inbounds i8, i8* %389, i64 19
%682 = getelementptr inbounds i8, i8* %392, i64 19
%683 = getelementptr inbounds i8, i8* %395, i64 19
%684 = getelementptr inbounds i8, i8* %398, i64 19
%685 = load i8, i8* %666
%686 = load i8, i8* %667
%687 = load i8, i8* %668
%688 = load i8, i8* %669
%689 = insertelement <4 x i8> poison, i8 %685, i64 0
%690 = insertelement <4 x i8> %689, i8 %686, i64 1
%691 = insertelement <4 x i8> %690, i8 %687, i64 2
%692 = insertelement <4 x i8> %691, i8 %688, i64 3
%693 = shl <4 x i32> %680, <i32 2, i32 2, i32 2, i32 2>
%694 = shl <4 x i8> %692, <i8 1, i8 1, i8 1, i8 1>
%695 = and <4 x i8> %694, <i8 2, i8 2, i8 2, i8 2>
%696 = zext <4 x i8> %695 to <4 x i32>
%697 = or <4 x i32> %693, %696
%698 = getelementptr inbounds i8, i8* %389, i64 20
%699 = getelementptr inbounds i8, i8* %392, i64 20
%700 = getelementptr inbounds i8, i8* %395, i64 20
%701 = getelementptr inbounds i8, i8* %398, i64 20
%702 = load i8, i8* %681
%703 = load i8, i8* %682
%704 = load i8, i8* %683
%705 = load i8, i8* %684
%706 = insertelement <4 x i8> poison, i8 %702, i64 0
%707 = insertelement <4 x i8> %706, i8 %703, i64 1
%708 = insertelement <4 x i8> %707, i8 %704, i64 2
%709 = insertelement <4 x i8> %708, i8 %705, i64 3
%710 = and <4 x i8> %709, <i8 1, i8 1, i8 1, i8 1>
%711 = zext <4 x i8> %710 to <4 x i32>
%712 = or <4 x i32> %697, %711
%713 = getelementptr inbounds i8, i8* %389, i64 21
%714 = getelementptr inbounds i8, i8* %392, i64 21
%715 = getelementptr inbounds i8, i8* %395, i64 21
%716 = getelementptr inbounds i8, i8* %398, i64 21
%717 = load i8, i8* %698
%718 = load i8, i8* %699
%719 = load i8, i8* %700
%720 = load i8, i8* %701
%721 = insertelement <4 x i8> poison, i8 %717, i64 0
%722 = insertelement <4 x i8> %721, i8 %718, i64 1
%723 = insertelement <4 x i8> %722, i8 %719, i64 2
%724 = insertelement <4 x i8> %723, i8 %720, i64 3
%725 = shl <4 x i32> %712, <i32 2, i32 2, i32 2, i32 2>
%726 = shl <4 x i8> %724, <i8 1, i8 1, i8 1, i8 1>
%727 = and <4 x i8> %726, <i8 2, i8 2, i8 2, i8 2>
%728 = zext <4 x i8> %727 to <4 x i32>
%729 = or <4 x i32> %725, %728
%730 = getelementptr inbounds i8, i8* %389, i64 22
%731 = getelementptr inbounds i8, i8* %392, i64 22
%732 = getelementptr inbounds i8, i8* %395, i64 22
%733 = getelementptr inbounds i8, i8* %398, i64 22
%734 = load i8, i8* %713
%735 = load i8, i8* %714
%736 = load i8, i8* %715
%737 = load i8, i8* %716
%738 = insertelement <4 x i8> poison, i8 %734, i64 0
%739 = insertelement <4 x i8> %738, i8 %735, i64 1
%740 = insertelement <4 x i8> %739, i8 %736, i64 2
%741 = insertelement <4 x i8> %740, i8 %737, i64 3
%742 = and <4 x i8> %741, <i8 1, i8 1, i8 1, i8 1>
%743 = zext <4 x i8> %742 to <4 x i32>
%744 = or <4 x i32> %729, %743
%745 = getelementptr inbounds i8, i8* %389, i64 23
%746 = getelementptr inbounds i8, i8* %392, i64 23
%747 = getelementptr inbounds i8, i8* %395, i64 23
%748 = getelementptr inbounds i8, i8* %398, i64 23
%749 = load i8, i8* %730
%750 = load i8, i8* %731
%751 = load i8, i8* %732
%752 = load i8, i8* %733
%753 = insertelement <4 x i8> poison, i8 %749, i64 0
%754 = insertelement <4 x i8> %753, i8 %750, i64 1
%755 = insertelement <4 x i8> %754, i8 %751, i64 2
%756 = insertelement <4 x i8> %755, i8 %752, i64 3
%757 = shl <4 x i32> %744, <i32 2, i32 2, i32 2, i32 2>
%758 = shl <4 x i8> %756, <i8 1, i8 1, i8 1, i8 1>
%759 = and <4 x i8> %758, <i8 2, i8 2, i8 2, i8 2>
%760 = zext <4 x i8> %759 to <4 x i32>
%761 = or <4 x i32> %757, %760
%762 = getelementptr inbounds i8, i8* %389, i64 24
%763 = getelementptr inbounds i8, i8* %392, i64 24
%764 = getelementptr inbounds i8, i8* %395, i64 24
%765 = getelementptr inbounds i8, i8* %398, i64 24
%766 = load i8, i8* %745
%767 = load i8, i8* %746
%768 = load i8, i8* %747
%769 = load i8, i8* %748
%770 = insertelement <4 x i8> poison, i8 %766, i64 0
%771 = insertelement <4 x i8> %770, i8 %767, i64 1
%772 = insertelement <4 x i8> %771, i8 %768, i64 2
%773 = insertelement <4 x i8> %772, i8 %769, i64 3
%774 = and <4 x i8> %773, <i8 1, i8 1, i8 1, i8 1>
%775 = zext <4 x i8> %774 to <4 x i32>
%776 = or <4 x i32> %761, %775
%777 = getelementptr inbounds i8, i8* %389, i64 25
%778 = getelementptr inbounds i8, i8* %392, i64 25
%779 = getelementptr inbounds i8, i8* %395, i64 25
%780 = getelementptr inbounds i8, i8* %398, i64 25
%781 = load i8, i8* %762
%782 = load i8, i8* %763
%783 = load i8, i8* %764
%784 = load i8, i8* %765
%785 = insertelement <4 x i8> poison, i8 %781, i64 0
%786 = insertelement <4 x i8> %785, i8 %782, i64 1
%787 = insertelement <4 x i8> %786, i8 %783, i64 2
%788 = insertelement <4 x i8> %787, i8 %784, i64 3
%789 = shl <4 x i32> %776, <i32 2, i32 2, i32 2, i32 2>
%790 = shl <4 x i8> %788, <i8 1, i8 1, i8 1, i8 1>
%791 = and <4 x i8> %790, <i8 2, i8 2, i8 2, i8 2>
%792 = zext <4 x i8> %791 to <4 x i32>
%793 = or <4 x i32> %789, %792
%794 = getelementptr inbounds i8, i8* %389, i64 26
%795 = getelementptr inbounds i8, i8* %392, i64 26
%796 = getelementptr inbounds i8, i8* %395, i64 26
%797 = getelementptr inbounds i8, i8* %398, i64 26
%798 = load i8, i8* %777
%799 = load i8, i8* %778
%800 = load i8, i8* %779
%801 = load i8, i8* %780
%802 = insertelement <4 x i8> poison, i8 %798, i64 0
%803 = insertelement <4 x i8> %802, i8 %799, i64 1
%804 = insertelement <4 x i8> %803, i8 %800, i64 2
%805 = insertelement <4 x i8> %804, i8 %801, i64 3
%806 = and <4 x i8> %805, <i8 1, i8 1, i8 1, i8 1>
%807 = zext <4 x i8> %806 to <4 x i32>
%808 = or <4 x i32> %793, %807
%809 = getelementptr inbounds i8, i8* %389, i64 27
%810 = getelementptr inbounds i8, i8* %392, i64 27
%811 = getelementptr inbounds i8, i8* %395, i64 27
%812 = getelementptr inbounds i8, i8* %398, i64 27
%813 = load i8, i8* %794
%814 = load i8, i8* %795
%815 = load i8, i8* %796
%816 = load i8, i8* %797
%817 = insertelement <4 x i8> poison, i8 %813, i64 0
%818 = insertelement <4 x i8> %817, i8 %814, i64 1
%819 = insertelement <4 x i8> %818, i8 %815, i64 2
%820 = insertelement <4 x i8> %819, i8 %816, i64 3
%821 = shl <4 x i32> %808, <i32 2, i32 2, i32 2, i32 2>
%822 = shl <4 x i8> %820, <i8 1, i8 1, i8 1, i8 1>
%823 = and <4 x i8> %822, <i8 2, i8 2, i8 2, i8 2>
%824 = zext <4 x i8> %823 to <4 x i32>
%825 = or <4 x i32> %821, %824
%826 = getelementptr inbounds i8, i8* %389, i64 28
%827 = getelementptr inbounds i8, i8* %392, i64 28
%828 = getelementptr inbounds i8, i8* %395, i64 28
%829 = getelementptr inbounds i8, i8* %398, i64 28
%830 = load i8, i8* %809
%831 = load i8, i8* %810
%832 = load i8, i8* %811
%833 = load i8, i8* %812
%834 = insertelement <4 x i8> poison, i8 %830, i64 0
%835 = insertelement <4 x i8> %834, i8 %831, i64 1
%836 = insertelement <4 x i8> %835, i8 %832, i64 2
%837 = insertelement <4 x i8> %836, i8 %833, i64 3
%838 = and <4 x i8> %837, <i8 1, i8 1, i8 1, i8 1>
%839 = zext <4 x i8> %838 to <4 x i32>
%840 = or <4 x i32> %825, %839
%841 = getelementptr inbounds i8, i8* %389, i64 29
%842 = getelementptr inbounds i8, i8* %392, i64 29
%843 = getelementptr inbounds i8, i8* %395, i64 29
%844 = getelementptr inbounds i8, i8* %398, i64 29
%845 = load i8, i8* %826
%846 = load i8, i8* %827
%847 = load i8, i8* %828
%848 = load i8, i8* %829
%849 = insertelement <4 x i8> poison, i8 %845, i64 0
%850 = insertelement <4 x i8> %849, i8 %846, i64 1
%851 = insertelement <4 x i8> %850, i8 %847, i64 2
%852 = insertelement <4 x i8> %851, i8 %848, i64 3
%853 = shl <4 x i32> %840, <i32 2, i32 2, i32 2, i32 2>
%854 = shl <4 x i8> %852, <i8 1, i8 1, i8 1, i8 1>
%855 = and <4 x i8> %854, <i8 2, i8 2, i8 2, i8 2>
%856 = zext <4 x i8> %855 to <4 x i32>
%857 = or <4 x i32> %853, %856
%858 = getelementptr inbounds i8, i8* %389, i64 30
%859 = getelementptr inbounds i8, i8* %392, i64 30
%860 = getelementptr inbounds i8, i8* %395, i64 30
%861 = getelementptr inbounds i8, i8* %398, i64 30
%862 = load i8, i8* %841
%863 = load i8, i8* %842
%864 = load i8, i8* %843
%865 = load i8, i8* %844
%866 = insertelement <4 x i8> poison, i8 %862, i64 0
%867 = insertelement <4 x i8> %866, i8 %863, i64 1
%868 = insertelement <4 x i8> %867, i8 %864, i64 2
%869 = insertelement <4 x i8> %868, i8 %865, i64 3
%870 = and <4 x i8> %869, <i8 1, i8 1, i8 1, i8 1>
%871 = zext <4 x i8> %870 to <4 x i32>
%872 = or <4 x i32> %857, %871
%873 = getelementptr inbounds i8, i8* %389, i64 31
%874 = getelementptr inbounds i8, i8* %392, i64 31
%875 = getelementptr inbounds i8, i8* %395, i64 31
%876 = getelementptr inbounds i8, i8* %398, i64 31
%877 = load i8, i8* %858
%878 = load i8, i8* %859
%879 = load i8, i8* %860
%880 = load i8, i8* %861
%881 = insertelement <4 x i8> poison, i8 %877, i64 0
%882 = insertelement <4 x i8> %881, i8 %878, i64 1
%883 = insertelement <4 x i8> %882, i8 %879, i64 2
%884 = insertelement <4 x i8> %883, i8 %880, i64 3
%885 = shl <4 x i32> %872, <i32 2, i32 2, i32 2, i32 2>
%886 = shl <4 x i8> %884, <i8 1, i8 1, i8 1, i8 1>
%887 = and <4 x i8> %886, <i8 2, i8 2, i8 2, i8 2>
%888 = zext <4 x i8> %887 to <4 x i32>
%889 = or <4 x i32> %885, %888
%890 = load i8, i8* %873
%891 = load i8, i8* %874
%892 = load i8, i8* %875
%893 = load i8, i8* %876
%894 = insertelement <4 x i8> poison, i8 %890, i64 0
%895 = insertelement <4 x i8> %894, i8 %891, i64 1
%896 = insertelement <4 x i8> %895, i8 %892, i64 2
%897 = insertelement <4 x i8> %896, i8 %893, i64 3
%898 = and <4 x i8> %897, <i8 1, i8 1, i8 1, i8 1>
%899 = zext <4 x i8> %898 to <4 x i32>
%900 = or <4 x i32> %889, %899
%901 = bitcast i32* %399 to <4 x i32>*
store <4 x i32> %900, <4 x i32>* %901
%902 = add nuw i64 %387, 4
%903 = icmp eq i64 %902, %379
br i1 %903, label %904, label %386
904: ; preds = %386
%905 = icmp eq i64 %379, %361
br i1 %905, label %1102, label %906
906: ; preds = %363, %355, %904
%907 = phi i8* [ %186, %363 ], [ %186, %355 ], [ %381, %904 ]
%908 = phi i32* [ %187, %363 ], [ %187, %355 ], [ %382, %904 ]
%909 = phi i32 [ %188, %363 ], [ %188, %355 ], [ %385, %904 ]
br label %910
910: ; preds = %906, %910
%911 = phi i8* [ %1098, %910 ], [ %907, %906 ]
%912 = phi i32* [ %1099, %910 ], [ %908, %906 ]
%913 = phi i32 [ %1100, %910 ], [ %909, %906 ]
%914 = getelementptr inbounds i8, i8* %911, i64 1
%915 = load i8, i8* %911
%916 = shl i8 %915, 1
%917 = and i8 %916, 2
%918 = getelementptr inbounds i8, i8* %911, i64 2
%919 = load i8, i8* %914
%920 = and i8 %919, 1
%921 = or i8 %917, %920
%922 = getelementptr inbounds i8, i8* %911, i64 3
%923 = load i8, i8* %918
%924 = shl nuw nsw i8 %921, 2
%925 = shl i8 %923, 1
%926 = and i8 %925, 2
%927 = or i8 %924, %926
%928 = getelementptr inbounds i8, i8* %911, i64 4
%929 = load i8, i8* %922
%930 = and i8 %929, 1
%931 = or i8 %927, %930
%932 = getelementptr inbounds i8, i8* %911, i64 5
%933 = load i8, i8* %928
%934 = shl nuw nsw i8 %931, 2
%935 = shl i8 %933, 1
%936 = and i8 %935, 2
%937 = or i8 %934, %936
%938 = getelementptr inbounds i8, i8* %911, i64 6
%939 = load i8, i8* %932
%940 = and i8 %939, 1
%941 = or i8 %937, %940
%942 = zext i8 %941 to i32
%943 = getelementptr inbounds i8, i8* %911, i64 7
%944 = load i8, i8* %938
%945 = shl nuw nsw i32 %942, 2
%946 = shl i8 %944, 1
%947 = and i8 %946, 2
%948 = zext i8 %947 to i32
%949 = or i32 %945, %948
%950 = getelementptr inbounds i8, i8* %911, i64 8
%951 = load i8, i8* %943
%952 = and i8 %951, 1
%953 = zext i8 %952 to i32
%954 = or i32 %949, %953
%955 = getelementptr inbounds i8, i8* %911, i64 9
%956 = load i8, i8* %950
%957 = shl nuw nsw i32 %954, 2
%958 = shl i8 %956, 1
%959 = and i8 %958, 2
%960 = zext i8 %959 to i32
%961 = or i32 %957, %960
%962 = getelementptr inbounds i8, i8* %911, i64 10
%963 = load i8, i8* %955
%964 = and i8 %963, 1
%965 = zext i8 %964 to i32
%966 = or i32 %961, %965
%967 = getelementptr inbounds i8, i8* %911, i64 11
%968 = load i8, i8* %962
%969 = shl i32 %966, 2
%970 = shl i8 %968, 1
%971 = and i8 %970, 2
%972 = zext i8 %971 to i32
%973 = or i32 %969, %972
%974 = getelementptr inbounds i8, i8* %911, i64 12
%975 = load i8, i8* %967
%976 = and i8 %975, 1
%977 = zext i8 %976 to i32
%978 = or i32 %973, %977
%979 = getelementptr inbounds i8, i8* %911, i64 13
%980 = load i8, i8* %974
%981 = shl i32 %978, 2
%982 = shl i8 %980, 1
%983 = and i8 %982, 2
%984 = zext i8 %983 to i32
%985 = or i32 %981, %984
%986 = getelementptr inbounds i8, i8* %911, i64 14
%987 = load i8, i8* %979
%988 = and i8 %987, 1
%989 = zext i8 %988 to i32
%990 = or i32 %985, %989
%991 = getelementptr inbounds i8, i8* %911, i64 15
%992 = load i8, i8* %986
%993 = shl i32 %990, 2
%994 = shl i8 %992, 1
%995 = and i8 %994, 2
%996 = zext i8 %995 to i32
%997 = or i32 %993, %996
%998 = getelementptr inbounds i8, i8* %911, i64 16
%999 = load i8, i8* %991
%1000 = and i8 %999, 1
%1001 = zext i8 %1000 to i32
%1002 = or i32 %997, %1001
%1003 = getelementptr inbounds i8, i8* %911, i64 17
%1004 = load i8, i8* %998
%1005 = shl i32 %1002, 2
%1006 = shl i8 %1004, 1
%1007 = and i8 %1006, 2
%1008 = zext i8 %1007 to i32
%1009 = or i32 %1005, %1008
%1010 = getelementptr inbounds i8, i8* %911, i64 18
%1011 = load i8, i8* %1003
%1012 = and i8 %1011, 1
%1013 = zext i8 %1012 to i32
%1014 = or i32 %1009, %1013
%1015 = getelementptr inbounds i8, i8* %911, i64 19
%1016 = load i8, i8* %1010
%1017 = shl i32 %1014, 2
%1018 = shl i8 %1016, 1
%1019 = and i8 %1018, 2
%1020 = zext i8 %1019 to i32
%1021 = or i32 %1017, %1020
%1022 = getelementptr inbounds i8, i8* %911, i64 20
%1023 = load i8, i8* %1015
%1024 = and i8 %1023, 1
%1025 = zext i8 %1024 to i32
%1026 = or i32 %1021, %1025
%1027 = getelementptr inbounds i8, i8* %911, i64 21
%1028 = load i8, i8* %1022
%1029 = shl i32 %1026, 2
%1030 = shl i8 %1028, 1
%1031 = and i8 %1030, 2
%1032 = zext i8 %1031 to i32
%1033 = or i32 %1029, %1032
%1034 = getelementptr inbounds i8, i8* %911, i64 22
%1035 = load i8, i8* %1027
%1036 = and i8 %1035, 1
%1037 = zext i8 %1036 to i32
%1038 = or i32 %1033, %1037
%1039 = getelementptr inbounds i8, i8* %911, i64 23
%1040 = load i8, i8* %1034
%1041 = shl i32 %1038, 2
%1042 = shl i8 %1040, 1
%1043 = and i8 %1042, 2
%1044 = zext i8 %1043 to i32
%1045 = or i32 %1041, %1044
%1046 = getelementptr inbounds i8, i8* %911, i64 24
%1047 = load i8, i8* %1039
%1048 = and i8 %1047, 1
%1049 = zext i8 %1048 to i32
%1050 = or i32 %1045, %1049
%1051 = getelementptr inbounds i8, i8* %911, i64 25
%1052 = load i8, i8* %1046
%1053 = shl i32 %1050, 2
%1054 = shl i8 %1052, 1
%1055 = and i8 %1054, 2
%1056 = zext i8 %1055 to i32
%1057 = or i32 %1053, %1056
%1058 = getelementptr inbounds i8, i8* %911, i64 26
%1059 = load i8, i8* %1051
%1060 = and i8 %1059, 1
%1061 = zext i8 %1060 to i32
%1062 = or i32 %1057, %1061
%1063 = getelementptr inbounds i8, i8* %911, i64 27
%1064 = load i8, i8* %1058
%1065 = shl i32 %1062, 2
%1066 = shl i8 %1064, 1
%1067 = and i8 %1066, 2
%1068 = zext i8 %1067 to i32
%1069 = or i32 %1065, %1068
%1070 = getelementptr inbounds i8, i8* %911, i64 28
%1071 = load i8, i8* %1063
%1072 = and i8 %1071, 1
%1073 = zext i8 %1072 to i32
%1074 = or i32 %1069, %1073
%1075 = getelementptr inbounds i8, i8* %911, i64 29
%1076 = load i8, i8* %1070
%1077 = shl i32 %1074, 2
%1078 = shl i8 %1076, 1
%1079 = and i8 %1078, 2
%1080 = zext i8 %1079 to i32
%1081 = or i32 %1077, %1080
%1082 = getelementptr inbounds i8, i8* %911, i64 30
%1083 = load i8, i8* %1075
%1084 = and i8 %1083, 1
%1085 = zext i8 %1084 to i32
%1086 = or i32 %1081, %1085
%1087 = getelementptr inbounds i8, i8* %911, i64 31
%1088 = load i8, i8* %1082
%1089 = shl i32 %1086, 2
%1090 = shl i8 %1088, 1
%1091 = and i8 %1090, 2
%1092 = zext i8 %1091 to i32
%1093 = or i32 %1089, %1092
%1094 = load i8, i8* %1087
%1095 = and i8 %1094, 1
%1096 = zext i8 %1095 to i32
%1097 = or i32 %1093, %1096
%1098 = getelementptr i8, i8* %911, i64 32
%1099 = getelementptr inbounds i32, i32* %912, i64 1
store i32 %1097, i32* %912
%1100 = add nsw i32 %913, -32
%1101 = icmp ugt i32 %913, 63
br i1 %1101, label %910, label %1102
1102: ; preds = %910, %250, %193, %24, %904, %351, %10
%1103 = phi i8* [ %186, %351 ], [ %1, %10 ], [ %381, %904 ], [ %63, %24 ], [ %238, %193 ], [ %343, %250 ], [ %1098, %910 ]
%1104 = phi i32* [ %187, %351 ], [ %14, %10 ], [ %382, %904 ], [ %73, %24 ], [ %243, %193 ], [ %348, %250 ], [ %1099, %910 ]
%1105 = phi i32 [ %188, %351 ], [ %4, %10 ], [ %385, %904 ], [ %74, %24 ], [ %244, %193 ], [ %349, %250 ], [ %1100, %910 ]
%1106 = icmp sgt i32 %15, 0
br i1 %1106, label %1107, label %1111
1107: ; preds = %1102
%1108 = load i32, i32* %1104
%1109 = lshr i32 %1108, %16
%1110 = zext i32 %1109 to i64
br label %1111
1111: ; preds = %1107, %1102
%1112 = phi i64 [ %1110, %1107 ], [ 0, %1102 ]
%1113 = icmp sgt i32 %1105, 2
br i1 %1113, label %1114, label %1116
1114: ; preds = %1111
%1115 = zext i32 %2 to i64
br label %1125
1116: ; preds = %1111
%1117 = icmp sgt i32 %1105, 0
br i1 %1117, label %1118, label %1201
1118: ; preds = %1167, %1116
%1119 = phi i32 [ %16, %1116 ], [ %1170, %1167 ]
%1120 = phi i32 [ %1105, %1116 ], [ %1171, %1167 ]
%1121 = phi i32* [ %1104, %1116 ], [ %1169, %1167 ]
%1122 = phi i8* [ %1103, %1116 ], [ %1151, %1167 ]
%1123 = phi i64 [ %1112, %1116 ], [ %1168, %1167 ]
%1124 = zext i32 %2 to i64
br label %1173
1125: ; preds = %1114, %1167
%1126 = phi i32 [ %16, %1114 ], [ %1170, %1167 ]
%1127 = phi i32 [ %1105, %1114 ], [ %1171, %1167 ]
%1128 = phi i32* [ %1104, %1114 ], [ %1169, %1167 ]
%1129 = phi i8* [ %1103, %1114 ], [ %1151, %1167 ]
%1130 = phi i64 [ %1112, %1114 ], [ %1168, %1167 ]
%1131 = getelementptr inbounds i8, i8* %1129, i64 1
%1132 = load i8, i8* %1129
%1133 = zext i8 %1132 to i32
%1134 = and i32 %1133, %18
%1135 = sub nsw i32 %1126, %2
%1136 = shl i64 %1130, %1115
%1137 = zext i32 %1134 to i64
%1138 = or i64 %1136, %1137
%1139 = icmp slt i32 %1135, 1
br i1 %1139, label %1140, label %1147
1140: ; preds = %1125
%1141 = sub nsw i32 0, %1135
%1142 = zext i32 %1141 to i64
%1143 = lshr i64 %1138, %1142
%1144 = trunc i64 %1143 to i32
%1145 = getelementptr inbounds i32, i32* %1128, i64 1
store i32 %1144, i32* %1128
%1146 = add nsw i32 %1135, 32
br label %1147
1147: ; preds = %1140, %1125
%1148 = phi i64 [ %1137, %1140 ], [ %1138, %1125 ]
%1149 = phi i32* [ %1145, %1140 ], [ %1128, %1125 ]
%1150 = phi i32 [ %1146, %1140 ], [ %1135, %1125 ]
%1151 = getelementptr inbounds i8, i8* %1129, i64 2
%1152 = load i8, i8* %1131
%1153 = zext i8 %1152 to i32
%1154 = and i32 %1153, %18
%1155 = sub nsw i32 %1150, %2
%1156 = shl i64 %1148, %1115
%1157 = zext i32 %1154 to i64
%1158 = or i64 %1156, %1157
%1159 = icmp slt i32 %1155, 1
br i1 %1159, label %1160, label %1167
1160: ; preds = %1147
%1161 = sub nsw i32 0, %1155
%1162 = zext i32 %1161 to i64
%1163 = lshr i64 %1158, %1162
%1164 = trunc i64 %1163 to i32
%1165 = getelementptr inbounds i32, i32* %1149, i64 1
store i32 %1164, i32* %1149
%1166 = add nsw i32 %1155, 32
br label %1167
1167: ; preds = %1160, %1147
%1168 = phi i64 [ %1157, %1160 ], [ %1158, %1147 ]
%1169 = phi i32* [ %1165, %1160 ], [ %1149, %1147 ]
%1170 = phi i32 [ %1166, %1160 ], [ %1155, %1147 ]
%1171 = add nsw i32 %1127, -2
%1172 = icmp ugt i32 %1127, 4
br i1 %1172, label %1125, label %1118
1173: ; preds = %1118, %1196
%1174 = phi i32 [ %1120, %1118 ], [ %1179, %1196 ]
%1175 = phi i32 [ %1119, %1118 ], [ %1199, %1196 ]
%1176 = phi i32* [ %1121, %1118 ], [ %1198, %1196 ]
%1177 = phi i8* [ %1122, %1118 ], [ %1180, %1196 ]
%1178 = phi i64 [ %1123, %1118 ], [ %1197, %1196 ]
%1179 = add nsw i32 %1174, -1
%1180 = getelementptr inbounds i8, i8* %1177, i64 1
%1181 = load i8, i8* %1177
%1182 = zext i8 %1181 to i32
%1183 = and i32 %1182, %18
%1184 = sub nsw i32 %1175, %2
%1185 = shl i64 %1178, %1124
%1186 = zext i32 %1183 to i64
%1187 = or i64 %1185, %1186
%1188 = icmp slt i32 %1184, 1
br i1 %1188, label %1189, label %1196
1189: ; preds = %1173
%1190 = sub nsw i32 0, %1184
%1191 = zext i32 %1190 to i64
%1192 = lshr i64 %1187, %1191
%1193 = trunc i64 %1192 to i32
%1194 = getelementptr inbounds i32, i32* %1176, i64 1
store i32 %1193, i32* %1176
%1195 = add nsw i32 %1184, 32
br label %1196
1196: ; preds = %1189, %1173
%1197 = phi i64 [ %1186, %1189 ], [ %1187, %1173 ]
%1198 = phi i32* [ %1194, %1189 ], [ %1176, %1173 ]
%1199 = phi i32 [ %1195, %1189 ], [ %1184, %1173 ]
%1200 = icmp ugt i32 %1174, 1
br i1 %1200, label %1173, label %1201
1201: ; preds = %1196, %1116
%1202 = phi i64 [ %1112, %1116 ], [ %1197, %1196 ]
%1203 = phi i32* [ %1104, %1116 ], [ %1198, %1196 ]
%1204 = phi i32 [ %16, %1116 ], [ %1199, %1196 ]
%1205 = icmp slt i32 %1204, 32
br i1 %1205, label %1206, label %1210
1206: ; preds = %1201
%1207 = zext i32 %1204 to i64
%1208 = shl i64 %1202, %1207
%1209 = trunc i64 %1208 to i32
store i32 %1209, i32* %1203
br label %1210
1210: ; preds = %1201, %1206, %6
ret void
}