void IntegerPacker_32(void *stream, void *src, int nbits, int nbitt, int n,
                      int offset) {
  unsigned int *packed = (unsigned int *)stream;
  unsigned int *unpacked = (unsigned int *)src;
  unsigned long long temp;
  unsigned int maskk, token, token1, token2, token3, token4, token5, token6,
      token7, token8;
  int bleft, i;
  if (nbits > 32 || nbitt > nbits)
    return;
  packed += offset / 32;
  bleft = 32 - (offset % 32);
  maskk = 0xFFFFFFFF;
  if (nbitt < 32)
    maskk = ~(0xFFFFFFFF << nbitt);
  if (bleft == 32) {
    const unsigned int mask = maskk;
    if (nbits == 32) {
      packed = (unsigned int *)memcpy(stream, src, n * sizeof(unsigned int));
      return;
    }
    temp = 0;
    if (nbits == 24) {
      while (n > 3) {
        token1 = (*unpacked++) & mask;
        token2 = (*unpacked++) & mask;
        token3 = (*unpacked++) & mask;
        token4 = (*unpacked++) & mask;
        *packed++ = (token1 << 8) | (token2 >> 16);
        *packed++ = (token2 << 16) | (token3 >> 8);
        *packed++ = (token3 << 24) | token4;
        n -= 4;
      }
    }
    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;
  {
    const unsigned int mask = maskk;
    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_32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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   $0x20,-0x14(%rbp)
jg     1157 <IntegerPacker_32+0x47>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    115c <IntegerPacker_32+0x4c>
jmp    1ead <IntegerPacker_32+0xd9d>
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)
movl   $0xffffffff,-0x3c(%rbp)
cmpl   $0x20,-0x18(%rbp)
jge    11b1 <IntegerPacker_32+0xa1>
mov    -0x18(%rbp),%ecx
mov    $0xffffffff,%eax
shl    %cl,%eax
xor    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x20,-0x64(%rbp)
jne    1cb1 <IntegerPacker_32+0xba1>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x20,-0x14(%rbp)
jne    11f1 <IntegerPacker_32+0xe1>
mov    -0x8(%rbp),%rdi
mov    %rdi,-0x78(%rbp)
mov    -0x10(%rbp),%rsi
movslq -0x1c(%rbp),%rdx
shl    $0x2,%rdx
call   1030 <memcpy@plt>
mov    -0x78(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1ead <IntegerPacker_32+0xd9d>
movq   $0x0,-0x38(%rbp)
cmpl   $0x18,-0x14(%rbp)
jne    12d9 <IntegerPacker_32+0x1c9>
jmp    1208 <IntegerPacker_32+0xf8>
cmpl   $0x3,-0x1c(%rbp)
jle    12d4 <IntegerPacker_32+0x1c4>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x8,%ecx
mov    -0x48(%rbp),%eax
shr    $0x10,%eax
or     %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x48(%rbp),%ecx
shl    $0x10,%ecx
mov    -0x4c(%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    -0x4c(%rbp),%ecx
shl    $0x18,%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    1208 <IntegerPacker_32+0xf8>
jmp    12d9 <IntegerPacker_32+0x1c9>
cmpl   $0x10,-0x14(%rbp)
jne    1395 <IntegerPacker_32+0x285>
jmp    12e8 <IntegerPacker_32+0x1d8>
cmpl   $0x3,-0x1c(%rbp)
jle    1390 <IntegerPacker_32+0x280>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    12e8 <IntegerPacker_32+0x1d8>
jmp    1395 <IntegerPacker_32+0x285>
cmpl   $0xc,-0x14(%rbp)
jne    14f1 <IntegerPacker_32+0x3e1>
jmp    13a4 <IntegerPacker_32+0x294>
cmpl   $0x7,-0x1c(%rbp)
jle    14ec <IntegerPacker_32+0x3dc>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    13a4 <IntegerPacker_32+0x294>
jmp    14f1 <IntegerPacker_32+0x3e1>
cmpl   $0x8,-0x14(%rbp)
jne    1629 <IntegerPacker_32+0x519>
jmp    1500 <IntegerPacker_32+0x3f0>
cmpl   $0x7,-0x1c(%rbp)
jle    1624 <IntegerPacker_32+0x514>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    1500 <IntegerPacker_32+0x3f0>
jmp    1629 <IntegerPacker_32+0x519>
cmpl   $0x6,-0x14(%rbp)
jne    187d <IntegerPacker_32+0x76d>
jmp    1638 <IntegerPacker_32+0x528>
cmpl   $0xf,-0x1c(%rbp)
jle    1878 <IntegerPacker_32+0x768>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    1638 <IntegerPacker_32+0x528>
jmp    187d <IntegerPacker_32+0x76d>
cmpl   $0x4,-0x14(%rbp)
jne    19a7 <IntegerPacker_32+0x897>
jmp    188c <IntegerPacker_32+0x77c>
cmpl   $0x7,-0x1c(%rbp)
jle    19a2 <IntegerPacker_32+0x892>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
shl    $0x4,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    188c <IntegerPacker_32+0x77c>
jmp    19a7 <IntegerPacker_32+0x897>
cmpl   $0x2,-0x14(%rbp)
jne    1bc9 <IntegerPacker_32+0xab9>
jmp    19b6 <IntegerPacker_32+0x8a6>
cmpl   $0xf,-0x1c(%rbp)
jle    1bc4 <IntegerPacker_32+0xab4>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    -0x6c(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x6c(%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    19b6 <IntegerPacker_32+0x8a6>
jmp    1bc9 <IntegerPacker_32+0xab9>
cmpl   $0x1,-0x14(%rbp)
jne    1cac <IntegerPacker_32+0xb9c>
jmp    1bd8 <IntegerPacker_32+0xac8>
cmpl   $0x1f,-0x1c(%rbp)
jle    1ca7 <IntegerPacker_32+0xb97>
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     1c85 <IntegerPacker_32+0xb75>
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%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    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%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    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%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    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rcx),%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
jmp    1bf0 <IntegerPacker_32+0xae0>
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    1bd8 <IntegerPacker_32+0xac8>
jmp    1cac <IntegerPacker_32+0xb9c>
jmp    1cb1 <IntegerPacker_32+0xba1>
cmpl   $0x20,-0x64(%rbp)
jge    1ccc <IntegerPacker_32+0xbbc>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    -0x64(%rbp),%ecx
shr    %cl,%eax
mov    %eax,%eax
mov    %rax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jle    1df0 <IntegerPacker_32+0xce0>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x70(%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     1d5f <IntegerPacker_32+0xc4f>
cmpl   $0x0,-0x64(%rbp)
jge    1d38 <IntegerPacker_32+0xc28>
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    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x70(%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     1de2 <IntegerPacker_32+0xcd2>
cmpl   $0x0,-0x64(%rbp)
jge    1dbb <IntegerPacker_32+0xcab>
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    1cd2 <IntegerPacker_32+0xbc2>
jmp    1df5 <IntegerPacker_32+0xce5>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1e91 <IntegerPacker_32+0xd81>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%eax
and    -0x70(%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     1e8c <IntegerPacker_32+0xd7c>
cmpl   $0x0,-0x64(%rbp)
jge    1e65 <IntegerPacker_32+0xd55>
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    1df5 <IntegerPacker_32+0xce5>
cmpl   $0x20,-0x64(%rbp)
jge    1ead <IntegerPacker_32+0xd9d>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    %cl,%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<IntegerPacker_32>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    $0x20,%edx
jg     1261 <IntegerPacker_32+0x151>
cmp    %edx,%ecx
jg     1261 <IntegerPacker_32+0x151>
lea    0x1f(%r9),%ebp
test   %r9d,%r9d
cmovns %r9d,%ebp
mov    %ebp,%eax
sar    $0x5,%eax
cltq
lea    (%rdi,%rax,4),%r11
and    $0xffffffe0,%ebp
sub    %ebp,%r9d
mov    $0xffffffff,%eax
mov    $0xffffffff,%r10d
shl    %cl,%r10d
cmp    $0x20,%ecx
not    %r10d
cmovge %eax,%r10d
test   %r9d,%r9d
je     1216 <IntegerPacker_32+0x106>
mov    %rsi,%r15
mov    $0x20,%eax
sub    %r9d,%eax
test   %r9d,%r9d
jle    122f <IntegerPacker_32+0x11f>
mov    (%r11),%esi
mov    %eax,%ecx
shr    %cl,%rsi
cmp    $0x2,%r8d
jl     123b <IntegerPacker_32+0x12b>
mov    %edx,%r9d
jmp    11c2 <IntegerPacker_32+0xb2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
neg    %cl
shr    %cl,%rbx
mov    %ebx,(%r11)
add    $0x4,%r11
add    $0x20,%eax
lea    -0x2(%r8),%ecx
lea    0x8(%rdi),%r15
cmp    $0x3,%r8d
mov    %ecx,%r8d
jbe    1209 <IntegerPacker_32+0xf9>
mov    %r15,%rdi
mov    %r9d,%ecx
shl    %cl,%rsi
mov    (%r15),%ebx
and    %r10d,%ebx
or     %rbx,%rsi
sub    %edx,%eax
jle    11e0 <IntegerPacker_32+0xd0>
mov    %rsi,%rbx
jmp    11f1 <IntegerPacker_32+0xe1>
nopl   (%rax)
mov    %eax,%ecx
neg    %cl
shr    %cl,%rsi
mov    %esi,(%r11)
add    $0x4,%r11
add    $0x20,%eax
mov    %r9d,%ecx
shl    %cl,%rbx
mov    0x4(%rdi),%esi
and    %r10d,%esi
or     %rsi,%rbx
sub    %edx,%eax
jle    11a0 <IntegerPacker_32+0x90>
mov    %rbx,%rsi
jmp    11b1 <IntegerPacker_32+0xa1>
add    $0x8,%rdi
mov    %rdi,%r15
test   %ecx,%ecx
jg     1242 <IntegerPacker_32+0x132>
jmp    1251 <IntegerPacker_32+0x141>
cmp    $0x20,%edx
jne    1282 <IntegerPacker_32+0x172>
movslq %r8d,%rdx
shl    $0x2,%rdx
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <memcpy@plt>
xor    %esi,%esi
cmp    $0x2,%r8d
jge    118c <IntegerPacker_32+0x7c>
mov    %r8d,%ecx
test   %ecx,%ecx
jle    1251 <IntegerPacker_32+0x141>
mov    %edx,%ecx
shl    %cl,%rsi
and    (%r15),%r10d
or     %r10,%rsi
sub    %edx,%eax
jle    126a <IntegerPacker_32+0x15a>
mov    %rsi,%r10
cmp    $0x1f,%eax
jg     1261 <IntegerPacker_32+0x151>
mov    %eax,%ecx
shl    %cl,%r10
mov    %r10d,(%r11)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%ecx
neg    %cl
shr    %cl,%rsi
mov    %esi,(%r11)
add    $0x4,%r11
add    $0x20,%eax
cmp    $0x1f,%eax
jle    1259 <IntegerPacker_32+0x149>
jmp    1261 <IntegerPacker_32+0x151>
cmp    $0x18,%edx
jne    12e5 <IntegerPacker_32+0x1d5>
cmp    $0x4,%r8d
jl     12e5 <IntegerPacker_32+0x1d5>
nopl   (%rax)
mov    %r8d,%r14d
mov    (%rsi),%ecx
and    %r10d,%ecx
mov    0x4(%rsi),%eax
and    %r10d,%eax
mov    0x8(%rsi),%ebp
and    %r10d,%ebp
mov    0xc(%rsi),%ebx
and    %r10d,%ebx
add    $0x10,%rsi
shl    $0x8,%ecx
mov    %eax,%edi
shr    $0x10,%edi
or     %ecx,%edi
mov    %edi,(%r11)
shl    $0x10,%eax
mov    %ebp,%ecx
shr    $0x8,%ecx
or     %eax,%ecx
mov    %ecx,0x4(%r11)
shl    $0x18,%ebp
or     %ebx,%ebp
mov    %ebp,0x8(%r11)
add    $0xc,%r11
lea    -0x4(%r14),%r8d
cmp    $0x7,%r14d
ja     1290 <IntegerPacker_32+0x180>
jmp    1166 <IntegerPacker_32+0x56>
cmp    $0x10,%edx
jne    1331 <IntegerPacker_32+0x221>
cmp    $0x4,%r8d
jl     1331 <IntegerPacker_32+0x221>
mov    %r8d,%eax
mov    (%rsi),%ecx
and    %r10d,%ecx
mov    0x4(%rsi),%edi
and    %r10d,%edi
mov    0x8(%rsi),%ebp
and    %r10d,%ebp
mov    0xc(%rsi),%ebx
and    %r10d,%ebx
add    $0x10,%rsi
shl    $0x10,%ecx
or     %edi,%ecx
mov    %ecx,(%r11)
shl    $0x10,%ebp
or     %ebx,%ebp
mov    %ebp,0x4(%r11)
add    $0x8,%r11
lea    -0x4(%rax),%r8d
cmp    $0x7,%eax
ja     12f0 <IntegerPacker_32+0x1e0>
jmp    1166 <IntegerPacker_32+0x56>
cmp    $0xc,%edx
jne    13dc <IntegerPacker_32+0x2cc>
cmp    $0x8,%r8d
jl     13dc <IntegerPacker_32+0x2cc>
mov    %rsi,%r15
mov    %r8d,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r15),%esi
and    %r10d,%esi
mov    0x4(%r15),%edi
and    %r10d,%edi
mov    0x8(%r15),%ebp
and    %r10d,%ebp
mov    0xc(%r15),%ecx
and    %r10d,%ecx
shl    $0x14,%esi
shl    $0x8,%edi
or     %esi,%edi
mov    %ebp,%esi
shr    $0x4,%esi
or     %edi,%esi
mov    %esi,(%r11)
mov    0x10(%r15),%edi
and    %r10d,%edi
mov    0x14(%r15),%ebx
and    %r10d,%ebx
shl    $0x1c,%ebp
shl    $0x10,%ecx
or     %ebp,%ecx
shl    $0x4,%edi
mov    %ebx,%esi
shr    $0x8,%esi
or     %edi,%esi
or     %ecx,%esi
mov    %esi,0x4(%r11)
mov    0x18(%r15),%ecx
and    %r10d,%ecx
mov    0x1c(%r15),%esi
and    %r10d,%esi
add    $0x20,%r15
shl    $0x18,%ebx
shl    $0xc,%ecx
or     %ebx,%ecx
or     %esi,%ecx
mov    %ecx,0x8(%r11)
add    $0xc,%r11
lea    -0x8(%rax),%r8d
cmp    $0xf,%eax
mov    %r8d,%eax
ja     1350 <IntegerPacker_32+0x240>
jmp    1169 <IntegerPacker_32+0x59>
cmp    $0x8,%edx
jne    1466 <IntegerPacker_32+0x356>
cmp    $0x8,%r8d
jl     1466 <IntegerPacker_32+0x356>
mov    %rsi,%r15
mov    %r8d,%eax
mov    (%r15),%ecx
and    %r10d,%ecx
mov    0x4(%r15),%esi
and    %r10d,%esi
mov    0x8(%r15),%edi
and    %r10d,%edi
mov    0xc(%r15),%ebp
and    %r10d,%ebp
shl    $0x18,%ecx
shl    $0x10,%esi
or     %ecx,%esi
shl    $0x8,%edi
or     %ebp,%edi
or     %esi,%edi
mov    %edi,(%r11)
mov    0x10(%r15),%ecx
and    %r10d,%ecx
mov    0x14(%r15),%esi
and    %r10d,%esi
mov    0x18(%r15),%edi
and    %r10d,%edi
mov    0x1c(%r15),%ebp
and    %r10d,%ebp
add    $0x20,%r15
shl    $0x18,%ecx
shl    $0x10,%esi
or     %ecx,%esi
shl    $0x8,%edi
or     %ebp,%edi
or     %esi,%edi
mov    %edi,0x4(%r11)
add    $0x8,%r11
lea    -0x8(%rax),%r8d
cmp    $0xf,%eax
mov    %r8d,%eax
ja     13f1 <IntegerPacker_32+0x2e1>
jmp    1169 <IntegerPacker_32+0x59>
cmp    $0x6,%edx
jne    155d <IntegerPacker_32+0x44d>
cmp    $0x10,%r8d
jl     155d <IntegerPacker_32+0x44d>
mov    %r8d,%r14d
mov    (%rsi),%ebx
and    %r10d,%ebx
mov    0x4(%rsi),%eax
and    %r10d,%eax
mov    0x8(%rsi),%ecx
and    %r10d,%ecx
mov    0xc(%rsi),%edi
and    %r10d,%edi
mov    0x10(%rsi),%ebp
and    %r10d,%ebp
mov    0x14(%rsi),%r15d
and    %r10d,%r15d
mov    0x18(%rsi),%r12d
and    %r10d,%r12d
mov    0x1c(%rsi),%r8d
and    %r10d,%r8d
shl    $0x1a,%ebx
shl    $0x14,%eax
or     %ebx,%eax
shl    $0xe,%ecx
shl    $0x8,%edi
or     %ecx,%edi
or     %eax,%edi
shl    $0x2,%ebp
mov    %r15d,%eax
shr    $0x4,%eax
or     %ebp,%eax
or     %edi,%eax
mov    %eax,(%r11)
mov    0x20(%rsi),%eax
and    %r10d,%eax
mov    0x24(%rsi),%ecx
and    %r10d,%ecx
mov    0x28(%rsi),%ebx
and    %r10d,%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(%r11)
mov    0x2c(%rsi),%eax
and    %r10d,%eax
mov    0x30(%rsi),%ecx
and    %r10d,%ecx
mov    0x34(%rsi),%edi
and    %r10d,%edi
mov    0x38(%rsi),%ebp
and    %r10d,%ebp
mov    0x3c(%rsi),%r8d
and    %r10d,%r8d
add    $0x40,%rsi
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(%r11)
add    $0xc,%r11
lea    -0x10(%r14),%r8d
cmp    $0x1f,%r14d
ja     1479 <IntegerPacker_32+0x369>
mov    %r11,%rax
cmp    $0x4,%edx
jne    15ee <IntegerPacker_32+0x4de>
cmp    $0x8,%r8d
jl     15ee <IntegerPacker_32+0x4de>
mov    %rsi,%r15
mov    %rax,%r11
mov    %r8d,%eax
mov    (%r15),%ecx
and    %r10d,%ecx
mov    0x4(%r15),%esi
and    %r10d,%esi
shl    $0x8,%ecx
shl    $0x4,%esi
or     %ecx,%esi
mov    0x8(%r15),%ecx
and    %r10d,%ecx
or     %esi,%ecx
mov    0xc(%r15),%esi
and    %r10d,%esi
mov    0x10(%r15),%edi
and    %r10d,%edi
mov    0x14(%r15),%ebp
and    %r10d,%ebp
shl    $0x10,%ecx
shl    $0xc,%esi
shl    $0x8,%edi
or     %esi,%edi
or     %ecx,%edi
shl    $0x4,%ebp
mov    0x18(%r15),%ecx
and    %r10d,%ecx
or     %ebp,%ecx
or     %edi,%ecx
shl    $0x4,%ecx
mov    0x1c(%r15),%esi
and    %r10d,%esi
add    $0x20,%r15
or     %ecx,%esi
mov    %esi,(%r11)
add    $0x4,%r11
lea    -0x8(%rax),%r8d
cmp    $0xf,%eax
mov    %r8d,%eax
ja     1578 <IntegerPacker_32+0x468>
jmp    1169 <IntegerPacker_32+0x59>
cmp    $0x2,%edx
jne    16e4 <IntegerPacker_32+0x5d4>
cmp    $0x10,%r8d
jl     16e4 <IntegerPacker_32+0x5d4>
mov    %rsi,%r15
mov    %rax,%r11
mov    %r8d,%eax
mov    (%r15),%ecx
and    %r10d,%ecx
mov    0x4(%r15),%esi
and    %r10d,%esi
shl    $0x4,%ecx
shl    $0x2,%esi
or     %ecx,%esi
mov    0x8(%r15),%ecx
and    %r10d,%ecx
or     %esi,%ecx
mov    0xc(%r15),%esi
and    %r10d,%esi
mov    0x10(%r15),%edi
and    %r10d,%edi
mov    0x14(%r15),%ebp
and    %r10d,%ebp
shl    $0x8,%ecx
shl    $0x6,%esi
shl    $0x4,%edi
or     %esi,%edi
or     %ecx,%edi
shl    $0x2,%ebp
mov    0x18(%r15),%ecx
and    %r10d,%ecx
or     %ebp,%ecx
or     %edi,%ecx
mov    0x1c(%r15),%esi
and    %r10d,%esi
mov    0x20(%r15),%edi
and    %r10d,%edi
mov    0x24(%r15),%ebp
and    %r10d,%ebp
shl    $0x8,%ecx
shl    $0x6,%esi
shl    $0x4,%edi
or     %esi,%edi
or     %ecx,%edi
shl    $0x2,%ebp
mov    0x28(%r15),%ecx
and    %r10d,%ecx
or     %ebp,%ecx
or     %edi,%ecx
mov    0x2c(%r15),%esi
and    %r10d,%esi
mov    0x30(%r15),%edi
and    %r10d,%edi
mov    0x34(%r15),%ebp
and    %r10d,%ebp
shl    $0x8,%ecx
shl    $0x6,%esi
shl    $0x4,%edi
or     %esi,%edi
or     %ecx,%edi
shl    $0x2,%ebp
mov    0x38(%r15),%ecx
and    %r10d,%ecx
or     %ebp,%ecx
or     %edi,%ecx
shl    $0x2,%ecx
mov    0x3c(%r15),%esi
and    %r10d,%esi
add    $0x40,%r15
or     %ecx,%esi
mov    %esi,(%r11)
add    $0x4,%r11
lea    -0x10(%rax),%r8d
cmp    $0x1f,%eax
mov    %r8d,%eax
ja     160a <IntegerPacker_32+0x4fa>
jmp    1169 <IntegerPacker_32+0x59>
cmp    $0x1,%edx
jne    18c3 <IntegerPacker_32+0x7b3>
cmp    $0x20,%r8d
jl     18c3 <IntegerPacker_32+0x7b3>
xor    %edi,%edi
mov    %r8d,%r14d
sub    $0x3f,%r14d
cmovb  %edi,%r14d
add    $0x1f,%r14d
cmp    $0x60,%r14d
jb     1748 <IntegerPacker_32+0x638>
mov    %r8d,%ecx
sub    $0x3f,%ecx
cmovb  %edi,%ecx
add    $0x1f,%ecx
shr    $0x5,%ecx
mov    %rcx,%rdi
shl    $0x7,%rdi
add    %rsi,%rdi
add    $0x80,%rdi
cmp    %rdi,%rax
jae    18ce <IntegerPacker_32+0x7be>
lea    (%rax,%rcx,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%rsi
jae    18ce <IntegerPacker_32+0x7be>
mov    %rsi,%r15
mov    %rax,%r11
mov    %r8d,%eax
mov    (%r15),%ecx
mov    0x4(%r15),%esi
and    $0x1,%ecx
and    $0x1,%esi
mov    0x8(%r15),%edi
and    $0x1,%edi
lea    (%rsi,%rcx,2),%ecx
add    %edi,%edi
mov    0xc(%r15),%esi
and    $0x1,%esi
lea    (%rdi,%rcx,4),%ecx
or     %ecx,%esi
mov    0x10(%r15),%ecx
and    $0x1,%ecx
shl    $0x2,%esi
lea    (%rsi,%rcx,2),%ecx
mov    0x14(%r15),%esi
and    $0x1,%esi
or     %ecx,%esi
mov    0x18(%r15),%ecx
and    $0x1,%ecx
add    %ecx,%ecx
lea    (%rcx,%rsi,4),%ecx
mov    0x1c(%r15),%esi
and    $0x1,%esi
mov    0x20(%r15),%edi
or     %ecx,%esi
shl    $0x2,%esi
and    $0x1,%edi
mov    0x24(%r15),%ecx
lea    (%rsi,%rdi,2),%esi
and    $0x1,%ecx
mov    0x28(%r15),%edi
and    $0x1,%edi
or     %esi,%ecx
add    %edi,%edi
mov    0x2c(%r15),%esi
and    $0x1,%esi
lea    (%rdi,%rcx,4),%ecx
or     %ecx,%esi
mov    0x30(%r15),%ecx
and    $0x1,%ecx
shl    $0x2,%esi
lea    (%rsi,%rcx,2),%ecx
mov    0x34(%r15),%esi
and    $0x1,%esi
or     %ecx,%esi
mov    0x38(%r15),%ecx
and    $0x1,%ecx
add    %ecx,%ecx
lea    (%rcx,%rsi,4),%ecx
mov    0x3c(%r15),%esi
and    $0x1,%esi
mov    0x40(%r15),%edi
or     %ecx,%esi
shl    $0x2,%esi
and    $0x1,%edi
mov    0x44(%r15),%ecx
lea    (%rsi,%rdi,2),%esi
and    $0x1,%ecx
mov    0x48(%r15),%edi
and    $0x1,%edi
or     %esi,%ecx
add    %edi,%edi
mov    0x4c(%r15),%esi
and    $0x1,%esi
lea    (%rdi,%rcx,4),%ecx
or     %ecx,%esi
mov    0x50(%r15),%ecx
and    $0x1,%ecx
shl    $0x2,%esi
lea    (%rsi,%rcx,2),%ecx
mov    0x54(%r15),%esi
and    $0x1,%esi
or     %ecx,%esi
mov    0x58(%r15),%ecx
and    $0x1,%ecx
add    %ecx,%ecx
lea    (%rcx,%rsi,4),%ecx
mov    0x5c(%r15),%esi
and    $0x1,%esi
mov    0x60(%r15),%edi
or     %ecx,%esi
shl    $0x2,%esi
and    $0x1,%edi
mov    0x64(%r15),%ecx
lea    (%rsi,%rdi,2),%esi
and    $0x1,%ecx
mov    0x68(%r15),%edi
and    $0x1,%edi
or     %esi,%ecx
add    %edi,%edi
mov    0x6c(%r15),%esi
and    $0x1,%esi
lea    (%rdi,%rcx,4),%ecx
or     %ecx,%esi
mov    0x70(%r15),%ecx
and    $0x1,%ecx
shl    $0x2,%esi
lea    (%rsi,%rcx,2),%ecx
mov    0x74(%r15),%esi
and    $0x1,%esi
or     %ecx,%esi
mov    0x78(%r15),%ecx
and    $0x1,%ecx
add    %ecx,%ecx
lea    (%rcx,%rsi,4),%ecx
mov    0x7c(%r15),%esi
and    $0x1,%esi
sub    $0xffffffffffffff80,%r15
or     %ecx,%esi
mov    %esi,(%r11)
add    $0x4,%r11
lea    -0x20(%rax),%r8d
cmp    $0x3f,%eax
mov    %r8d,%eax
ja     1751 <IntegerPacker_32+0x641>
jmp    1169 <IntegerPacker_32+0x59>
mov    %rsi,%r15
mov    %rax,%r11
jmp    1169 <IntegerPacker_32+0x59>
shr    $0x5,%r14d
add    $0x1,%r14d
mov    %r14d,%ebx
and    $0xfffffffc,%ebx
mov    %rbx,%r15
shl    $0x7,%r15
add    %rsi,%r15
lea    (%rax,%rbx,4),%r11
mov    %ebx,%ecx
shl    $0x5,%ecx
sub    %ecx,%r8d
add    $0x1fc,%rsi
xor    %ecx,%ecx
movdqa 0x6fd(%rip),%xmm0
movdqa 0x705(%rip),%xmm1
movd   -0x7c(%rsi),%xmm2
movd   -0xfc(%rsi),%xmm3
ff
punpckldq %xmm2,%xmm3
movd   -0x17c(%rsi),%xmm2
ff
movd   -0x1fc(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm4
pand   %xmm1,%xmm4
movd   -0x78(%rsi),%xmm2
movd   -0xf8(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
movd   -0x178(%rsi),%xmm2
ff
movd   -0x1f8(%rsi),%xmm3
ff
punpckldq %xmm2,%xmm3
punpcklqdq %xmm5,%xmm3
pand   %xmm0,%xmm3
por    %xmm4,%xmm3
movd   -0x74(%rsi),%xmm2
movd   -0xf4(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x174(%rsi),%xmm2
ff
movd   -0x1f4(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x70(%rsi),%xmm2
movd   -0xf0(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x170(%rsi),%xmm6
ff
movd   -0x1f0(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0x6c(%rsi),%xmm3
movd   -0xec(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x16c(%rsi),%xmm3
ff
movd   -0x1ec(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x68(%rsi),%xmm3
movd   -0xe8(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x168(%rsi),%xmm6
ff
movd   -0x1e8(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x64(%rsi),%xmm2
movd   -0xe4(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x164(%rsi),%xmm2
ff
movd   -0x1e4(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x60(%rsi),%xmm2
movd   -0xe0(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x160(%rsi),%xmm6
ff
movd   -0x1e0(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0x5c(%rsi),%xmm3
movd   -0xdc(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x15c(%rsi),%xmm3
ff
movd   -0x1dc(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x58(%rsi),%xmm3
movd   -0xd8(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x158(%rsi),%xmm6
ff
movd   -0x1d8(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x54(%rsi),%xmm2
movd   -0xd4(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x154(%rsi),%xmm2
ff
movd   -0x1d4(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x50(%rsi),%xmm2
movd   -0xd0(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x150(%rsi),%xmm6
ff
movd   -0x1d0(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0x4c(%rsi),%xmm3
movd   -0xcc(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x14c(%rsi),%xmm3
ff
movd   -0x1cc(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x48(%rsi),%xmm3
movd   -0xc8(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x148(%rsi),%xmm6
ff
movd   -0x1c8(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x44(%rsi),%xmm2
movd   -0xc4(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x144(%rsi),%xmm2
ff
movd   -0x1c4(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x40(%rsi),%xmm2
movd   -0xc0(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x140(%rsi),%xmm6
ff
movd   -0x1c0(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0x3c(%rsi),%xmm3
movd   -0xbc(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x13c(%rsi),%xmm3
ff
movd   -0x1bc(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x38(%rsi),%xmm3
movd   -0xb8(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x138(%rsi),%xmm6
ff
movd   -0x1b8(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x34(%rsi),%xmm2
movd   -0xb4(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x134(%rsi),%xmm2
ff
movd   -0x1b4(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x30(%rsi),%xmm2
movd   -0xb0(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x130(%rsi),%xmm6
ff
movd   -0x1b0(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0x2c(%rsi),%xmm3
movd   -0xac(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x12c(%rsi),%xmm3
ff
movd   -0x1ac(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x28(%rsi),%xmm3
movd   -0xa8(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x128(%rsi),%xmm6
ff
movd   -0x1a8(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x24(%rsi),%xmm2
movd   -0xa4(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x124(%rsi),%xmm2
ff
movd   -0x1a4(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x20(%rsi),%xmm2
movd   -0xa0(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x120(%rsi),%xmm6
ff
movd   -0x1a0(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0x1c(%rsi),%xmm3
movd   -0x9c(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x11c(%rsi),%xmm3
ff
movd   -0x19c(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x18(%rsi),%xmm3
movd   -0x98(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x118(%rsi),%xmm6
ff
movd   -0x198(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x14(%rsi),%xmm2
movd   -0x94(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x114(%rsi),%xmm2
ff
movd   -0x194(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x10(%rsi),%xmm2
movd   -0x90(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x110(%rsi),%xmm6
ff
movd   -0x190(%rsi),%xmm2
ff
punpckldq %xmm6,%xmm2
punpcklqdq %xmm4,%xmm2
pand   %xmm0,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movd   -0xc(%rsi),%xmm3
movd   -0x8c(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x10c(%rsi),%xmm3
ff
movd   -0x18c(%rsi),%xmm5
ff
punpckldq %xmm3,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm2
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   -0x8(%rsi),%xmm3
movd   -0x88(%rsi),%xmm4
ff
punpckldq %xmm3,%xmm4
movd   -0x108(%rsi),%xmm6
ff
movd   -0x188(%rsi),%xmm3
ff
punpckldq %xmm6,%xmm3
punpcklqdq %xmm4,%xmm3
pand   %xmm0,%xmm3
por    %xmm5,%xmm3
por    %xmm2,%xmm3
movd   -0x4(%rsi),%xmm2
movd   -0x84(%rsi),%xmm4
ff
punpckldq %xmm2,%xmm4
movd   -0x104(%rsi),%xmm2
ff
movd   -0x184(%rsi),%xmm5
ff
punpckldq %xmm2,%xmm5
punpcklqdq %xmm4,%xmm5
pslld  $0x2,%xmm3
paddd  %xmm5,%xmm5
pand   %xmm1,%xmm5
movd   (%rsi),%xmm2
movd   -0x80(%rsi),%xmm4
punpckldq %xmm2,%xmm4
movd   -0x100(%rsi),%xmm2
ff
movd   -0x180(%rsi),%xmm6
ff
punpckldq %xmm2,%xmm6
punpcklqdq %xmm4,%xmm6
pand   %xmm0,%xmm6
por    %xmm5,%xmm6
por    %xmm3,%xmm6
movdqu %xmm6,(%rax,%rcx,4)
add    $0x4,%rcx
add    $0x200,%rsi
cmp    %rcx,%rbx
jne    190b <IntegerPacker_32+0x7fb>
cmp    %r14,%rbx
je     1169 <IntegerPacker_32+0x59>
jmp    174e <IntegerPacker_32+0x63e>

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

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