void y4m_422jpeg_420jpeg_helper(unsigned char *_dst, const unsigned char *_src,
                                int _c_w, int _c_h) {
  int y;
  int x;
  for (x = 0; x < _c_w; x++) {
    for (y = 0; y < ((_c_h) > (2) ? (2) : (_c_h)); y += 2) {
      _dst[(y >> 1) * _c_w] =
          (((0) < ((((64 * _src[0] +
                      78 * _src[((1) > (_c_h - 1) ? (_c_h - 1) : (1)) * _c_w] -
                      17 * _src[((2) > (_c_h - 1) ? (_c_h - 1) : (2)) * _c_w] +
                      3 * _src[((3) > (_c_h - 1) ? (_c_h - 1) : (3)) * _c_w] +
                      64) >>
                     7) > (255)
                        ? (255)
                        : ((64 * _src[0] +
                            78 * _src[((1) > (_c_h - 1) ? (_c_h - 1) : (1)) *
                                      _c_w] -
                            17 * _src[((2) > (_c_h - 1) ? (_c_h - 1) : (2)) *
                                      _c_w] +
                            3 * _src[((3) > (_c_h - 1) ? (_c_h - 1) : (3)) *
                                     _c_w] +
                            64) >>
                           7)))
                ? ((((64 * _src[0] +
                      78 * _src[((1) > (_c_h - 1) ? (_c_h - 1) : (1)) * _c_w] -
                      17 * _src[((2) > (_c_h - 1) ? (_c_h - 1) : (2)) * _c_w] +
                      3 * _src[((3) > (_c_h - 1) ? (_c_h - 1) : (3)) * _c_w] +
                      64) >>
                     7) > (255)
                        ? (255)
                        : ((64 * _src[0] +
                            78 * _src[((1) > (_c_h - 1) ? (_c_h - 1) : (1)) *
                                      _c_w] -
                            17 * _src[((2) > (_c_h - 1) ? (_c_h - 1) : (2)) *
                                      _c_w] +
                            3 * _src[((3) > (_c_h - 1) ? (_c_h - 1) : (3)) *
                                     _c_w] +
                            64) >>
                           7)))
                : (0)));
    }
    for (; y < _c_h - 3; y += 2) {
      _dst[(y >> 1) * _c_w] = ((
          (0) < ((((3 * (_src[(y - 2) * _c_w] + _src[(y + 3) * _c_w]) -
                    17 * (_src[(y - 1) * _c_w] + _src[(y + 2) * _c_w]) +
                    78 * (_src[y * _c_w] + _src[(y + 1) * _c_w]) + 64) >>
                   7) > (255)
                      ? (255)
                      : ((3 * (_src[(y - 2) * _c_w] + _src[(y + 3) * _c_w]) -
                          17 * (_src[(y - 1) * _c_w] + _src[(y + 2) * _c_w]) +
                          78 * (_src[y * _c_w] + _src[(y + 1) * _c_w]) + 64) >>
                         7)))
              ? ((((3 * (_src[(y - 2) * _c_w] + _src[(y + 3) * _c_w]) -
                    17 * (_src[(y - 1) * _c_w] + _src[(y + 2) * _c_w]) +
                    78 * (_src[y * _c_w] + _src[(y + 1) * _c_w]) + 64) >>
                   7) > (255)
                      ? (255)
                      : ((3 * (_src[(y - 2) * _c_w] + _src[(y + 3) * _c_w]) -
                          17 * (_src[(y - 1) * _c_w] + _src[(y + 2) * _c_w]) +
                          78 * (_src[y * _c_w] + _src[(y + 1) * _c_w]) + 64) >>
                         7)))
              : (0)));
    }
    for (; y < _c_h; y += 2) {
      _dst[(y >> 1) * _c_w] = ((
          (0) < ((((3 * (_src[(y - 2) * _c_w] + _src[(_c_h - 1) * _c_w]) -
                    17 * (_src[(y - 1) * _c_w] +
                          _src[((y + 2) > (_c_h - 1) ? (_c_h - 1) : (y + 2)) *
                               _c_w]) +
                    78 * (_src[y * _c_w] +
                          _src[((y + 1) > (_c_h - 1) ? (_c_h - 1) : (y + 1)) *
                               _c_w]) +
                    64) >>
                   7) > (255)
                      ? (255)
                      : ((3 * (_src[(y - 2) * _c_w] + _src[(_c_h - 1) * _c_w]) -
                          17 * (_src[(y - 1) * _c_w] +
                                _src[((y + 2) > (_c_h - 1) ? (_c_h - 1)
                                                           : (y + 2)) *
                                     _c_w]) +
                          78 * (_src[y * _c_w] +
                                _src[((y + 1) > (_c_h - 1) ? (_c_h - 1)
                                                           : (y + 1)) *
                                     _c_w]) +
                          64) >>
                         7)))
              ? ((((3 * (_src[(y - 2) * _c_w] + _src[(_c_h - 1) * _c_w]) -
                    17 * (_src[(y - 1) * _c_w] +
                          _src[((y + 2) > (_c_h - 1) ? (_c_h - 1) : (y + 2)) *
                               _c_w]) +
                    78 * (_src[y * _c_w] +
                          _src[((y + 1) > (_c_h - 1) ? (_c_h - 1) : (y + 1)) *
                               _c_w]) +
                    64) >>
                   7) > (255)
                      ? (255)
                      : ((3 * (_src[(y - 2) * _c_w] + _src[(_c_h - 1) * _c_w]) -
                          17 * (_src[(y - 1) * _c_w] +
                                _src[((y + 2) > (_c_h - 1) ? (_c_h - 1)
                                                           : (y + 2)) *
                                     _c_w]) +
                          78 * (_src[y * _c_w] +
                                _src[((y + 1) > (_c_h - 1) ? (_c_h - 1)
                                                           : (y + 1)) *
                                     _c_w]) +
                          64) >>
                         7)))
              : (0)));
    }
    _src++;
    _dst++;
  }
}


x86 assembly (clang, -O0):
<y4m_422jpeg_420jpeg_helper>:
push   %rbp
mov    %rsp,%rbp
sub    $0x148,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f85 <y4m_422jpeg_420jpeg_helper+0xe85>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x2,-0x18(%rbp)
jle    1150 <y4m_422jpeg_420jpeg_helper+0x50>
mov    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1156 <y4m_422jpeg_420jpeg_helper+0x56>
mov    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    16ac <y4m_422jpeg_420jpeg_helper+0x5ac>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x6,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jle    119a <y4m_422jpeg_420jpeg_helper+0x9a>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a7 <y4m_422jpeg_420jpeg_helper+0xa7>
mov    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a7 <y4m_422jpeg_420jpeg_helper+0xa7>
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x2,%eax
cmp    %ecx,%eax
jle    11ed <y4m_422jpeg_420jpeg_helper+0xed>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11fa <y4m_422jpeg_420jpeg_helper+0xfa>
mov    $0x2,%eax
mov    %eax,-0x48(%rbp)
jmp    11fa <y4m_422jpeg_420jpeg_helper+0xfa>
mov    -0x44(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x3,%eax
cmp    %ecx,%eax
jle    1240 <y4m_422jpeg_420jpeg_helper+0x140>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    124d <y4m_422jpeg_420jpeg_helper+0x14d>
mov    $0x3,%eax
mov    %eax,-0x58(%rbp)
jmp    124d <y4m_422jpeg_420jpeg_helper+0x14d>
mov    -0x54(%rbp),%eax
mov    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1285 <y4m_422jpeg_420jpeg_helper+0x185>
mov    $0xff,%eax
mov    %eax,-0x5c(%rbp)
jmp    13a6 <y4m_422jpeg_420jpeg_helper+0x2a6>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x6,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jle    12bb <y4m_422jpeg_420jpeg_helper+0x1bb>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12c8 <y4m_422jpeg_420jpeg_helper+0x1c8>
mov    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12c8 <y4m_422jpeg_420jpeg_helper+0x1c8>
mov    -0x6c(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x2,%eax
cmp    %ecx,%eax
jle    130e <y4m_422jpeg_420jpeg_helper+0x20e>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    131b <y4m_422jpeg_420jpeg_helper+0x21b>
mov    $0x2,%eax
mov    %eax,-0x80(%rbp)
jmp    131b <y4m_422jpeg_420jpeg_helper+0x21b>
mov    -0x7c(%rbp),%eax
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x3,%eax
cmp    %ecx,%eax
jle    136a <y4m_422jpeg_420jpeg_helper+0x26a>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    137a <y4m_422jpeg_420jpeg_helper+0x27a>
mov    $0x3,%eax
mov    %eax,-0x90(%rbp)
jmp    137a <y4m_422jpeg_420jpeg_helper+0x27a>
mov    -0x8c(%rbp),%eax
mov    -0x88(%rbp),%rcx
mov    -0x90(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1675 <y4m_422jpeg_420jpeg_helper+0x575>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x6,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jle    13f2 <y4m_422jpeg_420jpeg_helper+0x2f2>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1402 <y4m_422jpeg_420jpeg_helper+0x302>
mov    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1402 <y4m_422jpeg_420jpeg_helper+0x302>
mov    -0x9c(%rbp),%eax
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x2,%eax
cmp    %ecx,%eax
jle    145a <y4m_422jpeg_420jpeg_helper+0x35a>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    146a <y4m_422jpeg_420jpeg_helper+0x36a>
mov    $0x2,%eax
mov    %eax,-0xb0(%rbp)
jmp    146a <y4m_422jpeg_420jpeg_helper+0x36a>
mov    -0xac(%rbp),%eax
mov    -0xa8(%rbp),%rcx
mov    -0xb0(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x3,%eax
cmp    %ecx,%eax
jle    14c2 <y4m_422jpeg_420jpeg_helper+0x3c2>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    14d2 <y4m_422jpeg_420jpeg_helper+0x3d2>
mov    $0x3,%eax
mov    %eax,-0xc0(%rbp)
jmp    14d2 <y4m_422jpeg_420jpeg_helper+0x3d2>
mov    -0xbc(%rbp),%eax
mov    -0xb8(%rbp),%rcx
mov    -0xc0(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1516 <y4m_422jpeg_420jpeg_helper+0x416>
mov    $0xff,%eax
mov    %eax,-0xc4(%rbp)
jmp    1664 <y4m_422jpeg_420jpeg_helper+0x564>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x6,%eax
mov    %eax,-0xd4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jle    1555 <y4m_422jpeg_420jpeg_helper+0x455>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1565 <y4m_422jpeg_420jpeg_helper+0x465>
mov    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1565 <y4m_422jpeg_420jpeg_helper+0x465>
mov    -0xd4(%rbp),%eax
mov    -0xd0(%rbp),%rcx
mov    -0xd8(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x2,%eax
cmp    %ecx,%eax
jle    15bd <y4m_422jpeg_420jpeg_helper+0x4bd>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    15cd <y4m_422jpeg_420jpeg_helper+0x4cd>
mov    $0x2,%eax
mov    %eax,-0xe8(%rbp)
jmp    15cd <y4m_422jpeg_420jpeg_helper+0x4cd>
mov    -0xe4(%rbp),%eax
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xf4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x3,%eax
cmp    %ecx,%eax
jle    1625 <y4m_422jpeg_420jpeg_helper+0x525>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    1635 <y4m_422jpeg_420jpeg_helper+0x535>
mov    $0x3,%eax
mov    %eax,-0xf8(%rbp)
jmp    1635 <y4m_422jpeg_420jpeg_helper+0x535>
mov    -0xf4(%rbp),%eax
mov    -0xf0(%rbp),%rcx
mov    -0xf8(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    1682 <y4m_422jpeg_420jpeg_helper+0x582>
xor    %eax,%eax
mov    %eax,-0xfc(%rbp)
jmp    1682 <y4m_422jpeg_420jpeg_helper+0x582>
mov    -0xfc(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sar    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1133 <y4m_422jpeg_420jpeg_helper+0x33>
jmp    16b1 <y4m_422jpeg_420jpeg_helper+0x5b1>
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    19ac <y4m_422jpeg_420jpeg_helper+0x8ac>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x3,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x2,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1771 <y4m_422jpeg_420jpeg_helper+0x671>
mov    $0xff,%eax
mov    %eax,-0x100(%rbp)
jmp    180b <y4m_422jpeg_420jpeg_helper+0x70b>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x3,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x2,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1975 <y4m_422jpeg_420jpeg_helper+0x875>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x3,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x2,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    18ca <y4m_422jpeg_420jpeg_helper+0x7ca>
mov    $0xff,%eax
mov    %eax,-0x104(%rbp)
jmp    1964 <y4m_422jpeg_420jpeg_helper+0x864>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x3,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x2,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
mov    %eax,-0x108(%rbp)
jmp    1982 <y4m_422jpeg_420jpeg_helper+0x882>
xor    %eax,%eax
mov    %eax,-0x108(%rbp)
jmp    1982 <y4m_422jpeg_420jpeg_helper+0x882>
mov    -0x108(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sar    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    16b1 <y4m_422jpeg_420jpeg_helper+0x5b1>
jmp    19b1 <y4m_422jpeg_420jpeg_helper+0x8b1>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1f5f <y4m_422jpeg_420jpeg_helper+0xe5f>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x118(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x114(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1a3d <y4m_422jpeg_420jpeg_helper+0x93d>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x11c(%rbp)
jmp    1a49 <y4m_422jpeg_420jpeg_helper+0x949>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x118(%rbp),%eax
mov    -0x114(%rbp),%ecx
mov    -0x110(%rbp),%rdx
mov    -0x11c(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x130(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1ac2 <y4m_422jpeg_420jpeg_helper+0x9c2>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1ace <y4m_422jpeg_420jpeg_helper+0x9ce>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x130(%rbp),%eax
mov    -0x12c(%rbp),%ecx
mov    -0x128(%rbp),%rdx
mov    -0x134(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1b1a <y4m_422jpeg_420jpeg_helper+0xa1a>
mov    $0xff,%eax
mov    %eax,-0x138(%rbp)
jmp    1c62 <y4m_422jpeg_420jpeg_helper+0xb62>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x148(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x144(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1b9a <y4m_422jpeg_420jpeg_helper+0xa9a>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14c(%rbp)
jmp    1ba6 <y4m_422jpeg_420jpeg_helper+0xaa6>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x148(%rbp),%eax
mov    -0x144(%rbp),%ecx
mov    -0x140(%rbp),%rdx
mov    -0x14c(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x160(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1c1f <y4m_422jpeg_420jpeg_helper+0xb1f>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x164(%rbp)
jmp    1c2b <y4m_422jpeg_420jpeg_helper+0xb2b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x164(%rbp)
mov    -0x160(%rbp),%eax
mov    -0x15c(%rbp),%ecx
mov    -0x158(%rbp),%rdx
mov    -0x164(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1f28 <y4m_422jpeg_420jpeg_helper+0xe28>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x178(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x174(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1cf2 <y4m_422jpeg_420jpeg_helper+0xbf2>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    1cfe <y4m_422jpeg_420jpeg_helper+0xbfe>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x17c(%rbp)
mov    -0x178(%rbp),%eax
mov    -0x174(%rbp),%ecx
mov    -0x170(%rbp),%rdx
mov    -0x17c(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x190(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x18c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1d77 <y4m_422jpeg_420jpeg_helper+0xc77>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1d83 <y4m_422jpeg_420jpeg_helper+0xc83>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
mov    -0x190(%rbp),%eax
mov    -0x18c(%rbp),%ecx
mov    -0x188(%rbp),%rdx
mov    -0x194(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1dcf <y4m_422jpeg_420jpeg_helper+0xccf>
mov    $0xff,%eax
mov    %eax,-0x198(%rbp)
jmp    1f17 <y4m_422jpeg_420jpeg_helper+0xe17>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
imul   -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
imul   $0x3,%eax,%eax
mov    %eax,-0x1a8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1e4f <y4m_422jpeg_420jpeg_helper+0xd4f>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1ac(%rbp)
jmp    1e5b <y4m_422jpeg_420jpeg_helper+0xd5b>
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x1a8(%rbp),%eax
mov    -0x1a4(%rbp),%ecx
mov    -0x1a0(%rbp),%rdx
mov    -0x1ac(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x1bc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1ed4 <y4m_422jpeg_420jpeg_helper+0xdd4>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    1ee0 <y4m_422jpeg_420jpeg_helper+0xde0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x1c0(%rbp),%eax
mov    -0x1bc(%rbp),%ecx
mov    -0x1b8(%rbp),%rdx
mov    -0x1c4(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
imul   $0x4e,%ecx,%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x198(%rbp)
mov    -0x198(%rbp),%eax
mov    %eax,-0x1c8(%rbp)
jmp    1f35 <y4m_422jpeg_420jpeg_helper+0xe35>
xor    %eax,%eax
mov    %eax,-0x1c8(%rbp)
jmp    1f35 <y4m_422jpeg_420jpeg_helper+0xe35>
mov    -0x1c8(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sar    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    19b1 <y4m_422jpeg_420jpeg_helper+0x8b1>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1120 <y4m_422jpeg_420jpeg_helper+0x20>
add    $0x148,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<y4m_422jpeg_420jpeg_helper>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x60(%rsp)
mov    %rdi,-0x68(%rsp)
test   %edx,%edx
jle    1469 <y4m_422jpeg_420jpeg_helper+0x369>
mov    %edx,%r8d
lea    -0x1(%rcx),%eax
test   %eax,%eax
mov    $0x1,%esi
cmovle %eax,%esi
imul   %edx,%esi
cmp    $0x2,%eax
mov    $0x2,%edx
cmovl  %eax,%edx
movslq %esi,%rsi
mov    %rsi,-0x38(%rsp)
imul   %r8d,%edx
movslq %edx,%rdx
mov    %rdx,-0x40(%rsp)
cmp    $0x3,%eax
mov    $0x3,%edx
cmovl  %eax,%edx
imul   %r8d,%edx
movslq %edx,%rdx
mov    %rdx,-0x48(%rsp)
lea    -0x3(%rcx),%edx
movslq %eax,%rsi
mov    %rsi,-0x18(%rsp)
imul   %r8d,%eax
cltq
mov    %rax,-0x20(%rsp)
mov    %r8d,%r15d
mov    %edx,-0x6c(%rsp)
movslq %edx,%r10
movslq %ecx,%rax
mov    %rax,-0x28(%rsp)
lea    (%r15,%r15,1),%r12
xor    %edi,%edi
mov    $0xff,%ebp
xor    %r9d,%r9d
mov    -0x68(%rsp),%rax
mov    %rax,-0x78(%rsp)
mov    -0x60(%rsp),%rax
mov    %rax,-0x80(%rsp)
mov    %r15,-0x58(%rsp)
mov    %r10,-0x30(%rsp)
mov    %rcx,-0x50(%rsp)
mov    %r8d,-0x70(%rsp)
jmp    11fd <y4m_422jpeg_420jpeg_helper+0xfd>
cs nopw 0x0(%rax,%rax,1)
nop
addq   $0x1,-0x80(%rsp)
addq   $0x1,-0x78(%rsp)
add    $0x1,%r9
cmp    %r8d,%r9d
mov    -0x50(%rsp),%rcx
mov    -0x58(%rsp),%r15
mov    -0x30(%rsp),%r10
mov    $0xff,%ebp
je     1469 <y4m_422jpeg_420jpeg_helper+0x369>
mov    $0x0,%r11d
test   %ecx,%ecx
jle    1265 <y4m_422jpeg_420jpeg_helper+0x165>
mov    -0x80(%rsp),%rbx
movzbl (%rbx),%eax
shl    $0x6,%eax
mov    -0x38(%rsp),%rdx
movzbl (%rbx,%rdx,1),%edx
imul   $0x4e,%edx,%esi
add    %eax,%esi
mov    -0x40(%rsp),%rax
movzbl (%rbx,%rax,1),%eax
mov    %eax,%edx
shl    $0x4,%edx
add    %eax,%edx
sub    %edx,%esi
mov    -0x48(%rsp),%rax
movzbl (%rbx,%rax,1),%eax
lea    (%rax,%rax,2),%eax
lea    (%rsi,%rax,1),%edx
add    $0x40,%edx
add    %eax,%esi
shr    $0x7,%edx
cmp    $0x7fc0,%esi
cmovge %ebp,%edx
cmp    $0x40,%esi
cmovl  %edi,%edx
mov    -0x78(%rsp),%rax
mov    %dl,(%rax)
mov    $0x2,%r11d
cmp    -0x6c(%rsp),%r11d
jge    1356 <y4m_422jpeg_420jpeg_helper+0x256>
mov    %r11d,%r11d
mov    %r10,%rcx
lea    0x1(%r11),%r10
imul   %r15,%r10
mov    -0x60(%rsp),%rax
add    %rax,%r10
mov    %r15,%r13
imul   %r11,%r13
add    %rax,%r13
lea    0x3(%r11),%r8
imul   %r15,%r8
add    %rax,%r8
lea    -0x2(%r11),%r14
imul   %r15,%r14
add    %rax,%r14
mov    %r15,%rbx
lea    -0x1(%r11),%rdi
imul   %r15,%rdi
add    %rax,%rdi
mov    %r11,%rbp
shr    %rbp
imul   %r15,%rbp
add    -0x68(%rsp),%rbp
lea    0x2(%r11),%r15
imul   %rbx,%r15
add    %rax,%r15
xchg   %ax,%ax
movzbl (%r14,%r9,1),%eax
movzbl (%r8,%r9,1),%edx
add    %eax,%edx
lea    (%rdx,%rdx,2),%eax
movzbl (%rdi,%r9,1),%edx
movzbl (%r15,%r9,1),%esi
add    %edx,%esi
mov    %esi,%edx
shl    $0x4,%edx
add    %esi,%edx
sub    %edx,%eax
movzbl 0x0(%r13,%r9,1),%edx
movzbl (%r10,%r9,1),%esi
add    %edx,%esi
imul   $0x4e,%esi,%edx
lea    (%rax,%rdx,1),%esi
add    $0x40,%esi
add    %edx,%eax
add    $0x2,%r11
shr    $0x7,%esi
cmp    $0x7fc0,%eax
mov    $0xff,%edx
cmovge %edx,%esi
cmp    $0x40,%eax
mov    $0x0,%eax
cmovl  %eax,%esi
mov    %sil,0x0(%rbp,%r9,1)
add    %r12,%r10
add    %r12,%r13
add    %r12,%r8
add    %r12,%r14
add    %r12,%rdi
add    %rbx,%rbp
add    %r12,%r15
cmp    %rcx,%r11
jl     12d0 <y4m_422jpeg_420jpeg_helper+0x1d0>
mov    -0x70(%rsp),%r8d
xor    %edi,%edi
mov    -0x50(%rsp),%rcx
cmp    %ecx,%r11d
jge    11d0 <y4m_422jpeg_420jpeg_helper+0xd0>
movslq %r11d,%r14
mov    -0x58(%rsp),%rax
mov    %rax,%rcx
imul   %r14,%rcx
mov    %rcx,-0x8(%rsp)
lea    -0x2(%r14),%rcx
imul   %rax,%rcx
mov    %rcx,-0x10(%rsp)
lea    -0x1(%r14),%r13
imul   %rax,%r13
mov    %r11d,%r11d
xor    %ecx,%ecx
mov    -0x80(%rsp),%rsi
jmp    13ce <y4m_422jpeg_420jpeg_helper+0x2ce>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x40,%edi
mov    $0x0,%edi
cmovl  %edi,%edx
shr    %ebp
imul   %r8d,%ebp
movslq %ebp,%rax
mov    -0x78(%rsp),%rbx
mov    %dl,(%rbx,%rax,1)
add    %r12,%rsi
add    $0x2,%rcx
cmp    -0x28(%rsp),%r15
jge    11d0 <y4m_422jpeg_420jpeg_helper+0xd0>
mov    -0x10(%rsp),%rax
movzbl (%rsi,%rax,1),%eax
mov    -0x20(%rsp),%rdx
mov    -0x80(%rsp),%r10
movzbl (%r10,%rdx,1),%edx
add    %eax,%edx
lea    (%rdx,%rdx,2),%ebx
movzbl (%rsi,%r13,1),%eax
lea    (%r14,%rcx,1),%r15
add    $0x2,%r15
lea    (%r11,%rcx,1),%ebp
mov    -0x18(%rsp),%rdi
cmp    %rdi,%r15
lea    0x2(%r11,%rcx,1),%edx
cmovg  %edi,%edx
imul   %r8d,%edx
movslq %edx,%rdx
movzbl (%r10,%rdx,1),%edx
add    %eax,%edx
mov    %edx,%eax
shl    $0x4,%eax
add    %edx,%eax
sub    %eax,%ebx
mov    -0x8(%rsp),%rax
movzbl (%rsi,%rax,1),%eax
mov    %ebp,%edx
or     $0x1,%edx
cmp    %edi,%edx
cmovg  %edi,%edx
imul   %r8d,%edx
movslq %edx,%rdx
movzbl (%r10,%rdx,1),%edx
add    %eax,%edx
imul   $0x4e,%edx,%eax
lea    (%rbx,%rax,1),%edi
mov    $0xff,%edx
cmp    $0x7fc0,%edi
jge    13a0 <y4m_422jpeg_420jpeg_helper+0x2a0>
lea    (%rbx,%rax,1),%edx
add    $0x40,%edx
shr    $0x7,%edx
jmp    13a0 <y4m_422jpeg_420jpeg_helper+0x2a0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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