void col221111(int *out, unsigned char *pic, int width, int bits) {
  int i, j, k, k_4, k_3;
  unsigned char *pic0, *pic1;
  int *outy, *outc;
  int cr, cg, cb, y;
  pic0 = pic;
  pic1 = pic + width;
  outy = out;
  outc = out + 64 * 4;
  for (i = 2; i > 0; i--) {
    for (j = 4; j > 0; j--) {
      for (k = 0; k < 8; k++) {
        k_4 = (k >> 2) << 3;
        k_3 = (k & 3) << 1;
        switch (bits) {
        case 8:
          ((cb = outc[0 + k], cr = outc[64 + k],
            cg = (50 * cb + 130 * cr + 128) >> 8),
           (y = outy[(k_4 + 0) * 8 + k_3 + 0],
            pic0[(k * 2 + 0)] = store_8(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                3 * 0x55)),
           (y = outy[(k_4 + 0) * 8 + k_3 + 1],
            pic0[(k * 2 + 1)] = store_8(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                0 * 0x55)),
           (y = outy[(k_4 + 1) * 8 + k_3 + 0],
            pic1[(k * 2 + 0)] = store_8(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                1 * 0x55)),
           (y = outy[(k_4 + 1) * 8 + k_3 + 1],
            pic1[(k * 2 + 1)] = store_8(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                2 * 0x55)));
          break;
        case 16:
          ((cb = outc[0 + k], cr = outc[64 + k],
            cg = (50 * cb + 130 * cr + 128) >> 8),
           (y = outy[(k_4 + 0) * 8 + k_3 + 0],
            *(unsigned short *)(pic0 + (k * 2 + 0) * 2) = store_16(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                3 * 0x55)),
           (y = outy[(k_4 + 0) * 8 + k_3 + 1],
            *(unsigned short *)(pic0 + (k * 2 + 1) * 2) = store_16(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                0 * 0x55)),
           (y = outy[(k_4 + 1) * 8 + k_3 + 0],
            *(unsigned short *)(pic1 + (k * 2 + 0) * 2) = store_16(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                1 * 0x55)),
           (y = outy[(k_4 + 1) * 8 + k_3 + 1],
            *(unsigned short *)(pic1 + (k * 2 + 1) * 2) = store_16(
                ((unsigned int)(y + cr) >= 256 ? ((y + cr) < 0 ? 0 : 255)
                                               : (y + cr)),
                ((unsigned int)(y - cg) >= 256 ? ((y - cg) < 0 ? 0 : 255)
                                               : (y - cg)),
                ((unsigned int)(y + cb) >= 256 ? ((y + cb) < 0 ? 0 : 255)
                                               : (y + cb)),
                2 * 0x55)));
          break;
        case 32:
          ((cb = outc[0 + k], cr = outc[64 + k],
            cg = (50 * cb + 130 * cr + 128) >> 8),
           (y = outy[(k_4 + 0) * 8 + k_3 + 0],
            ((pic0[(k * 2 + 0) * 4 + 0]) = (y + cb),
             (unsigned int)(y + cb) >= 256
                 ? ((pic0[(k * 2 + 0) * 4 + 0]) = (y + cb) < 0 ? 0 : 255)
                 : 0),
            ((pic0[(k * 2 + 0) * 4 + 1]) = (y - cg),
             (unsigned int)(y - cg) >= 256
                 ? ((pic0[(k * 2 + 0) * 4 + 1]) = (y - cg) < 0 ? 0 : 255)
                 : 0),
            ((pic0[(k * 2 + 0) * 4 + 2]) = (y + cr),
             (unsigned int)(y + cr) >= 256
                 ? ((pic0[(k * 2 + 0) * 4 + 2]) = (y + cr) < 0 ? 0 : 255)
                 : 0)),
           (y = outy[(k_4 + 0) * 8 + k_3 + 1],
            ((pic0[(k * 2 + 1) * 4 + 0]) = (y + cb),
             (unsigned int)(y + cb) >= 256
                 ? ((pic0[(k * 2 + 1) * 4 + 0]) = (y + cb) < 0 ? 0 : 255)
                 : 0),
            ((pic0[(k * 2 + 1) * 4 + 1]) = (y - cg),
             (unsigned int)(y - cg) >= 256
                 ? ((pic0[(k * 2 + 1) * 4 + 1]) = (y - cg) < 0 ? 0 : 255)
                 : 0),
            ((pic0[(k * 2 + 1) * 4 + 2]) = (y + cr),
             (unsigned int)(y + cr) >= 256
                 ? ((pic0[(k * 2 + 1) * 4 + 2]) = (y + cr) < 0 ? 0 : 255)
                 : 0)),
           (y = outy[(k_4 + 1) * 8 + k_3 + 0],
            ((pic1[(k * 2 + 0) * 4 + 0]) = (y + cb),
             (unsigned int)(y + cb) >= 256
                 ? ((pic1[(k * 2 + 0) * 4 + 0]) = (y + cb) < 0 ? 0 : 255)
                 : 0),
            ((pic1[(k * 2 + 0) * 4 + 1]) = (y - cg),
             (unsigned int)(y - cg) >= 256
                 ? ((pic1[(k * 2 + 0) * 4 + 1]) = (y - cg) < 0 ? 0 : 255)
                 : 0),
            ((pic1[(k * 2 + 0) * 4 + 2]) = (y + cr),
             (unsigned int)(y + cr) >= 256
                 ? ((pic1[(k * 2 + 0) * 4 + 2]) = (y + cr) < 0 ? 0 : 255)
                 : 0)),
           (y = outy[(k_4 + 1) * 8 + k_3 + 1],
            ((pic1[(k * 2 + 1) * 4 + 0]) = (y + cb),
             (unsigned int)(y + cb) >= 256
                 ? ((pic1[(k * 2 + 1) * 4 + 0]) = (y + cb) < 0 ? 0 : 255)
                 : 0),
            ((pic1[(k * 2 + 1) * 4 + 1]) = (y - cg),
             (unsigned int)(y - cg) >= 256
                 ? ((pic1[(k * 2 + 1) * 4 + 1]) = (y - cg) < 0 ? 0 : 255)
                 : 0),
            ((pic1[(k * 2 + 1) * 4 + 2]) = (y + cr),
             (unsigned int)(y + cr) >= 256
                 ? ((pic1[(k * 2 + 1) * 4 + 2]) = (y + cr) < 0 ? 0 : 255)
                 : 0)));
          break;
        }
      }
      outc += 8;
      outy += 16;
      pic0 += 2 * width;
      pic1 += 2 * width;
    }
    outy += 64 * 2 - 16 * 4;
  }
}


x86 assembly (clang, -O0):
<col221111>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
add    $0x400,%rax
mov    %rax,-0x50(%rbp)
movl   $0x2,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    2132 <col221111+0x1012>
movl   $0x4,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    2116 <col221111+0xff6>
movl   $0x0,-0x24(%rbp)
cmpl   $0x8,-0x24(%rbp)
jge    20c8 <col221111+0xfa8>
mov    -0x24(%rbp),%eax
add    %eax,%eax
and    $0xfffffff8,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
and    $0x3,%eax
add    %eax,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x64(%rbp)
sub    $0x8,%eax
je     11e5 <col221111+0xc5>
jmp    11c3 <col221111+0xa3>
mov    -0x64(%rbp),%eax
sub    $0x10,%eax
je     164f <col221111+0x52f>
jmp    11d4 <col221111+0xb4>
mov    -0x64(%rbp),%eax
sub    $0x20,%eax
je     1b03 <col221111+0x9e3>
jmp    20b5 <col221111+0xf95>
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
imul   $0x32,-0x5c(%rbp),%eax
imul   $0x82,-0x54(%rbp),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     126b <col221111+0x14b>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x68(%rbp)
jmp    1274 <col221111+0x154>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     12a6 <col221111+0x186>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x70(%rbp)
jmp    12af <col221111+0x18f>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     12e1 <col221111+0x1c1>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x78(%rbp)
jmp    12ea <col221111+0x1ca>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x74(%rbp),%esi
mov    -0x6c(%rbp),%edi
mov    -0x78(%rbp),%edx
mov    $0xff,%ecx
mov    $0x0,%al
call   1040 <store_8@plt>
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     135c <col221111+0x23c>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x7c(%rbp)
jmp    1365 <col221111+0x245>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     139a <col221111+0x27a>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x84(%rbp)
jmp    13a6 <col221111+0x286>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     13e1 <col221111+0x2c1>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x8c(%rbp)
jmp    13ed <col221111+0x2cd>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x88(%rbp),%esi
mov    -0x80(%rbp),%edi
mov    -0x8c(%rbp),%edx
xor    %ecx,%ecx
mov    $0x0,%al
call   1040 <store_8@plt>
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     1465 <col221111+0x345>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x90(%rbp)
jmp    1471 <col221111+0x351>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     14ac <col221111+0x38c>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x98(%rbp)
jmp    14b8 <col221111+0x398>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     14f3 <col221111+0x3d3>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xa0(%rbp)
jmp    14ff <col221111+0x3df>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x9c(%rbp),%esi
mov    -0x94(%rbp),%edi
mov    -0xa0(%rbp),%edx
mov    $0x55,%ecx
mov    $0x0,%al
call   1040 <store_8@plt>
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     157d <col221111+0x45d>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xa4(%rbp)
jmp    1589 <col221111+0x469>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     15c4 <col221111+0x4a4>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xac(%rbp)
jmp    15d0 <col221111+0x4b0>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     160b <col221111+0x4eb>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xb4(%rbp)
jmp    1617 <col221111+0x4f7>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb0(%rbp),%esi
mov    -0xa8(%rbp),%edi
mov    -0xb4(%rbp),%edx
mov    $0xaa,%ecx
mov    $0x0,%al
call   1040 <store_8@plt>
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    20b5 <col221111+0xf95>
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
imul   $0x32,-0x5c(%rbp),%eax
imul   $0x82,-0x54(%rbp),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     16d8 <col221111+0x5b8>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xb8(%rbp)
jmp    16e4 <col221111+0x5c4>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     171f <col221111+0x5ff>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xc0(%rbp)
jmp    172b <col221111+0x60b>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1766 <col221111+0x646>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xc8(%rbp)
jmp    1772 <col221111+0x652>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc4(%rbp),%esi
mov    -0xbc(%rbp),%edi
mov    -0xc8(%rbp),%edx
mov    $0xff,%ecx
mov    $0x0,%al
call   1030 <store_16@plt>
mov    %ax,%dx
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     17f5 <col221111+0x6d5>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xcc(%rbp)
jmp    1801 <col221111+0x6e1>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     183c <col221111+0x71c>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xd4(%rbp)
jmp    1848 <col221111+0x728>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1883 <col221111+0x763>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xdc(%rbp)
jmp    188f <col221111+0x76f>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xd8(%rbp),%esi
mov    -0xd0(%rbp),%edi
mov    -0xdc(%rbp),%edx
xor    %ecx,%ecx
mov    $0x0,%al
call   1030 <store_16@plt>
mov    %ax,%dx
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     190f <col221111+0x7ef>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xe0(%rbp)
jmp    191b <col221111+0x7fb>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     1956 <col221111+0x836>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xe8(%rbp)
jmp    1962 <col221111+0x842>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     199d <col221111+0x87d>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xf0(%rbp)
jmp    19a9 <col221111+0x889>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0xec(%rbp),%esi
mov    -0xe4(%rbp),%edi
mov    -0xf0(%rbp),%edx
mov    $0x55,%ecx
mov    $0x0,%al
call   1030 <store_16@plt>
mov    %ax,%dx
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     1a2c <col221111+0x90c>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xf4(%rbp)
jmp    1a38 <col221111+0x918>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     1a73 <col221111+0x953>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0xfc(%rbp)
jmp    1a7f <col221111+0x95f>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1aba <col221111+0x99a>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x104(%rbp)
jmp    1ac6 <col221111+0x9a6>
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x100(%rbp),%esi
mov    -0xf8(%rbp),%edi
mov    -0x104(%rbp),%edx
mov    $0xaa,%ecx
mov    $0x0,%al
call   1030 <store_16@plt>
mov    %ax,%dx
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,1)
jmp    20b5 <col221111+0xf95>
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
imul   $0x32,-0x5c(%rbp),%eax
imul   $0x82,-0x54(%rbp),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1bc3 <col221111+0xaa3>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
shl    $0x2,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1bc8 <col221111+0xaa8>
jmp    1bc8 <col221111+0xaa8>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     1c2e <col221111+0xb0e>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
shl    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1c33 <col221111+0xb13>
jmp    1c33 <col221111+0xb13>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     1c99 <col221111+0xb79>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
shl    $0x2,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1c9e <col221111+0xb7e>
jmp    1c9e <col221111+0xb7e>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1d20 <col221111+0xc00>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
shl    $0x2,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1d25 <col221111+0xc05>
jmp    1d25 <col221111+0xc05>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     1d8b <col221111+0xc6b>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
shl    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1d90 <col221111+0xc70>
jmp    1d90 <col221111+0xc70>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     1df6 <col221111+0xcd6>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
shl    $0x2,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1dfb <col221111+0xcdb>
jmp    1dfb <col221111+0xcdb>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1e7d <col221111+0xd5d>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
shl    $0x2,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1e82 <col221111+0xd62>
jmp    1e82 <col221111+0xd62>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     1ee8 <col221111+0xdc8>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
shl    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1eed <col221111+0xdcd>
jmp    1eed <col221111+0xdcd>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     1f53 <col221111+0xe33>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
shl    $0x2,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1f58 <col221111+0xe38>
jmp    1f58 <col221111+0xe38>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
cmp    $0x100,%eax
jb     1fda <col221111+0xeba>
mov    -0x60(%rbp),%edx
add    -0x5c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
shl    $0x2,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1fdf <col221111+0xebf>
jmp    1fdf <col221111+0xebf>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x100,%eax
jb     2045 <col221111+0xf25>
mov    -0x60(%rbp),%edx
sub    -0x58(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
shl    $0x2,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    204a <col221111+0xf2a>
jmp    204a <col221111+0xf2a>
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    -0x54(%rbp),%eax
cmp    $0x100,%eax
jb     20b0 <col221111+0xf90>
mov    -0x60(%rbp),%edx
add    -0x54(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
shl    $0x2,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    20b5 <col221111+0xf95>
jmp    20b5 <col221111+0xf95>
jmp    20ba <col221111+0xf9a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    118f <col221111+0x6f>
mov    -0x50(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    117e <col221111+0x5e>
mov    -0x48(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    116d <col221111+0x4d>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<col221111>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
movslq %edx,%rax
mov    %rsi,0x8(%rsp)
lea    (%rsi,%rax,1),%rdx
mov    %rdx,(%rsp)
lea    0x400(%rdi),%rdx
mov    %rdx,0x18(%rsp)
add    %eax,%eax
cltq
mov    %rax,0x28(%rsp)
mov    $0x2,%eax
xor    %r11d,%r11d
mov    %ecx,0x14(%rsp)
jmp    118b <col221111+0x6b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x140,%r12
mov    0x20(%rsp),%rdx
lea    -0x1(%rdx),%eax
mov    %r12,%rdi
cmp    $0x1,%edx
jbe    1724 <col221111+0x604>
mov    %rax,0x20(%rsp)
mov    $0x4,%eax
jmp    11c6 <col221111+0xa6>
nopw   0x0(%rax,%rax,1)
addq   $0x20,0x18(%rsp)
lea    0x40(%r12),%rdi
mov    0x28(%rsp),%rax
add    %rax,0x8(%rsp)
add    %rax,(%rsp)
mov    0x30(%rsp),%rdx
lea    -0x1(%rdx),%eax
cmp    $0x1,%edx
jbe    1170 <col221111+0x50>
mov    %rax,0x30(%rsp)
mov    %rdi,%r12
xor    %r14d,%r14d
jmp    1209 <col221111+0xe9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%edi
mov    $0xaa,%ecx
xor    %eax,%eax
call   1030 <store_16@plt>
mov    (%rsp),%rcx
mov    %ax,0x2(%rcx,%r14,2)
mov    0x14(%rsp),%ecx
xor    %r11d,%r11d
add    $0x2,%r14
cmp    $0x10,%r14
je     11a0 <col221111+0x80>
mov    %r14d,%esi
and    $0x7ffffff8,%esi
mov    %r14d,%edi
and    $0x6,%edi
cmp    $0x20,%ecx
je     1570 <col221111+0x450>
cmp    $0x10,%ecx
je     13e0 <col221111+0x2c0>
cmp    $0x8,%ecx
jne    11ff <col221111+0xdf>
mov    0x18(%rsp),%rax
mov    (%rax,%r14,2),%r15d
mov    0x100(%rax,%r14,2),%ebp
imul   $0x32,%r15d,%eax
mov    %ebp,%ecx
shl    $0x7,%ecx
lea    (%rcx,%rbp,2),%ecx
lea    (%rax,%rcx,1),%r13d
add    $0x80,%r13d
sar    $0x8,%r13d
lea    (%rdi,%rsi,8),%ebx
mov    (%r12,%rbx,4),%edx
mov    %edx,%edi
add    %ebp,%edi
cmovs  %r11d,%edi
cmp    $0xff,%edi
mov    $0xff,%eax
cmovae %eax,%edi
mov    %edx,%esi
sub    %r13d,%esi
cmovs  %r11d,%esi
cmp    $0xff,%esi
jb     128e <col221111+0x16e>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %r11d,%edx
cmp    $0xff,%edx
cmovae %eax,%edx
mov    $0xff,%ecx
xor    %eax,%eax
call   1040 <store_8@plt>
xor    %r8d,%r8d
mov    0x8(%rsp),%rcx
mov    %al,(%rcx,%r14,1)
mov    %ebx,%eax
or     $0x1,%eax
mov    (%r12,%rax,4),%edx
mov    %edx,%edi
add    %ebp,%edi
cmovs  %r8d,%edi
cmp    $0xff,%edi
jb     12d4 <col221111+0x1b4>
mov    $0xff,%edi
mov    %edx,%esi
sub    %r13d,%esi
cmovs  %r8d,%esi
cmp    $0xff,%esi
jb     12ea <col221111+0x1ca>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %r8d,%edx
cmp    $0xff,%edx
jb     12fe <col221111+0x1de>
mov    $0xff,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1040 <store_8@plt>
mov    0x8(%rsp),%rcx
mov    %al,0x1(%rcx,%r14,1)
mov    %ebx,%eax
or     $0x8,%eax
mov    (%r12,%rax,4),%edx
mov    %edx,%edi
add    %ebp,%edi
mov    $0x0,%eax
cmovs  %eax,%edi
cmp    $0xff,%edi
mov    $0x0,%eax
jb     1338 <col221111+0x218>
mov    $0xff,%edi
mov    %edx,%esi
sub    %r13d,%esi
cmovs  %eax,%esi
cmp    $0xff,%esi
jb     134d <col221111+0x22d>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %eax,%edx
cmp    $0xff,%edx
jb     1360 <col221111+0x240>
mov    $0xff,%edx
mov    $0x55,%ecx
xor    %eax,%eax
call   1040 <store_8@plt>
mov    (%rsp),%rcx
mov    %al,(%rcx,%r14,1)
or     $0x9,%ebx
mov    (%r12,%rbx,4),%edx
add    %edx,%ebp
mov    $0x0,%eax
cmovs  %eax,%ebp
cmp    $0xff,%ebp
mov    $0x0,%eax
jb     1397 <col221111+0x277>
mov    $0xff,%ebp
mov    %edx,%esi
sub    %r13d,%esi
cmovs  %eax,%esi
cmp    $0xff,%esi
jb     13ac <col221111+0x28c>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %eax,%edx
cmp    $0xff,%edx
jb     13bf <col221111+0x29f>
mov    $0xff,%edx
mov    %ebp,%edi
mov    $0xaa,%ecx
xor    %eax,%eax
call   1040 <store_8@plt>
mov    (%rsp),%rcx
mov    %al,0x1(%rcx,%r14,1)
jmp    11f8 <col221111+0xd8>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
mov    (%rax,%r14,2),%r15d
mov    0x100(%rax,%r14,2),%ebp
imul   $0x32,%r15d,%eax
mov    %ebp,%ecx
shl    $0x7,%ecx
lea    (%rcx,%rbp,2),%ecx
lea    (%rax,%rcx,1),%ebx
add    $0x80,%ebx
sar    $0x8,%ebx
lea    (%rdi,%rsi,8),%r13d
mov    (%r12,%r13,4),%edx
mov    %edx,%edi
add    %ebp,%edi
cmovs  %r11d,%edi
cmp    $0xff,%edi
mov    $0xff,%eax
cmovae %eax,%edi
mov    %edx,%esi
sub    %ebx,%esi
cmovs  %r11d,%esi
cmp    $0xff,%esi
jb     143c <col221111+0x31c>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %r11d,%edx
cmp    $0xff,%edx
cmovae %eax,%edx
mov    $0xff,%ecx
xor    %eax,%eax
call   1030 <store_16@plt>
xor    %r8d,%r8d
mov    0x8(%rsp),%rcx
mov    %ax,(%rcx,%r14,2)
mov    %r13d,%eax
or     $0x1,%eax
mov    (%r12,%rax,4),%edx
mov    %edx,%edi
add    %ebp,%edi
cmovs  %r8d,%edi
cmp    $0xff,%edi
jb     1484 <col221111+0x364>
mov    $0xff,%edi
mov    %edx,%esi
sub    %ebx,%esi
cmovs  %r8d,%esi
cmp    $0xff,%esi
jb     1499 <col221111+0x379>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %r8d,%edx
cmp    $0xff,%edx
jb     14ad <col221111+0x38d>
mov    $0xff,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1030 <store_16@plt>
mov    0x8(%rsp),%rcx
mov    %ax,0x2(%rcx,%r14,2)
mov    %r13d,%eax
or     $0x8,%eax
mov    (%r12,%rax,4),%edx
mov    %edx,%edi
add    %ebp,%edi
mov    $0x0,%eax
cmovs  %eax,%edi
cmp    $0xff,%edi
jb     14e4 <col221111+0x3c4>
mov    $0xff,%edi
mov    %edx,%esi
sub    %ebx,%esi
cmovs  %eax,%esi
cmp    $0xff,%esi
jb     14f8 <col221111+0x3d8>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %eax,%edx
cmp    $0xff,%edx
jb     150b <col221111+0x3eb>
mov    $0xff,%edx
mov    $0x55,%ecx
xor    %eax,%eax
call   1030 <store_16@plt>
mov    (%rsp),%rcx
mov    %ax,(%rcx,%r14,2)
or     $0x9,%r13d
mov    (%r12,%r13,4),%edx
add    %edx,%ebp
mov    $0x0,%eax
cmovs  %eax,%ebp
cmp    $0xff,%ebp
jb     153f <col221111+0x41f>
mov    $0xff,%ebp
mov    %edx,%esi
sub    %ebx,%esi
cmovs  %eax,%esi
cmp    $0xff,%esi
jb     1553 <col221111+0x433>
mov    $0xff,%esi
add    %r15d,%edx
cmovs  %eax,%edx
cmp    $0xff,%edx
jb     11e0 <col221111+0xc0>
mov    $0xff,%edx
jmp    11e0 <col221111+0xc0>
nop
mov    0x18(%rsp),%rax
mov    (%rax,%r14,2),%r10d
mov    0x100(%rax,%r14,2),%r8d
imul   $0x32,%r10d,%edx
mov    %r8d,%eax
shl    $0x7,%eax
lea    (%rax,%r8,2),%eax
lea    (%rdx,%rax,1),%r9d
add    $0x80,%r9d
sar    $0x8,%r9d
lea    (%rdi,%rsi,8),%esi
mov    (%r12,%rsi,4),%edi
lea    (%rdi,%r10,1),%ebx
mov    %ebx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ebx
not    %al
movzbl %al,%eax
cmovb  %ebx,%eax
mov    0x8(%rsp),%rdx
mov    %al,(%rdx,%r14,4)
mov    %edi,%ebx
sub    %r9d,%ebx
mov    %ebx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ebx
not    %al
movzbl %al,%eax
cmovb  %ebx,%eax
mov    %al,0x1(%rdx,%r14,4)
add    %r8d,%edi
mov    %edi,%eax
sar    $0x1f,%eax
cmp    $0x100,%edi
not    %al
movzbl %al,%eax
cmovb  %edi,%eax
mov    %al,0x2(%rdx,%r14,4)
mov    %esi,%eax
or     $0x1,%eax
mov    (%r12,%rax,4),%edi
lea    (%rdi,%r10,1),%ebx
mov    %ebx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ebx
not    %al
movzbl %al,%eax
cmovb  %ebx,%eax
mov    %al,0x4(%rdx,%r14,4)
mov    %edi,%ebx
sub    %r9d,%ebx
mov    %ebx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ebx
not    %al
movzbl %al,%eax
cmovb  %ebx,%eax
mov    %al,0x5(%rdx,%r14,4)
add    %r8d,%edi
mov    %edi,%eax
sar    $0x1f,%eax
cmp    $0x100,%edi
not    %al
movzbl %al,%eax
cmovb  %edi,%eax
mov    %al,0x6(%rdx,%r14,4)
mov    %esi,%eax
or     $0x8,%eax
mov    (%r12,%rax,4),%edi
lea    (%rdi,%r10,1),%ebx
mov    %ebx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ebx
not    %al
movzbl %al,%eax
cmovb  %ebx,%eax
mov    (%rsp),%rbp
mov    %al,0x0(%rbp,%r14,4)
mov    %edi,%ebx
sub    %r9d,%ebx
mov    %ebx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ebx
not    %al
movzbl %al,%eax
cmovb  %ebx,%eax
mov    %al,0x1(%rbp,%r14,4)
add    %r8d,%edi
mov    %edi,%eax
sar    $0x1f,%eax
cmp    $0x100,%edi
not    %al
movzbl %al,%eax
cmovb  %edi,%eax
mov    %al,0x2(%rbp,%r14,4)
or     $0x9,%esi
mov    (%r12,%rsi,4),%esi
add    %esi,%r10d
mov    %r10d,%eax
sar    $0x1f,%eax
cmp    $0x100,%r10d
not    %al
movzbl %al,%eax
cmovb  %r10d,%eax
mov    %al,0x4(%rbp,%r14,4)
mov    %esi,%eax
sub    %r9d,%eax
mov    %eax,%edx
sar    $0x1f,%edx
cmp    $0x100,%eax
not    %dl
movzbl %dl,%edx
cmovb  %eax,%edx
mov    %dl,0x5(%rbp,%r14,4)
add    %r8d,%esi
mov    %sil,0x6(%rbp,%r14,4)
cmp    $0x100,%esi
jb     11ff <col221111+0xdf>
sar    $0x1f,%esi
not    %sil
mov    (%rsp),%rax
mov    %sil,0x6(%rax,%r14,4)
jmp    11ff <col221111+0xdf>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @col221111(i32* nocapture %0, i8* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = sext i32 %2 to i64
%6 = getelementptr inbounds i8, i8* %1, i64 %5
%7 = getelementptr inbounds i32, i32* %0, i64 256
%8 = shl nsw i32 %2, 1
%9 = sext i32 %8 to i64
br label %10
10: ; preds = %4, %375
%11 = phi i32* [ %7, %4 ], [ %369, %375 ]
%12 = phi i32* [ %0, %4 ], [ %376, %375 ]
%13 = phi i8* [ %6, %4 ], [ %372, %375 ]
%14 = phi i8* [ %1, %4 ], [ %371, %375 ]
%15 = phi i32 [ 2, %4 ], [ %377, %375 ]
br label %16
16: ; preds = %10, %368
%17 = phi i32* [ %11, %10 ], [ %369, %368 ]
%18 = phi i32* [ %12, %10 ], [ %370, %368 ]
%19 = phi i8* [ %13, %10 ], [ %372, %368 ]
%20 = phi i8* [ %14, %10 ], [ %371, %368 ]
%21 = phi i32 [ 4, %10 ], [ %373, %368 ]
br label %22
22: ; preds = %16, %365
%23 = phi i64 [ 0, %16 ], [ %366, %365 ]
%24 = shl nuw nsw i64 %23, 1
%25 = trunc i64 %24 to i32
%26 = and i32 %25, 2147483640
%27 = and i32 %25, 6
switch i32 %3, label %365 [
i32 8, label %28
i32 16, label %129
i32 32, label %235
]
28: ; preds = %22
%29 = getelementptr inbounds i32, i32* %17, i64 %23
%30 = load i32, i32* %29
%31 = add nuw nsw i64 %23, 64
%32 = getelementptr inbounds i32, i32* %17, i64 %31
%33 = load i32, i32* %32
%34 = mul nsw i32 %30, 50
%35 = mul nsw i32 %33, 130
%36 = add i32 %34, 128
%37 = add i32 %36, %35
%38 = ashr i32 %37, 8
%39 = shl nuw nsw i32 %26, 3
%40 = or i32 %39, %27
%41 = zext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %18, i64 %41
%43 = load i32, i32* %42
%44 = add nsw i32 %43, %33
%45 = icmp sgt i32 %44, 0
%46 = select i1 %45, i32 %44, i32 0
%47 = icmp ult i32 %46, 255
%48 = select i1 %47, i32 %46, i32 255
%49 = sub nsw i32 %43, %38
%50 = icmp sgt i32 %49, 0
%51 = select i1 %50, i32 %49, i32 0
%52 = icmp ult i32 %51, 255
%53 = select i1 %52, i32 %51, i32 255
%54 = add nsw i32 %43, %30
%55 = icmp sgt i32 %54, 0
%56 = select i1 %55, i32 %54, i32 0
%57 = icmp ult i32 %56, 255
%58 = select i1 %57, i32 %56, i32 255
%59 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_8 to i32 (i32, i32, i32, i32, ...)*)(i32 %48, i32 %53, i32 %58, i32 255)
%60 = trunc i32 %59 to i8
%61 = getelementptr inbounds i8, i8* %20, i64 %24
store i8 %60, i8* %61
%62 = or i32 %40, 1
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %18, i64 %63
%65 = load i32, i32* %64
%66 = add nsw i32 %65, %33
%67 = icmp sgt i32 %66, 0
%68 = select i1 %67, i32 %66, i32 0
%69 = icmp ult i32 %68, 255
%70 = select i1 %69, i32 %68, i32 255
%71 = sub nsw i32 %65, %38
%72 = icmp sgt i32 %71, 0
%73 = select i1 %72, i32 %71, i32 0
%74 = icmp ult i32 %73, 255
%75 = select i1 %74, i32 %73, i32 255
%76 = add nsw i32 %65, %30
%77 = icmp sgt i32 %76, 0
%78 = select i1 %77, i32 %76, i32 0
%79 = icmp ult i32 %78, 255
%80 = select i1 %79, i32 %78, i32 255
%81 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_8 to i32 (i32, i32, i32, i32, ...)*)(i32 %70, i32 %75, i32 %80, i32 0)
%82 = trunc i32 %81 to i8
%83 = or i64 %24, 1
%84 = getelementptr inbounds i8, i8* %20, i64 %83
store i8 %82, i8* %84
%85 = or i32 %40, 8
%86 = zext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %18, i64 %86
%88 = load i32, i32* %87
%89 = add nsw i32 %88, %33
%90 = icmp sgt i32 %89, 0
%91 = select i1 %90, i32 %89, i32 0
%92 = icmp ult i32 %91, 255
%93 = select i1 %92, i32 %91, i32 255
%94 = sub nsw i32 %88, %38
%95 = icmp sgt i32 %94, 0
%96 = select i1 %95, i32 %94, i32 0
%97 = icmp ult i32 %96, 255
%98 = select i1 %97, i32 %96, i32 255
%99 = add nsw i32 %88, %30
%100 = icmp sgt i32 %99, 0
%101 = select i1 %100, i32 %99, i32 0
%102 = icmp ult i32 %101, 255
%103 = select i1 %102, i32 %101, i32 255
%104 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_8 to i32 (i32, i32, i32, i32, ...)*)(i32 %93, i32 %98, i32 %103, i32 85)
%105 = trunc i32 %104 to i8
%106 = getelementptr inbounds i8, i8* %19, i64 %24
store i8 %105, i8* %106
%107 = or i32 %40, 9
%108 = zext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %18, i64 %108
%110 = load i32, i32* %109
%111 = add nsw i32 %110, %33
%112 = icmp sgt i32 %111, 0
%113 = select i1 %112, i32 %111, i32 0
%114 = icmp ult i32 %113, 255
%115 = select i1 %114, i32 %113, i32 255
%116 = sub nsw i32 %110, %38
%117 = icmp sgt i32 %116, 0
%118 = select i1 %117, i32 %116, i32 0
%119 = icmp ult i32 %118, 255
%120 = select i1 %119, i32 %118, i32 255
%121 = add nsw i32 %110, %30
%122 = icmp sgt i32 %121, 0
%123 = select i1 %122, i32 %121, i32 0
%124 = icmp ult i32 %123, 255
%125 = select i1 %124, i32 %123, i32 255
%126 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_8 to i32 (i32, i32, i32, i32, ...)*)(i32 %115, i32 %120, i32 %125, i32 170)
%127 = trunc i32 %126 to i8
%128 = getelementptr inbounds i8, i8* %19, i64 %83
store i8 %127, i8* %128
br label %365
129: ; preds = %22
%130 = getelementptr inbounds i32, i32* %17, i64 %23
%131 = load i32, i32* %130
%132 = add nuw nsw i64 %23, 64
%133 = getelementptr inbounds i32, i32* %17, i64 %132
%134 = load i32, i32* %133
%135 = mul nsw i32 %131, 50
%136 = mul nsw i32 %134, 130
%137 = add i32 %135, 128
%138 = add i32 %137, %136
%139 = ashr i32 %138, 8
%140 = shl nuw nsw i32 %26, 3
%141 = or i32 %140, %27
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %18, i64 %142
%144 = load i32, i32* %143
%145 = add nsw i32 %144, %134
%146 = icmp sgt i32 %145, 0
%147 = select i1 %146, i32 %145, i32 0
%148 = icmp ult i32 %147, 255
%149 = select i1 %148, i32 %147, i32 255
%150 = sub nsw i32 %144, %139
%151 = icmp sgt i32 %150, 0
%152 = select i1 %151, i32 %150, i32 0
%153 = icmp ult i32 %152, 255
%154 = select i1 %153, i32 %152, i32 255
%155 = add nsw i32 %144, %131
%156 = icmp sgt i32 %155, 0
%157 = select i1 %156, i32 %155, i32 0
%158 = icmp ult i32 %157, 255
%159 = select i1 %158, i32 %157, i32 255
%160 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_16 to i32 (i32, i32, i32, i32, ...)*)(i32 %149, i32 %154, i32 %159, i32 255)
%161 = trunc i32 %160 to i16
%162 = shl nuw nsw i64 %23, 2
%163 = getelementptr inbounds i8, i8* %20, i64 %162
%164 = bitcast i8* %163 to i16*
store i16 %161, i16* %164
%165 = or i32 %141, 1
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %18, i64 %166
%168 = load i32, i32* %167
%169 = add nsw i32 %168, %134
%170 = icmp sgt i32 %169, 0
%171 = select i1 %170, i32 %169, i32 0
%172 = icmp ult i32 %171, 255
%173 = select i1 %172, i32 %171, i32 255
%174 = sub nsw i32 %168, %139
%175 = icmp sgt i32 %174, 0
%176 = select i1 %175, i32 %174, i32 0
%177 = icmp ult i32 %176, 255
%178 = select i1 %177, i32 %176, i32 255
%179 = add nsw i32 %168, %131
%180 = icmp sgt i32 %179, 0
%181 = select i1 %180, i32 %179, i32 0
%182 = icmp ult i32 %181, 255
%183 = select i1 %182, i32 %181, i32 255
%184 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_16 to i32 (i32, i32, i32, i32, ...)*)(i32 %173, i32 %178, i32 %183, i32 0)
%185 = trunc i32 %184 to i16
%186 = or i64 %162, 2
%187 = getelementptr inbounds i8, i8* %20, i64 %186
%188 = bitcast i8* %187 to i16*
store i16 %185, i16* %188
%189 = or i32 %141, 8
%190 = zext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %18, i64 %190
%192 = load i32, i32* %191
%193 = add nsw i32 %192, %134
%194 = icmp sgt i32 %193, 0
%195 = select i1 %194, i32 %193, i32 0
%196 = icmp ult i32 %195, 255
%197 = select i1 %196, i32 %195, i32 255
%198 = sub nsw i32 %192, %139
%199 = icmp sgt i32 %198, 0
%200 = select i1 %199, i32 %198, i32 0
%201 = icmp ult i32 %200, 255
%202 = select i1 %201, i32 %200, i32 255
%203 = add nsw i32 %192, %131
%204 = icmp sgt i32 %203, 0
%205 = select i1 %204, i32 %203, i32 0
%206 = icmp ult i32 %205, 255
%207 = select i1 %206, i32 %205, i32 255
%208 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_16 to i32 (i32, i32, i32, i32, ...)*)(i32 %197, i32 %202, i32 %207, i32 85)
%209 = trunc i32 %208 to i16
%210 = getelementptr inbounds i8, i8* %19, i64 %162
%211 = bitcast i8* %210 to i16*
store i16 %209, i16* %211
%212 = or i32 %141, 9
%213 = zext i32 %212 to i64
%214 = getelementptr inbounds i32, i32* %18, i64 %213
%215 = load i32, i32* %214
%216 = add nsw i32 %215, %134
%217 = icmp sgt i32 %216, 0
%218 = select i1 %217, i32 %216, i32 0
%219 = icmp ult i32 %218, 255
%220 = select i1 %219, i32 %218, i32 255
%221 = sub nsw i32 %215, %139
%222 = icmp sgt i32 %221, 0
%223 = select i1 %222, i32 %221, i32 0
%224 = icmp ult i32 %223, 255
%225 = select i1 %224, i32 %223, i32 255
%226 = add nsw i32 %215, %131
%227 = icmp sgt i32 %226, 0
%228 = select i1 %227, i32 %226, i32 0
%229 = icmp ult i32 %228, 255
%230 = select i1 %229, i32 %228, i32 255
%231 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @store_16 to i32 (i32, i32, i32, i32, ...)*)(i32 %220, i32 %225, i32 %230, i32 170)
%232 = trunc i32 %231 to i16
%233 = getelementptr inbounds i8, i8* %19, i64 %186
%234 = bitcast i8* %233 to i16*
store i16 %232, i16* %234
br label %365
235: ; preds = %22
%236 = getelementptr inbounds i32, i32* %17, i64 %23
%237 = load i32, i32* %236
%238 = add nuw nsw i64 %23, 64
%239 = getelementptr inbounds i32, i32* %17, i64 %238
%240 = load i32, i32* %239
%241 = mul nsw i32 %237, 50
%242 = mul nsw i32 %240, 130
%243 = add i32 %241, 128
%244 = add i32 %243, %242
%245 = ashr i32 %244, 8
%246 = shl nuw nsw i32 %26, 3
%247 = or i32 %246, %27
%248 = zext i32 %247 to i64
%249 = getelementptr inbounds i32, i32* %18, i64 %248
%250 = load i32, i32* %249
%251 = add nsw i32 %250, %237
%252 = trunc i32 %251 to i8
%253 = shl nuw nsw i64 %23, 3
%254 = getelementptr inbounds i8, i8* %20, i64 %253
%255 = icmp ugt i32 %251, 255
%256 = ashr i32 %251, 31
%257 = trunc i32 %256 to i8
%258 = xor i8 %257, -1
%259 = select i1 %255, i8 %258, i8 %252
store i8 %259, i8* %254
%260 = sub nsw i32 %250, %245
%261 = trunc i32 %260 to i8
%262 = or i64 %253, 1
%263 = getelementptr inbounds i8, i8* %20, i64 %262
%264 = icmp ugt i32 %260, 255
%265 = ashr i32 %260, 31
%266 = trunc i32 %265 to i8
%267 = xor i8 %266, -1
%268 = select i1 %264, i8 %267, i8 %261
store i8 %268, i8* %263
%269 = add nsw i32 %250, %240
%270 = trunc i32 %269 to i8
%271 = or i64 %253, 2
%272 = getelementptr inbounds i8, i8* %20, i64 %271
%273 = icmp ugt i32 %269, 255
%274 = ashr i32 %269, 31
%275 = trunc i32 %274 to i8
%276 = xor i8 %275, -1
%277 = select i1 %273, i8 %276, i8 %270
store i8 %277, i8* %272
%278 = or i32 %247, 1
%279 = zext i32 %278 to i64
%280 = getelementptr inbounds i32, i32* %18, i64 %279
%281 = load i32, i32* %280
%282 = add nsw i32 %281, %237
%283 = trunc i32 %282 to i8
%284 = or i64 %253, 4
%285 = getelementptr inbounds i8, i8* %20, i64 %284
%286 = icmp ugt i32 %282, 255
%287 = ashr i32 %282, 31
%288 = trunc i32 %287 to i8
%289 = xor i8 %288, -1
%290 = select i1 %286, i8 %289, i8 %283
store i8 %290, i8* %285
%291 = sub nsw i32 %281, %245
%292 = trunc i32 %291 to i8
%293 = or i64 %253, 5
%294 = getelementptr inbounds i8, i8* %20, i64 %293
%295 = icmp ugt i32 %291, 255
%296 = ashr i32 %291, 31
%297 = trunc i32 %296 to i8
%298 = xor i8 %297, -1
%299 = select i1 %295, i8 %298, i8 %292
store i8 %299, i8* %294
%300 = add nsw i32 %281, %240
%301 = trunc i32 %300 to i8
%302 = or i64 %253, 6
%303 = getelementptr inbounds i8, i8* %20, i64 %302
%304 = icmp ugt i32 %300, 255
%305 = ashr i32 %300, 31
%306 = trunc i32 %305 to i8
%307 = xor i8 %306, -1
%308 = select i1 %304, i8 %307, i8 %301
store i8 %308, i8* %303
%309 = or i32 %247, 8
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds i32, i32* %18, i64 %310
%312 = load i32, i32* %311
%313 = add nsw i32 %312, %237
%314 = trunc i32 %313 to i8
%315 = getelementptr inbounds i8, i8* %19, i64 %253
%316 = icmp ugt i32 %313, 255
%317 = ashr i32 %313, 31
%318 = trunc i32 %317 to i8
%319 = xor i8 %318, -1
%320 = select i1 %316, i8 %319, i8 %314
store i8 %320, i8* %315
%321 = sub nsw i32 %312, %245
%322 = trunc i32 %321 to i8
%323 = getelementptr inbounds i8, i8* %19, i64 %262
%324 = icmp ugt i32 %321, 255
%325 = ashr i32 %321, 31
%326 = trunc i32 %325 to i8
%327 = xor i8 %326, -1
%328 = select i1 %324, i8 %327, i8 %322
store i8 %328, i8* %323
%329 = add nsw i32 %312, %240
%330 = trunc i32 %329 to i8
%331 = getelementptr inbounds i8, i8* %19, i64 %271
%332 = icmp ugt i32 %329, 255
%333 = ashr i32 %329, 31
%334 = trunc i32 %333 to i8
%335 = xor i8 %334, -1
%336 = select i1 %332, i8 %335, i8 %330
store i8 %336, i8* %331
%337 = or i32 %247, 9
%338 = zext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %18, i64 %338
%340 = load i32, i32* %339
%341 = add nsw i32 %340, %237
%342 = trunc i32 %341 to i8
%343 = getelementptr inbounds i8, i8* %19, i64 %284
%344 = icmp ugt i32 %341, 255
%345 = ashr i32 %341, 31
%346 = trunc i32 %345 to i8
%347 = xor i8 %346, -1
%348 = select i1 %344, i8 %347, i8 %342
store i8 %348, i8* %343
%349 = sub nsw i32 %340, %245
%350 = trunc i32 %349 to i8
%351 = getelementptr inbounds i8, i8* %19, i64 %293
%352 = icmp ugt i32 %349, 255
%353 = ashr i32 %349, 31
%354 = trunc i32 %353 to i8
%355 = xor i8 %354, -1
%356 = select i1 %352, i8 %355, i8 %350
store i8 %356, i8* %351
%357 = add nsw i32 %340, %240
%358 = trunc i32 %357 to i8
%359 = getelementptr inbounds i8, i8* %19, i64 %302
store i8 %358, i8* %359
%360 = icmp ugt i32 %357, 255
br i1 %360, label %361, label %365
361: ; preds = %235
%362 = ashr i32 %357, 31
%363 = trunc i32 %362 to i8
%364 = xor i8 %363, -1
store i8 %364, i8* %359
br label %365
365: ; preds = %28, %129, %22, %235, %361
%366 = add nuw nsw i64 %23, 1
%367 = icmp eq i64 %366, 8
br i1 %367, label %368, label %22
368: ; preds = %365
%369 = getelementptr inbounds i32, i32* %17, i64 8
%370 = getelementptr inbounds i32, i32* %18, i64 16
%371 = getelementptr inbounds i8, i8* %20, i64 %9
%372 = getelementptr inbounds i8, i8* %19, i64 %9
%373 = add nsw i32 %21, -1
%374 = icmp ugt i32 %21, 1
br i1 %374, label %16, label %375
375: ; preds = %368
%376 = getelementptr inbounds i32, i32* %18, i64 80
%377 = add nsw i32 %15, -1
%378 = icmp ugt i32 %15, 1
br i1 %378, label %10, label %379
379: ; preds = %375
ret void
}