void png_predict(unsigned char *samples, unsigned int width,
                 unsigned int height, unsigned int n, unsigned int depth) {
  unsigned int stride = (width * n * depth + 7) / 8;
  unsigned int bpp = (n * depth + 7) / 8;
  unsigned int i, row;
  for (row = 0; row < height; row++) {
    unsigned char *src = samples + (unsigned int)((stride + 1) * row);
    unsigned char *dst = samples + (unsigned int)(stride * row);
    unsigned char *a = dst;
    unsigned char *b = dst - stride;
    unsigned char *c = dst - stride;
    switch (*src++) {
    default:
    case 0:
      for (i = 0; i < stride; i++)
        *dst++ = *src++;
      break;
    case 1:
      for (i = 0; i < bpp; i++)
        *dst++ = *src++;
      for (i = bpp; i < stride; i++)
        *dst++ = *src++ + *a++;
      break;
    case 2:
      if (row == 0)
        for (i = 0; i < stride; i++)
          *dst++ = *src++;
      else
        for (i = 0; i < stride; i++)
          *dst++ = *src++ + *b++;
      break;
    case 3:
      if (row == 0) {
        for (i = 0; i < bpp; i++)
          *dst++ = *src++;
        for (i = bpp; i < stride; i++)
          *dst++ = *src++ + (*a++ >> 1);
      } else {
        for (i = 0; i < bpp; i++)
          *dst++ = *src++ + (*b++ >> 1);
        for (i = bpp; i < stride; i++)
          *dst++ = *src++ + ((*b++ + *a++) >> 1);
      }
      break;
    case 4:
      if (row == 0) {
        for (i = 0; i < bpp; i++)
          *dst++ = *src++ + paeth(0, 0, 0);
        for (i = bpp; i < stride; i++)
          *dst++ = *src++ + paeth(*a++, 0, 0);
      } else {
        for (i = 0; i < bpp; i++)
          *dst++ = *src++ + paeth(0, *b++, 0);
        for (i = bpp; i < stride; i++)
          *dst++ = *src++ + paeth(*a++, *b++, *c++);
      }
      break;
    }
  }
}


x86 assembly (clang, -O0):
<png_predict>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
add    $0x7,%eax
shr    $0x3,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
add    $0x7,%eax
shr    $0x3,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    16fa <png_predict+0x5ea>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   %edx,%ecx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   %edx,%ecx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x58(%rbp)
sub    $0x4,%rax
ja     11e3 <png_predict+0xd3>
mov    -0x58(%rbp),%rax
lea    0xe26(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    11e8 <png_predict+0xd8>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    122b <png_predict+0x11b>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ef <png_predict+0xdf>
jmp    16e7 <png_predict+0x5d7>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    1273 <png_predict+0x163>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1237 <png_predict+0x127>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12cc <png_predict+0x1bc>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
movzbl (%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1279 <png_predict+0x169>
jmp    16e7 <png_predict+0x5d7>
cmpl   $0x0,-0x28(%rbp)
jne    1323 <png_predict+0x213>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    131e <png_predict+0x20e>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e2 <png_predict+0x1d2>
jmp    1382 <png_predict+0x272>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    137d <png_predict+0x26d>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
movzbl (%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    132a <png_predict+0x21a>
jmp    1382 <png_predict+0x272>
jmp    16e7 <png_predict+0x5d7>
cmpl   $0x0,-0x28(%rbp)
jne    1435 <png_predict+0x325>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    13d4 <png_predict+0x2c4>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1398 <png_predict+0x288>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1430 <png_predict+0x320>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
movzbl (%rcx),%ecx
sar    $0x1,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13da <png_predict+0x2ca>
jmp    1507 <png_predict+0x3f7>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    1492 <png_predict+0x382>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
movzbl (%rcx),%ecx
sar    $0x1,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    143c <png_predict+0x32c>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1502 <png_predict+0x3f2>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
movzbl (%rcx),%ecx
mov    -0x40(%rbp),%rdx
mov    %rdx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
movzbl (%rdx),%edx
add    %edx,%ecx
sar    $0x1,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1498 <png_predict+0x388>
jmp    1507 <png_predict+0x3f7>
jmp    16e7 <png_predict+0x5d7>
cmpl   $0x0,-0x28(%rbp)
jne    15e4 <png_predict+0x4d4>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    1573 <png_predict+0x463>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x5c(%rbp)
xor    %edx,%edx
mov    %edx,%edi
mov    %edx,%esi
mov    $0x0,%al
call   1030 <paeth@plt>
mov    %eax,%ecx
mov    -0x5c(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    151d <png_predict+0x40d>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    15df <png_predict+0x4cf>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%edi
xor    %edx,%edx
mov    %edx,%esi
mov    $0x0,%al
call   1030 <paeth@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1579 <png_predict+0x469>
jmp    16e2 <png_predict+0x5d2>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    1651 <png_predict+0x541>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movzbl (%rax),%esi
xor    %edx,%edx
mov    %edx,%edi
mov    $0x0,%al
call   1030 <paeth@plt>
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15eb <png_predict+0x4db>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    16dd <png_predict+0x5cd>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%edi
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movzbl (%rax),%esi
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movzbl (%rax),%edx
mov    $0x0,%al
call   1030 <paeth@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1657 <png_predict+0x547>
jmp    16e2 <png_predict+0x5d2>
jmp    16e7 <png_predict+0x5d7>
jmp    16ec <png_predict+0x5dc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1154 <png_predict+0x44>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<png_predict>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    %rdi,0xc8(%rsp)
test   %edx,%edx
je     2dc3 <png_predict+0x1cb3>
imul   %ecx,%r8d
imul   %r8d,%esi
add    $0x7,%esi
mov    %esi,0x8c(%rsp)
mov    %esi,%r13d
shr    $0x3,%r13d
add    $0x7,%r8d
mov    %r8d,0x34(%rsp)
mov    %r8d,%r15d
shr    $0x3,%r15d
mov    %r13d,%r10d
mov    %r10,%rcx
neg    %rcx
mov    %rcx,0x168(%rsp)
cmp    $0x2,%r15d
mov    $0x1,%ecx
cmovae %r15d,%ecx
mov    $0x1,%esi
cmp    $0x2,%r13d
cmovae %r13d,%esi
mov    %rsi,0x98(%rsp)
lea    -0x1(%rsi),%eax
mov    %rax,0x78(%rsp)
lea    0x1(%rax),%rsi
mov    %r15d,%r12d
not    %r12d
add    %r13d,%r12d
mov    %rcx,0x58(%rsp)
lea    -0x1(%rcx),%eax
mov    %rax,0xb0(%rsp)
lea    0x1(%rax),%rbx
mov    %rsi,%r11
mov    %rsi,%rbp
mov    %rsi,0x38(%rsp)
sub    %r10,%r11
mov    0xc8(%rsp),%rdi
add    %rdi,%r11
mov    %rbx,%rsi
sub    %r10,%rsi
mov    %r10,0xd0(%rsp)
add    %rdi,%rsi
mov    %rbx,0x100(%rsp)
and    $0xffffffffffffffe0,%rbx
mov    %rbx,0xf8(%rsp)
add    $0xffffffffffffffe0,%rbx
mov    %rbx,0xf0(%rsp)
shr    $0x5,%rbx
add    $0x1,%rbx
lea    0x1(%r12),%rcx
mov    %rcx,%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x18(%rsp)
lea    -0x20(%rax),%r8
mov    %r8,0x148(%rsp)
shr    $0x5,%r8
add    $0x1,%r8
mov    %rbp,%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x48(%rsp)
add    $0xffffffffffffffe0,%rax
mov    %rax,0xd8(%rsp)
mov    %edx,(%rsp)
mov    %rax,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
cmp    %rdi,%rsi
seta   %r9b
mov    %rdi,%r14
sub    %r10,%r14
mov    0xb0(%rsp),%rax
lea    (%rdi,%rax,1),%rsi
add    $0x1,%rsi
mov    %rsi,0x1c8(%rsp)
cmp    %rsi,%r14
setb   %al
and    %r9b,%al
mov    %al,0x17(%rsp)
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x190(%rsp)
movabs $0x1ffffffe0,%r9
or     $0x18,%r9
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
mov    %rcx,%rbp
and    %r9,%rbp
mov    %ebx,%r10d
and    $0x3,%r10d
movabs $0xffffffffffffffe,%rcx
ff ff 0f
add    $0xfffffffffffffffe,%rcx
mov    %rbx,%rsi
mov    %rbx,0x158(%rsp)
and    %rcx,%rbx
mov    %rbx,0x138(%rsp)
mov    %r8,%rax
mov    %r8,0x140(%rsp)
and    $0xfffffffffffffffe,%r8
mov    %r8,0x128(%rsp)
cmp    %rdi,%r11
seta   %al
mov    0x78(%rsp),%r8
lea    (%rdi,%r8,1),%rsi
add    $0x1,%rsi
mov    %rsi,0x160(%rsp)
cmp    %rsi,%r14
setb   %bl
and    %al,%bl
mov    %bl,0x16(%rsp)
mov    (%rsp),%eax
mov    %rax,0x1e0(%rsp)
mov    0xd0(%rsp),%rax
add    $0x1,%rax
mov    %rax,0xa8(%rsp)
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x180(%rsp)
mov    0x38(%rsp),%rbx
and    %rbx,%r9
mov    %r9,0xe0(%rsp)
mov    %edx,%esi
and    $0x3,%esi
mov    %rdx,%rax
mov    %rdx,0x150(%rsp)
and    %rdx,%rcx
mov    %rcx,0x120(%rsp)
mov    %r10,0x188(%rsp)
shl    $0x5,%r10
mov    %r10,0xc0(%rsp)
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
neg    %rax
mov    %rax,0x198(%rsp)
mov    %rsi,0x178(%rsp)
shl    $0x5,%rsi
mov    %rsi,0x130(%rsp)
mov    %r13d,%eax
sub    %r15d,%eax
mov    %rax,0xd0(%rsp)
movdqa 0x1c3e(%rip),%xmm4
lea    0x1(%r13),%eax
lea    0x1(%rdi),%rcx
mov    %rcx,0x60(%rsp)
mov    %r8,%rcx
lea    0x2(%r8,%rdi,1),%rcx
mov    %rcx,0x110(%rsp)
mov    %r12,0x90(%rsp)
lea    0x1(%rdi,%r12,1),%rcx
mov    %rcx,0x1c0(%rsp)
mov    0xb0(%rsp),%rcx
lea    0x2(%rcx,%rdi,1),%rcx
mov    %rcx,0x108(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%r15,1),%ecx
mov    %ecx,0x84(%rsp)
mov    %r15,0x8(%rsp)
mov    %rbp,0xe8(%rsp)
lea    0x0(%rbp,%r15,1),%ecx
mov    %ecx,0x88(%rsp)
mov    %r14,0x1a0(%rsp)
lea    0x30(%r14),%rcx
mov    %rcx,0x1b8(%rsp)
lea    0x30(%rdi),%rcx
mov    %rcx,0x1b0(%rsp)
lea    0x31(%rdi),%rcx
mov    %rcx,0x1a8(%rsp)
lea    0x10(%rdi),%rcx
mov    %rcx,0xa0(%rsp)
lea    0x70(%rdi),%rcx
mov    %rcx,0x1d8(%rsp)
lea    0x71(%rdi),%rcx
mov    %rcx,0x1d0(%rsp)
lea    0x11(%rdi),%rcx
mov    %rcx,0xb8(%rsp)
xor    %ebx,%ebx
xor    %edx,%edx
xor    %esi,%esi
mov    %r13,0x70(%rsp)
mov    %rax,0x170(%rsp)
jmp    14eb <png_predict+0x3db>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x40(%rsp),%rsi
add    $0x1,%rsi
mov    0x70(%rsp),%r13
mov    0x28(%rsp),%rdx
add    %r13d,%edx
mov    0x170(%rsp),%rax
mov    0x50(%rsp),%rbx
add    %eax,%ebx
cmp    0x1e0(%rsp),%rsi
movdqa 0x1b1b(%rip),%xmm4
je     2dc3 <png_predict+0x1cb3>
mov    %ebx,%ebx
mov    0x60(%rsp),%rcx
add    %rbx,%rcx
mov    %rcx,0x118(%rsp)
mov    %edx,%edx
mov    0xc8(%rsp),%rbp
lea    0x0(%rbp,%rdx,1),%rcx
mov    %rcx,0x68(%rsp)
mov    0x1d8(%rsp),%rcx
lea    (%rcx,%rdx,1),%r11
mov    0x1d0(%rsp),%rcx
lea    (%rcx,%rbx,1),%r8
mov    %r13d,%ecx
imul   %esi,%ecx
lea    (%rcx,%rbp,1),%r10
mov    %eax,%edi
imul   %esi,%edi
mov    0x0(%rbp,%rdi,1),%al
lea    (%rdi,%rbp,1),%r12
add    $0x1,%r12
add    $0xff,%al
cmp    $0x3,%al
mov    %rdx,0x28(%rsp)
mov    %rbx,0x50(%rsp)
mov    %rsi,0x40(%rsp)
ja     15e0 <png_predict+0x4d0>
mov    0x1b0(%rsp),%rdi
lea    (%rdi,%rdx,1),%r9
mov    0x1b8(%rsp),%rdi
add    %rdx,%rdi
mov    0x1a8(%rsp),%rbp
lea    0x0(%rbp,%rbx,1),%rbp
mov    0x1c8(%rsp),%rbx
mov    %r10,%rsi
lea    (%rbx,%rcx,1),%r10
mov    0x1c0(%rsp),%rbx
lea    (%rbx,%rcx,1),%r15
mov    0x168(%rsp),%rbx
mov    %rsi,(%rsp)
lea    (%rsi,%rbx,1),%r14
movzbl %al,%eax
lea    0x1a5a(%rip),%rbx
movslq (%rbx,%rax,4),%rax
add    %rbx,%rax
jmp    *%rax
cmpl   $0x8,0x34(%rsp)
jae    17ef <png_predict+0x6df>
mov    (%rsp),%r10
mov    %r10,%rdx
jmp    1f30 <png_predict+0xe20>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x8,0x8c(%rsp)
08
jb     14b0 <png_predict+0x3a0>
xor    %r9d,%r9d
cmpl   $0x7,0x78(%rsp)
jb     29d1 <png_predict+0x18c1>
mov    0xc8(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
mov    0x40(%rsp),%rdi
imul   0x170(%rsp),%edi
mov    0x110(%rsp),%rax
lea    (%rax,%rdi,1),%rbp
cmp    %rbp,%rdx
jae    163c <png_predict+0x52c>
add    0x160(%rsp),%rcx
add    0x60(%rsp),%rdi
cmp    %rcx,%rdi
jb     29d1 <png_predict+0x18c1>
cmpl   $0x1f,0x78(%rsp)
jae    1e07 <png_predict+0xcf7>
xor    %eax,%eax
jmp    254f <png_predict+0x143f>
xchg   %ax,%ax
mov    0x160(%rsp),%rax
add    %rax,%rcx
cmpq   $0x0,0x40(%rsp)
je     18d8 <png_predict+0x7c8>
cmpl   $0x8,0x8c(%rsp)
08
mov    (%rsp),%r15
jb     14b0 <png_predict+0x3a0>
xor    %r8d,%r8d
cmpl   $0x7,0x78(%rsp)
jb     2c06 <png_predict+0x1af6>
mov    0xa8(%rsp),%rax
imul   0x40(%rsp),%eax
mov    0x60(%rsp),%rdx
lea    (%rdx,%rax,1),%rsi
add    0x110(%rsp),%rax
cmp    %rax,%r15
setb   %al
cmp    %rcx,%rsi
setb   %cl
and    %al,%cl
or     0x16(%rsp),%cl
jne    2c06 <png_predict+0x1af6>
cmpl   $0x1f,0x78(%rsp)
jae    218c <png_predict+0x107c>
xor    %eax,%eax
mov    0x50(%rsp),%rcx
mov    0x28(%rsp),%rdx
jmp    2277 <png_predict+0x1167>
nopl   0x0(%rax)
cmpq   $0x0,0x40(%rsp)
je     1935 <png_predict+0x825>
cmpl   $0x8,0x34(%rsp)
jae    19cd <png_predict+0x8bd>
mov    (%rsp),%r8
mov    %r8,%rcx
jmp    1cfa <png_predict+0xbea>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,0x40(%rsp)
je     194c <png_predict+0x83c>
mov    0x1a0(%rsp),%rax
lea    (%rax,%rdx,1),%r13
cmpl   $0x8,0x34(%rsp)
mov    (%rsp),%r15
jb     1780 <png_predict+0x670>
xor    %ebx,%ebx
mov    0x58(%rsp),%r14
mov    0x68(%rsp),%r15
mov    0x118(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movzbl (%r12,%rbx,1),%ebp
movzbl 0x0(%r13,%rbx,1),%esi
xor    %edi,%edi
xor    %edx,%edx
xor    %eax,%eax
call   1030 <paeth@plt>
add    %bpl,%al
mov    %al,(%r15,%rbx,1)
add    $0x1,%rbx
cmp    %ebx,%r14d
jne    1750 <png_predict+0x640>
lea    (%rbx,%r13,1),%r14
add    %rbx,%r15
add    %rbx,%r12
mov    0x8(%rsp),%rax
cmp    0x70(%rsp),%eax
mov    0x68(%rsp),%rax
jae    14b0 <png_predict+0x3a0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movzbl (%r12,%rbp,1),%edx
mov    %dl,(%rsp)
movzbl (%rax,%rbp,1),%edi
movzbl (%r14,%rbp,1),%esi
movzbl 0x0(%r13,%rbp,1),%edx
mov    %r12,%rbx
mov    %r13,%r12
mov    %r14,%r13
mov    %rax,%r14
xor    %eax,%eax
call   1030 <paeth@plt>
add    (%rsp),%al
mov    %al,(%r15,%rbp,1)
mov    %r14,%rax
mov    %r13,%r14
mov    %r12,%r13
mov    %rbx,%r12
add    $0x1,%rbp
cmp    %ebp,0xd0(%rsp)
jne    17a0 <png_predict+0x690>
jmp    14b0 <png_predict+0x3a0>
xor    %ebp,%ebp
cmpl   $0x1f,0xb0(%rsp)
1f
jb     182c <png_predict+0x71c>
mov    0xa8(%rsp),%rcx
imul   0x40(%rsp),%ecx
mov    0x108(%rsp),%rax
lea    (%rax,%rcx,1),%rdi
cmp    %rdi,(%rsp)
jae    1b15 <png_predict+0xa05>
add    0x60(%rsp),%rcx
cmp    %r10,%rcx
jae    1b15 <png_predict+0xa05>
mov    (%rsp),%r10
mov    %r10,%rdx
mov    0x58(%rsp),%rax
mov    %eax,%ecx
sub    %ebp,%ecx
mov    %ebp,%esi
not    %esi
add    %eax,%esi
and    $0x7,%ecx
je     1869 <png_predict+0x759>
neg    %ecx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movzbl (%r12),%eax
add    $0x1,%r12
mov    %al,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%ecx
jne    1850 <png_predict+0x740>
sub    %edi,%ebp
cmp    $0x7,%esi
jb     1f30 <png_predict+0xe20>
mov    0x58(%rsp),%rax
mov    %eax,%ecx
sub    %ebp,%ecx
nopl   0x0(%rax,%rax,1)
movzbl (%r12),%eax
mov    %al,(%rdx)
movzbl 0x1(%r12),%eax
mov    %al,0x1(%rdx)
movzbl 0x2(%r12),%eax
mov    %al,0x2(%rdx)
movzbl 0x3(%r12),%eax
mov    %al,0x3(%rdx)
movzbl 0x4(%r12),%eax
mov    %al,0x4(%rdx)
movzbl 0x5(%r12),%eax
mov    %al,0x5(%rdx)
movzbl 0x6(%r12),%eax
mov    %al,0x6(%rdx)
movzbl 0x7(%r12),%eax
add    $0x8,%r12
mov    %al,0x7(%rdx)
add    $0x8,%rdx
add    $0xfffffff8,%ecx
jne    1880 <png_predict+0x770>
jmp    1f30 <png_predict+0xe20>
cmpl   $0x8,0x8c(%rsp)
08
mov    (%rsp),%r15
jb     14b0 <png_predict+0x3a0>
xor    %ebx,%ebx
cmpl   $0x7,0x78(%rsp)
jb     2d0d <png_predict+0x1bfd>
mov    0xa8(%rsp),%rdi
imul   0x40(%rsp),%edi
mov    0x110(%rsp),%rax
lea    (%rax,%rdi,1),%rbp
cmp    %rbp,%r15
jae    1923 <png_predict+0x813>
add    0x60(%rsp),%rdi
cmp    %rcx,%rdi
jb     2d0d <png_predict+0x1bfd>
cmpl   $0x1f,0x78(%rsp)
jae    25ad <png_predict+0x149d>
xor    %eax,%eax
jmp    2b8f <png_predict+0x1a7f>
cmpl   $0x8,0x34(%rsp)
jae    19ea <png_predict+0x8da>
mov    (%rsp),%r10
mov    %r10,%rdx
jmp    26ee <png_predict+0x15de>
mov    0x58(%rsp),%rax
mov    %eax,%ebp
cmpl   $0x8,0x34(%rsp)
mov    (%rsp),%r15
jb     1984 <png_predict+0x874>
xchg   %ax,%ax
movzbl (%r12),%ebx
add    $0x1,%r12
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1030 <paeth@plt>
add    %bl,%al
mov    %al,(%r15)
add    $0x1,%r15
add    $0xffffffff,%ebp
jne    1960 <png_predict+0x850>
cmp    %r13d,0x8(%rsp)
mov    0x68(%rsp),%r14
jae    14b0 <png_predict+0x3a0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movzbl (%r12,%rbp,1),%ebx
movzbl (%r14,%rbp,1),%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1030 <paeth@plt>
add    %bl,%al
mov    %al,(%r15,%rbp,1)
add    $0x1,%rbp
cmp    %ebp,0xd0(%rsp)
jne    19a0 <png_predict+0x890>
jmp    14b0 <png_predict+0x3a0>
xor    %r11d,%r11d
cmpl   $0x1f,0xb0(%rsp)
1f
jae    1ad8 <png_predict+0x9c8>
mov    (%rsp),%r8
mov    %r8,%rcx
jmp    1c5a <png_predict+0xb4a>
xor    %ebp,%ebp
cmpl   $0x1f,0xb0(%rsp)
1f
jb     1a27 <png_predict+0x917>
mov    0xa8(%rsp),%rcx
imul   0x40(%rsp),%ecx
mov    0x108(%rsp),%rax
lea    (%rax,%rcx,1),%rdi
cmp    %rdi,(%rsp)
jae    2165 <png_predict+0x1055>
add    0x60(%rsp),%rcx
cmp    %r10,%rcx
jae    2165 <png_predict+0x1055>
mov    (%rsp),%r10
mov    %r10,%rdx
mov    0x58(%rsp),%rax
mov    %eax,%ecx
sub    %ebp,%ecx
mov    %ebp,%esi
not    %esi
add    %eax,%esi
and    $0x7,%ecx
je     1a69 <png_predict+0x959>
neg    %ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movzbl (%r12),%eax
add    $0x1,%r12
mov    %al,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%ecx
jne    1a50 <png_predict+0x940>
sub    %edi,%ebp
cmp    $0x7,%esi
jb     26ee <png_predict+0x15de>
mov    0x58(%rsp),%rax
mov    %eax,%ecx
sub    %ebp,%ecx
nopl   0x0(%rax,%rax,1)
movzbl (%r12),%eax
mov    %al,(%rdx)
movzbl 0x1(%r12),%eax
mov    %al,0x1(%rdx)
movzbl 0x2(%r12),%eax
mov    %al,0x2(%rdx)
movzbl 0x3(%r12),%eax
mov    %al,0x3(%rdx)
movzbl 0x4(%r12),%eax
mov    %al,0x4(%rdx)
movzbl 0x5(%r12),%eax
mov    %al,0x5(%rdx)
movzbl 0x6(%r12),%eax
mov    %al,0x6(%rdx)
movzbl 0x7(%r12),%eax
add    $0x8,%r12
mov    %al,0x7(%rdx)
add    $0x8,%rdx
add    $0xfffffff8,%ecx
jne    1a80 <png_predict+0x970>
jmp    26ee <png_predict+0x15de>
mov    0xa8(%rsp),%rax
imul   0x40(%rsp),%eax
mov    0x60(%rsp),%rcx
add    %rax,%rcx
add    0x108(%rsp),%rax
mov    (%rsp),%r8
cmp    %rax,%r8
setb   %al
cmp    %r10,%rcx
setb   %cl
and    %al,%cl
or     0x17(%rsp),%cl
je     1b3c <png_predict+0xa2c>
mov    %r8,%rcx
jmp    1c5a <png_predict+0xb4a>
cmpq   $0x60,0xf0(%rsp)
jae    1e27 <png_predict+0xd17>
xor    %eax,%eax
mov    0xc0(%rsp),%rdi
mov    0x28(%rsp),%rdx
mov    (%rsp),%r10
jmp    1ebc <png_predict+0xdac>
cmpq   $0x0,0xf0(%rsp)
je     2594 <png_predict+0x1484>
mov    0x190(%rsp),%rcx
xor    %edx,%edx
mov    (%rsp),%r8
nopl   0x0(%rax)
movdqu -0x30(%rbp,%rdx,1),%xmm0
movdqu -0x20(%rbp,%rdx,1),%xmm1
movdqu -0x30(%rdi,%rdx,1),%xmm2
movdqu -0x20(%rdi,%rdx,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,-0x30(%r9,%rdx,1)
movdqu %xmm3,-0x20(%r9,%rdx,1)
movdqu -0x10(%rbp,%rdx,1),%xmm0
movdqu 0x0(%rbp,%rdx,1),%xmm1
movdqu -0x10(%rdi,%rdx,1),%xmm2
movdqu (%rdi,%rdx,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,-0x10(%r9,%rdx,1)
movdqu %xmm3,(%r9,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1b60 <png_predict+0xa50>
testb  $0x1,0x158(%rsp)
01
je     1c37 <png_predict+0xb27>
movdqu (%r12,%rdx,1),%xmm0
movdqu 0x10(%r12,%rdx,1),%xmm1
movdqu (%r14,%rdx,1),%xmm2
movdqu 0x10(%r14,%rdx,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,(%r8,%rdx,1)
movdqu %xmm3,0x10(%r8,%rdx,1)
mov    0xf8(%rsp),%rax
add    %rax,%r14
lea    (%r8,%rax,1),%rcx
add    %rax,%r12
mov    %eax,%r11d
cmp    %rax,0x100(%rsp)
je     1cfa <png_predict+0xbea>
mov    0x58(%rsp),%rdx
mov    %edx,%esi
sub    %r11d,%esi
mov    %r11d,%eax
not    %eax
add    %edx,%eax
and    $0x3,%esi
je     1ca3 <png_predict+0xb93>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r14),%edx
add    $0x1,%r14
shr    %dl
add    (%r12),%dl
add    $0x1,%r12
mov    %dl,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%esi
jne    1c80 <png_predict+0xb70>
sub    %edi,%r11d
cmp    $0x3,%eax
jb     1cfa <png_predict+0xbea>
mov    0x58(%rsp),%rax
sub    %r11d,%eax
movzbl (%r14),%edx
shr    %dl
add    (%r12),%dl
mov    %dl,(%rcx)
movzbl 0x1(%r14),%edx
shr    %dl
add    0x1(%r12),%dl
mov    %dl,0x1(%rcx)
movzbl 0x2(%r14),%edx
shr    %dl
add    0x2(%r12),%dl
mov    %dl,0x2(%rcx)
movzbl 0x3(%r14),%edx
add    $0x4,%r14
shr    %dl
add    0x3(%r12),%dl
add    $0x4,%r12
mov    %dl,0x3(%rcx)
add    $0x4,%rcx
add    $0xfffffffc,%eax
jne    1cb0 <png_predict+0xba0>
cmp    %r13d,0x8(%rsp)
jae    14b0 <png_predict+0x3a0>
cmpl   $0x7,0x90(%rsp)
07
jb     1d77 <png_predict+0xc67>
mov    0x20(%rsp),%rdx
lea    (%rcx,%rdx,1),%rdi
lea    (%r12,%rdx,1),%rax
add    %r14,%rdx
cmp    %rax,%rcx
setb   %r9b
cmp    %rdi,%r12
setb   %r10b
cmp    %rdx,%rcx
setb   %al
cmp    %rdi,%r14
setb   %sil
cmp    %r15,%rcx
setb   %dl
cmp    %rdi,%r8
setb   %dil
test   %r10b,%r9b
jne    22e2 <png_predict+0x11d2>
and    %sil,%al
jne    22e2 <png_predict+0x11d2>
and    %dil,%dl
mov    (%rsp),%r8
jne    1d77 <png_predict+0xc67>
cmpl   $0x1f,0x90(%rsp)
1f
jae    22f9 <png_predict+0x11e9>
xor    %edi,%edi
jmp    23de <png_predict+0x12ce>
mov    %r14,%rax
mov    %rcx,%rdx
mov    %r12,%rsi
mov    0x8(%rsp),%rcx
mov    0x70(%rsp),%rbx
mov    %ebx,%ebp
sub    %ecx,%ebp
lea    0x1(%rcx),%edi
test   $0x1,%bpl
je     1dba <png_predict+0xcaa>
movzbl (%rax),%ecx
add    $0x1,%rax
movzbl (%r8),%ebp
add    %ecx,%ebp
shr    %ebp
add    (%rsi),%bpl
add    $0x1,%r8
add    $0x1,%rsi
mov    %bpl,(%rdx)
add    $0x1,%rdx
mov    %edi,%ecx
cmp    %edi,%ebx
je     14b0 <png_predict+0x3a0>
mov    0x70(%rsp),%rdi
sub    %ecx,%edi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%ebp
movzbl (%r8,%rcx,1),%ebx
add    %ebp,%ebx
shr    %ebx
add    (%rsi,%rcx,1),%bl
mov    %bl,(%rdx,%rcx,1)
movzbl 0x1(%rax,%rcx,1),%ebp
movzbl 0x1(%r8,%rcx,1),%ebx
add    %ebp,%ebx
shr    %ebx
add    0x1(%rsi,%rcx,1),%bl
mov    %bl,0x1(%rdx,%rcx,1)
add    $0x2,%rcx
cmp    %ecx,%edi
jne    1dd0 <png_predict+0xcc0>
jmp    14b0 <png_predict+0x3a0>
cmpq   $0x60,0xd8(%rsp)
jae    244f <png_predict+0x133f>
xor    %eax,%eax
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rdx
jmp    24dc <png_predict+0x13cc>
mov    0x138(%rsp),%rcx
xor    %eax,%eax
mov    0xc0(%rsp),%rdi
mov    0x28(%rsp),%rdx
mov    (%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%r8,%rax,1),%xmm0
movups -0x60(%r8,%rax,1),%xmm1
movups %xmm0,-0x70(%r11,%rax,1)
movups %xmm1,-0x60(%r11,%rax,1)
movups -0x50(%r8,%rax,1),%xmm0
movups -0x40(%r8,%rax,1),%xmm1
movups %xmm0,-0x50(%r11,%rax,1)
movups %xmm1,-0x40(%r11,%rax,1)
movups -0x30(%r8,%rax,1),%xmm0
movups -0x20(%r8,%rax,1),%xmm1
movups %xmm0,-0x30(%r11,%rax,1)
movups %xmm1,-0x20(%r11,%rax,1)
movdqu -0x10(%r8,%rax,1),%xmm0
movdqu (%r8,%rax,1),%xmm1
movdqu %xmm0,-0x10(%r11,%rax,1)
movdqu %xmm1,(%r11,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    1e50 <png_predict+0xd40>
testb  $0x3,0x158(%rsp)
03
je     1f0f <png_predict+0xdff>
mov    0x50(%rsp),%rcx
add    %rax,%rcx
add    0xb8(%rsp),%rcx
add    %rdx,%rax
add    0xa0(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1ef0 <png_predict+0xde0>
mov    0xf8(%rsp),%rax
lea    (%r10,%rax,1),%rdx
add    %rax,%r12
mov    %eax,%ebp
cmp    %rax,0x100(%rsp)
jne    1833 <png_predict+0x723>
xchg   %ax,%ax
cmp    %r13d,0x8(%rsp)
jae    14b0 <png_predict+0x3a0>
cmpl   $0x7,0x90(%rsp)
07
jae    1fe2 <png_predict+0xed2>
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x8(%rsp),%rdx
mov    0x70(%rsp),%rbp
mov    %ebp,%edi
sub    %edx,%edi
mov    %edx,%esi
not    %esi
add    %ebp,%esi
and    $0x3,%edi
je     1f8e <png_predict+0xe7e>
neg    %edi
xor    %ebp,%ebp
nopl   0x0(%rax)
movzbl (%r10),%ebx
add    $0x1,%r10
add    (%rcx),%bl
add    $0x1,%rcx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edi
jne    1f70 <png_predict+0xe60>
sub    %ebp,%edx
cmp    $0x3,%esi
jb     14b0 <png_predict+0x3a0>
mov    0x70(%rsp),%rsi
sub    %edx,%esi
xor    %edx,%edx
movzbl (%r10,%rdx,1),%ebx
add    (%rcx,%rdx,1),%bl
mov    %bl,(%rax,%rdx,1)
movzbl 0x1(%r10,%rdx,1),%ebx
add    0x1(%rcx,%rdx,1),%bl
mov    %bl,0x1(%rax,%rdx,1)
movzbl 0x2(%r10,%rdx,1),%ebx
add    0x2(%rcx,%rdx,1),%bl
mov    %bl,0x2(%rax,%rdx,1)
movzbl 0x3(%r10,%rdx,1),%ebx
add    0x3(%rcx,%rdx,1),%bl
mov    %bl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %edx,%esi
jne    1fa0 <png_predict+0xe90>
jmp    14b0 <png_predict+0x3a0>
mov    0x20(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
add    %r12,%rax
cmp    %rax,%rdx
setb   %sil
cmp    %rcx,%r12
setb   %dil
cmp    %r15,%rdx
setb   %al
cmp    %rcx,%r10
setb   %cl
test   %dil,%sil
jne    1f49 <png_predict+0xe39>
and    %cl,%al
jne    1f49 <png_predict+0xe39>
cmpl   $0x1f,0x90(%rsp)
1f
jae    202a <png_predict+0xf1a>
xor    %esi,%esi
jmp    2109 <png_predict+0xff9>
cmpq   $0x0,0x148(%rsp)
je     25cd <png_predict+0x14bd>
mov    0x128(%rsp),%rcx
xor    %eax,%eax
mov    0x18(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu -0x30(%r9,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu -0x20(%r9,%rax,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,(%rdx,%rax,1)
movdqu %xmm0,0x10(%rdx,%rax,1)
movdqu 0x20(%r12,%rax,1),%xmm0
movdqu 0x30(%r12,%rax,1),%xmm1
movdqu -0x10(%r9,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu (%r9,%rax,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,0x20(%rdx,%rax,1)
movdqu %xmm0,0x30(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    2050 <png_predict+0xf40>
testb  $0x1,0x140(%rsp)
01
je     20ee <png_predict+0xfde>
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu (%r10,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu 0x10(%r10,%rax,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,(%rdx,%rax,1)
movdqu %xmm0,0x10(%rdx,%rax,1)
cmp    %rsi,0x20(%rsp)
je     14b0 <png_predict+0x3a0>
mov    0x18(%rsp),%rsi
testb  $0x18,0x20(%rsp)
je     29a3 <png_predict+0x1893>
mov    0xe8(%rsp),%rdi
add    %rdi,%r10
lea    (%rdx,%rdi,1),%rax
lea    (%r12,%rdi,1),%rcx
mov    0x68(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%r12,%rsi,1),%xmm0
movq   0x0(%rbp,%rsi,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rdx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    2130 <png_predict+0x1020>
mov    0x88(%rsp),%edx
cmp    %rdi,0x20(%rsp)
je     14b0 <png_predict+0x3a0>
jmp    1f54 <png_predict+0xe44>
cmpq   $0x60,0xf0(%rsp)
jae    25e7 <png_predict+0x14d7>
xor    %eax,%eax
mov    0xc0(%rsp),%rdi
mov    0x28(%rsp),%rdx
mov    (%rsp),%r10
jmp    267c <png_predict+0x156c>
cmpq   $0x0,0xd8(%rsp)
je     298e <png_predict+0x187e>
mov    0x180(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x30(%rbp,%rdx,1),%xmm0
movdqu -0x20(%rbp,%rdx,1),%xmm1
movdqu -0x30(%rdi,%rdx,1),%xmm2
paddb  %xmm0,%xmm2
movdqu -0x20(%rdi,%rdx,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,-0x30(%r9,%rdx,1)
movdqu %xmm0,-0x20(%r9,%rdx,1)
movdqu -0x10(%rbp,%rdx,1),%xmm0
movdqu 0x0(%rbp,%rdx,1),%xmm1
movdqu -0x10(%rdi,%rdx,1),%xmm2
paddb  %xmm0,%xmm2
movdqu (%rdi,%rdx,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,-0x10(%r9,%rdx,1)
movdqu %xmm0,(%r9,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rcx
jne    21b0 <png_predict+0x10a0>
testb  $0x1,0x150(%rsp)
01
je     224d <png_predict+0x113d>
movdqu (%r12,%rdx,1),%xmm0
movdqu 0x10(%r12,%rdx,1),%xmm1
movdqu (%r14,%rdx,1),%xmm2
paddb  %xmm0,%xmm2
movdqu 0x10(%r14,%rdx,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,(%r15,%rdx,1)
movdqu %xmm0,0x10(%r15,%rdx,1)
mov    0x48(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     14b0 <png_predict+0x3a0>
mov    0x48(%rsp),%rax
testb  $0x18,0x38(%rsp)
mov    0x50(%rsp),%rcx
mov    0x28(%rsp),%rdx
je     2bf5 <png_predict+0x1ae5>
mov    0xe0(%rsp),%rdi
add    %rdi,%r14
add    %rdi,%r15
add    %rdi,%r12
add    %rax,%rcx
add    0x60(%rsp),%rcx
add    %rax,%rdx
add    0xc8(%rsp),%rdx
add    0x198(%rsp),%rax
mov    0x168(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movq   (%rcx),%xmm0
movq   (%rdx,%rsi,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rdx)
add    $0x8,%rcx
add    $0x8,%rdx
add    $0x8,%rax
jne    22b0 <png_predict+0x11a0>
mov    %edi,%r8d
cmp    %rdi,0x38(%rsp)
je     14b0 <png_predict+0x3a0>
jmp    2c06 <png_predict+0x1af6>
mov    %r14,%rax
mov    %rcx,%rdx
mov    %r12,%rsi
mov    0x8(%rsp),%rcx
mov    (%rsp),%r8
jmp    1d85 <png_predict+0xc75>
mov    0xa0(%rsp),%rax
mov    0x28(%rsp),%rdx
add    %rdx,%rax
xor    %edx,%edx
mov    0x18(%rsp),%rsi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%r12,%rdx,1),%xmm9
movdqu 0x10(%r12,%rdx,1),%xmm8
movdqu (%r14,%rdx,1),%xmm4
movdqu 0x10(%r14,%rdx,1),%xmm5
movdqa %xmm4,%xmm6
punpckhbw %xmm1,%xmm6
punpcklbw %xmm1,%xmm4
movdqa %xmm5,%xmm7
punpckhbw %xmm1,%xmm7
punpcklbw %xmm1,%xmm5
movdqu -0x10(%rax,%rdx,1),%xmm2
movdqu (%rax,%rdx,1),%xmm3
movdqa %xmm2,%xmm0
punpckhbw %xmm1,%xmm0
paddw  %xmm6,%xmm0
punpcklbw %xmm1,%xmm2
paddw  %xmm4,%xmm2
movdqa %xmm3,%xmm4
punpckhbw %xmm1,%xmm4
paddw  %xmm7,%xmm4
punpcklbw %xmm1,%xmm3
paddw  %xmm5,%xmm3
psrlw  $0x1,%xmm0
psrlw  $0x1,%xmm2
packuswb %xmm0,%xmm2
paddb  %xmm9,%xmm2
psrlw  $0x1,%xmm4
psrlw  $0x1,%xmm3
packuswb %xmm4,%xmm3
paddb  %xmm8,%xmm3
movdqu %xmm2,(%rcx,%rdx,1)
movdqu %xmm3,0x10(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2320 <png_predict+0x1210>
cmp    %rsi,0x20(%rsp)
je     14b0 <png_predict+0x3a0>
mov    0x18(%rsp),%rdi
testb  $0x18,0x20(%rsp)
je     2cba <png_predict+0x1baa>
mov    0xe8(%rsp),%rbp
lea    (%r14,%rbp,1),%rax
add    %rbp,%r8
lea    (%rcx,%rbp,1),%rdx
lea    (%r12,%rbp,1),%rsi
pxor   %xmm3,%xmm3
mov    0x68(%rsp),%rbx
xchg   %ax,%ax
movq   (%r12,%rdi,1),%xmm0
movq   (%r14,%rdi,1),%xmm1
punpcklbw %xmm3,%xmm1
movq   (%rbx,%rdi,1),%xmm2
punpcklbw %xmm3,%xmm2
paddw  %xmm1,%xmm2
psrlw  $0x1,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm0,%xmm2
movq   %xmm2,(%rcx,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rbp
jne    2400 <png_predict+0x12f0>
mov    0x88(%rsp),%ecx
cmp    %rbp,0x20(%rsp)
je     14b0 <png_predict+0x3a0>
jmp    1d85 <png_predict+0xc75>
mov    0x120(%rsp),%rcx
xor    %eax,%eax
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%r8,%rax,1),%xmm0
movups -0x60(%r8,%rax,1),%xmm1
movups %xmm0,-0x70(%r11,%rax,1)
movups %xmm1,-0x60(%r11,%rax,1)
movups -0x50(%r8,%rax,1),%xmm0
movups -0x40(%r8,%rax,1),%xmm1
movups %xmm0,-0x50(%r11,%rax,1)
movups %xmm1,-0x40(%r11,%rax,1)
movups -0x30(%r8,%rax,1),%xmm0
movups -0x20(%r8,%rax,1),%xmm1
movups %xmm0,-0x30(%r11,%rax,1)
movups %xmm1,-0x20(%r11,%rax,1)
movdqu -0x10(%r8,%rax,1),%xmm0
movdqu (%r8,%rax,1),%xmm1
movdqu %xmm0,-0x10(%r11,%rax,1)
movdqu %xmm1,(%r11,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    2470 <png_predict+0x1360>
testb  $0x3,0x150(%rsp)
03
mov    0x130(%rsp),%rsi
je     252f <png_predict+0x141f>
lea    (%rax,%rdi,1),%rcx
add    0xb8(%rsp),%rcx
add    %rdx,%rax
add    0xa0(%rsp),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2510 <png_predict+0x1400>
mov    0x48(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     14b0 <png_predict+0x3a0>
mov    0x48(%rsp),%rax
testb  $0x18,0x38(%rsp)
je     29c3 <png_predict+0x18b3>
mov    0xe0(%rsp),%rdx
add    %rdx,%r10
add    %rdx,%r12
mov    0x68(%rsp),%rsi
mov    0x118(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,1),%rcx
mov    %rcx,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    2570 <png_predict+0x1460>
mov    %edx,%r9d
cmp    %rdx,0x38(%rsp)
je     14b0 <png_predict+0x3a0>
jmp    29d1 <png_predict+0x18c1>
xor    %edx,%edx
mov    (%rsp),%r8
testb  $0x1,0x158(%rsp)
01
jne    1bf6 <png_predict+0xae6>
jmp    1c37 <png_predict+0xb27>
cmpq   $0x60,0xd8(%rsp)
jae    2a93 <png_predict+0x1983>
xor    %eax,%eax
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rdx
jmp    2b1c <png_predict+0x1a0c>
xor    %eax,%eax
mov    0x18(%rsp),%rsi
testb  $0x1,0x140(%rsp)
01
jne    20c1 <png_predict+0xfb1>
jmp    20ee <png_predict+0xfde>
mov    0x138(%rsp),%rcx
xor    %eax,%eax
mov    0xc0(%rsp),%rdi
mov    0x28(%rsp),%rdx
mov    (%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%r8,%rax,1),%xmm0
movups -0x60(%r8,%rax,1),%xmm1
movups %xmm0,-0x70(%r11,%rax,1)
movups %xmm1,-0x60(%r11,%rax,1)
movups -0x50(%r8,%rax,1),%xmm0
movups -0x40(%r8,%rax,1),%xmm1
movups %xmm0,-0x50(%r11,%rax,1)
movups %xmm1,-0x40(%r11,%rax,1)
movups -0x30(%r8,%rax,1),%xmm0
movups -0x20(%r8,%rax,1),%xmm1
movups %xmm0,-0x30(%r11,%rax,1)
movups %xmm1,-0x20(%r11,%rax,1)
movdqu -0x10(%r8,%rax,1),%xmm0
movdqu (%r8,%rax,1),%xmm1
movdqu %xmm0,-0x10(%r11,%rax,1)
movdqu %xmm1,(%r11,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    2610 <png_predict+0x1500>
cmpq   $0x0,0x188(%rsp)
je     26cf <png_predict+0x15bf>
mov    0x50(%rsp),%rcx
add    %rax,%rcx
add    0xb8(%rsp),%rcx
add    %rdx,%rax
add    0xa0(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    26b0 <png_predict+0x15a0>
mov    0xf8(%rsp),%rax
lea    (%r10,%rax,1),%rdx
add    %rax,%r12
mov    %eax,%ebp
cmp    %rax,0x100(%rsp)
jne    1a2e <png_predict+0x91e>
cmp    %r13d,0x8(%rsp)
jae    14b0 <png_predict+0x3a0>
cmpl   $0x7,0x90(%rsp)
jae    27ba <png_predict+0x16aa>
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x8(%rsp),%rdx
mov    0x70(%rsp),%rbp
mov    %ebp,%edi
sub    %edx,%edi
mov    %edx,%esi
not    %esi
add    %ebp,%esi
and    $0x3,%edi
je     2750 <png_predict+0x1640>
neg    %edi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movzbl (%r10),%ebx
add    $0x1,%r10
shr    %bl
add    (%rcx),%bl
add    $0x1,%rcx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edi
jne    2730 <png_predict+0x1620>
sub    %ebp,%edx
cmp    $0x3,%esi
jb     14b0 <png_predict+0x3a0>
mov    0x70(%rsp),%rsi
sub    %edx,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r10,%rdx,1),%ebx
shr    %bl
add    (%rcx,%rdx,1),%bl
mov    %bl,(%rax,%rdx,1)
movzbl 0x1(%r10,%rdx,1),%ebx
shr    %bl
add    0x1(%rcx,%rdx,1),%bl
mov    %bl,0x1(%rax,%rdx,1)
movzbl 0x2(%r10,%rdx,1),%ebx
shr    %bl
add    0x2(%rcx,%rdx,1),%bl
mov    %bl,0x2(%rax,%rdx,1)
movzbl 0x3(%r10,%rdx,1),%ebx
shr    %bl
add    0x3(%rcx,%rdx,1),%bl
mov    %bl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %edx,%esi
jne    2770 <png_predict+0x1660>
jmp    14b0 <png_predict+0x3a0>
mov    0x20(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
add    %r12,%rax
cmp    %rax,%rdx
setb   %sil
cmp    %rcx,%r12
setb   %dil
cmp    %r15,%rdx
setb   %al
cmp    %rcx,%r10
setb   %cl
test   %dil,%sil
jne    2707 <png_predict+0x15f7>
and    %cl,%al
jne    2707 <png_predict+0x15f7>
cmpl   $0x1f,0x90(%rsp)
1f
jae    2802 <png_predict+0x16f2>
xor    %esi,%esi
jmp    2923 <png_predict+0x1813>
cmpq   $0x0,0x148(%rsp)
je     2bd3 <png_predict+0x1ac3>
mov    0x128(%rsp),%rcx
xor    %eax,%eax
mov    0x18(%rsp),%rsi
movdqa 0x7d8(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu -0x30(%r9,%rax,1),%xmm2
movdqu -0x20(%r9,%rax,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,(%rdx,%rax,1)
movdqu %xmm3,0x10(%rdx,%rax,1)
movdqu 0x20(%r12,%rax,1),%xmm0
movdqu 0x30(%r12,%rax,1),%xmm1
movdqu -0x10(%r9,%rax,1),%xmm2
movdqu (%r9,%rax,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,0x20(%rdx,%rax,1)
movdqu %xmm3,0x30(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    2830 <png_predict+0x1720>
testb  $0x1,0x140(%rsp)
01
je     2908 <png_predict+0x17f8>
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu (%r10,%rax,1),%xmm2
movdqu 0x10(%r10,%rax,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,(%rdx,%rax,1)
movdqu %xmm3,0x10(%rdx,%rax,1)
cmp    %rsi,0x20(%rsp)
je     14b0 <png_predict+0x3a0>
mov    0x18(%rsp),%rsi
testb  $0x18,0x20(%rsp)
je     2ce0 <png_predict+0x1bd0>
mov    0xe8(%rsp),%rdi
add    %rdi,%r10
lea    (%rdx,%rdi,1),%rax
lea    (%r12,%rdi,1),%rcx
movdqa 0x6c2(%rip),%xmm2
mov    0x68(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   (%r12,%rsi,1),%xmm0
movq   0x0(%rbp,%rsi,1),%xmm1
psrlw  $0x1,%xmm1
pand   %xmm2,%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rdx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    2950 <png_predict+0x1840>
mov    0x88(%rsp),%edx
cmp    %rdi,0x20(%rsp)
je     14b0 <png_predict+0x3a0>
jmp    2712 <png_predict+0x1602>
xor    %edx,%edx
testb  $0x1,0x150(%rsp)
01
jne    221e <png_predict+0x110e>
jmp    224d <png_predict+0x113d>
mov    0x18(%rsp),%rax
add    %rax,%r12
add    %rax,%rdx
add    %rax,%r10
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x84(%rsp),%edx
jmp    1f54 <png_predict+0xe44>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r10
mov    %eax,%r9d
mov    0x98(%rsp),%rax
mov    %eax,%edx
sub    %r9d,%edx
mov    %r9d,%ecx
not    %ecx
add    %eax,%ecx
and    $0x7,%edx
je     2a0b <png_predict+0x18fb>
neg    %edx
xor    %esi,%esi
xchg   %ax,%ax
movzbl (%r12),%eax
add    $0x1,%r12
mov    %al,(%r10)
add    $0x1,%r10
add    $0xffffffffffffffff,%rsi
cmp    %esi,%edx
jne    29f0 <png_predict+0x18e0>
sub    %esi,%r9d
cmp    $0x7,%ecx
jb     14b0 <png_predict+0x3a0>
mov    0x98(%rsp),%rcx
sub    %r9d,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rax,1),%edx
mov    %dl,(%r10,%rax,1)
movzbl 0x1(%r12,%rax,1),%edx
mov    %dl,0x1(%r10,%rax,1)
movzbl 0x2(%r12,%rax,1),%edx
mov    %dl,0x2(%r10,%rax,1)
movzbl 0x3(%r12,%rax,1),%edx
mov    %dl,0x3(%r10,%rax,1)
movzbl 0x4(%r12,%rax,1),%edx
mov    %dl,0x4(%r10,%rax,1)
movzbl 0x5(%r12,%rax,1),%edx
mov    %dl,0x5(%r10,%rax,1)
movzbl 0x6(%r12,%rax,1),%edx
mov    %dl,0x6(%r10,%rax,1)
movzbl 0x7(%r12,%rax,1),%edx
mov    %dl,0x7(%r10,%rax,1)
add    $0x8,%rax
cmp    %eax,%ecx
jne    2a30 <png_predict+0x1920>
jmp    14b0 <png_predict+0x3a0>
mov    0x120(%rsp),%rcx
xor    %eax,%eax
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movups -0x70(%r8,%rax,1),%xmm0
movups -0x60(%r8,%rax,1),%xmm1
movups %xmm0,-0x70(%r11,%rax,1)
movups %xmm1,-0x60(%r11,%rax,1)
movups -0x50(%r8,%rax,1),%xmm0
movups -0x40(%r8,%rax,1),%xmm1
movups %xmm0,-0x50(%r11,%rax,1)
movups %xmm1,-0x40(%r11,%rax,1)
movups -0x30(%r8,%rax,1),%xmm0
movups -0x20(%r8,%rax,1),%xmm1
movups %xmm0,-0x30(%r11,%rax,1)
movups %xmm1,-0x20(%r11,%rax,1)
movdqu -0x10(%r8,%rax,1),%xmm0
movdqu (%r8,%rax,1),%xmm1
movdqu %xmm0,-0x10(%r11,%rax,1)
movdqu %xmm1,(%r11,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    2ab0 <png_predict+0x19a0>
cmpq   $0x0,0x178(%rsp)
mov    0x130(%rsp),%rsi
je     2b6f <png_predict+0x1a5f>
lea    (%rax,%rdi,1),%rcx
add    0xb8(%rsp),%rcx
add    %rdx,%rax
add    0xa0(%rsp),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2b50 <png_predict+0x1a40>
mov    0x48(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     14b0 <png_predict+0x3a0>
mov    0x48(%rsp),%rax
testb  $0x18,0x38(%rsp)
je     2d00 <png_predict+0x1bf0>
mov    0xe0(%rsp),%rdx
add    %rdx,%r15
add    %rdx,%r12
mov    0x68(%rsp),%rsi
mov    0x118(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,1),%rcx
mov    %rcx,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    2bb0 <png_predict+0x1aa0>
mov    %edx,%ebx
cmp    %rdx,0x38(%rsp)
je     14b0 <png_predict+0x3a0>
jmp    2d0d <png_predict+0x1bfd>
xor    %eax,%eax
mov    0x18(%rsp),%rsi
movdqa 0x41e(%rip),%xmm4
testb  $0x1,0x140(%rsp)
01
jne    28c9 <png_predict+0x17b9>
jmp    2908 <png_predict+0x17f8>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
add    %rax,%r14
mov    %eax,%r8d
mov    0x98(%rsp),%rdx
mov    %edx,%ecx
sub    %r8d,%ecx
mov    %r8d,%eax
not    %eax
add    %edx,%eax
and    $0x3,%ecx
je     2c52 <png_predict+0x1b42>
neg    %ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r14),%edx
add    $0x1,%r14
add    (%r12),%dl
add    $0x1,%r12
mov    %dl,(%r15)
add    $0x1,%r15
add    $0xffffffffffffffff,%rsi
cmp    %esi,%ecx
jne    2c30 <png_predict+0x1b20>
sub    %esi,%r8d
cmp    $0x3,%eax
jb     14b0 <png_predict+0x3a0>
mov    0x98(%rsp),%rax
sub    %r8d,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%edx
add    (%r12,%rcx,1),%dl
mov    %dl,(%r15,%rcx,1)
movzbl 0x1(%r14,%rcx,1),%edx
add    0x1(%r12,%rcx,1),%dl
mov    %dl,0x1(%r15,%rcx,1)
movzbl 0x2(%r14,%rcx,1),%edx
add    0x2(%r12,%rcx,1),%dl
mov    %dl,0x2(%r15,%rcx,1)
movzbl 0x3(%r14,%rcx,1),%edx
add    0x3(%r12,%rcx,1),%dl
mov    %dl,0x3(%r15,%rcx,1)
add    $0x4,%rcx
cmp    %ecx,%eax
jne    2c70 <png_predict+0x1b60>
jmp    14b0 <png_predict+0x3a0>
mov    0x18(%rsp),%rax
add    %rax,%r12
add    %rax,%rcx
add    %rax,%r8
add    %rax,%r14
mov    %r14,%rax
mov    %rcx,%rdx
mov    %r12,%rsi
mov    0x84(%rsp),%ecx
jmp    1d85 <png_predict+0xc75>
mov    0x18(%rsp),%rax
add    %rax,%r12
add    %rax,%rdx
add    %rax,%r10
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x84(%rsp),%edx
jmp    2712 <png_predict+0x1602>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
mov    %eax,%ebx
mov    0x98(%rsp),%rax
mov    %eax,%edx
sub    %ebx,%edx
mov    %ebx,%ecx
not    %ecx
add    %eax,%ecx
and    $0x7,%edx
je     2d4a <png_predict+0x1c3a>
neg    %edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%r12),%eax
add    $0x1,%r12
mov    %al,(%r15)
add    $0x1,%r15
add    $0xffffffffffffffff,%rsi
cmp    %esi,%edx
jne    2d30 <png_predict+0x1c20>
sub    %esi,%ebx
cmp    $0x7,%ecx
jb     14b0 <png_predict+0x3a0>
mov    0x98(%rsp),%rcx
sub    %ebx,%ecx
xor    %eax,%eax
nop
movzbl (%r12,%rax,1),%edx
mov    %dl,(%r15,%rax,1)
movzbl 0x1(%r12,%rax,1),%edx
mov    %dl,0x1(%r15,%rax,1)
movzbl 0x2(%r12,%rax,1),%edx
mov    %dl,0x2(%r15,%rax,1)
movzbl 0x3(%r12,%rax,1),%edx
mov    %dl,0x3(%r15,%rax,1)
movzbl 0x4(%r12,%rax,1),%edx
mov    %dl,0x4(%r15,%rax,1)
movzbl 0x5(%r12,%rax,1),%edx
mov    %dl,0x5(%r15,%rax,1)
movzbl 0x6(%r12,%rax,1),%edx
mov    %dl,0x6(%r15,%rax,1)
movzbl 0x7(%r12,%rax,1),%edx
mov    %dl,0x7(%r15,%rax,1)
add    $0x8,%rax
cmp    %eax,%ecx
jne    2d60 <png_predict+0x1c50>
jmp    14b0 <png_predict+0x3a0>
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @png_predict(i8* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = mul i32 %4, %3
%7 = mul i32 %6, %1
%8 = add i32 %7, 7
%9 = lshr i32 %8, 3
%10 = add i32 %6, 7
%11 = lshr i32 %10, 3
%12 = icmp eq i32 %2, 0
br i1 %12, label %1814, label %13
13: ; preds = %5
%14 = add nuw nsw i32 %9, 1
%15 = zext i32 %9 to i64
%16 = sub nsw i64 0, %15
%17 = icmp ult i32 %10, 8
%18 = icmp ult i32 %11, %9
%19 = icmp ult i32 %8, 8
%20 = call i32 @llvm.umax.i32(i32 %11, i32 1)
%21 = call i32 @llvm.umax.i32(i32 %9, i32 1)
%22 = zext i32 %2 to i64
%23 = lshr i32 %8, 3
%24 = add nsw i32 %21, -1
%25 = zext i32 %24 to i64
%26 = add nuw nsw i64 %25, 1
%27 = getelementptr i8, i8* %0, i64 %26
%28 = getelementptr i8, i8* %0, i64 1
%29 = add nuw nsw i32 %23, 1
%30 = zext i32 %29 to i64
%31 = add nuw nsw i64 %25, 2
%32 = getelementptr i8, i8* %0, i64 %31
%33 = add nsw i32 %21, -1
%34 = zext i32 %33 to i64
%35 = add nuw nsw i64 %34, 1
%36 = add nsw i32 %21, -1
%37 = zext i32 %36 to i64
%38 = add nuw nsw i64 %37, 1
%39 = xor i32 %11, -1
%40 = add nsw i32 %9, %39
%41 = zext i32 %40 to i64
%42 = add nuw nsw i64 %41, 1
%43 = getelementptr i8, i8* %0, i64 %42
%44 = zext i32 %40 to i64
%45 = add nuw nsw i64 %44, 1
%46 = xor i32 %11, -1
%47 = add nsw i32 %9, %46
%48 = zext i32 %47 to i64
%49 = add nuw nsw i64 %48, 1
%50 = add nsw i32 %20, -1
%51 = zext i32 %50 to i64
%52 = add nuw nsw i64 %51, 1
%53 = getelementptr i8, i8* %0, i64 %52
%54 = getelementptr i8, i8* %0, i64 1
%55 = add nuw nsw i64 %15, 1
%56 = add nuw nsw i64 %51, 2
%57 = getelementptr i8, i8* %0, i64 %56
%58 = add nsw i32 %20, -1
%59 = zext i32 %58 to i64
%60 = add nuw nsw i64 %59, 1
%61 = add nsw i32 %21, -1
%62 = zext i32 %61 to i64
%63 = add nuw nsw i64 %62, 1
%64 = getelementptr i8, i8* %0, i64 %63
%65 = getelementptr i8, i8* %0, i64 1
%66 = add nuw nsw i64 %15, 1
%67 = add nuw nsw i64 %62, 2
%68 = getelementptr i8, i8* %0, i64 %67
%69 = add nsw i32 %21, -1
%70 = zext i32 %69 to i64
%71 = add nuw nsw i64 %70, 1
%72 = add nsw i32 %21, -1
%73 = zext i32 %72 to i64
%74 = add nuw nsw i64 %73, 1
%75 = add nsw i32 %21, -1
%76 = zext i32 %75 to i64
%77 = add nuw nsw i64 %76, 1
%78 = getelementptr i8, i8* %0, i64 %77
%79 = getelementptr i8, i8* %0, i64 1
%80 = add nuw nsw i64 %15, 1
%81 = add nuw nsw i64 %76, 2
%82 = getelementptr i8, i8* %0, i64 %81
%83 = getelementptr i8, i8* %0, i64 %16
%84 = add nuw nsw i64 %76, 1
%85 = sub nsw i64 %84, %15
%86 = getelementptr i8, i8* %0, i64 %85
%87 = add nsw i32 %21, -1
%88 = zext i32 %87 to i64
%89 = add nuw nsw i64 %88, 1
%90 = add nsw i32 %21, -1
%91 = zext i32 %90 to i64
%92 = add nuw nsw i64 %91, 1
%93 = xor i32 %11, -1
%94 = add nsw i32 %9, %93
%95 = zext i32 %94 to i64
%96 = add nuw nsw i64 %95, 1
%97 = getelementptr i8, i8* %0, i64 %96
%98 = zext i32 %94 to i64
%99 = add nuw nsw i64 %98, 1
%100 = xor i32 %11, -1
%101 = add nsw i32 %9, %100
%102 = zext i32 %101 to i64
%103 = add nuw nsw i64 %102, 1
%104 = add nsw i32 %20, -1
%105 = zext i32 %104 to i64
%106 = add nuw nsw i64 %105, 1
%107 = getelementptr i8, i8* %0, i64 %106
%108 = getelementptr i8, i8* %0, i64 1
%109 = add nuw nsw i64 %15, 1
%110 = add nuw nsw i64 %105, 2
%111 = getelementptr i8, i8* %0, i64 %110
%112 = add nsw i32 %20, -1
%113 = zext i32 %112 to i64
%114 = add nuw nsw i64 %113, 1
%115 = xor i32 %11, -1
%116 = add nsw i32 %9, %115
%117 = zext i32 %116 to i64
%118 = add nuw nsw i64 %117, 1
%119 = getelementptr i8, i8* %0, i64 %118
%120 = zext i32 %116 to i64
%121 = add nuw nsw i64 %120, 1
%122 = xor i32 %11, -1
%123 = add nsw i32 %9, %122
%124 = zext i32 %123 to i64
%125 = add nuw nsw i64 %124, 1
%126 = add nsw i32 %20, -1
%127 = zext i32 %126 to i64
%128 = add nuw nsw i64 %127, 1
%129 = getelementptr i8, i8* %0, i64 %128
%130 = getelementptr i8, i8* %0, i64 1
%131 = add nuw nsw i64 %15, 1
%132 = add nuw nsw i64 %127, 2
%133 = getelementptr i8, i8* %0, i64 %132
%134 = getelementptr i8, i8* %0, i64 %16
%135 = add nuw nsw i64 %127, 1
%136 = sub nsw i64 %135, %15
%137 = getelementptr i8, i8* %0, i64 %136
%138 = add nsw i32 %20, -1
%139 = zext i32 %138 to i64
%140 = add nuw nsw i64 %139, 1
%141 = and i64 %52, 8589934560
%142 = add nsw i64 %141, -32
%143 = lshr exact i64 %142, 5
%144 = add nuw nsw i64 %143, 1
%145 = and i64 %42, 8589934560
%146 = add nsw i64 %145, -32
%147 = lshr exact i64 %146, 5
%148 = add nuw nsw i64 %147, 1
%149 = and i64 %26, 8589934560
%150 = add nsw i64 %149, -32
%151 = lshr exact i64 %150, 5
%152 = add nuw nsw i64 %151, 1
%153 = icmp ult i32 %138, 31
%154 = icmp ugt i8* %137, %0
%155 = icmp ult i8* %134, %129
%156 = and i1 %154, %155
%157 = and i64 %140, 8589934560
%158 = trunc i64 %157 to i32
%159 = and i64 %144, 1
%160 = icmp eq i64 %142, 0
%161 = and i64 %144, 1152921504606846974
%162 = icmp eq i64 %159, 0
%163 = icmp eq i64 %140, %157
%164 = icmp ult i32 %116, 7
%165 = icmp ult i32 %116, 31
%166 = and i64 %121, 8589934560
%167 = icmp eq i64 %121, %166
%168 = trunc i64 %166 to i32
%169 = add i32 %11, %168
%170 = and i64 %121, 24
%171 = icmp eq i64 %170, 0
%172 = and i64 %125, 8589934584
%173 = trunc i64 %172 to i32
%174 = add i32 %11, %173
%175 = icmp eq i64 %125, %172
%176 = icmp ult i32 %112, 31
%177 = and i64 %114, 8589934560
%178 = trunc i64 %177 to i32
%179 = and i64 %144, 3
%180 = icmp ult i64 %142, 96
%181 = and i64 %144, 1152921504606846972
%182 = icmp eq i64 %179, 0
%183 = icmp eq i64 %114, %177
%184 = icmp ult i32 %94, 7
%185 = icmp ult i32 %94, 31
%186 = and i64 %99, 8589934560
%187 = and i64 %148, 1
%188 = icmp eq i64 %146, 0
%189 = and i64 %148, 1152921504606846974
%190 = icmp eq i64 %187, 0
%191 = icmp eq i64 %99, %186
%192 = trunc i64 %186 to i32
%193 = add i32 %11, %192
%194 = and i64 %99, 24
%195 = icmp eq i64 %194, 0
%196 = and i64 %103, 8589934584
%197 = trunc i64 %196 to i32
%198 = add i32 %11, %197
%199 = icmp eq i64 %103, %196
%200 = icmp ult i32 %87, 7
%201 = icmp ugt i8* %86, %0
%202 = icmp ult i8* %83, %78
%203 = and i1 %201, %202
%204 = icmp ult i32 %87, 31
%205 = and i64 %89, 8589934560
%206 = and i64 %152, 1
%207 = icmp eq i64 %150, 0
%208 = and i64 %152, 1152921504606846974
%209 = icmp eq i64 %206, 0
%210 = icmp eq i64 %89, %205
%211 = trunc i64 %205 to i32
%212 = and i64 %89, 24
%213 = icmp eq i64 %212, 0
%214 = and i64 %92, 8589934584
%215 = trunc i64 %214 to i32
%216 = icmp eq i64 %92, %214
%217 = icmp ult i32 %69, 7
%218 = icmp ult i32 %69, 31
%219 = and i64 %71, 8589934560
%220 = and i64 %152, 3
%221 = icmp ult i64 %150, 96
%222 = and i64 %152, 1152921504606846972
%223 = icmp eq i64 %220, 0
%224 = icmp eq i64 %71, %219
%225 = trunc i64 %219 to i32
%226 = and i64 %71, 24
%227 = icmp eq i64 %226, 0
%228 = and i64 %74, 8589934584
%229 = trunc i64 %228 to i32
%230 = icmp eq i64 %74, %228
%231 = icmp ult i32 %58, 31
%232 = and i64 %60, 8589934560
%233 = trunc i64 %232 to i32
%234 = and i64 %144, 3
%235 = icmp ult i64 %142, 96
%236 = and i64 %144, 1152921504606846972
%237 = icmp eq i64 %234, 0
%238 = icmp eq i64 %60, %232
%239 = icmp ult i32 %40, 7
%240 = icmp ult i32 %40, 31
%241 = and i64 %45, 8589934560
%242 = and i64 %148, 1
%243 = icmp eq i64 %146, 0
%244 = and i64 %148, 1152921504606846974
%245 = icmp eq i64 %242, 0
%246 = icmp eq i64 %45, %241
%247 = trunc i64 %241 to i32
%248 = add i32 %11, %247
%249 = and i64 %45, 24
%250 = icmp eq i64 %249, 0
%251 = and i64 %49, 8589934584
%252 = trunc i64 %251 to i32
%253 = add i32 %11, %252
%254 = icmp eq i64 %49, %251
%255 = icmp ult i32 %33, 7
%256 = icmp ult i32 %33, 31
%257 = and i64 %35, 8589934560
%258 = and i64 %152, 3
%259 = icmp ult i64 %150, 96
%260 = and i64 %152, 1152921504606846972
%261 = icmp eq i64 %258, 0
%262 = icmp eq i64 %35, %257
%263 = trunc i64 %257 to i32
%264 = and i64 %35, 24
%265 = icmp eq i64 %264, 0
%266 = and i64 %38, 8589934584
%267 = trunc i64 %266 to i32
%268 = icmp eq i64 %38, %266
br label %269
269: ; preds = %13, %1811
%270 = phi i64 [ 0, %13 ], [ %1812, %1811 ]
%271 = trunc i64 %270 to i32
%272 = mul i32 %9, %271
%273 = zext i32 %272 to i64
%274 = getelementptr i8, i8* %0, i64 %273
%275 = getelementptr i8, i8* %129, i64 %273
%276 = mul i64 %131, %270
%277 = and i64 %276, 4294967295
%278 = getelementptr i8, i8* %130, i64 %277
%279 = getelementptr i8, i8* %133, i64 %277
%280 = trunc i64 %270 to i32
%281 = mul i32 %9, %280
%282 = zext i32 %281 to i64
%283 = getelementptr i8, i8* %0, i64 %282
%284 = getelementptr i8, i8* %119, i64 %282
%285 = trunc i64 %270 to i32
%286 = mul i32 %9, %285
%287 = zext i32 %286 to i64
%288 = getelementptr i8, i8* %0, i64 %287
%289 = getelementptr i8, i8* %107, i64 %287
%290 = mul i64 %109, %270
%291 = and i64 %290, 4294967295
%292 = getelementptr i8, i8* %108, i64 %291
%293 = getelementptr i8, i8* %111, i64 %291
%294 = trunc i64 %270 to i32
%295 = mul i32 %9, %294
%296 = zext i32 %295 to i64
%297 = getelementptr i8, i8* %0, i64 %296
%298 = getelementptr i8, i8* %97, i64 %296
%299 = trunc i64 %270 to i32
%300 = mul i32 %9, %299
%301 = zext i32 %300 to i64
%302 = getelementptr i8, i8* %0, i64 %301
%303 = getelementptr i8, i8* %78, i64 %301
%304 = mul i64 %80, %270
%305 = and i64 %304, 4294967295
%306 = getelementptr i8, i8* %79, i64 %305
%307 = getelementptr i8, i8* %82, i64 %305
%308 = trunc i64 %270 to i32
%309 = mul i32 %9, %308
%310 = zext i32 %309 to i64
%311 = getelementptr i8, i8* %0, i64 %310
%312 = getelementptr i8, i8* %64, i64 %310
%313 = mul i64 %66, %270
%314 = and i64 %313, 4294967295
%315 = getelementptr i8, i8* %65, i64 %314
%316 = getelementptr i8, i8* %68, i64 %314
%317 = trunc i64 %270 to i32
%318 = mul i32 %9, %317
%319 = zext i32 %318 to i64
%320 = getelementptr i8, i8* %0, i64 %319
%321 = getelementptr i8, i8* %53, i64 %319
%322 = mul i64 %55, %270
%323 = and i64 %322, 4294967295
%324 = getelementptr i8, i8* %54, i64 %323
%325 = getelementptr i8, i8* %57, i64 %323
%326 = trunc i64 %270 to i32
%327 = mul i32 %9, %326
%328 = zext i32 %327 to i64
%329 = getelementptr i8, i8* %0, i64 %328
%330 = getelementptr i8, i8* %43, i64 %328
%331 = trunc i64 %270 to i32
%332 = mul i32 %23, %331
%333 = zext i32 %332 to i64
%334 = getelementptr i8, i8* %0, i64 %333
%335 = getelementptr i8, i8* %27, i64 %333
%336 = mul i64 %270, %30
%337 = and i64 %336, 4294967295
%338 = getelementptr i8, i8* %28, i64 %337
%339 = getelementptr i8, i8* %32, i64 %337
%340 = trunc i64 %270 to i32
%341 = mul i32 %14, %340
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds i8, i8* %0, i64 %342
%344 = mul i32 %9, %340
%345 = zext i32 %344 to i64
%346 = getelementptr inbounds i8, i8* %0, i64 %345
%347 = getelementptr inbounds i8, i8* %346, i64 %16
%348 = getelementptr inbounds i8, i8* %343, i64 1
%349 = load i8, i8* %343
switch i8 %349, label %454 [
i8 4, label %1732
i8 1, label %350
i8 2, label %798
i8 3, label %1107
]
350: ; preds = %269
br i1 %17, label %602, label %351
351: ; preds = %350
br i1 %231, label %427, label %352
352: ; preds = %351
%353 = icmp ult i8* %320, %325
%354 = icmp ult i8* %324, %321
%355 = and i1 %353, %354
br i1 %355, label %427, label %356
356: ; preds = %352
%357 = getelementptr i8, i8* %346, i64 %232
%358 = getelementptr i8, i8* %348, i64 %232
br i1 %235, label %408, label %359
359: ; preds = %356, %359
%360 = phi i64 [ %405, %359 ], [ 0, %356 ]
%361 = phi i64 [ %406, %359 ], [ 0, %356 ]
%362 = getelementptr i8, i8* %346, i64 %360
%363 = getelementptr i8, i8* %348, i64 %360
%364 = bitcast i8* %363 to <16 x i8>*
%365 = load <16 x i8>, <16 x i8>* %364
%366 = getelementptr i8, i8* %363, i64 16
%367 = bitcast i8* %366 to <16 x i8>*
%368 = load <16 x i8>, <16 x i8>* %367
%369 = bitcast i8* %362 to <16 x i8>*
store <16 x i8> %365, <16 x i8>* %369
%370 = getelementptr i8, i8* %362, i64 16
%371 = bitcast i8* %370 to <16 x i8>*
store <16 x i8> %368, <16 x i8>* %371
%372 = or i64 %360, 32
%373 = getelementptr i8, i8* %346, i64 %372
%374 = getelementptr i8, i8* %348, i64 %372
%375 = bitcast i8* %374 to <16 x i8>*
%376 = load <16 x i8>, <16 x i8>* %375
%377 = getelementptr i8, i8* %374, i64 16
%378 = bitcast i8* %377 to <16 x i8>*
%379 = load <16 x i8>, <16 x i8>* %378
%380 = bitcast i8* %373 to <16 x i8>*
store <16 x i8> %376, <16 x i8>* %380
%381 = getelementptr i8, i8* %373, i64 16
%382 = bitcast i8* %381 to <16 x i8>*
store <16 x i8> %379, <16 x i8>* %382
%383 = or i64 %360, 64
%384 = getelementptr i8, i8* %346, i64 %383
%385 = getelementptr i8, i8* %348, i64 %383
%386 = bitcast i8* %385 to <16 x i8>*
%387 = load <16 x i8>, <16 x i8>* %386
%388 = getelementptr i8, i8* %385, i64 16
%389 = bitcast i8* %388 to <16 x i8>*
%390 = load <16 x i8>, <16 x i8>* %389
%391 = bitcast i8* %384 to <16 x i8>*
store <16 x i8> %387, <16 x i8>* %391
%392 = getelementptr i8, i8* %384, i64 16
%393 = bitcast i8* %392 to <16 x i8>*
store <16 x i8> %390, <16 x i8>* %393
%394 = or i64 %360, 96
%395 = getelementptr i8, i8* %346, i64 %394
%396 = getelementptr i8, i8* %348, i64 %394
%397 = bitcast i8* %396 to <16 x i8>*
%398 = load <16 x i8>, <16 x i8>* %397
%399 = getelementptr i8, i8* %396, i64 16
%400 = bitcast i8* %399 to <16 x i8>*
%401 = load <16 x i8>, <16 x i8>* %400
%402 = bitcast i8* %395 to <16 x i8>*
store <16 x i8> %398, <16 x i8>* %402
%403 = getelementptr i8, i8* %395, i64 16
%404 = bitcast i8* %403 to <16 x i8>*
store <16 x i8> %401, <16 x i8>* %404
%405 = add nuw i64 %360, 128
%406 = add i64 %361, 4
%407 = icmp eq i64 %406, %236
br i1 %407, label %408, label %359
408: ; preds = %359, %356
%409 = phi i64 [ 0, %356 ], [ %405, %359 ]
br i1 %237, label %426, label %410
410: ; preds = %408, %410
%411 = phi i64 [ %423, %410 ], [ %409, %408 ]
%412 = phi i64 [ %424, %410 ], [ 0, %408 ]
%413 = getelementptr i8, i8* %346, i64 %411
%414 = getelementptr i8, i8* %348, i64 %411
%415 = bitcast i8* %414 to <16 x i8>*
%416 = load <16 x i8>, <16 x i8>* %415
%417 = getelementptr i8, i8* %414, i64 16
%418 = bitcast i8* %417 to <16 x i8>*
%419 = load <16 x i8>, <16 x i8>* %418
%420 = bitcast i8* %413 to <16 x i8>*
store <16 x i8> %416, <16 x i8>* %420
%421 = getelementptr i8, i8* %413, i64 16
%422 = bitcast i8* %421 to <16 x i8>*
store <16 x i8> %419, <16 x i8>* %422
%423 = add nuw i64 %411, 32
%424 = add i64 %412, 1
%425 = icmp eq i64 %424, %234
br i1 %425, label %426, label %410
426: ; preds = %410, %408
br i1 %238, label %602, label %427
427: ; preds = %352, %351, %426
%428 = phi i8* [ %346, %352 ], [ %346, %351 ], [ %357, %426 ]
%429 = phi i8* [ %348, %352 ], [ %348, %351 ], [ %358, %426 ]
%430 = phi i32 [ 0, %352 ], [ 0, %351 ], [ %233, %426 ]
%431 = sub i32 %20, %430
%432 = xor i32 %430, -1
%433 = add i32 %20, %432
%434 = and i32 %431, 7
%435 = icmp eq i32 %434, 0
br i1 %435, label %447, label %436
436: ; preds = %427, %436
%437 = phi i8* [ %443, %436 ], [ %428, %427 ]
%438 = phi i8* [ %441, %436 ], [ %429, %427 ]
%439 = phi i32 [ %444, %436 ], [ %430, %427 ]
%440 = phi i32 [ %445, %436 ], [ 0, %427 ]
%441 = getelementptr inbounds i8, i8* %438, i64 1
%442 = load i8, i8* %438
%443 = getelementptr inbounds i8, i8* %437, i64 1
store i8 %442, i8* %437
%444 = add nuw nsw i32 %439, 1
%445 = add i32 %440, 1
%446 = icmp eq i32 %445, %434
br i1 %446, label %447, label %436
447: ; preds = %436, %427
%448 = phi i8* [ undef, %427 ], [ %441, %436 ]
%449 = phi i8* [ undef, %427 ], [ %443, %436 ]
%450 = phi i8* [ %428, %427 ], [ %443, %436 ]
%451 = phi i8* [ %429, %427 ], [ %441, %436 ]
%452 = phi i32 [ %430, %427 ], [ %444, %436 ]
%453 = icmp ult i32 %433, 7
br i1 %453, label %602, label %737
454: ; preds = %269
br i1 %19, label %1811, label %455
455: ; preds = %454
br i1 %255, label %547, label %456
456: ; preds = %455
%457 = icmp ult i8* %334, %339
%458 = icmp ult i8* %338, %335
%459 = and i1 %457, %458
br i1 %459, label %547, label %460
460: ; preds = %456
br i1 %256, label %533, label %461
461: ; preds = %460
br i1 %259, label %511, label %462
462: ; preds = %461, %462
%463 = phi i64 [ %508, %462 ], [ 0, %461 ]
%464 = phi i64 [ %509, %462 ], [ 0, %461 ]
%465 = getelementptr i8, i8* %346, i64 %463
%466 = getelementptr i8, i8* %348, i64 %463
%467 = bitcast i8* %466 to <16 x i8>*
%468 = load <16 x i8>, <16 x i8>* %467
%469 = getelementptr i8, i8* %466, i64 16
%470 = bitcast i8* %469 to <16 x i8>*
%471 = load <16 x i8>, <16 x i8>* %470
%472 = bitcast i8* %465 to <16 x i8>*
store <16 x i8> %468, <16 x i8>* %472
%473 = getelementptr i8, i8* %465, i64 16
%474 = bitcast i8* %473 to <16 x i8>*
store <16 x i8> %471, <16 x i8>* %474
%475 = or i64 %463, 32
%476 = getelementptr i8, i8* %346, i64 %475
%477 = getelementptr i8, i8* %348, i64 %475
%478 = bitcast i8* %477 to <16 x i8>*
%479 = load <16 x i8>, <16 x i8>* %478
%480 = getelementptr i8, i8* %477, i64 16
%481 = bitcast i8* %480 to <16 x i8>*
%482 = load <16 x i8>, <16 x i8>* %481
%483 = bitcast i8* %476 to <16 x i8>*
store <16 x i8> %479, <16 x i8>* %483
%484 = getelementptr i8, i8* %476, i64 16
%485 = bitcast i8* %484 to <16 x i8>*
store <16 x i8> %482, <16 x i8>* %485
%486 = or i64 %463, 64
%487 = getelementptr i8, i8* %346, i64 %486
%488 = getelementptr i8, i8* %348, i64 %486
%489 = bitcast i8* %488 to <16 x i8>*
%490 = load <16 x i8>, <16 x i8>* %489
%491 = getelementptr i8, i8* %488, i64 16
%492 = bitcast i8* %491 to <16 x i8>*
%493 = load <16 x i8>, <16 x i8>* %492
%494 = bitcast i8* %487 to <16 x i8>*
store <16 x i8> %490, <16 x i8>* %494
%495 = getelementptr i8, i8* %487, i64 16
%496 = bitcast i8* %495 to <16 x i8>*
store <16 x i8> %493, <16 x i8>* %496
%497 = or i64 %463, 96
%498 = getelementptr i8, i8* %346, i64 %497
%499 = getelementptr i8, i8* %348, i64 %497
%500 = bitcast i8* %499 to <16 x i8>*
%501 = load <16 x i8>, <16 x i8>* %500
%502 = getelementptr i8, i8* %499, i64 16
%503 = bitcast i8* %502 to <16 x i8>*
%504 = load <16 x i8>, <16 x i8>* %503
%505 = bitcast i8* %498 to <16 x i8>*
store <16 x i8> %501, <16 x i8>* %505
%506 = getelementptr i8, i8* %498, i64 16
%507 = bitcast i8* %506 to <16 x i8>*
store <16 x i8> %504, <16 x i8>* %507
%508 = add nuw i64 %463, 128
%509 = add i64 %464, 4
%510 = icmp eq i64 %509, %260
br i1 %510, label %511, label %462
511: ; preds = %462, %461
%512 = phi i64 [ 0, %461 ], [ %508, %462 ]
br i1 %261, label %529, label %513
513: ; preds = %511, %513
%514 = phi i64 [ %526, %513 ], [ %512, %511 ]
%515 = phi i64 [ %527, %513 ], [ 0, %511 ]
%516 = getelementptr i8, i8* %346, i64 %514
%517 = getelementptr i8, i8* %348, i64 %514
%518 = bitcast i8* %517 to <16 x i8>*
%519 = load <16 x i8>, <16 x i8>* %518
%520 = getelementptr i8, i8* %517, i64 16
%521 = bitcast i8* %520 to <16 x i8>*
%522 = load <16 x i8>, <16 x i8>* %521
%523 = bitcast i8* %516 to <16 x i8>*
store <16 x i8> %519, <16 x i8>* %523
%524 = getelementptr i8, i8* %516, i64 16
%525 = bitcast i8* %524 to <16 x i8>*
store <16 x i8> %522, <16 x i8>* %525
%526 = add nuw i64 %514, 32
%527 = add i64 %515, 1
%528 = icmp eq i64 %527, %258
br i1 %528, label %529, label %513
529: ; preds = %513, %511
br i1 %262, label %1811, label %530
530: ; preds = %529
%531 = getelementptr i8, i8* %348, i64 %257
%532 = getelementptr i8, i8* %346, i64 %257
br i1 %265, label %547, label %533
533: ; preds = %460, %530
%534 = phi i64 [ %257, %530 ], [ 0, %460 ]
%535 = getelementptr i8, i8* %346, i64 %266
%536 = getelementptr i8, i8* %348, i64 %266
br label %537
537: ; preds = %537, %533
%538 = phi i64 [ %534, %533 ], [ %544, %537 ]
%539 = getelementptr i8, i8* %346, i64 %538
%540 = getelementptr i8, i8* %348, i64 %538
%541 = bitcast i8* %540 to <8 x i8>*
%542 = load <8 x i8>, <8 x i8>* %541
%543 = bitcast i8* %539 to <8 x i8>*
store <8 x i8> %542, <8 x i8>* %543
%544 = add nuw i64 %538, 8
%545 = icmp eq i64 %544, %266
br i1 %545, label %546, label %537
546: ; preds = %537
br i1 %268, label %1811, label %547
547: ; preds = %456, %455, %530, %546
%548 = phi i8* [ %346, %455 ], [ %346, %456 ], [ %532, %530 ], [ %535, %546 ]
%549 = phi i8* [ %348, %455 ], [ %348, %456 ], [ %531, %530 ], [ %536, %546 ]
%550 = phi i32 [ 0, %455 ], [ 0, %456 ], [ %263, %530 ], [ %267, %546 ]
%551 = sub i32 %21, %550
%552 = xor i32 %550, -1
%553 = add i32 %21, %552
%554 = and i32 %551, 7
%555 = icmp eq i32 %554, 0
br i1 %555, label %567, label %556
556: ; preds = %547, %556
%557 = phi i8* [ %563, %556 ], [ %548, %547 ]
%558 = phi i8* [ %561, %556 ], [ %549, %547 ]
%559 = phi i32 [ %564, %556 ], [ %550, %547 ]
%560 = phi i32 [ %565, %556 ], [ 0, %547 ]
%561 = getelementptr inbounds i8, i8* %558, i64 1
%562 = load i8, i8* %558
%563 = getelementptr inbounds i8, i8* %557, i64 1
store i8 %562, i8* %557
%564 = add nuw nsw i32 %559, 1
%565 = add i32 %560, 1
%566 = icmp eq i32 %565, %554
br i1 %566, label %567, label %556
567: ; preds = %556, %547
%568 = phi i8* [ %548, %547 ], [ %563, %556 ]
%569 = phi i8* [ %549, %547 ], [ %561, %556 ]
%570 = phi i32 [ %550, %547 ], [ %564, %556 ]
%571 = icmp ult i32 %553, 7
br i1 %571, label %1811, label %572
572: ; preds = %567, %572
%573 = phi i8* [ %599, %572 ], [ %568, %567 ]
%574 = phi i8* [ %597, %572 ], [ %569, %567 ]
%575 = phi i32 [ %600, %572 ], [ %570, %567 ]
%576 = getelementptr inbounds i8, i8* %574, i64 1
%577 = load i8, i8* %574
%578 = getelementptr inbounds i8, i8* %573, i64 1
store i8 %577, i8* %573
%579 = getelementptr inbounds i8, i8* %574, i64 2
%580 = load i8, i8* %576
%581 = getelementptr inbounds i8, i8* %573, i64 2
store i8 %580, i8* %578
%582 = getelementptr inbounds i8, i8* %574, i64 3
%583 = load i8, i8* %579
%584 = getelementptr inbounds i8, i8* %573, i64 3
store i8 %583, i8* %581
%585 = getelementptr inbounds i8, i8* %574, i64 4
%586 = load i8, i8* %582
%587 = getelementptr inbounds i8, i8* %573, i64 4
store i8 %586, i8* %584
%588 = getelementptr inbounds i8, i8* %574, i64 5
%589 = load i8, i8* %585
%590 = getelementptr inbounds i8, i8* %573, i64 5
store i8 %589, i8* %587
%591 = getelementptr inbounds i8, i8* %574, i64 6
%592 = load i8, i8* %588
%593 = getelementptr inbounds i8, i8* %573, i64 6
store i8 %592, i8* %590
%594 = getelementptr inbounds i8, i8* %574, i64 7
%595 = load i8, i8* %591
%596 = getelementptr inbounds i8, i8* %573, i64 7
store i8 %595, i8* %593
%597 = getelementptr inbounds i8, i8* %574, i64 8
%598 = load i8, i8* %594
%599 = getelementptr inbounds i8, i8* %573, i64 8
store i8 %598, i8* %596
%600 = add nuw nsw i32 %575, 8
%601 = icmp eq i32 %600, %21
br i1 %601, label %1811, label %572
602: ; preds = %447, %737, %426, %350
%603 = phi i8* [ %348, %350 ], [ %358, %426 ], [ %448, %447 ], [ %762, %737 ]
%604 = phi i8* [ %346, %350 ], [ %357, %426 ], [ %449, %447 ], [ %764, %737 ]
br i1 %18, label %605, label %1811
605: ; preds = %602
br i1 %239, label %706, label %606
606: ; preds = %605
%607 = getelementptr i8, i8* %604, i64 %42
%608 = getelementptr i8, i8* %603, i64 %42
%609 = icmp ult i8* %604, %608
%610 = icmp ult i8* %603, %607
%611 = and i1 %609, %610
%612 = icmp ult i8* %604, %330
%613 = icmp ult i8* %329, %607
%614 = and i1 %612, %613
%615 = or i1 %611, %614
br i1 %615, label %706, label %616
616: ; preds = %606
br i1 %240, label %687, label %617
617: ; preds = %616
br i1 %243, label %661, label %618
618: ; preds = %617, %618
%619 = phi i64 [ %658, %618 ], [ 0, %617 ]
%620 = phi i64 [ %659, %618 ], [ 0, %617 ]
%621 = getelementptr i8, i8* %346, i64 %619
%622 = getelementptr i8, i8* %604, i64 %619
%623 = getelementptr i8, i8* %603, i64 %619
%624 = bitcast i8* %623 to <16 x i8>*
%625 = load <16 x i8>, <16 x i8>* %624
%626 = getelementptr i8, i8* %623, i64 16
%627 = bitcast i8* %626 to <16 x i8>*
%628 = load <16 x i8>, <16 x i8>* %627
%629 = bitcast i8* %621 to <16 x i8>*
%630 = load <16 x i8>, <16 x i8>* %629
%631 = getelementptr i8, i8* %621, i64 16
%632 = bitcast i8* %631 to <16 x i8>*
%633 = load <16 x i8>, <16 x i8>* %632
%634 = add <16 x i8> %630, %625
%635 = add <16 x i8> %633, %628
%636 = bitcast i8* %622 to <16 x i8>*
store <16 x i8> %634, <16 x i8>* %636
%637 = getelementptr i8, i8* %622, i64 16
%638 = bitcast i8* %637 to <16 x i8>*
store <16 x i8> %635, <16 x i8>* %638
%639 = or i64 %619, 32
%640 = getelementptr i8, i8* %346, i64 %639
%641 = getelementptr i8, i8* %604, i64 %639
%642 = getelementptr i8, i8* %603, i64 %639
%643 = bitcast i8* %642 to <16 x i8>*
%644 = load <16 x i8>, <16 x i8>* %643
%645 = getelementptr i8, i8* %642, i64 16
%646 = bitcast i8* %645 to <16 x i8>*
%647 = load <16 x i8>, <16 x i8>* %646
%648 = bitcast i8* %640 to <16 x i8>*
%649 = load <16 x i8>, <16 x i8>* %648
%650 = getelementptr i8, i8* %640, i64 16
%651 = bitcast i8* %650 to <16 x i8>*
%652 = load <16 x i8>, <16 x i8>* %651
%653 = add <16 x i8> %649, %644
%654 = add <16 x i8> %652, %647
%655 = bitcast i8* %641 to <16 x i8>*
store <16 x i8> %653, <16 x i8>* %655
%656 = getelementptr i8, i8* %641, i64 16
%657 = bitcast i8* %656 to <16 x i8>*
store <16 x i8> %654, <16 x i8>* %657
%658 = add nuw i64 %619, 64
%659 = add i64 %620, 2
%660 = icmp eq i64 %659, %244
br i1 %660, label %661, label %618
661: ; preds = %618, %617
%662 = phi i64 [ 0, %617 ], [ %658, %618 ]
br i1 %245, label %682, label %663
663: ; preds = %661
%664 = getelementptr i8, i8* %346, i64 %662
%665 = getelementptr i8, i8* %604, i64 %662
%666 = getelementptr i8, i8* %603, i64 %662
%667 = bitcast i8* %666 to <16 x i8>*
%668 = load <16 x i8>, <16 x i8>* %667
%669 = getelementptr i8, i8* %666, i64 16
%670 = bitcast i8* %669 to <16 x i8>*
%671 = load <16 x i8>, <16 x i8>* %670
%672 = bitcast i8* %664 to <16 x i8>*
%673 = load <16 x i8>, <16 x i8>* %672
%674 = getelementptr i8, i8* %664, i64 16
%675 = bitcast i8* %674 to <16 x i8>*
%676 = load <16 x i8>, <16 x i8>* %675
%677 = add <16 x i8> %673, %668
%678 = add <16 x i8> %676, %671
%679 = bitcast i8* %665 to <16 x i8>*
store <16 x i8> %677, <16 x i8>* %679
%680 = getelementptr i8, i8* %665, i64 16
%681 = bitcast i8* %680 to <16 x i8>*
store <16 x i8> %678, <16 x i8>* %681
br label %682
682: ; preds = %661, %663
br i1 %246, label %1811, label %683
683: ; preds = %682
%684 = getelementptr i8, i8* %603, i64 %241
%685 = getelementptr i8, i8* %604, i64 %241
%686 = getelementptr i8, i8* %346, i64 %241
br i1 %250, label %706, label %687
687: ; preds = %616, %683
%688 = phi i64 [ %241, %683 ], [ 0, %616 ]
%689 = getelementptr i8, i8* %346, i64 %251
%690 = getelementptr i8, i8* %604, i64 %251
%691 = getelementptr i8, i8* %603, i64 %251
br label %692
692: ; preds = %692, %687
%693 = phi i64 [ %688, %687 ], [ %703, %692 ]
%694 = getelementptr i8, i8* %346, i64 %693
%695 = getelementptr i8, i8* %604, i64 %693
%696 = getelementptr i8, i8* %603, i64 %693
%697 = bitcast i8* %696 to <8 x i8>*
%698 = load <8 x i8>, <8 x i8>* %697
%699 = bitcast i8* %694 to <8 x i8>*
%700 = load <8 x i8>, <8 x i8>* %699
%701 = add <8 x i8> %700, %698
%702 = bitcast i8* %695 to <8 x i8>*
store <8 x i8> %701, <8 x i8>* %702
%703 = add nuw i64 %693, 8
%704 = icmp eq i64 %703, %251
br i1 %704, label %705, label %692
705: ; preds = %692
br i1 %254, label %1811, label %706
706: ; preds = %606, %605, %683, %705
%707 = phi i8* [ %346, %605 ], [ %346, %606 ], [ %686, %683 ], [ %689, %705 ]
%708 = phi i8* [ %604, %605 ], [ %604, %606 ], [ %685, %683 ], [ %690, %705 ]
%709 = phi i8* [ %603, %605 ], [ %603, %606 ], [ %684, %683 ], [ %691, %705 ]
%710 = phi i32 [ %11, %605 ], [ %11, %606 ], [ %248, %683 ], [ %253, %705 ]
%711 = sub i32 %9, %710
%712 = xor i32 %710, -1
%713 = add i32 %9, %712
%714 = and i32 %711, 3
%715 = icmp eq i32 %714, 0
br i1 %715, label %731, label %716
716: ; preds = %706, %716
%717 = phi i8* [ %724, %716 ], [ %707, %706 ]
%718 = phi i8* [ %727, %716 ], [ %708, %706 ]
%719 = phi i8* [ %722, %716 ], [ %709, %706 ]
%720 = phi i32 [ %728, %716 ], [ %710, %706 ]
%721 = phi i32 [ %729, %716 ], [ 0, %706 ]
%722 = getelementptr inbounds i8, i8* %719, i64 1
%723 = load i8, i8* %719
%724 = getelementptr inbounds i8, i8* %717, i64 1
%725 = load i8, i8* %717
%726 = add i8 %725, %723
%727 = getelementptr inbounds i8, i8* %718, i64 1
store i8 %726, i8* %718
%728 = add nuw nsw i32 %720, 1
%729 = add i32 %721, 1
%730 = icmp eq i32 %729, %714
br i1 %730, label %731, label %716
731: ; preds = %716, %706
%732 = phi i8* [ %707, %706 ], [ %724, %716 ]
%733 = phi i8* [ %708, %706 ], [ %727, %716 ]
%734 = phi i8* [ %709, %706 ], [ %722, %716 ]
%735 = phi i32 [ %710, %706 ], [ %728, %716 ]
%736 = icmp ult i32 %713, 3
br i1 %736, label %1811, label %767
737: ; preds = %447, %737
%738 = phi i8* [ %764, %737 ], [ %450, %447 ]
%739 = phi i8* [ %762, %737 ], [ %451, %447 ]
%740 = phi i32 [ %765, %737 ], [ %452, %447 ]
%741 = getelementptr inbounds i8, i8* %739, i64 1
%742 = load i8, i8* %739
%743 = getelementptr inbounds i8, i8* %738, i64 1
store i8 %742, i8* %738
%744 = getelementptr inbounds i8, i8* %739, i64 2
%745 = load i8, i8* %741
%746 = getelementptr inbounds i8, i8* %738, i64 2
store i8 %745, i8* %743
%747 = getelementptr inbounds i8, i8* %739, i64 3
%748 = load i8, i8* %744
%749 = getelementptr inbounds i8, i8* %738, i64 3
store i8 %748, i8* %746
%750 = getelementptr inbounds i8, i8* %739, i64 4
%751 = load i8, i8* %747
%752 = getelementptr inbounds i8, i8* %738, i64 4
store i8 %751, i8* %749
%753 = getelementptr inbounds i8, i8* %739, i64 5
%754 = load i8, i8* %750
%755 = getelementptr inbounds i8, i8* %738, i64 5
store i8 %754, i8* %752
%756 = getelementptr inbounds i8, i8* %739, i64 6
%757 = load i8, i8* %753
%758 = getelementptr inbounds i8, i8* %738, i64 6
store i8 %757, i8* %755
%759 = getelementptr inbounds i8, i8* %739, i64 7
%760 = load i8, i8* %756
%761 = getelementptr inbounds i8, i8* %738, i64 7
store i8 %760, i8* %758
%762 = getelementptr inbounds i8, i8* %739, i64 8
%763 = load i8, i8* %759
%764 = getelementptr inbounds i8, i8* %738, i64 8
store i8 %763, i8* %761
%765 = add nuw nsw i32 %740, 8
%766 = icmp eq i32 %765, %20
br i1 %766, label %602, label %737
767: ; preds = %731, %767
%768 = phi i8* [ %792, %767 ], [ %732, %731 ]
%769 = phi i8* [ %795, %767 ], [ %733, %731 ]
%770 = phi i8* [ %790, %767 ], [ %734, %731 ]
%771 = phi i32 [ %796, %767 ], [ %735, %731 ]
%772 = getelementptr inbounds i8, i8* %770, i64 1
%773 = load i8, i8* %770
%774 = getelementptr inbounds i8, i8* %768, i64 1
%775 = load i8, i8* %768
%776 = add i8 %775, %773
%777 = getelementptr inbounds i8, i8* %769, i64 1
store i8 %776, i8* %769
%778 = getelementptr inbounds i8, i8* %770, i64 2
%779 = load i8, i8* %772
%780 = getelementptr inbounds i8, i8* %768, i64 2
%781 = load i8, i8* %774
%782 = add i8 %781, %779
%783 = getelementptr inbounds i8, i8* %769, i64 2
store i8 %782, i8* %777
%784 = getelementptr inbounds i8, i8* %770, i64 3
%785 = load i8, i8* %778
%786 = getelementptr inbounds i8, i8* %768, i64 3
%787 = load i8, i8* %780
%788 = add i8 %787, %785
%789 = getelementptr inbounds i8, i8* %769, i64 3
store i8 %788, i8* %783
%790 = getelementptr inbounds i8, i8* %770, i64 4
%791 = load i8, i8* %784
%792 = getelementptr inbounds i8, i8* %768, i64 4
%793 = load i8, i8* %786
%794 = add i8 %793, %791
%795 = getelementptr inbounds i8, i8* %769, i64 4
store i8 %794, i8* %789
%796 = add nuw nsw i32 %771, 4
%797 = icmp eq i32 %796, %9
br i1 %797, label %1811, label %767
798: ; preds = %269
%799 = icmp eq i64 %270, 0
br i1 %799, label %928, label %800
800: ; preds = %798
br i1 %19, label %1811, label %801
801: ; preds = %800
br i1 %200, label %897, label %802
802: ; preds = %801
%803 = icmp ult i8* %302, %307
%804 = icmp ult i8* %306, %303
%805 = and i1 %803, %804
%806 = or i1 %805, %203
br i1 %806, label %897, label %807
807: ; preds = %802
br i1 %204, label %878, label %808
808: ; preds = %807
br i1 %207, label %852, label %809
809: ; preds = %808, %809
%810 = phi i64 [ %849, %809 ], [ 0, %808 ]
%811 = phi i64 [ %850, %809 ], [ 0, %808 ]
%812 = getelementptr i8, i8* %347, i64 %810
%813 = getelementptr i8, i8* %346, i64 %810
%814 = getelementptr i8, i8* %348, i64 %810
%815 = bitcast i8* %814 to <16 x i8>*
%816 = load <16 x i8>, <16 x i8>* %815
%817 = getelementptr i8, i8* %814, i64 16
%818 = bitcast i8* %817 to <16 x i8>*
%819 = load <16 x i8>, <16 x i8>* %818
%820 = bitcast i8* %812 to <16 x i8>*
%821 = load <16 x i8>, <16 x i8>* %820
%822 = getelementptr i8, i8* %812, i64 16
%823 = bitcast i8* %822 to <16 x i8>*
%824 = load <16 x i8>, <16 x i8>* %823
%825 = add <16 x i8> %821, %816
%826 = add <16 x i8> %824, %819
%827 = bitcast i8* %813 to <16 x i8>*
store <16 x i8> %825, <16 x i8>* %827
%828 = getelementptr i8, i8* %813, i64 16
%829 = bitcast i8* %828 to <16 x i8>*
store <16 x i8> %826, <16 x i8>* %829
%830 = or i64 %810, 32
%831 = getelementptr i8, i8* %347, i64 %830
%832 = getelementptr i8, i8* %346, i64 %830
%833 = getelementptr i8, i8* %348, i64 %830
%834 = bitcast i8* %833 to <16 x i8>*
%835 = load <16 x i8>, <16 x i8>* %834
%836 = getelementptr i8, i8* %833, i64 16
%837 = bitcast i8* %836 to <16 x i8>*
%838 = load <16 x i8>, <16 x i8>* %837
%839 = bitcast i8* %831 to <16 x i8>*
%840 = load <16 x i8>, <16 x i8>* %839
%841 = getelementptr i8, i8* %831, i64 16
%842 = bitcast i8* %841 to <16 x i8>*
%843 = load <16 x i8>, <16 x i8>* %842
%844 = add <16 x i8> %840, %835
%845 = add <16 x i8> %843, %838
%846 = bitcast i8* %832 to <16 x i8>*
store <16 x i8> %844, <16 x i8>* %846
%847 = getelementptr i8, i8* %832, i64 16
%848 = bitcast i8* %847 to <16 x i8>*
store <16 x i8> %845, <16 x i8>* %848
%849 = add nuw i64 %810, 64
%850 = add i64 %811, 2
%851 = icmp eq i64 %850, %208
br i1 %851, label %852, label %809
852: ; preds = %809, %808
%853 = phi i64 [ 0, %808 ], [ %849, %809 ]
br i1 %209, label %873, label %854
854: ; preds = %852
%855 = getelementptr i8, i8* %347, i64 %853
%856 = getelementptr i8, i8* %346, i64 %853
%857 = getelementptr i8, i8* %348, i64 %853
%858 = bitcast i8* %857 to <16 x i8>*
%859 = load <16 x i8>, <16 x i8>* %858
%860 = getelementptr i8, i8* %857, i64 16
%861 = bitcast i8* %860 to <16 x i8>*
%862 = load <16 x i8>, <16 x i8>* %861
%863 = bitcast i8* %855 to <16 x i8>*
%864 = load <16 x i8>, <16 x i8>* %863
%865 = getelementptr i8, i8* %855, i64 16
%866 = bitcast i8* %865 to <16 x i8>*
%867 = load <16 x i8>, <16 x i8>* %866
%868 = add <16 x i8> %864, %859
%869 = add <16 x i8> %867, %862
%870 = bitcast i8* %856 to <16 x i8>*
store <16 x i8> %868, <16 x i8>* %870
%871 = getelementptr i8, i8* %856, i64 16
%872 = bitcast i8* %871 to <16 x i8>*
store <16 x i8> %869, <16 x i8>* %872
br label %873
873: ; preds = %852, %854
br i1 %210, label %1811, label %874
874: ; preds = %873
%875 = getelementptr i8, i8* %348, i64 %205
%876 = getelementptr i8, i8* %346, i64 %205
%877 = getelementptr i8, i8* %347, i64 %205
br i1 %213, label %897, label %878
878: ; preds = %807, %874
%879 = phi i64 [ %205, %874 ], [ 0, %807 ]
%880 = getelementptr i8, i8* %347, i64 %214
%881 = getelementptr i8, i8* %346, i64 %214
%882 = getelementptr i8, i8* %348, i64 %214
br label %883
883: ; preds = %883, %878
%884 = phi i64 [ %879, %878 ], [ %894, %883 ]
%885 = getelementptr i8, i8* %347, i64 %884
%886 = getelementptr i8, i8* %346, i64 %884
%887 = getelementptr i8, i8* %348, i64 %884
%888 = bitcast i8* %887 to <8 x i8>*
%889 = load <8 x i8>, <8 x i8>* %888
%890 = bitcast i8* %885 to <8 x i8>*
%891 = load <8 x i8>, <8 x i8>* %890
%892 = add <8 x i8> %891, %889
%893 = bitcast i8* %886 to <8 x i8>*
store <8 x i8> %892, <8 x i8>* %893
%894 = add nuw i64 %884, 8
%895 = icmp eq i64 %894, %214
br i1 %895, label %896, label %883
896: ; preds = %883
br i1 %216, label %1811, label %897
897: ; preds = %802, %801, %874, %896
%898 = phi i8* [ %347, %801 ], [ %347, %802 ], [ %877, %874 ], [ %880, %896 ]
%899 = phi i8* [ %346, %801 ], [ %346, %802 ], [ %876, %874 ], [ %881, %896 ]
%900 = phi i8* [ %348, %801 ], [ %348, %802 ], [ %875, %874 ], [ %882, %896 ]
%901 = phi i32 [ 0, %801 ], [ 0, %802 ], [ %211, %874 ], [ %215, %896 ]
%902 = sub i32 %21, %901
%903 = xor i32 %901, -1
%904 = add i32 %21, %903
%905 = and i32 %902, 3
%906 = icmp eq i32 %905, 0
br i1 %906, label %922, label %907
907: ; preds = %897, %907
%908 = phi i8* [ %915, %907 ], [ %898, %897 ]
%909 = phi i8* [ %918, %907 ], [ %899, %897 ]
%910 = phi i8* [ %913, %907 ], [ %900, %897 ]
%911 = phi i32 [ %919, %907 ], [ %901, %897 ]
%912 = phi i32 [ %920, %907 ], [ 0, %897 ]
%913 = getelementptr inbounds i8, i8* %910, i64 1
%914 = load i8, i8* %910
%915 = getelementptr inbounds i8, i8* %908, i64 1
%916 = load i8, i8* %908
%917 = add i8 %916, %914
%918 = getelementptr inbounds i8, i8* %909, i64 1
store i8 %917, i8* %909
%919 = add nuw nsw i32 %911, 1
%920 = add i32 %912, 1
%921 = icmp eq i32 %920, %905
br i1 %921, label %922, label %907
922: ; preds = %907, %897
%923 = phi i8* [ %898, %897 ], [ %915, %907 ]
%924 = phi i8* [ %899, %897 ], [ %918, %907 ]
%925 = phi i8* [ %900, %897 ], [ %913, %907 ]
%926 = phi i32 [ %901, %897 ], [ %919, %907 ]
%927 = icmp ult i32 %904, 3
br i1 %927, label %1811, label %1076
928: ; preds = %798
br i1 %19, label %1811, label %929
929: ; preds = %928
br i1 %217, label %1021, label %930
930: ; preds = %929
%931 = icmp ult i8* %311, %316
%932 = icmp ult i8* %315, %312
%933 = and i1 %931, %932
br i1 %933, label %1021, label %934
934: ; preds = %930
br i1 %218, label %1007, label %935
935: ; preds = %934
br i1 %221, label %985, label %936
936: ; preds = %935, %936
%937 = phi i64 [ %982, %936 ], [ 0, %935 ]
%938 = phi i64 [ %983, %936 ], [ 0, %935 ]
%939 = getelementptr i8, i8* %346, i64 %937
%940 = getelementptr i8, i8* %348, i64 %937
%941 = bitcast i8* %940 to <16 x i8>*
%942 = load <16 x i8>, <16 x i8>* %941
%943 = getelementptr i8, i8* %940, i64 16
%944 = bitcast i8* %943 to <16 x i8>*
%945 = load <16 x i8>, <16 x i8>* %944
%946 = bitcast i8* %939 to <16 x i8>*
store <16 x i8> %942, <16 x i8>* %946
%947 = getelementptr i8, i8* %939, i64 16
%948 = bitcast i8* %947 to <16 x i8>*
store <16 x i8> %945, <16 x i8>* %948
%949 = or i64 %937, 32
%950 = getelementptr i8, i8* %346, i64 %949
%951 = getelementptr i8, i8* %348, i64 %949
%952 = bitcast i8* %951 to <16 x i8>*
%953 = load <16 x i8>, <16 x i8>* %952
%954 = getelementptr i8, i8* %951, i64 16
%955 = bitcast i8* %954 to <16 x i8>*
%956 = load <16 x i8>, <16 x i8>* %955
%957 = bitcast i8* %950 to <16 x i8>*
store <16 x i8> %953, <16 x i8>* %957
%958 = getelementptr i8, i8* %950, i64 16
%959 = bitcast i8* %958 to <16 x i8>*
store <16 x i8> %956, <16 x i8>* %959
%960 = or i64 %937, 64
%961 = getelementptr i8, i8* %346, i64 %960
%962 = getelementptr i8, i8* %348, i64 %960
%963 = bitcast i8* %962 to <16 x i8>*
%964 = load <16 x i8>, <16 x i8>* %963
%965 = getelementptr i8, i8* %962, i64 16
%966 = bitcast i8* %965 to <16 x i8>*
%967 = load <16 x i8>, <16 x i8>* %966
%968 = bitcast i8* %961 to <16 x i8>*
store <16 x i8> %964, <16 x i8>* %968
%969 = getelementptr i8, i8* %961, i64 16
%970 = bitcast i8* %969 to <16 x i8>*
store <16 x i8> %967, <16 x i8>* %970
%971 = or i64 %937, 96
%972 = getelementptr i8, i8* %346, i64 %971
%973 = getelementptr i8, i8* %348, i64 %971
%974 = bitcast i8* %973 to <16 x i8>*
%975 = load <16 x i8>, <16 x i8>* %974
%976 = getelementptr i8, i8* %973, i64 16
%977 = bitcast i8* %976 to <16 x i8>*
%978 = load <16 x i8>, <16 x i8>* %977
%979 = bitcast i8* %972 to <16 x i8>*
store <16 x i8> %975, <16 x i8>* %979
%980 = getelementptr i8, i8* %972, i64 16
%981 = bitcast i8* %980 to <16 x i8>*
store <16 x i8> %978, <16 x i8>* %981
%982 = add nuw i64 %937, 128
%983 = add i64 %938, 4
%984 = icmp eq i64 %983, %222
br i1 %984, label %985, label %936
985: ; preds = %936, %935
%986 = phi i64 [ 0, %935 ], [ %982, %936 ]
br i1 %223, label %1003, label %987
987: ; preds = %985, %987
%988 = phi i64 [ %1000, %987 ], [ %986, %985 ]
%989 = phi i64 [ %1001, %987 ], [ 0, %985 ]
%990 = getelementptr i8, i8* %346, i64 %988
%991 = getelementptr i8, i8* %348, i64 %988
%992 = bitcast i8* %991 to <16 x i8>*
%993 = load <16 x i8>, <16 x i8>* %992
%994 = getelementptr i8, i8* %991, i64 16
%995 = bitcast i8* %994 to <16 x i8>*
%996 = load <16 x i8>, <16 x i8>* %995
%997 = bitcast i8* %990 to <16 x i8>*
store <16 x i8> %993, <16 x i8>* %997
%998 = getelementptr i8, i8* %990, i64 16
%999 = bitcast i8* %998 to <16 x i8>*
store <16 x i8> %996, <16 x i8>* %999
%1000 = add nuw i64 %988, 32
%1001 = add i64 %989, 1
%1002 = icmp eq i64 %1001, %220
br i1 %1002, label %1003, label %987
1003: ; preds = %987, %985
br i1 %224, label %1811, label %1004
1004: ; preds = %1003
%1005 = getelementptr i8, i8* %348, i64 %219
%1006 = getelementptr i8, i8* %346, i64 %219
br i1 %227, label %1021, label %1007
1007: ; preds = %934, %1004
%1008 = phi i64 [ %219, %1004 ], [ 0, %934 ]
%1009 = getelementptr i8, i8* %346, i64 %228
%1010 = getelementptr i8, i8* %348, i64 %228
br label %1011
1011: ; preds = %1011, %1007
%1012 = phi i64 [ %1008, %1007 ], [ %1018, %1011 ]
%1013 = getelementptr i8, i8* %346, i64 %1012
%1014 = getelementptr i8, i8* %348, i64 %1012
%1015 = bitcast i8* %1014 to <8 x i8>*
%1016 = load <8 x i8>, <8 x i8>* %1015
%1017 = bitcast i8* %1013 to <8 x i8>*
store <8 x i8> %1016, <8 x i8>* %1017
%1018 = add nuw i64 %1012, 8
%1019 = icmp eq i64 %1018, %228
br i1 %1019, label %1020, label %1011
1020: ; preds = %1011
br i1 %230, label %1811, label %1021
1021: ; preds = %930, %929, %1004, %1020
%1022 = phi i8* [ %346, %929 ], [ %346, %930 ], [ %1006, %1004 ], [ %1009, %1020 ]
%1023 = phi i8* [ %348, %929 ], [ %348, %930 ], [ %1005, %1004 ], [ %1010, %1020 ]
%1024 = phi i32 [ 0, %929 ], [ 0, %930 ], [ %225, %1004 ], [ %229, %1020 ]
%1025 = sub i32 %21, %1024
%1026 = xor i32 %1024, -1
%1027 = add i32 %21, %1026
%1028 = and i32 %1025, 7
%1029 = icmp eq i32 %1028, 0
br i1 %1029, label %1041, label %1030
1030: ; preds = %1021, %1030
%1031 = phi i8* [ %1037, %1030 ], [ %1022, %1021 ]
%1032 = phi i8* [ %1035, %1030 ], [ %1023, %1021 ]
%1033 = phi i32 [ %1038, %1030 ], [ %1024, %1021 ]
%1034 = phi i32 [ %1039, %1030 ], [ 0, %1021 ]
%1035 = getelementptr inbounds i8, i8* %1032, i64 1
%1036 = load i8, i8* %1032
%1037 = getelementptr inbounds i8, i8* %1031, i64 1
store i8 %1036, i8* %1031
%1038 = add nuw nsw i32 %1033, 1
%1039 = add i32 %1034, 1
%1040 = icmp eq i32 %1039, %1028
br i1 %1040, label %1041, label %1030
1041: ; preds = %1030, %1021
%1042 = phi i8* [ %1022, %1021 ], [ %1037, %1030 ]
%1043 = phi i8* [ %1023, %1021 ], [ %1035, %1030 ]
%1044 = phi i32 [ %1024, %1021 ], [ %1038, %1030 ]
%1045 = icmp ult i32 %1027, 7
br i1 %1045, label %1811, label %1046
1046: ; preds = %1041, %1046
%1047 = phi i8* [ %1073, %1046 ], [ %1042, %1041 ]
%1048 = phi i8* [ %1071, %1046 ], [ %1043, %1041 ]
%1049 = phi i32 [ %1074, %1046 ], [ %1044, %1041 ]
%1050 = getelementptr inbounds i8, i8* %1048, i64 1
%1051 = load i8, i8* %1048
%1052 = getelementptr inbounds i8, i8* %1047, i64 1
store i8 %1051, i8* %1047
%1053 = getelementptr inbounds i8, i8* %1048, i64 2
%1054 = load i8, i8* %1050
%1055 = getelementptr inbounds i8, i8* %1047, i64 2
store i8 %1054, i8* %1052
%1056 = getelementptr inbounds i8, i8* %1048, i64 3
%1057 = load i8, i8* %1053
%1058 = getelementptr inbounds i8, i8* %1047, i64 3
store i8 %1057, i8* %1055
%1059 = getelementptr inbounds i8, i8* %1048, i64 4
%1060 = load i8, i8* %1056
%1061 = getelementptr inbounds i8, i8* %1047, i64 4
store i8 %1060, i8* %1058
%1062 = getelementptr inbounds i8, i8* %1048, i64 5
%1063 = load i8, i8* %1059
%1064 = getelementptr inbounds i8, i8* %1047, i64 5
store i8 %1063, i8* %1061
%1065 = getelementptr inbounds i8, i8* %1048, i64 6
%1066 = load i8, i8* %1062
%1067 = getelementptr inbounds i8, i8* %1047, i64 6
store i8 %1066, i8* %1064
%1068 = getelementptr inbounds i8, i8* %1048, i64 7
%1069 = load i8, i8* %1065
%1070 = getelementptr inbounds i8, i8* %1047, i64 7
store i8 %1069, i8* %1067
%1071 = getelementptr inbounds i8, i8* %1048, i64 8
%1072 = load i8, i8* %1068
%1073 = getelementptr inbounds i8, i8* %1047, i64 8
store i8 %1072, i8* %1070
%1074 = add nuw nsw i32 %1049, 8
%1075 = icmp eq i32 %1074, %21
br i1 %1075, label %1811, label %1046
1076: ; preds = %922, %1076
%1077 = phi i8* [ %1101, %1076 ], [ %923, %922 ]
%1078 = phi i8* [ %1104, %1076 ], [ %924, %922 ]
%1079 = phi i8* [ %1099, %1076 ], [ %925, %922 ]
%1080 = phi i32 [ %1105, %1076 ], [ %926, %922 ]
%1081 = getelementptr inbounds i8, i8* %1079, i64 1
%1082 = load i8, i8* %1079
%1083 = getelementptr inbounds i8, i8* %1077, i64 1
%1084 = load i8, i8* %1077
%1085 = add i8 %1084, %1082
%1086 = getelementptr inbounds i8, i8* %1078, i64 1
store i8 %1085, i8* %1078
%1087 = getelementptr inbounds i8, i8* %1079, i64 2
%1088 = load i8, i8* %1081
%1089 = getelementptr inbounds i8, i8* %1077, i64 2
%1090 = load i8, i8* %1083
%1091 = add i8 %1090, %1088
%1092 = getelementptr inbounds i8, i8* %1078, i64 2
store i8 %1091, i8* %1086
%1093 = getelementptr inbounds i8, i8* %1079, i64 3
%1094 = load i8, i8* %1087
%1095 = getelementptr inbounds i8, i8* %1077, i64 3
%1096 = load i8, i8* %1089
%1097 = add i8 %1096, %1094
%1098 = getelementptr inbounds i8, i8* %1078, i64 3
store i8 %1097, i8* %1092
%1099 = getelementptr inbounds i8, i8* %1079, i64 4
%1100 = load i8, i8* %1093
%1101 = getelementptr inbounds i8, i8* %1077, i64 4
%1102 = load i8, i8* %1095
%1103 = add i8 %1102, %1100
%1104 = getelementptr inbounds i8, i8* %1078, i64 4
store i8 %1103, i8* %1098
%1105 = add nuw nsw i32 %1080, 4
%1106 = icmp eq i32 %1105, %21
br i1 %1106, label %1811, label %1076
1107: ; preds = %269
%1108 = icmp eq i64 %270, 0
br i1 %1108, label %1226, label %1109
1109: ; preds = %1107
br i1 %17, label %1538, label %1110
1110: ; preds = %1109
br i1 %153, label %1191, label %1111
1111: ; preds = %1110
%1112 = icmp ult i8* %274, %279
%1113 = icmp ult i8* %278, %275
%1114 = and i1 %1112, %1113
%1115 = or i1 %1114, %156
br i1 %1115, label %1191, label %1116
1116: ; preds = %1111
%1117 = getelementptr i8, i8* %347, i64 %157
%1118 = getelementptr i8, i8* %346, i64 %157
%1119 = getelementptr i8, i8* %348, i64 %157
br i1 %160, label %1167, label %1120
1120: ; preds = %1116, %1120
%1121 = phi i64 [ %1164, %1120 ], [ 0, %1116 ]
%1122 = phi i64 [ %1165, %1120 ], [ 0, %1116 ]
%1123 = getelementptr i8, i8* %347, i64 %1121
%1124 = getelementptr i8, i8* %346, i64 %1121
%1125 = getelementptr i8, i8* %348, i64 %1121
%1126 = bitcast i8* %1125 to <16 x i8>*
%1127 = load <16 x i8>, <16 x i8>* %1126
%1128 = getelementptr i8, i8* %1125, i64 16
%1129 = bitcast i8* %1128 to <16 x i8>*
%1130 = load <16 x i8>, <16 x i8>* %1129
%1131 = bitcast i8* %1123 to <16 x i8>*
%1132 = load <16 x i8>, <16 x i8>* %1131
%1133 = getelementptr i8, i8* %1123, i64 16
%1134 = bitcast i8* %1133 to <16 x i8>*
%1135 = load <16 x i8>, <16 x i8>* %1134
%1136 = lshr <16 x i8> %1132, <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>
%1137 = lshr <16 x i8> %1135, <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>
%1138 = add <16 x i8> %1136, %1127
%1139 = add <16 x i8> %1137, %1130
%1140 = bitcast i8* %1124 to <16 x i8>*
store <16 x i8> %1138, <16 x i8>* %1140
%1141 = getelementptr i8, i8* %1124, i64 16
%1142 = bitcast i8* %1141 to <16 x i8>*
store <16 x i8> %1139, <16 x i8>* %1142
%1143 = or i64 %1121, 32
%1144 = getelementptr i8, i8* %347, i64 %1143
%1145 = getelementptr i8, i8* %346, i64 %1143
%1146 = getelementptr i8, i8* %348, i64 %1143
%1147 = bitcast i8* %1146 to <16 x i8>*
%1148 = load <16 x i8>, <16 x i8>* %1147
%1149 = getelementptr i8, i8* %1146, i64 16
%1150 = bitcast i8* %1149 to <16 x i8>*
%1151 = load <16 x i8>, <16 x i8>* %1150
%1152 = bitcast i8* %1144 to <16 x i8>*
%1153 = load <16 x i8>, <16 x i8>* %1152
%1154 = getelementptr i8, i8* %1144, i64 16
%1155 = bitcast i8* %1154 to <16 x i8>*
%1156 = load <16 x i8>, <16 x i8>* %1155
%1157 = lshr <16 x i8> %1153, <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>
%1158 = lshr <16 x i8> %1156, <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>
%1159 = add <16 x i8> %1157, %1148
%1160 = add <16 x i8> %1158, %1151
%1161 = bitcast i8* %1145 to <16 x i8>*
store <16 x i8> %1159, <16 x i8>* %1161
%1162 = getelementptr i8, i8* %1145, i64 16
%1163 = bitcast i8* %1162 to <16 x i8>*
store <16 x i8> %1160, <16 x i8>* %1163
%1164 = add nuw i64 %1121, 64
%1165 = add i64 %1122, 2
%1166 = icmp eq i64 %1165, %161
br i1 %1166, label %1167, label %1120
1167: ; preds = %1120, %1116
%1168 = phi i64 [ 0, %1116 ], [ %1164, %1120 ]
br i1 %162, label %1190, label %1169
1169: ; preds = %1167
%1170 = getelementptr i8, i8* %347, i64 %1168
%1171 = getelementptr i8, i8* %346, i64 %1168
%1172 = getelementptr i8, i8* %348, i64 %1168
%1173 = bitcast i8* %1172 to <16 x i8>*
%1174 = load <16 x i8>, <16 x i8>* %1173
%1175 = getelementptr i8, i8* %1172, i64 16
%1176 = bitcast i8* %1175 to <16 x i8>*
%1177 = load <16 x i8>, <16 x i8>* %1176
%1178 = bitcast i8* %1170 to <16 x i8>*
%1179 = load <16 x i8>, <16 x i8>* %1178
%1180 = getelementptr i8, i8* %1170, i64 16
%1181 = bitcast i8* %1180 to <16 x i8>*
%1182 = load <16 x i8>, <16 x i8>* %1181
%1183 = lshr <16 x i8> %1179, <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>
%1184 = lshr <16 x i8> %1182, <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>
%1185 = add <16 x i8> %1183, %1174
%1186 = add <16 x i8> %1184, %1177
%1187 = bitcast i8* %1171 to <16 x i8>*
store <16 x i8> %1185, <16 x i8>* %1187
%1188 = getelementptr i8, i8* %1171, i64 16
%1189 = bitcast i8* %1188 to <16 x i8>*
store <16 x i8> %1186, <16 x i8>* %1189
br label %1190
1190: ; preds = %1167, %1169
br i1 %163, label %1538, label %1191
1191: ; preds = %1111, %1110, %1190
%1192 = phi i8* [ %347, %1111 ], [ %347, %1110 ], [ %1117, %1190 ]
%1193 = phi i8* [ %346, %1111 ], [ %346, %1110 ], [ %1118, %1190 ]
%1194 = phi i8* [ %348, %1111 ], [ %348, %1110 ], [ %1119, %1190 ]
%1195 = phi i32 [ 0, %1111 ], [ 0, %1110 ], [ %158, %1190 ]
%1196 = sub i32 %20, %1195
%1197 = xor i32 %1195, -1
%1198 = add i32 %20, %1197
%1199 = and i32 %1196, 3
%1200 = icmp eq i32 %1199, 0
br i1 %1200, label %1217, label %1201
1201: ; preds = %1191, %1201
%1202 = phi i8* [ %1209, %1201 ], [ %1192, %1191 ]
%1203 = phi i8* [ %1213, %1201 ], [ %1193, %1191 ]
%1204 = phi i8* [ %1207, %1201 ], [ %1194, %1191 ]
%1205 = phi i32 [ %1214, %1201 ], [ %1195, %1191 ]
%1206 = phi i32 [ %1215, %1201 ], [ 0, %1191 ]
%1207 = getelementptr inbounds i8, i8* %1204, i64 1
%1208 = load i8, i8* %1204
%1209 = getelementptr inbounds i8, i8* %1202, i64 1
%1210 = load i8, i8* %1202
%1211 = lshr i8 %1210, 1
%1212 = add i8 %1211, %1208
%1213 = getelementptr inbounds i8, i8* %1203, i64 1
store i8 %1212, i8* %1203
%1214 = add nuw nsw i32 %1205, 1
%1215 = add i32 %1206, 1
%1216 = icmp eq i32 %1215, %1199
br i1 %1216, label %1217, label %1201
1217: ; preds = %1201, %1191
%1218 = phi i8* [ undef, %1191 ], [ %1207, %1201 ]
%1219 = phi i8* [ undef, %1191 ], [ %1209, %1201 ]
%1220 = phi i8* [ undef, %1191 ], [ %1213, %1201 ]
%1221 = phi i8* [ %1192, %1191 ], [ %1209, %1201 ]
%1222 = phi i8* [ %1193, %1191 ], [ %1213, %1201 ]
%1223 = phi i8* [ %1194, %1191 ], [ %1207, %1201 ]
%1224 = phi i32 [ %1195, %1191 ], [ %1214, %1201 ]
%1225 = icmp ult i32 %1198, 3
br i1 %1225, label %1538, label %1663
1226: ; preds = %1107
br i1 %17, label %1330, label %1227
1227: ; preds = %1226
br i1 %176, label %1303, label %1228
1228: ; preds = %1227
%1229 = icmp ult i8* %288, %293
%1230 = icmp ult i8* %292, %289
%1231 = and i1 %1229, %1230
br i1 %1231, label %1303, label %1232
1232: ; preds = %1228
%1233 = getelementptr i8, i8* %346, i64 %177
%1234 = getelementptr i8, i8* %348, i64 %177
br i1 %180, label %1284, label %1235
1235: ; preds = %1232, %1235
%1236 = phi i64 [ %1281, %1235 ], [ 0, %1232 ]
%1237 = phi i64 [ %1282, %1235 ], [ 0, %1232 ]
%1238 = getelementptr i8, i8* %346, i64 %1236
%1239 = getelementptr i8, i8* %348, i64 %1236
%1240 = bitcast i8* %1239 to <16 x i8>*
%1241 = load <16 x i8>, <16 x i8>* %1240
%1242 = getelementptr i8, i8* %1239, i64 16
%1243 = bitcast i8* %1242 to <16 x i8>*
%1244 = load <16 x i8>, <16 x i8>* %1243
%1245 = bitcast i8* %1238 to <16 x i8>*
store <16 x i8> %1241, <16 x i8>* %1245
%1246 = getelementptr i8, i8* %1238, i64 16
%1247 = bitcast i8* %1246 to <16 x i8>*
store <16 x i8> %1244, <16 x i8>* %1247
%1248 = or i64 %1236, 32
%1249 = getelementptr i8, i8* %346, i64 %1248
%1250 = getelementptr i8, i8* %348, i64 %1248
%1251 = bitcast i8* %1250 to <16 x i8>*
%1252 = load <16 x i8>, <16 x i8>* %1251
%1253 = getelementptr i8, i8* %1250, i64 16
%1254 = bitcast i8* %1253 to <16 x i8>*
%1255 = load <16 x i8>, <16 x i8>* %1254
%1256 = bitcast i8* %1249 to <16 x i8>*
store <16 x i8> %1252, <16 x i8>* %1256
%1257 = getelementptr i8, i8* %1249, i64 16
%1258 = bitcast i8* %1257 to <16 x i8>*
store <16 x i8> %1255, <16 x i8>* %1258
%1259 = or i64 %1236, 64
%1260 = getelementptr i8, i8* %346, i64 %1259
%1261 = getelementptr i8, i8* %348, i64 %1259
%1262 = bitcast i8* %1261 to <16 x i8>*
%1263 = load <16 x i8>, <16 x i8>* %1262
%1264 = getelementptr i8, i8* %1261, i64 16
%1265 = bitcast i8* %1264 to <16 x i8>*
%1266 = load <16 x i8>, <16 x i8>* %1265
%1267 = bitcast i8* %1260 to <16 x i8>*
store <16 x i8> %1263, <16 x i8>* %1267
%1268 = getelementptr i8, i8* %1260, i64 16
%1269 = bitcast i8* %1268 to <16 x i8>*
store <16 x i8> %1266, <16 x i8>* %1269
%1270 = or i64 %1236, 96
%1271 = getelementptr i8, i8* %346, i64 %1270
%1272 = getelementptr i8, i8* %348, i64 %1270
%1273 = bitcast i8* %1272 to <16 x i8>*
%1274 = load <16 x i8>, <16 x i8>* %1273
%1275 = getelementptr i8, i8* %1272, i64 16
%1276 = bitcast i8* %1275 to <16 x i8>*
%1277 = load <16 x i8>, <16 x i8>* %1276
%1278 = bitcast i8* %1271 to <16 x i8>*
store <16 x i8> %1274, <16 x i8>* %1278
%1279 = getelementptr i8, i8* %1271, i64 16
%1280 = bitcast i8* %1279 to <16 x i8>*
store <16 x i8> %1277, <16 x i8>* %1280
%1281 = add nuw i64 %1236, 128
%1282 = add i64 %1237, 4
%1283 = icmp eq i64 %1282, %181
br i1 %1283, label %1284, label %1235
1284: ; preds = %1235, %1232
%1285 = phi i64 [ 0, %1232 ], [ %1281, %1235 ]
br i1 %182, label %1302, label %1286
1286: ; preds = %1284, %1286
%1287 = phi i64 [ %1299, %1286 ], [ %1285, %1284 ]
%1288 = phi i64 [ %1300, %1286 ], [ 0, %1284 ]
%1289 = getelementptr i8, i8* %346, i64 %1287
%1290 = getelementptr i8, i8* %348, i64 %1287
%1291 = bitcast i8* %1290 to <16 x i8>*
%1292 = load <16 x i8>, <16 x i8>* %1291
%1293 = getelementptr i8, i8* %1290, i64 16
%1294 = bitcast i8* %1293 to <16 x i8>*
%1295 = load <16 x i8>, <16 x i8>* %1294
%1296 = bitcast i8* %1289 to <16 x i8>*
store <16 x i8> %1292, <16 x i8>* %1296
%1297 = getelementptr i8, i8* %1289, i64 16
%1298 = bitcast i8* %1297 to <16 x i8>*
store <16 x i8> %1295, <16 x i8>* %1298
%1299 = add nuw i64 %1287, 32
%1300 = add i64 %1288, 1
%1301 = icmp eq i64 %1300, %179
br i1 %1301, label %1302, label %1286
1302: ; preds = %1286, %1284
br i1 %183, label %1330, label %1303
1303: ; preds = %1228, %1227, %1302
%1304 = phi i8* [ %346, %1228 ], [ %346, %1227 ], [ %1233, %1302 ]
%1305 = phi i8* [ %348, %1228 ], [ %348, %1227 ], [ %1234, %1302 ]
%1306 = phi i32 [ 0, %1228 ], [ 0, %1227 ], [ %178, %1302 ]
%1307 = sub i32 %20, %1306
%1308 = xor i32 %1306, -1
%1309 = add i32 %20, %1308
%1310 = and i32 %1307, 7
%1311 = icmp eq i32 %1310, 0
br i1 %1311, label %1323, label %1312
1312: ; preds = %1303, %1312
%1313 = phi i8* [ %1319, %1312 ], [ %1304, %1303 ]
%1314 = phi i8* [ %1317, %1312 ], [ %1305, %1303 ]
%1315 = phi i32 [ %1320, %1312 ], [ %1306, %1303 ]
%1316 = phi i32 [ %1321, %1312 ], [ 0, %1303 ]
%1317 = getelementptr inbounds i8, i8* %1314, i64 1
%1318 = load i8, i8* %1314
%1319 = getelementptr inbounds i8, i8* %1313, i64 1
store i8 %1318, i8* %1313
%1320 = add nuw nsw i32 %1315, 1
%1321 = add i32 %1316, 1
%1322 = icmp eq i32 %1321, %1310
br i1 %1322, label %1323, label %1312
1323: ; preds = %1312, %1303
%1324 = phi i8* [ undef, %1303 ], [ %1317, %1312 ]
%1325 = phi i8* [ undef, %1303 ], [ %1319, %1312 ]
%1326 = phi i8* [ %1304, %1303 ], [ %1319, %1312 ]
%1327 = phi i8* [ %1305, %1303 ], [ %1317, %1312 ]
%1328 = phi i32 [ %1306, %1303 ], [ %1320, %1312 ]
%1329 = icmp ult i32 %1309, 7
br i1 %1329, label %1330, label %1473
1330: ; preds = %1323, %1473, %1302, %1226
%1331 = phi i8* [ %348, %1226 ], [ %1234, %1302 ], [ %1324, %1323 ], [ %1498, %1473 ]
%1332 = phi i8* [ %346, %1226 ], [ %1233, %1302 ], [ %1325, %1323 ], [ %1500, %1473 ]
br i1 %18, label %1333, label %1811
1333: ; preds = %1330
br i1 %184, label %1441, label %1334
1334: ; preds = %1333
%1335 = getelementptr i8, i8* %1332, i64 %96
%1336 = getelementptr i8, i8* %1331, i64 %96
%1337 = icmp ult i8* %1332, %1336
%1338 = icmp ult i8* %1331, %1335
%1339 = and i1 %1337, %1338
%1340 = icmp ult i8* %1332, %298
%1341 = icmp ult i8* %297, %1335
%1342 = and i1 %1340, %1341
%1343 = or i1 %1339, %1342
br i1 %1343, label %1441, label %1344
1344: ; preds = %1334
br i1 %185, label %1421, label %1345
1345: ; preds = %1344
br i1 %188, label %1393, label %1346
1346: ; preds = %1345, %1346
%1347 = phi i64 [ %1390, %1346 ], [ 0, %1345 ]
%1348 = phi i64 [ %1391, %1346 ], [ 0, %1345 ]
%1349 = getelementptr i8, i8* %346, i64 %1347
%1350 = getelementptr i8, i8* %1332, i64 %1347
%1351 = getelementptr i8, i8* %1331, i64 %1347
%1352 = bitcast i8* %1351 to <16 x i8>*
%1353 = load <16 x i8>, <16 x i8>* %1352
%1354 = getelementptr i8, i8* %1351, i64 16
%1355 = bitcast i8* %1354 to <16 x i8>*
%1356 = load <16 x i8>, <16 x i8>* %1355
%1357 = bitcast i8* %1349 to <16 x i8>*
%1358 = load <16 x i8>, <16 x i8>* %1357
%1359 = getelementptr i8, i8* %1349, i64 16
%1360 = bitcast i8* %1359 to <16 x i8>*
%1361 = load <16 x i8>, <16 x i8>* %1360
%1362 = lshr <16 x i8> %1358, <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>
%1363 = lshr <16 x i8> %1361, <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>
%1364 = add <16 x i8> %1362, %1353
%1365 = add <16 x i8> %1363, %1356
%1366 = bitcast i8* %1350 to <16 x i8>*
store <16 x i8> %1364, <16 x i8>* %1366
%1367 = getelementptr i8, i8* %1350, i64 16
%1368 = bitcast i8* %1367 to <16 x i8>*
store <16 x i8> %1365, <16 x i8>* %1368
%1369 = or i64 %1347, 32
%1370 = getelementptr i8, i8* %346, i64 %1369
%1371 = getelementptr i8, i8* %1332, i64 %1369
%1372 = getelementptr i8, i8* %1331, i64 %1369
%1373 = bitcast i8* %1372 to <16 x i8>*
%1374 = load <16 x i8>, <16 x i8>* %1373
%1375 = getelementptr i8, i8* %1372, i64 16
%1376 = bitcast i8* %1375 to <16 x i8>*
%1377 = load <16 x i8>, <16 x i8>* %1376
%1378 = bitcast i8* %1370 to <16 x i8>*
%1379 = load <16 x i8>, <16 x i8>* %1378
%1380 = getelementptr i8, i8* %1370, i64 16
%1381 = bitcast i8* %1380 to <16 x i8>*
%1382 = load <16 x i8>, <16 x i8>* %1381
%1383 = lshr <16 x i8> %1379, <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>
%1384 = lshr <16 x i8> %1382, <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>
%1385 = add <16 x i8> %1383, %1374
%1386 = add <16 x i8> %1384, %1377
%1387 = bitcast i8* %1371 to <16 x i8>*
store <16 x i8> %1385, <16 x i8>* %1387
%1388 = getelementptr i8, i8* %1371, i64 16
%1389 = bitcast i8* %1388 to <16 x i8>*
store <16 x i8> %1386, <16 x i8>* %1389
%1390 = add nuw i64 %1347, 64
%1391 = add i64 %1348, 2
%1392 = icmp eq i64 %1391, %189
br i1 %1392, label %1393, label %1346
1393: ; preds = %1346, %1345
%1394 = phi i64 [ 0, %1345 ], [ %1390, %1346 ]
br i1 %190, label %1416, label %1395
1395: ; preds = %1393
%1396 = getelementptr i8, i8* %346, i64 %1394
%1397 = getelementptr i8, i8* %1332, i64 %1394
%1398 = getelementptr i8, i8* %1331, i64 %1394
%1399 = bitcast i8* %1398 to <16 x i8>*
%1400 = load <16 x i8>, <16 x i8>* %1399
%1401 = getelementptr i8, i8* %1398, i64 16
%1402 = bitcast i8* %1401 to <16 x i8>*
%1403 = load <16 x i8>, <16 x i8>* %1402
%1404 = bitcast i8* %1396 to <16 x i8>*
%1405 = load <16 x i8>, <16 x i8>* %1404
%1406 = getelementptr i8, i8* %1396, i64 16
%1407 = bitcast i8* %1406 to <16 x i8>*
%1408 = load <16 x i8>, <16 x i8>* %1407
%1409 = lshr <16 x i8> %1405, <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>
%1410 = lshr <16 x i8> %1408, <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>
%1411 = add <16 x i8> %1409, %1400
%1412 = add <16 x i8> %1410, %1403
%1413 = bitcast i8* %1397 to <16 x i8>*
store <16 x i8> %1411, <16 x i8>* %1413
%1414 = getelementptr i8, i8* %1397, i64 16
%1415 = bitcast i8* %1414 to <16 x i8>*
store <16 x i8> %1412, <16 x i8>* %1415
br label %1416
1416: ; preds = %1393, %1395
br i1 %191, label %1811, label %1417
1417: ; preds = %1416
%1418 = getelementptr i8, i8* %1331, i64 %186
%1419 = getelementptr i8, i8* %1332, i64 %186
%1420 = getelementptr i8, i8* %346, i64 %186
br i1 %195, label %1441, label %1421
1421: ; preds = %1344, %1417
%1422 = phi i64 [ %186, %1417 ], [ 0, %1344 ]
%1423 = getelementptr i8, i8* %346, i64 %196
%1424 = getelementptr i8, i8* %1332, i64 %196
%1425 = getelementptr i8, i8* %1331, i64 %196
br label %1426
1426: ; preds = %1426, %1421
%1427 = phi i64 [ %1422, %1421 ], [ %1438, %1426 ]
%1428 = getelementptr i8, i8* %346, i64 %1427
%1429 = getelementptr i8, i8* %1332, i64 %1427
%1430 = getelementptr i8, i8* %1331, i64 %1427
%1431 = bitcast i8* %1430 to <8 x i8>*
%1432 = load <8 x i8>, <8 x i8>* %1431
%1433 = bitcast i8* %1428 to <8 x i8>*
%1434 = load <8 x i8>, <8 x i8>* %1433
%1435 = lshr <8 x i8> %1434, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%1436 = add <8 x i8> %1435, %1432
%1437 = bitcast i8* %1429 to <8 x i8>*
store <8 x i8> %1436, <8 x i8>* %1437
%1438 = add nuw i64 %1427, 8
%1439 = icmp eq i64 %1438, %196
br i1 %1439, label %1440, label %1426
1440: ; preds = %1426
br i1 %199, label %1811, label %1441
1441: ; preds = %1334, %1333, %1417, %1440
%1442 = phi i8* [ %346, %1333 ], [ %346, %1334 ], [ %1420, %1417 ], [ %1423, %1440 ]
%1443 = phi i8* [ %1332, %1333 ], [ %1332, %1334 ], [ %1419, %1417 ], [ %1424, %1440 ]
%1444 = phi i8* [ %1331, %1333 ], [ %1331, %1334 ], [ %1418, %1417 ], [ %1425, %1440 ]
%1445 = phi i32 [ %11, %1333 ], [ %11, %1334 ], [ %193, %1417 ], [ %198, %1440 ]
%1446 = sub i32 %9, %1445
%1447 = xor i32 %1445, -1
%1448 = add i32 %9, %1447
%1449 = and i32 %1446, 3
%1450 = icmp eq i32 %1449, 0
br i1 %1450, label %1467, label %1451
1451: ; preds = %1441, %1451
%1452 = phi i8* [ %1459, %1451 ], [ %1442, %1441 ]
%1453 = phi i8* [ %1463, %1451 ], [ %1443, %1441 ]
%1454 = phi i8* [ %1457, %1451 ], [ %1444, %1441 ]
%1455 = phi i32 [ %1464, %1451 ], [ %1445, %1441 ]
%1456 = phi i32 [ %1465, %1451 ], [ 0, %1441 ]
%1457 = getelementptr inbounds i8, i8* %1454, i64 1
%1458 = load i8, i8* %1454
%1459 = getelementptr inbounds i8, i8* %1452, i64 1
%1460 = load i8, i8* %1452
%1461 = lshr i8 %1460, 1
%1462 = add i8 %1461, %1458
%1463 = getelementptr inbounds i8, i8* %1453, i64 1
store i8 %1462, i8* %1453
%1464 = add nuw nsw i32 %1455, 1
%1465 = add i32 %1456, 1
%1466 = icmp eq i32 %1465, %1449
br i1 %1466, label %1467, label %1451
1467: ; preds = %1451, %1441
%1468 = phi i8* [ %1442, %1441 ], [ %1459, %1451 ]
%1469 = phi i8* [ %1443, %1441 ], [ %1463, %1451 ]
%1470 = phi i8* [ %1444, %1441 ], [ %1457, %1451 ]
%1471 = phi i32 [ %1445, %1441 ], [ %1464, %1451 ]
%1472 = icmp ult i32 %1448, 3
br i1 %1472, label %1811, label %1503
1473: ; preds = %1323, %1473
%1474 = phi i8* [ %1500, %1473 ], [ %1326, %1323 ]
%1475 = phi i8* [ %1498, %1473 ], [ %1327, %1323 ]
%1476 = phi i32 [ %1501, %1473 ], [ %1328, %1323 ]
%1477 = getelementptr inbounds i8, i8* %1475, i64 1
%1478 = load i8, i8* %1475
%1479 = getelementptr inbounds i8, i8* %1474, i64 1
store i8 %1478, i8* %1474
%1480 = getelementptr inbounds i8, i8* %1475, i64 2
%1481 = load i8, i8* %1477
%1482 = getelementptr inbounds i8, i8* %1474, i64 2
store i8 %1481, i8* %1479
%1483 = getelementptr inbounds i8, i8* %1475, i64 3
%1484 = load i8, i8* %1480
%1485 = getelementptr inbounds i8, i8* %1474, i64 3
store i8 %1484, i8* %1482
%1486 = getelementptr inbounds i8, i8* %1475, i64 4
%1487 = load i8, i8* %1483
%1488 = getelementptr inbounds i8, i8* %1474, i64 4
store i8 %1487, i8* %1485
%1489 = getelementptr inbounds i8, i8* %1475, i64 5
%1490 = load i8, i8* %1486
%1491 = getelementptr inbounds i8, i8* %1474, i64 5
store i8 %1490, i8* %1488
%1492 = getelementptr inbounds i8, i8* %1475, i64 6
%1493 = load i8, i8* %1489
%1494 = getelementptr inbounds i8, i8* %1474, i64 6
store i8 %1493, i8* %1491
%1495 = getelementptr inbounds i8, i8* %1475, i64 7
%1496 = load i8, i8* %1492
%1497 = getelementptr inbounds i8, i8* %1474, i64 7
store i8 %1496, i8* %1494
%1498 = getelementptr inbounds i8, i8* %1475, i64 8
%1499 = load i8, i8* %1495
%1500 = getelementptr inbounds i8, i8* %1474, i64 8
store i8 %1499, i8* %1497
%1501 = add nuw nsw i32 %1476, 8
%1502 = icmp eq i32 %1501, %20
br i1 %1502, label %1330, label %1473
1503: ; preds = %1467, %1503
%1504 = phi i8* [ %1531, %1503 ], [ %1468, %1467 ]
%1505 = phi i8* [ %1535, %1503 ], [ %1469, %1467 ]
%1506 = phi i8* [ %1529, %1503 ], [ %1470, %1467 ]
%1507 = phi i32 [ %1536, %1503 ], [ %1471, %1467 ]
%1508 = getelementptr inbounds i8, i8* %1506, i64 1
%1509 = load i8, i8* %1506
%1510 = getelementptr inbounds i8, i8* %1504, i64 1
%1511 = load i8, i8* %1504
%1512 = lshr i8 %1511, 1
%1513 = add i8 %1512, %1509
%1514 = getelementptr inbounds i8, i8* %1505, i64 1
store i8 %1513, i8* %1505
%1515 = getelementptr inbounds i8, i8* %1506, i64 2
%1516 = load i8, i8* %1508
%1517 = getelementptr inbounds i8, i8* %1504, i64 2
%1518 = load i8, i8* %1510
%1519 = lshr i8 %1518, 1
%1520 = add i8 %1519, %1516
%1521 = getelementptr inbounds i8, i8* %1505, i64 2
store i8 %1520, i8* %1514
%1522 = getelementptr inbounds i8, i8* %1506, i64 3
%1523 = load i8, i8* %1515
%1524 = getelementptr inbounds i8, i8* %1504, i64 3
%1525 = load i8, i8* %1517
%1526 = lshr i8 %1525, 1
%1527 = add i8 %1526, %1523
%1528 = getelementptr inbounds i8, i8* %1505, i64 3
store i8 %1527, i8* %1521
%1529 = getelementptr inbounds i8, i8* %1506, i64 4
%1530 = load i8, i8* %1522
%1531 = getelementptr inbounds i8, i8* %1504, i64 4
%1532 = load i8, i8* %1524
%1533 = lshr i8 %1532, 1
%1534 = add i8 %1533, %1530
%1535 = getelementptr inbounds i8, i8* %1505, i64 4
store i8 %1534, i8* %1528
%1536 = add nuw nsw i32 %1507, 4
%1537 = icmp eq i32 %1536, %9
br i1 %1537, label %1811, label %1503
1538: ; preds = %1217, %1663, %1190, %1109
%1539 = phi i8* [ %348, %1109 ], [ %1119, %1190 ], [ %1218, %1217 ], [ %1689, %1663 ]
%1540 = phi i8* [ %346, %1109 ], [ %1118, %1190 ], [ %1220, %1217 ], [ %1695, %1663 ]
%1541 = phi i8* [ %347, %1109 ], [ %1117, %1190 ], [ %1219, %1217 ], [ %1691, %1663 ]
br i1 %18, label %1542, label %1811
1542: ; preds = %1538
br i1 %164, label %1631, label %1543
1543: ; preds = %1542
%1544 = getelementptr i8, i8* %1540, i64 %118
%1545 = getelementptr i8, i8* %1539, i64 %118
%1546 = getelementptr i8, i8* %1541, i64 %118
%1547 = icmp ult i8* %1540, %1545
%1548 = icmp ult i8* %1539, %1544
%1549 = and i1 %1547, %1548
%1550 = icmp ult i8* %1540, %1546
%1551 = icmp ult i8* %1541, %1544
%1552 = and i1 %1550, %1551
%1553 = or i1 %1549, %1552
%1554 = icmp ult i8* %1540, %284
%1555 = icmp ult i8* %283, %1544
%1556 = and i1 %1554, %1555
%1557 = or i1 %1553, %1556
br i1 %1557, label %1631, label %1558
1558: ; preds = %1543
br i1 %165, label %1603, label %1559
1559: ; preds = %1558, %1559
%1560 = phi i64 [ %1595, %1559 ], [ 0, %1558 ]
%1561 = getelementptr i8, i8* %1541, i64 %1560
%1562 = getelementptr i8, i8* %346, i64 %1560
%1563 = getelementptr i8, i8* %1540, i64 %1560
%1564 = getelementptr i8, i8* %1539, i64 %1560
%1565 = bitcast i8* %1564 to <16 x i8>*
%1566 = load <16 x i8>, <16 x i8>* %1565
%1567 = getelementptr i8, i8* %1564, i64 16
%1568 = bitcast i8* %1567 to <16 x i8>*
%1569 = load <16 x i8>, <16 x i8>* %1568
%1570 = bitcast i8* %1561 to <16 x i8>*
%1571 = load <16 x i8>, <16 x i8>* %1570
%1572 = getelementptr i8, i8* %1561, i64 16
%1573 = bitcast i8* %1572 to <16 x i8>*
%1574 = load <16 x i8>, <16 x i8>* %1573
%1575 = zext <16 x i8> %1571 to <16 x i16>
%1576 = zext <16 x i8> %1574 to <16 x i16>
%1577 = bitcast i8* %1562 to <16 x i8>*
%1578 = load <16 x i8>, <16 x i8>* %1577
%1579 = getelementptr i8, i8* %1562, i64 16
%1580 = bitcast i8* %1579 to <16 x i8>*
%1581 = load <16 x i8>, <16 x i8>* %1580
%1582 = zext <16 x i8> %1578 to <16 x i16>
%1583 = zext <16 x i8> %1581 to <16 x i16>
%1584 = add nuw nsw <16 x i16> %1582, %1575
%1585 = add nuw nsw <16 x i16> %1583, %1576
%1586 = lshr <16 x i16> %1584, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%1587 = lshr <16 x i16> %1585, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%1588 = trunc <16 x i16> %1586 to <16 x i8>
%1589 = trunc <16 x i16> %1587 to <16 x i8>
%1590 = add <16 x i8> %1566, %1588
%1591 = add <16 x i8> %1569, %1589
%1592 = bitcast i8* %1563 to <16 x i8>*
store <16 x i8> %1590, <16 x i8>* %1592
%1593 = getelementptr i8, i8* %1563, i64 16
%1594 = bitcast i8* %1593 to <16 x i8>*
store <16 x i8> %1591, <16 x i8>* %1594
%1595 = add nuw i64 %1560, 32
%1596 = icmp eq i64 %1595, %166
br i1 %1596, label %1597, label %1559
1597: ; preds = %1559
br i1 %167, label %1811, label %1598
1598: ; preds = %1597
%1599 = getelementptr i8, i8* %1539, i64 %166
%1600 = getelementptr i8, i8* %1540, i64 %166
%1601 = getelementptr i8, i8* %346, i64 %166
%1602 = getelementptr i8, i8* %1541, i64 %166
br i1 %171, label %1631, label %1603
1603: ; preds = %1558, %1598
%1604 = phi i64 [ %166, %1598 ], [ 0, %1558 ]
%1605 = getelementptr i8, i8* %1541, i64 %172
%1606 = getelementptr i8, i8* %346, i64 %172
%1607 = getelementptr i8, i8* %1540, i64 %172
%1608 = getelementptr i8, i8* %1539, i64 %172
br label %1609
1609: ; preds = %1609, %1603
%1610 = phi i64 [ %1604, %1603 ], [ %1628, %1609 ]
%1611 = getelementptr i8, i8* %1541, i64 %1610
%1612 = getelementptr i8, i8* %346, i64 %1610
%1613 = getelementptr i8, i8* %1540, i64 %1610
%1614 = getelementptr i8, i8* %1539, i64 %1610
%1615 = bitcast i8* %1614 to <8 x i8>*
%1616 = load <8 x i8>, <8 x i8>* %1615
%1617 = bitcast i8* %1611 to <8 x i8>*
%1618 = load <8 x i8>, <8 x i8>* %1617
%1619 = zext <8 x i8> %1618 to <8 x i16>
%1620 = bitcast i8* %1612 to <8 x i8>*
%1621 = load <8 x i8>, <8 x i8>* %1620
%1622 = zext <8 x i8> %1621 to <8 x i16>
%1623 = add nuw nsw <8 x i16> %1622, %1619
%1624 = lshr <8 x i16> %1623, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%1625 = trunc <8 x i16> %1624 to <8 x i8>
%1626 = add <8 x i8> %1616, %1625
%1627 = bitcast i8* %1613 to <8 x i8>*
store <8 x i8> %1626, <8 x i8>* %1627
%1628 = add nuw i64 %1610, 8
%1629 = icmp eq i64 %1628, %172
br i1 %1629, label %1630, label %1609
1630: ; preds = %1609
br i1 %175, label %1811, label %1631
1631: ; preds = %1543, %1542, %1598, %1630
%1632 = phi i8* [ %1541, %1542 ], [ %1541, %1543 ], [ %1602, %1598 ], [ %1605, %1630 ]
%1633 = phi i8* [ %346, %1542 ], [ %346, %1543 ], [ %1601, %1598 ], [ %1606, %1630 ]
%1634 = phi i8* [ %1540, %1542 ], [ %1540, %1543 ], [ %1600, %1598 ], [ %1607, %1630 ]
%1635 = phi i8* [ %1539, %1542 ], [ %1539, %1543 ], [ %1599, %1598 ], [ %1608, %1630 ]
%1636 = phi i32 [ %11, %1542 ], [ %11, %1543 ], [ %169, %1598 ], [ %174, %1630 ]
%1637 = sub i32 %9, %1636
%1638 = add i32 %1636, 1
%1639 = and i32 %1637, 1
%1640 = icmp eq i32 %1639, 0
br i1 %1640, label %1656, label %1641
1641: ; preds = %1631
%1642 = getelementptr inbounds i8, i8* %1635, i64 1
%1643 = load i8, i8* %1635
%1644 = getelementptr inbounds i8, i8* %1632, i64 1
%1645 = load i8, i8* %1632
%1646 = zext i8 %1645 to i16
%1647 = getelementptr inbounds i8, i8* %1633, i64 1
%1648 = load i8, i8* %1633
%1649 = zext i8 %1648 to i16
%1650 = add nuw nsw i16 %1649, %1646
%1651 = lshr i16 %1650, 1
%1652 = trunc i16 %1651 to i8
%1653 = add i8 %1643, %1652
%1654 = getelementptr inbounds i8, i8* %1634, i64 1
store i8 %1653, i8* %1634
%1655 = add nuw nsw i32 %1636, 1
br label %1656
1656: ; preds = %1641, %1631
%1657 = phi i8* [ %1632, %1631 ], [ %1644, %1641 ]
%1658 = phi i8* [ %1633, %1631 ], [ %1647, %1641 ]
%1659 = phi i8* [ %1634, %1631 ], [ %1654, %1641 ]
%1660 = phi i8* [ %1635, %1631 ], [ %1642, %1641 ]
%1661 = phi i32 [ %1636, %1631 ], [ %1655, %1641 ]
%1662 = icmp eq i32 %9, %1638
br i1 %1662, label %1811, label %1698
1663: ; preds = %1217, %1663
%1664 = phi i8* [ %1691, %1663 ], [ %1221, %1217 ]
%1665 = phi i8* [ %1695, %1663 ], [ %1222, %1217 ]
%1666 = phi i8* [ %1689, %1663 ], [ %1223, %1217 ]
%1667 = phi i32 [ %1696, %1663 ], [ %1224, %1217 ]
%1668 = getelementptr inbounds i8, i8* %1666, i64 1
%1669 = load i8, i8* %1666
%1670 = getelementptr inbounds i8, i8* %1664, i64 1
%1671 = load i8, i8* %1664
%1672 = lshr i8 %1671, 1
%1673 = add i8 %1672, %1669
%1674 = getelementptr inbounds i8, i8* %1665, i64 1
store i8 %1673, i8* %1665
%1675 = getelementptr inbounds i8, i8* %1666, i64 2
%1676 = load i8, i8* %1668
%1677 = getelementptr inbounds i8, i8* %1664, i64 2
%1678 = load i8, i8* %1670
%1679 = lshr i8 %1678, 1
%1680 = add i8 %1679, %1676
%1681 = getelementptr inbounds i8, i8* %1665, i64 2
store i8 %1680, i8* %1674
%1682 = getelementptr inbounds i8, i8* %1666, i64 3
%1683 = load i8, i8* %1675
%1684 = getelementptr inbounds i8, i8* %1664, i64 3
%1685 = load i8, i8* %1677
%1686 = lshr i8 %1685, 1
%1687 = add i8 %1686, %1683
%1688 = getelementptr inbounds i8, i8* %1665, i64 3
store i8 %1687, i8* %1681
%1689 = getelementptr inbounds i8, i8* %1666, i64 4
%1690 = load i8, i8* %1682
%1691 = getelementptr inbounds i8, i8* %1664, i64 4
%1692 = load i8, i8* %1684
%1693 = lshr i8 %1692, 1
%1694 = add i8 %1693, %1690
%1695 = getelementptr inbounds i8, i8* %1665, i64 4
store i8 %1694, i8* %1688
%1696 = add nuw nsw i32 %1667, 4
%1697 = icmp eq i32 %1696, %20
br i1 %1697, label %1538, label %1663
1698: ; preds = %1656, %1698
%1699 = phi i8* [ %1719, %1698 ], [ %1657, %1656 ]
%1700 = phi i8* [ %1722, %1698 ], [ %1658, %1656 ]
%1701 = phi i8* [ %1729, %1698 ], [ %1659, %1656 ]
%1702 = phi i8* [ %1717, %1698 ], [ %1660, %1656 ]
%1703 = phi i32 [ %1730, %1698 ], [ %1661, %1656 ]
%1704 = getelementptr inbounds i8, i8* %1702, i64 1
%1705 = load i8, i8* %1702
%1706 = getelementptr inbounds i8, i8* %1699, i64 1
%1707 = load i8, i8* %1699
%1708 = zext i8 %1707 to i16
%1709 = getelementptr inbounds i8, i8* %1700, i64 1
%1710 = load i8, i8* %1700
%1711 = zext i8 %1710 to i16
%1712 = add nuw nsw i16 %1711, %1708
%1713 = lshr i16 %1712, 1
%1714 = trunc i16 %1713 to i8
%1715 = add i8 %1705, %1714
%1716 = getelementptr inbounds i8, i8* %1701, i64 1
store i8 %1715, i8* %1701
%1717 = getelementptr inbounds i8, i8* %1702, i64 2
%1718 = load i8, i8* %1704
%1719 = getelementptr inbounds i8, i8* %1699, i64 2
%1720 = load i8, i8* %1706
%1721 = zext i8 %1720 to i16
%1722 = getelementptr inbounds i8, i8* %1700, i64 2
%1723 = load i8, i8* %1709
%1724 = zext i8 %1723 to i16
%1725 = add nuw nsw i16 %1724, %1721
%1726 = lshr i16 %1725, 1
%1727 = trunc i16 %1726 to i8
%1728 = add i8 %1718, %1727
%1729 = getelementptr inbounds i8, i8* %1701, i64 2
store i8 %1728, i8* %1716
%1730 = add nuw nsw i32 %1703, 2
%1731 = icmp eq i32 %1730, %9
br i1 %1731, label %1811, label %1698
1732: ; preds = %269
%1733 = icmp eq i64 %270, 0
br i1 %1733, label %1735, label %1734
1734: ; preds = %1732
br i1 %17, label %1767, label %1771
1735: ; preds = %1732
br i1 %17, label %1736, label %1739
1736: ; preds = %1739, %1735
%1737 = phi i8* [ %348, %1735 ], [ %1743, %1739 ]
%1738 = phi i8* [ %346, %1735 ], [ %1748, %1739 ]
br i1 %18, label %1751, label %1811
1739: ; preds = %1735, %1739
%1740 = phi i8* [ %1748, %1739 ], [ %346, %1735 ]
%1741 = phi i8* [ %1743, %1739 ], [ %348, %1735 ]
%1742 = phi i32 [ %1749, %1739 ], [ 0, %1735 ]
%1743 = getelementptr inbounds i8, i8* %1741, i64 1
%1744 = load i8, i8* %1741
%1745 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 0, i32 0, i32 0)
%1746 = trunc i32 %1745 to i8
%1747 = add i8 %1744, %1746
%1748 = getelementptr inbounds i8, i8* %1740, i64 1
store i8 %1747, i8* %1740
%1749 = add nuw nsw i32 %1742, 1
%1750 = icmp eq i32 %1749, %20
br i1 %1750, label %1736, label %1739
1751: ; preds = %1736, %1751
%1752 = phi i8* [ %1758, %1751 ], [ %346, %1736 ]
%1753 = phi i8* [ %1764, %1751 ], [ %1738, %1736 ]
%1754 = phi i8* [ %1756, %1751 ], [ %1737, %1736 ]
%1755 = phi i32 [ %1765, %1751 ], [ %11, %1736 ]
%1756 = getelementptr inbounds i8, i8* %1754, i64 1
%1757 = load i8, i8* %1754
%1758 = getelementptr inbounds i8, i8* %1752, i64 1
%1759 = load i8, i8* %1752
%1760 = zext i8 %1759 to i32
%1761 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 %1760, i32 0, i32 0)
%1762 = trunc i32 %1761 to i8
%1763 = add i8 %1757, %1762
%1764 = getelementptr inbounds i8, i8* %1753, i64 1
store i8 %1763, i8* %1753
%1765 = add nuw nsw i32 %1755, 1
%1766 = icmp eq i32 %1765, %9
br i1 %1766, label %1811, label %1751
1767: ; preds = %1771, %1734
%1768 = phi i8* [ %348, %1734 ], [ %1776, %1771 ]
%1769 = phi i8* [ %346, %1734 ], [ %1784, %1771 ]
%1770 = phi i8* [ %347, %1734 ], [ %1778, %1771 ]
br i1 %18, label %1787, label %1811
1771: ; preds = %1734, %1771
%1772 = phi i8* [ %1778, %1771 ], [ %347, %1734 ]
%1773 = phi i8* [ %1784, %1771 ], [ %346, %1734 ]
%1774 = phi i8* [ %1776, %1771 ], [ %348, %1734 ]
%1775 = phi i32 [ %1785, %1771 ], [ 0, %1734 ]
%1776 = getelementptr inbounds i8, i8* %1774, i64 1
%1777 = load i8, i8* %1774
%1778 = getelementptr inbounds i8, i8* %1772, i64 1
%1779 = load i8, i8* %1772
%1780 = zext i8 %1779 to i32
%1781 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 0, i32 %1780, i32 0)
%1782 = trunc i32 %1781 to i8
%1783 = add i8 %1777, %1782
%1784 = getelementptr inbounds i8, i8* %1773, i64 1
store i8 %1783, i8* %1773
%1785 = add nuw nsw i32 %1775, 1
%1786 = icmp eq i32 %1785, %20
br i1 %1786, label %1767, label %1771
1787: ; preds = %1767, %1787
%1788 = phi i8* [ %1802, %1787 ], [ %347, %1767 ]
%1789 = phi i8* [ %1799, %1787 ], [ %1770, %1767 ]
%1790 = phi i8* [ %1796, %1787 ], [ %346, %1767 ]
%1791 = phi i8* [ %1808, %1787 ], [ %1769, %1767 ]
%1792 = phi i8* [ %1794, %1787 ], [ %1768, %1767 ]
%1793 = phi i32 [ %1809, %1787 ], [ %11, %1767 ]
%1794 = getelementptr inbounds i8, i8* %1792, i64 1
%1795 = load i8, i8* %1792
%1796 = getelementptr inbounds i8, i8* %1790, i64 1
%1797 = load i8, i8* %1790
%1798 = zext i8 %1797 to i32
%1799 = getelementptr inbounds i8, i8* %1789, i64 1
%1800 = load i8, i8* %1789
%1801 = zext i8 %1800 to i32
%1802 = getelementptr inbounds i8, i8* %1788, i64 1
%1803 = load i8, i8* %1788
%1804 = zext i8 %1803 to i32
%1805 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 %1798, i32 %1801, i32 %1804)
%1806 = trunc i32 %1805 to i8
%1807 = add i8 %1795, %1806
%1808 = getelementptr inbounds i8, i8* %1791, i64 1
store i8 %1807, i8* %1791
%1809 = add nuw nsw i32 %1793, 1
%1810 = icmp eq i32 %1809, %9
br i1 %1810, label %1811, label %1787
1811: ; preds = %1656, %1698, %1467, %1503, %922, %1076, %1041, %1046, %731, %767, %1787, %1751, %567, %572, %1597, %1630, %1416, %1440, %873, %896, %1003, %1020, %682, %705, %529, %546, %1538, %1330, %800, %928, %602, %1767, %1736, %454
%1812 = add nuw nsw i64 %270, 1
%1813 = icmp eq i64 %1812, %22
br i1 %1813, label %1814, label %269
1814: ; preds = %1811, %5
ret void
}