void IntegerPacker_16(void *stream, void *src, int nbits, int nbitt, int n,
                      int offset) {
  unsigned int *packed = (unsigned int *)stream;
  unsigned short *unpacked = (unsigned short *)src;
  unsigned long long temp;
  unsigned int mask, token, token1, token2, token3, token4, token5, token6,
      token7, token8;
  int bleft, i;
  if (nbits > 16 || nbitt > nbits)
    return;
  packed += offset / 32;
  bleft = 32 - (offset % 32);
  temp = 0;
  mask = ~(0xFFFFFFFF << nbitt);
  if (bleft == 32) {
    if (nbits == 16) {
      while (n > 3) {
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        *packed++ = (token1 << 16) | token2;
        *packed++ = (token3 << 16) | token4;
        n -= 4;
      }
    }
    if (nbits == 12) {
      while (n > 7) {
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        *packed++ = (token1 << 20) | (token2 << 8) | (token3 >> 4);
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        *packed++ =
            (token3 << 28) | (token4 << 16) | (token1 << 4) | (token2 >> 8);
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        *packed++ = (token2 << 24) | (token3 << 12) | token4;
        n -= 8;
      }
    }
    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 > 1) {
    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_16>:
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   $0x10,-0x14(%rbp)
jg     1140 <IntegerPacker_16+0x40>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1145 <IntegerPacker_16+0x45>
jmp    1db1 <IntegerPacker_16+0xcb1>
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    1bb3 <IntegerPacker_16+0xab3>
cmpl   $0x10,-0x14(%rbp)
jne    125b <IntegerPacker_16+0x15b>
jmp    11aa <IntegerPacker_16+0xaa>
cmpl   $0x3,-0x1c(%rbp)
jle    1256 <IntegerPacker_16+0x156>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x10,%ecx
or     -0x48(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
shl    $0x10,%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    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    11aa <IntegerPacker_16+0xaa>
jmp    125b <IntegerPacker_16+0x15b>
cmpl   $0xc,-0x14(%rbp)
jne    13bf <IntegerPacker_16+0x2bf>
jmp    126a <IntegerPacker_16+0x16a>
cmpl   $0x7,-0x1c(%rbp)
jle    13ba <IntegerPacker_16+0x2ba>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x14,%ecx
mov    -0x48(%rbp),%eax
shl    $0x8,%eax
or     %eax,%ecx
mov    -0x4c(%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    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%ecx
shl    $0x1c,%ecx
mov    -0x50(%rbp),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x44(%rbp),%eax
shl    $0x4,%eax
or     %eax,%ecx
mov    -0x48(%rbp),%eax
shr    $0x8,%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    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%ecx
shl    $0x18,%ecx
mov    -0x4c(%rbp),%eax
shl    $0xc,%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    126a <IntegerPacker_16+0x16a>
jmp    13bf <IntegerPacker_16+0x2bf>
cmpl   $0x8,-0x14(%rbp)
jne    14ff <IntegerPacker_16+0x3ff>
jmp    13ce <IntegerPacker_16+0x2ce>
cmpl   $0x7,-0x1c(%rbp)
jle    14fa <IntegerPacker_16+0x3fa>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    13ce <IntegerPacker_16+0x2ce>
jmp    14ff <IntegerPacker_16+0x3ff>
cmpl   $0x6,-0x14(%rbp)
jne    1763 <IntegerPacker_16+0x663>
jmp    150e <IntegerPacker_16+0x40e>
cmpl   $0xf,-0x1c(%rbp)
jle    175e <IntegerPacker_16+0x65e>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%rax),%eax
and    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    150e <IntegerPacker_16+0x40e>
jmp    1763 <IntegerPacker_16+0x663>
cmpl   $0x4,-0x14(%rbp)
jne    1895 <IntegerPacker_16+0x795>
jmp    1772 <IntegerPacker_16+0x672>
cmpl   $0x7,-0x1c(%rbp)
jle    1890 <IntegerPacker_16+0x790>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    1772 <IntegerPacker_16+0x672>
jmp    1895 <IntegerPacker_16+0x795>
cmpl   $0x2,-0x14(%rbp)
jne    1ac7 <IntegerPacker_16+0x9c7>
jmp    18a4 <IntegerPacker_16+0x7a4>
cmpl   $0xf,-0x1c(%rbp)
jle    1ac2 <IntegerPacker_16+0x9c2>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    18a4 <IntegerPacker_16+0x7a4>
jmp    1ac7 <IntegerPacker_16+0x9c7>
cmpl   $0x1,-0x14(%rbp)
jne    1bae <IntegerPacker_16+0xaae>
jmp    1ad6 <IntegerPacker_16+0x9d6>
cmpl   $0x1f,-0x1c(%rbp)
jle    1ba9 <IntegerPacker_16+0xaa9>
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     1b87 <IntegerPacker_16+0xa87>
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%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    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%rcx),%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
jmp    1aee <IntegerPacker_16+0x9ee>
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    1ad6 <IntegerPacker_16+0x9d6>
jmp    1bae <IntegerPacker_16+0xaae>
jmp    1bb3 <IntegerPacker_16+0xab3>
cmpl   $0x20,-0x64(%rbp)
jge    1bce <IntegerPacker_16+0xace>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    -0x64(%rbp),%ecx
shr    %cl,%eax
mov    %eax,%eax
mov    %rax,-0x38(%rbp)
jmp    1bd3 <IntegerPacker_16+0xad3>
cmpl   $0x1,-0x1c(%rbp)
jle    1cf3 <IntegerPacker_16+0xbf3>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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     1c61 <IntegerPacker_16+0xb61>
cmpl   $0x0,-0x64(%rbp)
jge    1c3a <IntegerPacker_16+0xb3a>
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    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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     1ce5 <IntegerPacker_16+0xbe5>
cmpl   $0x0,-0x64(%rbp)
jge    1cbe <IntegerPacker_16+0xbbe>
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    1bd3 <IntegerPacker_16+0xad3>
jmp    1cf8 <IntegerPacker_16+0xbf8>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1d95 <IntegerPacker_16+0xc95>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rbp)
movzwl (%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     1d90 <IntegerPacker_16+0xc90>
cmpl   $0x0,-0x64(%rbp)
jge    1d69 <IntegerPacker_16+0xc69>
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    1cf8 <IntegerPacker_16+0xbf8>
cmpl   $0x20,-0x64(%rbp)
jge    1db1 <IntegerPacker_16+0xcb1>
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_16>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x10,%edx
jg     13c3 <IntegerPacker_16+0x2c3>
cmp    %edx,%ecx
jg     13c3 <IntegerPacker_16+0x2c3>
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,%r13d
shl    %cl,%r13d
sub    %ebp,%r9d
mov    $0x20,%r11d
not    %r13d
test   %r9d,%r9d
jne    12d0 <IntegerPacker_16+0x1d0>
cmp    $0x10,%edx
jne    11a5 <IntegerPacker_16+0xa5>
cmp    $0x4,%r8d
jl     11a5 <IntegerPacker_16+0xa5>
nopl   (%rax)
mov    %r8d,%eax
movzwl (%rsi),%ecx
and    %r13d,%ecx
movzwl 0x2(%rsi),%edi
and    %r13d,%edi
movzwl 0x4(%rsi),%ebp
and    %r13d,%ebp
movzwl 0x6(%rsi),%ebx
add    $0x8,%rsi
and    %r13d,%ebx
shl    $0x10,%ecx
or     %edi,%ecx
mov    %ecx,(%r10)
shl    $0x10,%ebp
or     %ebx,%ebp
mov    %ebp,0x4(%r10)
add    $0x8,%r10
lea    -0x4(%rax),%r8d
cmp    $0x7,%eax
ja     1160 <IntegerPacker_16+0x60>
jmp    12d0 <IntegerPacker_16+0x1d0>
cmp    $0xc,%edx
jne    124d <IntegerPacker_16+0x14d>
cmp    $0x8,%r8d
jl     124d <IntegerPacker_16+0x14d>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%r14d
movzwl (%rsi),%edi
and    %r13d,%edi
movzwl 0x2(%rsi),%ebp
and    %r13d,%ebp
movzwl 0x4(%rsi),%ebx
and    %r13d,%ebx
movzwl 0x6(%rsi),%ecx
and    %r13d,%ecx
shl    $0x14,%edi
shl    $0x8,%ebp
or     %edi,%ebp
mov    %ebx,%edi
shr    $0x4,%edi
or     %ebp,%edi
mov    %edi,(%r10)
movzwl 0x8(%rsi),%ebp
and    %r13d,%ebp
movzwl 0xa(%rsi),%eax
and    %r13d,%eax
shl    $0x1c,%ebx
shl    $0x10,%ecx
or     %ebx,%ecx
shl    $0x4,%ebp
mov    %eax,%edi
shr    $0x8,%edi
or     %ebp,%edi
or     %ecx,%edi
mov    %edi,0x4(%r10)
movzwl 0xc(%rsi),%ecx
and    %r13d,%ecx
movzwl 0xe(%rsi),%edi
add    $0x10,%rsi
and    %r13d,%edi
shl    $0x18,%eax
shl    $0xc,%ecx
or     %eax,%ecx
or     %edi,%ecx
mov    %ecx,0x8(%r10)
add    $0xc,%r10
lea    -0x8(%r14),%r8d
cmp    $0xf,%r14d
ja     11c0 <IntegerPacker_16+0xc0>
jmp    12d0 <IntegerPacker_16+0x1d0>
cmp    $0x8,%edx
jne    13e9 <IntegerPacker_16+0x2e9>
cmp    $0x8,%r8d
jl     13e9 <IntegerPacker_16+0x2e9>
mov    %r8d,%eax
movzwl (%rsi),%ecx
and    %r13d,%ecx
movzwl 0x2(%rsi),%edi
and    %r13d,%edi
movzwl 0x4(%rsi),%ebp
and    %r13d,%ebp
movzwl 0x6(%rsi),%ebx
and    %r13d,%ebx
shl    $0x18,%ecx
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%ebp
or     %ebx,%ebp
or     %edi,%ebp
mov    %ebp,(%r10)
movzwl 0x8(%rsi),%ecx
and    %r13d,%ecx
movzwl 0xa(%rsi),%edi
and    %r13d,%edi
movzwl 0xc(%rsi),%ebp
and    %r13d,%ebp
movzwl 0xe(%rsi),%ebx
add    $0x10,%rsi
and    %r13d,%ebx
shl    $0x18,%ecx
shl    $0x10,%edi
or     %ecx,%edi
shl    $0x8,%ebp
or     %ebx,%ebp
or     %edi,%ebp
mov    %ebp,0x4(%r10)
add    $0x8,%r10
lea    -0x8(%rax),%r8d
cmp    $0xf,%eax
ja     1260 <IntegerPacker_16+0x160>
mov    %rsi,%r12
mov    %r10,%rbp
sub    %r9d,%r11d
test   %r9d,%r9d
jle    1389 <IntegerPacker_16+0x289>
mov    0x0(%rbp),%edi
mov    %r11d,%ecx
shr    %cl,%rdi
cmp    $0x2,%r8d
jl     1395 <IntegerPacker_16+0x295>
mov    %edx,%esi
jmp    1324 <IntegerPacker_16+0x224>
nopl   0x0(%rax)
mov    %r11d,%ecx
neg    %cl
shr    %cl,%rbx
mov    %ebx,0x0(%rbp)
add    $0x4,%rbp
add    $0x20,%r11d
lea    -0x2(%r8),%ecx
lea    0x4(%rax),%r12
cmp    $0x3,%r8d
mov    %ecx,%r8d
jbe    137c <IntegerPacker_16+0x27c>
mov    %r12,%rax
mov    %esi,%ecx
shl    %cl,%rdi
movzwl (%r12),%ebx
and    %r13d,%ebx
or     %rbx,%rdi
sub    %edx,%r11d
jle    1350 <IntegerPacker_16+0x250>
mov    %rdi,%rbx
jmp    1363 <IntegerPacker_16+0x263>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11d,%ecx
neg    %cl
shr    %cl,%rdi
mov    %edi,0x0(%rbp)
add    $0x4,%rbp
add    $0x20,%r11d
mov    %esi,%ecx
shl    %cl,%rbx
movzwl 0x2(%rax),%edi
and    %r13d,%edi
or     %rdi,%rbx
sub    %edx,%r11d
jle    1300 <IntegerPacker_16+0x200>
mov    %rbx,%rdi
jmp    1313 <IntegerPacker_16+0x213>
add    $0x4,%rax
mov    %rax,%r12
test   %ecx,%ecx
jg     139c <IntegerPacker_16+0x29c>
jmp    13b1 <IntegerPacker_16+0x2b1>
xor    %edi,%edi
cmp    $0x2,%r8d
jge    12f5 <IntegerPacker_16+0x1f5>
mov    %r8d,%ecx
test   %ecx,%ecx
jle    13b1 <IntegerPacker_16+0x2b1>
mov    %edx,%ecx
shl    %cl,%rdi
movzwl (%r12),%eax
and    %r13d,%eax
or     %rax,%rdi
sub    %edx,%r11d
jle    13ce <IntegerPacker_16+0x2ce>
mov    %rdi,%rax
cmp    $0x1f,%r11d
jg     13c3 <IntegerPacker_16+0x2c3>
mov    %r11d,%ecx
shl    %cl,%rax
mov    %eax,0x0(%rbp)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r11d,%ecx
neg    %cl
shr    %cl,%rdi
mov    %edi,0x0(%rbp)
add    $0x4,%rbp
add    $0x20,%r11d
cmp    $0x1f,%r11d
jle    13ba <IntegerPacker_16+0x2ba>
jmp    13c3 <IntegerPacker_16+0x2c3>
cmp    $0x6,%edx
jne    14f4 <IntegerPacker_16+0x3f4>
cmp    $0x10,%r8d
jl     14f4 <IntegerPacker_16+0x3f4>
nopl   0x0(%rax)
mov    %r8d,%r14d
movzwl (%rsi),%eax
and    %r13d,%eax
movzwl 0x2(%rsi),%ebp
and    %r13d,%ebp
movzwl 0x4(%rsi),%ecx
and    %r13d,%ecx
movzwl 0x6(%rsi),%edi
and    %r13d,%edi
movzwl 0x8(%rsi),%ebx
and    %r13d,%ebx
movzwl 0xa(%rsi),%r15d
and    %r13d,%r15d
movzwl 0xc(%rsi),%r12d
and    %r13d,%r12d
movzwl 0xe(%rsi),%r8d
and    %r13d,%r8d
shl    $0x1a,%eax
shl    $0x14,%ebp
or     %eax,%ebp
shl    $0xe,%ecx
shl    $0x8,%edi
or     %ecx,%edi
or     %ebp,%edi
shl    $0x2,%ebx
mov    %r15d,%eax
shr    $0x4,%eax
or     %ebx,%eax
or     %edi,%eax
mov    %eax,(%r10)
movzwl 0x10(%rsi),%eax
and    %r13d,%eax
movzwl 0x12(%rsi),%ecx
and    %r13d,%ecx
movzwl 0x14(%rsi),%ebx
and    %r13d,%ebx
shl    $0x1c,%r15d
shl    $0x16,%r12d
or     %r15d,%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)
movzwl 0x16(%rsi),%eax
and    %r13d,%eax
movzwl 0x18(%rsi),%ecx
and    %r13d,%ecx
movzwl 0x1a(%rsi),%edi
and    %r13d,%edi
movzwl 0x1c(%rsi),%ebp
and    %r13d,%ebp
movzwl 0x1e(%rsi),%r8d
add    $0x20,%rsi
and    %r13d,%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(%r14),%r8d
cmp    $0x1f,%r14d
ja     1400 <IntegerPacker_16+0x300>
cmp    $0x4,%edx
jne    1521 <IntegerPacker_16+0x421>
cmp    $0x8,%r8d
jl     1521 <IntegerPacker_16+0x421>
xor    %eax,%eax
mov    %r8d,%r14d
sub    $0xf,%r14d
cmovb  %eax,%r14d
add    $0x7,%r14d
cmp    $0x18,%r14d
jae    158b <IntegerPacker_16+0x48b>
mov    %rsi,%r12
mov    %r10,%rbp
jmp    16f6 <IntegerPacker_16+0x5f6>
cmp    $0x2,%edx
jne    1552 <IntegerPacker_16+0x452>
cmp    $0x10,%r8d
jl     1552 <IntegerPacker_16+0x452>
xor    %eax,%eax
mov    %r8d,%r14d
sub    $0x1f,%r14d
cmovb  %eax,%r14d
add    $0xf,%r14d
cmp    $0x30,%r14d
jae    178a <IntegerPacker_16+0x68a>
mov    %rsi,%r12
mov    %r10,%rbp
jmp    1a8a <IntegerPacker_16+0x98a>
cmp    $0x1,%edx
jne    12d0 <IntegerPacker_16+0x1d0>
cmp    $0x20,%r8d
jl     12d0 <IntegerPacker_16+0x1d0>
xor    %eax,%eax
mov    %r8d,%r14d
sub    $0x3f,%r14d
cmovb  %eax,%r14d
add    $0x1f,%r14d
cmp    $0x60,%r14d
jae    1b87 <IntegerPacker_16+0xa87>
mov    %rsi,%r12
mov    %r10,%rbp
jmp    232b <IntegerPacker_16+0x122b>
shr    $0x3,%r14d
add    $0x1,%r14d
mov    %r14d,%r15d
and    $0xfffffffc,%r15d
mov    %r15,%r12
shl    $0x4,%r12
add    %rsi,%r12
lea    (%r10,%r15,4),%rbp
lea    0x0(,%r15,8),%eax
sub    %eax,%r8d
movd   %r13d,%xmm0
pshufd $0x0,%xmm0,%xmm9
xor    %ecx,%ecx
pxor   %xmm8,%xmm8
movdqu (%rsi),%xmm2
movdqu 0x10(%rsi),%xmm10
movdqu 0x20(%rsi),%xmm5
movdqu 0x30(%rsi),%xmm7
movdqa %xmm5,%xmm4
punpcklwd %xmm7,%xmm4
movdqa %xmm2,%xmm3
punpcklwd %xmm10,%xmm3
movdqa %xmm3,%xmm1
punpckldq %xmm4,%xmm1
punpcklwd %xmm1,%xmm1
pshufd $0x55,%xmm4,%xmm6
pshufd $0x55,%xmm3,%xmm0
punpckldq %xmm6,%xmm0
punpcklwd %xmm0,%xmm0
pshufd $0xff,%xmm3,%xmm11
punpckhdq %xmm4,%xmm3
punpcklwd %xmm3,%xmm3
pshufd $0xff,%xmm4,%xmm4
punpckldq %xmm4,%xmm11
punpckhwd %xmm7,%xmm5
punpckhwd %xmm10,%xmm2
movdqa %xmm2,%xmm6
punpckldq %xmm5,%xmm6
pshufd $0x55,%xmm5,%xmm4
pshufd $0x55,%xmm2,%xmm7
punpckldq %xmm4,%xmm7
pshufd $0xff,%xmm2,%xmm10
punpckhdq %xmm5,%xmm2
pshufd $0xff,%xmm5,%xmm4
punpckldq %xmm4,%xmm10
pand   %xmm9,%xmm1
pand   %xmm9,%xmm0
pslld  $0x8,%xmm1
pslld  $0x4,%xmm0
pand   %xmm9,%xmm3
por    %xmm1,%xmm3
por    %xmm0,%xmm3
punpcklwd %xmm8,%xmm11
pand   %xmm9,%xmm11
punpcklwd %xmm8,%xmm6
pand   %xmm9,%xmm6
punpcklwd %xmm8,%xmm7
pand   %xmm9,%xmm7
pslld  $0x10,%xmm3
pslld  $0xc,%xmm11
pslld  $0x8,%xmm6
por    %xmm11,%xmm6
por    %xmm3,%xmm6
pslld  $0x4,%xmm7
punpcklwd %xmm8,%xmm2
pand   %xmm9,%xmm2
por    %xmm7,%xmm2
por    %xmm6,%xmm2
pslld  $0x4,%xmm2
punpcklwd %xmm8,%xmm10
pand   %xmm9,%xmm10
por    %xmm2,%xmm10
movdqu %xmm10,(%r10,%rcx,4)
add    $0x4,%rcx
add    $0x40,%rsi
cmp    %rcx,%r15
jne    15c5 <IntegerPacker_16+0x4c5>
cmp    %r14,%r15
je     12d6 <IntegerPacker_16+0x1d6>
mov    %r8d,%eax
nopl   0x0(%rax)
movzwl (%r12),%ecx
and    %r13d,%ecx
movzwl 0x2(%r12),%esi
and    %r13d,%esi
shl    $0x8,%ecx
shl    $0x4,%esi
or     %ecx,%esi
movzwl 0x4(%r12),%ecx
and    %r13d,%ecx
or     %esi,%ecx
movzwl 0x6(%r12),%esi
and    %r13d,%esi
movzwl 0x8(%r12),%edi
and    %r13d,%edi
movzwl 0xa(%r12),%ebx
and    %r13d,%ebx
shl    $0x10,%ecx
shl    $0xc,%esi
shl    $0x8,%edi
or     %esi,%edi
or     %ecx,%edi
shl    $0x4,%ebx
movzwl 0xc(%r12),%ecx
and    %r13d,%ecx
or     %ebx,%ecx
or     %edi,%ecx
shl    $0x4,%ecx
movzwl 0xe(%r12),%esi
add    $0x10,%r12
and    %r13d,%esi
or     %ecx,%esi
mov    %esi,0x0(%rbp)
add    $0x4,%rbp
lea    -0x8(%rax),%r8d
cmp    $0xf,%eax
mov    %r8d,%eax
ja     1700 <IntegerPacker_16+0x600>
jmp    12d6 <IntegerPacker_16+0x1d6>
shr    $0x4,%r14d
add    $0x1,%r14d
mov    %r14d,%r15d
and    $0xfffffffc,%r15d
mov    %r15,%r12
shl    $0x5,%r12
add    %rsi,%r12
lea    (%r10,%r15,4),%rbp
mov    %r15d,%eax
shl    $0x4,%eax
sub    %eax,%r8d
movd   %r13d,%xmm0
pshufd $0x0,%xmm0,%xmm0
add    $0x7e,%rsi
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
movzwl -0x7e(%rsi),%eax
movd   %eax,%xmm3
pinsrw $0x1,-0x5e(%rsi),%xmm3
pinsrw $0x2,-0x3e(%rsi),%xmm3
pinsrw $0x3,-0x1e(%rsi),%xmm3
punpcklwd %xmm1,%xmm3
pand   %xmm0,%xmm3
movzwl -0x7c(%rsi),%eax
movd   %eax,%xmm4
pinsrw $0x1,-0x5c(%rsi),%xmm4
pinsrw $0x2,-0x3c(%rsi),%xmm4
pinsrw $0x3,-0x1c(%rsi),%xmm4
punpcklwd %xmm1,%xmm4
pand   %xmm0,%xmm4
pslld  $0x4,%xmm3
pslld  $0x2,%xmm4
movzwl -0x7a(%rsi),%eax
movd   %eax,%xmm2
pinsrw $0x1,-0x5a(%rsi),%xmm2
pinsrw $0x2,-0x3a(%rsi),%xmm2
pinsrw $0x3,-0x1a(%rsi),%xmm2
por    %xmm3,%xmm4
punpcklwd %xmm1,%xmm2
pand   %xmm0,%xmm2
por    %xmm4,%xmm2
movzwl -0x78(%rsi),%eax
movd   %eax,%xmm4
pinsrw $0x1,-0x58(%rsi),%xmm4
pinsrw $0x2,-0x38(%rsi),%xmm4
pinsrw $0x3,-0x18(%rsi),%xmm4
punpcklwd %xmm1,%xmm4
pand   %xmm0,%xmm4
movzwl -0x76(%rsi),%eax
movd   %eax,%xmm3
pinsrw $0x1,-0x56(%rsi),%xmm3
pinsrw $0x2,-0x36(%rsi),%xmm3
pinsrw $0x3,-0x16(%rsi),%xmm3
punpcklwd %xmm1,%xmm3
pand   %xmm0,%xmm3
movzwl -0x74(%rsi),%eax
movd   %eax,%xmm5
pinsrw $0x1,-0x54(%rsi),%xmm5
pinsrw $0x2,-0x34(%rsi),%xmm5
pinsrw $0x3,-0x14(%rsi),%xmm5
punpcklwd %xmm1,%xmm5
pand   %xmm0,%xmm5
pslld  $0x8,%xmm2
pslld  $0x6,%xmm4
pslld  $0x4,%xmm3
por    %xmm4,%xmm3
por    %xmm2,%xmm3
pslld  $0x2,%xmm5
movzwl -0x72(%rsi),%eax
movd   %eax,%xmm2
pinsrw $0x1,-0x52(%rsi),%xmm2
pinsrw $0x2,-0x32(%rsi),%xmm2
pinsrw $0x3,-0x12(%rsi),%xmm2
punpcklwd %xmm1,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movzwl -0x70(%rsi),%eax
movd   %eax,%xmm4
pinsrw $0x1,-0x50(%rsi),%xmm4
pinsrw $0x2,-0x30(%rsi),%xmm4
pinsrw $0x3,-0x10(%rsi),%xmm4
punpcklwd %xmm1,%xmm4
pand   %xmm0,%xmm4
movzwl -0x6e(%rsi),%eax
movd   %eax,%xmm3
pinsrw $0x1,-0x4e(%rsi),%xmm3
pinsrw $0x2,-0x2e(%rsi),%xmm3
pinsrw $0x3,-0xe(%rsi),%xmm3
punpcklwd %xmm1,%xmm3
pand   %xmm0,%xmm3
movzwl -0x6c(%rsi),%eax
movd   %eax,%xmm5
pinsrw $0x1,-0x4c(%rsi),%xmm5
pinsrw $0x2,-0x2c(%rsi),%xmm5
pinsrw $0x3,-0xc(%rsi),%xmm5
punpcklwd %xmm1,%xmm5
pand   %xmm0,%xmm5
pslld  $0x8,%xmm2
pslld  $0x6,%xmm4
pslld  $0x4,%xmm3
por    %xmm4,%xmm3
por    %xmm2,%xmm3
pslld  $0x2,%xmm5
movzwl -0x6a(%rsi),%eax
movd   %eax,%xmm2
pinsrw $0x1,-0x4a(%rsi),%xmm2
pinsrw $0x2,-0x2a(%rsi),%xmm2
pinsrw $0x3,-0xa(%rsi),%xmm2
punpcklwd %xmm1,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movzwl -0x68(%rsi),%eax
movd   %eax,%xmm4
pinsrw $0x1,-0x48(%rsi),%xmm4
pinsrw $0x2,-0x28(%rsi),%xmm4
pinsrw $0x3,-0x8(%rsi),%xmm4
punpcklwd %xmm1,%xmm4
pand   %xmm0,%xmm4
movzwl -0x66(%rsi),%eax
movd   %eax,%xmm3
pinsrw $0x1,-0x46(%rsi),%xmm3
pinsrw $0x2,-0x26(%rsi),%xmm3
pinsrw $0x3,-0x6(%rsi),%xmm3
punpcklwd %xmm1,%xmm3
pand   %xmm0,%xmm3
movzwl -0x64(%rsi),%eax
movd   %eax,%xmm5
pinsrw $0x1,-0x44(%rsi),%xmm5
pinsrw $0x2,-0x24(%rsi),%xmm5
pinsrw $0x3,-0x4(%rsi),%xmm5
punpcklwd %xmm1,%xmm5
pand   %xmm0,%xmm5
pslld  $0x8,%xmm2
pslld  $0x6,%xmm4
pslld  $0x4,%xmm3
por    %xmm4,%xmm3
por    %xmm2,%xmm3
pslld  $0x2,%xmm5
movzwl -0x62(%rsi),%eax
movd   %eax,%xmm2
pinsrw $0x1,-0x42(%rsi),%xmm2
pinsrw $0x2,-0x22(%rsi),%xmm2
pinsrw $0x3,-0x2(%rsi),%xmm2
punpcklwd %xmm1,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movzwl -0x60(%rsi),%eax
movd   %eax,%xmm3
pinsrw $0x1,-0x40(%rsi),%xmm3
pinsrw $0x2,-0x20(%rsi),%xmm3
pinsrw $0x3,(%rsi),%xmm3
pslld  $0x2,%xmm2
punpcklwd %xmm1,%xmm3
pand   %xmm0,%xmm3
por    %xmm2,%xmm3
movdqu %xmm3,(%r10,%rcx,4)
add    $0x4,%rcx
sub    $0xffffffffffffff80,%rsi
cmp    %rcx,%r15
jne    17c4 <IntegerPacker_16+0x6c4>
cmp    %r14,%r15
je     12d6 <IntegerPacker_16+0x1d6>
mov    %r8d,%ecx
movzwl (%r12),%eax
and    %r13d,%eax
movzwl 0x2(%r12),%esi
and    %r13d,%esi
shl    $0x4,%eax
shl    $0x2,%esi
or     %eax,%esi
movzwl 0x4(%r12),%eax
and    %r13d,%eax
or     %esi,%eax
movzwl 0x6(%r12),%esi
and    %r13d,%esi
movzwl 0x8(%r12),%edi
and    %r13d,%edi
movzwl 0xa(%r12),%ebx
and    %r13d,%ebx
shl    $0x8,%eax
shl    $0x6,%esi
shl    $0x4,%edi
or     %esi,%edi
or     %eax,%edi
shl    $0x2,%ebx
movzwl 0xc(%r12),%eax
and    %r13d,%eax
or     %ebx,%eax
or     %edi,%eax
movzwl 0xe(%r12),%esi
and    %r13d,%esi
movzwl 0x10(%r12),%edi
and    %r13d,%edi
movzwl 0x12(%r12),%ebx
and    %r13d,%ebx
shl    $0x8,%eax
shl    $0x6,%esi
shl    $0x4,%edi
or     %esi,%edi
or     %eax,%edi
shl    $0x2,%ebx
movzwl 0x14(%r12),%eax
and    %r13d,%eax
or     %ebx,%eax
or     %edi,%eax
movzwl 0x16(%r12),%esi
and    %r13d,%esi
movzwl 0x18(%r12),%edi
and    %r13d,%edi
movzwl 0x1a(%r12),%ebx
and    %r13d,%ebx
shl    $0x8,%eax
shl    $0x6,%esi
shl    $0x4,%edi
or     %esi,%edi
or     %eax,%edi
shl    $0x2,%ebx
movzwl 0x1c(%r12),%eax
and    %r13d,%eax
or     %ebx,%eax
or     %edi,%eax
shl    $0x2,%eax
movzwl 0x1e(%r12),%esi
add    $0x20,%r12
and    %r13d,%esi
or     %eax,%esi
mov    %esi,0x0(%rbp)
add    $0x4,%rbp
lea    -0x10(%rcx),%r8d
cmp    $0x1f,%ecx
mov    %r8d,%ecx
ja     1a8d <IntegerPacker_16+0x98d>
jmp    12d6 <IntegerPacker_16+0x1d6>
shr    $0x5,%r14d
add    $0x1,%r14d
mov    %r14d,%r15d
and    $0xfffffffc,%r15d
mov    %r15,%r12
shl    $0x6,%r12
add    %rsi,%r12
lea    (%r10,%r15,4),%rbp
mov    %r15d,%eax
shl    $0x5,%eax
sub    %eax,%r8d
add    $0xfe,%rsi
xor    %ecx,%ecx
movzwl -0xfe(%rsi),%eax
movd   %eax,%xmm13
pinsrw $0x1,-0xbe(%rsi),%xmm13
ff ff 01
movzwl -0xfc(%rsi),%eax
movd   %eax,%xmm0
pinsrw $0x1,-0xbc(%rsi),%xmm0
ff 01
movdqa %xmm0,%xmm1
movzwl -0xfa(%rsi),%eax
movd   %eax,%xmm2
pinsrw $0x1,-0xba(%rsi),%xmm2
ff 01
movzwl -0xf8(%rsi),%eax
movd   %eax,%xmm0
pinsrw $0x1,-0xb8(%rsi),%xmm0
ff 01
pinsrw $0x2,-0x7e(%rsi),%xmm13
movzwl -0xf6(%rsi),%eax
movd   %eax,%xmm15
pinsrw $0x2,-0x7c(%rsi),%xmm1
pinsrw $0x1,-0xb6(%rsi),%xmm15
ff ff 01
pinsrw $0x2,-0x7a(%rsi),%xmm2
movzwl -0xf4(%rsi),%eax
movd   %eax,%xmm12
pinsrw $0x2,-0x78(%rsi),%xmm0
movdqa %xmm0,%xmm4
pinsrw $0x1,-0xb4(%rsi),%xmm12
ff ff 01
pinsrw $0x2,-0x76(%rsi),%xmm15
movzwl -0xf2(%rsi),%eax
movd   %eax,%xmm3
pinsrw $0x2,-0x74(%rsi),%xmm12
pinsrw $0x1,-0xb2(%rsi),%xmm3
ff 01
pinsrw $0x2,-0x72(%rsi),%xmm3
movzwl -0xf0(%rsi),%eax
movd   %eax,%xmm0
pinsrw $0x3,-0x3e(%rsi),%xmm13
pinsrw $0x1,-0xb0(%rsi),%xmm0
ff 01
pinsrw $0x3,-0x3c(%rsi),%xmm1
movdqa %xmm1,%xmm5
pinsrw $0x2,-0x70(%rsi),%xmm0
pinsrw $0x3,-0x3a(%rsi),%xmm2
movzwl -0xee(%rsi),%eax
movd   %eax,%xmm8
pinsrw $0x3,-0x38(%rsi),%xmm4
pinsrw $0x1,-0xae(%rsi),%xmm8
ff ff 01
pinsrw $0x3,-0x36(%rsi),%xmm15
pinsrw $0x2,-0x6e(%rsi),%xmm8
pinsrw $0x3,-0x34(%rsi),%xmm12
movzwl -0xec(%rsi),%eax
movd   %eax,%xmm6
pinsrw $0x3,-0x32(%rsi),%xmm3
pinsrw $0x1,-0xac(%rsi),%xmm6
ff 01
pinsrw $0x3,-0x30(%rsi),%xmm0
movdqa %xmm0,%xmm1
pinsrw $0x2,-0x6c(%rsi),%xmm6
pinsrw $0x3,-0x2e(%rsi),%xmm8
movzwl -0xea(%rsi),%eax
pinsrw $0x3,-0x2c(%rsi),%xmm6
movd   %eax,%xmm10
pinsrw $0x1,-0xaa(%rsi),%xmm10
ff ff 01
paddw  %xmm13,%xmm13
movdqa 0x12c7(%rip),%xmm0
pand   %xmm0,%xmm5
movdqa %xmm5,-0x28(%rsp)
pinsrw $0x2,-0x6a(%rsi),%xmm10
paddw  %xmm2,%xmm2
pinsrw $0x3,-0x2a(%rsi),%xmm10
movzwl -0xe8(%rsi),%eax
pand   %xmm0,%xmm4
movdqa %xmm4,-0x38(%rsp)
movd   %eax,%xmm11
pinsrw $0x1,-0xa8(%rsi),%xmm11
ff ff 01
paddw  %xmm15,%xmm15
pand   %xmm0,%xmm12
pinsrw $0x2,-0x68(%rsi),%xmm11
paddw  %xmm3,%xmm3
pinsrw $0x3,-0x28(%rsi),%xmm11
movzwl -0xe6(%rsi),%eax
pand   %xmm0,%xmm1
movdqa %xmm1,%xmm4
movd   %eax,%xmm14
pinsrw $0x1,-0xa6(%rsi),%xmm14
ff ff 01
paddw  %xmm8,%xmm8
movdqa %xmm6,%xmm5
pand   %xmm0,%xmm5
pinsrw $0x2,-0x66(%rsi),%xmm14
paddw  %xmm10,%xmm10
pinsrw $0x3,-0x26(%rsi),%xmm14
movzwl -0xe4(%rsi),%eax
pand   %xmm0,%xmm11
movdqa %xmm0,%xmm1
movd   %eax,%xmm7
pinsrw $0x1,-0xa4(%rsi),%xmm7
ff 01
movdqa 0x121c(%rip),%xmm0
pand   %xmm0,%xmm13
paddw  %xmm14,%xmm14
pinsrw $0x2,-0x64(%rsi),%xmm7
pand   %xmm0,%xmm2
pinsrw $0x3,-0x24(%rsi),%xmm7
movzwl -0xe2(%rsi),%eax
pand   %xmm0,%xmm15
movd   %eax,%xmm9
pinsrw $0x1,-0xa2(%rsi),%xmm9
ff ff 01
pand   %xmm0,%xmm3
pand   %xmm1,%xmm7
pinsrw $0x2,-0x62(%rsi),%xmm9
pxor   %xmm1,%xmm1
punpcklwd %xmm1,%xmm4
movdqa %xmm4,-0x48(%rsp)
pinsrw $0x3,-0x22(%rsi),%xmm9
movzwl -0xe0(%rsi),%eax
pand   %xmm0,%xmm8
movd   %eax,%xmm6
pinsrw $0x1,-0xa0(%rsi),%xmm6
ff 01
punpcklwd %xmm1,%xmm5
movdqa %xmm5,%xmm4
paddw  %xmm9,%xmm9
pinsrw $0x2,-0x60(%rsi),%xmm6
pand   %xmm0,%xmm10
pinsrw $0x3,-0x20(%rsi),%xmm6
movzwl -0xde(%rsi),%eax
movdqa -0x28(%rsp),%xmm5
por    %xmm13,%xmm5
movdqa %xmm5,-0x28(%rsp)
movd   %eax,%xmm13
pinsrw $0x1,-0x9e(%rsi),%xmm13
ff ff 01
punpcklwd %xmm1,%xmm11
pand   0x1148(%rip),%xmm6
pinsrw $0x2,-0x5e(%rsi),%xmm13
pand   %xmm0,%xmm14
pinsrw $0x3,-0x1e(%rsi),%xmm13
movzwl -0xdc(%rsi),%eax
movdqa -0x38(%rsp),%xmm0
por    %xmm2,%xmm0
movdqa %xmm0,-0x38(%rsp)
movd   %eax,%xmm5
pinsrw $0x1,-0x9c(%rsi),%xmm5
ff 01
punpcklwd %xmm1,%xmm7
paddw  %xmm13,%xmm13
pinsrw $0x2,-0x5c(%rsi),%xmm5
pand   0x1109(%rip),%xmm9
pinsrw $0x3,-0x1c(%rsi),%xmm5
movzwl -0xda(%rsi),%eax
por    %xmm15,%xmm12
movd   %eax,%xmm2
pinsrw $0x1,-0x9a(%rsi),%xmm2
ff 01
punpcklwd %xmm1,%xmm6
movdqa 0x10ce(%rip),%xmm0
pand   %xmm0,%xmm5
pinsrw $0x2,-0x5a(%rsi),%xmm2
punpcklwd %xmm1,%xmm3
pinsrw $0x3,-0x1a(%rsi),%xmm2
movzwl -0xd8(%rsi),%eax
movdqa -0x48(%rsp),%xmm0
por    %xmm3,%xmm0
movdqa %xmm0,-0x48(%rsp)
movd   %eax,%xmm15
pinsrw $0x1,-0x98(%rsi),%xmm15
ff ff 01
movdqa 0x109c(%rip),%xmm3
pand   %xmm3,%xmm13
paddw  %xmm2,%xmm2
pinsrw $0x2,-0x58(%rsi),%xmm15
punpcklwd %xmm1,%xmm8
pinsrw $0x3,-0x18(%rsi),%xmm15
movzwl -0xd6(%rsi),%eax
por    %xmm8,%xmm4
movdqa %xmm4,-0x18(%rsp)
movd   %eax,%xmm0
pinsrw $0x1,-0x96(%rsi),%xmm0
ff 01
punpcklwd %xmm1,%xmm5
movdqa 0x1045(%rip),%xmm4
pand   %xmm4,%xmm15
pinsrw $0x2,-0x56(%rsi),%xmm0
punpcklwd %xmm1,%xmm10
pinsrw $0x3,-0x16(%rsi),%xmm0
movzwl -0xd4(%rsi),%eax
por    %xmm10,%xmm11
movd   %eax,%xmm8
pinsrw $0x1,-0x94(%rsi),%xmm8
ff ff 01
pand   %xmm3,%xmm2
punpcklwd %xmm1,%xmm15
pinsrw $0x2,-0x54(%rsi),%xmm8
punpcklwd %xmm1,%xmm14
paddw  %xmm0,%xmm0
pinsrw $0x3,-0x14(%rsi),%xmm8
punpcklwd %xmm1,%xmm9
pand   %xmm3,%xmm0
pand   %xmm4,%xmm8
movzwl -0xd2(%rsi),%eax
por    %xmm14,%xmm7
movd   %eax,%xmm14
pinsrw $0x1,-0x92(%rsi),%xmm14
ff ff 01
punpcklwd %xmm1,%xmm13
punpcklwd %xmm1,%xmm8
pinsrw $0x2,-0x52(%rsi),%xmm14
movdqa -0x28(%rsp),%xmm10
psllw  $0x2,%xmm10
pinsrw $0x3,-0x12(%rsi),%xmm14
movzwl -0xd0(%rsi),%eax
movdqa -0x38(%rsp),%xmm3
por    %xmm10,%xmm3
movd   %eax,%xmm10
pinsrw $0x1,-0x90(%rsi),%xmm10
ff ff 01
punpcklwd %xmm1,%xmm2
paddw  %xmm14,%xmm14
pinsrw $0x2,-0x50(%rsi),%xmm10
psllw  $0x2,%xmm3
pinsrw $0x3,-0x10(%rsi),%xmm10
movzwl -0xce(%rsi),%eax
por    %xmm3,%xmm12
movd   %eax,%xmm1
pinsrw $0x1,-0x8e(%rsi),%xmm1
ff 01
pxor   %xmm3,%xmm3
punpcklwd %xmm3,%xmm0
movdqa 0xf50(%rip),%xmm4
pand   %xmm4,%xmm14
pinsrw $0x2,-0x4e(%rsi),%xmm1
punpcklwd %xmm3,%xmm12
pand   0xf27(%rip),%xmm10
pinsrw $0x3,-0xe(%rsi),%xmm1
pslld  $0x2,%xmm12
punpcklwd %xmm3,%xmm10
pxor   %xmm3,%xmm3
paddw  %xmm1,%xmm1
movzwl -0xcc(%rsi),%eax
movdqa -0x48(%rsp),%xmm4
por    %xmm12,%xmm4
movd   %eax,%xmm12
pinsrw $0x1,-0x8c(%rsi),%xmm12
ff ff 01
punpcklwd %xmm3,%xmm14
pand   0xef0(%rip),%xmm1
pinsrw $0x2,-0x4c(%rsi),%xmm12
punpcklwd %xmm3,%xmm1
pinsrw $0x3,-0xc(%rsi),%xmm12
movzwl -0xca(%rsi),%eax
por    %xmm9,%xmm6
movd   %eax,%xmm3
pinsrw $0x1,-0x8a(%rsi),%xmm3
ff 01
por    %xmm13,%xmm5
movdqa 0xea7(%rip),%xmm9
pand   %xmm9,%xmm12
pinsrw $0x2,-0x4a(%rsi),%xmm3
por    %xmm2,%xmm15
punpcklwd 0xeae(%rip),%xmm12
pinsrw $0x3,-0xa(%rsi),%xmm3
movdqa %xmm4,%xmm2
pslld  $0x2,%xmm2
paddw  %xmm3,%xmm3
movdqa 0xe83(%rip),%xmm4
pand   %xmm4,%xmm3
movzwl -0xc8(%rsi),%eax
por    %xmm0,%xmm8
movd   %eax,%xmm0
pinsrw $0x1,-0x88(%rsi),%xmm0
ff 01
por    %xmm14,%xmm10
pxor   %xmm13,%xmm13
punpcklwd %xmm13,%xmm3
pinsrw $0x2,-0x48(%rsi),%xmm0
por    %xmm1,%xmm12
pinsrw $0x3,-0x8(%rsi),%xmm0
pand   %xmm9,%xmm0
movdqa -0x18(%rsp),%xmm1
por    %xmm2,%xmm1
punpcklwd %xmm13,%xmm0
pxor   %xmm13,%xmm13
por    %xmm3,%xmm0
movzwl -0xc6(%rsi),%eax
pslld  $0x2,%xmm1
movd   %eax,%xmm2
pinsrw $0x1,-0x86(%rsi),%xmm2
ff 01
por    %xmm1,%xmm11
pslld  $0x2,%xmm11
pinsrw $0x2,-0x46(%rsi),%xmm2
por    %xmm11,%xmm7
pslld  $0x2,%xmm7
pinsrw $0x3,-0x6(%rsi),%xmm2
por    %xmm7,%xmm6
paddw  %xmm2,%xmm2
pand   %xmm4,%xmm2
movzwl -0xc4(%rsi),%eax
pslld  $0x2,%xmm6
movd   %eax,%xmm1
pinsrw $0x1,-0x84(%rsi),%xmm1
ff 01
por    %xmm6,%xmm5
punpcklwd %xmm13,%xmm2
pinsrw $0x2,-0x44(%rsi),%xmm1
pslld  $0x2,%xmm5
pinsrw $0x3,-0x4(%rsi),%xmm1
pand   %xmm9,%xmm1
por    %xmm5,%xmm15
punpcklwd %xmm13,%xmm1
por    %xmm2,%xmm1
movzwl -0xc2(%rsi),%eax
pslld  $0x2,%xmm15
movd   %eax,%xmm2
pinsrw $0x1,-0x82(%rsi),%xmm2
ff 01
por    %xmm15,%xmm8
pslld  $0x2,%xmm8
pinsrw $0x2,-0x42(%rsi),%xmm2
por    %xmm8,%xmm10
pslld  $0x2,%xmm10
pinsrw $0x3,-0x2(%rsi),%xmm2
por    %xmm10,%xmm12
pslld  $0x2,%xmm12
paddw  %xmm2,%xmm2
movzwl -0xc0(%rsi),%eax
por    %xmm12,%xmm0
movd   %eax,%xmm3
pinsrw $0x1,-0x80(%rsi),%xmm3
pslld  $0x2,%xmm0
pand   %xmm4,%xmm2
pinsrw $0x2,-0x40(%rsi),%xmm3
por    %xmm0,%xmm1
punpcklwd %xmm13,%xmm2
pinsrw $0x3,(%rsi),%xmm3
pslld  $0x2,%xmm1
pand   %xmm9,%xmm3
punpcklwd %xmm13,%xmm3
por    %xmm2,%xmm3
por    %xmm1,%xmm3
movdqu %xmm3,(%r10,%rcx,4)
add    $0x4,%rcx
add    $0x100,%rsi
cmp    %rcx,%r15
jne    1bb6 <IntegerPacker_16+0xab6>
cmp    %r14,%r15
je     12d6 <IntegerPacker_16+0x1d6>
mov    %r8d,%ecx
movzwl (%r12),%eax
and    $0x1,%eax
movzwl 0x2(%r12),%esi
and    $0x1,%esi
lea    (%rsi,%rax,2),%eax
movzwl 0x4(%r12),%esi
and    $0x1,%esi
add    %esi,%esi
lea    (%rsi,%rax,4),%eax
movzwl 0x6(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x8(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0xa(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0xc(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0xe(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x10(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x12(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x14(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x16(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x18(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x1a(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x1c(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x1e(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x20(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x22(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x24(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x26(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x28(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x2a(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x2c(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x2e(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x30(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x32(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x34(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x36(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x38(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x3a(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
movzwl 0x3c(%r12),%eax
and    $0x1,%eax
add    %eax,%eax
lea    (%rax,%rsi,4),%eax
movzwl 0x3e(%r12),%esi
and    $0x1,%esi
or     %eax,%esi
add    $0x40,%r12
mov    %esi,0x0(%rbp)
add    $0x4,%rbp
lea    -0x20(%rcx),%r8d
cmp    $0x3f,%ecx
mov    %r8d,%ecx
ja     232e <IntegerPacker_16+0x122e>
jmp    12d6 <IntegerPacker_16+0x1d6>

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

LLVM IR (-O2):
define void @IntegerPacker_16(i8* nocapture %0, i8* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = bitcast i8* %1 to i16*
%8 = icmp sgt i32 %2, 16
%9 = icmp sgt i32 %3, %2
%10 = or i1 %8, %9
br i1 %10, label %1637, label %11
11: ; preds = %6
%12 = bitcast i8* %0 to i32*
%13 = sdiv i32 %5, 32
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i32, i32* %12, i64 %14
%16 = srem i32 %5, 32
%17 = sub nsw i32 32, %16
%18 = shl nsw i32 -1, %3
%19 = xor i32 %18, -1
%20 = icmp eq i32 %16, 0
br i1 %20, label %21, label %1542
21: ; preds = %11
%22 = icmp eq i32 %2, 16
%23 = icmp sgt i32 %4, 3
%24 = and i1 %22, %23
br i1 %24, label %25, label %53
25: ; preds = %21, %25
%26 = phi i16* [ %41, %25 ], [ %7, %21 ]
%27 = phi i32* [ %50, %25 ], [ %15, %21 ]
%28 = phi i32 [ %51, %25 ], [ %4, %21 ]
%29 = getelementptr inbounds i16, i16* %26, i64 1
%30 = load i16, i16* %26
%31 = zext i16 %30 to i32
%32 = and i32 %31, %19
%33 = getelementptr inbounds i16, i16* %26, i64 2
%34 = load i16, i16* %29
%35 = zext i16 %34 to i32
%36 = and i32 %35, %19
%37 = getelementptr inbounds i16, i16* %26, i64 3
%38 = load i16, i16* %33
%39 = zext i16 %38 to i32
%40 = and i32 %39, %19
%41 = getelementptr inbounds i16, i16* %26, i64 4
%42 = load i16, i16* %37
%43 = zext i16 %42 to i32
%44 = and i32 %43, %19
%45 = shl nuw i32 %32, 16
%46 = or i32 %45, %36
%47 = getelementptr inbounds i32, i32* %27, i64 1
store i32 %46, i32* %27
%48 = shl nuw i32 %40, 16
%49 = or i32 %48, %44
%50 = getelementptr inbounds i32, i32* %27, i64 2
store i32 %49, i32* %47
%51 = add nsw i32 %28, -4
%52 = icmp ugt i32 %28, 7
br i1 %52, label %25, label %1542
53: ; preds = %21
%54 = icmp eq i32 %2, 12
%55 = icmp sgt i32 %4, 7
%56 = and i1 %54, %55
br i1 %56, label %57, label %114
57: ; preds = %53, %57
%58 = phi i16* [ %103, %57 ], [ %7, %53 ]
%59 = phi i32* [ %111, %57 ], [ %15, %53 ]
%60 = phi i32 [ %112, %57 ], [ %4, %53 ]
%61 = getelementptr inbounds i16, i16* %58, i64 1
%62 = load i16, i16* %58
%63 = zext i16 %62 to i32
%64 = and i32 %63, %19
%65 = getelementptr inbounds i16, i16* %58, i64 2
%66 = load i16, i16* %61
%67 = zext i16 %66 to i32
%68 = and i32 %67, %19
%69 = getelementptr inbounds i16, i16* %58, i64 3
%70 = load i16, i16* %65
%71 = zext i16 %70 to i32
%72 = and i32 %71, %19
%73 = getelementptr inbounds i16, i16* %58, i64 4
%74 = load i16, i16* %69
%75 = zext i16 %74 to i32
%76 = and i32 %75, %19
%77 = shl i32 %64, 20
%78 = shl nuw nsw i32 %68, 8
%79 = or i32 %78, %77
%80 = lshr i32 %72, 4
%81 = or i32 %79, %80
%82 = getelementptr inbounds i32, i32* %59, i64 1
store i32 %81, i32* %59
%83 = getelementptr inbounds i16, i16* %58, i64 5
%84 = load i16, i16* %73
%85 = zext i16 %84 to i32
%86 = and i32 %85, %19
%87 = getelementptr inbounds i16, i16* %58, i64 6
%88 = load i16, i16* %83
%89 = zext i16 %88 to i32
%90 = and i32 %89, %19
%91 = shl i32 %72, 28
%92 = shl nuw i32 %76, 16
%93 = or i32 %92, %91
%94 = shl nuw nsw i32 %86, 4
%95 = or i32 %93, %94
%96 = lshr i32 %90, 8
%97 = or i32 %95, %96
%98 = getelementptr inbounds i32, i32* %59, i64 2
store i32 %97, i32* %82
%99 = getelementptr inbounds i16, i16* %58, i64 7
%100 = load i16, i16* %87
%101 = zext i16 %100 to i32
%102 = and i32 %101, %19
%103 = getelementptr inbounds i16, i16* %58, i64 8
%104 = load i16, i16* %99
%105 = zext i16 %104 to i32
%106 = and i32 %105, %19
%107 = shl i32 %90, 24
%108 = shl nuw nsw i32 %102, 12
%109 = or i32 %108, %107
%110 = or i32 %109, %106
%111 = getelementptr inbounds i32, i32* %59, i64 3
store i32 %110, i32* %98
%112 = add nsw i32 %60, -8
%113 = icmp ugt i32 %60, 15
br i1 %113, label %57, label %1542
114: ; preds = %53
%115 = icmp eq i32 %2, 8
%116 = and i1 %115, %55
br i1 %116, label %117, label %169
117: ; preds = %114, %117
%118 = phi i16* [ %156, %117 ], [ %7, %114 ]
%119 = phi i32* [ %166, %117 ], [ %15, %114 ]
%120 = phi i32 [ %167, %117 ], [ %4, %114 ]
%121 = getelementptr inbounds i16, i16* %118, i64 1
%122 = load i16, i16* %118
%123 = zext i16 %122 to i32
%124 = and i32 %123, %19
%125 = getelementptr inbounds i16, i16* %118, i64 2
%126 = load i16, i16* %121
%127 = zext i16 %126 to i32
%128 = and i32 %127, %19
%129 = getelementptr inbounds i16, i16* %118, i64 3
%130 = load i16, i16* %125
%131 = zext i16 %130 to i32
%132 = and i32 %131, %19
%133 = getelementptr inbounds i16, i16* %118, i64 4
%134 = load i16, i16* %129
%135 = zext i16 %134 to i32
%136 = and i32 %135, %19
%137 = shl i32 %124, 24
%138 = shl nuw i32 %128, 16
%139 = or i32 %138, %137
%140 = shl nuw nsw i32 %132, 8
%141 = or i32 %139, %140
%142 = or i32 %141, %136
%143 = getelementptr inbounds i32, i32* %119, i64 1
store i32 %142, i32* %119
%144 = getelementptr inbounds i16, i16* %118, i64 5
%145 = load i16, i16* %133
%146 = zext i16 %145 to i32
%147 = and i32 %146, %19
%148 = getelementptr inbounds i16, i16* %118, i64 6
%149 = load i16, i16* %144
%150 = zext i16 %149 to i32
%151 = and i32 %150, %19
%152 = getelementptr inbounds i16, i16* %118, i64 7
%153 = load i16, i16* %148
%154 = zext i16 %153 to i32
%155 = and i32 %154, %19
%156 = getelementptr inbounds i16, i16* %118, i64 8
%157 = load i16, i16* %152
%158 = zext i16 %157 to i32
%159 = and i32 %158, %19
%160 = shl i32 %147, 24
%161 = shl nuw i32 %151, 16
%162 = or i32 %161, %160
%163 = shl nuw nsw i32 %155, 8
%164 = or i32 %162, %163
%165 = or i32 %164, %159
%166 = getelementptr inbounds i32, i32* %119, i64 2
store i32 %165, i32* %143
%167 = add nsw i32 %120, -8
%168 = icmp ugt i32 %120, 15
br i1 %168, label %117, label %1542
169: ; preds = %114
%170 = icmp eq i32 %2, 6
%171 = icmp sgt i32 %4, 15
%172 = and i1 %170, %171
br i1 %172, label %173, label %278
173: ; preds = %169, %173
%174 = phi i16* [ %261, %173 ], [ %7, %169 ]
%175 = phi i32* [ %275, %173 ], [ %15, %169 ]
%176 = phi i32 [ %276, %173 ], [ %4, %169 ]
%177 = getelementptr inbounds i16, i16* %174, i64 1
%178 = load i16, i16* %174
%179 = zext i16 %178 to i32
%180 = and i32 %179, %19
%181 = getelementptr inbounds i16, i16* %174, i64 2
%182 = load i16, i16* %177
%183 = zext i16 %182 to i32
%184 = and i32 %183, %19
%185 = getelementptr inbounds i16, i16* %174, i64 3
%186 = load i16, i16* %181
%187 = zext i16 %186 to i32
%188 = and i32 %187, %19
%189 = getelementptr inbounds i16, i16* %174, i64 4
%190 = load i16, i16* %185
%191 = zext i16 %190 to i32
%192 = and i32 %191, %19
%193 = getelementptr inbounds i16, i16* %174, i64 5
%194 = load i16, i16* %189
%195 = zext i16 %194 to i32
%196 = and i32 %195, %19
%197 = getelementptr inbounds i16, i16* %174, i64 6
%198 = load i16, i16* %193
%199 = zext i16 %198 to i32
%200 = and i32 %199, %19
%201 = getelementptr inbounds i16, i16* %174, i64 7
%202 = load i16, i16* %197
%203 = zext i16 %202 to i32
%204 = and i32 %203, %19
%205 = getelementptr inbounds i16, i16* %174, i64 8
%206 = load i16, i16* %201
%207 = zext i16 %206 to i32
%208 = and i32 %207, %19
%209 = shl i32 %180, 26
%210 = shl i32 %184, 20
%211 = or i32 %210, %209
%212 = shl nuw nsw i32 %188, 14
%213 = or i32 %211, %212
%214 = shl nuw nsw i32 %192, 8
%215 = or i32 %213, %214
%216 = shl nuw nsw i32 %196, 2
%217 = or i32 %215, %216
%218 = lshr i32 %200, 4
%219 = or i32 %217, %218
%220 = getelementptr inbounds i32, i32* %175, i64 1
store i32 %219, i32* %175
%221 = getelementptr inbounds i16, i16* %174, i64 9
%222 = load i16, i16* %205
%223 = zext i16 %222 to i32
%224 = and i32 %223, %19
%225 = getelementptr inbounds i16, i16* %174, i64 10
%226 = load i16, i16* %221
%227 = zext i16 %226 to i32
%228 = and i32 %227, %19
%229 = getelementptr inbounds i16, i16* %174, i64 11
%230 = load i16, i16* %225
%231 = zext i16 %230 to i32
%232 = and i32 %231, %19
%233 = shl i32 %200, 28
%234 = shl i32 %204, 22
%235 = or i32 %234, %233
%236 = shl nuw i32 %208, 16
%237 = or i32 %235, %236
%238 = shl nuw nsw i32 %224, 10
%239 = or i32 %237, %238
%240 = shl nuw nsw i32 %228, 4
%241 = or i32 %239, %240
%242 = lshr i32 %232, 2
%243 = or i32 %241, %242
%244 = getelementptr inbounds i32, i32* %175, i64 2
store i32 %243, i32* %220
%245 = getelementptr inbounds i16, i16* %174, i64 12
%246 = load i16, i16* %229
%247 = zext i16 %246 to i32
%248 = and i32 %247, %19
%249 = getelementptr inbounds i16, i16* %174, i64 13
%250 = load i16, i16* %245
%251 = zext i16 %250 to i32
%252 = and i32 %251, %19
%253 = getelementptr inbounds i16, i16* %174, i64 14
%254 = load i16, i16* %249
%255 = zext i16 %254 to i32
%256 = and i32 %255, %19
%257 = getelementptr inbounds i16, i16* %174, i64 15
%258 = load i16, i16* %253
%259 = zext i16 %258 to i32
%260 = and i32 %259, %19
%261 = getelementptr inbounds i16, i16* %174, i64 16
%262 = load i16, i16* %257
%263 = zext i16 %262 to i32
%264 = and i32 %263, %19
%265 = shl i32 %232, 30
%266 = shl i32 %248, 24
%267 = or i32 %266, %265
%268 = shl i32 %252, 18
%269 = or i32 %267, %268
%270 = shl nuw nsw i32 %256, 12
%271 = or i32 %269, %270
%272 = shl nuw nsw i32 %260, 6
%273 = or i32 %271, %272
%274 = or i32 %273, %264
%275 = getelementptr inbounds i32, i32* %175, i64 3
store i32 %274, i32* %244
%276 = add nsw i32 %176, -16
%277 = icmp ugt i32 %176, 31
br i1 %277, label %173, label %278
278: ; preds = %173, %169
%279 = phi i16* [ %7, %169 ], [ %261, %173 ]
%280 = phi i32* [ %15, %169 ], [ %275, %173 ]
%281 = phi i32 [ %4, %169 ], [ %276, %173 ]
%282 = icmp eq i32 %2, 4
%283 = icmp sgt i32 %281, 7
%284 = select i1 %282, i1 %283, i1 false
br i1 %284, label %285, label %410
285: ; preds = %278
%286 = add i32 %281, 7
%287 = call i32 @llvm.umin.i32(i32 %281, i32 15)
%288 = sub i32 %286, %287
%289 = lshr i32 %288, 3
%290 = add nuw nsw i32 %289, 1
%291 = zext i32 %290 to i64
%292 = icmp ult i32 %288, 24
br i1 %292, label %353, label %293
293: ; preds = %285
%294 = and i64 %291, 1073741820
%295 = shl nuw nsw i64 %294, 3
%296 = getelementptr i16, i16* %279, i64 %295
%297 = getelementptr i32, i32* %280, i64 %294
%298 = trunc i64 %294 to i32
%299 = mul i32 %298, -8
%300 = add i32 %281, %299
%301 = insertelement <4 x i32> poison, i32 %19, i64 0
%302 = shufflevector <4 x i32> %301, <4 x i32> poison, <4 x i32> zeroinitializer
br label %303
303: ; preds = %303, %293
%304 = phi i64 [ 0, %293 ], [ %349, %303 ]
%305 = shl i64 %304, 3
%306 = getelementptr i16, i16* %279, i64 %305
%307 = getelementptr i32, i32* %280, i64 %304
%308 = bitcast i16* %306 to <32 x i16>*
%309 = load <32 x i16>, <32 x i16>* %308
%310 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 0, i32 8, i32 16, i32 24>
%311 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 1, i32 9, i32 17, i32 25>
%312 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 2, i32 10, i32 18, i32 26>
%313 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 3, i32 11, i32 19, i32 27>
%314 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 4, i32 12, i32 20, i32 28>
%315 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 5, i32 13, i32 21, i32 29>
%316 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 6, i32 14, i32 22, i32 30>
%317 = shufflevector <32 x i16> %309, <32 x i16> poison, <4 x i32> <i32 7, i32 15, i32 23, i32 31>
%318 = zext <4 x i16> %310 to <4 x i32>
%319 = and <4 x i32> %302, %318
%320 = zext <4 x i16> %311 to <4 x i32>
%321 = and <4 x i32> %302, %320
%322 = shl nuw nsw <4 x i32> %319, <i32 8, i32 8, i32 8, i32 8>
%323 = shl nuw nsw <4 x i32> %321, <i32 4, i32 4, i32 4, i32 4>
%324 = or <4 x i32> %323, %322
%325 = zext <4 x i16> %312 to <4 x i32>
%326 = and <4 x i32> %302, %325
%327 = or <4 x i32> %324, %326
%328 = zext <4 x i16> %313 to <4 x i32>
%329 = and <4 x i32> %302, %328
%330 = zext <4 x i16> %314 to <4 x i32>
%331 = and <4 x i32> %302, %330
%332 = zext <4 x i16> %315 to <4 x i32>
%333 = and <4 x i32> %302, %332
%334 = shl <4 x i32> %327, <i32 16, i32 16, i32 16, i32 16>
%335 = shl nuw nsw <4 x i32> %329, <i32 12, i32 12, i32 12, i32 12>
%336 = shl nuw nsw <4 x i32> %331, <i32 8, i32 8, i32 8, i32 8>
%337 = or <4 x i32> %335, %336
%338 = or <4 x i32> %334, %337
%339 = shl nuw nsw <4 x i32> %333, <i32 4, i32 4, i32 4, i32 4>
%340 = zext <4 x i16> %316 to <4 x i32>
%341 = and <4 x i32> %302, %340
%342 = or <4 x i32> %341, %339
%343 = or <4 x i32> %342, %338
%344 = shl <4 x i32> %343, <i32 4, i32 4, i32 4, i32 4>
%345 = zext <4 x i16> %317 to <4 x i32>
%346 = and <4 x i32> %302, %345
%347 = or <4 x i32> %344, %346
%348 = bitcast i32* %307 to <4 x i32>*
store <4 x i32> %347, <4 x i32>* %348
%349 = add nuw i64 %304, 4
%350 = icmp eq i64 %349, %294
br i1 %350, label %351, label %303
351: ; preds = %303
%352 = icmp eq i64 %294, %291
br i1 %352, label %1542, label %353
353: ; preds = %285, %351
%354 = phi i16* [ %279, %285 ], [ %296, %351 ]
%355 = phi i32* [ %280, %285 ], [ %297, %351 ]
%356 = phi i32 [ %281, %285 ], [ %300, %351 ]
br label %357
357: ; preds = %353, %357
%358 = phi i16* [ %402, %357 ], [ %354, %353 ]
%359 = phi i32* [ %407, %357 ], [ %355, %353 ]
%360 = phi i32 [ %408, %357 ], [ %356, %353 ]
%361 = getelementptr inbounds i16, i16* %358, i64 1
%362 = load i16, i16* %358
%363 = zext i16 %362 to i32
%364 = and i32 %363, %19
%365 = getelementptr inbounds i16, i16* %358, i64 2
%366 = load i16, i16* %361
%367 = zext i16 %366 to i32
%368 = and i32 %367, %19
%369 = shl nuw nsw i32 %364, 8
%370 = shl nuw nsw i32 %368, 4
%371 = or i32 %370, %369
%372 = getelementptr inbounds i16, i16* %358, i64 3
%373 = load i16, i16* %365
%374 = zext i16 %373 to i32
%375 = and i32 %374, %19
%376 = or i32 %371, %375
%377 = getelementptr inbounds i16, i16* %358, i64 4
%378 = load i16, i16* %372
%379 = zext i16 %378 to i32
%380 = and i32 %379, %19
%381 = getelementptr inbounds i16, i16* %358, i64 5
%382 = load i16, i16* %377
%383 = zext i16 %382 to i32
%384 = and i32 %383, %19
%385 = getelementptr inbounds i16, i16* %358, i64 6
%386 = load i16, i16* %381
%387 = zext i16 %386 to i32
%388 = and i32 %387, %19
%389 = shl i32 %376, 16
%390 = shl nuw nsw i32 %380, 12
%391 = shl nuw nsw i32 %384, 8
%392 = or i32 %390, %391
%393 = or i32 %389, %392
%394 = shl nuw nsw i32 %388, 4
%395 = getelementptr inbounds i16, i16* %358, i64 7
%396 = load i16, i16* %385
%397 = zext i16 %396 to i32
%398 = and i32 %397, %19
%399 = or i32 %398, %394
%400 = or i32 %399, %393
%401 = shl i32 %400, 4
%402 = getelementptr inbounds i16, i16* %358, i64 8
%403 = load i16, i16* %395
%404 = zext i16 %403 to i32
%405 = and i32 %404, %19
%406 = or i32 %401, %405
%407 = getelementptr inbounds i32, i32* %359, i64 1
store i32 %406, i32* %359
%408 = add nsw i32 %360, -8
%409 = icmp ugt i32 %360, 15
br i1 %409, label %357, label %1542
410: ; preds = %278
%411 = icmp eq i32 %2, 2
%412 = icmp sgt i32 %281, 15
%413 = select i1 %411, i1 %412, i1 false
br i1 %413, label %414, label %806
414: ; preds = %410
%415 = add i32 %281, 15
%416 = call i32 @llvm.umin.i32(i32 %281, i32 31)
%417 = sub i32 %415, %416
%418 = lshr i32 %417, 4
%419 = add nuw nsw i32 %418, 1
%420 = zext i32 %419 to i64
%421 = icmp ult i32 %417, 48
br i1 %421, label %701, label %422
422: ; preds = %414
%423 = and i64 %420, 536870908
%424 = shl nuw nsw i64 %423, 4
%425 = getelementptr i16, i16* %279, i64 %424
%426 = getelementptr i32, i32* %280, i64 %423
%427 = trunc i64 %423 to i32
%428 = mul i32 %427, -16
%429 = add i32 %281, %428
%430 = insertelement <4 x i32> poison, i32 %19, i64 0
%431 = shufflevector <4 x i32> %430, <4 x i32> poison, <4 x i32> zeroinitializer
br label %432
432: ; preds = %432, %422
%433 = phi i64 [ 0, %422 ], [ %697, %432 ]
%434 = shl i64 %433, 4
%435 = getelementptr i16, i16* %279, i64 %434
%436 = shl i64 %433, 4
%437 = or i64 %436, 16
%438 = getelementptr i16, i16* %279, i64 %437
%439 = shl i64 %433, 4
%440 = or i64 %439, 32
%441 = getelementptr i16, i16* %279, i64 %440
%442 = shl i64 %433, 4
%443 = or i64 %442, 48
%444 = getelementptr i16, i16* %279, i64 %443
%445 = getelementptr i32, i32* %280, i64 %433
%446 = getelementptr inbounds i16, i16* %435, i64 1
%447 = getelementptr inbounds i16, i16* %438, i64 1
%448 = getelementptr inbounds i16, i16* %441, i64 1
%449 = getelementptr inbounds i16, i16* %444, i64 1
%450 = load i16, i16* %435
%451 = load i16, i16* %438
%452 = load i16, i16* %441
%453 = load i16, i16* %444
%454 = insertelement <4 x i16> poison, i16 %450, i64 0
%455 = insertelement <4 x i16> %454, i16 %451, i64 1
%456 = insertelement <4 x i16> %455, i16 %452, i64 2
%457 = insertelement <4 x i16> %456, i16 %453, i64 3
%458 = zext <4 x i16> %457 to <4 x i32>
%459 = and <4 x i32> %431, %458
%460 = getelementptr inbounds i16, i16* %435, i64 2
%461 = getelementptr inbounds i16, i16* %438, i64 2
%462 = getelementptr inbounds i16, i16* %441, i64 2
%463 = getelementptr inbounds i16, i16* %444, i64 2
%464 = load i16, i16* %446
%465 = load i16, i16* %447
%466 = load i16, i16* %448
%467 = load i16, i16* %449
%468 = insertelement <4 x i16> poison, i16 %464, i64 0
%469 = insertelement <4 x i16> %468, i16 %465, i64 1
%470 = insertelement <4 x i16> %469, i16 %466, i64 2
%471 = insertelement <4 x i16> %470, i16 %467, i64 3
%472 = zext <4 x i16> %471 to <4 x i32>
%473 = and <4 x i32> %431, %472
%474 = shl nuw nsw <4 x i32> %459, <i32 4, i32 4, i32 4, i32 4>
%475 = shl nuw nsw <4 x i32> %473, <i32 2, i32 2, i32 2, i32 2>
%476 = or <4 x i32> %475, %474
%477 = getelementptr inbounds i16, i16* %435, i64 3
%478 = getelementptr inbounds i16, i16* %438, i64 3
%479 = getelementptr inbounds i16, i16* %441, i64 3
%480 = getelementptr inbounds i16, i16* %444, i64 3
%481 = load i16, i16* %460
%482 = load i16, i16* %461
%483 = load i16, i16* %462
%484 = load i16, i16* %463
%485 = insertelement <4 x i16> poison, i16 %481, i64 0
%486 = insertelement <4 x i16> %485, i16 %482, i64 1
%487 = insertelement <4 x i16> %486, i16 %483, i64 2
%488 = insertelement <4 x i16> %487, i16 %484, i64 3
%489 = zext <4 x i16> %488 to <4 x i32>
%490 = and <4 x i32> %431, %489
%491 = or <4 x i32> %476, %490
%492 = getelementptr inbounds i16, i16* %435, i64 4
%493 = getelementptr inbounds i16, i16* %438, i64 4
%494 = getelementptr inbounds i16, i16* %441, i64 4
%495 = getelementptr inbounds i16, i16* %444, i64 4
%496 = load i16, i16* %477
%497 = load i16, i16* %478
%498 = load i16, i16* %479
%499 = load i16, i16* %480
%500 = insertelement <4 x i16> poison, i16 %496, i64 0
%501 = insertelement <4 x i16> %500, i16 %497, i64 1
%502 = insertelement <4 x i16> %501, i16 %498, i64 2
%503 = insertelement <4 x i16> %502, i16 %499, i64 3
%504 = zext <4 x i16> %503 to <4 x i32>
%505 = and <4 x i32> %431, %504
%506 = getelementptr inbounds i16, i16* %435, i64 5
%507 = getelementptr inbounds i16, i16* %438, i64 5
%508 = getelementptr inbounds i16, i16* %441, i64 5
%509 = getelementptr inbounds i16, i16* %444, i64 5
%510 = load i16, i16* %492
%511 = load i16, i16* %493
%512 = load i16, i16* %494
%513 = load i16, i16* %495
%514 = insertelement <4 x i16> poison, i16 %510, i64 0
%515 = insertelement <4 x i16> %514, i16 %511, i64 1
%516 = insertelement <4 x i16> %515, i16 %512, i64 2
%517 = insertelement <4 x i16> %516, i16 %513, i64 3
%518 = zext <4 x i16> %517 to <4 x i32>
%519 = and <4 x i32> %431, %518
%520 = getelementptr inbounds i16, i16* %435, i64 6
%521 = getelementptr inbounds i16, i16* %438, i64 6
%522 = getelementptr inbounds i16, i16* %441, i64 6
%523 = getelementptr inbounds i16, i16* %444, i64 6
%524 = load i16, i16* %506
%525 = load i16, i16* %507
%526 = load i16, i16* %508
%527 = load i16, i16* %509
%528 = insertelement <4 x i16> poison, i16 %524, i64 0
%529 = insertelement <4 x i16> %528, i16 %525, i64 1
%530 = insertelement <4 x i16> %529, i16 %526, i64 2
%531 = insertelement <4 x i16> %530, i16 %527, i64 3
%532 = zext <4 x i16> %531 to <4 x i32>
%533 = and <4 x i32> %431, %532
%534 = shl nuw nsw <4 x i32> %491, <i32 8, i32 8, i32 8, i32 8>
%535 = shl nuw nsw <4 x i32> %505, <i32 6, i32 6, i32 6, i32 6>
%536 = shl nuw nsw <4 x i32> %519, <i32 4, i32 4, i32 4, i32 4>
%537 = or <4 x i32> %535, %536
%538 = or <4 x i32> %534, %537
%539 = shl nuw nsw <4 x i32> %533, <i32 2, i32 2, i32 2, i32 2>
%540 = getelementptr inbounds i16, i16* %435, i64 7
%541 = getelementptr inbounds i16, i16* %438, i64 7
%542 = getelementptr inbounds i16, i16* %441, i64 7
%543 = getelementptr inbounds i16, i16* %444, i64 7
%544 = load i16, i16* %520
%545 = load i16, i16* %521
%546 = load i16, i16* %522
%547 = load i16, i16* %523
%548 = insertelement <4 x i16> poison, i16 %544, i64 0
%549 = insertelement <4 x i16> %548, i16 %545, i64 1
%550 = insertelement <4 x i16> %549, i16 %546, i64 2
%551 = insertelement <4 x i16> %550, i16 %547, i64 3
%552 = zext <4 x i16> %551 to <4 x i32>
%553 = and <4 x i32> %431, %552
%554 = or <4 x i32> %553, %539
%555 = or <4 x i32> %554, %538
%556 = getelementptr inbounds i16, i16* %435, i64 8
%557 = getelementptr inbounds i16, i16* %438, i64 8
%558 = getelementptr inbounds i16, i16* %441, i64 8
%559 = getelementptr inbounds i16, i16* %444, i64 8
%560 = load i16, i16* %540
%561 = load i16, i16* %541
%562 = load i16, i16* %542
%563 = load i16, i16* %543
%564 = insertelement <4 x i16> poison, i16 %560, i64 0
%565 = insertelement <4 x i16> %564, i16 %561, i64 1
%566 = insertelement <4 x i16> %565, i16 %562, i64 2
%567 = insertelement <4 x i16> %566, i16 %563, i64 3
%568 = zext <4 x i16> %567 to <4 x i32>
%569 = and <4 x i32> %431, %568
%570 = getelementptr inbounds i16, i16* %435, i64 9
%571 = getelementptr inbounds i16, i16* %438, i64 9
%572 = getelementptr inbounds i16, i16* %441, i64 9
%573 = getelementptr inbounds i16, i16* %444, i64 9
%574 = load i16, i16* %556
%575 = load i16, i16* %557
%576 = load i16, i16* %558
%577 = load i16, i16* %559
%578 = insertelement <4 x i16> poison, i16 %574, i64 0
%579 = insertelement <4 x i16> %578, i16 %575, i64 1
%580 = insertelement <4 x i16> %579, i16 %576, i64 2
%581 = insertelement <4 x i16> %580, i16 %577, i64 3
%582 = zext <4 x i16> %581 to <4 x i32>
%583 = and <4 x i32> %431, %582
%584 = getelementptr inbounds i16, i16* %435, i64 10
%585 = getelementptr inbounds i16, i16* %438, i64 10
%586 = getelementptr inbounds i16, i16* %441, i64 10
%587 = getelementptr inbounds i16, i16* %444, i64 10
%588 = load i16, i16* %570
%589 = load i16, i16* %571
%590 = load i16, i16* %572
%591 = load i16, i16* %573
%592 = insertelement <4 x i16> poison, i16 %588, i64 0
%593 = insertelement <4 x i16> %592, i16 %589, i64 1
%594 = insertelement <4 x i16> %593, i16 %590, i64 2
%595 = insertelement <4 x i16> %594, i16 %591, i64 3
%596 = zext <4 x i16> %595 to <4 x i32>
%597 = and <4 x i32> %431, %596
%598 = shl <4 x i32> %555, <i32 8, i32 8, i32 8, i32 8>
%599 = shl nuw nsw <4 x i32> %569, <i32 6, i32 6, i32 6, i32 6>
%600 = shl nuw nsw <4 x i32> %583, <i32 4, i32 4, i32 4, i32 4>
%601 = or <4 x i32> %599, %600
%602 = or <4 x i32> %598, %601
%603 = shl nuw nsw <4 x i32> %597, <i32 2, i32 2, i32 2, i32 2>
%604 = getelementptr inbounds i16, i16* %435, i64 11
%605 = getelementptr inbounds i16, i16* %438, i64 11
%606 = getelementptr inbounds i16, i16* %441, i64 11
%607 = getelementptr inbounds i16, i16* %444, i64 11
%608 = load i16, i16* %584
%609 = load i16, i16* %585
%610 = load i16, i16* %586
%611 = load i16, i16* %587
%612 = insertelement <4 x i16> poison, i16 %608, i64 0
%613 = insertelement <4 x i16> %612, i16 %609, i64 1
%614 = insertelement <4 x i16> %613, i16 %610, i64 2
%615 = insertelement <4 x i16> %614, i16 %611, i64 3
%616 = zext <4 x i16> %615 to <4 x i32>
%617 = and <4 x i32> %431, %616
%618 = or <4 x i32> %617, %603
%619 = or <4 x i32> %618, %602
%620 = getelementptr inbounds i16, i16* %435, i64 12
%621 = getelementptr inbounds i16, i16* %438, i64 12
%622 = getelementptr inbounds i16, i16* %441, i64 12
%623 = getelementptr inbounds i16, i16* %444, i64 12
%624 = load i16, i16* %604
%625 = load i16, i16* %605
%626 = load i16, i16* %606
%627 = load i16, i16* %607
%628 = insertelement <4 x i16> poison, i16 %624, i64 0
%629 = insertelement <4 x i16> %628, i16 %625, i64 1
%630 = insertelement <4 x i16> %629, i16 %626, i64 2
%631 = insertelement <4 x i16> %630, i16 %627, i64 3
%632 = zext <4 x i16> %631 to <4 x i32>
%633 = and <4 x i32> %431, %632
%634 = getelementptr inbounds i16, i16* %435, i64 13
%635 = getelementptr inbounds i16, i16* %438, i64 13
%636 = getelementptr inbounds i16, i16* %441, i64 13
%637 = getelementptr inbounds i16, i16* %444, i64 13
%638 = load i16, i16* %620
%639 = load i16, i16* %621
%640 = load i16, i16* %622
%641 = load i16, i16* %623
%642 = insertelement <4 x i16> poison, i16 %638, i64 0
%643 = insertelement <4 x i16> %642, i16 %639, i64 1
%644 = insertelement <4 x i16> %643, i16 %640, i64 2
%645 = insertelement <4 x i16> %644, i16 %641, i64 3
%646 = zext <4 x i16> %645 to <4 x i32>
%647 = and <4 x i32> %431, %646
%648 = getelementptr inbounds i16, i16* %435, i64 14
%649 = getelementptr inbounds i16, i16* %438, i64 14
%650 = getelementptr inbounds i16, i16* %441, i64 14
%651 = getelementptr inbounds i16, i16* %444, i64 14
%652 = load i16, i16* %634
%653 = load i16, i16* %635
%654 = load i16, i16* %636
%655 = load i16, i16* %637
%656 = insertelement <4 x i16> poison, i16 %652, i64 0
%657 = insertelement <4 x i16> %656, i16 %653, i64 1
%658 = insertelement <4 x i16> %657, i16 %654, i64 2
%659 = insertelement <4 x i16> %658, i16 %655, i64 3
%660 = zext <4 x i16> %659 to <4 x i32>
%661 = and <4 x i32> %431, %660
%662 = shl <4 x i32> %619, <i32 8, i32 8, i32 8, i32 8>
%663 = shl nuw nsw <4 x i32> %633, <i32 6, i32 6, i32 6, i32 6>
%664 = shl nuw nsw <4 x i32> %647, <i32 4, i32 4, i32 4, i32 4>
%665 = or <4 x i32> %663, %664
%666 = or <4 x i32> %662, %665
%667 = shl nuw nsw <4 x i32> %661, <i32 2, i32 2, i32 2, i32 2>
%668 = getelementptr inbounds i16, i16* %435, i64 15
%669 = getelementptr inbounds i16, i16* %438, i64 15
%670 = getelementptr inbounds i16, i16* %441, i64 15
%671 = getelementptr inbounds i16, i16* %444, i64 15
%672 = load i16, i16* %648
%673 = load i16, i16* %649
%674 = load i16, i16* %650
%675 = load i16, i16* %651
%676 = insertelement <4 x i16> poison, i16 %672, i64 0
%677 = insertelement <4 x i16> %676, i16 %673, i64 1
%678 = insertelement <4 x i16> %677, i16 %674, i64 2
%679 = insertelement <4 x i16> %678, i16 %675, i64 3
%680 = zext <4 x i16> %679 to <4 x i32>
%681 = and <4 x i32> %431, %680
%682 = or <4 x i32> %681, %667
%683 = or <4 x i32> %682, %666
%684 = shl <4 x i32> %683, <i32 2, i32 2, i32 2, i32 2>
%685 = load i16, i16* %668
%686 = load i16, i16* %669
%687 = load i16, i16* %670
%688 = load i16, i16* %671
%689 = insertelement <4 x i16> poison, i16 %685, i64 0
%690 = insertelement <4 x i16> %689, i16 %686, i64 1
%691 = insertelement <4 x i16> %690, i16 %687, i64 2
%692 = insertelement <4 x i16> %691, i16 %688, i64 3
%693 = zext <4 x i16> %692 to <4 x i32>
%694 = and <4 x i32> %431, %693
%695 = or <4 x i32> %684, %694
%696 = bitcast i32* %445 to <4 x i32>*
store <4 x i32> %695, <4 x i32>* %696
%697 = add nuw i64 %433, 4
%698 = icmp eq i64 %697, %423
br i1 %698, label %699, label %432
699: ; preds = %432
%700 = icmp eq i64 %423, %420
br i1 %700, label %1542, label %701
701: ; preds = %414, %699
%702 = phi i16* [ %279, %414 ], [ %425, %699 ]
%703 = phi i32* [ %280, %414 ], [ %426, %699 ]
%704 = phi i32 [ %281, %414 ], [ %429, %699 ]
br label %705
705: ; preds = %701, %705
%706 = phi i16* [ %798, %705 ], [ %702, %701 ]
%707 = phi i32* [ %803, %705 ], [ %703, %701 ]
%708 = phi i32 [ %804, %705 ], [ %704, %701 ]
%709 = getelementptr inbounds i16, i16* %706, i64 1
%710 = load i16, i16* %706
%711 = zext i16 %710 to i32
%712 = and i32 %711, %19
%713 = getelementptr inbounds i16, i16* %706, i64 2
%714 = load i16, i16* %709
%715 = zext i16 %714 to i32
%716 = and i32 %715, %19
%717 = shl nuw nsw i32 %712, 4
%718 = shl nuw nsw i32 %716, 2
%719 = or i32 %718, %717
%720 = getelementptr inbounds i16, i16* %706, i64 3
%721 = load i16, i16* %713
%722 = zext i16 %721 to i32
%723 = and i32 %722, %19
%724 = or i32 %719, %723
%725 = getelementptr inbounds i16, i16* %706, i64 4
%726 = load i16, i16* %720
%727 = zext i16 %726 to i32
%728 = and i32 %727, %19
%729 = getelementptr inbounds i16, i16* %706, i64 5
%730 = load i16, i16* %725
%731 = zext i16 %730 to i32
%732 = and i32 %731, %19
%733 = getelementptr inbounds i16, i16* %706, i64 6
%734 = load i16, i16* %729
%735 = zext i16 %734 to i32
%736 = and i32 %735, %19
%737 = shl nuw nsw i32 %724, 8
%738 = shl nuw nsw i32 %728, 6
%739 = shl nuw nsw i32 %732, 4
%740 = or i32 %738, %739
%741 = or i32 %737, %740
%742 = shl nuw nsw i32 %736, 2
%743 = getelementptr inbounds i16, i16* %706, i64 7
%744 = load i16, i16* %733
%745 = zext i16 %744 to i32
%746 = and i32 %745, %19
%747 = or i32 %746, %742
%748 = or i32 %747, %741
%749 = getelementptr inbounds i16, i16* %706, i64 8
%750 = load i16, i16* %743
%751 = zext i16 %750 to i32
%752 = and i32 %751, %19
%753 = getelementptr inbounds i16, i16* %706, i64 9
%754 = load i16, i16* %749
%755 = zext i16 %754 to i32
%756 = and i32 %755, %19
%757 = getelementptr inbounds i16, i16* %706, i64 10
%758 = load i16, i16* %753
%759 = zext i16 %758 to i32
%760 = and i32 %759, %19
%761 = shl i32 %748, 8
%762 = shl nuw nsw i32 %752, 6
%763 = shl nuw nsw i32 %756, 4
%764 = or i32 %762, %763
%765 = or i32 %761, %764
%766 = shl nuw nsw i32 %760, 2
%767 = getelementptr inbounds i16, i16* %706, i64 11
%768 = load i16, i16* %757
%769 = zext i16 %768 to i32
%770 = and i32 %769, %19
%771 = or i32 %770, %766
%772 = or i32 %771, %765
%773 = getelementptr inbounds i16, i16* %706, i64 12
%774 = load i16, i16* %767
%775 = zext i16 %774 to i32
%776 = and i32 %775, %19
%777 = getelementptr inbounds i16, i16* %706, i64 13
%778 = load i16, i16* %773
%779 = zext i16 %778 to i32
%780 = and i32 %779, %19
%781 = getelementptr inbounds i16, i16* %706, i64 14
%782 = load i16, i16* %777
%783 = zext i16 %782 to i32
%784 = and i32 %783, %19
%785 = shl i32 %772, 8
%786 = shl nuw nsw i32 %776, 6
%787 = shl nuw nsw i32 %780, 4
%788 = or i32 %786, %787
%789 = or i32 %785, %788
%790 = shl nuw nsw i32 %784, 2
%791 = getelementptr inbounds i16, i16* %706, i64 15
%792 = load i16, i16* %781
%793 = zext i16 %792 to i32
%794 = and i32 %793, %19
%795 = or i32 %794, %790
%796 = or i32 %795, %789
%797 = shl i32 %796, 2
%798 = getelementptr inbounds i16, i16* %706, i64 16
%799 = load i16, i16* %791
%800 = zext i16 %799 to i32
%801 = and i32 %800, %19
%802 = or i32 %797, %801
%803 = getelementptr inbounds i32, i32* %707, i64 1
store i32 %802, i32* %707
%804 = add nsw i32 %708, -16
%805 = icmp ugt i32 %708, 31
br i1 %805, label %705, label %1542
806: ; preds = %410
%807 = icmp eq i32 %2, 1
%808 = icmp sgt i32 %281, 31
%809 = select i1 %807, i1 %808, i1 false
br i1 %809, label %810, label %1542
810: ; preds = %806
%811 = add i32 %281, 31
%812 = call i32 @llvm.umin.i32(i32 %281, i32 63)
%813 = sub i32 %811, %812
%814 = lshr i32 %813, 5
%815 = add nuw nsw i32 %814, 1
%816 = zext i32 %815 to i64
%817 = icmp ult i32 %813, 96
br i1 %817, label %1346, label %818
818: ; preds = %810
%819 = and i64 %816, 268435452
%820 = shl nuw nsw i64 %819, 5
%821 = getelementptr i16, i16* %279, i64 %820
%822 = getelementptr i32, i32* %280, i64 %819
%823 = trunc i64 %819 to i32
%824 = mul i32 %823, -32
%825 = add i32 %281, %824
br label %826
826: ; preds = %826, %818
%827 = phi i64 [ 0, %818 ], [ %1342, %826 ]
%828 = shl i64 %827, 5
%829 = getelementptr i16, i16* %279, i64 %828
%830 = shl i64 %827, 5
%831 = or i64 %830, 32
%832 = getelementptr i16, i16* %279, i64 %831
%833 = shl i64 %827, 5
%834 = or i64 %833, 64
%835 = getelementptr i16, i16* %279, i64 %834
%836 = shl i64 %827, 5
%837 = or i64 %836, 96
%838 = getelementptr i16, i16* %279, i64 %837
%839 = getelementptr i32, i32* %280, i64 %827
%840 = getelementptr inbounds i16, i16* %829, i64 1
%841 = getelementptr inbounds i16, i16* %832, i64 1
%842 = getelementptr inbounds i16, i16* %835, i64 1
%843 = getelementptr inbounds i16, i16* %838, i64 1
%844 = load i16, i16* %829
%845 = load i16, i16* %832
%846 = load i16, i16* %835
%847 = load i16, i16* %838
%848 = insertelement <4 x i16> poison, i16 %844, i64 0
%849 = insertelement <4 x i16> %848, i16 %845, i64 1
%850 = insertelement <4 x i16> %849, i16 %846, i64 2
%851 = insertelement <4 x i16> %850, i16 %847, i64 3
%852 = shl <4 x i16> %851, <i16 1, i16 1, i16 1, i16 1>
%853 = and <4 x i16> %852, <i16 2, i16 2, i16 2, i16 2>
%854 = getelementptr inbounds i16, i16* %829, i64 2
%855 = getelementptr inbounds i16, i16* %832, i64 2
%856 = getelementptr inbounds i16, i16* %835, i64 2
%857 = getelementptr inbounds i16, i16* %838, i64 2
%858 = load i16, i16* %840
%859 = load i16, i16* %841
%860 = load i16, i16* %842
%861 = load i16, i16* %843
%862 = insertelement <4 x i16> poison, i16 %858, i64 0
%863 = insertelement <4 x i16> %862, i16 %859, i64 1
%864 = insertelement <4 x i16> %863, i16 %860, i64 2
%865 = insertelement <4 x i16> %864, i16 %861, i64 3
%866 = and <4 x i16> %865, <i16 1, i16 1, i16 1, i16 1>
%867 = or <4 x i16> %853, %866
%868 = getelementptr inbounds i16, i16* %829, i64 3
%869 = getelementptr inbounds i16, i16* %832, i64 3
%870 = getelementptr inbounds i16, i16* %835, i64 3
%871 = getelementptr inbounds i16, i16* %838, i64 3
%872 = load i16, i16* %854
%873 = load i16, i16* %855
%874 = load i16, i16* %856
%875 = load i16, i16* %857
%876 = insertelement <4 x i16> poison, i16 %872, i64 0
%877 = insertelement <4 x i16> %876, i16 %873, i64 1
%878 = insertelement <4 x i16> %877, i16 %874, i64 2
%879 = insertelement <4 x i16> %878, i16 %875, i64 3
%880 = shl nuw nsw <4 x i16> %867, <i16 2, i16 2, i16 2, i16 2>
%881 = shl <4 x i16> %879, <i16 1, i16 1, i16 1, i16 1>
%882 = and <4 x i16> %881, <i16 2, i16 2, i16 2, i16 2>
%883 = or <4 x i16> %880, %882
%884 = getelementptr inbounds i16, i16* %829, i64 4
%885 = getelementptr inbounds i16, i16* %832, i64 4
%886 = getelementptr inbounds i16, i16* %835, i64 4
%887 = getelementptr inbounds i16, i16* %838, i64 4
%888 = load i16, i16* %868
%889 = load i16, i16* %869
%890 = load i16, i16* %870
%891 = load i16, i16* %871
%892 = insertelement <4 x i16> poison, i16 %888, i64 0
%893 = insertelement <4 x i16> %892, i16 %889, i64 1
%894 = insertelement <4 x i16> %893, i16 %890, i64 2
%895 = insertelement <4 x i16> %894, i16 %891, i64 3
%896 = and <4 x i16> %895, <i16 1, i16 1, i16 1, i16 1>
%897 = or <4 x i16> %883, %896
%898 = getelementptr inbounds i16, i16* %829, i64 5
%899 = getelementptr inbounds i16, i16* %832, i64 5
%900 = getelementptr inbounds i16, i16* %835, i64 5
%901 = getelementptr inbounds i16, i16* %838, i64 5
%902 = load i16, i16* %884
%903 = load i16, i16* %885
%904 = load i16, i16* %886
%905 = load i16, i16* %887
%906 = insertelement <4 x i16> poison, i16 %902, i64 0
%907 = insertelement <4 x i16> %906, i16 %903, i64 1
%908 = insertelement <4 x i16> %907, i16 %904, i64 2
%909 = insertelement <4 x i16> %908, i16 %905, i64 3
%910 = shl nuw nsw <4 x i16> %897, <i16 2, i16 2, i16 2, i16 2>
%911 = shl <4 x i16> %909, <i16 1, i16 1, i16 1, i16 1>
%912 = and <4 x i16> %911, <i16 2, i16 2, i16 2, i16 2>
%913 = or <4 x i16> %910, %912
%914 = getelementptr inbounds i16, i16* %829, i64 6
%915 = getelementptr inbounds i16, i16* %832, i64 6
%916 = getelementptr inbounds i16, i16* %835, i64 6
%917 = getelementptr inbounds i16, i16* %838, i64 6
%918 = load i16, i16* %898
%919 = load i16, i16* %899
%920 = load i16, i16* %900
%921 = load i16, i16* %901
%922 = insertelement <4 x i16> poison, i16 %918, i64 0
%923 = insertelement <4 x i16> %922, i16 %919, i64 1
%924 = insertelement <4 x i16> %923, i16 %920, i64 2
%925 = insertelement <4 x i16> %924, i16 %921, i64 3
%926 = and <4 x i16> %925, <i16 1, i16 1, i16 1, i16 1>
%927 = or <4 x i16> %913, %926
%928 = zext <4 x i16> %927 to <4 x i32>
%929 = getelementptr inbounds i16, i16* %829, i64 7
%930 = getelementptr inbounds i16, i16* %832, i64 7
%931 = getelementptr inbounds i16, i16* %835, i64 7
%932 = getelementptr inbounds i16, i16* %838, i64 7
%933 = load i16, i16* %914
%934 = load i16, i16* %915
%935 = load i16, i16* %916
%936 = load i16, i16* %917
%937 = insertelement <4 x i16> poison, i16 %933, i64 0
%938 = insertelement <4 x i16> %937, i16 %934, i64 1
%939 = insertelement <4 x i16> %938, i16 %935, i64 2
%940 = insertelement <4 x i16> %939, i16 %936, i64 3
%941 = shl nuw nsw <4 x i32> %928, <i32 2, i32 2, i32 2, i32 2>
%942 = shl <4 x i16> %940, <i16 1, i16 1, i16 1, i16 1>
%943 = and <4 x i16> %942, <i16 2, i16 2, i16 2, i16 2>
%944 = zext <4 x i16> %943 to <4 x i32>
%945 = or <4 x i32> %941, %944
%946 = getelementptr inbounds i16, i16* %829, i64 8
%947 = getelementptr inbounds i16, i16* %832, i64 8
%948 = getelementptr inbounds i16, i16* %835, i64 8
%949 = getelementptr inbounds i16, i16* %838, i64 8
%950 = load i16, i16* %929
%951 = load i16, i16* %930
%952 = load i16, i16* %931
%953 = load i16, i16* %932
%954 = insertelement <4 x i16> poison, i16 %950, i64 0
%955 = insertelement <4 x i16> %954, i16 %951, i64 1
%956 = insertelement <4 x i16> %955, i16 %952, i64 2
%957 = insertelement <4 x i16> %956, i16 %953, i64 3
%958 = and <4 x i16> %957, <i16 1, i16 1, i16 1, i16 1>
%959 = zext <4 x i16> %958 to <4 x i32>
%960 = or <4 x i32> %945, %959
%961 = getelementptr inbounds i16, i16* %829, i64 9
%962 = getelementptr inbounds i16, i16* %832, i64 9
%963 = getelementptr inbounds i16, i16* %835, i64 9
%964 = getelementptr inbounds i16, i16* %838, i64 9
%965 = load i16, i16* %946
%966 = load i16, i16* %947
%967 = load i16, i16* %948
%968 = load i16, i16* %949
%969 = insertelement <4 x i16> poison, i16 %965, i64 0
%970 = insertelement <4 x i16> %969, i16 %966, i64 1
%971 = insertelement <4 x i16> %970, i16 %967, i64 2
%972 = insertelement <4 x i16> %971, i16 %968, i64 3
%973 = shl nuw nsw <4 x i32> %960, <i32 2, i32 2, i32 2, i32 2>
%974 = shl <4 x i16> %972, <i16 1, i16 1, i16 1, i16 1>
%975 = and <4 x i16> %974, <i16 2, i16 2, i16 2, i16 2>
%976 = zext <4 x i16> %975 to <4 x i32>
%977 = or <4 x i32> %973, %976
%978 = getelementptr inbounds i16, i16* %829, i64 10
%979 = getelementptr inbounds i16, i16* %832, i64 10
%980 = getelementptr inbounds i16, i16* %835, i64 10
%981 = getelementptr inbounds i16, i16* %838, i64 10
%982 = load i16, i16* %961
%983 = load i16, i16* %962
%984 = load i16, i16* %963
%985 = load i16, i16* %964
%986 = insertelement <4 x i16> poison, i16 %982, i64 0
%987 = insertelement <4 x i16> %986, i16 %983, i64 1
%988 = insertelement <4 x i16> %987, i16 %984, i64 2
%989 = insertelement <4 x i16> %988, i16 %985, i64 3
%990 = and <4 x i16> %989, <i16 1, i16 1, i16 1, i16 1>
%991 = zext <4 x i16> %990 to <4 x i32>
%992 = or <4 x i32> %977, %991
%993 = getelementptr inbounds i16, i16* %829, i64 11
%994 = getelementptr inbounds i16, i16* %832, i64 11
%995 = getelementptr inbounds i16, i16* %835, i64 11
%996 = getelementptr inbounds i16, i16* %838, i64 11
%997 = load i16, i16* %978
%998 = load i16, i16* %979
%999 = load i16, i16* %980
%1000 = load i16, i16* %981
%1001 = insertelement <4 x i16> poison, i16 %997, i64 0
%1002 = insertelement <4 x i16> %1001, i16 %998, i64 1
%1003 = insertelement <4 x i16> %1002, i16 %999, i64 2
%1004 = insertelement <4 x i16> %1003, i16 %1000, i64 3
%1005 = shl <4 x i32> %992, <i32 2, i32 2, i32 2, i32 2>
%1006 = shl <4 x i16> %1004, <i16 1, i16 1, i16 1, i16 1>
%1007 = and <4 x i16> %1006, <i16 2, i16 2, i16 2, i16 2>
%1008 = zext <4 x i16> %1007 to <4 x i32>
%1009 = or <4 x i32> %1005, %1008
%1010 = getelementptr inbounds i16, i16* %829, i64 12
%1011 = getelementptr inbounds i16, i16* %832, i64 12
%1012 = getelementptr inbounds i16, i16* %835, i64 12
%1013 = getelementptr inbounds i16, i16* %838, i64 12
%1014 = load i16, i16* %993
%1015 = load i16, i16* %994
%1016 = load i16, i16* %995
%1017 = load i16, i16* %996
%1018 = insertelement <4 x i16> poison, i16 %1014, i64 0
%1019 = insertelement <4 x i16> %1018, i16 %1015, i64 1
%1020 = insertelement <4 x i16> %1019, i16 %1016, i64 2
%1021 = insertelement <4 x i16> %1020, i16 %1017, i64 3
%1022 = and <4 x i16> %1021, <i16 1, i16 1, i16 1, i16 1>
%1023 = zext <4 x i16> %1022 to <4 x i32>
%1024 = or <4 x i32> %1009, %1023
%1025 = getelementptr inbounds i16, i16* %829, i64 13
%1026 = getelementptr inbounds i16, i16* %832, i64 13
%1027 = getelementptr inbounds i16, i16* %835, i64 13
%1028 = getelementptr inbounds i16, i16* %838, i64 13
%1029 = load i16, i16* %1010
%1030 = load i16, i16* %1011
%1031 = load i16, i16* %1012
%1032 = load i16, i16* %1013
%1033 = insertelement <4 x i16> poison, i16 %1029, i64 0
%1034 = insertelement <4 x i16> %1033, i16 %1030, i64 1
%1035 = insertelement <4 x i16> %1034, i16 %1031, i64 2
%1036 = insertelement <4 x i16> %1035, i16 %1032, i64 3
%1037 = shl <4 x i32> %1024, <i32 2, i32 2, i32 2, i32 2>
%1038 = shl <4 x i16> %1036, <i16 1, i16 1, i16 1, i16 1>
%1039 = and <4 x i16> %1038, <i16 2, i16 2, i16 2, i16 2>
%1040 = zext <4 x i16> %1039 to <4 x i32>
%1041 = or <4 x i32> %1037, %1040
%1042 = getelementptr inbounds i16, i16* %829, i64 14
%1043 = getelementptr inbounds i16, i16* %832, i64 14
%1044 = getelementptr inbounds i16, i16* %835, i64 14
%1045 = getelementptr inbounds i16, i16* %838, i64 14
%1046 = load i16, i16* %1025
%1047 = load i16, i16* %1026
%1048 = load i16, i16* %1027
%1049 = load i16, i16* %1028
%1050 = insertelement <4 x i16> poison, i16 %1046, i64 0
%1051 = insertelement <4 x i16> %1050, i16 %1047, i64 1
%1052 = insertelement <4 x i16> %1051, i16 %1048, i64 2
%1053 = insertelement <4 x i16> %1052, i16 %1049, i64 3
%1054 = and <4 x i16> %1053, <i16 1, i16 1, i16 1, i16 1>
%1055 = zext <4 x i16> %1054 to <4 x i32>
%1056 = or <4 x i32> %1041, %1055
%1057 = getelementptr inbounds i16, i16* %829, i64 15
%1058 = getelementptr inbounds i16, i16* %832, i64 15
%1059 = getelementptr inbounds i16, i16* %835, i64 15
%1060 = getelementptr inbounds i16, i16* %838, i64 15
%1061 = load i16, i16* %1042
%1062 = load i16, i16* %1043
%1063 = load i16, i16* %1044
%1064 = load i16, i16* %1045
%1065 = insertelement <4 x i16> poison, i16 %1061, i64 0
%1066 = insertelement <4 x i16> %1065, i16 %1062, i64 1
%1067 = insertelement <4 x i16> %1066, i16 %1063, i64 2
%1068 = insertelement <4 x i16> %1067, i16 %1064, i64 3
%1069 = shl <4 x i32> %1056, <i32 2, i32 2, i32 2, i32 2>
%1070 = shl <4 x i16> %1068, <i16 1, i16 1, i16 1, i16 1>
%1071 = and <4 x i16> %1070, <i16 2, i16 2, i16 2, i16 2>
%1072 = zext <4 x i16> %1071 to <4 x i32>
%1073 = or <4 x i32> %1069, %1072
%1074 = getelementptr inbounds i16, i16* %829, i64 16
%1075 = getelementptr inbounds i16, i16* %832, i64 16
%1076 = getelementptr inbounds i16, i16* %835, i64 16
%1077 = getelementptr inbounds i16, i16* %838, i64 16
%1078 = load i16, i16* %1057
%1079 = load i16, i16* %1058
%1080 = load i16, i16* %1059
%1081 = load i16, i16* %1060
%1082 = insertelement <4 x i16> poison, i16 %1078, i64 0
%1083 = insertelement <4 x i16> %1082, i16 %1079, i64 1
%1084 = insertelement <4 x i16> %1083, i16 %1080, i64 2
%1085 = insertelement <4 x i16> %1084, i16 %1081, i64 3
%1086 = and <4 x i16> %1085, <i16 1, i16 1, i16 1, i16 1>
%1087 = zext <4 x i16> %1086 to <4 x i32>
%1088 = or <4 x i32> %1073, %1087
%1089 = getelementptr inbounds i16, i16* %829, i64 17
%1090 = getelementptr inbounds i16, i16* %832, i64 17
%1091 = getelementptr inbounds i16, i16* %835, i64 17
%1092 = getelementptr inbounds i16, i16* %838, i64 17
%1093 = load i16, i16* %1074
%1094 = load i16, i16* %1075
%1095 = load i16, i16* %1076
%1096 = load i16, i16* %1077
%1097 = insertelement <4 x i16> poison, i16 %1093, i64 0
%1098 = insertelement <4 x i16> %1097, i16 %1094, i64 1
%1099 = insertelement <4 x i16> %1098, i16 %1095, i64 2
%1100 = insertelement <4 x i16> %1099, i16 %1096, i64 3
%1101 = shl <4 x i32> %1088, <i32 2, i32 2, i32 2, i32 2>
%1102 = shl <4 x i16> %1100, <i16 1, i16 1, i16 1, i16 1>
%1103 = and <4 x i16> %1102, <i16 2, i16 2, i16 2, i16 2>
%1104 = zext <4 x i16> %1103 to <4 x i32>
%1105 = or <4 x i32> %1101, %1104
%1106 = getelementptr inbounds i16, i16* %829, i64 18
%1107 = getelementptr inbounds i16, i16* %832, i64 18
%1108 = getelementptr inbounds i16, i16* %835, i64 18
%1109 = getelementptr inbounds i16, i16* %838, i64 18
%1110 = load i16, i16* %1089
%1111 = load i16, i16* %1090
%1112 = load i16, i16* %1091
%1113 = load i16, i16* %1092
%1114 = insertelement <4 x i16> poison, i16 %1110, i64 0
%1115 = insertelement <4 x i16> %1114, i16 %1111, i64 1
%1116 = insertelement <4 x i16> %1115, i16 %1112, i64 2
%1117 = insertelement <4 x i16> %1116, i16 %1113, i64 3
%1118 = and <4 x i16> %1117, <i16 1, i16 1, i16 1, i16 1>
%1119 = zext <4 x i16> %1118 to <4 x i32>
%1120 = or <4 x i32> %1105, %1119
%1121 = getelementptr inbounds i16, i16* %829, i64 19
%1122 = getelementptr inbounds i16, i16* %832, i64 19
%1123 = getelementptr inbounds i16, i16* %835, i64 19
%1124 = getelementptr inbounds i16, i16* %838, i64 19
%1125 = load i16, i16* %1106
%1126 = load i16, i16* %1107
%1127 = load i16, i16* %1108
%1128 = load i16, i16* %1109
%1129 = insertelement <4 x i16> poison, i16 %1125, i64 0
%1130 = insertelement <4 x i16> %1129, i16 %1126, i64 1
%1131 = insertelement <4 x i16> %1130, i16 %1127, i64 2
%1132 = insertelement <4 x i16> %1131, i16 %1128, i64 3
%1133 = shl <4 x i32> %1120, <i32 2, i32 2, i32 2, i32 2>
%1134 = shl <4 x i16> %1132, <i16 1, i16 1, i16 1, i16 1>
%1135 = and <4 x i16> %1134, <i16 2, i16 2, i16 2, i16 2>
%1136 = zext <4 x i16> %1135 to <4 x i32>
%1137 = or <4 x i32> %1133, %1136
%1138 = getelementptr inbounds i16, i16* %829, i64 20
%1139 = getelementptr inbounds i16, i16* %832, i64 20
%1140 = getelementptr inbounds i16, i16* %835, i64 20
%1141 = getelementptr inbounds i16, i16* %838, i64 20
%1142 = load i16, i16* %1121
%1143 = load i16, i16* %1122
%1144 = load i16, i16* %1123
%1145 = load i16, i16* %1124
%1146 = insertelement <4 x i16> poison, i16 %1142, i64 0
%1147 = insertelement <4 x i16> %1146, i16 %1143, i64 1
%1148 = insertelement <4 x i16> %1147, i16 %1144, i64 2
%1149 = insertelement <4 x i16> %1148, i16 %1145, i64 3
%1150 = and <4 x i16> %1149, <i16 1, i16 1, i16 1, i16 1>
%1151 = zext <4 x i16> %1150 to <4 x i32>
%1152 = or <4 x i32> %1137, %1151
%1153 = getelementptr inbounds i16, i16* %829, i64 21
%1154 = getelementptr inbounds i16, i16* %832, i64 21
%1155 = getelementptr inbounds i16, i16* %835, i64 21
%1156 = getelementptr inbounds i16, i16* %838, i64 21
%1157 = load i16, i16* %1138
%1158 = load i16, i16* %1139
%1159 = load i16, i16* %1140
%1160 = load i16, i16* %1141
%1161 = insertelement <4 x i16> poison, i16 %1157, i64 0
%1162 = insertelement <4 x i16> %1161, i16 %1158, i64 1
%1163 = insertelement <4 x i16> %1162, i16 %1159, i64 2
%1164 = insertelement <4 x i16> %1163, i16 %1160, i64 3
%1165 = shl <4 x i32> %1152, <i32 2, i32 2, i32 2, i32 2>
%1166 = shl <4 x i16> %1164, <i16 1, i16 1, i16 1, i16 1>
%1167 = and <4 x i16> %1166, <i16 2, i16 2, i16 2, i16 2>
%1168 = zext <4 x i16> %1167 to <4 x i32>
%1169 = or <4 x i32> %1165, %1168
%1170 = getelementptr inbounds i16, i16* %829, i64 22
%1171 = getelementptr inbounds i16, i16* %832, i64 22
%1172 = getelementptr inbounds i16, i16* %835, i64 22
%1173 = getelementptr inbounds i16, i16* %838, i64 22
%1174 = load i16, i16* %1153
%1175 = load i16, i16* %1154
%1176 = load i16, i16* %1155
%1177 = load i16, i16* %1156
%1178 = insertelement <4 x i16> poison, i16 %1174, i64 0
%1179 = insertelement <4 x i16> %1178, i16 %1175, i64 1
%1180 = insertelement <4 x i16> %1179, i16 %1176, i64 2
%1181 = insertelement <4 x i16> %1180, i16 %1177, i64 3
%1182 = and <4 x i16> %1181, <i16 1, i16 1, i16 1, i16 1>
%1183 = zext <4 x i16> %1182 to <4 x i32>
%1184 = or <4 x i32> %1169, %1183
%1185 = getelementptr inbounds i16, i16* %829, i64 23
%1186 = getelementptr inbounds i16, i16* %832, i64 23
%1187 = getelementptr inbounds i16, i16* %835, i64 23
%1188 = getelementptr inbounds i16, i16* %838, i64 23
%1189 = load i16, i16* %1170
%1190 = load i16, i16* %1171
%1191 = load i16, i16* %1172
%1192 = load i16, i16* %1173
%1193 = insertelement <4 x i16> poison, i16 %1189, i64 0
%1194 = insertelement <4 x i16> %1193, i16 %1190, i64 1
%1195 = insertelement <4 x i16> %1194, i16 %1191, i64 2
%1196 = insertelement <4 x i16> %1195, i16 %1192, i64 3
%1197 = shl <4 x i32> %1184, <i32 2, i32 2, i32 2, i32 2>
%1198 = shl <4 x i16> %1196, <i16 1, i16 1, i16 1, i16 1>
%1199 = and <4 x i16> %1198, <i16 2, i16 2, i16 2, i16 2>
%1200 = zext <4 x i16> %1199 to <4 x i32>
%1201 = or <4 x i32> %1197, %1200
%1202 = getelementptr inbounds i16, i16* %829, i64 24
%1203 = getelementptr inbounds i16, i16* %832, i64 24
%1204 = getelementptr inbounds i16, i16* %835, i64 24
%1205 = getelementptr inbounds i16, i16* %838, i64 24
%1206 = load i16, i16* %1185
%1207 = load i16, i16* %1186
%1208 = load i16, i16* %1187
%1209 = load i16, i16* %1188
%1210 = insertelement <4 x i16> poison, i16 %1206, i64 0
%1211 = insertelement <4 x i16> %1210, i16 %1207, i64 1
%1212 = insertelement <4 x i16> %1211, i16 %1208, i64 2
%1213 = insertelement <4 x i16> %1212, i16 %1209, i64 3
%1214 = and <4 x i16> %1213, <i16 1, i16 1, i16 1, i16 1>
%1215 = zext <4 x i16> %1214 to <4 x i32>
%1216 = or <4 x i32> %1201, %1215
%1217 = getelementptr inbounds i16, i16* %829, i64 25
%1218 = getelementptr inbounds i16, i16* %832, i64 25
%1219 = getelementptr inbounds i16, i16* %835, i64 25
%1220 = getelementptr inbounds i16, i16* %838, i64 25
%1221 = load i16, i16* %1202
%1222 = load i16, i16* %1203
%1223 = load i16, i16* %1204
%1224 = load i16, i16* %1205
%1225 = insertelement <4 x i16> poison, i16 %1221, i64 0
%1226 = insertelement <4 x i16> %1225, i16 %1222, i64 1
%1227 = insertelement <4 x i16> %1226, i16 %1223, i64 2
%1228 = insertelement <4 x i16> %1227, i16 %1224, i64 3
%1229 = shl <4 x i32> %1216, <i32 2, i32 2, i32 2, i32 2>
%1230 = shl <4 x i16> %1228, <i16 1, i16 1, i16 1, i16 1>
%1231 = and <4 x i16> %1230, <i16 2, i16 2, i16 2, i16 2>
%1232 = zext <4 x i16> %1231 to <4 x i32>
%1233 = or <4 x i32> %1229, %1232
%1234 = getelementptr inbounds i16, i16* %829, i64 26
%1235 = getelementptr inbounds i16, i16* %832, i64 26
%1236 = getelementptr inbounds i16, i16* %835, i64 26
%1237 = getelementptr inbounds i16, i16* %838, i64 26
%1238 = load i16, i16* %1217
%1239 = load i16, i16* %1218
%1240 = load i16, i16* %1219
%1241 = load i16, i16* %1220
%1242 = insertelement <4 x i16> poison, i16 %1238, i64 0
%1243 = insertelement <4 x i16> %1242, i16 %1239, i64 1
%1244 = insertelement <4 x i16> %1243, i16 %1240, i64 2
%1245 = insertelement <4 x i16> %1244, i16 %1241, i64 3
%1246 = and <4 x i16> %1245, <i16 1, i16 1, i16 1, i16 1>
%1247 = zext <4 x i16> %1246 to <4 x i32>
%1248 = or <4 x i32> %1233, %1247
%1249 = getelementptr inbounds i16, i16* %829, i64 27
%1250 = getelementptr inbounds i16, i16* %832, i64 27
%1251 = getelementptr inbounds i16, i16* %835, i64 27
%1252 = getelementptr inbounds i16, i16* %838, i64 27
%1253 = load i16, i16* %1234
%1254 = load i16, i16* %1235
%1255 = load i16, i16* %1236
%1256 = load i16, i16* %1237
%1257 = insertelement <4 x i16> poison, i16 %1253, i64 0
%1258 = insertelement <4 x i16> %1257, i16 %1254, i64 1
%1259 = insertelement <4 x i16> %1258, i16 %1255, i64 2
%1260 = insertelement <4 x i16> %1259, i16 %1256, i64 3
%1261 = shl <4 x i32> %1248, <i32 2, i32 2, i32 2, i32 2>
%1262 = shl <4 x i16> %1260, <i16 1, i16 1, i16 1, i16 1>
%1263 = and <4 x i16> %1262, <i16 2, i16 2, i16 2, i16 2>
%1264 = zext <4 x i16> %1263 to <4 x i32>
%1265 = or <4 x i32> %1261, %1264
%1266 = getelementptr inbounds i16, i16* %829, i64 28
%1267 = getelementptr inbounds i16, i16* %832, i64 28
%1268 = getelementptr inbounds i16, i16* %835, i64 28
%1269 = getelementptr inbounds i16, i16* %838, i64 28
%1270 = load i16, i16* %1249
%1271 = load i16, i16* %1250
%1272 = load i16, i16* %1251
%1273 = load i16, i16* %1252
%1274 = insertelement <4 x i16> poison, i16 %1270, i64 0
%1275 = insertelement <4 x i16> %1274, i16 %1271, i64 1
%1276 = insertelement <4 x i16> %1275, i16 %1272, i64 2
%1277 = insertelement <4 x i16> %1276, i16 %1273, i64 3
%1278 = and <4 x i16> %1277, <i16 1, i16 1, i16 1, i16 1>
%1279 = zext <4 x i16> %1278 to <4 x i32>
%1280 = or <4 x i32> %1265, %1279
%1281 = getelementptr inbounds i16, i16* %829, i64 29
%1282 = getelementptr inbounds i16, i16* %832, i64 29
%1283 = getelementptr inbounds i16, i16* %835, i64 29
%1284 = getelementptr inbounds i16, i16* %838, i64 29
%1285 = load i16, i16* %1266
%1286 = load i16, i16* %1267
%1287 = load i16, i16* %1268
%1288 = load i16, i16* %1269
%1289 = insertelement <4 x i16> poison, i16 %1285, i64 0
%1290 = insertelement <4 x i16> %1289, i16 %1286, i64 1
%1291 = insertelement <4 x i16> %1290, i16 %1287, i64 2
%1292 = insertelement <4 x i16> %1291, i16 %1288, i64 3
%1293 = shl <4 x i32> %1280, <i32 2, i32 2, i32 2, i32 2>
%1294 = shl <4 x i16> %1292, <i16 1, i16 1, i16 1, i16 1>
%1295 = and <4 x i16> %1294, <i16 2, i16 2, i16 2, i16 2>
%1296 = zext <4 x i16> %1295 to <4 x i32>
%1297 = or <4 x i32> %1293, %1296
%1298 = getelementptr inbounds i16, i16* %829, i64 30
%1299 = getelementptr inbounds i16, i16* %832, i64 30
%1300 = getelementptr inbounds i16, i16* %835, i64 30
%1301 = getelementptr inbounds i16, i16* %838, i64 30
%1302 = load i16, i16* %1281
%1303 = load i16, i16* %1282
%1304 = load i16, i16* %1283
%1305 = load i16, i16* %1284
%1306 = insertelement <4 x i16> poison, i16 %1302, i64 0
%1307 = insertelement <4 x i16> %1306, i16 %1303, i64 1
%1308 = insertelement <4 x i16> %1307, i16 %1304, i64 2
%1309 = insertelement <4 x i16> %1308, i16 %1305, i64 3
%1310 = and <4 x i16> %1309, <i16 1, i16 1, i16 1, i16 1>
%1311 = zext <4 x i16> %1310 to <4 x i32>
%1312 = or <4 x i32> %1297, %1311
%1313 = getelementptr inbounds i16, i16* %829, i64 31
%1314 = getelementptr inbounds i16, i16* %832, i64 31
%1315 = getelementptr inbounds i16, i16* %835, i64 31
%1316 = getelementptr inbounds i16, i16* %838, i64 31
%1317 = load i16, i16* %1298
%1318 = load i16, i16* %1299
%1319 = load i16, i16* %1300
%1320 = load i16, i16* %1301
%1321 = insertelement <4 x i16> poison, i16 %1317, i64 0
%1322 = insertelement <4 x i16> %1321, i16 %1318, i64 1
%1323 = insertelement <4 x i16> %1322, i16 %1319, i64 2
%1324 = insertelement <4 x i16> %1323, i16 %1320, i64 3
%1325 = shl <4 x i32> %1312, <i32 2, i32 2, i32 2, i32 2>
%1326 = shl <4 x i16> %1324, <i16 1, i16 1, i16 1, i16 1>
%1327 = and <4 x i16> %1326, <i16 2, i16 2, i16 2, i16 2>
%1328 = zext <4 x i16> %1327 to <4 x i32>
%1329 = or <4 x i32> %1325, %1328
%1330 = load i16, i16* %1313
%1331 = load i16, i16* %1314
%1332 = load i16, i16* %1315
%1333 = load i16, i16* %1316
%1334 = insertelement <4 x i16> poison, i16 %1330, i64 0
%1335 = insertelement <4 x i16> %1334, i16 %1331, i64 1
%1336 = insertelement <4 x i16> %1335, i16 %1332, i64 2
%1337 = insertelement <4 x i16> %1336, i16 %1333, i64 3
%1338 = and <4 x i16> %1337, <i16 1, i16 1, i16 1, i16 1>
%1339 = zext <4 x i16> %1338 to <4 x i32>
%1340 = or <4 x i32> %1329, %1339
%1341 = bitcast i32* %839 to <4 x i32>*
store <4 x i32> %1340, <4 x i32>* %1341
%1342 = add nuw i64 %827, 4
%1343 = icmp eq i64 %1342, %819
br i1 %1343, label %1344, label %826
1344: ; preds = %826
%1345 = icmp eq i64 %819, %816
br i1 %1345, label %1542, label %1346
1346: ; preds = %810, %1344
%1347 = phi i16* [ %279, %810 ], [ %821, %1344 ]
%1348 = phi i32* [ %280, %810 ], [ %822, %1344 ]
%1349 = phi i32 [ %281, %810 ], [ %825, %1344 ]
br label %1350
1350: ; preds = %1346, %1350
%1351 = phi i16* [ %1538, %1350 ], [ %1347, %1346 ]
%1352 = phi i32* [ %1539, %1350 ], [ %1348, %1346 ]
%1353 = phi i32 [ %1540, %1350 ], [ %1349, %1346 ]
%1354 = getelementptr inbounds i16, i16* %1351, i64 1
%1355 = load i16, i16* %1351
%1356 = shl i16 %1355, 1
%1357 = and i16 %1356, 2
%1358 = getelementptr inbounds i16, i16* %1351, i64 2
%1359 = load i16, i16* %1354
%1360 = and i16 %1359, 1
%1361 = or i16 %1357, %1360
%1362 = getelementptr inbounds i16, i16* %1351, i64 3
%1363 = load i16, i16* %1358
%1364 = shl nuw nsw i16 %1361, 2
%1365 = shl i16 %1363, 1
%1366 = and i16 %1365, 2
%1367 = or i16 %1364, %1366
%1368 = getelementptr inbounds i16, i16* %1351, i64 4
%1369 = load i16, i16* %1362
%1370 = and i16 %1369, 1
%1371 = or i16 %1367, %1370
%1372 = getelementptr inbounds i16, i16* %1351, i64 5
%1373 = load i16, i16* %1368
%1374 = shl nuw nsw i16 %1371, 2
%1375 = shl i16 %1373, 1
%1376 = and i16 %1375, 2
%1377 = or i16 %1374, %1376
%1378 = getelementptr inbounds i16, i16* %1351, i64 6
%1379 = load i16, i16* %1372
%1380 = and i16 %1379, 1
%1381 = or i16 %1377, %1380
%1382 = zext i16 %1381 to i32
%1383 = getelementptr inbounds i16, i16* %1351, i64 7
%1384 = load i16, i16* %1378
%1385 = shl nuw nsw i32 %1382, 2
%1386 = shl i16 %1384, 1
%1387 = and i16 %1386, 2
%1388 = zext i16 %1387 to i32
%1389 = or i32 %1385, %1388
%1390 = getelementptr inbounds i16, i16* %1351, i64 8
%1391 = load i16, i16* %1383
%1392 = and i16 %1391, 1
%1393 = zext i16 %1392 to i32
%1394 = or i32 %1389, %1393
%1395 = getelementptr inbounds i16, i16* %1351, i64 9
%1396 = load i16, i16* %1390
%1397 = shl nuw nsw i32 %1394, 2
%1398 = shl i16 %1396, 1
%1399 = and i16 %1398, 2
%1400 = zext i16 %1399 to i32
%1401 = or i32 %1397, %1400
%1402 = getelementptr inbounds i16, i16* %1351, i64 10
%1403 = load i16, i16* %1395
%1404 = and i16 %1403, 1
%1405 = zext i16 %1404 to i32
%1406 = or i32 %1401, %1405
%1407 = getelementptr inbounds i16, i16* %1351, i64 11
%1408 = load i16, i16* %1402
%1409 = shl i32 %1406, 2
%1410 = shl i16 %1408, 1
%1411 = and i16 %1410, 2
%1412 = zext i16 %1411 to i32
%1413 = or i32 %1409, %1412
%1414 = getelementptr inbounds i16, i16* %1351, i64 12
%1415 = load i16, i16* %1407
%1416 = and i16 %1415, 1
%1417 = zext i16 %1416 to i32
%1418 = or i32 %1413, %1417
%1419 = getelementptr inbounds i16, i16* %1351, i64 13
%1420 = load i16, i16* %1414
%1421 = shl i32 %1418, 2
%1422 = shl i16 %1420, 1
%1423 = and i16 %1422, 2
%1424 = zext i16 %1423 to i32
%1425 = or i32 %1421, %1424
%1426 = getelementptr inbounds i16, i16* %1351, i64 14
%1427 = load i16, i16* %1419
%1428 = and i16 %1427, 1
%1429 = zext i16 %1428 to i32
%1430 = or i32 %1425, %1429
%1431 = getelementptr inbounds i16, i16* %1351, i64 15
%1432 = load i16, i16* %1426
%1433 = shl i32 %1430, 2
%1434 = shl i16 %1432, 1
%1435 = and i16 %1434, 2
%1436 = zext i16 %1435 to i32
%1437 = or i32 %1433, %1436
%1438 = getelementptr inbounds i16, i16* %1351, i64 16
%1439 = load i16, i16* %1431
%1440 = and i16 %1439, 1
%1441 = zext i16 %1440 to i32
%1442 = or i32 %1437, %1441
%1443 = getelementptr inbounds i16, i16* %1351, i64 17
%1444 = load i16, i16* %1438
%1445 = shl i32 %1442, 2
%1446 = shl i16 %1444, 1
%1447 = and i16 %1446, 2
%1448 = zext i16 %1447 to i32
%1449 = or i32 %1445, %1448
%1450 = getelementptr inbounds i16, i16* %1351, i64 18
%1451 = load i16, i16* %1443
%1452 = and i16 %1451, 1
%1453 = zext i16 %1452 to i32
%1454 = or i32 %1449, %1453
%1455 = getelementptr inbounds i16, i16* %1351, i64 19
%1456 = load i16, i16* %1450
%1457 = shl i32 %1454, 2
%1458 = shl i16 %1456, 1
%1459 = and i16 %1458, 2
%1460 = zext i16 %1459 to i32
%1461 = or i32 %1457, %1460
%1462 = getelementptr inbounds i16, i16* %1351, i64 20
%1463 = load i16, i16* %1455
%1464 = and i16 %1463, 1
%1465 = zext i16 %1464 to i32
%1466 = or i32 %1461, %1465
%1467 = getelementptr inbounds i16, i16* %1351, i64 21
%1468 = load i16, i16* %1462
%1469 = shl i32 %1466, 2
%1470 = shl i16 %1468, 1
%1471 = and i16 %1470, 2
%1472 = zext i16 %1471 to i32
%1473 = or i32 %1469, %1472
%1474 = getelementptr inbounds i16, i16* %1351, i64 22
%1475 = load i16, i16* %1467
%1476 = and i16 %1475, 1
%1477 = zext i16 %1476 to i32
%1478 = or i32 %1473, %1477
%1479 = getelementptr inbounds i16, i16* %1351, i64 23
%1480 = load i16, i16* %1474
%1481 = shl i32 %1478, 2
%1482 = shl i16 %1480, 1
%1483 = and i16 %1482, 2
%1484 = zext i16 %1483 to i32
%1485 = or i32 %1481, %1484
%1486 = getelementptr inbounds i16, i16* %1351, i64 24
%1487 = load i16, i16* %1479
%1488 = and i16 %1487, 1
%1489 = zext i16 %1488 to i32
%1490 = or i32 %1485, %1489
%1491 = getelementptr inbounds i16, i16* %1351, i64 25
%1492 = load i16, i16* %1486
%1493 = shl i32 %1490, 2
%1494 = shl i16 %1492, 1
%1495 = and i16 %1494, 2
%1496 = zext i16 %1495 to i32
%1497 = or i32 %1493, %1496
%1498 = getelementptr inbounds i16, i16* %1351, i64 26
%1499 = load i16, i16* %1491
%1500 = and i16 %1499, 1
%1501 = zext i16 %1500 to i32
%1502 = or i32 %1497, %1501
%1503 = getelementptr inbounds i16, i16* %1351, i64 27
%1504 = load i16, i16* %1498
%1505 = shl i32 %1502, 2
%1506 = shl i16 %1504, 1
%1507 = and i16 %1506, 2
%1508 = zext i16 %1507 to i32
%1509 = or i32 %1505, %1508
%1510 = getelementptr inbounds i16, i16* %1351, i64 28
%1511 = load i16, i16* %1503
%1512 = and i16 %1511, 1
%1513 = zext i16 %1512 to i32
%1514 = or i32 %1509, %1513
%1515 = getelementptr inbounds i16, i16* %1351, i64 29
%1516 = load i16, i16* %1510
%1517 = shl i32 %1514, 2
%1518 = shl i16 %1516, 1
%1519 = and i16 %1518, 2
%1520 = zext i16 %1519 to i32
%1521 = or i32 %1517, %1520
%1522 = getelementptr inbounds i16, i16* %1351, i64 30
%1523 = load i16, i16* %1515
%1524 = and i16 %1523, 1
%1525 = zext i16 %1524 to i32
%1526 = or i32 %1521, %1525
%1527 = getelementptr inbounds i16, i16* %1351, i64 31
%1528 = load i16, i16* %1522
%1529 = shl i32 %1526, 2
%1530 = shl i16 %1528, 1
%1531 = and i16 %1530, 2
%1532 = zext i16 %1531 to i32
%1533 = or i32 %1529, %1532
%1534 = load i16, i16* %1527
%1535 = and i16 %1534, 1
%1536 = zext i16 %1535 to i32
%1537 = or i32 %1533, %1536
%1538 = getelementptr i16, i16* %1351, i64 32
%1539 = getelementptr inbounds i32, i32* %1352, i64 1
store i32 %1537, i32* %1352
%1540 = add nsw i32 %1353, -32
%1541 = icmp ugt i32 %1353, 63
br i1 %1541, label %1350, label %1542
1542: ; preds = %1350, %705, %357, %117, %57, %25, %1344, %699, %351, %806, %11
%1543 = phi i16* [ %279, %806 ], [ %7, %11 ], [ %296, %351 ], [ %425, %699 ], [ %821, %1344 ], [ %41, %25 ], [ %103, %57 ], [ %156, %117 ], [ %402, %357 ], [ %798, %705 ], [ %1538, %1350 ]
%1544 = phi i32* [ %280, %806 ], [ %15, %11 ], [ %297, %351 ], [ %426, %699 ], [ %822, %1344 ], [ %50, %25 ], [ %111, %57 ], [ %166, %117 ], [ %407, %357 ], [ %803, %705 ], [ %1539, %1350 ]
%1545 = phi i32 [ %281, %806 ], [ %4, %11 ], [ %300, %351 ], [ %429, %699 ], [ %825, %1344 ], [ %51, %25 ], [ %112, %57 ], [ %167, %117 ], [ %408, %357 ], [ %804, %705 ], [ %1540, %1350 ]
%1546 = icmp sgt i32 %16, 0
br i1 %1546, label %1547, label %1551
1547: ; preds = %1542
%1548 = load i32, i32* %1544
%1549 = lshr i32 %1548, %17
%1550 = zext i32 %1549 to i64
br label %1551
1551: ; preds = %1547, %1542
%1552 = phi i64 [ %1550, %1547 ], [ 0, %1542 ]
%1553 = icmp sgt i32 %1545, 1
br i1 %1553, label %1554, label %1556
1554: ; preds = %1551
%1555 = zext i32 %2 to i64
br label %1563
1556: ; preds = %1605, %1551
%1557 = phi i64 [ %1552, %1551 ], [ %1606, %1605 ]
%1558 = phi i16* [ %1543, %1551 ], [ %1589, %1605 ]
%1559 = phi i32* [ %1544, %1551 ], [ %1607, %1605 ]
%1560 = phi i32 [ %1545, %1551 ], [ %1609, %1605 ]
%1561 = phi i32 [ %17, %1551 ], [ %1608, %1605 ]
%1562 = icmp sgt i32 %1560, 0
br i1 %1562, label %1611, label %1628
1563: ; preds = %1554, %1605
%1564 = phi i32 [ %17, %1554 ], [ %1608, %1605 ]
%1565 = phi i32 [ %1545, %1554 ], [ %1609, %1605 ]
%1566 = phi i32* [ %1544, %1554 ], [ %1607, %1605 ]
%1567 = phi i16* [ %1543, %1554 ], [ %1589, %1605 ]
%1568 = phi i64 [ %1552, %1554 ], [ %1606, %1605 ]
%1569 = getelementptr inbounds i16, i16* %1567, i64 1
%1570 = load i16, i16* %1567
%1571 = zext i16 %1570 to i32
%1572 = and i32 %1571, %19
%1573 = sub nsw i32 %1564, %2
%1574 = shl i64 %1568, %1555
%1575 = zext i32 %1572 to i64
%1576 = or i64 %1574, %1575
%1577 = icmp slt i32 %1573, 1
br i1 %1577, label %1578, label %1585
1578: ; preds = %1563
%1579 = sub nsw i32 0, %1573
%1580 = zext i32 %1579 to i64
%1581 = lshr i64 %1576, %1580
%1582 = trunc i64 %1581 to i32
%1583 = getelementptr inbounds i32, i32* %1566, i64 1
store i32 %1582, i32* %1566
%1584 = add nsw i32 %1573, 32
br label %1585
1585: ; preds = %1578, %1563
%1586 = phi i64 [ %1575, %1578 ], [ %1576, %1563 ]
%1587 = phi i32* [ %1583, %1578 ], [ %1566, %1563 ]
%1588 = phi i32 [ %1584, %1578 ], [ %1573, %1563 ]
%1589 = getelementptr inbounds i16, i16* %1567, i64 2
%1590 = load i16, i16* %1569
%1591 = zext i16 %1590 to i32
%1592 = and i32 %1591, %19
%1593 = sub nsw i32 %1588, %2
%1594 = shl i64 %1586, %1555
%1595 = zext i32 %1592 to i64
%1596 = or i64 %1594, %1595
%1597 = icmp slt i32 %1593, 1
br i1 %1597, label %1598, label %1605
1598: ; preds = %1585
%1599 = sub nsw i32 0, %1593
%1600 = zext i32 %1599 to i64
%1601 = lshr i64 %1596, %1600
%1602 = trunc i64 %1601 to i32
%1603 = getelementptr inbounds i32, i32* %1587, i64 1
store i32 %1602, i32* %1587
%1604 = add nsw i32 %1593, 32
br label %1605
1605: ; preds = %1598, %1585
%1606 = phi i64 [ %1595, %1598 ], [ %1596, %1585 ]
%1607 = phi i32* [ %1603, %1598 ], [ %1587, %1585 ]
%1608 = phi i32 [ %1604, %1598 ], [ %1593, %1585 ]
%1609 = add nsw i32 %1565, -2
%1610 = icmp ugt i32 %1565, 3
br i1 %1610, label %1563, label %1556
1611: ; preds = %1556
%1612 = zext i32 %2 to i64
%1613 = load i16, i16* %1558
%1614 = zext i16 %1613 to i32
%1615 = and i32 %1614, %19
%1616 = sub nsw i32 %1561, %2
%1617 = shl i64 %1557, %1612
%1618 = zext i32 %1615 to i64
%1619 = or i64 %1617, %1618
%1620 = icmp slt i32 %1616, 1
br i1 %1620, label %1621, label %1628
1621: ; preds = %1611
%1622 = sub nsw i32 0, %1616
%1623 = zext i32 %1622 to i64
%1624 = lshr i64 %1619, %1623
%1625 = trunc i64 %1624 to i32
%1626 = getelementptr inbounds i32, i32* %1559, i64 1
store i32 %1625, i32* %1559
%1627 = add nsw i32 %1616, 32
br label %1628
1628: ; preds = %1621, %1611, %1556
%1629 = phi i64 [ %1557, %1556 ], [ %1618, %1621 ], [ %1619, %1611 ]
%1630 = phi i32* [ %1559, %1556 ], [ %1626, %1621 ], [ %1559, %1611 ]
%1631 = phi i32 [ %1561, %1556 ], [ %1627, %1621 ], [ %1616, %1611 ]
%1632 = icmp slt i32 %1631, 32
br i1 %1632, label %1633, label %1637
1633: ; preds = %1628
%1634 = zext i32 %1631 to i64
%1635 = shl i64 %1629, %1634
%1636 = trunc i64 %1635 to i32
store i32 %1636, i32* %1630
br label %1637
1637: ; preds = %1628, %1633, %6
ret void
}