void y4m_42xmpeg2_42xjpeg_helper(unsigned char *_dst, const unsigned char *_src,
                                 int _c_w, int _c_h) {
  int pli;
  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    $0x168,%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    -0x18(%rbp),%eax
jge    1fc7 <y4m_42xmpeg2_42xjpeg_helper+0xec7>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x2,-0x14(%rbp)
jle    1150 <y4m_42xmpeg2_42xjpeg_helper+0x50>
mov    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1156 <y4m_42xmpeg2_42xjpeg_helper+0x56>
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jge    17f6 <y4m_42xmpeg2_42xjpeg_helper+0x6f6>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1192 <y4m_42xmpeg2_42xjpeg_helper+0x92>
xor    %eax,%eax
mov    %eax,-0x40(%rbp)
jmp    119b <y4m_42xmpeg2_42xjpeg_helper+0x9b>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x24(%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,-0x50(%rbp)
jmp    11f8 <y4m_42xmpeg2_42xjpeg_helper+0xf8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x48(%rbp),%rcx
mov    -0x50(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x24(%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,-0x60(%rbp)
jmp    1244 <y4m_42xmpeg2_42xjpeg_helper+0x144>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x24(%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,-0x70(%rbp)
jmp    1290 <y4m_42xmpeg2_42xjpeg_helper+0x190>
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x70(%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,-0x74(%rbp)
jmp    1457 <y4m_42xmpeg2_42xjpeg_helper+0x357>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x84(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    12f5 <y4m_42xmpeg2_42xjpeg_helper+0x1f5>
xor    %eax,%eax
mov    %eax,-0x88(%rbp)
jmp    1301 <y4m_42xmpeg2_42xjpeg_helper+0x201>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x80(%rbp),%rcx
mov    -0x88(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1364 <y4m_42xmpeg2_42xjpeg_helper+0x264>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1370 <y4m_42xmpeg2_42xjpeg_helper+0x270>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x90(%rbp),%rcx
mov    -0x98(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    13c5 <y4m_42xmpeg2_42xjpeg_helper+0x2c5>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    13d1 <y4m_42xmpeg2_42xjpeg_helper+0x2d1>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0xa0(%rbp),%rcx
mov    -0xa8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1426 <y4m_42xmpeg2_42xjpeg_helper+0x326>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1432 <y4m_42xmpeg2_42xjpeg_helper+0x332>
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0xb0(%rbp),%rcx
mov    -0xb8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    17c8 <y4m_42xmpeg2_42xjpeg_helper+0x6c8>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0xc4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    149b <y4m_42xmpeg2_42xjpeg_helper+0x39b>
xor    %eax,%eax
mov    %eax,-0xc8(%rbp)
jmp    14a7 <y4m_42xmpeg2_42xjpeg_helper+0x3a7>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0xc0(%rbp),%rcx
mov    -0xc8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xd4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    150d <y4m_42xmpeg2_42xjpeg_helper+0x40d>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1519 <y4m_42xmpeg2_42xjpeg_helper+0x419>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd4(%rbp),%eax
mov    -0xd0(%rbp),%rcx
mov    -0xd8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    156e <y4m_42xmpeg2_42xjpeg_helper+0x46e>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    157a <y4m_42xmpeg2_42xjpeg_helper+0x47a>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe4(%rbp),%eax
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xf4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    15cf <y4m_42xmpeg2_42xjpeg_helper+0x4cf>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    15db <y4m_42xmpeg2_42xjpeg_helper+0x4db>
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf4(%rbp),%eax
mov    -0xf0(%rbp),%rcx
mov    -0xf8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
cmp    $0xff,%eax
jle    1618 <y4m_42xmpeg2_42xjpeg_helper+0x518>
mov    $0xff,%eax
mov    %eax,-0xfc(%rbp)
jmp    17b7 <y4m_42xmpeg2_42xjpeg_helper+0x6b7>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x2,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    164f <y4m_42xmpeg2_42xjpeg_helper+0x54f>
xor    %eax,%eax
mov    %eax,-0x110(%rbp)
jmp    165b <y4m_42xmpeg2_42xjpeg_helper+0x55b>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x110(%rbp)
mov    -0x10c(%rbp),%eax
mov    -0x108(%rbp),%rcx
mov    -0x110(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x11,%ecx,%ecx
sub    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    16c1 <y4m_42xmpeg2_42xjpeg_helper+0x5c1>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    16cd <y4m_42xmpeg2_42xjpeg_helper+0x5cd>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
mov    -0x11c(%rbp),%eax
mov    -0x118(%rbp),%rcx
mov    -0x120(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1722 <y4m_42xmpeg2_42xjpeg_helper+0x622>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    172e <y4m_42xmpeg2_42xjpeg_helper+0x62e>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x130(%rbp)
mov    -0x12c(%rbp),%eax
mov    -0x128(%rbp),%rcx
mov    -0x130(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x9,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x13c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1783 <y4m_42xmpeg2_42xjpeg_helper+0x683>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x140(%rbp)
jmp    178f <y4m_42xmpeg2_42xjpeg_helper+0x68f>
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x140(%rbp)
mov    -0x13c(%rbp),%eax
mov    -0x138(%rbp),%rcx
mov    -0x140(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    %eax,-0x144(%rbp)
jmp    17d5 <y4m_42xmpeg2_42xjpeg_helper+0x6d5>
xor    %eax,%eax
mov    %eax,-0x144(%rbp)
jmp    17d5 <y4m_42xmpeg2_42xjpeg_helper+0x6d5>
mov    -0x144(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1133 <y4m_42xmpeg2_42xjpeg_helper+0x33>
jmp    17fb <y4m_42xmpeg2_42xjpeg_helper+0x6fb>
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1a9d <y4m_42xmpeg2_42xjpeg_helper+0x99d>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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    -0x24(%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    -0x24(%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    18a7 <y4m_42xmpeg2_42xjpeg_helper+0x7a7>
mov    $0xff,%eax
mov    %eax,-0x148(%rbp)
jmp    192d <y4m_42xmpeg2_42xjpeg_helper+0x82d>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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    -0x24(%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    -0x24(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1a6f <y4m_42xmpeg2_42xjpeg_helper+0x96f>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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    -0x24(%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    -0x24(%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    19d8 <y4m_42xmpeg2_42xjpeg_helper+0x8d8>
mov    $0xff,%eax
mov    %eax,-0x14c(%rbp)
jmp    1a5e <y4m_42xmpeg2_42xjpeg_helper+0x95e>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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    -0x24(%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    -0x24(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x40,%eax
sar    $0x7,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    1a7c <y4m_42xmpeg2_42xjpeg_helper+0x97c>
xor    %eax,%eax
mov    %eax,-0x150(%rbp)
jmp    1a7c <y4m_42xmpeg2_42xjpeg_helper+0x97c>
mov    -0x150(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17fb <y4m_42xmpeg2_42xjpeg_helper+0x6fb>
jmp    1aa2 <y4m_42xmpeg2_42xjpeg_helper+0x9a2>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f97 <y4m_42xmpeg2_42xjpeg_helper+0xe97>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1b1f <y4m_42xmpeg2_42xjpeg_helper+0xa1f>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x160(%rbp)
jmp    1b2b <y4m_42xmpeg2_42xjpeg_helper+0xa2b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x160(%rbp)
mov    -0x15c(%rbp),%eax
mov    -0x158(%rbp),%rcx
mov    -0x160(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x16c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1b80 <y4m_42xmpeg2_42xjpeg_helper+0xa80>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x170(%rbp)
jmp    1b8c <y4m_42xmpeg2_42xjpeg_helper+0xa8c>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x170(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x168(%rbp),%rcx
mov    -0x170(%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    1bdf <y4m_42xmpeg2_42xjpeg_helper+0xadf>
mov    $0xff,%eax
mov    %eax,-0x174(%rbp)
jmp    1cfb <y4m_42xmpeg2_42xjpeg_helper+0xbfb>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x184(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1c50 <y4m_42xmpeg2_42xjpeg_helper+0xb50>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x188(%rbp)
jmp    1c5c <y4m_42xmpeg2_42xjpeg_helper+0xb5c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x188(%rbp)
mov    -0x184(%rbp),%eax
mov    -0x180(%rbp),%rcx
mov    -0x188(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x194(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1cb1 <y4m_42xmpeg2_42xjpeg_helper+0xbb1>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    1cbd <y4m_42xmpeg2_42xjpeg_helper+0xbbd>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x198(%rbp)
mov    -0x194(%rbp),%eax
mov    -0x190(%rbp),%rcx
mov    -0x198(%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,-0x174(%rbp)
mov    -0x174(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jge    1f69 <y4m_42xmpeg2_42xjpeg_helper+0xe69>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1d7c <y4m_42xmpeg2_42xjpeg_helper+0xc7c>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1a8(%rbp)
jmp    1d88 <y4m_42xmpeg2_42xjpeg_helper+0xc88>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a8(%rbp)
mov    -0x1a4(%rbp),%eax
mov    -0x1a0(%rbp),%rcx
mov    -0x1a8(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1b4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1ddd <y4m_42xmpeg2_42xjpeg_helper+0xcdd>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1b8(%rbp)
jmp    1de9 <y4m_42xmpeg2_42xjpeg_helper+0xce9>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1b8(%rbp)
mov    -0x1b4(%rbp),%eax
mov    -0x1b0(%rbp),%rcx
mov    -0x1b8(%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    1e3c <y4m_42xmpeg2_42xjpeg_helper+0xd3c>
mov    $0xff,%eax
mov    %eax,-0x1bc(%rbp)
jmp    1f58 <y4m_42xmpeg2_42xjpeg_helper+0xe58>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%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 -0x24(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x72,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1cc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1ead <y4m_42xmpeg2_42xjpeg_helper+0xdad>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
jmp    1eb9 <y4m_42xmpeg2_42xjpeg_helper+0xdb9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
mov    -0x1cc(%rbp),%eax
mov    -0x1c8(%rbp),%rcx
mov    -0x1d0(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x23,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1f0e <y4m_42xmpeg2_42xjpeg_helper+0xe0e>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1e0(%rbp)
jmp    1f1a <y4m_42xmpeg2_42xjpeg_helper+0xe1a>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1e0(%rbp)
mov    -0x1dc(%rbp),%eax
mov    -0x1d8(%rbp),%rcx
mov    -0x1e0(%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,-0x1bc(%rbp)
mov    -0x1bc(%rbp),%eax
mov    %eax,-0x1e4(%rbp)
jmp    1f76 <y4m_42xmpeg2_42xjpeg_helper+0xe76>
xor    %eax,%eax
mov    %eax,-0x1e4(%rbp)
jmp    1f76 <y4m_42xmpeg2_42xjpeg_helper+0xe76>
mov    -0x1e4(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1aa2 <y4m_42xmpeg2_42xjpeg_helper+0x9a2>
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    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1120 <y4m_42xmpeg2_42xjpeg_helper+0x20>
add    $0x168,%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
%11 = 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 %12
12: ; preds = %991, %4
%13 = load i32, i32* %10
%14 = load i32, i32* %8
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %994
16: ; preds = %12
store i32 0, i32* %11
br label %17
17: ; preds = %408, %16
%18 = load i32, i32* %11
%19 = load i32, i32* %7
%20 = icmp sgt i32 %19, 2
br i1 %20, label %21, label %22
21: ; preds = %17
br label %24
22: ; preds = %17
%23 = load i32, i32* %7
br label %24
24: ; preds = %22, %21
%25 = phi i32 [ 2, %21 ], [ %23, %22 ]
%26 = icmp slt i32 %18, %25
br i1 %26, label %27, label %411
27: ; preds = %24
%28 = load i8*, i8** %6
%29 = getelementptr inbounds i8, i8* %28, i64 0
%30 = load i8, i8* %29
%31 = zext i8 %30 to i32
%32 = mul nsw i32 4, %31
%33 = load i8*, i8** %6
%34 = load i32, i32* %11
%35 = sub nsw i32 %34, 1
%36 = icmp slt i32 %35, 0
br i1 %36, label %37, label %38
37: ; preds = %27
br label %41
38: ; preds = %27
%39 = load i32, i32* %11
%40 = sub nsw i32 %39, 1
br label %41
41: ; preds = %38, %37
%42 = phi i32 [ 0, %37 ], [ %40, %38 ]
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %33, i64 %43
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = mul nsw i32 17, %46
%48 = sub nsw i32 %32, %47
%49 = load i8*, i8** %6
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
%55 = mul nsw i32 114, %54
%56 = add nsw i32 %48, %55
%57 = load i8*, i8** %6
%58 = load i32, i32* %11
%59 = add nsw i32 %58, 1
%60 = load i32, i32* %7
%61 = sub nsw i32 %60, 1
%62 = icmp sgt i32 %59, %61
br i1 %62, label %63, label %66
63: ; preds = %41
%64 = load i32, i32* %7
%65 = sub nsw i32 %64, 1
br label %69
66: ; preds = %41
%67 = load i32, i32* %11
%68 = add nsw i32 %67, 1
br label %69
69: ; preds = %66, %63
%70 = phi i32 [ %65, %63 ], [ %68, %66 ]
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %57, i64 %71
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = mul nsw i32 35, %74
%76 = add nsw i32 %56, %75
%77 = load i8*, i8** %6
%78 = load i32, i32* %11
%79 = add nsw i32 %78, 2
%80 = load i32, i32* %7
%81 = sub nsw i32 %80, 1
%82 = icmp sgt i32 %79, %81
br i1 %82, label %83, label %86
83: ; preds = %69
%84 = load i32, i32* %7
%85 = sub nsw i32 %84, 1
br label %89
86: ; preds = %69
%87 = load i32, i32* %11
%88 = add nsw i32 %87, 2
br label %89
89: ; preds = %86, %83
%90 = phi i32 [ %85, %83 ], [ %88, %86 ]
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %77, i64 %91
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = mul nsw i32 9, %94
%96 = sub nsw i32 %76, %95
%97 = load i8*, i8** %6
%98 = load i32, i32* %11
%99 = add nsw i32 %98, 3
%100 = load i32, i32* %7
%101 = sub nsw i32 %100, 1
%102 = icmp sgt i32 %99, %101
br i1 %102, label %103, label %106
103: ; preds = %89
%104 = load i32, i32* %7
%105 = sub nsw i32 %104, 1
br label %109
106: ; preds = %89
%107 = load i32, i32* %11
%108 = add nsw i32 %107, 3
br label %109
109: ; preds = %106, %103
%110 = phi i32 [ %105, %103 ], [ %108, %106 ]
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %97, i64 %111
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = add nsw i32 %96, %114
%116 = add nsw i32 %115, 64
%117 = ashr i32 %116, 7
%118 = icmp sgt i32 %117, 255
br i1 %118, label %119, label %120
119: ; preds = %109
br label %211
120: ; preds = %109
%121 = load i8*, i8** %6
%122 = getelementptr inbounds i8, i8* %121, i64 0
%123 = load i8, i8* %122
%124 = zext i8 %123 to i32
%125 = mul nsw i32 4, %124
%126 = load i8*, i8** %6
%127 = load i32, i32* %11
%128 = sub nsw i32 %127, 1
%129 = icmp slt i32 %128, 0
br i1 %129, label %130, label %131
130: ; preds = %120
br label %134
131: ; preds = %120
%132 = load i32, i32* %11
%133 = sub nsw i32 %132, 1
br label %134
134: ; preds = %131, %130
%135 = phi i32 [ 0, %130 ], [ %133, %131 ]
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i8, i8* %126, i64 %136
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = mul nsw i32 17, %139
%141 = sub nsw i32 %125, %140
%142 = load i8*, i8** %6
%143 = load i32, i32* %11
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i8, i8* %142, i64 %144
%146 = load i8, i8* %145
%147 = zext i8 %146 to i32
%148 = mul nsw i32 114, %147
%149 = add nsw i32 %141, %148
%150 = load i8*, i8** %6
%151 = load i32, i32* %11
%152 = add nsw i32 %151, 1
%153 = load i32, i32* %7
%154 = sub nsw i32 %153, 1
%155 = icmp sgt i32 %152, %154
br i1 %155, label %156, label %159
156: ; preds = %134
%157 = load i32, i32* %7
%158 = sub nsw i32 %157, 1
br label %162
159: ; preds = %134
%160 = load i32, i32* %11
%161 = add nsw i32 %160, 1
br label %162
162: ; preds = %159, %156
%163 = phi i32 [ %158, %156 ], [ %161, %159 ]
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %150, i64 %164
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = mul nsw i32 35, %167
%169 = add nsw i32 %149, %168
%170 = load i8*, i8** %6
%171 = load i32, i32* %11
%172 = add nsw i32 %171, 2
%173 = load i32, i32* %7
%174 = sub nsw i32 %173, 1
%175 = icmp sgt i32 %172, %174
br i1 %175, label %176, label %179
176: ; preds = %162
%177 = load i32, i32* %7
%178 = sub nsw i32 %177, 1
br label %182
179: ; preds = %162
%180 = load i32, i32* %11
%181 = add nsw i32 %180, 2
br label %182
182: ; preds = %179, %176
%183 = phi i32 [ %178, %176 ], [ %181, %179 ]
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i8, i8* %170, i64 %184
%186 = load i8, i8* %185
%187 = zext i8 %186 to i32
%188 = mul nsw i32 9, %187
%189 = sub nsw i32 %169, %188
%190 = load i8*, i8** %6
%191 = load i32, i32* %11
%192 = add nsw i32 %191, 3
%193 = load i32, i32* %7
%194 = sub nsw i32 %193, 1
%195 = icmp sgt i32 %192, %194
br i1 %195, label %196, label %199
196: ; preds = %182
%197 = load i32, i32* %7
%198 = sub nsw i32 %197, 1
br label %202
199: ; preds = %182
%200 = load i32, i32* %11
%201 = add nsw i32 %200, 3
br label %202
202: ; preds = %199, %196
%203 = phi i32 [ %198, %196 ], [ %201, %199 ]
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i8, i8* %190, i64 %204
%206 = load i8, i8* %205
%207 = zext i8 %206 to i32
%208 = add nsw i32 %189, %207
%209 = add nsw i32 %208, 64
%210 = ashr i32 %209, 7
br label %211
211: ; preds = %202, %119
%212 = phi i32 [ 255, %119 ], [ %210, %202 ]
%213 = icmp slt i32 0, %212
br i1 %213, label %214, label %400
214: ; preds = %211
%215 = load i8*, i8** %6
%216 = getelementptr inbounds i8, i8* %215, i64 0
%217 = load i8, i8* %216
%218 = zext i8 %217 to i32
%219 = mul nsw i32 4, %218
%220 = load i8*, i8** %6
%221 = load i32, i32* %11
%222 = sub nsw i32 %221, 1
%223 = icmp slt i32 %222, 0
br i1 %223, label %224, label %225
224: ; preds = %214
br label %228
225: ; preds = %214
%226 = load i32, i32* %11
%227 = sub nsw i32 %226, 1
br label %228
228: ; preds = %225, %224
%229 = phi i32 [ 0, %224 ], [ %227, %225 ]
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i8, i8* %220, i64 %230
%232 = load i8, i8* %231
%233 = zext i8 %232 to i32
%234 = mul nsw i32 17, %233
%235 = sub nsw i32 %219, %234
%236 = load i8*, i8** %6
%237 = load i32, i32* %11
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i8, i8* %236, i64 %238
%240 = load i8, i8* %239
%241 = zext i8 %240 to i32
%242 = mul nsw i32 114, %241
%243 = add nsw i32 %235, %242
%244 = load i8*, i8** %6
%245 = load i32, i32* %11
%246 = add nsw i32 %245, 1
%247 = load i32, i32* %7
%248 = sub nsw i32 %247, 1
%249 = icmp sgt i32 %246, %248
br i1 %249, label %250, label %253
250: ; preds = %228
%251 = load i32, i32* %7
%252 = sub nsw i32 %251, 1
br label %256
253: ; preds = %228
%254 = load i32, i32* %11
%255 = add nsw i32 %254, 1
br label %256
256: ; preds = %253, %250
%257 = phi i32 [ %252, %250 ], [ %255, %253 ]
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %244, i64 %258
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = mul nsw i32 35, %261
%263 = add nsw i32 %243, %262
%264 = load i8*, i8** %6
%265 = load i32, i32* %11
%266 = add nsw i32 %265, 2
%267 = load i32, i32* %7
%268 = sub nsw i32 %267, 1
%269 = icmp sgt i32 %266, %268
br i1 %269, label %270, label %273
270: ; preds = %256
%271 = load i32, i32* %7
%272 = sub nsw i32 %271, 1
br label %276
273: ; preds = %256
%274 = load i32, i32* %11
%275 = add nsw i32 %274, 2
br label %276
276: ; preds = %273, %270
%277 = phi i32 [ %272, %270 ], [ %275, %273 ]
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i8, i8* %264, i64 %278
%280 = load i8, i8* %279
%281 = zext i8 %280 to i32
%282 = mul nsw i32 9, %281
%283 = sub nsw i32 %263, %282
%284 = load i8*, i8** %6
%285 = load i32, i32* %11
%286 = add nsw i32 %285, 3
%287 = load i32, i32* %7
%288 = sub nsw i32 %287, 1
%289 = icmp sgt i32 %286, %288
br i1 %289, label %290, label %293
290: ; preds = %276
%291 = load i32, i32* %7
%292 = sub nsw i32 %291, 1
br label %296
293: ; preds = %276
%294 = load i32, i32* %11
%295 = add nsw i32 %294, 3
br label %296
296: ; preds = %293, %290
%297 = phi i32 [ %292, %290 ], [ %295, %293 ]
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i8, i8* %284, i64 %298
%300 = load i8, i8* %299
%301 = zext i8 %300 to i32
%302 = add nsw i32 %283, %301
%303 = add nsw i32 %302, 64
%304 = ashr i32 %303, 7
%305 = icmp sgt i32 %304, 255
br i1 %305, label %306, label %307
306: ; preds = %296
br label %398
307: ; preds = %296
%308 = load i8*, i8** %6
%309 = getelementptr inbounds i8, i8* %308, i64 0
%310 = load i8, i8* %309
%311 = zext i8 %310 to i32
%312 = mul nsw i32 4, %311
%313 = load i8*, i8** %6
%314 = load i32, i32* %11
%315 = sub nsw i32 %314, 1
%316 = icmp slt i32 %315, 0
br i1 %316, label %317, label %318
317: ; preds = %307
br label %321
318: ; preds = %307
%319 = load i32, i32* %11
%320 = sub nsw i32 %319, 1
br label %321
321: ; preds = %318, %317
%322 = phi i32 [ 0, %317 ], [ %320, %318 ]
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds i8, i8* %313, i64 %323
%325 = load i8, i8* %324
%326 = zext i8 %325 to i32
%327 = mul nsw i32 17, %326
%328 = sub nsw i32 %312, %327
%329 = load i8*, i8** %6
%330 = load i32, i32* %11
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i8, i8* %329, i64 %331
%333 = load i8, i8* %332
%334 = zext i8 %333 to i32
%335 = mul nsw i32 114, %334
%336 = add nsw i32 %328, %335
%337 = load i8*, i8** %6
%338 = load i32, i32* %11
%339 = add nsw i32 %338, 1
%340 = load i32, i32* %7
%341 = sub nsw i32 %340, 1
%342 = icmp sgt i32 %339, %341
br i1 %342, label %343, label %346
343: ; preds = %321
%344 = load i32, i32* %7
%345 = sub nsw i32 %344, 1
br label %349
346: ; preds = %321
%347 = load i32, i32* %11
%348 = add nsw i32 %347, 1
br label %349
349: ; preds = %346, %343
%350 = phi i32 [ %345, %343 ], [ %348, %346 ]
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i8, i8* %337, i64 %351
%353 = load i8, i8* %352
%354 = zext i8 %353 to i32
%355 = mul nsw i32 35, %354
%356 = add nsw i32 %336, %355
%357 = load i8*, i8** %6
%358 = load i32, i32* %11
%359 = add nsw i32 %358, 2
%360 = load i32, i32* %7
%361 = sub nsw i32 %360, 1
%362 = icmp sgt i32 %359, %361
br i1 %362, label %363, label %366
363: ; preds = %349
%364 = load i32, i32* %7
%365 = sub nsw i32 %364, 1
br label %369
366: ; preds = %349
%367 = load i32, i32* %11
%368 = add nsw i32 %367, 2
br label %369
369: ; preds = %366, %363
%370 = phi i32 [ %365, %363 ], [ %368, %366 ]
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds i8, i8* %357, i64 %371
%373 = load i8, i8* %372
%374 = zext i8 %373 to i32
%375 = mul nsw i32 9, %374
%376 = sub nsw i32 %356, %375
%377 = load i8*, i8** %6
%378 = load i32, i32* %11
%379 = add nsw i32 %378, 3
%380 = load i32, i32* %7
%381 = sub nsw i32 %380, 1
%382 = icmp sgt i32 %379, %381
br i1 %382, label %383, label %386
383: ; preds = %369
%384 = load i32, i32* %7
%385 = sub nsw i32 %384, 1
br label %389
386: ; preds = %369
%387 = load i32, i32* %11
%388 = add nsw i32 %387, 3
br label %389
389: ; preds = %386, %383
%390 = phi i32 [ %385, %383 ], [ %388, %386 ]
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i8, i8* %377, i64 %391
%393 = load i8, i8* %392
%394 = zext i8 %393 to i32
%395 = add nsw i32 %376, %394
%396 = add nsw i32 %395, 64
%397 = ashr i32 %396, 7
br label %398
398: ; preds = %389, %306
%399 = phi i32 [ 255, %306 ], [ %397, %389 ]
br label %401
400: ; preds = %211
br label %401
401: ; preds = %400, %398
%402 = phi i32 [ %399, %398 ], [ 0, %400 ]
%403 = trunc i32 %402 to i8
%404 = load i8*, i8** %5
%405 = load i32, i32* %11
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds i8, i8* %404, i64 %406
store i8 %403, i8* %407
br label %408
408: ; preds = %401
%409 = load i32, i32* %11
%410 = add nsw i32 %409, 1
store i32 %410, i32* %11
br label %17
411: ; preds = %24
br label %412
412: ; preds = %650, %411
%413 = load i32, i32* %11
%414 = load i32, i32* %7
%415 = sub nsw i32 %414, 3
%416 = icmp slt i32 %413, %415
br i1 %416, label %417, label %653
417: ; preds = %412
%418 = load i8*, i8** %6
%419 = load i32, i32* %11
%420 = sub nsw i32 %419, 2
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds i8, i8* %418, i64 %421
%423 = load i8, i8* %422
%424 = zext i8 %423 to i32
%425 = mul nsw i32 4, %424
%426 = load i8*, i8** %6
%427 = load i32, i32* %11
%428 = sub nsw i32 %427, 1
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i8, i8* %426, i64 %429
%431 = load i8, i8* %430
%432 = zext i8 %431 to i32
%433 = mul nsw i32 17, %432
%434 = sub nsw i32 %425, %433
%435 = load i8*, i8** %6
%436 = load i32, i32* %11
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i8, i8* %435, i64 %437
%439 = load i8, i8* %438
%440 = zext i8 %439 to i32
%441 = mul nsw i32 114, %440
%442 = add nsw i32 %434, %441
%443 = load i8*, i8** %6
%444 = load i32, i32* %11
%445 = add nsw i32 %444, 1
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i8, i8* %443, i64 %446
%448 = load i8, i8* %447
%449 = zext i8 %448 to i32
%450 = mul nsw i32 35, %449
%451 = add nsw i32 %442, %450
%452 = load i8*, i8** %6
%453 = load i32, i32* %11
%454 = add nsw i32 %453, 2
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i8, i8* %452, i64 %455
%457 = load i8, i8* %456
%458 = zext i8 %457 to i32
%459 = mul nsw i32 9, %458
%460 = sub nsw i32 %451, %459
%461 = load i8*, i8** %6
%462 = load i32, i32* %11
%463 = add nsw i32 %462, 3
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i8, i8* %461, i64 %464
%466 = load i8, i8* %465
%467 = zext i8 %466 to i32
%468 = add nsw i32 %460, %467
%469 = add nsw i32 %468, 64
%470 = ashr i32 %469, 7
%471 = icmp sgt i32 %470, 255
br i1 %471, label %472, label %473
472: ; preds = %417
br label %527
473: ; preds = %417
%474 = load i8*, i8** %6
%475 = load i32, i32* %11
%476 = sub nsw i32 %475, 2
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i8, i8* %474, i64 %477
%479 = load i8, i8* %478
%480 = zext i8 %479 to i32
%481 = mul nsw i32 4, %480
%482 = load i8*, i8** %6
%483 = load i32, i32* %11
%484 = sub nsw i32 %483, 1
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i8, i8* %482, i64 %485
%487 = load i8, i8* %486
%488 = zext i8 %487 to i32
%489 = mul nsw i32 17, %488
%490 = sub nsw i32 %481, %489
%491 = load i8*, i8** %6
%492 = load i32, i32* %11
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds i8, i8* %491, i64 %493
%495 = load i8, i8* %494
%496 = zext i8 %495 to i32
%497 = mul nsw i32 114, %496
%498 = add nsw i32 %490, %497
%499 = load i8*, i8** %6
%500 = load i32, i32* %11
%501 = add nsw i32 %500, 1
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds i8, i8* %499, i64 %502
%504 = load i8, i8* %503
%505 = zext i8 %504 to i32
%506 = mul nsw i32 35, %505
%507 = add nsw i32 %498, %506
%508 = load i8*, i8** %6
%509 = load i32, i32* %11
%510 = add nsw i32 %509, 2
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds i8, i8* %508, i64 %511
%513 = load i8, i8* %512
%514 = zext i8 %513 to i32
%515 = mul nsw i32 9, %514
%516 = sub nsw i32 %507, %515
%517 = load i8*, i8** %6
%518 = load i32, i32* %11
%519 = add nsw i32 %518, 3
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds i8, i8* %517, i64 %520
%522 = load i8, i8* %521
%523 = zext i8 %522 to i32
%524 = add nsw i32 %516, %523
%525 = add nsw i32 %524, 64
%526 = ashr i32 %525, 7
br label %527
527: ; preds = %473, %472
%528 = phi i32 [ 255, %472 ], [ %526, %473 ]
%529 = icmp slt i32 0, %528
br i1 %529, label %530, label %642
530: ; preds = %527
%531 = load i8*, i8** %6
%532 = load i32, i32* %11
%533 = sub nsw i32 %532, 2
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds i8, i8* %531, i64 %534
%536 = load i8, i8* %535
%537 = zext i8 %536 to i32
%538 = mul nsw i32 4, %537
%539 = load i8*, i8** %6
%540 = load i32, i32* %11
%541 = sub nsw i32 %540, 1
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds i8, i8* %539, i64 %542
%544 = load i8, i8* %543
%545 = zext i8 %544 to i32
%546 = mul nsw i32 17, %545
%547 = sub nsw i32 %538, %546
%548 = load i8*, i8** %6
%549 = load i32, i32* %11
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds i8, i8* %548, i64 %550
%552 = load i8, i8* %551
%553 = zext i8 %552 to i32
%554 = mul nsw i32 114, %553
%555 = add nsw i32 %547, %554
%556 = load i8*, i8** %6
%557 = load i32, i32* %11
%558 = add nsw i32 %557, 1
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds i8, i8* %556, i64 %559
%561 = load i8, i8* %560
%562 = zext i8 %561 to i32
%563 = mul nsw i32 35, %562
%564 = add nsw i32 %555, %563
%565 = load i8*, i8** %6
%566 = load i32, i32* %11
%567 = add nsw i32 %566, 2
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds i8, i8* %565, i64 %568
%570 = load i8, i8* %569
%571 = zext i8 %570 to i32
%572 = mul nsw i32 9, %571
%573 = sub nsw i32 %564, %572
%574 = load i8*, i8** %6
%575 = load i32, i32* %11
%576 = add nsw i32 %575, 3
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds i8, i8* %574, i64 %577
%579 = load i8, i8* %578
%580 = zext i8 %579 to i32
%581 = add nsw i32 %573, %580
%582 = add nsw i32 %581, 64
%583 = ashr i32 %582, 7
%584 = icmp sgt i32 %583, 255
br i1 %584, label %585, label %586
585: ; preds = %530
br label %640
586: ; preds = %530
%587 = load i8*, i8** %6
%588 = load i32, i32* %11
%589 = sub nsw i32 %588, 2
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds i8, i8* %587, i64 %590
%592 = load i8, i8* %591
%593 = zext i8 %592 to i32
%594 = mul nsw i32 4, %593
%595 = load i8*, i8** %6
%596 = load i32, i32* %11
%597 = sub nsw i32 %596, 1
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds i8, i8* %595, i64 %598
%600 = load i8, i8* %599
%601 = zext i8 %600 to i32
%602 = mul nsw i32 17, %601
%603 = sub nsw i32 %594, %602
%604 = load i8*, i8** %6
%605 = load i32, i32* %11
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i8, i8* %604, i64 %606
%608 = load i8, i8* %607
%609 = zext i8 %608 to i32
%610 = mul nsw i32 114, %609
%611 = add nsw i32 %603, %610
%612 = load i8*, i8** %6
%613 = load i32, i32* %11
%614 = add nsw i32 %613, 1
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds i8, i8* %612, i64 %615
%617 = load i8, i8* %616
%618 = zext i8 %617 to i32
%619 = mul nsw i32 35, %618
%620 = add nsw i32 %611, %619
%621 = load i8*, i8** %6
%622 = load i32, i32* %11
%623 = add nsw i32 %622, 2
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i8, i8* %621, i64 %624
%626 = load i8, i8* %625
%627 = zext i8 %626 to i32
%628 = mul nsw i32 9, %627
%629 = sub nsw i32 %620, %628
%630 = load i8*, i8** %6
%631 = load i32, i32* %11
%632 = add nsw i32 %631, 3
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds i8, i8* %630, i64 %633
%635 = load i8, i8* %634
%636 = zext i8 %635 to i32
%637 = add nsw i32 %629, %636
%638 = add nsw i32 %637, 64
%639 = ashr i32 %638, 7
br label %640
640: ; preds = %586, %585
%641 = phi i32 [ 255, %585 ], [ %639, %586 ]
br label %643
642: ; preds = %527
br label %643
643: ; preds = %642, %640
%644 = phi i32 [ %641, %640 ], [ 0, %642 ]
%645 = trunc i32 %644 to i8
%646 = load i8*, i8** %5
%647 = load i32, i32* %11
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds i8, i8* %646, i64 %648
store i8 %645, i8* %649
br label %650
650: ; preds = %643
%651 = load i32, i32* %11
%652 = add nsw i32 %651, 1
store i32 %652, i32* %11
br label %412
653: ; preds = %412
br label %654
654: ; preds = %979, %653
%655 = load i32, i32* %11
%656 = load i32, i32* %7
%657 = icmp slt i32 %655, %656
br i1 %657, label %658, label %982
658: ; preds = %654
%659 = load i8*, i8** %6
%660 = load i32, i32* %11
%661 = sub nsw i32 %660, 2
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds i8, i8* %659, i64 %662
%664 = load i8, i8* %663
%665 = zext i8 %664 to i32
%666 = mul nsw i32 4, %665
%667 = load i8*, i8** %6
%668 = load i32, i32* %11
%669 = sub nsw i32 %668, 1
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds i8, i8* %667, i64 %670
%672 = load i8, i8* %671
%673 = zext i8 %672 to i32
%674 = mul nsw i32 17, %673
%675 = sub nsw i32 %666, %674
%676 = load i8*, i8** %6
%677 = load i32, i32* %11
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds i8, i8* %676, i64 %678
%680 = load i8, i8* %679
%681 = zext i8 %680 to i32
%682 = mul nsw i32 114, %681
%683 = add nsw i32 %675, %682
%684 = load i8*, i8** %6
%685 = load i32, i32* %11
%686 = add nsw i32 %685, 1
%687 = load i32, i32* %7
%688 = sub nsw i32 %687, 1
%689 = icmp sgt i32 %686, %688
br i1 %689, label %690, label %693
690: ; preds = %658
%691 = load i32, i32* %7
%692 = sub nsw i32 %691, 1
br label %696
693: ; preds = %658
%694 = load i32, i32* %11
%695 = add nsw i32 %694, 1
br label %696
696: ; preds = %693, %690
%697 = phi i32 [ %692, %690 ], [ %695, %693 ]
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i8, i8* %684, i64 %698
%700 = load i8, i8* %699
%701 = zext i8 %700 to i32
%702 = mul nsw i32 35, %701
%703 = add nsw i32 %683, %702
%704 = load i8*, i8** %6
%705 = load i32, i32* %11
%706 = add nsw i32 %705, 2
%707 = load i32, i32* %7
%708 = sub nsw i32 %707, 1
%709 = icmp sgt i32 %706, %708
br i1 %709, label %710, label %713
710: ; preds = %696
%711 = load i32, i32* %7
%712 = sub nsw i32 %711, 1
br label %716
713: ; preds = %696
%714 = load i32, i32* %11
%715 = add nsw i32 %714, 2
br label %716
716: ; preds = %713, %710
%717 = phi i32 [ %712, %710 ], [ %715, %713 ]
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds i8, i8* %704, i64 %718
%720 = load i8, i8* %719
%721 = zext i8 %720 to i32
%722 = mul nsw i32 9, %721
%723 = sub nsw i32 %703, %722
%724 = load i8*, i8** %6
%725 = load i32, i32* %7
%726 = sub nsw i32 %725, 1
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds i8, i8* %724, i64 %727
%729 = load i8, i8* %728
%730 = zext i8 %729 to i32
%731 = add nsw i32 %723, %730
%732 = add nsw i32 %731, 64
%733 = ashr i32 %732, 7
%734 = icmp sgt i32 %733, 255
br i1 %734, label %735, label %736
735: ; preds = %716
br label %812
736: ; preds = %716
%737 = load i8*, i8** %6
%738 = load i32, i32* %11
%739 = sub nsw i32 %738, 2
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds i8, i8* %737, i64 %740
%742 = load i8, i8* %741
%743 = zext i8 %742 to i32
%744 = mul nsw i32 4, %743
%745 = load i8*, i8** %6
%746 = load i32, i32* %11
%747 = sub nsw i32 %746, 1
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds i8, i8* %745, i64 %748
%750 = load i8, i8* %749
%751 = zext i8 %750 to i32
%752 = mul nsw i32 17, %751
%753 = sub nsw i32 %744, %752
%754 = load i8*, i8** %6
%755 = load i32, i32* %11
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds i8, i8* %754, i64 %756
%758 = load i8, i8* %757
%759 = zext i8 %758 to i32
%760 = mul nsw i32 114, %759
%761 = add nsw i32 %753, %760
%762 = load i8*, i8** %6
%763 = load i32, i32* %11
%764 = add nsw i32 %763, 1
%765 = load i32, i32* %7
%766 = sub nsw i32 %765, 1
%767 = icmp sgt i32 %764, %766
br i1 %767, label %768, label %771
768: ; preds = %736
%769 = load i32, i32* %7
%770 = sub nsw i32 %769, 1
br label %774
771: ; preds = %736
%772 = load i32, i32* %11
%773 = add nsw i32 %772, 1
br label %774
774: ; preds = %771, %768
%775 = phi i32 [ %770, %768 ], [ %773, %771 ]
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds i8, i8* %762, i64 %776
%778 = load i8, i8* %777
%779 = zext i8 %778 to i32
%780 = mul nsw i32 35, %779
%781 = add nsw i32 %761, %780
%782 = load i8*, i8** %6
%783 = load i32, i32* %11
%784 = add nsw i32 %783, 2
%785 = load i32, i32* %7
%786 = sub nsw i32 %785, 1
%787 = icmp sgt i32 %784, %786
br i1 %787, label %788, label %791
788: ; preds = %774
%789 = load i32, i32* %7
%790 = sub nsw i32 %789, 1
br label %794
791: ; preds = %774
%792 = load i32, i32* %11
%793 = add nsw i32 %792, 2
br label %794
794: ; preds = %791, %788
%795 = phi i32 [ %790, %788 ], [ %793, %791 ]
%796 = sext i32 %795 to i64
%797 = getelementptr inbounds i8, i8* %782, i64 %796
%798 = load i8, i8* %797
%799 = zext i8 %798 to i32
%800 = mul nsw i32 9, %799
%801 = sub nsw i32 %781, %800
%802 = load i8*, i8** %6
%803 = load i32, i32* %7
%804 = sub nsw i32 %803, 1
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds i8, i8* %802, i64 %805
%807 = load i8, i8* %806
%808 = zext i8 %807 to i32
%809 = add nsw i32 %801, %808
%810 = add nsw i32 %809, 64
%811 = ashr i32 %810, 7
br label %812
812: ; preds = %794, %735
%813 = phi i32 [ 255, %735 ], [ %811, %794 ]
%814 = icmp slt i32 0, %813
br i1 %814, label %815, label %971
815: ; preds = %812
%816 = load i8*, i8** %6
%817 = load i32, i32* %11
%818 = sub nsw i32 %817, 2
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds i8, i8* %816, i64 %819
%821 = load i8, i8* %820
%822 = zext i8 %821 to i32
%823 = mul nsw i32 4, %822
%824 = load i8*, i8** %6
%825 = load i32, i32* %11
%826 = sub nsw i32 %825, 1
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds i8, i8* %824, i64 %827
%829 = load i8, i8* %828
%830 = zext i8 %829 to i32
%831 = mul nsw i32 17, %830
%832 = sub nsw i32 %823, %831
%833 = load i8*, i8** %6
%834 = load i32, i32* %11
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds i8, i8* %833, i64 %835
%837 = load i8, i8* %836
%838 = zext i8 %837 to i32
%839 = mul nsw i32 114, %838
%840 = add nsw i32 %832, %839
%841 = load i8*, i8** %6
%842 = load i32, i32* %11
%843 = add nsw i32 %842, 1
%844 = load i32, i32* %7
%845 = sub nsw i32 %844, 1
%846 = icmp sgt i32 %843, %845
br i1 %846, label %847, label %850
847: ; preds = %815
%848 = load i32, i32* %7
%849 = sub nsw i32 %848, 1
br label %853
850: ; preds = %815
%851 = load i32, i32* %11
%852 = add nsw i32 %851, 1
br label %853
853: ; preds = %850, %847
%854 = phi i32 [ %849, %847 ], [ %852, %850 ]
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds i8, i8* %841, i64 %855
%857 = load i8, i8* %856
%858 = zext i8 %857 to i32
%859 = mul nsw i32 35, %858
%860 = add nsw i32 %840, %859
%861 = load i8*, i8** %6
%862 = load i32, i32* %11
%863 = add nsw i32 %862, 2
%864 = load i32, i32* %7
%865 = sub nsw i32 %864, 1
%866 = icmp sgt i32 %863, %865
br i1 %866, label %867, label %870
867: ; preds = %853
%868 = load i32, i32* %7
%869 = sub nsw i32 %868, 1
br label %873
870: ; preds = %853
%871 = load i32, i32* %11
%872 = add nsw i32 %871, 2
br label %873
873: ; preds = %870, %867
%874 = phi i32 [ %869, %867 ], [ %872, %870 ]
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds i8, i8* %861, i64 %875
%877 = load i8, i8* %876
%878 = zext i8 %877 to i32
%879 = mul nsw i32 9, %878
%880 = sub nsw i32 %860, %879
%881 = load i8*, i8** %6
%882 = load i32, i32* %7
%883 = sub nsw i32 %882, 1
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds i8, i8* %881, i64 %884
%886 = load i8, i8* %885
%887 = zext i8 %886 to i32
%888 = add nsw i32 %880, %887
%889 = add nsw i32 %888, 64
%890 = ashr i32 %889, 7
%891 = icmp sgt i32 %890, 255
br i1 %891, label %892, label %893
892: ; preds = %873
br label %969
893: ; preds = %873
%894 = load i8*, i8** %6
%895 = load i32, i32* %11
%896 = sub nsw i32 %895, 2
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds i8, i8* %894, i64 %897
%899 = load i8, i8* %898
%900 = zext i8 %899 to i32
%901 = mul nsw i32 4, %900
%902 = load i8*, i8** %6
%903 = load i32, i32* %11
%904 = sub nsw i32 %903, 1
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds i8, i8* %902, i64 %905
%907 = load i8, i8* %906
%908 = zext i8 %907 to i32
%909 = mul nsw i32 17, %908
%910 = sub nsw i32 %901, %909
%911 = load i8*, i8** %6
%912 = load i32, i32* %11
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds i8, i8* %911, i64 %913
%915 = load i8, i8* %914
%916 = zext i8 %915 to i32
%917 = mul nsw i32 114, %916
%918 = add nsw i32 %910, %917
%919 = load i8*, i8** %6
%920 = load i32, i32* %11
%921 = add nsw i32 %920, 1
%922 = load i32, i32* %7
%923 = sub nsw i32 %922, 1
%924 = icmp sgt i32 %921, %923
br i1 %924, label %925, label %928
925: ; preds = %893
%926 = load i32, i32* %7
%927 = sub nsw i32 %926, 1
br label %931
928: ; preds = %893
%929 = load i32, i32* %11
%930 = add nsw i32 %929, 1
br label %931
931: ; preds = %928, %925
%932 = phi i32 [ %927, %925 ], [ %930, %928 ]
%933 = sext i32 %932 to i64
%934 = getelementptr inbounds i8, i8* %919, i64 %933
%935 = load i8, i8* %934
%936 = zext i8 %935 to i32
%937 = mul nsw i32 35, %936
%938 = add nsw i32 %918, %937
%939 = load i8*, i8** %6
%940 = load i32, i32* %11
%941 = add nsw i32 %940, 2
%942 = load i32, i32* %7
%943 = sub nsw i32 %942, 1
%944 = icmp sgt i32 %941, %943
br i1 %944, label %945, label %948
945: ; preds = %931
%946 = load i32, i32* %7
%947 = sub nsw i32 %946, 1
br label %951
948: ; preds = %931
%949 = load i32, i32* %11
%950 = add nsw i32 %949, 2
br label %951
951: ; preds = %948, %945
%952 = phi i32 [ %947, %945 ], [ %950, %948 ]
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds i8, i8* %939, i64 %953
%955 = load i8, i8* %954
%956 = zext i8 %955 to i32
%957 = mul nsw i32 9, %956
%958 = sub nsw i32 %938, %957
%959 = load i8*, i8** %6
%960 = load i32, i32* %7
%961 = sub nsw i32 %960, 1
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds i8, i8* %959, i64 %962
%964 = load i8, i8* %963
%965 = zext i8 %964 to i32
%966 = add nsw i32 %958, %965
%967 = add nsw i32 %966, 64
%968 = ashr i32 %967, 7
br label %969
969: ; preds = %951, %892
%970 = phi i32 [ 255, %892 ], [ %968, %951 ]
br label %972
971: ; preds = %812
br label %972
972: ; preds = %971, %969
%973 = phi i32 [ %970, %969 ], [ 0, %971 ]
%974 = trunc i32 %973 to i8
%975 = load i8*, i8** %5
%976 = load i32, i32* %11
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds i8, i8* %975, i64 %977
store i8 %974, i8* %978
br label %979
979: ; preds = %972
%980 = load i32, i32* %11
%981 = add nsw i32 %980, 1
store i32 %981, i32* %11
br label %654
982: ; preds = %654
%983 = load i32, i32* %7
%984 = load i8*, i8** %5
%985 = sext i32 %983 to i64
%986 = getelementptr inbounds i8, i8* %984, i64 %985
store i8* %986, i8** %5
%987 = load i32, i32* %7
%988 = load i8*, i8** %6
%989 = sext i32 %987 to i64
%990 = getelementptr inbounds i8, i8* %988, i64 %989
store i8* %990, i8** %6
br label %991
991: ; preds = %982
%992 = load i32, i32* %10
%993 = add nsw i32 %992, 1
store i32 %993, i32* %10
br label %12
994: ; preds = %12
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
}