void col221111(int *out, unsigned char *pic, int width) {
  int i, j, k;
  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++)
        ((cb = outc[0 + 0 * 8 + k], cr = outc[64 + 0 * 8 + k],
          cg = (50 * cb + 130 * cr + 128) >> 8),
         (y = outy[(k / 4 * 8 + 0) * 8 + (k & 3) * 2 + 0],
          ((pic0[(k * 2 + 0) * 3 + 0]) = (y + cr),
           (unsigned int)(y + cr) >= 256
               ? ((pic0[(k * 2 + 0) * 3 + 0]) = (y + cr) < 0 ? 0 : 255)
               : 0),
          ((pic0[(k * 2 + 0) * 3 + 1]) = (y - cg),
           (unsigned int)(y - cg) >= 256
               ? ((pic0[(k * 2 + 0) * 3 + 1]) = (y - cg) < 0 ? 0 : 255)
               : 0),
          ((pic0[(k * 2 + 0) * 3 + 2]) = (y + cb),
           (unsigned int)(y + cb) >= 256
               ? ((pic0[(k * 2 + 0) * 3 + 2]) = (y + cb) < 0 ? 0 : 255)
               : 0)),
         (y = outy[(k / 4 * 8 + 0) * 8 + (k & 3) * 2 + 1],
          ((pic0[(k * 2 + 1) * 3 + 0]) = (y + cr),
           (unsigned int)(y + cr) >= 256
               ? ((pic0[(k * 2 + 1) * 3 + 0]) = (y + cr) < 0 ? 0 : 255)
               : 0),
          ((pic0[(k * 2 + 1) * 3 + 1]) = (y - cg),
           (unsigned int)(y - cg) >= 256
               ? ((pic0[(k * 2 + 1) * 3 + 1]) = (y - cg) < 0 ? 0 : 255)
               : 0),
          ((pic0[(k * 2 + 1) * 3 + 2]) = (y + cb),
           (unsigned int)(y + cb) >= 256
               ? ((pic0[(k * 2 + 1) * 3 + 2]) = (y + cb) < 0 ? 0 : 255)
               : 0)),
         (y = outy[(k / 4 * 8 + 1) * 8 + (k & 3) * 2 + 0],
          ((pic1[(k * 2 + 0) * 3 + 0]) = (y + cr),
           (unsigned int)(y + cr) >= 256
               ? ((pic1[(k * 2 + 0) * 3 + 0]) = (y + cr) < 0 ? 0 : 255)
               : 0),
          ((pic1[(k * 2 + 0) * 3 + 1]) = (y - cg),
           (unsigned int)(y - cg) >= 256
               ? ((pic1[(k * 2 + 0) * 3 + 1]) = (y - cg) < 0 ? 0 : 255)
               : 0),
          ((pic1[(k * 2 + 0) * 3 + 2]) = (y + cb),
           (unsigned int)(y + cb) >= 256
               ? ((pic1[(k * 2 + 0) * 3 + 2]) = (y + cb) < 0 ? 0 : 255)
               : 0)),
         (y = outy[(k / 4 * 8 + 1) * 8 + (k & 3) * 2 + 1],
          ((pic1[(k * 2 + 1) * 3 + 0]) = (y + cr),
           (unsigned int)(y + cr) >= 256
               ? ((pic1[(k * 2 + 1) * 3 + 0]) = (y + cr) < 0 ? 0 : 255)
               : 0),
          ((pic1[(k * 2 + 1) * 3 + 1]) = (y - cg),
           (unsigned int)(y - cg) >= 256
               ? ((pic1[(k * 2 + 1) * 3 + 1]) = (y - cg) < 0 ? 0 : 255)
               : 0),
          ((pic1[(k * 2 + 1) * 3 + 2]) = (y + cb),
           (unsigned int)(y + cb) >= 256
               ? ((pic1[(k * 2 + 1) * 3 + 2]) = (y + cb) < 0 ? 0 : 255)
               : 0)));
      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
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
add    $0x400,%rax
mov    %rax,-0x40(%rbp)
movl   $0x2,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    180d <col221111+0x70d>
movl   $0x4,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    17f1 <col221111+0x6f1>
movl   $0x0,-0x20(%rbp)
cmpl   $0x8,-0x20(%rbp)
jge    17a3 <col221111+0x6a3>
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
imul   $0x32,-0x4c(%rbp),%eax
imul   $0x82,-0x44(%rbp),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x58(%rbp),%rax
shl    $0x3,%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
mov    -0x20(%rbp),%edx
and    $0x3,%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
cmp    $0x100,%eax
jb     124c <col221111+0x14c>
mov    -0x50(%rbp),%edx
add    -0x44(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
imul   $0x3,%edx,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1251 <col221111+0x151>
jmp    1251 <col221111+0x151>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x100,%eax
jb     12b7 <col221111+0x1b7>
mov    -0x50(%rbp),%edx
sub    -0x48(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
imul   $0x3,%edx,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    12bc <col221111+0x1bc>
jmp    12bc <col221111+0x1bc>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
cmp    $0x100,%eax
jb     1322 <col221111+0x222>
mov    -0x50(%rbp),%edx
add    -0x4c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
imul   $0x3,%edx,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1327 <col221111+0x227>
jmp    1327 <col221111+0x227>
mov    -0x38(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
shl    $0x3,%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
mov    -0x20(%rbp),%edx
and    $0x3,%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
cmp    $0x100,%eax
jb     13c6 <col221111+0x2c6>
mov    -0x50(%rbp),%edx
add    -0x44(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    13cb <col221111+0x2cb>
jmp    13cb <col221111+0x2cb>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x100,%eax
jb     1431 <col221111+0x331>
mov    -0x50(%rbp),%edx
sub    -0x48(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1436 <col221111+0x336>
jmp    1436 <col221111+0x336>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
cmp    $0x100,%eax
jb     149c <col221111+0x39c>
mov    -0x50(%rbp),%edx
add    -0x4c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    14a1 <col221111+0x3a1>
jmp    14a1 <col221111+0x3a1>
mov    -0x38(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
shl    $0x3,%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x20(%rbp),%edx
and    $0x3,%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
cmp    $0x100,%eax
jb     1540 <col221111+0x440>
mov    -0x50(%rbp),%edx
add    -0x44(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
imul   $0x3,%edx,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1545 <col221111+0x445>
jmp    1545 <col221111+0x445>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x100,%eax
jb     15ab <col221111+0x4ab>
mov    -0x50(%rbp),%edx
sub    -0x48(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
imul   $0x3,%edx,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    15b0 <col221111+0x4b0>
jmp    15b0 <col221111+0x4b0>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
cmp    $0x100,%eax
jb     1616 <col221111+0x516>
mov    -0x50(%rbp),%edx
add    -0x4c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x0,%edx
imul   $0x3,%edx,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    161b <col221111+0x51b>
jmp    161b <col221111+0x51b>
mov    -0x38(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
shl    $0x3,%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x20(%rbp),%edx
and    $0x3,%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
cmp    $0x100,%eax
jb     16ba <col221111+0x5ba>
mov    -0x50(%rbp),%edx
add    -0x44(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    16bf <col221111+0x5bf>
jmp    16bf <col221111+0x5bf>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x100,%eax
jb     1725 <col221111+0x625>
mov    -0x50(%rbp),%edx
sub    -0x48(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    172a <col221111+0x62a>
jmp    172a <col221111+0x62a>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
cmp    $0x100,%eax
jb     1790 <col221111+0x690>
mov    -0x50(%rbp),%edx
add    -0x4c(%rbp),%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movzbl %al,%eax
jmp    1795 <col221111+0x695>
jmp    1795 <col221111+0x695>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1165 <col221111+0x65>
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1154 <col221111+0x54>
mov    -0x38(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1143 <col221111+0x43>
pop    %rbp
ret

x86 assembly (clang, -O2):
<col221111>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movslq %edx,%rax
lea    (%rsi,%rax,1),%r15
lea    0x400(%rdi),%rcx
add    %eax,%eax
cltq
mov    %rax,-0x18(%rsp)
mov    $0x2,%eax
cs nopw 0x0(%rax,%rax,1)
mov    %rax,-0x20(%rsp)
mov    $0x4,%eax
nopw   0x0(%rax,%rax,1)
mov    %rax,-0x10(%rsp)
mov    %rdi,%r14
xor    %r11d,%r11d
xor    %r9d,%r9d
xor    %r13d,%r13d
mov    %rcx,-0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    (%rcx,%r9,2),%r12d
mov    0x100(%rcx,%r9,2),%edx
imul   $0x32,%r12d,%eax
mov    %edx,%ecx
shl    $0x7,%ecx
lea    (%rcx,%rdx,2),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %r13d,%ebp
and    $0xffffffc0,%ebp
mov    %r9d,%ecx
and    $0x6,%ecx
lea    (%rcx,%rbp,1),%ebx
mov    (%r14,%rbx,4),%r8d
lea    (%r8,%rdx,1),%r10d
mov    %r10d,%ebx
sar    $0x1f,%ebx
cmp    $0x100,%r10d
not    %bl
movzbl %bl,%ebx
cmovb  %r10d,%ebx
mov    %bl,(%rsi,%r11,1)
mov    %r8d,%edi
sub    %eax,%edi
mov    %edi,%ebx
sar    $0x1f,%ebx
cmp    $0x100,%edi
not    %bl
movzbl %bl,%ebx
cmovb  %edi,%ebx
mov    %bl,0x1(%rsi,%r11,1)
add    %r12d,%r8d
mov    %r8d,%edi
sar    $0x1f,%edi
cmp    $0x100,%r8d
not    %dil
movzbl %dil,%edi
cmovb  %r8d,%edi
mov    %dil,0x2(%rsi,%r11,1)
lea    0x1(%rbp,%rcx,1),%edi
mov    (%r14,%rdi,4),%ebx
lea    (%rbx,%rdx,1),%r8d
mov    %r8d,%edi
sar    $0x1f,%edi
cmp    $0x100,%r8d
not    %dil
movzbl %dil,%r10d
cmovb  %r8d,%r10d
mov    %ebx,%r8d
sub    %eax,%r8d
mov    %r8d,%edi
sar    $0x1f,%edi
cmp    $0x100,%r8d
not    %dil
movzbl %dil,%edi
cmovb  %r8d,%edi
mov    %r10b,0x3(%rsi,%r11,1)
add    %r12d,%ebx
mov    %ebx,%r8d
sar    $0x1f,%r8d
cmp    $0x100,%ebx
not    %r8b
movzbl %r8b,%r8d
cmovb  %ebx,%r8d
mov    %dil,0x4(%rsi,%r11,1)
mov    %r8b,0x5(%rsi,%r11,1)
lea    0x8(%rbp,%rcx,1),%edi
movslq %edi,%rdi
mov    (%r14,%rdi,4),%r10d
lea    (%r10,%rdx,1),%r8d
mov    %r8d,%edi
sar    $0x1f,%edi
cmp    $0x100,%r8d
not    %dil
movzbl %dil,%edi
cmovb  %r8d,%edi
mov    %dil,(%r15,%r11,1)
mov    %r10d,%ebx
sub    %eax,%ebx
mov    %ebx,%edi
sar    $0x1f,%edi
cmp    $0x100,%ebx
not    %dil
movzbl %dil,%edi
cmovb  %ebx,%edi
mov    %dil,0x1(%r15,%r11,1)
add    %r12d,%r10d
mov    %r10d,%edi
sar    $0x1f,%edi
cmp    $0x100,%r10d
not    %dil
movzbl %dil,%edi
cmovb  %r10d,%edi
mov    %dil,0x2(%r15,%r11,1)
add    %ebp,%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
mov    (%r14,%rcx,4),%ecx
add    %ecx,%edx
mov    %edx,%edi
sar    $0x1f,%edi
cmp    $0x100,%edx
not    %dil
movzbl %dil,%edi
cmovb  %edx,%edi
mov    %dil,0x3(%r15,%r11,1)
mov    %ecx,%edx
sub    %eax,%edx
mov    %edx,%eax
sar    $0x1f,%eax
cmp    $0x100,%edx
not    %al
movzbl %al,%eax
cmovb  %edx,%eax
mov    %al,0x4(%r15,%r11,1)
add    %r12d,%ecx
mov    %ecx,%eax
sar    $0x1f,%eax
cmp    $0x100,%ecx
not    %al
movzbl %al,%eax
cmovb  %ecx,%eax
mov    -0x8(%rsp),%rcx
mov    %al,0x5(%r15,%r11,1)
add    $0x10,%r13d
add    $0x2,%r9
add    $0x6,%r11
cmp    $0x30,%r11
jne    1160 <col221111+0x60>
add    $0x20,%rcx
lea    0x40(%r14),%rdi
mov    -0x18(%rsp),%rax
add    %rax,%rsi
add    %rax,%r15
mov    -0x10(%rsp),%rdx
lea    -0x1(%rdx),%eax
cmp    $0x1,%edx
ja     1140 <col221111+0x40>
add    $0x140,%r14
mov    -0x20(%rsp),%rdx
lea    -0x1(%rdx),%eax
mov    %r14,%rdi
cmp    $0x1,%edx
ja     1130 <col221111+0x30>
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) {
%4 = alloca i32*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i32* %0, i32** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%18 = load i8*, i8** %5
store i8* %18, i8** %10
%19 = load i8*, i8** %5
%20 = load i32, i32* %6
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
store i8* %22, i8** %11
%23 = load i32*, i32** %4
store i32* %23, i32** %12
%24 = load i32*, i32** %4
%25 = getelementptr inbounds i32, i32* %24, i64 256
store i32* %25, i32** %13
store i32 2, i32* %7
br label %26
26: ; preds = %569, %3
%27 = load i32, i32* %7
%28 = icmp sgt i32 %27, 0
br i1 %28, label %29, label %572
29: ; preds = %26
store i32 4, i32* %8
br label %30
30: ; preds = %563, %29
%31 = load i32, i32* %8
%32 = icmp sgt i32 %31, 0
br i1 %32, label %33, label %566
33: ; preds = %30
store i32 0, i32* %9
br label %34
34: ; preds = %545, %33
%35 = load i32, i32* %9
%36 = icmp slt i32 %35, 8
br i1 %36, label %37, label %548
37: ; preds = %34
%38 = load i32*, i32** %13
%39 = load i32, i32* %9
%40 = add nsw i32 0, %39
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %38, i64 %41
%43 = load i32, i32* %42
store i32 %43, i32* %16
%44 = load i32*, i32** %13
%45 = load i32, i32* %9
%46 = add nsw i32 64, %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %44, i64 %47
%49 = load i32, i32* %48
store i32 %49, i32* %14
%50 = load i32, i32* %16
%51 = mul nsw i32 50, %50
%52 = load i32, i32* %14
%53 = mul nsw i32 130, %52
%54 = add nsw i32 %51, %53
%55 = add nsw i32 %54, 128
%56 = ashr i32 %55, 8
store i32 %56, i32* %15
%57 = load i32*, i32** %12
%58 = load i32, i32* %9
%59 = sdiv i32 %58, 4
%60 = mul nsw i32 %59, 8
%61 = add nsw i32 %60, 0
%62 = mul nsw i32 %61, 8
%63 = load i32, i32* %9
%64 = and i32 %63, 3
%65 = mul nsw i32 %64, 2
%66 = add nsw i32 %62, %65
%67 = add nsw i32 %66, 0
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %57, i64 %68
%70 = load i32, i32* %69
store i32 %70, i32* %17
%71 = load i32, i32* %17
%72 = load i32, i32* %14
%73 = add nsw i32 %71, %72
%74 = trunc i32 %73 to i8
%75 = load i8*, i8** %10
%76 = load i32, i32* %9
%77 = mul nsw i32 %76, 2
%78 = add nsw i32 %77, 0
%79 = mul nsw i32 %78, 3
%80 = add nsw i32 %79, 0
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8, i8* %75, i64 %81
store i8 %74, i8* %82
%83 = load i32, i32* %17
%84 = load i32, i32* %14
%85 = add nsw i32 %83, %84
%86 = icmp uge i32 %85, 256
br i1 %86, label %87, label %104
87: ; preds = %37
%88 = load i32, i32* %17
%89 = load i32, i32* %14
%90 = add nsw i32 %88, %89
%91 = icmp slt i32 %90, 0
%92 = zext i1 %91 to i64
%93 = select i1 %91, i32 0, i32 255
%94 = trunc i32 %93 to i8
%95 = load i8*, i8** %10
%96 = load i32, i32* %9
%97 = mul nsw i32 %96, 2
%98 = add nsw i32 %97, 0
%99 = mul nsw i32 %98, 3
%100 = add nsw i32 %99, 0
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %95, i64 %101
store i8 %94, i8* %102
%103 = zext i8 %94 to i32
br label %105
104: ; preds = %37
br label %105
105: ; preds = %104, %87
%106 = phi i32 [ %103, %87 ], [ 0, %104 ]
%107 = load i32, i32* %17
%108 = load i32, i32* %15
%109 = sub nsw i32 %107, %108
%110 = trunc i32 %109 to i8
%111 = load i8*, i8** %10
%112 = load i32, i32* %9
%113 = mul nsw i32 %112, 2
%114 = add nsw i32 %113, 0
%115 = mul nsw i32 %114, 3
%116 = add nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %111, i64 %117
store i8 %110, i8* %118
%119 = load i32, i32* %17
%120 = load i32, i32* %15
%121 = sub nsw i32 %119, %120
%122 = icmp uge i32 %121, 256
br i1 %122, label %123, label %140
123: ; preds = %105
%124 = load i32, i32* %17
%125 = load i32, i32* %15
%126 = sub nsw i32 %124, %125
%127 = icmp slt i32 %126, 0
%128 = zext i1 %127 to i64
%129 = select i1 %127, i32 0, i32 255
%130 = trunc i32 %129 to i8
%131 = load i8*, i8** %10
%132 = load i32, i32* %9
%133 = mul nsw i32 %132, 2
%134 = add nsw i32 %133, 0
%135 = mul nsw i32 %134, 3
%136 = add nsw i32 %135, 1
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i8, i8* %131, i64 %137
store i8 %130, i8* %138
%139 = zext i8 %130 to i32
br label %141
140: ; preds = %105
br label %141
141: ; preds = %140, %123
%142 = phi i32 [ %139, %123 ], [ 0, %140 ]
%143 = load i32, i32* %17
%144 = load i32, i32* %16
%145 = add nsw i32 %143, %144
%146 = trunc i32 %145 to i8
%147 = load i8*, i8** %10
%148 = load i32, i32* %9
%149 = mul nsw i32 %148, 2
%150 = add nsw i32 %149, 0
%151 = mul nsw i32 %150, 3
%152 = add nsw i32 %151, 2
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %147, i64 %153
store i8 %146, i8* %154
%155 = load i32, i32* %17
%156 = load i32, i32* %16
%157 = add nsw i32 %155, %156
%158 = icmp uge i32 %157, 256
br i1 %158, label %159, label %176
159: ; preds = %141
%160 = load i32, i32* %17
%161 = load i32, i32* %16
%162 = add nsw i32 %160, %161
%163 = icmp slt i32 %162, 0
%164 = zext i1 %163 to i64
%165 = select i1 %163, i32 0, i32 255
%166 = trunc i32 %165 to i8
%167 = load i8*, i8** %10
%168 = load i32, i32* %9
%169 = mul nsw i32 %168, 2
%170 = add nsw i32 %169, 0
%171 = mul nsw i32 %170, 3
%172 = add nsw i32 %171, 2
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i8, i8* %167, i64 %173
store i8 %166, i8* %174
%175 = zext i8 %166 to i32
br label %177
176: ; preds = %141
br label %177
177: ; preds = %176, %159
%178 = phi i32 [ %175, %159 ], [ 0, %176 ]
%179 = load i32*, i32** %12
%180 = load i32, i32* %9
%181 = sdiv i32 %180, 4
%182 = mul nsw i32 %181, 8
%183 = add nsw i32 %182, 0
%184 = mul nsw i32 %183, 8
%185 = load i32, i32* %9
%186 = and i32 %185, 3
%187 = mul nsw i32 %186, 2
%188 = add nsw i32 %184, %187
%189 = add nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %179, i64 %190
%192 = load i32, i32* %191
store i32 %192, i32* %17
%193 = load i32, i32* %17
%194 = load i32, i32* %14
%195 = add nsw i32 %193, %194
%196 = trunc i32 %195 to i8
%197 = load i8*, i8** %10
%198 = load i32, i32* %9
%199 = mul nsw i32 %198, 2
%200 = add nsw i32 %199, 1
%201 = mul nsw i32 %200, 3
%202 = add nsw i32 %201, 0
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i8, i8* %197, i64 %203
store i8 %196, i8* %204
%205 = load i32, i32* %17
%206 = load i32, i32* %14
%207 = add nsw i32 %205, %206
%208 = icmp uge i32 %207, 256
br i1 %208, label %209, label %226
209: ; preds = %177
%210 = load i32, i32* %17
%211 = load i32, i32* %14
%212 = add nsw i32 %210, %211
%213 = icmp slt i32 %212, 0
%214 = zext i1 %213 to i64
%215 = select i1 %213, i32 0, i32 255
%216 = trunc i32 %215 to i8
%217 = load i8*, i8** %10
%218 = load i32, i32* %9
%219 = mul nsw i32 %218, 2
%220 = add nsw i32 %219, 1
%221 = mul nsw i32 %220, 3
%222 = add nsw i32 %221, 0
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %217, i64 %223
store i8 %216, i8* %224
%225 = zext i8 %216 to i32
br label %227
226: ; preds = %177
br label %227
227: ; preds = %226, %209
%228 = phi i32 [ %225, %209 ], [ 0, %226 ]
%229 = load i32, i32* %17
%230 = load i32, i32* %15
%231 = sub nsw i32 %229, %230
%232 = trunc i32 %231 to i8
%233 = load i8*, i8** %10
%234 = load i32, i32* %9
%235 = mul nsw i32 %234, 2
%236 = add nsw i32 %235, 1
%237 = mul nsw i32 %236, 3
%238 = add nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i8, i8* %233, i64 %239
store i8 %232, i8* %240
%241 = load i32, i32* %17
%242 = load i32, i32* %15
%243 = sub nsw i32 %241, %242
%244 = icmp uge i32 %243, 256
br i1 %244, label %245, label %262
245: ; preds = %227
%246 = load i32, i32* %17
%247 = load i32, i32* %15
%248 = sub nsw i32 %246, %247
%249 = icmp slt i32 %248, 0
%250 = zext i1 %249 to i64
%251 = select i1 %249, i32 0, i32 255
%252 = trunc i32 %251 to i8
%253 = load i8*, i8** %10
%254 = load i32, i32* %9
%255 = mul nsw i32 %254, 2
%256 = add nsw i32 %255, 1
%257 = mul nsw i32 %256, 3
%258 = add nsw i32 %257, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8, i8* %253, i64 %259
store i8 %252, i8* %260
%261 = zext i8 %252 to i32
br label %263
262: ; preds = %227
br label %263
263: ; preds = %262, %245
%264 = phi i32 [ %261, %245 ], [ 0, %262 ]
%265 = load i32, i32* %17
%266 = load i32, i32* %16
%267 = add nsw i32 %265, %266
%268 = trunc i32 %267 to i8
%269 = load i8*, i8** %10
%270 = load i32, i32* %9
%271 = mul nsw i32 %270, 2
%272 = add nsw i32 %271, 1
%273 = mul nsw i32 %272, 3
%274 = add nsw i32 %273, 2
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i8, i8* %269, i64 %275
store i8 %268, i8* %276
%277 = load i32, i32* %17
%278 = load i32, i32* %16
%279 = add nsw i32 %277, %278
%280 = icmp uge i32 %279, 256
br i1 %280, label %281, label %298
281: ; preds = %263
%282 = load i32, i32* %17
%283 = load i32, i32* %16
%284 = add nsw i32 %282, %283
%285 = icmp slt i32 %284, 0
%286 = zext i1 %285 to i64
%287 = select i1 %285, i32 0, i32 255
%288 = trunc i32 %287 to i8
%289 = load i8*, i8** %10
%290 = load i32, i32* %9
%291 = mul nsw i32 %290, 2
%292 = add nsw i32 %291, 1
%293 = mul nsw i32 %292, 3
%294 = add nsw i32 %293, 2
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i8, i8* %289, i64 %295
store i8 %288, i8* %296
%297 = zext i8 %288 to i32
br label %299
298: ; preds = %263
br label %299
299: ; preds = %298, %281
%300 = phi i32 [ %297, %281 ], [ 0, %298 ]
%301 = load i32*, i32** %12
%302 = load i32, i32* %9
%303 = sdiv i32 %302, 4
%304 = mul nsw i32 %303, 8
%305 = add nsw i32 %304, 1
%306 = mul nsw i32 %305, 8
%307 = load i32, i32* %9
%308 = and i32 %307, 3
%309 = mul nsw i32 %308, 2
%310 = add nsw i32 %306, %309
%311 = add nsw i32 %310, 0
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds i32, i32* %301, i64 %312
%314 = load i32, i32* %313
store i32 %314, i32* %17
%315 = load i32, i32* %17
%316 = load i32, i32* %14
%317 = add nsw i32 %315, %316
%318 = trunc i32 %317 to i8
%319 = load i8*, i8** %11
%320 = load i32, i32* %9
%321 = mul nsw i32 %320, 2
%322 = add nsw i32 %321, 0
%323 = mul nsw i32 %322, 3
%324 = add nsw i32 %323, 0
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i8, i8* %319, i64 %325
store i8 %318, i8* %326
%327 = load i32, i32* %17
%328 = load i32, i32* %14
%329 = add nsw i32 %327, %328
%330 = icmp uge i32 %329, 256
br i1 %330, label %331, label %348
331: ; preds = %299
%332 = load i32, i32* %17
%333 = load i32, i32* %14
%334 = add nsw i32 %332, %333
%335 = icmp slt i32 %334, 0
%336 = zext i1 %335 to i64
%337 = select i1 %335, i32 0, i32 255
%338 = trunc i32 %337 to i8
%339 = load i8*, i8** %11
%340 = load i32, i32* %9
%341 = mul nsw i32 %340, 2
%342 = add nsw i32 %341, 0
%343 = mul nsw i32 %342, 3
%344 = add nsw i32 %343, 0
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i8, i8* %339, i64 %345
store i8 %338, i8* %346
%347 = zext i8 %338 to i32
br label %349
348: ; preds = %299
br label %349
349: ; preds = %348, %331
%350 = phi i32 [ %347, %331 ], [ 0, %348 ]
%351 = load i32, i32* %17
%352 = load i32, i32* %15
%353 = sub nsw i32 %351, %352
%354 = trunc i32 %353 to i8
%355 = load i8*, i8** %11
%356 = load i32, i32* %9
%357 = mul nsw i32 %356, 2
%358 = add nsw i32 %357, 0
%359 = mul nsw i32 %358, 3
%360 = add nsw i32 %359, 1
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds i8, i8* %355, i64 %361
store i8 %354, i8* %362
%363 = load i32, i32* %17
%364 = load i32, i32* %15
%365 = sub nsw i32 %363, %364
%366 = icmp uge i32 %365, 256
br i1 %366, label %367, label %384
367: ; preds = %349
%368 = load i32, i32* %17
%369 = load i32, i32* %15
%370 = sub nsw i32 %368, %369
%371 = icmp slt i32 %370, 0
%372 = zext i1 %371 to i64
%373 = select i1 %371, i32 0, i32 255
%374 = trunc i32 %373 to i8
%375 = load i8*, i8** %11
%376 = load i32, i32* %9
%377 = mul nsw i32 %376, 2
%378 = add nsw i32 %377, 0
%379 = mul nsw i32 %378, 3
%380 = add nsw i32 %379, 1
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i8, i8* %375, i64 %381
store i8 %374, i8* %382
%383 = zext i8 %374 to i32
br label %385
384: ; preds = %349
br label %385
385: ; preds = %384, %367
%386 = phi i32 [ %383, %367 ], [ 0, %384 ]
%387 = load i32, i32* %17
%388 = load i32, i32* %16
%389 = add nsw i32 %387, %388
%390 = trunc i32 %389 to i8
%391 = load i8*, i8** %11
%392 = load i32, i32* %9
%393 = mul nsw i32 %392, 2
%394 = add nsw i32 %393, 0
%395 = mul nsw i32 %394, 3
%396 = add nsw i32 %395, 2
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i8, i8* %391, i64 %397
store i8 %390, i8* %398
%399 = load i32, i32* %17
%400 = load i32, i32* %16
%401 = add nsw i32 %399, %400
%402 = icmp uge i32 %401, 256
br i1 %402, label %403, label %420
403: ; preds = %385
%404 = load i32, i32* %17
%405 = load i32, i32* %16
%406 = add nsw i32 %404, %405
%407 = icmp slt i32 %406, 0
%408 = zext i1 %407 to i64
%409 = select i1 %407, i32 0, i32 255
%410 = trunc i32 %409 to i8
%411 = load i8*, i8** %11
%412 = load i32, i32* %9
%413 = mul nsw i32 %412, 2
%414 = add nsw i32 %413, 0
%415 = mul nsw i32 %414, 3
%416 = add nsw i32 %415, 2
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i8, i8* %411, i64 %417
store i8 %410, i8* %418
%419 = zext i8 %410 to i32
br label %421
420: ; preds = %385
br label %421
421: ; preds = %420, %403
%422 = phi i32 [ %419, %403 ], [ 0, %420 ]
%423 = load i32*, i32** %12
%424 = load i32, i32* %9
%425 = sdiv i32 %424, 4
%426 = mul nsw i32 %425, 8
%427 = add nsw i32 %426, 1
%428 = mul nsw i32 %427, 8
%429 = load i32, i32* %9
%430 = and i32 %429, 3
%431 = mul nsw i32 %430, 2
%432 = add nsw i32 %428, %431
%433 = add nsw i32 %432, 1
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds i32, i32* %423, i64 %434
%436 = load i32, i32* %435
store i32 %436, i32* %17
%437 = load i32, i32* %17
%438 = load i32, i32* %14
%439 = add nsw i32 %437, %438
%440 = trunc i32 %439 to i8
%441 = load i8*, i8** %11
%442 = load i32, i32* %9
%443 = mul nsw i32 %442, 2
%444 = add nsw i32 %443, 1
%445 = mul nsw i32 %444, 3
%446 = add nsw i32 %445, 0
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i8, i8* %441, i64 %447
store i8 %440, i8* %448
%449 = load i32, i32* %17
%450 = load i32, i32* %14
%451 = add nsw i32 %449, %450
%452 = icmp uge i32 %451, 256
br i1 %452, label %453, label %470
453: ; preds = %421
%454 = load i32, i32* %17
%455 = load i32, i32* %14
%456 = add nsw i32 %454, %455
%457 = icmp slt i32 %456, 0
%458 = zext i1 %457 to i64
%459 = select i1 %457, i32 0, i32 255
%460 = trunc i32 %459 to i8
%461 = load i8*, i8** %11
%462 = load i32, i32* %9
%463 = mul nsw i32 %462, 2
%464 = add nsw i32 %463, 1
%465 = mul nsw i32 %464, 3
%466 = add nsw i32 %465, 0
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds i8, i8* %461, i64 %467
store i8 %460, i8* %468
%469 = zext i8 %460 to i32
br label %471
470: ; preds = %421
br label %471
471: ; preds = %470, %453
%472 = phi i32 [ %469, %453 ], [ 0, %470 ]
%473 = load i32, i32* %17
%474 = load i32, i32* %15
%475 = sub nsw i32 %473, %474
%476 = trunc i32 %475 to i8
%477 = load i8*, i8** %11
%478 = load i32, i32* %9
%479 = mul nsw i32 %478, 2
%480 = add nsw i32 %479, 1
%481 = mul nsw i32 %480, 3
%482 = add nsw i32 %481, 1
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds i8, i8* %477, i64 %483
store i8 %476, i8* %484
%485 = load i32, i32* %17
%486 = load i32, i32* %15
%487 = sub nsw i32 %485, %486
%488 = icmp uge i32 %487, 256
br i1 %488, label %489, label %506
489: ; preds = %471
%490 = load i32, i32* %17
%491 = load i32, i32* %15
%492 = sub nsw i32 %490, %491
%493 = icmp slt i32 %492, 0
%494 = zext i1 %493 to i64
%495 = select i1 %493, i32 0, i32 255
%496 = trunc i32 %495 to i8
%497 = load i8*, i8** %11
%498 = load i32, i32* %9
%499 = mul nsw i32 %498, 2
%500 = add nsw i32 %499, 1
%501 = mul nsw i32 %500, 3
%502 = add nsw i32 %501, 1
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i8, i8* %497, i64 %503
store i8 %496, i8* %504
%505 = zext i8 %496 to i32
br label %507
506: ; preds = %471
br label %507
507: ; preds = %506, %489
%508 = phi i32 [ %505, %489 ], [ 0, %506 ]
%509 = load i32, i32* %17
%510 = load i32, i32* %16
%511 = add nsw i32 %509, %510
%512 = trunc i32 %511 to i8
%513 = load i8*, i8** %11
%514 = load i32, i32* %9
%515 = mul nsw i32 %514, 2
%516 = add nsw i32 %515, 1
%517 = mul nsw i32 %516, 3
%518 = add nsw i32 %517, 2
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds i8, i8* %513, i64 %519
store i8 %512, i8* %520
%521 = load i32, i32* %17
%522 = load i32, i32* %16
%523 = add nsw i32 %521, %522
%524 = icmp uge i32 %523, 256
br i1 %524, label %525, label %542
525: ; preds = %507
%526 = load i32, i32* %17
%527 = load i32, i32* %16
%528 = add nsw i32 %526, %527
%529 = icmp slt i32 %528, 0
%530 = zext i1 %529 to i64
%531 = select i1 %529, i32 0, i32 255
%532 = trunc i32 %531 to i8
%533 = load i8*, i8** %11
%534 = load i32, i32* %9
%535 = mul nsw i32 %534, 2
%536 = add nsw i32 %535, 1
%537 = mul nsw i32 %536, 3
%538 = add nsw i32 %537, 2
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i8, i8* %533, i64 %539
store i8 %532, i8* %540
%541 = zext i8 %532 to i32
br label %543
542: ; preds = %507
br label %543
543: ; preds = %542, %525
%544 = phi i32 [ %541, %525 ], [ 0, %542 ]
br label %545
545: ; preds = %543
%546 = load i32, i32* %9
%547 = add nsw i32 %546, 1
store i32 %547, i32* %9
br label %34
548: ; preds = %34
%549 = load i32*, i32** %13
%550 = getelementptr inbounds i32, i32* %549, i64 8
store i32* %550, i32** %13
%551 = load i32*, i32** %12
%552 = getelementptr inbounds i32, i32* %551, i64 16
store i32* %552, i32** %12
%553 = load i32, i32* %6
%554 = mul nsw i32 2, %553
%555 = load i8*, i8** %10
%556 = sext i32 %554 to i64
%557 = getelementptr inbounds i8, i8* %555, i64 %556
store i8* %557, i8** %10
%558 = load i32, i32* %6
%559 = mul nsw i32 2, %558
%560 = load i8*, i8** %11
%561 = sext i32 %559 to i64
%562 = getelementptr inbounds i8, i8* %560, i64 %561
store i8* %562, i8** %11
br label %563
563: ; preds = %548
%564 = load i32, i32* %8
%565 = add nsw i32 %564, -1
store i32 %565, i32* %8
br label %30
566: ; preds = %30
%567 = load i32*, i32** %12
%568 = getelementptr inbounds i32, i32* %567, i64 64
store i32* %568, i32** %12
br label %569
569: ; preds = %566
%570 = load i32, i32* %7
%571 = add nsw i32 %570, -1
store i32 %571, i32* %7
br label %26
572: ; preds = %26
ret void
}

LLVM IR (-O2):
define void @col221111(i32* nocapture %0, i8* nocapture writeonly %1, i32 %2) {
%4 = sext i32 %2 to i64
%5 = getelementptr inbounds i8, i8* %1, i64 %4
%6 = getelementptr inbounds i32, i32* %0, i64 256
%7 = shl nsw i32 %2, 1
%8 = sext i32 %7 to i64
br label %9
9: ; preds = %3, %167
%10 = phi i32 [ 2, %3 ], [ %169, %167 ]
%11 = phi i32* [ %6, %3 ], [ %161, %167 ]
%12 = phi i32* [ %0, %3 ], [ %168, %167 ]
%13 = phi i8* [ %5, %3 ], [ %164, %167 ]
%14 = phi i8* [ %1, %3 ], [ %163, %167 ]
br label %15
15: ; preds = %9, %160
%16 = phi i32 [ 4, %9 ], [ %165, %160 ]
%17 = phi i32* [ %11, %9 ], [ %161, %160 ]
%18 = phi i32* [ %12, %9 ], [ %162, %160 ]
%19 = phi i8* [ %13, %9 ], [ %164, %160 ]
%20 = phi i8* [ %14, %9 ], [ %163, %160 ]
br label %21
21: ; preds = %15, %21
%22 = phi i64 [ 0, %15 ], [ %158, %21 ]
%23 = getelementptr inbounds i32, i32* %17, i64 %22
%24 = load i32, i32* %23
%25 = add nuw nsw i64 %22, 64
%26 = getelementptr inbounds i32, i32* %17, i64 %25
%27 = load i32, i32* %26
%28 = mul nsw i32 %24, 50
%29 = mul nsw i32 %27, 130
%30 = add i32 %28, 128
%31 = add i32 %30, %29
%32 = ashr i32 %31, 8
%33 = shl nuw nsw i64 %22, 1
%34 = trunc i64 %22 to i32
%35 = shl i32 %34, 4
%36 = and i32 %35, -64
%37 = trunc i64 %33 to i32
%38 = and i32 %37, 6
%39 = or i32 %36, %38
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds i32, i32* %18, i64 %40
%42 = load i32, i32* %41
%43 = add nsw i32 %42, %27
%44 = trunc i32 %43 to i8
%45 = mul nuw nsw i64 %22, 6
%46 = getelementptr inbounds i8, i8* %20, i64 %45
%47 = icmp ugt i32 %43, 255
%48 = ashr i32 %43, 31
%49 = trunc i32 %48 to i8
%50 = xor i8 %49, -1
%51 = select i1 %47, i8 %50, i8 %44
store i8 %51, i8* %46
%52 = sub nsw i32 %42, %32
%53 = trunc i32 %52 to i8
%54 = or i64 %45, 1
%55 = getelementptr inbounds i8, i8* %20, i64 %54
%56 = icmp ugt i32 %52, 255
%57 = ashr i32 %52, 31
%58 = trunc i32 %57 to i8
%59 = xor i8 %58, -1
%60 = select i1 %56, i8 %59, i8 %53
store i8 %60, i8* %55
%61 = add nsw i32 %42, %24
%62 = trunc i32 %61 to i8
%63 = add nuw nsw i64 %45, 2
%64 = getelementptr inbounds i8, i8* %20, i64 %63
%65 = icmp ugt i32 %61, 255
%66 = ashr i32 %61, 31
%67 = trunc i32 %66 to i8
%68 = xor i8 %67, -1
%69 = select i1 %65, i8 %68, i8 %62
store i8 %69, i8* %64
%70 = or i32 %39, 1
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %18, i64 %71
%73 = load i32, i32* %72
%74 = add nsw i32 %73, %27
%75 = trunc i32 %74 to i8
%76 = or i64 %33, 1
%77 = mul nuw nsw i64 %76, 3
%78 = getelementptr inbounds i8, i8* %20, i64 %77
%79 = icmp ugt i32 %74, 255
%80 = ashr i32 %74, 31
%81 = trunc i32 %80 to i8
%82 = xor i8 %81, -1
%83 = select i1 %79, i8 %82, i8 %75
store i8 %83, i8* %78
%84 = sub nsw i32 %73, %32
%85 = trunc i32 %84 to i8
%86 = add nuw nsw i64 %77, 1
%87 = getelementptr inbounds i8, i8* %20, i64 %86
%88 = icmp ugt i32 %84, 255
%89 = ashr i32 %84, 31
%90 = trunc i32 %89 to i8
%91 = xor i8 %90, -1
%92 = select i1 %88, i8 %91, i8 %85
store i8 %92, i8* %87
%93 = add nsw i32 %73, %24
%94 = trunc i32 %93 to i8
%95 = add nuw nsw i64 %77, 2
%96 = getelementptr inbounds i8, i8* %20, i64 %95
%97 = icmp ugt i32 %93, 255
%98 = ashr i32 %93, 31
%99 = trunc i32 %98 to i8
%100 = xor i8 %99, -1
%101 = select i1 %97, i8 %100, i8 %94
store i8 %101, i8* %96
%102 = or i32 %39, 8
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %18, i64 %103
%105 = load i32, i32* %104
%106 = add nsw i32 %105, %27
%107 = trunc i32 %106 to i8
%108 = getelementptr inbounds i8, i8* %19, i64 %45
%109 = icmp ugt i32 %106, 255
%110 = ashr i32 %106, 31
%111 = trunc i32 %110 to i8
%112 = xor i8 %111, -1
%113 = select i1 %109, i8 %112, i8 %107
store i8 %113, i8* %108
%114 = sub nsw i32 %105, %32
%115 = trunc i32 %114 to i8
%116 = getelementptr inbounds i8, i8* %19, i64 %54
%117 = icmp ugt i32 %114, 255
%118 = ashr i32 %114, 31
%119 = trunc i32 %118 to i8
%120 = xor i8 %119, -1
%121 = select i1 %117, i8 %120, i8 %115
store i8 %121, i8* %116
%122 = add nsw i32 %105, %24
%123 = trunc i32 %122 to i8
%124 = getelementptr inbounds i8, i8* %19, i64 %63
%125 = icmp ugt i32 %122, 255
%126 = ashr i32 %122, 31
%127 = trunc i32 %126 to i8
%128 = xor i8 %127, -1
%129 = select i1 %125, i8 %128, i8 %123
store i8 %129, i8* %124
%130 = or i32 %39, 9
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %18, i64 %131
%133 = load i32, i32* %132
%134 = add nsw i32 %133, %27
%135 = trunc i32 %134 to i8
%136 = getelementptr inbounds i8, i8* %19, i64 %77
%137 = icmp ugt i32 %134, 255
%138 = ashr i32 %134, 31
%139 = trunc i32 %138 to i8
%140 = xor i8 %139, -1
%141 = select i1 %137, i8 %140, i8 %135
store i8 %141, i8* %136
%142 = sub nsw i32 %133, %32
%143 = trunc i32 %142 to i8
%144 = getelementptr inbounds i8, i8* %19, i64 %86
%145 = icmp ugt i32 %142, 255
%146 = ashr i32 %142, 31
%147 = trunc i32 %146 to i8
%148 = xor i8 %147, -1
%149 = select i1 %145, i8 %148, i8 %143
store i8 %149, i8* %144
%150 = add nsw i32 %133, %24
%151 = trunc i32 %150 to i8
%152 = getelementptr inbounds i8, i8* %19, i64 %95
%153 = icmp ugt i32 %150, 255
%154 = ashr i32 %150, 31
%155 = trunc i32 %154 to i8
%156 = xor i8 %155, -1
%157 = select i1 %153, i8 %156, i8 %151
store i8 %157, i8* %152
%158 = add nuw nsw i64 %22, 1
%159 = icmp eq i64 %158, 8
br i1 %159, label %160, label %21
160: ; preds = %21
%161 = getelementptr inbounds i32, i32* %17, i64 8
%162 = getelementptr inbounds i32, i32* %18, i64 16
%163 = getelementptr inbounds i8, i8* %20, i64 %8
%164 = getelementptr inbounds i8, i8* %19, i64 %8
%165 = add nsw i32 %16, -1
%166 = icmp ugt i32 %16, 1
br i1 %166, label %15, label %167
167: ; preds = %160
%168 = getelementptr inbounds i32, i32* %18, i64 80
%169 = add nsw i32 %10, -1
%170 = icmp ugt i32 %10, 1
br i1 %170, label %9, label %171
171: ; preds = %167
ret void
}