void qc_imag_bay2rgb_gptm_fast(unsigned char *bay, int bay_line,
                               unsigned char *rgb, int rgb_line, int columns,
                               int rows, int bpp) {
  int r, g, b, w;
  unsigned char *cur_bay, *cur_rgb;
  int bay_line2, bay_line3, rgb_line2;
  int total_columns;
  total_columns = (columns >> 1) - 2;
  rows = (rows >> 1) - 2;
  bay_line2 = 2 * bay_line;
  bay_line3 = 3 * bay_line;
  rgb_line2 = 2 * rgb_line;
  cur_bay = bay;
  cur_rgb = rgb;
  columns = total_columns + 2;
  do {
    qc_imag_writergb(cur_rgb + 0, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + bpp, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line, bpp, cur_bay[1], cur_bay[bay_line + 1],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line + bpp, bpp, cur_bay[1],
                     cur_bay[bay_line + 1], cur_bay[bay_line]);
    cur_bay += 2;
    cur_rgb += 2 * bpp;
  } while (--columns);
  bay += bay_line2;
  rgb += rgb_line2;
  do {
    cur_bay = bay;
    cur_rgb = rgb;
    columns = total_columns;
    qc_imag_writergb(cur_rgb + 0, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + bpp, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line, bpp, cur_bay[1], cur_bay[bay_line + 1],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line + bpp, bpp, cur_bay[1],
                     cur_bay[bay_line + 1], cur_bay[bay_line]);
    cur_bay += 2;
    cur_rgb += 2 * bpp;
    do {
      w = 4 * cur_bay[0] - (cur_bay[-bay_line - 1] + cur_bay[-bay_line + 1] +
                            cur_bay[bay_line - 1] + cur_bay[bay_line + 1]);
      r = (2 * (cur_bay[-1] + cur_bay[1]) + w) >> 2;
      b = (2 * (cur_bay[-bay_line] + cur_bay[bay_line]) + w) >> 2;
      qc_imag_writergb(cur_rgb + 0, bpp,
                       (((0)) > ((((255)) < ((r)) ? ((255)) : ((r))))
                            ? ((0))
                            : ((((255)) < ((r)) ? ((255)) : ((r))))),
                       cur_bay[0],
                       (((0)) > ((((255)) < ((b)) ? ((255)) : ((b))))
                            ? ((0))
                            : ((((255)) < ((b)) ? ((255)) : ((b))))));
      w = 4 * cur_bay[1] - (cur_bay[-bay_line2 + 1] + cur_bay[-1] + cur_bay[3] +
                            cur_bay[bay_line2 + 1]);
      g = (2 * (cur_bay[-bay_line + 1] + cur_bay[0] + cur_bay[2] +
                cur_bay[bay_line + 1]) +
           w) >>
          3;
      b = (2 * (cur_bay[-bay_line] + cur_bay[-bay_line + 2] +
                cur_bay[bay_line] + cur_bay[bay_line + 2]) +
           w) >>
          3;
      qc_imag_writergb(cur_rgb + bpp, bpp, cur_bay[1],
                       (((0)) > ((((255)) < ((g)) ? ((255)) : ((g))))
                            ? ((0))
                            : ((((255)) < ((g)) ? ((255)) : ((g))))),
                       (((0)) > ((((255)) < ((b)) ? ((255)) : ((b))))
                            ? ((0))
                            : ((((255)) < ((b)) ? ((255)) : ((b))))));
      w = 4 * cur_bay[bay_line] - (cur_bay[-bay_line] + cur_bay[bay_line - 2] +
                                   cur_bay[bay_line + 2] + cur_bay[bay_line3]);
      r = ((cur_bay[-1] + cur_bay[1] + cur_bay[bay_line2 - 1] +
            cur_bay[bay_line2 + 1]) +
           w) >>
          2;
      g = ((cur_bay[0] + cur_bay[bay_line - 1] + cur_bay[bay_line + 1] +
            cur_bay[bay_line2]) +
           w) >>
          2;
      qc_imag_writergb(cur_rgb + rgb_line, bpp,
                       (((0)) > ((((255)) < ((r)) ? ((255)) : ((r))))
                            ? ((0))
                            : ((((255)) < ((r)) ? ((255)) : ((r))))),
                       (((0)) > ((((255)) < ((g)) ? ((255)) : ((g))))
                            ? ((0))
                            : ((((255)) < ((g)) ? ((255)) : ((g))))),
                       cur_bay[bay_line]);
      w = 4 * cur_bay[bay_line + 1] -
          (cur_bay[0] + cur_bay[2] + cur_bay[bay_line2] +
           cur_bay[bay_line2 + 2]);
      r = (2 * (cur_bay[1] + cur_bay[bay_line2 + 1]) + w) >> 2;
      b = (2 * (cur_bay[bay_line] + cur_bay[bay_line + 2]) + w) >> 2;
      qc_imag_writergb(cur_rgb + rgb_line + bpp, bpp,
                       (((0)) > ((((255)) < ((r)) ? ((255)) : ((r))))
                            ? ((0))
                            : ((((255)) < ((r)) ? ((255)) : ((r))))),
                       cur_bay[bay_line + 1],
                       (((0)) > ((((255)) < ((b)) ? ((255)) : ((b))))
                            ? ((0))
                            : ((((255)) < ((b)) ? ((255)) : ((b))))));
      cur_bay += 2;
      cur_rgb += 2 * bpp;
    } while (--columns);
    qc_imag_writergb(cur_rgb + 0, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + bpp, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line, bpp, cur_bay[1], cur_bay[bay_line + 1],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line + bpp, bpp, cur_bay[1],
                     cur_bay[bay_line + 1], cur_bay[bay_line]);
    bay += bay_line2;
    rgb += rgb_line2;
  } while (--rows);
  cur_bay = bay;
  cur_rgb = rgb;
  columns = total_columns + 2;
  do {
    qc_imag_writergb(cur_rgb + 0, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + bpp, bpp, cur_bay[1], cur_bay[0],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line, bpp, cur_bay[1], cur_bay[bay_line + 1],
                     cur_bay[bay_line]);
    qc_imag_writergb(cur_rgb + rgb_line + bpp, bpp, cur_bay[1],
                     cur_bay[bay_line + 1], cur_bay[bay_line]);
    cur_bay += 2;
    cur_rgb += 2 * bpp;
  } while (--columns);
}


x86 assembly (clang, -O0):
<qc_imag_bay2rgb_gptm_fast>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x20(%rbp),%eax
sar    $0x1,%eax
sub    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x24(%rbp),%eax
sar    $0x1,%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
imul   $0x3,-0xc(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x48(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jne    117e <qc_imag_bay2rgb_gptm_fast+0x6e>
mov    -0x4c(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x48(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    -0x40(%rbp),%rcx
xor    %edx,%edx
sub    -0xc(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x40(%rbp),%rdx
xor    %esi,%esi
sub    -0xc(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0xc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
movzbl -0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
add    %ecx,%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    $0xff,%eax
cmp    -0x28(%rbp),%eax
jge    1486 <qc_imag_bay2rgb_gptm_fast+0x376>
mov    $0xff,%eax
mov    %eax,-0x6c(%rbp)
jmp    148c <qc_imag_bay2rgb_gptm_fast+0x37c>
mov    -0x28(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    14a3 <qc_imag_bay2rgb_gptm_fast+0x393>
xor    %eax,%eax
mov    %eax,-0x70(%rbp)
jmp    14ca <qc_imag_bay2rgb_gptm_fast+0x3ba>
mov    $0xff,%eax
cmp    -0x28(%rbp),%eax
jge    14be <qc_imag_bay2rgb_gptm_fast+0x3ae>
mov    $0xff,%eax
mov    %eax,-0x74(%rbp)
jmp    14c4 <qc_imag_bay2rgb_gptm_fast+0x3b4>
mov    -0x28(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x78(%rbp)
mov    $0xff,%eax
cmp    -0x30(%rbp),%eax
jge    14f5 <qc_imag_bay2rgb_gptm_fast+0x3e5>
mov    $0xff,%eax
mov    %eax,-0x80(%rbp)
jmp    14fb <qc_imag_bay2rgb_gptm_fast+0x3eb>
mov    -0x30(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1515 <qc_imag_bay2rgb_gptm_fast+0x405>
xor    %eax,%eax
mov    %eax,-0x84(%rbp)
jmp    1548 <qc_imag_bay2rgb_gptm_fast+0x438>
mov    $0xff,%eax
cmp    -0x30(%rbp),%eax
jge    1533 <qc_imag_bay2rgb_gptm_fast+0x423>
mov    $0xff,%eax
mov    %eax,-0x88(%rbp)
jmp    153c <qc_imag_bay2rgb_gptm_fast+0x42c>
mov    -0x30(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x78(%rbp),%ecx
mov    -0x7c(%rbp),%edx
mov    -0x5c(%rbp),%esi
mov    -0x68(%rbp),%rdi
mov    -0x84(%rbp),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x2,%eax
mov    -0x40(%rbp),%rcx
xor    %edx,%edx
sub    -0x4c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x40(%rbp),%rdx
movzbl -0x1(%rdx),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
movzbl 0x3(%rdx),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0x4c(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
xor    %edx,%edx
sub    -0xc(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
movslq -0xc(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
movslq 0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x8c(%rbp)
mov    $0xff,%eax
cmp    -0x2c(%rbp),%eax
jge    168b <qc_imag_bay2rgb_gptm_fast+0x57b>
mov    $0xff,%eax
mov    %eax,-0x9c(%rbp)
jmp    1694 <qc_imag_bay2rgb_gptm_fast+0x584>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    16b1 <qc_imag_bay2rgb_gptm_fast+0x5a1>
xor    %eax,%eax
mov    %eax,-0xa0(%rbp)
jmp    16e4 <qc_imag_bay2rgb_gptm_fast+0x5d4>
mov    $0xff,%eax
cmp    -0x2c(%rbp),%eax
jge    16cf <qc_imag_bay2rgb_gptm_fast+0x5bf>
mov    $0xff,%eax
mov    %eax,-0xa4(%rbp)
jmp    16d8 <qc_imag_bay2rgb_gptm_fast+0x5c8>
mov    -0x2c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    $0xff,%eax
cmp    -0x30(%rbp),%eax
jge    170e <qc_imag_bay2rgb_gptm_fast+0x5fe>
mov    $0xff,%eax
mov    %eax,-0xac(%rbp)
jmp    1717 <qc_imag_bay2rgb_gptm_fast+0x607>
mov    -0x30(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1734 <qc_imag_bay2rgb_gptm_fast+0x624>
xor    %eax,%eax
mov    %eax,-0xb0(%rbp)
jmp    1767 <qc_imag_bay2rgb_gptm_fast+0x657>
mov    $0xff,%eax
cmp    -0x30(%rbp),%eax
jge    1752 <qc_imag_bay2rgb_gptm_fast+0x642>
mov    $0xff,%eax
mov    %eax,-0xb4(%rbp)
jmp    175b <qc_imag_bay2rgb_gptm_fast+0x64b>
mov    -0x30(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xa8(%rbp),%ecx
mov    -0x8c(%rbp),%edx
mov    -0x90(%rbp),%esi
mov    -0x98(%rbp),%rdi
mov    -0xb0(%rbp),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x40(%rbp),%rcx
xor    %edx,%edx
sub    -0xc(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x40(%rbp),%rdx
mov    -0xc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0xc(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
movslq -0x50(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
movzbl -0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    -0x34(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    -0x34(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    $0xff,%eax
cmp    -0x28(%rbp),%eax
jge    18a4 <qc_imag_bay2rgb_gptm_fast+0x794>
mov    $0xff,%eax
mov    %eax,-0xc4(%rbp)
jmp    18ad <qc_imag_bay2rgb_gptm_fast+0x79d>
mov    -0x28(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    18ca <qc_imag_bay2rgb_gptm_fast+0x7ba>
xor    %eax,%eax
mov    %eax,-0xc8(%rbp)
jmp    18fd <qc_imag_bay2rgb_gptm_fast+0x7ed>
mov    $0xff,%eax
cmp    -0x28(%rbp),%eax
jge    18e8 <qc_imag_bay2rgb_gptm_fast+0x7d8>
mov    $0xff,%eax
mov    %eax,-0xcc(%rbp)
jmp    18f1 <qc_imag_bay2rgb_gptm_fast+0x7e1>
mov    -0x28(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    $0xff,%eax
cmp    -0x2c(%rbp),%eax
jge    1927 <qc_imag_bay2rgb_gptm_fast+0x817>
mov    $0xff,%eax
mov    %eax,-0xd4(%rbp)
jmp    1930 <qc_imag_bay2rgb_gptm_fast+0x820>
mov    -0x2c(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    194d <qc_imag_bay2rgb_gptm_fast+0x83d>
xor    %eax,%eax
mov    %eax,-0xd8(%rbp)
jmp    1980 <qc_imag_bay2rgb_gptm_fast+0x870>
mov    $0xff,%eax
cmp    -0x2c(%rbp),%eax
jge    196b <qc_imag_bay2rgb_gptm_fast+0x85b>
mov    $0xff,%eax
mov    %eax,-0xdc(%rbp)
jmp    1974 <qc_imag_bay2rgb_gptm_fast+0x864>
mov    -0x2c(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd0(%rbp),%edx
mov    -0xb8(%rbp),%esi
mov    -0xc0(%rbp),%rdi
mov    -0xd8(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
mov    -0x40(%rbp),%rdx
movzbl 0x2(%rdx),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
movslq -0x4c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0x4c(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
movslq 0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    $0xff,%eax
cmp    -0x28(%rbp),%eax
jge    1a8a <qc_imag_bay2rgb_gptm_fast+0x97a>
mov    $0xff,%eax
mov    %eax,-0xec(%rbp)
jmp    1a93 <qc_imag_bay2rgb_gptm_fast+0x983>
mov    -0x28(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xec(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1ab0 <qc_imag_bay2rgb_gptm_fast+0x9a0>
xor    %eax,%eax
mov    %eax,-0xf0(%rbp)
jmp    1ae3 <qc_imag_bay2rgb_gptm_fast+0x9d3>
mov    $0xff,%eax
cmp    -0x28(%rbp),%eax
jge    1ace <qc_imag_bay2rgb_gptm_fast+0x9be>
mov    $0xff,%eax
mov    %eax,-0xf4(%rbp)
jmp    1ad7 <qc_imag_bay2rgb_gptm_fast+0x9c7>
mov    -0x28(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xf8(%rbp)
mov    $0xff,%eax
cmp    -0x30(%rbp),%eax
jge    1b24 <qc_imag_bay2rgb_gptm_fast+0xa14>
mov    $0xff,%eax
mov    %eax,-0x100(%rbp)
jmp    1b2d <qc_imag_bay2rgb_gptm_fast+0xa1d>
mov    -0x30(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1b4a <qc_imag_bay2rgb_gptm_fast+0xa3a>
xor    %eax,%eax
mov    %eax,-0x104(%rbp)
jmp    1b7d <qc_imag_bay2rgb_gptm_fast+0xa6d>
mov    $0xff,%eax
cmp    -0x30(%rbp),%eax
jge    1b68 <qc_imag_bay2rgb_gptm_fast+0xa58>
mov    $0xff,%eax
mov    %eax,-0x108(%rbp)
jmp    1b71 <qc_imag_bay2rgb_gptm_fast+0xa61>
mov    -0x30(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0xf8(%rbp),%ecx
mov    -0xfc(%rbp),%edx
mov    -0xe0(%rbp),%esi
mov    -0xe8(%rbp),%rdi
mov    -0x104(%rbp),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jne    13b8 <qc_imag_bay2rgb_gptm_fast+0x2a8>
mov    -0x48(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x4c(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jne    12aa <qc_imag_bay2rgb_gptm_fast+0x19a>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x48(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x48(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
movslq 0x10(%rbp),%rax
add    %rax,%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%r8
movzbl (%rax,%r8,1),%r8d
mov    $0x0,%al
call   1030 <qc_imag_writergb@plt>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jne    1cfb <qc_imag_bay2rgb_gptm_fast+0xbeb>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qc_imag_bay2rgb_gptm_fast>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rdx,%rbx
sar    %r8d
sar    %r9d
add    $0xfffffffe,%r9d
mov    %r9d,0x74(%rsp)
lea    (%rsi,%rsi,2),%eax
mov    %eax,0x8(%rsp)
movslq %esi,%r15
movslq 0x120(%rsp),%r14
movslq %ecx,%rcx
lea    0x1(%r15),%r13
lea    (%r14,%r14,1),%eax
cltq
mov    %rax,0x18(%rsp)
mov    %rcx,0x28(%rsp)
lea    (%r14,%rcx,1),%rax
mov    %rax,0x48(%rsp)
mov    %rdi,0x30(%rsp)
mov    %rdi,%rbp
mov    %rdx,0x50(%rsp)
mov    %r8d,0x24(%rsp)
mov    %r8d,%r12d
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%rbp),%edx
movzbl 0x0(%rbp),%ecx
movzbl 0x0(%rbp,%r15,1),%r8d
mov    %rbx,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
lea    (%rbx,%r14,1),%rdi
movzbl 0x1(%rbp),%edx
movzbl 0x0(%rbp),%ecx
movzbl 0x0(%rbp,%r15,1),%r8d
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x28(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
movzbl 0x1(%rbp),%edx
movzbl 0x0(%rbp,%r13,1),%ecx
movzbl 0x0(%rbp,%r15,1),%r8d
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x48(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
movzbl 0x1(%rbp),%edx
movzbl 0x0(%rbp,%r13,1),%ecx
movzbl 0x0(%rbp,%r15,1),%r8d
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
add    $0x2,%rbp
add    0x18(%rsp),%rbx
add    $0xffffffff,%r12d
jne    1180 <qc_imag_bay2rgb_gptm_fast+0x70>
lea    (%r15,%r15,1),%eax
mov    0x28(%rsp),%r11
lea    (%r11,%r11,1),%ecx
movslq %eax,%rdi
movslq %ecx,%rax
mov    0x50(%rsp),%r12
mov    %rax,0xd0(%rsp)
add    %rax,%r12
mov    %r15d,%eax
not    %eax
movslq %eax,%r8
mov    $0x1,%edx
mov    $0x1,%ecx
sub    %r15d,%ecx
movslq %ecx,%r9
sub    %edi,%edx
movslq %edx,%r10
mov    $0x2,%esi
sub    %r15d,%esi
movslq %esi,%rsi
lea    (%r15,%rdi,1),%rax
movslq 0x8(%rsp),%rbp
lea    (%rdi,%rdi,1),%rdx
mov    0x30(%rsp),%rbx
lea    0x4(%rbx,%rdx,1),%rcx
mov    %rcx,0xc8(%rsp)
lea    (%rbx,%rdx,1),%rcx
add    $0x1,%rcx
mov    %rcx,0xc0(%rsp)
add    %rdi,%rbp
lea    (%rbx,%rbp,1),%rcx
add    $0x2,%rcx
mov    %rcx,0xb8(%rsp)
lea    (%rax,%rbx,1),%rcx
mov    %rcx,0xb0(%rsp)
lea    (%rbx,%rax,1),%rcx
add    $0x4,%rcx
mov    %rcx,0x40(%rsp)
add    %rdi,%rsi
lea    (%rbx,%rsi,1),%rcx
add    $0x2,%rcx
mov    %rcx,0xa8(%rsp)
mov    %r13,0x58(%rsp)
lea    (%rdi,%r13,1),%rsi
lea    (%rbx,%rsi,1),%rcx
add    $0x2,%rcx
mov    %rcx,0x8(%rsp)
add    %rdi,%r10
lea    (%rbx,%r10,1),%rcx
add    $0x2,%rcx
mov    %rcx,0xa0(%rsp)
mov    %rdi,%rdx
sub    %r15,%rdx
lea    (%rdx,%rbx,1),%rcx
add    $0x2,%rcx
mov    %rcx,0x38(%rsp)
lea    0x2(%rbx,%rax,1),%rcx
mov    %rcx,0x10(%rsp)
add    %rbx,%rax
add    $0x1,%rax
mov    %rax,0x68(%rsp)
add    %rdi,%r9
lea    (%rbx,%r9,1),%rax
add    $0x2,%rax
mov    %rax,0x60(%rsp)
add    %rdi,%r8
lea    (%rbx,%r8,1),%rax
add    $0x2,%rax
mov    %rax,0x98(%rsp)
lea    (%rbx,%rdi,1),%r13
mov    %rdi,0xd8(%rsp)
lea    (%rbx,%rdi,2),%rbp
add    $0x3,%rbp
movslq 0x24(%rsp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0xe0(%rsp)
mov    0x18(%rsp),%rcx
mov    0x48(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x30(%rsp)
lea    (%r11,%rcx,1),%rax
mov    %rax,0x90(%rsp)
lea    (%r14,%rcx,1),%rax
mov    %rax,0x88(%rsp)
mov    %r15,%rbx
mov    %r14,%r15
mov    %rbx,0x80(%rsp)
mov    %r14,0x78(%rsp)
jmp    14ef <qc_imag_bay2rgb_gptm_fast+0x3df>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x3(%r13,%r15,2),%edx
movzbl 0x2(%r13,%r15,2),%ecx
mov    0x10(%rsp),%r12
movzbl (%r12,%r15,2),%r8d
mov    0x18(%rsp),%rax
lea    (%r14,%rax,1),%rdi
mov    0x120(%rsp),%ebx
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x88(%rsp),%rax
lea    (%r14,%rax,1),%rdi
movzbl 0x3(%r13,%r15,2),%edx
movzbl 0x2(%r13,%r15,2),%ecx
movzbl (%r12,%r15,2),%r8d
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x90(%rsp),%rax
lea    (%r14,%rax,1),%rdi
movzbl 0x3(%r13,%r15,2),%edx
mov    0x8(%rsp),%rbx
movzbl (%rbx,%r15,2),%ecx
movzbl (%r12,%r15,2),%r8d
mov    0x120(%rsp),%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
add    0x30(%rsp),%r14
movzbl 0x3(%r13,%r15,2),%edx
movzbl (%rbx,%r15,2),%ecx
movzbl (%r12,%r15,2),%r8d
mov    %r12,%r15
mov    %r14,%rdi
mov    0x120(%rsp),%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0xd8(%rsp),%rax
add    %rax,%r13
mov    0x50(%rsp),%r12
add    0xd0(%rsp),%r12
add    %rax,0xc8(%rsp)
add    %rax,%rbp
add    %rax,0xc0(%rsp)
add    %rax,0xb8(%rsp)
add    %rax,0xb0(%rsp)
add    %rax,0x40(%rsp)
add    %rax,0xa8(%rsp)
mov    %r15,%rcx
add    %rax,%rcx
mov    %rcx,0x10(%rsp)
add    %rax,%rbx
mov    %rbx,0x8(%rsp)
add    %rax,0xa0(%rsp)
add    %rax,0x38(%rsp)
add    %rax,0x68(%rsp)
add    %rax,0x60(%rsp)
add    %rax,0x98(%rsp)
addl   $0xffffffff,0x74(%rsp)
mov    0x80(%rsp),%rbx
mov    0x78(%rsp),%r15
je     18b8 <qc_imag_bay2rgb_gptm_fast+0x7a8>
movzbl 0x1(%r13),%edx
movzbl 0x0(%r13),%ecx
movzbl 0x0(%r13,%rbx,1),%r8d
mov    %r12,%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
lea    (%r12,%r15,1),%rdi
movzbl 0x1(%r13),%edx
movzbl 0x0(%r13),%ecx
movzbl 0x0(%r13,%rbx,1),%r8d
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x28(%rsp),%rax
mov    %rbx,%r14
lea    (%r12,%rax,1),%rbx
movzbl 0x1(%r13),%edx
mov    0x58(%rsp),%rax
movzbl 0x0(%r13,%rax,1),%ecx
movzbl 0x0(%r13,%r14,1),%r8d
mov    %rbx,%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
add    %r15,%rbx
movzbl 0x1(%r13),%edx
mov    0x58(%rsp),%rax
movzbl 0x0(%r13,%rax,1),%ecx
movzbl 0x0(%r13,%r14,1),%r8d
mov    %rbx,%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    %r12,0x50(%rsp)
mov    %r12,%rbx
xor    %r15d,%r15d
jmp    15b9 <qc_imag_bay2rgb_gptm_fast+0x4a9>
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    0x120(%rsp),%esi
mov    %r12d,%r8d
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
add    $0x1,%r15
mov    %r14,%rbx
cmp    %r15d,0xe0(%rsp)
je     13b0 <qc_imag_bay2rgb_gptm_fast+0x2a0>
movzbl 0x2(%r13,%r15,2),%ecx
lea    0x0(,%rcx,4),%eax
mov    0x98(%rsp),%rdx
movzbl (%rdx,%r15,2),%edx
mov    0x60(%rsp),%rsi
movzbl (%rsi,%r15,2),%esi
add    %edx,%esi
mov    0x68(%rsp),%rdx
movzbl (%rdx,%r15,2),%edx
add    %esi,%edx
mov    0x8(%rsp),%rsi
movzbl (%rsi,%r15,2),%esi
add    %edx,%esi
sub    %esi,%eax
movzbl 0x1(%r13,%r15,2),%edx
movzbl 0x3(%r13,%r15,2),%esi
add    %edx,%esi
lea    (%rax,%rsi,2),%edx
sar    $0x2,%edx
mov    0x38(%rsp),%rsi
movzbl (%rsi,%r15,2),%esi
mov    0x10(%rsp),%rdi
movzbl (%rdi,%r15,2),%edi
add    %esi,%edi
lea    (%rax,%rdi,2),%r8d
sar    $0x2,%r8d
cmp    $0xff,%edx
mov    $0xff,%r12d
cmovge %r12d,%edx
test   %edx,%edx
jns    1641 <qc_imag_bay2rgb_gptm_fast+0x531>
xor    %edx,%edx
mov    0x18(%rsp),%rax
lea    (%rbx,%rax,1),%r14
cmp    $0xff,%r8d
cmovge %r12d,%r8d
test   %r8d,%r8d
jns    165d <qc_imag_bay2rgb_gptm_fast+0x54d>
xor    %r8d,%r8d
mov    %r14,%rdi
mov    0x120(%rsp),%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
movzbl 0x3(%r13,%r15,2),%edx
lea    0x0(,%rdx,4),%eax
mov    0xa0(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
movzbl 0x1(%r13,%r15,2),%esi
add    %ecx,%esi
movzbl 0x5(%r13,%r15,2),%ecx
add    %esi,%ecx
movzbl 0x0(%rbp,%r15,2),%esi
add    %ecx,%esi
sub    %esi,%eax
mov    0x60(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
movzbl 0x2(%r13,%r15,2),%esi
add    %ecx,%esi
movzbl 0x4(%r13,%r15,2),%ecx
add    %esi,%ecx
mov    0x8(%rsp),%rsi
movzbl (%rsi,%r15,2),%esi
add    %ecx,%esi
mov    0x38(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
mov    0xa8(%rsp),%rdi
movzbl (%rdi,%r15,2),%edi
add    %ecx,%edi
mov    0x10(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
add    %edi,%ecx
mov    0x40(%rsp),%rdi
movzbl (%rdi,%r15,2),%edi
add    %ecx,%edi
lea    (%rax,%rsi,2),%ecx
lea    (%rax,%rdi,2),%r8d
sar    $0x3,%ecx
sar    $0x3,%r8d
cmp    $0xff,%ecx
cmovge %r12d,%ecx
test   %ecx,%ecx
jns    1717 <qc_imag_bay2rgb_gptm_fast+0x607>
xor    %ecx,%ecx
mov    0x88(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
cmp    $0xff,%r8d
cmovge %r12d,%r8d
test   %r8d,%r8d
jns    1736 <qc_imag_bay2rgb_gptm_fast+0x626>
xor    %r8d,%r8d
mov    0x120(%rsp),%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x10(%rsp),%rax
movzbl (%rax,%r15,2),%r8d
lea    0x0(,%r8,4),%eax
mov    0x38(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
mov    0xb0(%rsp),%rdx
movzbl (%rdx,%r15,2),%edx
add    %ecx,%edx
mov    0x40(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
add    %edx,%ecx
mov    0xb8(%rsp),%rdx
movzbl (%rdx,%r15,2),%edx
add    %ecx,%edx
sub    %edx,%eax
movzbl 0x1(%r13,%r15,2),%ecx
movzbl 0x3(%r13,%r15,2),%edx
add    %ecx,%edx
mov    0xc0(%rsp),%rcx
movzbl (%rcx,%r15,2),%ecx
add    %eax,%edx
add    %ecx,%edx
movzbl 0x0(%rbp,%r15,2),%ecx
add    %ecx,%edx
movzbl 0x2(%r13,%r15,2),%ecx
add    %eax,%ecx
mov    0x68(%rsp),%rax
movzbl (%rax,%r15,2),%eax
add    %eax,%ecx
mov    0x8(%rsp),%rax
movzbl (%rax,%r15,2),%eax
add    %eax,%ecx
movzbl -0x1(%rbp,%r15,2),%eax
add    %eax,%ecx
sar    $0x2,%edx
cmp    $0xff,%edx
jl     17eb <qc_imag_bay2rgb_gptm_fast+0x6db>
mov    $0xff,%edx
sar    $0x2,%ecx
test   %edx,%edx
jns    17f4 <qc_imag_bay2rgb_gptm_fast+0x6e4>
xor    %edx,%edx
cmp    $0xff,%ecx
jl     1801 <qc_imag_bay2rgb_gptm_fast+0x6f1>
mov    $0xff,%ecx
mov    0x90(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
test   %ecx,%ecx
jns    1813 <qc_imag_bay2rgb_gptm_fast+0x703>
xor    %ecx,%ecx
mov    0x120(%rsp),%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x8(%rsp),%rax
movzbl (%rax,%r15,2),%ecx
lea    0x0(,%rcx,4),%eax
movzbl 0x2(%r13,%r15,2),%edx
movzbl 0x4(%r13,%r15,2),%esi
add    %edx,%esi
movzbl -0x1(%rbp,%r15,2),%edx
add    %esi,%edx
mov    0xc8(%rsp),%rsi
movzbl (%rsi,%r15,2),%esi
add    %edx,%esi
sub    %esi,%eax
movzbl 0x3(%r13,%r15,2),%edx
movzbl 0x0(%rbp,%r15,2),%esi
add    %edx,%esi
lea    (%rax,%rsi,2),%edx
sar    $0x2,%edx
mov    0x10(%rsp),%rsi
movzbl (%rsi,%r15,2),%esi
mov    0x40(%rsp),%rdi
movzbl (%rdi,%r15,2),%edi
add    %esi,%edi
lea    (%rax,%rdi,2),%eax
sar    $0x2,%eax
cmp    $0xff,%edx
cmovge %r12d,%edx
test   %edx,%edx
jns    1899 <qc_imag_bay2rgb_gptm_fast+0x789>
xor    %edx,%edx
add    0x30(%rsp),%rbx
cmp    $0xff,%eax
cmovl  %eax,%r12d
test   %r12d,%r12d
jns    1590 <qc_imag_bay2rgb_gptm_fast+0x480>
xor    %r12d,%r12d
jmp    1590 <qc_imag_bay2rgb_gptm_fast+0x480>
mov    0x24(%rsp),%ebx
mov    0x80(%rsp),%r14
mov    0x58(%rsp),%rbp
nopl   0x0(%rax)
movzbl 0x1(%r13),%edx
movzbl 0x0(%r13),%ecx
movzbl 0x0(%r13,%r14,1),%r8d
mov    %r12,%rdi
mov    0x120(%rsp),%r15d
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x78(%rsp),%rax
lea    (%r12,%rax,1),%rdi
movzbl 0x1(%r13),%edx
movzbl 0x0(%r13),%ecx
movzbl 0x0(%r13,%r14,1),%r8d
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x28(%rsp),%rax
lea    (%r12,%rax,1),%rdi
movzbl 0x1(%r13),%edx
movzbl 0x0(%r13,%rbp,1),%ecx
movzbl 0x0(%r13,%r14,1),%r8d
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
mov    0x48(%rsp),%rax
lea    (%r12,%rax,1),%rdi
movzbl 0x1(%r13),%edx
movzbl 0x0(%r13,%rbp,1),%ecx
movzbl 0x0(%r13,%r14,1),%r8d
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <qc_imag_writergb@plt>
add    $0x2,%r13
add    0x18(%rsp),%r12
add    $0xffffffff,%ebx
jne    18d0 <qc_imag_bay2rgb_gptm_fast+0x7c0>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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