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


x86 assembly (clang, -O0):
<y4m_42xmpeg2_42xjpeg_helper>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1fb8 <y4m_42xmpeg2_42xjpeg_helper+0xeb8>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x2,-0x14(%rbp)
jle    1150 <y4m_42xmpeg2_42xjpeg_helper+0x50>
mov    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1156 <y4m_42xmpeg2_42xjpeg_helper+0x56>
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    17e7 <y4m_42xmpeg2_42xjpeg_helper+0x6e7>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1192 <y4m_42xmpeg2_42xjpeg_helper+0x92>
xor    %eax,%eax
mov    %eax,-0x38(%rbp)
jmp    119b <y4m_42xmpeg2_42xjpeg_helper+0x9b>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    11ef <y4m_42xmpeg2_42xjpeg_helper+0xef>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11f8 <y4m_42xmpeg2_42xjpeg_helper+0xf8>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    123b <y4m_42xmpeg2_42xjpeg_helper+0x13b>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1244 <y4m_42xmpeg2_42xjpeg_helper+0x144>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1287 <y4m_42xmpeg2_42xjpeg_helper+0x187>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1290 <y4m_42xmpeg2_42xjpeg_helper+0x190>
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    12c1 <y4m_42xmpeg2_42xjpeg_helper+0x1c1>
mov    $0xff,%eax
mov    %eax,-0x6c(%rbp)
jmp    1448 <y4m_42xmpeg2_42xjpeg_helper+0x348>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    12ef <y4m_42xmpeg2_42xjpeg_helper+0x1ef>
xor    %eax,%eax
mov    %eax,-0x80(%rbp)
jmp    12f8 <y4m_42xmpeg2_42xjpeg_helper+0x1f8>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1355 <y4m_42xmpeg2_42xjpeg_helper+0x255>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1361 <y4m_42xmpeg2_42xjpeg_helper+0x261>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x88(%rbp),%rcx
mov    -0x90(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    13b6 <y4m_42xmpeg2_42xjpeg_helper+0x2b6>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    13c2 <y4m_42xmpeg2_42xjpeg_helper+0x2c2>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1417 <y4m_42xmpeg2_42xjpeg_helper+0x317>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1423 <y4m_42xmpeg2_42xjpeg_helper+0x323>
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xa8(%rbp),%rcx
mov    -0xb0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    17b9 <y4m_42xmpeg2_42xjpeg_helper+0x6b9>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    148c <y4m_42xmpeg2_42xjpeg_helper+0x38c>
xor    %eax,%eax
mov    %eax,-0xc0(%rbp)
jmp    1498 <y4m_42xmpeg2_42xjpeg_helper+0x398>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0xb8(%rbp),%rcx
mov    -0xc0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    14fe <y4m_42xmpeg2_42xjpeg_helper+0x3fe>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    150a <y4m_42xmpeg2_42xjpeg_helper+0x40a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0xc8(%rbp),%rcx
mov    -0xd0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    155f <y4m_42xmpeg2_42xjpeg_helper+0x45f>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    156b <y4m_42xmpeg2_42xjpeg_helper+0x46b>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xe0(%rbp)
mov    -0xdc(%rbp),%eax
mov    -0xd8(%rbp),%rcx
mov    -0xe0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    15c0 <y4m_42xmpeg2_42xjpeg_helper+0x4c0>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    15cc <y4m_42xmpeg2_42xjpeg_helper+0x4cc>
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xec(%rbp),%eax
mov    -0xe8(%rbp),%rcx
mov    -0xf0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1609 <y4m_42xmpeg2_42xjpeg_helper+0x509>
mov    $0xff,%eax
mov    %eax,-0xf4(%rbp)
jmp    17a8 <y4m_42xmpeg2_42xjpeg_helper+0x6a8>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x104(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1640 <y4m_42xmpeg2_42xjpeg_helper+0x540>
xor    %eax,%eax
mov    %eax,-0x108(%rbp)
jmp    164c <y4m_42xmpeg2_42xjpeg_helper+0x54c>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x108(%rbp)
mov    -0x104(%rbp),%eax
mov    -0x100(%rbp),%rcx
mov    -0x108(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x114(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    16b2 <y4m_42xmpeg2_42xjpeg_helper+0x5b2>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    16be <y4m_42xmpeg2_42xjpeg_helper+0x5be>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x110(%rbp),%rcx
mov    -0x118(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x124(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1713 <y4m_42xmpeg2_42xjpeg_helper+0x613>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    171f <y4m_42xmpeg2_42xjpeg_helper+0x61f>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x128(%rbp)
mov    -0x124(%rbp),%eax
mov    -0x120(%rbp),%rcx
mov    -0x128(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x134(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1774 <y4m_42xmpeg2_42xjpeg_helper+0x674>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1780 <y4m_42xmpeg2_42xjpeg_helper+0x680>
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x138(%rbp)
mov    -0x134(%rbp),%eax
mov    -0x130(%rbp),%rcx
mov    -0x138(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
mov    %eax,-0x13c(%rbp)
jmp    17c6 <y4m_42xmpeg2_42xjpeg_helper+0x6c6>
xor    %eax,%eax
mov    %eax,-0x13c(%rbp)
jmp    17c6 <y4m_42xmpeg2_42xjpeg_helper+0x6c6>
mov    -0x13c(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1133 <y4m_42xmpeg2_42xjpeg_helper+0x33>
jmp    17ec <y4m_42xmpeg2_42xjpeg_helper+0x6ec>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1a8e <y4m_42xmpeg2_42xjpeg_helper+0x98e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1898 <y4m_42xmpeg2_42xjpeg_helper+0x798>
mov    $0xff,%eax
mov    %eax,-0x140(%rbp)
jmp    191e <y4m_42xmpeg2_42xjpeg_helper+0x81e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1a60 <y4m_42xmpeg2_42xjpeg_helper+0x960>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    19c9 <y4m_42xmpeg2_42xjpeg_helper+0x8c9>
mov    $0xff,%eax
mov    %eax,-0x144(%rbp)
jmp    1a4f <y4m_42xmpeg2_42xjpeg_helper+0x94f>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
mov    %eax,-0x148(%rbp)
jmp    1a6d <y4m_42xmpeg2_42xjpeg_helper+0x96d>
xor    %eax,%eax
mov    %eax,-0x148(%rbp)
jmp    1a6d <y4m_42xmpeg2_42xjpeg_helper+0x96d>
mov    -0x148(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    17ec <y4m_42xmpeg2_42xjpeg_helper+0x6ec>
jmp    1a93 <y4m_42xmpeg2_42xjpeg_helper+0x993>
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f88 <y4m_42xmpeg2_42xjpeg_helper+0xe88>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x154(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1b10 <y4m_42xmpeg2_42xjpeg_helper+0xa10>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1b1c <y4m_42xmpeg2_42xjpeg_helper+0xa1c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
mov    -0x154(%rbp),%eax
mov    -0x150(%rbp),%rcx
mov    -0x158(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x164(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1b71 <y4m_42xmpeg2_42xjpeg_helper+0xa71>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    1b7d <y4m_42xmpeg2_42xjpeg_helper+0xa7d>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x168(%rbp)
mov    -0x164(%rbp),%eax
mov    -0x160(%rbp),%rcx
mov    -0x168(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1bd0 <y4m_42xmpeg2_42xjpeg_helper+0xad0>
mov    $0xff,%eax
mov    %eax,-0x16c(%rbp)
jmp    1cec <y4m_42xmpeg2_42xjpeg_helper+0xbec>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x17c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1c41 <y4m_42xmpeg2_42xjpeg_helper+0xb41>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    1c4d <y4m_42xmpeg2_42xjpeg_helper+0xb4d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
mov    -0x17c(%rbp),%eax
mov    -0x178(%rbp),%rcx
mov    -0x180(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x18c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1ca2 <y4m_42xmpeg2_42xjpeg_helper+0xba2>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    1cae <y4m_42xmpeg2_42xjpeg_helper+0xbae>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x190(%rbp)
mov    -0x18c(%rbp),%eax
mov    -0x188(%rbp),%rcx
mov    -0x190(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1f5a <y4m_42xmpeg2_42xjpeg_helper+0xe5a>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x19c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1d6d <y4m_42xmpeg2_42xjpeg_helper+0xc6d>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    1d79 <y4m_42xmpeg2_42xjpeg_helper+0xc79>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
mov    -0x19c(%rbp),%eax
mov    -0x198(%rbp),%rcx
mov    -0x1a0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1dce <y4m_42xmpeg2_42xjpeg_helper+0xcce>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1b0(%rbp)
jmp    1dda <y4m_42xmpeg2_42xjpeg_helper+0xcda>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1b0(%rbp)
mov    -0x1ac(%rbp),%eax
mov    -0x1a8(%rbp),%rcx
mov    -0x1b0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1e2d <y4m_42xmpeg2_42xjpeg_helper+0xd2d>
mov    $0xff,%eax
mov    %eax,-0x1b4(%rbp)
jmp    1f49 <y4m_42xmpeg2_42xjpeg_helper+0xe49>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1e9e <y4m_42xmpeg2_42xjpeg_helper+0xd9e>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    1eaa <y4m_42xmpeg2_42xjpeg_helper+0xdaa>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
mov    -0x1c4(%rbp),%eax
mov    -0x1c0(%rbp),%rcx
mov    -0x1c8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1eff <y4m_42xmpeg2_42xjpeg_helper+0xdff>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1d8(%rbp)
jmp    1f0b <y4m_42xmpeg2_42xjpeg_helper+0xe0b>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1d8(%rbp)
mov    -0x1d4(%rbp),%eax
mov    -0x1d0(%rbp),%rcx
mov    -0x1d8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x1b4(%rbp)
mov    -0x1b4(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
jmp    1f67 <y4m_42xmpeg2_42xjpeg_helper+0xe67>
xor    %eax,%eax
mov    %eax,-0x1dc(%rbp)
jmp    1f67 <y4m_42xmpeg2_42xjpeg_helper+0xe67>
mov    -0x1dc(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1a93 <y4m_42xmpeg2_42xjpeg_helper+0x993>
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1120 <y4m_42xmpeg2_42xjpeg_helper+0x20>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<y4m_42xmpeg2_42xjpeg_helper>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x18(%rsp)
mov    %rdi,-0x20(%rsp)
mov    %ecx,-0x24(%rsp)
test   %ecx,%ecx
jle    193a <y4m_42xmpeg2_42xjpeg_helper+0x83a>
movslq %edx,%rcx
lea    -0x1(%rcx),%r15
lea    -0x3(%rcx),%r11d
xor    %r8d,%r8d
cmp    $0x2,%ecx
setge  %r8b
add    $0x1,%r8d
lea    0x3(%r11),%rax
mov    %rax,-0x10(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
xor    %r12d,%r12d
pxor   %xmm15,%xmm15
movdqa 0xf02(%rip),%xmm14
movdqa 0xe99(%rip),%xmm8
movdqa 0xea0(%rip),%xmm9
movdqa 0xea7(%rip),%xmm10
movdqa 0xeae(%rip),%xmm11
movdqa 0xeb5(%rip),%xmm12
movdqa 0xebc(%rip),%xmm13
xor    %eax,%eax
mov    %rax,-0x30(%rsp)
mov    -0x20(%rsp),%r13
mov    -0x18(%rsp),%r14
mov    %r11,-0x38(%rsp)
mov    %edx,-0x28(%rsp)
jmp    11ce <y4m_42xmpeg2_42xjpeg_helper+0xce>
add    %rcx,%r13
add    %rcx,%r14
mov    -0x30(%rsp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rsp)
cmp    -0x24(%rsp),%eax
je     193a <y4m_42xmpeg2_42xjpeg_helper+0x83a>
mov    $0x0,%r10d
test   %edx,%edx
jle    1273 <y4m_42xmpeg2_42xjpeg_helper+0x173>
xor    %ebx,%ebx
jmp    11f4 <y4m_42xmpeg2_42xjpeg_helper+0xf4>
cmp    $0x40,%edi
cmovl  %r12d,%ebp
mov    %bpl,0x0(%r13,%rbx,1)
mov    %r9,%rbx
cmp    %r8,%r9
je     1270 <y4m_42xmpeg2_42xjpeg_helper+0x170>
movzbl (%r14),%eax
imul   $0xfffffff3,%eax,%eax
movzbl (%r14,%rbx,1),%esi
imul   $0x72,%esi,%edi
add    %eax,%edi
lea    0x1(%rbx),%r9
cmp    %r15,%rbx
mov    %r15d,%eax
cmovl  %r9d,%eax
cltq
movzbl (%r14,%rax,1),%eax
imul   $0x23,%eax,%esi
add    %edi,%esi
lea    0x2(%rbx),%rax
cmp    %r15,%rax
cmovg  %r15d,%eax
cltq
movzbl (%r14,%rax,1),%eax
lea    (%rax,%rax,8),%eax
sub    %eax,%esi
lea    0x3(%rbx),%rax
cmp    %r15,%rax
cmovg  %r15d,%eax
cltq
movzbl (%r14,%rax,1),%eax
lea    (%rsi,%rax,1),%edi
mov    $0xff,%ebp
cmp    $0x7fc0,%edi
jge    11e0 <y4m_42xmpeg2_42xjpeg_helper+0xe0>
lea    (%rsi,%rax,1),%ebp
add    $0x40,%ebp
shr    $0x7,%ebp
jmp    11e0 <y4m_42xmpeg2_42xjpeg_helper+0xe0>
cs nopw 0x0(%rax,%rax,1)
mov    %r8d,%r10d
cmp    %r11d,%r10d
jge    1390 <y4m_42xmpeg2_42xjpeg_helper+0x290>
mov    %r10d,%ebp
mov    %r11,%rbx
sub    %rbp,%rbx
cmp    $0x8,%rbx
jb     12f0 <y4m_42xmpeg2_42xjpeg_helper+0x1f0>
mov    %rbp,%rax
not    %rax
add    %r11,%rax
mov    $0xfffffffc,%esi
sub    %r10d,%esi
cmp    %eax,%esi
jb     12f0 <y4m_42xmpeg2_42xjpeg_helper+0x1f0>
shr    $0x20,%rax
jne    12f0 <y4m_42xmpeg2_42xjpeg_helper+0x1f0>
mov    -0x30(%rsp),%rdx
imul   %rcx,%rdx
mov    -0x10(%rsp),%rax
add    %rdx,%rax
mov    -0x18(%rsp),%rdi
add    %rdi,%rax
mov    %r13,%rsi
add    %rbp,%rsi
cmp    %rax,%rsi
jae    144c <y4m_42xmpeg2_42xjpeg_helper+0x34c>
lea    (%rdx,%r11,1),%rax
add    -0x20(%rsp),%rax
add    %rdi,%rdx
add    $0xfffffffffffffffe,%rdx
add    %rbp,%rdx
cmp    %rax,%rdx
jae    144c <y4m_42xmpeg2_42xjpeg_helper+0x34c>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rsi
add    $0x3,%rsi
mov    -0x38(%rsp),%r10
mov    -0x8(%rsp),%rbx
jmp    1327 <y4m_42xmpeg2_42xjpeg_helper+0x227>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %dl,-0x3(%r13,%rsi,1)
lea    (%rbx,%rsi,1),%rax
add    $0x1,%rax
add    $0x1,%rsi
cmp    $0x3,%rax
je     1390 <y4m_42xmpeg2_42xjpeg_helper+0x290>
movzbl -0x5(%r14,%rsi,1),%eax
movd   -0x4(%r14,%rsi,1),%xmm0
punpcklbw %xmm15,%xmm0
punpcklwd %xmm15,%xmm0
pmaddwd %xmm14,%xmm0
mov    %esi,%edx
movzbl (%r14,%rdx,1),%ebp
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
lea    (%rdx,%rax,4),%eax
lea    (%rax,%rbp,1),%edi
mov    $0xff,%edx
cmp    $0x7fc0,%edi
jge    137c <y4m_42xmpeg2_42xjpeg_helper+0x27c>
lea    (%rax,%rbp,1),%edx
add    $0x40,%edx
shr    $0x7,%edx
cmp    $0x40,%edi
jge    1310 <y4m_42xmpeg2_42xjpeg_helper+0x210>
xor    %edx,%edx
jmp    1310 <y4m_42xmpeg2_42xjpeg_helper+0x210>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x28(%rsp),%edx
cmp    %edx,%r10d
mov    -0x38(%rsp),%r11
jge    11b0 <y4m_42xmpeg2_42xjpeg_helper+0xb0>
movslq %r10d,%r9
add    $0x2,%r10d
jmp    13c9 <y4m_42xmpeg2_42xjpeg_helper+0x2c9>
nopl   0x0(%rax,%rax,1)
cmp    $0x40,%edi
cmovl  %r12d,%eax
mov    %al,0x0(%r13,%rsi,1)
add    $0x1,%r10d
cmp    %r9,%rcx
je     11b0 <y4m_42xmpeg2_42xjpeg_helper+0xb0>
mov    %r9,%rdi
movzbl -0x2(%r14,%r9,1),%eax
shl    $0x2,%eax
movzbl -0x1(%r14,%r9,1),%ebp
mov    %ebp,%esi
shl    $0x4,%esi
add    %ebp,%esi
sub    %esi,%eax
mov    %edi,%esi
movzbl (%r14,%rsi,1),%ebp
imul   $0x72,%ebp,%ebx
add    %eax,%ebx
add    $0x1,%r9
lea    -0x1(%r10),%eax
cmp    %r15,%rdi
cmovge %r15d,%eax
cltq
movzbl (%r14,%rax,1),%eax
imul   $0x23,%eax,%ebp
add    %ebx,%ebp
add    $0x2,%rdi
cmp    %r15,%rdi
mov    %r10d,%eax
cmovg  %r15d,%eax
cltq
movzbl (%r14,%rax,1),%eax
lea    (%rax,%rax,8),%eax
sub    %eax,%ebp
movzbl (%r14,%r15,1),%ebx
lea    (%rbx,%rbp,1),%edi
mov    $0xff,%eax
cmp    $0x7fc0,%edi
jge    13b0 <y4m_42xmpeg2_42xjpeg_helper+0x2b0>
lea    (%rbx,%rbp,1),%eax
add    $0x40,%eax
shr    $0x7,%eax
jmp    13b0 <y4m_42xmpeg2_42xjpeg_helper+0x2b0>
cmp    $0x10,%rbx
jae    161f <y4m_42xmpeg2_42xjpeg_helper+0x51f>
xor    %r11d,%r11d
mov    %rbx,%rdi
and    $0xfffffffffffffff8,%rdi
lea    (%rdi,%rbp,1),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r11,%r9
or     %rbp,%r9
movq   -0x2(%r14,%r9,1),%xmm1
punpcklbw %xmm15,%xmm1
movdqa %xmm1,%xmm2
punpcklwd %xmm15,%xmm2
punpckhwd %xmm15,%xmm1
pslld  $0x2,%xmm1
pslld  $0x2,%xmm2
movq   -0x1(%r14,%r9,1),%xmm0
punpcklbw %xmm15,%xmm0
movdqa %xmm0,%xmm3
punpcklwd %xmm15,%xmm3
punpckhwd %xmm15,%xmm0
movdqa %xmm0,%xmm4
pslld  $0x4,%xmm4
paddd  %xmm0,%xmm4
psubd  %xmm4,%xmm1
movdqa %xmm3,%xmm0
pslld  $0x4,%xmm0
paddd  %xmm3,%xmm0
psubd  %xmm0,%xmm2
movq   (%r14,%r9,1),%xmm0
punpcklbw %xmm15,%xmm0
movdqa %xmm0,%xmm4
punpckhwd %xmm15,%xmm4
punpcklwd %xmm15,%xmm0
pmaddwd %xmm8,%xmm0
paddd  %xmm2,%xmm0
pmaddwd %xmm8,%xmm4
paddd  %xmm1,%xmm4
movq   0x1(%r14,%r9,1),%xmm3
punpcklbw %xmm15,%xmm3
movdqa %xmm3,%xmm2
punpcklwd %xmm15,%xmm2
punpckhwd %xmm15,%xmm3
pmaddwd %xmm9,%xmm3
paddd  %xmm4,%xmm3
pmaddwd %xmm9,%xmm2
paddd  %xmm0,%xmm2
movq   0x2(%r14,%r9,1),%xmm0
punpcklbw %xmm15,%xmm0
movdqa %xmm0,%xmm1
punpckhwd %xmm15,%xmm1
punpcklwd %xmm15,%xmm0
movdqa %xmm0,%xmm4
pslld  $0x3,%xmm4
paddd  %xmm0,%xmm4
psubd  %xmm4,%xmm2
movdqa %xmm1,%xmm0
pslld  $0x3,%xmm0
paddd  %xmm1,%xmm0
psubd  %xmm0,%xmm3
lea    0x3(%r9),%eax
movq   (%r14,%rax,1),%xmm1
punpcklbw %xmm15,%xmm1
movdqa %xmm1,%xmm4
punpckhwd %xmm15,%xmm4
paddd  %xmm3,%xmm4
punpcklwd %xmm15,%xmm1
paddd  %xmm2,%xmm1
movdqa %xmm4,%xmm2
pcmpgtd %xmm10,%xmm2
movdqa %xmm1,%xmm0
pcmpgtd %xmm10,%xmm0
packssdw %xmm2,%xmm0
packsswb %xmm0,%xmm0
movdqa %xmm4,%xmm2
paddd  %xmm11,%xmm2
movdqa %xmm1,%xmm3
paddd  %xmm11,%xmm3
psrld  $0x7,%xmm3
psrld  $0x7,%xmm2
pcmpgtd %xmm12,%xmm4
pcmpgtd %xmm12,%xmm1
packssdw %xmm4,%xmm1
packsswb %xmm1,%xmm1
pand   %xmm13,%xmm2
pand   %xmm13,%xmm3
packuswb %xmm2,%xmm3
packuswb %xmm3,%xmm3
movdqa %xmm0,%xmm2
pandn  %xmm3,%xmm2
por    %xmm0,%xmm2
pand   %xmm1,%xmm2
movq   %xmm2,0x0(%r13,%r9,1)
add    $0x8,%r11
cmp    %r11,%rdi
jne    1470 <y4m_42xmpeg2_42xjpeg_helper+0x370>
mov    -0x38(%rsp),%r10
cmp    %rdi,%rbx
jne    12f3 <y4m_42xmpeg2_42xjpeg_helper+0x1f3>
jmp    1390 <y4m_42xmpeg2_42xjpeg_helper+0x290>
mov    %rbx,%r11
and    $0xfffffffffffffff0,%r11
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rdi
or     %rbp,%rdi
movdqu -0x2(%r14,%rdi,1),%xmm2
movdqu -0x1(%r14,%rdi,1),%xmm5
movdqu (%r14,%rdi,1),%xmm3
movdqu 0x1(%r14,%rdi,1),%xmm6
movdqa %xmm2,%xmm4
punpcklbw %xmm15,%xmm4
punpckhbw %xmm15,%xmm2
movdqa %xmm5,%xmm0
punpckhbw %xmm15,%xmm5
movdqa %xmm5,%xmm7
punpckhwd %xmm15,%xmm5
movdqa %xmm5,%xmm1
pslld  $0x4,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm2,%xmm5
punpcklwd %xmm15,%xmm5
punpckhwd %xmm15,%xmm2
pslld  $0x2,%xmm2
pslld  $0x2,%xmm5
punpcklbw %xmm15,%xmm0
punpcklwd %xmm15,%xmm7
psubd  %xmm1,%xmm2
movdqa %xmm7,%xmm1
pslld  $0x4,%xmm1
paddd  %xmm7,%xmm1
movdqa %xmm0,%xmm7
punpckhwd %xmm15,%xmm0
psubd  %xmm1,%xmm5
movdqa %xmm0,%xmm1
pslld  $0x4,%xmm1
paddd  %xmm0,%xmm1
movdqa %xmm4,%xmm0
punpcklwd %xmm15,%xmm0
punpckhwd %xmm15,%xmm4
pslld  $0x2,%xmm4
pslld  $0x2,%xmm0
punpcklwd %xmm15,%xmm7
psubd  %xmm1,%xmm4
movdqa %xmm7,%xmm1
pslld  $0x4,%xmm1
paddd  %xmm7,%xmm1
psubd  %xmm1,%xmm0
movdqa %xmm3,%xmm1
punpckhbw %xmm15,%xmm1
punpcklbw %xmm15,%xmm3
movdqa %xmm3,%xmm7
punpcklwd %xmm15,%xmm3
pmaddwd %xmm8,%xmm3
paddd  %xmm0,%xmm3
movdqa %xmm1,%xmm0
punpckhwd %xmm15,%xmm0
punpcklwd %xmm15,%xmm1
punpckhwd %xmm15,%xmm7
pmaddwd %xmm8,%xmm7
paddd  %xmm4,%xmm7
pmaddwd %xmm8,%xmm1
paddd  %xmm5,%xmm1
pmaddwd %xmm8,%xmm0
paddd  %xmm2,%xmm0
movdqa %xmm6,%xmm2
punpcklbw %xmm15,%xmm2
movdqa %xmm2,%xmm4
punpcklwd %xmm15,%xmm4
punpckhwd %xmm15,%xmm2
punpckhbw %xmm15,%xmm6
movdqa %xmm6,%xmm5
punpcklwd %xmm15,%xmm5
punpckhwd %xmm15,%xmm6
pmaddwd %xmm9,%xmm6
paddd  %xmm0,%xmm6
pmaddwd %xmm9,%xmm5
paddd  %xmm1,%xmm5
pmaddwd %xmm9,%xmm2
paddd  %xmm7,%xmm2
pmaddwd %xmm9,%xmm4
paddd  %xmm3,%xmm4
movdqu 0x2(%r14,%rdi,1),%xmm0
movdqa %xmm0,%xmm1
punpckhbw %xmm15,%xmm1
punpcklbw %xmm15,%xmm0
movdqa %xmm0,%xmm3
punpcklwd %xmm15,%xmm0
movdqa %xmm0,%xmm7
pslld  $0x3,%xmm7
paddd  %xmm0,%xmm7
movdqa %xmm1,%xmm0
punpckhwd %xmm15,%xmm0
punpcklwd %xmm15,%xmm1
punpckhwd %xmm15,%xmm3
psubd  %xmm7,%xmm4
movdqa %xmm3,%xmm7
pslld  $0x3,%xmm7
paddd  %xmm3,%xmm7
psubd  %xmm7,%xmm2
movdqa %xmm1,%xmm3
pslld  $0x3,%xmm3
paddd  %xmm1,%xmm3
psubd  %xmm3,%xmm5
movdqa %xmm0,%xmm1
pslld  $0x3,%xmm1
paddd  %xmm0,%xmm1
psubd  %xmm1,%xmm6
lea    0x3(%rdi),%eax
and    $0xfffffff7,%eax
movdqu (%r14,%rax,1),%xmm7
movdqa %xmm7,%xmm3
punpckhbw %xmm15,%xmm3
movdqa %xmm3,%xmm0
punpckhwd %xmm15,%xmm0
paddd  %xmm6,%xmm0
punpcklwd %xmm15,%xmm3
paddd  %xmm5,%xmm3
punpcklbw %xmm15,%xmm7
movdqa %xmm7,%xmm5
punpckhwd %xmm15,%xmm5
paddd  %xmm2,%xmm5
punpcklwd %xmm15,%xmm7
paddd  %xmm4,%xmm7
movdqa %xmm0,%xmm1
pcmpgtd %xmm10,%xmm1
movdqa %xmm3,%xmm4
pcmpgtd %xmm10,%xmm4
packssdw %xmm1,%xmm4
movdqa %xmm5,%xmm1
pcmpgtd %xmm10,%xmm1
movdqa %xmm7,%xmm2
pcmpgtd %xmm10,%xmm2
packssdw %xmm1,%xmm2
packsswb %xmm4,%xmm2
movdqa %xmm0,%xmm1
movdqa %xmm3,%xmm4
movdqa %xmm5,%xmm6
pcmpgtd %xmm12,%xmm0
pcmpgtd %xmm12,%xmm3
packssdw %xmm0,%xmm3
movdqa %xmm7,%xmm0
pcmpgtd %xmm12,%xmm5
pcmpgtd %xmm12,%xmm7
packssdw %xmm5,%xmm7
packsswb %xmm3,%xmm7
paddd  %xmm11,%xmm1
paddd  %xmm11,%xmm4
psrld  $0x7,%xmm4
psrld  $0x7,%xmm1
pand   %xmm13,%xmm1
pand   %xmm13,%xmm4
packuswb %xmm1,%xmm4
paddd  %xmm11,%xmm6
paddd  %xmm11,%xmm0
psrld  $0x7,%xmm0
psrld  $0x7,%xmm6
pand   %xmm13,%xmm6
pand   %xmm13,%xmm0
packuswb %xmm6,%xmm0
packuswb %xmm4,%xmm0
por    %xmm2,%xmm0
pand   %xmm7,%xmm0
movdqu %xmm0,0x0(%r13,%rdi,1)
add    $0x10,%rsi
cmp    %rsi,%r11
jne    1630 <y4m_42xmpeg2_42xjpeg_helper+0x530>
mov    -0x38(%rsp),%r10
cmp    %r11,%rbx
je     1390 <y4m_42xmpeg2_42xjpeg_helper+0x290>
test   $0x8,%bl
jne    1459 <y4m_42xmpeg2_42xjpeg_helper+0x359>
or     %rbp,%r11
mov    %r11,%rsi
jmp    12f3 <y4m_42xmpeg2_42xjpeg_helper+0x1f3>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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