void png_predict(unsigned char *samples, int width, int height, int n,
                 int depth) {
  int stride = (width * n * depth + 7) / 8;
  int bpp = (n * depth + 7) / 8;
  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
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1706 <png_predict+0x5f6>
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
movslq -0x1c(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
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     11ef <png_predict+0xdf>
mov    -0x58(%rbp),%rax
lea    0xe1a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    11f4 <png_predict+0xe4>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1237 <png_predict+0x127>
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    11fb <png_predict+0xeb>
jmp    16f3 <png_predict+0x5e3>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    127f <png_predict+0x16f>
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    1243 <png_predict+0x133>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12d8 <png_predict+0x1c8>
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    1285 <png_predict+0x175>
jmp    16f3 <png_predict+0x5e3>
cmpl   $0x0,-0x28(%rbp)
jne    132f <png_predict+0x21f>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    132a <png_predict+0x21a>
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    12ee <png_predict+0x1de>
jmp    138e <png_predict+0x27e>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1389 <png_predict+0x279>
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    1336 <png_predict+0x226>
jmp    138e <png_predict+0x27e>
jmp    16f3 <png_predict+0x5e3>
cmpl   $0x0,-0x28(%rbp)
jne    1441 <png_predict+0x331>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13e0 <png_predict+0x2d0>
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    13a4 <png_predict+0x294>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    143c <png_predict+0x32c>
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    13e6 <png_predict+0x2d6>
jmp    1513 <png_predict+0x403>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    149e <png_predict+0x38e>
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    1448 <png_predict+0x338>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    150e <png_predict+0x3fe>
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    14a4 <png_predict+0x394>
jmp    1513 <png_predict+0x403>
jmp    16f3 <png_predict+0x5e3>
cmpl   $0x0,-0x28(%rbp)
jne    15f0 <png_predict+0x4e0>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    157f <png_predict+0x46f>
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    1529 <png_predict+0x419>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15eb <png_predict+0x4db>
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    1585 <png_predict+0x475>
jmp    16ee <png_predict+0x5de>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    165d <png_predict+0x54d>
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    15f7 <png_predict+0x4e7>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16e9 <png_predict+0x5d9>
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    1663 <png_predict+0x553>
jmp    16ee <png_predict+0x5de>
jmp    16f3 <png_predict+0x5e3>
jmp    16f8 <png_predict+0x5e8>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115e <png_predict+0x4e>
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,0x100(%rsp)
imul   %r8d,%ecx
imul   %ecx,%esi
lea    0x7(%rsi),%eax
mov    %rsi,0xf8(%rsp)
add    $0xe,%esi
test   %eax,%eax
cmovns %eax,%esi
lea    0x7(%rcx),%eax
mov    %rcx,0xa0(%rsp)
lea    0xe(%rcx),%edi
test   %eax,%eax
cmovns %eax,%edi
test   %edx,%edx
jle    2cda <png_predict+0x1bca>
sar    $0x3,%esi
mov    %rsi,0x8(%rsp)
mov    %rdi,%r15
sar    $0x3,%r15d
movslq %esi,%r13
mov    %r13,%rax
neg    %rax
mov    %rax,0x160(%rsp)
cmp    $0x2,%r15d
mov    $0x1,%eax
cmovge %r15d,%eax
mov    $0x1,%ecx
cmp    $0x2,%r13d
cmovge %esi,%ecx
mov    %rcx,0x80(%rsp)
add    $0xffffffff,%ecx
mov    %rcx,0x50(%rsp)
lea    0x1(%rcx),%r9
mov    %r15d,%r12d
not    %r12d
add    %esi,%r12d
mov    %rax,0x58(%rsp)
add    $0xffffffff,%eax
lea    0x1(%rax),%rbx
mov    %rax,%r11
mov    %rax,0xb8(%rsp)
mov    %r9,0x38(%rsp)
mov    %r9,%r8
sub    %r13,%r8
mov    0x100(%rsp),%rsi
add    %rsi,%r8
mov    %rbx,%rcx
sub    %r13,%rcx
add    %rsi,%rcx
mov    %rbx,0xe0(%rsp)
and    $0xffffffffffffffe0,%rbx
mov    %rbx,0xd8(%rsp)
add    $0xffffffffffffffe0,%rbx
mov    %rbx,0xd0(%rsp)
shr    $0x5,%rbx
add    $0x1,%rbx
lea    0x1(%r12),%r14
mov    %r14,%rdi
and    $0xffffffffffffffe0,%rdi
mov    %rdi,0x20(%rsp)
lea    -0x20(%rdi),%rbp
mov    %rbp,0x128(%rsp)
shr    $0x5,%rbp
add    $0x1,%rbp
and    $0xffffffffffffffe0,%r9
mov    %r9,0x48(%rsp)
add    $0xffffffffffffffe0,%r9
mov    %r9,0xc0(%rsp)
shr    $0x5,%r9
add    $0x1,%r9
cmp    %rsi,%rcx
seta   %cl
mov    %rsi,%r10
sub    %r13,%r10
add    %rsi,%rax
add    $0x1,%rax
mov    %rax,0x1c0(%rsp)
cmp    %rax,%r10
setb   %al
and    %cl,%al
mov    %al,0x1f(%rsp)
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x188(%rsp)
movabs $0x1ffffffe0,%rax
or     $0x18,%rax
mov    %r14,%rcx
mov    %r14,0x28(%rsp)
mov    %r14,%r11
and    %rax,%r11
mov    %ebx,%edi
and    $0x3,%edi
mov    %edx,%r14d
movabs $0xffffffffffffffe,%rdx
ff ff 0f
add    $0xfffffffffffffffe,%rdx
mov    %rbx,%rcx
mov    %rbx,0x150(%rsp)
and    %rdx,%rbx
mov    %rbx,0x138(%rsp)
mov    %rbp,%rcx
mov    %rbp,0x120(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x110(%rsp)
cmp    %rsi,%r8
mov    0x8(%rsp),%r8
seta   %cl
mov    0x50(%rsp),%rbx
lea    (%rsi,%rbx,1),%rbp
add    $0x1,%rbp
mov    %rbp,0x1e0(%rsp)
cmp    %rbp,%r10
setb   %bl
and    %cl,%bl
mov    %bl,0x1e(%rsp)
mov    %r14d,%ecx
mov    %rcx,0x1d8(%rsp)
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x178(%rsp)
mov    0x38(%rsp),%rbx
and    %rbx,%rax
mov    %rax,0x90(%rsp)
mov    %r9d,%ecx
and    $0x3,%ecx
mov    %r9,%rax
mov    %r9,0x140(%rsp)
and    %r9,%rdx
mov    %rdx,0x118(%rsp)
mov    %rdi,0x180(%rsp)
shl    $0x5,%rdi
mov    %rdi,0x148(%rsp)
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
neg    %rax
mov    %rax,0x190(%rsp)
mov    %rcx,0x170(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x130(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x158(%rsp)
sub    %r15d,%r13d
mov    %r13,0x168(%rsp)
movdqa 0x1c4c(%rip),%xmm4
lea    0x1(%r8),%ecx
lea    0x1(%rsi),%rax
mov    %rax,0x60(%rsp)
mov    0x50(%rsp),%rax
lea    0x2(%rax,%rsi,1),%rax
mov    %rax,0xf0(%rsp)
mov    %r12,0x78(%rsp)
lea    0x1(%rsi,%r12,1),%rax
mov    %rax,0x1b8(%rsp)
mov    0xb8(%rsp),%rax
lea    0x2(%rax,%rsi,1),%rax
mov    %rax,0xe8(%rsp)
mov    0x20(%rsp),%rax
lea    (%rax,%r15,1),%eax
mov    %eax,0x70(%rsp)
mov    %r15,0x10(%rsp)
mov    %r11,0xc8(%rsp)
lea    (%r11,%r15,1),%eax
mov    %eax,0x74(%rsp)
mov    %r10,0x198(%rsp)
lea    0x30(%r10),%rax
mov    %rax,0x1b0(%rsp)
lea    0x30(%rsi),%rax
mov    %rax,0x1a8(%rsp)
lea    0x31(%rsi),%rax
mov    %rax,0x1a0(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,0x98(%rsp)
lea    0x70(%rsi),%rax
mov    %rax,0x1d0(%rsp)
lea    0x71(%rsi),%rax
mov    %rax,0x1c8(%rsp)
lea    0x11(%rsi),%rax
mov    %rax,0xb0(%rsp)
xor    %ebx,%ebx
xor    %ebp,%ebp
xor    %edi,%edi
mov    %ecx,0x10c(%rsp)
jmp    14cd <png_predict+0x3bd>
nopw   0x0(%rax,%rax,1)
mov    0xa8(%rsp),%rdi
add    $0x1,%rdi
mov    0x8(%rsp),%r8
mov    0x30(%rsp),%rbp
add    %r8d,%ebp
mov    0x10c(%rsp),%ecx
mov    0x40(%rsp),%rbx
add    %ecx,%ebx
cmp    0x1d8(%rsp),%rdi
movdqa 0x1b39(%rip),%xmm4
je     2cda <png_predict+0x1bca>
mov    %ebx,%ebx
mov    0x60(%rsp),%rax
lea    (%rax,%rbx,1),%r13
mov    %ebp,%ebp
mov    0x100(%rsp),%rax
lea    (%rax,%rbp,1),%rdx
mov    %rdx,0x68(%rsp)
mov    0x1d0(%rsp),%rdx
add    %rbp,%rdx
mov    0x1c8(%rsp),%rsi
add    %rbx,%rsi
mov    %r8d,%r9d
imul   %edi,%r9d
lea    (%rax,%r9,1),%r14
mov    %rdi,0xa8(%rsp)
imul   %edi,%ecx
mov    0x1e0(%rsp),%rdi
lea    (%rdi,%r9,1),%r11
lea    (%rax,%rcx,1),%r12
add    $0x1,%r12
mov    (%rax,%rcx,1),%al
add    $0xff,%al
cmp    $0x3,%al
mov    %rbx,0x40(%rsp)
mov    %rbp,0x30(%rsp)
ja     16a0 <png_predict+0x590>
mov    0x1a8(%rsp),%rdi
add    %rbp,%rdi
mov    %rdi,0x88(%rsp)
mov    0x1b0(%rsp),%rdi
lea    (%rdi,%rbp,1),%r8
mov    0x1a0(%rsp),%rdi
add    %rdi,%rbx
mov    0x1c0(%rsp),%rdi
lea    (%rdi,%r9,1),%r10
add    0x1b8(%rsp),%r9
mov    0x160(%rsp),%rdi
lea    (%r14,%rdi,1),%r15
movzbl %al,%eax
lea    0x1a7a(%rip),%rdi
movslq (%rdi,%rax,4),%rax
add    %rdi,%rax
mov    %r14,%rbp
jmp    *%rax
cmpl   $0x0,0xa0(%rsp)
jle    1986 <png_predict+0x876>
xor    %edi,%edi
cmpl   $0x1f,0xb8(%rsp)
1f
jb     15de <png_predict+0x4ce>
mov    0xe8(%rsp),%rax
add    %rcx,%rax
cmp    %rax,%rbp
jae    1d11 <png_predict+0xc01>
add    0x60(%rsp),%rcx
cmp    %r10,%rcx
jae    1d11 <png_predict+0xc01>
mov    %rbp,%r10
mov    %rbp,%rdx
mov    0x8(%rsp),%r8
mov    0x58(%rsp),%rsi
mov    %esi,%ecx
sub    %edi,%ecx
mov    %edi,%eax
not    %eax
add    %esi,%eax
and    $0x7,%ecx
je     1629 <png_predict+0x519>
neg    %ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r12),%ebx
add    $0x1,%r12
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %esi,%ecx
jne    1610 <png_predict+0x500>
sub    %esi,%edi
cmp    $0x7,%eax
jb     1991 <png_predict+0x881>
mov    0x58(%rsp),%rax
sub    %edi,%eax
nopl   0x0(%rax)
movzbl (%r12),%ecx
mov    %cl,(%rdx)
movzbl 0x1(%r12),%ecx
mov    %cl,0x1(%rdx)
movzbl 0x2(%r12),%ecx
mov    %cl,0x2(%rdx)
movzbl 0x3(%r12),%ecx
mov    %cl,0x3(%rdx)
movzbl 0x4(%r12),%ecx
mov    %cl,0x4(%rdx)
movzbl 0x5(%r12),%ecx
mov    %cl,0x5(%rdx)
movzbl 0x6(%r12),%ecx
mov    %cl,0x6(%rdx)
movzbl 0x7(%r12),%ecx
add    $0x8,%r12
mov    %cl,0x7(%rdx)
add    $0x8,%rdx
add    $0xfffffff8,%eax
jne    1640 <png_predict+0x530>
jmp    1991 <png_predict+0x881>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0xf8(%rsp)
jle    1490 <png_predict+0x380>
xor    %edi,%edi
cmpl   $0x7,0x50(%rsp)
jb     28f8 <png_predict+0x17e8>
mov    0xf0(%rsp),%rax
add    %rcx,%rax
cmp    %rax,%r14
jae    16d9 <png_predict+0x5c9>
add    0x60(%rsp),%rcx
cmp    %r11,%rcx
jb     28f8 <png_predict+0x17e8>
cmpl   $0x1f,0x50(%rsp)
jae    1fe9 <png_predict+0xed9>
xor    %eax,%eax
mov    0x90(%rsp),%rdx
jmp    25d7 <png_predict+0x14c7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,0xa8(%rsp)
je     1a5e <png_predict+0x94e>
cmpl   $0x0,0xf8(%rsp)
jle    1490 <png_predict+0x380>
xor    %ecx,%ecx
cmpl   $0x7,0x50(%rsp)
jb     2b12 <png_predict+0x1a02>
mov    0x158(%rsp),%rax
imul   0xa8(%rsp),%eax
mov    0x60(%rsp),%rdx
add    %rax,%rdx
add    0xf0(%rsp),%rax
cmp    %rax,%rbp
setb   %al
cmp    %r11,%rdx
setb   %dl
and    %al,%dl
or     0x1e(%rsp),%dl
jne    2b12 <png_predict+0x1a02>
cmpl   $0x1f,0x50(%rsp)
jae    2246 <png_predict+0x1136>
xor    %eax,%eax
jmp    232b <png_predict+0x121b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa8(%rsp),%rdi
test   %rdi,%rdi
je     1ab1 <png_predict+0x9a1>
cmpl   $0x0,0xa0(%rsp)
jle    1c66 <png_predict+0xb56>
xor    %edx,%edx
cmpl   $0x1f,0xb8(%rsp)
1f
jb     17e1 <png_predict+0x6d1>
mov    0x158(%rsp),%rax
imul   %edi,%eax
mov    0x60(%rsp),%rcx
add    %rax,%rcx
add    0xe8(%rsp),%rax
cmp    %rax,%rbp
setb   %al
cmp    %r10,%rcx
setb   %cl
and    %al,%cl
or     0x1f(%rsp),%cl
je     1e78 <png_predict+0xd68>
mov    %rbp,%rsi
mov    %rbp,%rcx
mov    0x8(%rsp),%r8
mov    0x58(%rsp),%rdi
mov    %edi,%esi
sub    %edx,%esi
mov    %edx,%eax
not    %eax
add    %edi,%eax
and    $0x3,%esi
je     1832 <png_predict+0x722>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r15),%ebx
add    $0x1,%r15
shr    %bl
add    (%r12),%bl
add    $0x1,%r12
mov    %bl,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%esi
jne    1810 <png_predict+0x700>
sub    %edi,%edx
cmp    $0x3,%eax
jb     1c6e <png_predict+0xb5e>
mov    0x58(%rsp),%rax
sub    %edx,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r15),%edx
shr    %dl
add    (%r12),%dl
mov    %dl,(%rcx)
movzbl 0x1(%r15),%edx
shr    %dl
add    0x1(%r12),%dl
mov    %dl,0x1(%rcx)
movzbl 0x2(%r15),%edx
shr    %dl
add    0x2(%r12),%dl
mov    %dl,0x2(%rcx)
movzbl 0x3(%r15),%edx
add    $0x4,%r15
shr    %dl
add    0x3(%r12),%dl
add    $0x4,%r12
mov    %dl,0x3(%rcx)
add    $0x4,%rcx
add    $0xfffffffc,%eax
jne    1850 <png_predict+0x740>
jmp    1c6e <png_predict+0xb5e>
nop
cmpq   $0x0,0xa8(%rsp)
je     1b98 <png_predict+0xa88>
mov    0x198(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,1),%r14
cmpl   $0x0,0xa0(%rsp)
jle    1916 <png_predict+0x806>
xor    %ebp,%ebp
mov    0x58(%rsp),%r15
mov    0x68(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rbp,1),%ebx
movzbl (%r14,%rbp,1),%esi
xor    %edi,%edi
xor    %edx,%edx
xor    %eax,%eax
call   1030 <paeth@plt>
add    %bl,%al
mov    %al,(%r12,%rbp,1)
add    $0x1,%rbp
cmp    %ebp,%r15d
jne    18e0 <png_predict+0x7d0>
lea    (%r14,%rbp,1),%r15
lea    (%r12,%rbp,1),%rax
add    %rbp,%r13
mov    %rax,%rbp
mov    %r13,%r12
mov    0x10(%rsp),%rax
cmp    0x8(%rsp),%eax
mov    0x68(%rsp),%rax
jge    1490 <png_predict+0x380>
xor    %ebx,%ebx
nopl   0x0(%rax)
movzbl (%r12,%rbx,1),%edx
mov    %dl,0x88(%rsp)
movzbl (%rax,%rbx,1),%edi
movzbl (%r15,%rbx,1),%esi
movzbl (%r14,%rbx,1),%edx
mov    %r12,%r13
mov    %r15,%r12
mov    %r14,%r15
mov    %rax,%r14
xor    %eax,%eax
call   1030 <paeth@plt>
add    0x88(%rsp),%al
mov    %al,0x0(%rbp,%rbx,1)
mov    %r14,%rax
mov    %r15,%r14
mov    %r12,%r15
mov    %r13,%r12
add    $0x1,%rbx
cmp    %ebx,0x168(%rsp)
jne    1930 <png_predict+0x820>
jmp    1490 <png_predict+0x380>
mov    %rbp,%r10
mov    %rbp,%rdx
mov    0x8(%rsp),%r8
cmp    %r8d,0x10(%rsp)
jge    1490 <png_predict+0x380>
cmpl   $0x7,0x78(%rsp)
jae    1c1e <png_predict+0xb0e>
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x10(%rsp),%rdx
mov    %edx,%r8d
mov    %r10,%rdi
mov    0x8(%rsp),%rbp
mov    %ebp,%edx
sub    %r8d,%edx
mov    %r8d,%esi
not    %esi
add    %ebp,%esi
and    $0x3,%edx
je     19fe <png_predict+0x8ee>
neg    %edx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdi),%ebx
add    $0x1,%rdi
add    (%rcx),%bl
add    $0x1,%rcx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edx
jne    19e0 <png_predict+0x8d0>
sub    %ebp,%r8d
cmp    $0x3,%esi
jb     1490 <png_predict+0x380>
mov    0x8(%rsp),%rsi
sub    %r8d,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ebx
add    (%rcx,%rdx,1),%bl
mov    %bl,(%rax,%rdx,1)
movzbl 0x1(%rdi,%rdx,1),%ebx
add    0x1(%rcx,%rdx,1),%bl
mov    %bl,0x1(%rax,%rdx,1)
movzbl 0x2(%rdi,%rdx,1),%ebx
add    0x2(%rcx,%rdx,1),%bl
mov    %bl,0x2(%rax,%rdx,1)
movzbl 0x3(%rdi,%rdx,1),%ebx
add    0x3(%rcx,%rdx,1),%bl
mov    %bl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %edx,%esi
jne    1a20 <png_predict+0x910>
jmp    1490 <png_predict+0x380>
cmpl   $0x0,0xf8(%rsp)
jle    1490 <png_predict+0x380>
xor    %edi,%edi
cmpl   $0x7,0x50(%rsp)
jb     2c09 <png_predict+0x1af9>
mov    0xf0(%rsp),%rax
add    %rcx,%rax
cmp    %rax,%rbp
jae    1a97 <png_predict+0x987>
add    0x60(%rsp),%rcx
cmp    %r11,%rcx
jb     2c09 <png_predict+0x1af9>
cmpl   $0x1f,0x50(%rsp)
jae    2629 <png_predict+0x1519>
xor    %eax,%eax
mov    0x90(%rsp),%rdx
jmp    2aa7 <png_predict+0x1997>
cmpl   $0x0,0xa0(%rsp)
mov    0x8(%rsp),%r8
jle    1d39 <png_predict+0xc29>
xor    %edi,%edi
cmpl   $0x1f,0xb8(%rsp)
1f
jb     1af2 <png_predict+0x9e2>
mov    0xe8(%rsp),%rax
add    %rcx,%rax
cmp    %rax,%rbp
jae    2223 <png_predict+0x1113>
add    0x60(%rsp),%rcx
cmp    %r10,%rcx
jae    2223 <png_predict+0x1113>
mov    %rbp,%r10
mov    %rbp,%rdx
mov    0x58(%rsp),%rsi
mov    %esi,%ecx
sub    %edi,%ecx
mov    %edi,%eax
not    %eax
add    %esi,%eax
and    $0x7,%ecx
je     1b29 <png_predict+0xa19>
neg    %ecx
xor    %esi,%esi
movzbl (%r12),%ebx
add    $0x1,%r12
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %esi,%ecx
jne    1b10 <png_predict+0xa00>
sub    %esi,%edi
cmp    $0x7,%eax
jb     1d3f <png_predict+0xc2f>
mov    0x58(%rsp),%rax
sub    %edi,%eax
nopl   0x0(%rax)
movzbl (%r12),%ecx
mov    %cl,(%rdx)
movzbl 0x1(%r12),%ecx
mov    %cl,0x1(%rdx)
movzbl 0x2(%r12),%ecx
mov    %cl,0x2(%rdx)
movzbl 0x3(%r12),%ecx
mov    %cl,0x3(%rdx)
movzbl 0x4(%r12),%ecx
mov    %cl,0x4(%rdx)
movzbl 0x5(%r12),%ecx
mov    %cl,0x5(%rdx)
movzbl 0x6(%r12),%ecx
mov    %cl,0x6(%rdx)
movzbl 0x7(%r12),%ecx
add    $0x8,%r12
mov    %cl,0x7(%rdx)
add    $0x8,%rdx
add    $0xfffffff8,%eax
jne    1b40 <png_predict+0xa30>
jmp    1d3f <png_predict+0xc2f>
mov    0x58(%rsp),%rax
mov    %eax,%ebx
cmpl   $0x0,0xa0(%rsp)
jle    1bd5 <png_predict+0xac5>
nopl   0x0(%rax)
movzbl (%r12),%r14d
add    $0x1,%r12
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1030 <paeth@plt>
add    %r14b,%al
mov    %al,0x0(%rbp)
add    $0x1,%rbp
add    $0xffffffff,%ebx
jne    1bb0 <png_predict+0xaa0>
mov    0x10(%rsp),%rax
cmp    0x8(%rsp),%eax
mov    0x68(%rsp),%r15
jge    1490 <png_predict+0x380>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rbx,1),%r14d
movzbl (%r15,%rbx,1),%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1030 <paeth@plt>
add    %r14b,%al
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
cmp    %ebx,0x168(%rsp)
jne    1bf0 <png_predict+0xae0>
jmp    1490 <png_predict+0x380>
mov    0x28(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
add    %r12,%rax
cmp    %rax,%rdx
setb   %sil
cmp    %rcx,%r12
setb   %bl
cmp    %r9,%rdx
setb   %al
cmp    %rcx,%r10
setb   %cl
test   %bl,%sil
jne    19a7 <png_predict+0x897>
and    %cl,%al
jne    19a7 <png_predict+0x897>
cmpl   $0x1f,0x78(%rsp)
jae    20f3 <png_predict+0xfe3>
xor    %esi,%esi
jmp    21d5 <png_predict+0x10c5>
mov    %rbp,%rcx
mov    0x8(%rsp),%r8
cmp    %r8d,0x10(%rsp)
jge    1490 <png_predict+0x380>
cmpl   $0x7,0x78(%rsp)
jb     1cd8 <png_predict+0xbc8>
mov    0x28(%rsp),%rdx
lea    (%rcx,%rdx,1),%rsi
lea    (%r12,%rdx,1),%rax
add    %r15,%rdx
cmp    %rax,%rcx
setb   %r8b
cmp    %rsi,%r12
setb   %bl
cmp    %rdx,%rcx
setb   %al
cmp    %rsi,%r15
setb   %dil
cmp    %r9,%rcx
setb   %dl
cmp    %rsi,%rbp
setb   %sil
test   %bl,%r8b
jne    1cd8 <png_predict+0xbc8>
and    %dil,%al
jne    1cd8 <png_predict+0xbc8>
and    %sil,%dl
jne    1cd8 <png_predict+0xbc8>
cmpl   $0x1f,0x78(%rsp)
jae    23a1 <png_predict+0x1291>
xor    %edi,%edi
jmp    247e <png_predict+0x136e>
mov    %r15,%r9
mov    %rcx,%rdx
mov    %r12,%rsi
mov    0x10(%rsp),%rcx
mov    %rbp,%rdi
mov    0x8(%rsp),%rbx
mov    %ebx,%ebp
sub    %ecx,%ebp
lea    0x1(%rcx),%r8d
test   $0x1,%bpl
jne    1e06 <png_predict+0xcf6>
mov    %rdi,%rbp
cmp    %r8d,%ebx
je     1490 <png_predict+0x380>
jmp    1e36 <png_predict+0xd26>
cmpq   $0x60,0xd0(%rsp)
mov    0x8(%rsp),%r8
jae    2009 <png_predict+0xef9>
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
mov    %rbp,%r10
jmp    207c <png_predict+0xf6c>
mov    %rbp,%r10
mov    %rbp,%rdx
cmp    %r8d,0x10(%rsp)
jge    1490 <png_predict+0x380>
cmpl   $0x7,0x78(%rsp)
jae    1fa1 <png_predict+0xe91>
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x10(%rsp),%rdx
mov    %edx,%r8d
mov    %r10,%rdi
mov    0x8(%rsp),%rbp
mov    %ebp,%edx
sub    %r8d,%edx
mov    %r8d,%esi
not    %esi
add    %ebp,%esi
and    $0x3,%edx
je     1da0 <png_predict+0xc90>
neg    %edx
xor    %ebp,%ebp
movzbl (%rdi),%ebx
add    $0x1,%rdi
shr    %bl
add    (%rcx),%bl
add    $0x1,%rcx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edx
jne    1d80 <png_predict+0xc70>
sub    %ebp,%r8d
cmp    $0x3,%esi
jb     1490 <png_predict+0x380>
mov    0x8(%rsp),%rsi
sub    %r8d,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdi,%rdx,1),%ebx
shr    %bl
add    (%rcx,%rdx,1),%bl
mov    %bl,(%rax,%rdx,1)
movzbl 0x1(%rdi,%rdx,1),%ebx
shr    %bl
add    0x1(%rcx,%rdx,1),%bl
mov    %bl,0x1(%rax,%rdx,1)
movzbl 0x2(%rdi,%rdx,1),%ebx
shr    %bl
add    0x2(%rcx,%rdx,1),%bl
mov    %bl,0x2(%rax,%rdx,1)
movzbl 0x3(%rdi,%rdx,1),%ebx
shr    %bl
add    0x3(%rcx,%rdx,1),%bl
mov    %bl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %edx,%esi
jne    1dc0 <png_predict+0xcb0>
jmp    1490 <png_predict+0x380>
movzbl (%r9),%ecx
add    $0x1,%r9
movzbl (%rdi),%ebp
add    %ecx,%ebp
shr    %ebp
add    (%rsi),%bpl
add    $0x1,%rdi
add    $0x1,%rsi
mov    %bpl,(%rdx)
mov    %rdi,%rbp
add    $0x1,%rdx
mov    %r8d,%ecx
cmp    %r8d,%ebx
je     1490 <png_predict+0x380>
mov    0x8(%rsp),%rdi
sub    %ecx,%edi
xor    %ecx,%ecx
nop
movzbl (%r9,%rcx,1),%eax
movzbl 0x0(%rbp,%rcx,1),%ebx
add    %eax,%ebx
shr    %ebx
add    (%rsi,%rcx,1),%bl
mov    %bl,(%rdx,%rcx,1)
movzbl 0x1(%r9,%rcx,1),%eax
movzbl 0x1(%rbp,%rcx,1),%ebx
add    %eax,%ebx
shr    %ebx
add    0x1(%rsi,%rcx,1),%bl
mov    %bl,0x1(%rdx,%rcx,1)
add    $0x2,%rcx
cmp    %ecx,%edi
jne    1e40 <png_predict+0xd30>
jmp    1490 <png_predict+0x380>
cmpq   $0x0,0xd0(%rsp)
je     2614 <png_predict+0x1504>
mov    0x188(%rsp),%rcx
xor    %eax,%eax
mov    0x88(%rsp),%rdx
nopl   0x0(%rax)
movdqu -0x30(%rbx,%rax,1),%xmm0
movdqu -0x20(%rbx,%rax,1),%xmm1
movdqu -0x30(%r8,%rax,1),%xmm2
movdqu -0x20(%r8,%rax,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,-0x30(%rdx,%rax,1)
movdqu %xmm3,-0x20(%rdx,%rax,1)
movdqu -0x10(%rbx,%rax,1),%xmm0
movdqu (%rbx,%rax,1),%xmm1
movdqu -0x10(%r8,%rax,1),%xmm2
movdqu (%r8,%rax,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,-0x10(%rdx,%rax,1)
movdqu %xmm3,(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    1ea0 <png_predict+0xd90>
testb  $0x1,0x150(%rsp)
01
je     1f75 <png_predict+0xe65>
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu (%r15,%rax,1),%xmm2
movdqu 0x10(%r15,%rax,1),%xmm3
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
paddb  %xmm0,%xmm2
psrlw  $0x1,%xmm3
pand   %xmm4,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm2,0x0(%rbp,%rax,1)
movdqu %xmm3,0x10(%rbp,%rax,1)
mov    0xd8(%rsp),%rax
add    %rax,%r15
lea    (%rax,%rbp,1),%rcx
add    %rax,%r12
mov    %eax,%edx
cmp    %rax,0xe0(%rsp)
mov    0x8(%rsp),%r8
je     1c6e <png_predict+0xb5e>
jmp    17e9 <png_predict+0x6d9>
mov    0x28(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
add    %r12,%rax
cmp    %rax,%rdx
setb   %sil
cmp    %rcx,%r12
setb   %bl
cmp    %r9,%rdx
setb   %al
cmp    %rcx,%r10
setb   %cl
test   %bl,%sil
jne    1d55 <png_predict+0xc45>
and    %cl,%al
jne    1d55 <png_predict+0xc45>
cmpl   $0x1f,0x78(%rsp)
jae    2733 <png_predict+0x1623>
xor    %esi,%esi
jmp    285f <png_predict+0x174f>
cmpq   $0x60,0xc0(%rsp)
jae    24ec <png_predict+0x13dc>
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
jmp    255c <png_predict+0x144c>
mov    0x138(%rsp),%rcx
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
mov    %rbp,%r10
movups -0x70(%rsi,%rax,1),%xmm0
movups -0x60(%rsi,%rax,1),%xmm1
movups %xmm0,-0x70(%rdx,%rax,1)
movups %xmm1,-0x60(%rdx,%rax,1)
movups -0x50(%rsi,%rax,1),%xmm0
movups -0x40(%rsi,%rax,1),%xmm1
movups %xmm0,-0x50(%rdx,%rax,1)
movups %xmm1,-0x40(%rdx,%rax,1)
movups -0x30(%rsi,%rax,1),%xmm0
movups -0x20(%rsi,%rax,1),%xmm1
movups %xmm0,-0x30(%rdx,%rax,1)
movups %xmm1,-0x20(%rdx,%rax,1)
movdqu -0x10(%rsi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rax,1)
movdqu %xmm1,(%rdx,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    2020 <png_predict+0xf10>
testb  $0x3,0x150(%rsp)
03
mov    0x148(%rsp),%rsi
je     20cf <png_predict+0xfbf>
lea    (%rax,%rdi,1),%rcx
add    0xb0(%rsp),%rcx
add    %rbx,%rax
add    0x98(%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    20b0 <png_predict+0xfa0>
mov    0xd8(%rsp),%rax
lea    (%r10,%rax,1),%rdx
add    %rax,%r12
mov    %eax,%edi
cmp    %rax,0xe0(%rsp)
jne    15e9 <png_predict+0x4d9>
jmp    1991 <png_predict+0x881>
cmpq   $0x0,0x128(%rsp)
je     28bc <png_predict+0x17ac>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
mov    0x20(%rsp),%rsi
mov    0x88(%rsp),%rdi
nopl   0x0(%rax)
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu -0x30(%rdi,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu -0x20(%rdi,%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(%rdi,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu (%rdi,%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    2120 <png_predict+0x1010>
testb  $0x1,0x120(%rsp)
01
je     21ba <png_predict+0x10aa>
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,0x28(%rsp)
je     1490 <png_predict+0x380>
mov    0x20(%rsp),%rsi
testb  $0x18,0x28(%rsp)
je     2ae4 <png_predict+0x19d4>
mov    0xc8(%rsp),%rdi
add    %rdi,%r10
lea    (%rdx,%rdi,1),%rax
lea    (%r12,%rdi,1),%rcx
mov    0x68(%rsp),%rbp
nopl   (%rax)
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    21f0 <png_predict+0x10e0>
mov    0x74(%rsp),%r8d
cmp    %rdi,0x28(%rsp)
je     1490 <png_predict+0x380>
jmp    19b5 <png_predict+0x8a5>
cmpq   $0x60,0xd0(%rsp)
jae    2649 <png_predict+0x1539>
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
mov    %rbp,%r10
jmp    26bc <png_predict+0x15ac>
cmpq   $0x0,0xc0(%rsp)
je     28d6 <png_predict+0x17c6>
mov    0x178(%rsp),%rcx
xor    %eax,%eax
mov    0x88(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%rbx,%rax,1),%xmm0
movdqu -0x20(%rbx,%rax,1),%xmm1
movdqu -0x30(%r8,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu -0x20(%r8,%rax,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdx,%rax,1)
movdqu %xmm0,-0x20(%rdx,%rax,1)
movdqu -0x10(%rbx,%rax,1),%xmm0
movdqu (%rbx,%rax,1),%xmm1
movdqu -0x10(%r8,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu (%r8,%rax,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdx,%rax,1)
movdqu %xmm0,(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    2270 <png_predict+0x1160>
testb  $0x1,0x140(%rsp)
01
je     230b <png_predict+0x11fb>
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu (%r15,%rax,1),%xmm2
paddb  %xmm0,%xmm2
movdqu 0x10(%r15,%rax,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,0x0(%rbp,%rax,1)
movdqu %xmm0,0x10(%rbp,%rax,1)
mov    0x48(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     1490 <png_predict+0x380>
mov    0x48(%rsp),%rax
testb  $0x18,0x38(%rsp)
je     2b02 <png_predict+0x19f2>
mov    0x90(%rsp),%rdi
add    %rdi,%r15
add    %rdi,%rbp
add    %rdi,%r12
mov    0x40(%rsp),%rcx
add    %rax,%rcx
add    0x60(%rsp),%rcx
mov    0x30(%rsp),%rdx
add    %rax,%rdx
add    0x100(%rsp),%rdx
add    0x190(%rsp),%rax
mov    0x160(%rsp),%rsi
nopl   0x0(%rax)
movq   (%rcx),%xmm0
movq   (%rdx,%rsi,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rdx)
add    $0x8,%rcx
add    $0x8,%rdx
add    $0x8,%rax
jne    2370 <png_predict+0x1260>
mov    %edi,%ecx
cmp    %rdi,0x38(%rsp)
je     1490 <png_predict+0x380>
jmp    2b12 <png_predict+0x1a02>
mov    0x98(%rsp),%rax
mov    0x30(%rsp),%rdx
add    %rdx,%rax
xor    %edx,%edx
mov    0x20(%rsp),%rsi
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu (%r12,%rdx,1),%xmm9
movdqu 0x10(%r12,%rdx,1),%xmm8
movdqu (%r15,%rdx,1),%xmm4
movdqu 0x10(%r15,%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    23c0 <png_predict+0x12b0>
cmp    %rsi,0x28(%rsp)
je     1490 <png_predict+0x380>
mov    0x20(%rsp),%rdi
testb  $0x18,0x28(%rsp)
je     2bd9 <png_predict+0x1ac9>
mov    0xc8(%rsp),%rbx
lea    (%r15,%rbx,1),%r9
add    %rbx,%rbp
lea    (%rcx,%rbx,1),%rdx
lea    (%r12,%rbx,1),%rsi
pxor   %xmm3,%xmm3
mov    0x68(%rsp),%rax
xchg   %ax,%ax
movq   (%r12,%rdi,1),%xmm0
movq   (%r15,%rdi,1),%xmm1
punpcklbw %xmm3,%xmm1
movq   (%rax,%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,%rbx
jne    24a0 <png_predict+0x1390>
mov    0x74(%rsp),%ecx
cmp    %rbx,0x28(%rsp)
je     1490 <png_predict+0x380>
jmp    1ce6 <png_predict+0xbd6>
mov    0x118(%rsp),%rcx
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
movups -0x70(%rsi,%rax,1),%xmm0
movups -0x60(%rsi,%rax,1),%xmm1
movups %xmm0,-0x70(%rdx,%rax,1)
movups %xmm1,-0x60(%rdx,%rax,1)
movups -0x50(%rsi,%rax,1),%xmm0
movups -0x40(%rsi,%rax,1),%xmm1
movups %xmm0,-0x50(%rdx,%rax,1)
movups %xmm1,-0x40(%rdx,%rax,1)
movups -0x30(%rsi,%rax,1),%xmm0
movups -0x20(%rsi,%rax,1),%xmm1
movups %xmm0,-0x30(%rdx,%rax,1)
movups %xmm1,-0x20(%rdx,%rax,1)
movdqu -0x10(%rsi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rax,1)
movdqu %xmm1,(%rdx,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    2500 <png_predict+0x13f0>
testb  $0x3,0x140(%rsp)
03
mov    0x130(%rsp),%rsi
je     25af <png_predict+0x149f>
lea    (%rax,%rdi,1),%rcx
add    0xb0(%rsp),%rcx
add    %rbx,%rax
add    0x98(%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    2590 <png_predict+0x1480>
mov    0x48(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     1490 <png_predict+0x380>
mov    0x48(%rsp),%rax
testb  $0x18,0x38(%rsp)
mov    0x90(%rsp),%rdx
je     28eb <png_predict+0x17db>
add    %rdx,%r14
add    %rdx,%r12
mov    0x68(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rax,1),%rcx
mov    %rcx,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    25f0 <png_predict+0x14e0>
mov    %edx,%edi
cmp    %rdx,0x38(%rsp)
je     1490 <png_predict+0x380>
jmp    28f8 <png_predict+0x17e8>
xor    %eax,%eax
testb  $0x1,0x150(%rsp)
01
jne    1f35 <png_predict+0xe25>
jmp    1f75 <png_predict+0xe65>
cmpq   $0x60,0xc0(%rsp)
jae    29b3 <png_predict+0x18a3>
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
jmp    2a2c <png_predict+0x191c>
mov    0x138(%rsp),%rcx
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
mov    %rbp,%r10
movups -0x70(%rsi,%rax,1),%xmm0
movups -0x60(%rsi,%rax,1),%xmm1
movups %xmm0,-0x70(%rdx,%rax,1)
movups %xmm1,-0x60(%rdx,%rax,1)
movups -0x50(%rsi,%rax,1),%xmm0
movups -0x40(%rsi,%rax,1),%xmm1
movups %xmm0,-0x50(%rdx,%rax,1)
movups %xmm1,-0x40(%rdx,%rax,1)
movups -0x30(%rsi,%rax,1),%xmm0
movups -0x20(%rsi,%rax,1),%xmm1
movups %xmm0,-0x30(%rdx,%rax,1)
movups %xmm1,-0x20(%rdx,%rax,1)
movdqu -0x10(%rsi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rax,1)
movdqu %xmm1,(%rdx,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    2660 <png_predict+0x1550>
cmpq   $0x0,0x180(%rsp)
mov    0x148(%rsp),%rsi
je     270f <png_predict+0x15ff>
lea    (%rax,%rdi,1),%rcx
add    0xb0(%rsp),%rcx
add    %rbx,%rax
add    0x98(%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    26f0 <png_predict+0x15e0>
mov    0xd8(%rsp),%rax
lea    (%r10,%rax,1),%rdx
add    %rax,%r12
mov    %eax,%edi
cmp    %rax,0xe0(%rsp)
jne    1af8 <png_predict+0x9e8>
jmp    1d3f <png_predict+0xc2f>
cmpq   $0x0,0x128(%rsp)
je     2bb7 <png_predict+0x1aa7>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
mov    0x20(%rsp),%rsi
movdqa 0x8a7(%rip),%xmm4
mov    0x88(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%r12,%rax,1),%xmm0
movdqu 0x10(%r12,%rax,1),%xmm1
movdqu -0x30(%rdi,%rax,1),%xmm2
movdqu -0x20(%rdi,%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(%rdi,%rax,1),%xmm2
movdqu (%rdi,%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    2770 <png_predict+0x1660>
testb  $0x1,0x120(%rsp)
01
je     2844 <png_predict+0x1734>
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,0x28(%rsp)
je     1490 <png_predict+0x380>
mov    0x20(%rsp),%rsi
testb  $0x18,0x28(%rsp)
je     2cbc <png_predict+0x1bac>
mov    0xc8(%rsp),%rdi
add    %rdi,%r10
lea    (%rdx,%rdi,1),%rax
lea    (%r12,%rdi,1),%rcx
movdqa 0x786(%rip),%xmm2
mov    0x68(%rsp),%rbp
nop
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    2880 <png_predict+0x1770>
mov    0x74(%rsp),%r8d
cmp    %rdi,0x28(%rsp)
je     1490 <png_predict+0x380>
jmp    1d63 <png_predict+0xc53>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
testb  $0x1,0x120(%rsp)
01
jne    218d <png_predict+0x107d>
jmp    21ba <png_predict+0x10aa>
xor    %eax,%eax
testb  $0x1,0x140(%rsp)
01
jne    22dd <png_predict+0x11cd>
jmp    230b <png_predict+0x11fb>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r14
mov    %eax,%edi
mov    0x80(%rsp),%rdx
mov    %edx,%ecx
sub    %edi,%ecx
mov    %edi,%eax
not    %eax
add    %edx,%eax
and    $0x7,%ecx
je     293a <png_predict+0x182a>
neg    %ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r12),%ebx
add    $0x1,%r12
mov    %bl,(%r14)
add    $0x1,%r14
add    $0xffffffffffffffff,%rdx
cmp    %edx,%ecx
jne    2920 <png_predict+0x1810>
sub    %edx,%edi
cmp    $0x7,%eax
jb     1490 <png_predict+0x380>
mov    0x80(%rsp),%rax
sub    %edi,%eax
xor    %ecx,%ecx
nop
movzbl (%r12,%rcx,1),%edx
mov    %dl,(%r14,%rcx,1)
movzbl 0x1(%r12,%rcx,1),%edx
mov    %dl,0x1(%r14,%rcx,1)
movzbl 0x2(%r12,%rcx,1),%edx
mov    %dl,0x2(%r14,%rcx,1)
movzbl 0x3(%r12,%rcx,1),%edx
mov    %dl,0x3(%r14,%rcx,1)
movzbl 0x4(%r12,%rcx,1),%edx
mov    %dl,0x4(%r14,%rcx,1)
movzbl 0x5(%r12,%rcx,1),%edx
mov    %dl,0x5(%r14,%rcx,1)
movzbl 0x6(%r12,%rcx,1),%edx
mov    %dl,0x6(%r14,%rcx,1)
movzbl 0x7(%r12,%rcx,1),%edx
mov    %dl,0x7(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %ecx,%eax
jne    2950 <png_predict+0x1840>
jmp    1490 <png_predict+0x380>
mov    0x118(%rsp),%rcx
xor    %eax,%eax
mov    0x40(%rsp),%rdi
mov    0x30(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movups -0x70(%rsi,%rax,1),%xmm0
movups -0x60(%rsi,%rax,1),%xmm1
movups %xmm0,-0x70(%rdx,%rax,1)
movups %xmm1,-0x60(%rdx,%rax,1)
movups -0x50(%rsi,%rax,1),%xmm0
movups -0x40(%rsi,%rax,1),%xmm1
movups %xmm0,-0x50(%rdx,%rax,1)
movups %xmm1,-0x40(%rdx,%rax,1)
movups -0x30(%rsi,%rax,1),%xmm0
movups -0x20(%rsi,%rax,1),%xmm1
movups %xmm0,-0x30(%rdx,%rax,1)
movups %xmm1,-0x20(%rdx,%rax,1)
movdqu -0x10(%rsi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rax,1)
movdqu %xmm1,(%rdx,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    29d0 <png_predict+0x18c0>
cmpq   $0x0,0x170(%rsp)
mov    0x130(%rsp),%rsi
je     2a7f <png_predict+0x196f>
lea    (%rax,%rdi,1),%rcx
add    0xb0(%rsp),%rcx
add    %rbx,%rax
add    0x98(%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    2a60 <png_predict+0x1950>
mov    0x48(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     1490 <png_predict+0x380>
mov    0x48(%rsp),%rax
testb  $0x18,0x38(%rsp)
mov    0x90(%rsp),%rdx
je     2bfc <png_predict+0x1aec>
add    %rdx,%rbp
add    %rdx,%r12
mov    0x68(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rax,1),%rcx
mov    %rcx,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    2ac0 <png_predict+0x19b0>
mov    %edx,%edi
cmp    %rdx,0x38(%rsp)
je     1490 <png_predict+0x380>
jmp    2c09 <png_predict+0x1af9>
mov    0x20(%rsp),%rax
add    %rax,%r12
add    %rax,%rdx
add    %rax,%r10
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x70(%rsp),%r8d
jmp    19b5 <png_predict+0x8a5>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%rbp
add    %rax,%r15
mov    %eax,%ecx
mov    0x80(%rsp),%rsi
mov    %esi,%edx
sub    %ecx,%edx
mov    %ecx,%eax
not    %eax
add    %esi,%eax
and    $0x3,%edx
je     2b51 <png_predict+0x1a41>
neg    %edx
xor    %esi,%esi
nopl   (%rax)
movzbl (%r15),%ebx
add    $0x1,%r15
add    (%r12),%bl
add    $0x1,%r12
mov    %bl,0x0(%rbp)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
cmp    %esi,%edx
jne    2b30 <png_predict+0x1a20>
sub    %esi,%ecx
cmp    $0x3,%eax
jb     1490 <png_predict+0x380>
mov    0x80(%rsp),%rax
sub    %ecx,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%rcx,1),%edx
add    (%r12,%rcx,1),%dl
mov    %dl,0x0(%rbp,%rcx,1)
movzbl 0x1(%r15,%rcx,1),%edx
add    0x1(%r12,%rcx,1),%dl
mov    %dl,0x1(%rbp,%rcx,1)
movzbl 0x2(%r15,%rcx,1),%edx
add    0x2(%r12,%rcx,1),%dl
mov    %dl,0x2(%rbp,%rcx,1)
movzbl 0x3(%r15,%rcx,1),%edx
add    0x3(%r12,%rcx,1),%dl
mov    %dl,0x3(%rbp,%rcx,1)
add    $0x4,%rcx
cmp    %ecx,%eax
jne    2b70 <png_predict+0x1a60>
jmp    1490 <png_predict+0x380>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
movdqa 0x43a(%rip),%xmm4
testb  $0x1,0x120(%rsp)
01
jne    2805 <png_predict+0x16f5>
jmp    2844 <png_predict+0x1734>
mov    0x20(%rsp),%rax
add    %rax,%r12
add    %rax,%rcx
add    %rax,%rbp
add    %rax,%r15
mov    %r15,%r9
mov    %rcx,%rdx
mov    %r12,%rsi
mov    0x70(%rsp),%ecx
jmp    1ce6 <png_predict+0xbd6>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%rbp
mov    %eax,%edi
mov    0x80(%rsp),%rdx
mov    %edx,%ecx
sub    %edi,%ecx
mov    %edi,%eax
not    %eax
add    %edx,%eax
and    $0x7,%ecx
je     2c4a <png_predict+0x1b3a>
neg    %ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12),%ebx
add    $0x1,%r12
mov    %bl,0x0(%rbp)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
cmp    %edx,%ecx
jne    2c30 <png_predict+0x1b20>
sub    %edx,%edi
cmp    $0x7,%eax
jb     1490 <png_predict+0x380>
mov    0x80(%rsp),%rax
sub    %edi,%eax
xor    %ecx,%ecx
nop
movzbl (%r12,%rcx,1),%edx
mov    %dl,0x0(%rbp,%rcx,1)
movzbl 0x1(%r12,%rcx,1),%edx
mov    %dl,0x1(%rbp,%rcx,1)
movzbl 0x2(%r12,%rcx,1),%edx
mov    %dl,0x2(%rbp,%rcx,1)
movzbl 0x3(%r12,%rcx,1),%edx
mov    %dl,0x3(%rbp,%rcx,1)
movzbl 0x4(%r12,%rcx,1),%edx
mov    %dl,0x4(%rbp,%rcx,1)
movzbl 0x5(%r12,%rcx,1),%edx
mov    %dl,0x5(%rbp,%rcx,1)
movzbl 0x6(%r12,%rcx,1),%edx
mov    %dl,0x6(%rbp,%rcx,1)
movzbl 0x7(%r12,%rcx,1),%edx
mov    %dl,0x7(%rbp,%rcx,1)
add    $0x8,%rcx
cmp    %ecx,%eax
jne    2c60 <png_predict+0x1b50>
jmp    1490 <png_predict+0x380>
mov    0x20(%rsp),%rax
add    %rax,%r12
add    %rax,%rdx
add    %rax,%r10
mov    %rdx,%rax
mov    %r12,%rcx
mov    0x70(%rsp),%r8d
jmp    1d63 <png_predict+0xc53>
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 nsw i32 %20, %21
%23 = load i32, i32* %10
%24 = mul nsw i32 %22, %23
%25 = add nsw i32 %24, 7
%26 = sdiv i32 %25, 8
store i32 %26, i32* %11
%27 = load i32, i32* %9
%28 = load i32, i32* %10
%29 = mul nsw i32 %27, %28
%30 = add nsw i32 %29, 7
%31 = sdiv 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 slt 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 nsw i32 %38, 1
%40 = load i32, i32* %14
%41 = mul nsw 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 nsw 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 = sext 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 = sext 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 slt 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 nsw 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 nsw 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 nsw i32 %7, 7
%9 = sdiv i32 %8, 8
%10 = add nsw i32 %6, 7
%11 = sdiv i32 %10, 8
%12 = icmp sgt i32 %2, 0
br i1 %12, label %13, label %1819
13: ; preds = %5
%14 = add nsw i32 %9, 1
%15 = sub nsw i32 0, %9
%16 = sext i32 %15 to i64
%17 = icmp sgt i32 %6, 0
%18 = icmp slt i32 %11, %9
%19 = icmp sgt i32 %7, 0
%20 = call i32 @llvm.smax.i32(i32 %11, i32 1)
%21 = call i32 @llvm.smax.i32(i32 %9, i32 1)
%22 = zext i32 %2 to i64
%23 = add nsw i32 %21, -1
%24 = zext i32 %23 to i64
%25 = add nuw nsw i64 %24, 1
%26 = getelementptr i8, i8* %0, i64 %25
%27 = getelementptr i8, i8* %0, i64 1
%28 = add nsw i32 %9, 1
%29 = add nuw nsw i64 %24, 2
%30 = getelementptr i8, i8* %0, i64 %29
%31 = add nsw i32 %21, -1
%32 = zext i32 %31 to i64
%33 = add nuw nsw i64 %32, 1
%34 = add nsw i32 %21, -1
%35 = zext i32 %34 to i64
%36 = add nuw nsw i64 %35, 1
%37 = xor i32 %11, -1
%38 = add nsw i32 %9, %37
%39 = zext i32 %38 to i64
%40 = add nuw nsw i64 %39, 1
%41 = getelementptr i8, i8* %0, i64 %40
%42 = zext i32 %38 to i64
%43 = add nuw nsw i64 %42, 1
%44 = xor i32 %11, -1
%45 = add nsw i32 %9, %44
%46 = zext i32 %45 to i64
%47 = add nuw nsw i64 %46, 1
%48 = add nsw i32 %20, -1
%49 = zext i32 %48 to i64
%50 = add nuw nsw i64 %49, 1
%51 = getelementptr i8, i8* %0, i64 %50
%52 = getelementptr i8, i8* %0, i64 1
%53 = add nsw i32 %9, 1
%54 = add nuw nsw i64 %49, 2
%55 = getelementptr i8, i8* %0, i64 %54
%56 = add nsw i32 %20, -1
%57 = zext i32 %56 to i64
%58 = add nuw nsw i64 %57, 1
%59 = add nsw i32 %21, -1
%60 = zext i32 %59 to i64
%61 = add nuw nsw i64 %60, 1
%62 = getelementptr i8, i8* %0, i64 %61
%63 = getelementptr i8, i8* %0, i64 1
%64 = add nsw i32 %9, 1
%65 = add nuw nsw i64 %60, 2
%66 = getelementptr i8, i8* %0, i64 %65
%67 = add nsw i32 %21, -1
%68 = zext i32 %67 to i64
%69 = add nuw nsw i64 %68, 1
%70 = add nsw i32 %21, -1
%71 = zext i32 %70 to i64
%72 = add nuw nsw i64 %71, 1
%73 = add nsw i32 %21, -1
%74 = zext i32 %73 to i64
%75 = add nuw nsw i64 %74, 1
%76 = getelementptr i8, i8* %0, i64 %75
%77 = getelementptr i8, i8* %0, i64 1
%78 = sext i32 %9 to i64
%79 = add nsw i64 %78, 1
%80 = add nuw nsw i64 %74, 2
%81 = getelementptr i8, i8* %0, i64 %80
%82 = getelementptr i8, i8* %0, i64 %16
%83 = add nuw nsw i64 %74, 1
%84 = sub nsw i64 %83, %78
%85 = getelementptr i8, i8* %0, i64 %84
%86 = add nsw i32 %21, -1
%87 = zext i32 %86 to i64
%88 = add nuw nsw i64 %87, 1
%89 = add nsw i32 %21, -1
%90 = zext i32 %89 to i64
%91 = add nuw nsw i64 %90, 1
%92 = xor i32 %11, -1
%93 = add nsw i32 %9, %92
%94 = zext i32 %93 to i64
%95 = add nuw nsw i64 %94, 1
%96 = getelementptr i8, i8* %0, i64 %95
%97 = zext i32 %93 to i64
%98 = add nuw nsw i64 %97, 1
%99 = xor i32 %11, -1
%100 = add nsw i32 %9, %99
%101 = zext i32 %100 to i64
%102 = add nuw nsw i64 %101, 1
%103 = add nsw i32 %20, -1
%104 = zext i32 %103 to i64
%105 = add nuw nsw i64 %104, 1
%106 = getelementptr i8, i8* %0, i64 %105
%107 = getelementptr i8, i8* %0, i64 1
%108 = add nsw i32 %9, 1
%109 = add nuw nsw i64 %104, 2
%110 = getelementptr i8, i8* %0, i64 %109
%111 = add nsw i32 %20, -1
%112 = zext i32 %111 to i64
%113 = add nuw nsw i64 %112, 1
%114 = xor i32 %11, -1
%115 = add nsw i32 %9, %114
%116 = zext i32 %115 to i64
%117 = add nuw nsw i64 %116, 1
%118 = getelementptr i8, i8* %0, i64 %117
%119 = zext i32 %115 to i64
%120 = add nuw nsw i64 %119, 1
%121 = xor i32 %11, -1
%122 = add nsw i32 %9, %121
%123 = zext i32 %122 to i64
%124 = add nuw nsw i64 %123, 1
%125 = add nsw i32 %20, -1
%126 = zext i32 %125 to i64
%127 = add nuw nsw i64 %126, 1
%128 = getelementptr i8, i8* %0, i64 %127
%129 = getelementptr i8, i8* %0, i64 1
%130 = sext i32 %9 to i64
%131 = add nsw i64 %130, 1
%132 = add nuw nsw i64 %126, 2
%133 = getelementptr i8, i8* %0, i64 %132
%134 = getelementptr i8, i8* %0, i64 %16
%135 = add nuw nsw i64 %126, 1
%136 = sub nsw i64 %135, %130
%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 %50, 8589934560
%142 = add nsw i64 %141, -32
%143 = lshr exact i64 %142, 5
%144 = add nuw nsw i64 %143, 1
%145 = and i64 %40, 8589934560
%146 = add nsw i64 %145, -32
%147 = lshr exact i64 %146, 5
%148 = add nuw nsw i64 %147, 1
%149 = and i64 %25, 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, %128
%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 %115, 7
%165 = icmp ult i32 %115, 31
%166 = and i64 %120, 8589934560
%167 = icmp eq i64 %120, %166
%168 = trunc i64 %166 to i32
%169 = add i32 %11, %168
%170 = and i64 %120, 24
%171 = icmp eq i64 %170, 0
%172 = and i64 %124, 8589934584
%173 = trunc i64 %172 to i32
%174 = add i32 %11, %173
%175 = icmp eq i64 %124, %172
%176 = icmp ult i32 %111, 31
%177 = and i64 %113, 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 %113, %177
%184 = icmp ult i32 %93, 7
%185 = icmp ult i32 %93, 31
%186 = and i64 %98, 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 %98, %186
%192 = trunc i64 %186 to i32
%193 = add i32 %11, %192
%194 = and i64 %98, 24
%195 = icmp eq i64 %194, 0
%196 = and i64 %102, 8589934584
%197 = trunc i64 %196 to i32
%198 = add i32 %11, %197
%199 = icmp eq i64 %102, %196
%200 = icmp ult i32 %86, 7
%201 = icmp ugt i8* %85, %0
%202 = icmp ult i8* %82, %76
%203 = and i1 %201, %202
%204 = icmp ult i32 %86, 31
%205 = and i64 %88, 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 %88, %205
%211 = trunc i64 %205 to i32
%212 = and i64 %88, 24
%213 = icmp eq i64 %212, 0
%214 = and i64 %91, 8589934584
%215 = trunc i64 %214 to i32
%216 = icmp eq i64 %91, %214
%217 = icmp ult i32 %67, 7
%218 = icmp ult i32 %67, 31
%219 = and i64 %69, 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 %69, %219
%225 = trunc i64 %219 to i32
%226 = and i64 %69, 24
%227 = icmp eq i64 %226, 0
%228 = and i64 %72, 8589934584
%229 = trunc i64 %228 to i32
%230 = icmp eq i64 %72, %228
%231 = icmp ult i32 %56, 31
%232 = and i64 %58, 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 %58, %232
%239 = icmp ult i32 %38, 7
%240 = icmp ult i32 %38, 31
%241 = and i64 %43, 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 %43, %241
%247 = trunc i64 %241 to i32
%248 = add i32 %11, %247
%249 = and i64 %43, 24
%250 = icmp eq i64 %249, 0
%251 = and i64 %47, 8589934584
%252 = trunc i64 %251 to i32
%253 = add i32 %11, %252
%254 = icmp eq i64 %47, %251
%255 = icmp ult i32 %31, 7
%256 = icmp ult i32 %31, 31
%257 = and i64 %33, 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 %33, %257
%263 = trunc i64 %257 to i32
%264 = and i64 %33, 24
%265 = icmp eq i64 %264, 0
%266 = and i64 %36, 8589934584
%267 = trunc i64 %266 to i32
%268 = icmp eq i64 %36, %266
br label %269
269: ; preds = %13, %1816
%270 = phi i64 [ 0, %13 ], [ %1817, %1816 ]
%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* %128, i64 %273
%276 = mul i64 %131, %270
%277 = and i64 %276, 4294967295
%278 = getelementptr i8, i8* %129, 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* %118, 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* %106, i64 %287
%290 = trunc i64 %270 to i32
%291 = mul i32 %108, %290
%292 = zext i32 %291 to i64
%293 = getelementptr i8, i8* %107, i64 %292
%294 = getelementptr i8, i8* %110, i64 %292
%295 = trunc i64 %270 to i32
%296 = mul i32 %9, %295
%297 = zext i32 %296 to i64
%298 = getelementptr i8, i8* %0, i64 %297
%299 = getelementptr i8, i8* %96, i64 %297
%300 = trunc i64 %270 to i32
%301 = mul i32 %9, %300
%302 = zext i32 %301 to i64
%303 = getelementptr i8, i8* %0, i64 %302
%304 = getelementptr i8, i8* %76, i64 %302
%305 = mul i64 %79, %270
%306 = and i64 %305, 4294967295
%307 = getelementptr i8, i8* %77, i64 %306
%308 = getelementptr i8, i8* %81, i64 %306
%309 = trunc i64 %270 to i32
%310 = mul i32 %9, %309
%311 = zext i32 %310 to i64
%312 = getelementptr i8, i8* %0, i64 %311
%313 = getelementptr i8, i8* %62, i64 %311
%314 = trunc i64 %270 to i32
%315 = mul i32 %64, %314
%316 = zext i32 %315 to i64
%317 = getelementptr i8, i8* %63, i64 %316
%318 = getelementptr i8, i8* %66, i64 %316
%319 = trunc i64 %270 to i32
%320 = mul i32 %9, %319
%321 = zext i32 %320 to i64
%322 = getelementptr i8, i8* %0, i64 %321
%323 = getelementptr i8, i8* %51, i64 %321
%324 = trunc i64 %270 to i32
%325 = mul i32 %53, %324
%326 = zext i32 %325 to i64
%327 = getelementptr i8, i8* %52, i64 %326
%328 = getelementptr i8, i8* %55, i64 %326
%329 = trunc i64 %270 to i32
%330 = mul i32 %9, %329
%331 = zext i32 %330 to i64
%332 = getelementptr i8, i8* %0, i64 %331
%333 = getelementptr i8, i8* %41, i64 %331
%334 = trunc i64 %270 to i32
%335 = mul i32 %9, %334
%336 = zext i32 %335 to i64
%337 = getelementptr i8, i8* %0, i64 %336
%338 = getelementptr i8, i8* %26, i64 %336
%339 = trunc i64 %270 to i32
%340 = mul i32 %28, %339
%341 = zext i32 %340 to i64
%342 = getelementptr i8, i8* %27, i64 %341
%343 = getelementptr i8, i8* %30, i64 %341
%344 = trunc i64 %270 to i32
%345 = mul i32 %14, %344
%346 = zext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %0, i64 %346
%348 = trunc i64 %270 to i32
%349 = mul nsw i32 %9, %348
%350 = zext i32 %349 to i64
%351 = getelementptr inbounds i8, i8* %0, i64 %350
%352 = getelementptr inbounds i8, i8* %351, i64 %16
%353 = getelementptr inbounds i8, i8* %347, i64 1
%354 = load i8, i8* %347
switch i8 %354, label %459 [
i8 4, label %1737
i8 1, label %355
i8 2, label %803
i8 3, label %1112
]
355: ; preds = %269
br i1 %17, label %356, label %607
356: ; preds = %355
br i1 %231, label %432, label %357
357: ; preds = %356
%358 = icmp ult i8* %322, %328
%359 = icmp ult i8* %327, %323
%360 = and i1 %358, %359
br i1 %360, label %432, label %361
361: ; preds = %357
%362 = getelementptr i8, i8* %351, i64 %232
%363 = getelementptr i8, i8* %353, i64 %232
br i1 %235, label %413, label %364
364: ; preds = %361, %364
%365 = phi i64 [ %410, %364 ], [ 0, %361 ]
%366 = phi i64 [ %411, %364 ], [ 0, %361 ]
%367 = getelementptr i8, i8* %351, i64 %365
%368 = getelementptr i8, i8* %353, i64 %365
%369 = bitcast i8* %368 to <16 x i8>*
%370 = load <16 x i8>, <16 x i8>* %369
%371 = getelementptr i8, i8* %368, i64 16
%372 = bitcast i8* %371 to <16 x i8>*
%373 = load <16 x i8>, <16 x i8>* %372
%374 = bitcast i8* %367 to <16 x i8>*
store <16 x i8> %370, <16 x i8>* %374
%375 = getelementptr i8, i8* %367, i64 16
%376 = bitcast i8* %375 to <16 x i8>*
store <16 x i8> %373, <16 x i8>* %376
%377 = or i64 %365, 32
%378 = getelementptr i8, i8* %351, i64 %377
%379 = getelementptr i8, i8* %353, i64 %377
%380 = bitcast i8* %379 to <16 x i8>*
%381 = load <16 x i8>, <16 x i8>* %380
%382 = getelementptr i8, i8* %379, i64 16
%383 = bitcast i8* %382 to <16 x i8>*
%384 = load <16 x i8>, <16 x i8>* %383
%385 = bitcast i8* %378 to <16 x i8>*
store <16 x i8> %381, <16 x i8>* %385
%386 = getelementptr i8, i8* %378, i64 16
%387 = bitcast i8* %386 to <16 x i8>*
store <16 x i8> %384, <16 x i8>* %387
%388 = or i64 %365, 64
%389 = getelementptr i8, i8* %351, i64 %388
%390 = getelementptr i8, i8* %353, i64 %388
%391 = bitcast i8* %390 to <16 x i8>*
%392 = load <16 x i8>, <16 x i8>* %391
%393 = getelementptr i8, i8* %390, i64 16
%394 = bitcast i8* %393 to <16 x i8>*
%395 = load <16 x i8>, <16 x i8>* %394
%396 = bitcast i8* %389 to <16 x i8>*
store <16 x i8> %392, <16 x i8>* %396
%397 = getelementptr i8, i8* %389, i64 16
%398 = bitcast i8* %397 to <16 x i8>*
store <16 x i8> %395, <16 x i8>* %398
%399 = or i64 %365, 96
%400 = getelementptr i8, i8* %351, i64 %399
%401 = getelementptr i8, i8* %353, i64 %399
%402 = bitcast i8* %401 to <16 x i8>*
%403 = load <16 x i8>, <16 x i8>* %402
%404 = getelementptr i8, i8* %401, i64 16
%405 = bitcast i8* %404 to <16 x i8>*
%406 = load <16 x i8>, <16 x i8>* %405
%407 = bitcast i8* %400 to <16 x i8>*
store <16 x i8> %403, <16 x i8>* %407
%408 = getelementptr i8, i8* %400, i64 16
%409 = bitcast i8* %408 to <16 x i8>*
store <16 x i8> %406, <16 x i8>* %409
%410 = add nuw i64 %365, 128
%411 = add i64 %366, 4
%412 = icmp eq i64 %411, %236
br i1 %412, label %413, label %364
413: ; preds = %364, %361
%414 = phi i64 [ 0, %361 ], [ %410, %364 ]
br i1 %237, label %431, label %415
415: ; preds = %413, %415
%416 = phi i64 [ %428, %415 ], [ %414, %413 ]
%417 = phi i64 [ %429, %415 ], [ 0, %413 ]
%418 = getelementptr i8, i8* %351, i64 %416
%419 = getelementptr i8, i8* %353, i64 %416
%420 = bitcast i8* %419 to <16 x i8>*
%421 = load <16 x i8>, <16 x i8>* %420
%422 = getelementptr i8, i8* %419, i64 16
%423 = bitcast i8* %422 to <16 x i8>*
%424 = load <16 x i8>, <16 x i8>* %423
%425 = bitcast i8* %418 to <16 x i8>*
store <16 x i8> %421, <16 x i8>* %425
%426 = getelementptr i8, i8* %418, i64 16
%427 = bitcast i8* %426 to <16 x i8>*
store <16 x i8> %424, <16 x i8>* %427
%428 = add nuw i64 %416, 32
%429 = add i64 %417, 1
%430 = icmp eq i64 %429, %234
br i1 %430, label %431, label %415
431: ; preds = %415, %413
br i1 %238, label %607, label %432
432: ; preds = %357, %356, %431
%433 = phi i8* [ %351, %357 ], [ %351, %356 ], [ %362, %431 ]
%434 = phi i8* [ %353, %357 ], [ %353, %356 ], [ %363, %431 ]
%435 = phi i32 [ 0, %357 ], [ 0, %356 ], [ %233, %431 ]
%436 = sub i32 %20, %435
%437 = xor i32 %435, -1
%438 = add i32 %20, %437
%439 = and i32 %436, 7
%440 = icmp eq i32 %439, 0
br i1 %440, label %452, label %441
441: ; preds = %432, %441
%442 = phi i8* [ %448, %441 ], [ %433, %432 ]
%443 = phi i8* [ %446, %441 ], [ %434, %432 ]
%444 = phi i32 [ %449, %441 ], [ %435, %432 ]
%445 = phi i32 [ %450, %441 ], [ 0, %432 ]
%446 = getelementptr inbounds i8, i8* %443, i64 1
%447 = load i8, i8* %443
%448 = getelementptr inbounds i8, i8* %442, i64 1
store i8 %447, i8* %442
%449 = add nuw nsw i32 %444, 1
%450 = add i32 %445, 1
%451 = icmp eq i32 %450, %439
br i1 %451, label %452, label %441
452: ; preds = %441, %432
%453 = phi i8* [ undef, %432 ], [ %446, %441 ]
%454 = phi i8* [ undef, %432 ], [ %448, %441 ]
%455 = phi i8* [ %433, %432 ], [ %448, %441 ]
%456 = phi i8* [ %434, %432 ], [ %446, %441 ]
%457 = phi i32 [ %435, %432 ], [ %449, %441 ]
%458 = icmp ult i32 %438, 7
br i1 %458, label %607, label %742
459: ; preds = %269
br i1 %19, label %460, label %1816
460: ; preds = %459
br i1 %255, label %552, label %461
461: ; preds = %460
%462 = icmp ult i8* %337, %343
%463 = icmp ult i8* %342, %338
%464 = and i1 %462, %463
br i1 %464, label %552, label %465
465: ; preds = %461
br i1 %256, label %538, label %466
466: ; preds = %465
br i1 %259, label %516, label %467
467: ; preds = %466, %467
%468 = phi i64 [ %513, %467 ], [ 0, %466 ]
%469 = phi i64 [ %514, %467 ], [ 0, %466 ]
%470 = getelementptr i8, i8* %351, i64 %468
%471 = getelementptr i8, i8* %353, i64 %468
%472 = bitcast i8* %471 to <16 x i8>*
%473 = load <16 x i8>, <16 x i8>* %472
%474 = getelementptr i8, i8* %471, i64 16
%475 = bitcast i8* %474 to <16 x i8>*
%476 = load <16 x i8>, <16 x i8>* %475
%477 = bitcast i8* %470 to <16 x i8>*
store <16 x i8> %473, <16 x i8>* %477
%478 = getelementptr i8, i8* %470, i64 16
%479 = bitcast i8* %478 to <16 x i8>*
store <16 x i8> %476, <16 x i8>* %479
%480 = or i64 %468, 32
%481 = getelementptr i8, i8* %351, i64 %480
%482 = getelementptr i8, i8* %353, i64 %480
%483 = bitcast i8* %482 to <16 x i8>*
%484 = load <16 x i8>, <16 x i8>* %483
%485 = getelementptr i8, i8* %482, i64 16
%486 = bitcast i8* %485 to <16 x i8>*
%487 = load <16 x i8>, <16 x i8>* %486
%488 = bitcast i8* %481 to <16 x i8>*
store <16 x i8> %484, <16 x i8>* %488
%489 = getelementptr i8, i8* %481, i64 16
%490 = bitcast i8* %489 to <16 x i8>*
store <16 x i8> %487, <16 x i8>* %490
%491 = or i64 %468, 64
%492 = getelementptr i8, i8* %351, i64 %491
%493 = getelementptr i8, i8* %353, i64 %491
%494 = bitcast i8* %493 to <16 x i8>*
%495 = load <16 x i8>, <16 x i8>* %494
%496 = getelementptr i8, i8* %493, i64 16
%497 = bitcast i8* %496 to <16 x i8>*
%498 = load <16 x i8>, <16 x i8>* %497
%499 = bitcast i8* %492 to <16 x i8>*
store <16 x i8> %495, <16 x i8>* %499
%500 = getelementptr i8, i8* %492, i64 16
%501 = bitcast i8* %500 to <16 x i8>*
store <16 x i8> %498, <16 x i8>* %501
%502 = or i64 %468, 96
%503 = getelementptr i8, i8* %351, i64 %502
%504 = getelementptr i8, i8* %353, i64 %502
%505 = bitcast i8* %504 to <16 x i8>*
%506 = load <16 x i8>, <16 x i8>* %505
%507 = getelementptr i8, i8* %504, i64 16
%508 = bitcast i8* %507 to <16 x i8>*
%509 = load <16 x i8>, <16 x i8>* %508
%510 = bitcast i8* %503 to <16 x i8>*
store <16 x i8> %506, <16 x i8>* %510
%511 = getelementptr i8, i8* %503, i64 16
%512 = bitcast i8* %511 to <16 x i8>*
store <16 x i8> %509, <16 x i8>* %512
%513 = add nuw i64 %468, 128
%514 = add i64 %469, 4
%515 = icmp eq i64 %514, %260
br i1 %515, label %516, label %467
516: ; preds = %467, %466
%517 = phi i64 [ 0, %466 ], [ %513, %467 ]
br i1 %261, label %534, label %518
518: ; preds = %516, %518
%519 = phi i64 [ %531, %518 ], [ %517, %516 ]
%520 = phi i64 [ %532, %518 ], [ 0, %516 ]
%521 = getelementptr i8, i8* %351, i64 %519
%522 = getelementptr i8, i8* %353, i64 %519
%523 = bitcast i8* %522 to <16 x i8>*
%524 = load <16 x i8>, <16 x i8>* %523
%525 = getelementptr i8, i8* %522, i64 16
%526 = bitcast i8* %525 to <16 x i8>*
%527 = load <16 x i8>, <16 x i8>* %526
%528 = bitcast i8* %521 to <16 x i8>*
store <16 x i8> %524, <16 x i8>* %528
%529 = getelementptr i8, i8* %521, i64 16
%530 = bitcast i8* %529 to <16 x i8>*
store <16 x i8> %527, <16 x i8>* %530
%531 = add nuw i64 %519, 32
%532 = add i64 %520, 1
%533 = icmp eq i64 %532, %258
br i1 %533, label %534, label %518
534: ; preds = %518, %516
br i1 %262, label %1816, label %535
535: ; preds = %534
%536 = getelementptr i8, i8* %353, i64 %257
%537 = getelementptr i8, i8* %351, i64 %257
br i1 %265, label %552, label %538
538: ; preds = %465, %535
%539 = phi i64 [ %257, %535 ], [ 0, %465 ]
%540 = getelementptr i8, i8* %351, i64 %266
%541 = getelementptr i8, i8* %353, i64 %266
br label %542
542: ; preds = %542, %538
%543 = phi i64 [ %539, %538 ], [ %549, %542 ]
%544 = getelementptr i8, i8* %351, i64 %543
%545 = getelementptr i8, i8* %353, i64 %543
%546 = bitcast i8* %545 to <8 x i8>*
%547 = load <8 x i8>, <8 x i8>* %546
%548 = bitcast i8* %544 to <8 x i8>*
store <8 x i8> %547, <8 x i8>* %548
%549 = add nuw i64 %543, 8
%550 = icmp eq i64 %549, %266
br i1 %550, label %551, label %542
551: ; preds = %542
br i1 %268, label %1816, label %552
552: ; preds = %461, %460, %535, %551
%553 = phi i8* [ %351, %460 ], [ %351, %461 ], [ %537, %535 ], [ %540, %551 ]
%554 = phi i8* [ %353, %460 ], [ %353, %461 ], [ %536, %535 ], [ %541, %551 ]
%555 = phi i32 [ 0, %460 ], [ 0, %461 ], [ %263, %535 ], [ %267, %551 ]
%556 = sub i32 %21, %555
%557 = xor i32 %555, -1
%558 = add i32 %21, %557
%559 = and i32 %556, 7
%560 = icmp eq i32 %559, 0
br i1 %560, label %572, label %561
561: ; preds = %552, %561
%562 = phi i8* [ %568, %561 ], [ %553, %552 ]
%563 = phi i8* [ %566, %561 ], [ %554, %552 ]
%564 = phi i32 [ %569, %561 ], [ %555, %552 ]
%565 = phi i32 [ %570, %561 ], [ 0, %552 ]
%566 = getelementptr inbounds i8, i8* %563, i64 1
%567 = load i8, i8* %563
%568 = getelementptr inbounds i8, i8* %562, i64 1
store i8 %567, i8* %562
%569 = add nuw nsw i32 %564, 1
%570 = add i32 %565, 1
%571 = icmp eq i32 %570, %559
br i1 %571, label %572, label %561
572: ; preds = %561, %552
%573 = phi i8* [ %553, %552 ], [ %568, %561 ]
%574 = phi i8* [ %554, %552 ], [ %566, %561 ]
%575 = phi i32 [ %555, %552 ], [ %569, %561 ]
%576 = icmp ult i32 %558, 7
br i1 %576, label %1816, label %577
577: ; preds = %572, %577
%578 = phi i8* [ %604, %577 ], [ %573, %572 ]
%579 = phi i8* [ %602, %577 ], [ %574, %572 ]
%580 = phi i32 [ %605, %577 ], [ %575, %572 ]
%581 = getelementptr inbounds i8, i8* %579, i64 1
%582 = load i8, i8* %579
%583 = getelementptr inbounds i8, i8* %578, i64 1
store i8 %582, i8* %578
%584 = getelementptr inbounds i8, i8* %579, i64 2
%585 = load i8, i8* %581
%586 = getelementptr inbounds i8, i8* %578, i64 2
store i8 %585, i8* %583
%587 = getelementptr inbounds i8, i8* %579, i64 3
%588 = load i8, i8* %584
%589 = getelementptr inbounds i8, i8* %578, i64 3
store i8 %588, i8* %586
%590 = getelementptr inbounds i8, i8* %579, i64 4
%591 = load i8, i8* %587
%592 = getelementptr inbounds i8, i8* %578, i64 4
store i8 %591, i8* %589
%593 = getelementptr inbounds i8, i8* %579, i64 5
%594 = load i8, i8* %590
%595 = getelementptr inbounds i8, i8* %578, i64 5
store i8 %594, i8* %592
%596 = getelementptr inbounds i8, i8* %579, i64 6
%597 = load i8, i8* %593
%598 = getelementptr inbounds i8, i8* %578, i64 6
store i8 %597, i8* %595
%599 = getelementptr inbounds i8, i8* %579, i64 7
%600 = load i8, i8* %596
%601 = getelementptr inbounds i8, i8* %578, i64 7
store i8 %600, i8* %598
%602 = getelementptr inbounds i8, i8* %579, i64 8
%603 = load i8, i8* %599
%604 = getelementptr inbounds i8, i8* %578, i64 8
store i8 %603, i8* %601
%605 = add nuw nsw i32 %580, 8
%606 = icmp eq i32 %605, %21
br i1 %606, label %1816, label %577
607: ; preds = %452, %742, %431, %355
%608 = phi i8* [ %353, %355 ], [ %363, %431 ], [ %453, %452 ], [ %767, %742 ]
%609 = phi i8* [ %351, %355 ], [ %362, %431 ], [ %454, %452 ], [ %769, %742 ]
br i1 %18, label %610, label %1816
610: ; preds = %607
br i1 %239, label %711, label %611
611: ; preds = %610
%612 = getelementptr i8, i8* %609, i64 %40
%613 = getelementptr i8, i8* %608, i64 %40
%614 = icmp ult i8* %609, %613
%615 = icmp ult i8* %608, %612
%616 = and i1 %614, %615
%617 = icmp ult i8* %609, %333
%618 = icmp ult i8* %332, %612
%619 = and i1 %617, %618
%620 = or i1 %616, %619
br i1 %620, label %711, label %621
621: ; preds = %611
br i1 %240, label %692, label %622
622: ; preds = %621
br i1 %243, label %666, label %623
623: ; preds = %622, %623
%624 = phi i64 [ %663, %623 ], [ 0, %622 ]
%625 = phi i64 [ %664, %623 ], [ 0, %622 ]
%626 = getelementptr i8, i8* %351, i64 %624
%627 = getelementptr i8, i8* %609, i64 %624
%628 = getelementptr i8, i8* %608, i64 %624
%629 = bitcast i8* %628 to <16 x i8>*
%630 = load <16 x i8>, <16 x i8>* %629
%631 = getelementptr i8, i8* %628, i64 16
%632 = bitcast i8* %631 to <16 x i8>*
%633 = load <16 x i8>, <16 x i8>* %632
%634 = bitcast i8* %626 to <16 x i8>*
%635 = load <16 x i8>, <16 x i8>* %634
%636 = getelementptr i8, i8* %626, i64 16
%637 = bitcast i8* %636 to <16 x i8>*
%638 = load <16 x i8>, <16 x i8>* %637
%639 = add <16 x i8> %635, %630
%640 = add <16 x i8> %638, %633
%641 = bitcast i8* %627 to <16 x i8>*
store <16 x i8> %639, <16 x i8>* %641
%642 = getelementptr i8, i8* %627, i64 16
%643 = bitcast i8* %642 to <16 x i8>*
store <16 x i8> %640, <16 x i8>* %643
%644 = or i64 %624, 32
%645 = getelementptr i8, i8* %351, i64 %644
%646 = getelementptr i8, i8* %609, i64 %644
%647 = getelementptr i8, i8* %608, i64 %644
%648 = bitcast i8* %647 to <16 x i8>*
%649 = load <16 x i8>, <16 x i8>* %648
%650 = getelementptr i8, i8* %647, i64 16
%651 = bitcast i8* %650 to <16 x i8>*
%652 = load <16 x i8>, <16 x i8>* %651
%653 = bitcast i8* %645 to <16 x i8>*
%654 = load <16 x i8>, <16 x i8>* %653
%655 = getelementptr i8, i8* %645, i64 16
%656 = bitcast i8* %655 to <16 x i8>*
%657 = load <16 x i8>, <16 x i8>* %656
%658 = add <16 x i8> %654, %649
%659 = add <16 x i8> %657, %652
%660 = bitcast i8* %646 to <16 x i8>*
store <16 x i8> %658, <16 x i8>* %660
%661 = getelementptr i8, i8* %646, i64 16
%662 = bitcast i8* %661 to <16 x i8>*
store <16 x i8> %659, <16 x i8>* %662
%663 = add nuw i64 %624, 64
%664 = add i64 %625, 2
%665 = icmp eq i64 %664, %244
br i1 %665, label %666, label %623
666: ; preds = %623, %622
%667 = phi i64 [ 0, %622 ], [ %663, %623 ]
br i1 %245, label %687, label %668
668: ; preds = %666
%669 = getelementptr i8, i8* %351, i64 %667
%670 = getelementptr i8, i8* %609, i64 %667
%671 = getelementptr i8, i8* %608, i64 %667
%672 = bitcast i8* %671 to <16 x i8>*
%673 = load <16 x i8>, <16 x i8>* %672
%674 = getelementptr i8, i8* %671, i64 16
%675 = bitcast i8* %674 to <16 x i8>*
%676 = load <16 x i8>, <16 x i8>* %675
%677 = bitcast i8* %669 to <16 x i8>*
%678 = load <16 x i8>, <16 x i8>* %677
%679 = getelementptr i8, i8* %669, i64 16
%680 = bitcast i8* %679 to <16 x i8>*
%681 = load <16 x i8>, <16 x i8>* %680
%682 = add <16 x i8> %678, %673
%683 = add <16 x i8> %681, %676
%684 = bitcast i8* %670 to <16 x i8>*
store <16 x i8> %682, <16 x i8>* %684
%685 = getelementptr i8, i8* %670, i64 16
%686 = bitcast i8* %685 to <16 x i8>*
store <16 x i8> %683, <16 x i8>* %686
br label %687
687: ; preds = %666, %668
br i1 %246, label %1816, label %688
688: ; preds = %687
%689 = getelementptr i8, i8* %608, i64 %241
%690 = getelementptr i8, i8* %609, i64 %241
%691 = getelementptr i8, i8* %351, i64 %241
br i1 %250, label %711, label %692
692: ; preds = %621, %688
%693 = phi i64 [ %241, %688 ], [ 0, %621 ]
%694 = getelementptr i8, i8* %351, i64 %251
%695 = getelementptr i8, i8* %609, i64 %251
%696 = getelementptr i8, i8* %608, i64 %251
br label %697
697: ; preds = %697, %692
%698 = phi i64 [ %693, %692 ], [ %708, %697 ]
%699 = getelementptr i8, i8* %351, i64 %698
%700 = getelementptr i8, i8* %609, i64 %698
%701 = getelementptr i8, i8* %608, i64 %698
%702 = bitcast i8* %701 to <8 x i8>*
%703 = load <8 x i8>, <8 x i8>* %702
%704 = bitcast i8* %699 to <8 x i8>*
%705 = load <8 x i8>, <8 x i8>* %704
%706 = add <8 x i8> %705, %703
%707 = bitcast i8* %700 to <8 x i8>*
store <8 x i8> %706, <8 x i8>* %707
%708 = add nuw i64 %698, 8
%709 = icmp eq i64 %708, %251
br i1 %709, label %710, label %697
710: ; preds = %697
br i1 %254, label %1816, label %711
711: ; preds = %611, %610, %688, %710
%712 = phi i8* [ %351, %610 ], [ %351, %611 ], [ %691, %688 ], [ %694, %710 ]
%713 = phi i8* [ %609, %610 ], [ %609, %611 ], [ %690, %688 ], [ %695, %710 ]
%714 = phi i8* [ %608, %610 ], [ %608, %611 ], [ %689, %688 ], [ %696, %710 ]
%715 = phi i32 [ %11, %610 ], [ %11, %611 ], [ %248, %688 ], [ %253, %710 ]
%716 = sub i32 %9, %715
%717 = xor i32 %715, -1
%718 = add i32 %9, %717
%719 = and i32 %716, 3
%720 = icmp eq i32 %719, 0
br i1 %720, label %736, label %721
721: ; preds = %711, %721
%722 = phi i8* [ %729, %721 ], [ %712, %711 ]
%723 = phi i8* [ %732, %721 ], [ %713, %711 ]
%724 = phi i8* [ %727, %721 ], [ %714, %711 ]
%725 = phi i32 [ %733, %721 ], [ %715, %711 ]
%726 = phi i32 [ %734, %721 ], [ 0, %711 ]
%727 = getelementptr inbounds i8, i8* %724, i64 1
%728 = load i8, i8* %724
%729 = getelementptr inbounds i8, i8* %722, i64 1
%730 = load i8, i8* %722
%731 = add i8 %730, %728
%732 = getelementptr inbounds i8, i8* %723, i64 1
store i8 %731, i8* %723
%733 = add nsw i32 %725, 1
%734 = add i32 %726, 1
%735 = icmp eq i32 %734, %719
br i1 %735, label %736, label %721
736: ; preds = %721, %711
%737 = phi i8* [ %712, %711 ], [ %729, %721 ]
%738 = phi i8* [ %713, %711 ], [ %732, %721 ]
%739 = phi i8* [ %714, %711 ], [ %727, %721 ]
%740 = phi i32 [ %715, %711 ], [ %733, %721 ]
%741 = icmp ult i32 %718, 3
br i1 %741, label %1816, label %772
742: ; preds = %452, %742
%743 = phi i8* [ %769, %742 ], [ %455, %452 ]
%744 = phi i8* [ %767, %742 ], [ %456, %452 ]
%745 = phi i32 [ %770, %742 ], [ %457, %452 ]
%746 = getelementptr inbounds i8, i8* %744, i64 1
%747 = load i8, i8* %744
%748 = getelementptr inbounds i8, i8* %743, i64 1
store i8 %747, i8* %743
%749 = getelementptr inbounds i8, i8* %744, i64 2
%750 = load i8, i8* %746
%751 = getelementptr inbounds i8, i8* %743, i64 2
store i8 %750, i8* %748
%752 = getelementptr inbounds i8, i8* %744, i64 3
%753 = load i8, i8* %749
%754 = getelementptr inbounds i8, i8* %743, i64 3
store i8 %753, i8* %751
%755 = getelementptr inbounds i8, i8* %744, i64 4
%756 = load i8, i8* %752
%757 = getelementptr inbounds i8, i8* %743, i64 4
store i8 %756, i8* %754
%758 = getelementptr inbounds i8, i8* %744, i64 5
%759 = load i8, i8* %755
%760 = getelementptr inbounds i8, i8* %743, i64 5
store i8 %759, i8* %757
%761 = getelementptr inbounds i8, i8* %744, i64 6
%762 = load i8, i8* %758
%763 = getelementptr inbounds i8, i8* %743, i64 6
store i8 %762, i8* %760
%764 = getelementptr inbounds i8, i8* %744, i64 7
%765 = load i8, i8* %761
%766 = getelementptr inbounds i8, i8* %743, i64 7
store i8 %765, i8* %763
%767 = getelementptr inbounds i8, i8* %744, i64 8
%768 = load i8, i8* %764
%769 = getelementptr inbounds i8, i8* %743, i64 8
store i8 %768, i8* %766
%770 = add nuw nsw i32 %745, 8
%771 = icmp eq i32 %770, %20
br i1 %771, label %607, label %742
772: ; preds = %736, %772
%773 = phi i8* [ %797, %772 ], [ %737, %736 ]
%774 = phi i8* [ %800, %772 ], [ %738, %736 ]
%775 = phi i8* [ %795, %772 ], [ %739, %736 ]
%776 = phi i32 [ %801, %772 ], [ %740, %736 ]
%777 = getelementptr inbounds i8, i8* %775, i64 1
%778 = load i8, i8* %775
%779 = getelementptr inbounds i8, i8* %773, i64 1
%780 = load i8, i8* %773
%781 = add i8 %780, %778
%782 = getelementptr inbounds i8, i8* %774, i64 1
store i8 %781, i8* %774
%783 = getelementptr inbounds i8, i8* %775, i64 2
%784 = load i8, i8* %777
%785 = getelementptr inbounds i8, i8* %773, i64 2
%786 = load i8, i8* %779
%787 = add i8 %786, %784
%788 = getelementptr inbounds i8, i8* %774, i64 2
store i8 %787, i8* %782
%789 = getelementptr inbounds i8, i8* %775, i64 3
%790 = load i8, i8* %783
%791 = getelementptr inbounds i8, i8* %773, i64 3
%792 = load i8, i8* %785
%793 = add i8 %792, %790
%794 = getelementptr inbounds i8, i8* %774, i64 3
store i8 %793, i8* %788
%795 = getelementptr inbounds i8, i8* %775, i64 4
%796 = load i8, i8* %789
%797 = getelementptr inbounds i8, i8* %773, i64 4
%798 = load i8, i8* %791
%799 = add i8 %798, %796
%800 = getelementptr inbounds i8, i8* %774, i64 4
store i8 %799, i8* %794
%801 = add nsw i32 %776, 4
%802 = icmp eq i32 %801, %9
br i1 %802, label %1816, label %772
803: ; preds = %269
%804 = icmp eq i64 %270, 0
br i1 %804, label %933, label %805
805: ; preds = %803
br i1 %19, label %806, label %1816
806: ; preds = %805
br i1 %200, label %902, label %807
807: ; preds = %806
%808 = icmp ult i8* %303, %308
%809 = icmp ult i8* %307, %304
%810 = and i1 %808, %809
%811 = or i1 %810, %203
br i1 %811, label %902, label %812
812: ; preds = %807
br i1 %204, label %883, label %813
813: ; preds = %812
br i1 %207, label %857, label %814
814: ; preds = %813, %814
%815 = phi i64 [ %854, %814 ], [ 0, %813 ]
%816 = phi i64 [ %855, %814 ], [ 0, %813 ]
%817 = getelementptr i8, i8* %352, i64 %815
%818 = getelementptr i8, i8* %351, i64 %815
%819 = getelementptr i8, i8* %353, i64 %815
%820 = bitcast i8* %819 to <16 x i8>*
%821 = load <16 x i8>, <16 x i8>* %820
%822 = getelementptr i8, i8* %819, i64 16
%823 = bitcast i8* %822 to <16 x i8>*
%824 = load <16 x i8>, <16 x i8>* %823
%825 = bitcast i8* %817 to <16 x i8>*
%826 = load <16 x i8>, <16 x i8>* %825
%827 = getelementptr i8, i8* %817, i64 16
%828 = bitcast i8* %827 to <16 x i8>*
%829 = load <16 x i8>, <16 x i8>* %828
%830 = add <16 x i8> %826, %821
%831 = add <16 x i8> %829, %824
%832 = bitcast i8* %818 to <16 x i8>*
store <16 x i8> %830, <16 x i8>* %832
%833 = getelementptr i8, i8* %818, i64 16
%834 = bitcast i8* %833 to <16 x i8>*
store <16 x i8> %831, <16 x i8>* %834
%835 = or i64 %815, 32
%836 = getelementptr i8, i8* %352, i64 %835
%837 = getelementptr i8, i8* %351, i64 %835
%838 = getelementptr i8, i8* %353, i64 %835
%839 = bitcast i8* %838 to <16 x i8>*
%840 = load <16 x i8>, <16 x i8>* %839
%841 = getelementptr i8, i8* %838, i64 16
%842 = bitcast i8* %841 to <16 x i8>*
%843 = load <16 x i8>, <16 x i8>* %842
%844 = bitcast i8* %836 to <16 x i8>*
%845 = load <16 x i8>, <16 x i8>* %844
%846 = getelementptr i8, i8* %836, i64 16
%847 = bitcast i8* %846 to <16 x i8>*
%848 = load <16 x i8>, <16 x i8>* %847
%849 = add <16 x i8> %845, %840
%850 = add <16 x i8> %848, %843
%851 = bitcast i8* %837 to <16 x i8>*
store <16 x i8> %849, <16 x i8>* %851
%852 = getelementptr i8, i8* %837, i64 16
%853 = bitcast i8* %852 to <16 x i8>*
store <16 x i8> %850, <16 x i8>* %853
%854 = add nuw i64 %815, 64
%855 = add i64 %816, 2
%856 = icmp eq i64 %855, %208
br i1 %856, label %857, label %814
857: ; preds = %814, %813
%858 = phi i64 [ 0, %813 ], [ %854, %814 ]
br i1 %209, label %878, label %859
859: ; preds = %857
%860 = getelementptr i8, i8* %352, i64 %858
%861 = getelementptr i8, i8* %351, i64 %858
%862 = getelementptr i8, i8* %353, i64 %858
%863 = bitcast i8* %862 to <16 x i8>*
%864 = load <16 x i8>, <16 x i8>* %863
%865 = getelementptr i8, i8* %862, i64 16
%866 = bitcast i8* %865 to <16 x i8>*
%867 = load <16 x i8>, <16 x i8>* %866
%868 = bitcast i8* %860 to <16 x i8>*
%869 = load <16 x i8>, <16 x i8>* %868
%870 = getelementptr i8, i8* %860, i64 16
%871 = bitcast i8* %870 to <16 x i8>*
%872 = load <16 x i8>, <16 x i8>* %871
%873 = add <16 x i8> %869, %864
%874 = add <16 x i8> %872, %867
%875 = bitcast i8* %861 to <16 x i8>*
store <16 x i8> %873, <16 x i8>* %875
%876 = getelementptr i8, i8* %861, i64 16
%877 = bitcast i8* %876 to <16 x i8>*
store <16 x i8> %874, <16 x i8>* %877
br label %878
878: ; preds = %857, %859
br i1 %210, label %1816, label %879
879: ; preds = %878
%880 = getelementptr i8, i8* %353, i64 %205
%881 = getelementptr i8, i8* %351, i64 %205
%882 = getelementptr i8, i8* %352, i64 %205
br i1 %213, label %902, label %883
883: ; preds = %812, %879
%884 = phi i64 [ %205, %879 ], [ 0, %812 ]
%885 = getelementptr i8, i8* %352, i64 %214
%886 = getelementptr i8, i8* %351, i64 %214
%887 = getelementptr i8, i8* %353, i64 %214
br label %888
888: ; preds = %888, %883
%889 = phi i64 [ %884, %883 ], [ %899, %888 ]
%890 = getelementptr i8, i8* %352, i64 %889
%891 = getelementptr i8, i8* %351, i64 %889
%892 = getelementptr i8, i8* %353, i64 %889
%893 = bitcast i8* %892 to <8 x i8>*
%894 = load <8 x i8>, <8 x i8>* %893
%895 = bitcast i8* %890 to <8 x i8>*
%896 = load <8 x i8>, <8 x i8>* %895
%897 = add <8 x i8> %896, %894
%898 = bitcast i8* %891 to <8 x i8>*
store <8 x i8> %897, <8 x i8>* %898
%899 = add nuw i64 %889, 8
%900 = icmp eq i64 %899, %214
br i1 %900, label %901, label %888
901: ; preds = %888
br i1 %216, label %1816, label %902
902: ; preds = %807, %806, %879, %901
%903 = phi i8* [ %352, %806 ], [ %352, %807 ], [ %882, %879 ], [ %885, %901 ]
%904 = phi i8* [ %351, %806 ], [ %351, %807 ], [ %881, %879 ], [ %886, %901 ]
%905 = phi i8* [ %353, %806 ], [ %353, %807 ], [ %880, %879 ], [ %887, %901 ]
%906 = phi i32 [ 0, %806 ], [ 0, %807 ], [ %211, %879 ], [ %215, %901 ]
%907 = sub i32 %21, %906
%908 = xor i32 %906, -1
%909 = add i32 %21, %908
%910 = and i32 %907, 3
%911 = icmp eq i32 %910, 0
br i1 %911, label %927, label %912
912: ; preds = %902, %912
%913 = phi i8* [ %920, %912 ], [ %903, %902 ]
%914 = phi i8* [ %923, %912 ], [ %904, %902 ]
%915 = phi i8* [ %918, %912 ], [ %905, %902 ]
%916 = phi i32 [ %924, %912 ], [ %906, %902 ]
%917 = phi i32 [ %925, %912 ], [ 0, %902 ]
%918 = getelementptr inbounds i8, i8* %915, i64 1
%919 = load i8, i8* %915
%920 = getelementptr inbounds i8, i8* %913, i64 1
%921 = load i8, i8* %913
%922 = add i8 %921, %919
%923 = getelementptr inbounds i8, i8* %914, i64 1
store i8 %922, i8* %914
%924 = add nuw nsw i32 %916, 1
%925 = add i32 %917, 1
%926 = icmp eq i32 %925, %910
br i1 %926, label %927, label %912
927: ; preds = %912, %902
%928 = phi i8* [ %903, %902 ], [ %920, %912 ]
%929 = phi i8* [ %904, %902 ], [ %923, %912 ]
%930 = phi i8* [ %905, %902 ], [ %918, %912 ]
%931 = phi i32 [ %906, %902 ], [ %924, %912 ]
%932 = icmp ult i32 %909, 3
br i1 %932, label %1816, label %1081
933: ; preds = %803
br i1 %19, label %934, label %1816
934: ; preds = %933
br i1 %217, label %1026, label %935
935: ; preds = %934
%936 = icmp ult i8* %312, %318
%937 = icmp ult i8* %317, %313
%938 = and i1 %936, %937
br i1 %938, label %1026, label %939
939: ; preds = %935
br i1 %218, label %1012, label %940
940: ; preds = %939
br i1 %221, label %990, label %941
941: ; preds = %940, %941
%942 = phi i64 [ %987, %941 ], [ 0, %940 ]
%943 = phi i64 [ %988, %941 ], [ 0, %940 ]
%944 = getelementptr i8, i8* %351, i64 %942
%945 = getelementptr i8, i8* %353, i64 %942
%946 = bitcast i8* %945 to <16 x i8>*
%947 = load <16 x i8>, <16 x i8>* %946
%948 = getelementptr i8, i8* %945, i64 16
%949 = bitcast i8* %948 to <16 x i8>*
%950 = load <16 x i8>, <16 x i8>* %949
%951 = bitcast i8* %944 to <16 x i8>*
store <16 x i8> %947, <16 x i8>* %951
%952 = getelementptr i8, i8* %944, i64 16
%953 = bitcast i8* %952 to <16 x i8>*
store <16 x i8> %950, <16 x i8>* %953
%954 = or i64 %942, 32
%955 = getelementptr i8, i8* %351, i64 %954
%956 = getelementptr i8, i8* %353, i64 %954
%957 = bitcast i8* %956 to <16 x i8>*
%958 = load <16 x i8>, <16 x i8>* %957
%959 = getelementptr i8, i8* %956, i64 16
%960 = bitcast i8* %959 to <16 x i8>*
%961 = load <16 x i8>, <16 x i8>* %960
%962 = bitcast i8* %955 to <16 x i8>*
store <16 x i8> %958, <16 x i8>* %962
%963 = getelementptr i8, i8* %955, i64 16
%964 = bitcast i8* %963 to <16 x i8>*
store <16 x i8> %961, <16 x i8>* %964
%965 = or i64 %942, 64
%966 = getelementptr i8, i8* %351, i64 %965
%967 = getelementptr i8, i8* %353, i64 %965
%968 = bitcast i8* %967 to <16 x i8>*
%969 = load <16 x i8>, <16 x i8>* %968
%970 = getelementptr i8, i8* %967, i64 16
%971 = bitcast i8* %970 to <16 x i8>*
%972 = load <16 x i8>, <16 x i8>* %971
%973 = bitcast i8* %966 to <16 x i8>*
store <16 x i8> %969, <16 x i8>* %973
%974 = getelementptr i8, i8* %966, i64 16
%975 = bitcast i8* %974 to <16 x i8>*
store <16 x i8> %972, <16 x i8>* %975
%976 = or i64 %942, 96
%977 = getelementptr i8, i8* %351, i64 %976
%978 = getelementptr i8, i8* %353, i64 %976
%979 = bitcast i8* %978 to <16 x i8>*
%980 = load <16 x i8>, <16 x i8>* %979
%981 = getelementptr i8, i8* %978, i64 16
%982 = bitcast i8* %981 to <16 x i8>*
%983 = load <16 x i8>, <16 x i8>* %982
%984 = bitcast i8* %977 to <16 x i8>*
store <16 x i8> %980, <16 x i8>* %984
%985 = getelementptr i8, i8* %977, i64 16
%986 = bitcast i8* %985 to <16 x i8>*
store <16 x i8> %983, <16 x i8>* %986
%987 = add nuw i64 %942, 128
%988 = add i64 %943, 4
%989 = icmp eq i64 %988, %222
br i1 %989, label %990, label %941
990: ; preds = %941, %940
%991 = phi i64 [ 0, %940 ], [ %987, %941 ]
br i1 %223, label %1008, label %992
992: ; preds = %990, %992
%993 = phi i64 [ %1005, %992 ], [ %991, %990 ]
%994 = phi i64 [ %1006, %992 ], [ 0, %990 ]
%995 = getelementptr i8, i8* %351, i64 %993
%996 = getelementptr i8, i8* %353, i64 %993
%997 = bitcast i8* %996 to <16 x i8>*
%998 = load <16 x i8>, <16 x i8>* %997
%999 = getelementptr i8, i8* %996, i64 16
%1000 = bitcast i8* %999 to <16 x i8>*
%1001 = load <16 x i8>, <16 x i8>* %1000
%1002 = bitcast i8* %995 to <16 x i8>*
store <16 x i8> %998, <16 x i8>* %1002
%1003 = getelementptr i8, i8* %995, i64 16
%1004 = bitcast i8* %1003 to <16 x i8>*
store <16 x i8> %1001, <16 x i8>* %1004
%1005 = add nuw i64 %993, 32
%1006 = add i64 %994, 1
%1007 = icmp eq i64 %1006, %220
br i1 %1007, label %1008, label %992
1008: ; preds = %992, %990
br i1 %224, label %1816, label %1009
1009: ; preds = %1008
%1010 = getelementptr i8, i8* %353, i64 %219
%1011 = getelementptr i8, i8* %351, i64 %219
br i1 %227, label %1026, label %1012
1012: ; preds = %939, %1009
%1013 = phi i64 [ %219, %1009 ], [ 0, %939 ]
%1014 = getelementptr i8, i8* %351, i64 %228
%1015 = getelementptr i8, i8* %353, i64 %228
br label %1016
1016: ; preds = %1016, %1012
%1017 = phi i64 [ %1013, %1012 ], [ %1023, %1016 ]
%1018 = getelementptr i8, i8* %351, i64 %1017
%1019 = getelementptr i8, i8* %353, i64 %1017
%1020 = bitcast i8* %1019 to <8 x i8>*
%1021 = load <8 x i8>, <8 x i8>* %1020
%1022 = bitcast i8* %1018 to <8 x i8>*
store <8 x i8> %1021, <8 x i8>* %1022
%1023 = add nuw i64 %1017, 8
%1024 = icmp eq i64 %1023, %228
br i1 %1024, label %1025, label %1016
1025: ; preds = %1016
br i1 %230, label %1816, label %1026
1026: ; preds = %935, %934, %1009, %1025
%1027 = phi i8* [ %351, %934 ], [ %351, %935 ], [ %1011, %1009 ], [ %1014, %1025 ]
%1028 = phi i8* [ %353, %934 ], [ %353, %935 ], [ %1010, %1009 ], [ %1015, %1025 ]
%1029 = phi i32 [ 0, %934 ], [ 0, %935 ], [ %225, %1009 ], [ %229, %1025 ]
%1030 = sub i32 %21, %1029
%1031 = xor i32 %1029, -1
%1032 = add i32 %21, %1031
%1033 = and i32 %1030, 7
%1034 = icmp eq i32 %1033, 0
br i1 %1034, label %1046, label %1035
1035: ; preds = %1026, %1035
%1036 = phi i8* [ %1042, %1035 ], [ %1027, %1026 ]
%1037 = phi i8* [ %1040, %1035 ], [ %1028, %1026 ]
%1038 = phi i32 [ %1043, %1035 ], [ %1029, %1026 ]
%1039 = phi i32 [ %1044, %1035 ], [ 0, %1026 ]
%1040 = getelementptr inbounds i8, i8* %1037, i64 1
%1041 = load i8, i8* %1037
%1042 = getelementptr inbounds i8, i8* %1036, i64 1
store i8 %1041, i8* %1036
%1043 = add nuw nsw i32 %1038, 1
%1044 = add i32 %1039, 1
%1045 = icmp eq i32 %1044, %1033
br i1 %1045, label %1046, label %1035
1046: ; preds = %1035, %1026
%1047 = phi i8* [ %1027, %1026 ], [ %1042, %1035 ]
%1048 = phi i8* [ %1028, %1026 ], [ %1040, %1035 ]
%1049 = phi i32 [ %1029, %1026 ], [ %1043, %1035 ]
%1050 = icmp ult i32 %1032, 7
br i1 %1050, label %1816, label %1051
1051: ; preds = %1046, %1051
%1052 = phi i8* [ %1078, %1051 ], [ %1047, %1046 ]
%1053 = phi i8* [ %1076, %1051 ], [ %1048, %1046 ]
%1054 = phi i32 [ %1079, %1051 ], [ %1049, %1046 ]
%1055 = getelementptr inbounds i8, i8* %1053, i64 1
%1056 = load i8, i8* %1053
%1057 = getelementptr inbounds i8, i8* %1052, i64 1
store i8 %1056, i8* %1052
%1058 = getelementptr inbounds i8, i8* %1053, i64 2
%1059 = load i8, i8* %1055
%1060 = getelementptr inbounds i8, i8* %1052, i64 2
store i8 %1059, i8* %1057
%1061 = getelementptr inbounds i8, i8* %1053, i64 3
%1062 = load i8, i8* %1058
%1063 = getelementptr inbounds i8, i8* %1052, i64 3
store i8 %1062, i8* %1060
%1064 = getelementptr inbounds i8, i8* %1053, i64 4
%1065 = load i8, i8* %1061
%1066 = getelementptr inbounds i8, i8* %1052, i64 4
store i8 %1065, i8* %1063
%1067 = getelementptr inbounds i8, i8* %1053, i64 5
%1068 = load i8, i8* %1064
%1069 = getelementptr inbounds i8, i8* %1052, i64 5
store i8 %1068, i8* %1066
%1070 = getelementptr inbounds i8, i8* %1053, i64 6
%1071 = load i8, i8* %1067
%1072 = getelementptr inbounds i8, i8* %1052, i64 6
store i8 %1071, i8* %1069
%1073 = getelementptr inbounds i8, i8* %1053, i64 7
%1074 = load i8, i8* %1070
%1075 = getelementptr inbounds i8, i8* %1052, i64 7
store i8 %1074, i8* %1072
%1076 = getelementptr inbounds i8, i8* %1053, i64 8
%1077 = load i8, i8* %1073
%1078 = getelementptr inbounds i8, i8* %1052, i64 8
store i8 %1077, i8* %1075
%1079 = add nuw nsw i32 %1054, 8
%1080 = icmp eq i32 %1079, %21
br i1 %1080, label %1816, label %1051
1081: ; preds = %927, %1081
%1082 = phi i8* [ %1106, %1081 ], [ %928, %927 ]
%1083 = phi i8* [ %1109, %1081 ], [ %929, %927 ]
%1084 = phi i8* [ %1104, %1081 ], [ %930, %927 ]
%1085 = phi i32 [ %1110, %1081 ], [ %931, %927 ]
%1086 = getelementptr inbounds i8, i8* %1084, i64 1
%1087 = load i8, i8* %1084
%1088 = getelementptr inbounds i8, i8* %1082, i64 1
%1089 = load i8, i8* %1082
%1090 = add i8 %1089, %1087
%1091 = getelementptr inbounds i8, i8* %1083, i64 1
store i8 %1090, i8* %1083
%1092 = getelementptr inbounds i8, i8* %1084, i64 2
%1093 = load i8, i8* %1086
%1094 = getelementptr inbounds i8, i8* %1082, i64 2
%1095 = load i8, i8* %1088
%1096 = add i8 %1095, %1093
%1097 = getelementptr inbounds i8, i8* %1083, i64 2
store i8 %1096, i8* %1091
%1098 = getelementptr inbounds i8, i8* %1084, i64 3
%1099 = load i8, i8* %1092
%1100 = getelementptr inbounds i8, i8* %1082, i64 3
%1101 = load i8, i8* %1094
%1102 = add i8 %1101, %1099
%1103 = getelementptr inbounds i8, i8* %1083, i64 3
store i8 %1102, i8* %1097
%1104 = getelementptr inbounds i8, i8* %1084, i64 4
%1105 = load i8, i8* %1098
%1106 = getelementptr inbounds i8, i8* %1082, i64 4
%1107 = load i8, i8* %1100
%1108 = add i8 %1107, %1105
%1109 = getelementptr inbounds i8, i8* %1083, i64 4
store i8 %1108, i8* %1103
%1110 = add nuw nsw i32 %1085, 4
%1111 = icmp eq i32 %1110, %21
br i1 %1111, label %1816, label %1081
1112: ; preds = %269
%1113 = icmp eq i64 %270, 0
br i1 %1113, label %1231, label %1114
1114: ; preds = %1112
br i1 %17, label %1115, label %1543
1115: ; preds = %1114
br i1 %153, label %1196, label %1116
1116: ; preds = %1115
%1117 = icmp ult i8* %274, %279
%1118 = icmp ult i8* %278, %275
%1119 = and i1 %1117, %1118
%1120 = or i1 %1119, %156
br i1 %1120, label %1196, label %1121
1121: ; preds = %1116
%1122 = getelementptr i8, i8* %352, i64 %157
%1123 = getelementptr i8, i8* %351, i64 %157
%1124 = getelementptr i8, i8* %353, i64 %157
br i1 %160, label %1172, label %1125
1125: ; preds = %1121, %1125
%1126 = phi i64 [ %1169, %1125 ], [ 0, %1121 ]
%1127 = phi i64 [ %1170, %1125 ], [ 0, %1121 ]
%1128 = getelementptr i8, i8* %352, i64 %1126
%1129 = getelementptr i8, i8* %351, i64 %1126
%1130 = getelementptr i8, i8* %353, i64 %1126
%1131 = bitcast i8* %1130 to <16 x i8>*
%1132 = load <16 x i8>, <16 x i8>* %1131
%1133 = getelementptr i8, i8* %1130, i64 16
%1134 = bitcast i8* %1133 to <16 x i8>*
%1135 = load <16 x i8>, <16 x i8>* %1134
%1136 = bitcast i8* %1128 to <16 x i8>*
%1137 = load <16 x i8>, <16 x i8>* %1136
%1138 = getelementptr i8, i8* %1128, i64 16
%1139 = bitcast i8* %1138 to <16 x i8>*
%1140 = load <16 x i8>, <16 x i8>* %1139
%1141 = lshr <16 x i8> %1137, <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>
%1142 = lshr <16 x i8> %1140, <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>
%1143 = add <16 x i8> %1141, %1132
%1144 = add <16 x i8> %1142, %1135
%1145 = bitcast i8* %1129 to <16 x i8>*
store <16 x i8> %1143, <16 x i8>* %1145
%1146 = getelementptr i8, i8* %1129, i64 16
%1147 = bitcast i8* %1146 to <16 x i8>*
store <16 x i8> %1144, <16 x i8>* %1147
%1148 = or i64 %1126, 32
%1149 = getelementptr i8, i8* %352, i64 %1148
%1150 = getelementptr i8, i8* %351, i64 %1148
%1151 = getelementptr i8, i8* %353, i64 %1148
%1152 = bitcast i8* %1151 to <16 x i8>*
%1153 = load <16 x i8>, <16 x i8>* %1152
%1154 = getelementptr i8, i8* %1151, i64 16
%1155 = bitcast i8* %1154 to <16 x i8>*
%1156 = load <16 x i8>, <16 x i8>* %1155
%1157 = bitcast i8* %1149 to <16 x i8>*
%1158 = load <16 x i8>, <16 x i8>* %1157
%1159 = getelementptr i8, i8* %1149, i64 16
%1160 = bitcast i8* %1159 to <16 x i8>*
%1161 = load <16 x i8>, <16 x i8>* %1160
%1162 = lshr <16 x i8> %1158, <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>
%1163 = lshr <16 x i8> %1161, <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>
%1164 = add <16 x i8> %1162, %1153
%1165 = add <16 x i8> %1163, %1156
%1166 = bitcast i8* %1150 to <16 x i8>*
store <16 x i8> %1164, <16 x i8>* %1166
%1167 = getelementptr i8, i8* %1150, i64 16
%1168 = bitcast i8* %1167 to <16 x i8>*
store <16 x i8> %1165, <16 x i8>* %1168
%1169 = add nuw i64 %1126, 64
%1170 = add i64 %1127, 2
%1171 = icmp eq i64 %1170, %161
br i1 %1171, label %1172, label %1125
1172: ; preds = %1125, %1121
%1173 = phi i64 [ 0, %1121 ], [ %1169, %1125 ]
br i1 %162, label %1195, label %1174
1174: ; preds = %1172
%1175 = getelementptr i8, i8* %352, i64 %1173
%1176 = getelementptr i8, i8* %351, i64 %1173
%1177 = getelementptr i8, i8* %353, i64 %1173
%1178 = bitcast i8* %1177 to <16 x i8>*
%1179 = load <16 x i8>, <16 x i8>* %1178
%1180 = getelementptr i8, i8* %1177, i64 16
%1181 = bitcast i8* %1180 to <16 x i8>*
%1182 = load <16 x i8>, <16 x i8>* %1181
%1183 = bitcast i8* %1175 to <16 x i8>*
%1184 = load <16 x i8>, <16 x i8>* %1183
%1185 = getelementptr i8, i8* %1175, i64 16
%1186 = bitcast i8* %1185 to <16 x i8>*
%1187 = load <16 x i8>, <16 x i8>* %1186
%1188 = lshr <16 x i8> %1184, <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>
%1189 = lshr <16 x i8> %1187, <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>
%1190 = add <16 x i8> %1188, %1179
%1191 = add <16 x i8> %1189, %1182
%1192 = bitcast i8* %1176 to <16 x i8>*
store <16 x i8> %1190, <16 x i8>* %1192
%1193 = getelementptr i8, i8* %1176, i64 16
%1194 = bitcast i8* %1193 to <16 x i8>*
store <16 x i8> %1191, <16 x i8>* %1194
br label %1195
1195: ; preds = %1172, %1174
br i1 %163, label %1543, label %1196
1196: ; preds = %1116, %1115, %1195
%1197 = phi i8* [ %352, %1116 ], [ %352, %1115 ], [ %1122, %1195 ]
%1198 = phi i8* [ %351, %1116 ], [ %351, %1115 ], [ %1123, %1195 ]
%1199 = phi i8* [ %353, %1116 ], [ %353, %1115 ], [ %1124, %1195 ]
%1200 = phi i32 [ 0, %1116 ], [ 0, %1115 ], [ %158, %1195 ]
%1201 = sub i32 %20, %1200
%1202 = xor i32 %1200, -1
%1203 = add i32 %20, %1202
%1204 = and i32 %1201, 3
%1205 = icmp eq i32 %1204, 0
br i1 %1205, label %1222, label %1206
1206: ; preds = %1196, %1206
%1207 = phi i8* [ %1214, %1206 ], [ %1197, %1196 ]
%1208 = phi i8* [ %1218, %1206 ], [ %1198, %1196 ]
%1209 = phi i8* [ %1212, %1206 ], [ %1199, %1196 ]
%1210 = phi i32 [ %1219, %1206 ], [ %1200, %1196 ]
%1211 = phi i32 [ %1220, %1206 ], [ 0, %1196 ]
%1212 = getelementptr inbounds i8, i8* %1209, i64 1
%1213 = load i8, i8* %1209
%1214 = getelementptr inbounds i8, i8* %1207, i64 1
%1215 = load i8, i8* %1207
%1216 = lshr i8 %1215, 1
%1217 = add i8 %1216, %1213
%1218 = getelementptr inbounds i8, i8* %1208, i64 1
store i8 %1217, i8* %1208
%1219 = add nuw nsw i32 %1210, 1
%1220 = add i32 %1211, 1
%1221 = icmp eq i32 %1220, %1204
br i1 %1221, label %1222, label %1206
1222: ; preds = %1206, %1196
%1223 = phi i8* [ undef, %1196 ], [ %1212, %1206 ]
%1224 = phi i8* [ undef, %1196 ], [ %1214, %1206 ]
%1225 = phi i8* [ undef, %1196 ], [ %1218, %1206 ]
%1226 = phi i8* [ %1197, %1196 ], [ %1214, %1206 ]
%1227 = phi i8* [ %1198, %1196 ], [ %1218, %1206 ]
%1228 = phi i8* [ %1199, %1196 ], [ %1212, %1206 ]
%1229 = phi i32 [ %1200, %1196 ], [ %1219, %1206 ]
%1230 = icmp ult i32 %1203, 3
br i1 %1230, label %1543, label %1668
1231: ; preds = %1112
br i1 %17, label %1232, label %1335
1232: ; preds = %1231
br i1 %176, label %1308, label %1233
1233: ; preds = %1232
%1234 = icmp ult i8* %288, %294
%1235 = icmp ult i8* %293, %289
%1236 = and i1 %1234, %1235
br i1 %1236, label %1308, label %1237
1237: ; preds = %1233
%1238 = getelementptr i8, i8* %351, i64 %177
%1239 = getelementptr i8, i8* %353, i64 %177
br i1 %180, label %1289, label %1240
1240: ; preds = %1237, %1240
%1241 = phi i64 [ %1286, %1240 ], [ 0, %1237 ]
%1242 = phi i64 [ %1287, %1240 ], [ 0, %1237 ]
%1243 = getelementptr i8, i8* %351, i64 %1241
%1244 = getelementptr i8, i8* %353, i64 %1241
%1245 = bitcast i8* %1244 to <16 x i8>*
%1246 = load <16 x i8>, <16 x i8>* %1245
%1247 = getelementptr i8, i8* %1244, i64 16
%1248 = bitcast i8* %1247 to <16 x i8>*
%1249 = load <16 x i8>, <16 x i8>* %1248
%1250 = bitcast i8* %1243 to <16 x i8>*
store <16 x i8> %1246, <16 x i8>* %1250
%1251 = getelementptr i8, i8* %1243, i64 16
%1252 = bitcast i8* %1251 to <16 x i8>*
store <16 x i8> %1249, <16 x i8>* %1252
%1253 = or i64 %1241, 32
%1254 = getelementptr i8, i8* %351, i64 %1253
%1255 = getelementptr i8, i8* %353, i64 %1253
%1256 = bitcast i8* %1255 to <16 x i8>*
%1257 = load <16 x i8>, <16 x i8>* %1256
%1258 = getelementptr i8, i8* %1255, i64 16
%1259 = bitcast i8* %1258 to <16 x i8>*
%1260 = load <16 x i8>, <16 x i8>* %1259
%1261 = bitcast i8* %1254 to <16 x i8>*
store <16 x i8> %1257, <16 x i8>* %1261
%1262 = getelementptr i8, i8* %1254, i64 16
%1263 = bitcast i8* %1262 to <16 x i8>*
store <16 x i8> %1260, <16 x i8>* %1263
%1264 = or i64 %1241, 64
%1265 = getelementptr i8, i8* %351, i64 %1264
%1266 = getelementptr i8, i8* %353, i64 %1264
%1267 = bitcast i8* %1266 to <16 x i8>*
%1268 = load <16 x i8>, <16 x i8>* %1267
%1269 = getelementptr i8, i8* %1266, i64 16
%1270 = bitcast i8* %1269 to <16 x i8>*
%1271 = load <16 x i8>, <16 x i8>* %1270
%1272 = bitcast i8* %1265 to <16 x i8>*
store <16 x i8> %1268, <16 x i8>* %1272
%1273 = getelementptr i8, i8* %1265, i64 16
%1274 = bitcast i8* %1273 to <16 x i8>*
store <16 x i8> %1271, <16 x i8>* %1274
%1275 = or i64 %1241, 96
%1276 = getelementptr i8, i8* %351, i64 %1275
%1277 = getelementptr i8, i8* %353, i64 %1275
%1278 = bitcast i8* %1277 to <16 x i8>*
%1279 = load <16 x i8>, <16 x i8>* %1278
%1280 = getelementptr i8, i8* %1277, i64 16
%1281 = bitcast i8* %1280 to <16 x i8>*
%1282 = load <16 x i8>, <16 x i8>* %1281
%1283 = bitcast i8* %1276 to <16 x i8>*
store <16 x i8> %1279, <16 x i8>* %1283
%1284 = getelementptr i8, i8* %1276, i64 16
%1285 = bitcast i8* %1284 to <16 x i8>*
store <16 x i8> %1282, <16 x i8>* %1285
%1286 = add nuw i64 %1241, 128
%1287 = add i64 %1242, 4
%1288 = icmp eq i64 %1287, %181
br i1 %1288, label %1289, label %1240
1289: ; preds = %1240, %1237
%1290 = phi i64 [ 0, %1237 ], [ %1286, %1240 ]
br i1 %182, label %1307, label %1291
1291: ; preds = %1289, %1291
%1292 = phi i64 [ %1304, %1291 ], [ %1290, %1289 ]
%1293 = phi i64 [ %1305, %1291 ], [ 0, %1289 ]
%1294 = getelementptr i8, i8* %351, i64 %1292
%1295 = getelementptr i8, i8* %353, i64 %1292
%1296 = bitcast i8* %1295 to <16 x i8>*
%1297 = load <16 x i8>, <16 x i8>* %1296
%1298 = getelementptr i8, i8* %1295, i64 16
%1299 = bitcast i8* %1298 to <16 x i8>*
%1300 = load <16 x i8>, <16 x i8>* %1299
%1301 = bitcast i8* %1294 to <16 x i8>*
store <16 x i8> %1297, <16 x i8>* %1301
%1302 = getelementptr i8, i8* %1294, i64 16
%1303 = bitcast i8* %1302 to <16 x i8>*
store <16 x i8> %1300, <16 x i8>* %1303
%1304 = add nuw i64 %1292, 32
%1305 = add i64 %1293, 1
%1306 = icmp eq i64 %1305, %179
br i1 %1306, label %1307, label %1291
1307: ; preds = %1291, %1289
br i1 %183, label %1335, label %1308
1308: ; preds = %1233, %1232, %1307
%1309 = phi i8* [ %351, %1233 ], [ %351, %1232 ], [ %1238, %1307 ]
%1310 = phi i8* [ %353, %1233 ], [ %353, %1232 ], [ %1239, %1307 ]
%1311 = phi i32 [ 0, %1233 ], [ 0, %1232 ], [ %178, %1307 ]
%1312 = sub i32 %20, %1311
%1313 = xor i32 %1311, -1
%1314 = add i32 %20, %1313
%1315 = and i32 %1312, 7
%1316 = icmp eq i32 %1315, 0
br i1 %1316, label %1328, label %1317
1317: ; preds = %1308, %1317
%1318 = phi i8* [ %1324, %1317 ], [ %1309, %1308 ]
%1319 = phi i8* [ %1322, %1317 ], [ %1310, %1308 ]
%1320 = phi i32 [ %1325, %1317 ], [ %1311, %1308 ]
%1321 = phi i32 [ %1326, %1317 ], [ 0, %1308 ]
%1322 = getelementptr inbounds i8, i8* %1319, i64 1
%1323 = load i8, i8* %1319
%1324 = getelementptr inbounds i8, i8* %1318, i64 1
store i8 %1323, i8* %1318
%1325 = add nuw nsw i32 %1320, 1
%1326 = add i32 %1321, 1
%1327 = icmp eq i32 %1326, %1315
br i1 %1327, label %1328, label %1317
1328: ; preds = %1317, %1308
%1329 = phi i8* [ undef, %1308 ], [ %1322, %1317 ]
%1330 = phi i8* [ undef, %1308 ], [ %1324, %1317 ]
%1331 = phi i8* [ %1309, %1308 ], [ %1324, %1317 ]
%1332 = phi i8* [ %1310, %1308 ], [ %1322, %1317 ]
%1333 = phi i32 [ %1311, %1308 ], [ %1325, %1317 ]
%1334 = icmp ult i32 %1314, 7
br i1 %1334, label %1335, label %1478
1335: ; preds = %1328, %1478, %1307, %1231
%1336 = phi i8* [ %353, %1231 ], [ %1239, %1307 ], [ %1329, %1328 ], [ %1503, %1478 ]
%1337 = phi i8* [ %351, %1231 ], [ %1238, %1307 ], [ %1330, %1328 ], [ %1505, %1478 ]
br i1 %18, label %1338, label %1816
1338: ; preds = %1335
br i1 %184, label %1446, label %1339
1339: ; preds = %1338
%1340 = getelementptr i8, i8* %1337, i64 %95
%1341 = getelementptr i8, i8* %1336, i64 %95
%1342 = icmp ult i8* %1337, %1341
%1343 = icmp ult i8* %1336, %1340
%1344 = and i1 %1342, %1343
%1345 = icmp ult i8* %1337, %299
%1346 = icmp ult i8* %298, %1340
%1347 = and i1 %1345, %1346
%1348 = or i1 %1344, %1347
br i1 %1348, label %1446, label %1349
1349: ; preds = %1339
br i1 %185, label %1426, label %1350
1350: ; preds = %1349
br i1 %188, label %1398, label %1351
1351: ; preds = %1350, %1351
%1352 = phi i64 [ %1395, %1351 ], [ 0, %1350 ]
%1353 = phi i64 [ %1396, %1351 ], [ 0, %1350 ]
%1354 = getelementptr i8, i8* %351, i64 %1352
%1355 = getelementptr i8, i8* %1337, i64 %1352
%1356 = getelementptr i8, i8* %1336, i64 %1352
%1357 = bitcast i8* %1356 to <16 x i8>*
%1358 = load <16 x i8>, <16 x i8>* %1357
%1359 = getelementptr i8, i8* %1356, i64 16
%1360 = bitcast i8* %1359 to <16 x i8>*
%1361 = load <16 x i8>, <16 x i8>* %1360
%1362 = bitcast i8* %1354 to <16 x i8>*
%1363 = load <16 x i8>, <16 x i8>* %1362
%1364 = getelementptr i8, i8* %1354, i64 16
%1365 = bitcast i8* %1364 to <16 x i8>*
%1366 = load <16 x i8>, <16 x i8>* %1365
%1367 = lshr <16 x i8> %1363, <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>
%1368 = lshr <16 x i8> %1366, <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>
%1369 = add <16 x i8> %1367, %1358
%1370 = add <16 x i8> %1368, %1361
%1371 = bitcast i8* %1355 to <16 x i8>*
store <16 x i8> %1369, <16 x i8>* %1371
%1372 = getelementptr i8, i8* %1355, i64 16
%1373 = bitcast i8* %1372 to <16 x i8>*
store <16 x i8> %1370, <16 x i8>* %1373
%1374 = or i64 %1352, 32
%1375 = getelementptr i8, i8* %351, i64 %1374
%1376 = getelementptr i8, i8* %1337, i64 %1374
%1377 = getelementptr i8, i8* %1336, i64 %1374
%1378 = bitcast i8* %1377 to <16 x i8>*
%1379 = load <16 x i8>, <16 x i8>* %1378
%1380 = getelementptr i8, i8* %1377, i64 16
%1381 = bitcast i8* %1380 to <16 x i8>*
%1382 = load <16 x i8>, <16 x i8>* %1381
%1383 = bitcast i8* %1375 to <16 x i8>*
%1384 = load <16 x i8>, <16 x i8>* %1383
%1385 = getelementptr i8, i8* %1375, i64 16
%1386 = bitcast i8* %1385 to <16 x i8>*
%1387 = load <16 x i8>, <16 x i8>* %1386
%1388 = lshr <16 x i8> %1384, <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>
%1389 = lshr <16 x i8> %1387, <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>
%1390 = add <16 x i8> %1388, %1379
%1391 = add <16 x i8> %1389, %1382
%1392 = bitcast i8* %1376 to <16 x i8>*
store <16 x i8> %1390, <16 x i8>* %1392
%1393 = getelementptr i8, i8* %1376, i64 16
%1394 = bitcast i8* %1393 to <16 x i8>*
store <16 x i8> %1391, <16 x i8>* %1394
%1395 = add nuw i64 %1352, 64
%1396 = add i64 %1353, 2
%1397 = icmp eq i64 %1396, %189
br i1 %1397, label %1398, label %1351
1398: ; preds = %1351, %1350
%1399 = phi i64 [ 0, %1350 ], [ %1395, %1351 ]
br i1 %190, label %1421, label %1400
1400: ; preds = %1398
%1401 = getelementptr i8, i8* %351, i64 %1399
%1402 = getelementptr i8, i8* %1337, i64 %1399
%1403 = getelementptr i8, i8* %1336, i64 %1399
%1404 = bitcast i8* %1403 to <16 x i8>*
%1405 = load <16 x i8>, <16 x i8>* %1404
%1406 = getelementptr i8, i8* %1403, i64 16
%1407 = bitcast i8* %1406 to <16 x i8>*
%1408 = load <16 x i8>, <16 x i8>* %1407
%1409 = bitcast i8* %1401 to <16 x i8>*
%1410 = load <16 x i8>, <16 x i8>* %1409
%1411 = getelementptr i8, i8* %1401, i64 16
%1412 = bitcast i8* %1411 to <16 x i8>*
%1413 = load <16 x i8>, <16 x i8>* %1412
%1414 = lshr <16 x i8> %1410, <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>
%1415 = lshr <16 x i8> %1413, <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>
%1416 = add <16 x i8> %1414, %1405
%1417 = add <16 x i8> %1415, %1408
%1418 = bitcast i8* %1402 to <16 x i8>*
store <16 x i8> %1416, <16 x i8>* %1418
%1419 = getelementptr i8, i8* %1402, i64 16
%1420 = bitcast i8* %1419 to <16 x i8>*
store <16 x i8> %1417, <16 x i8>* %1420
br label %1421
1421: ; preds = %1398, %1400
br i1 %191, label %1816, label %1422
1422: ; preds = %1421
%1423 = getelementptr i8, i8* %1336, i64 %186
%1424 = getelementptr i8, i8* %1337, i64 %186
%1425 = getelementptr i8, i8* %351, i64 %186
br i1 %195, label %1446, label %1426
1426: ; preds = %1349, %1422
%1427 = phi i64 [ %186, %1422 ], [ 0, %1349 ]
%1428 = getelementptr i8, i8* %351, i64 %196
%1429 = getelementptr i8, i8* %1337, i64 %196
%1430 = getelementptr i8, i8* %1336, i64 %196
br label %1431
1431: ; preds = %1431, %1426
%1432 = phi i64 [ %1427, %1426 ], [ %1443, %1431 ]
%1433 = getelementptr i8, i8* %351, i64 %1432
%1434 = getelementptr i8, i8* %1337, i64 %1432
%1435 = getelementptr i8, i8* %1336, i64 %1432
%1436 = bitcast i8* %1435 to <8 x i8>*
%1437 = load <8 x i8>, <8 x i8>* %1436
%1438 = bitcast i8* %1433 to <8 x i8>*
%1439 = load <8 x i8>, <8 x i8>* %1438
%1440 = lshr <8 x i8> %1439, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%1441 = add <8 x i8> %1440, %1437
%1442 = bitcast i8* %1434 to <8 x i8>*
store <8 x i8> %1441, <8 x i8>* %1442
%1443 = add nuw i64 %1432, 8
%1444 = icmp eq i64 %1443, %196
br i1 %1444, label %1445, label %1431
1445: ; preds = %1431
br i1 %199, label %1816, label %1446
1446: ; preds = %1339, %1338, %1422, %1445
%1447 = phi i8* [ %351, %1338 ], [ %351, %1339 ], [ %1425, %1422 ], [ %1428, %1445 ]
%1448 = phi i8* [ %1337, %1338 ], [ %1337, %1339 ], [ %1424, %1422 ], [ %1429, %1445 ]
%1449 = phi i8* [ %1336, %1338 ], [ %1336, %1339 ], [ %1423, %1422 ], [ %1430, %1445 ]
%1450 = phi i32 [ %11, %1338 ], [ %11, %1339 ], [ %193, %1422 ], [ %198, %1445 ]
%1451 = sub i32 %9, %1450
%1452 = xor i32 %1450, -1
%1453 = add i32 %9, %1452
%1454 = and i32 %1451, 3
%1455 = icmp eq i32 %1454, 0
br i1 %1455, label %1472, label %1456
1456: ; preds = %1446, %1456
%1457 = phi i8* [ %1464, %1456 ], [ %1447, %1446 ]
%1458 = phi i8* [ %1468, %1456 ], [ %1448, %1446 ]
%1459 = phi i8* [ %1462, %1456 ], [ %1449, %1446 ]
%1460 = phi i32 [ %1469, %1456 ], [ %1450, %1446 ]
%1461 = phi i32 [ %1470, %1456 ], [ 0, %1446 ]
%1462 = getelementptr inbounds i8, i8* %1459, i64 1
%1463 = load i8, i8* %1459
%1464 = getelementptr inbounds i8, i8* %1457, i64 1
%1465 = load i8, i8* %1457
%1466 = lshr i8 %1465, 1
%1467 = add i8 %1466, %1463
%1468 = getelementptr inbounds i8, i8* %1458, i64 1
store i8 %1467, i8* %1458
%1469 = add nsw i32 %1460, 1
%1470 = add i32 %1461, 1
%1471 = icmp eq i32 %1470, %1454
br i1 %1471, label %1472, label %1456
1472: ; preds = %1456, %1446
%1473 = phi i8* [ %1447, %1446 ], [ %1464, %1456 ]
%1474 = phi i8* [ %1448, %1446 ], [ %1468, %1456 ]
%1475 = phi i8* [ %1449, %1446 ], [ %1462, %1456 ]
%1476 = phi i32 [ %1450, %1446 ], [ %1469, %1456 ]
%1477 = icmp ult i32 %1453, 3
br i1 %1477, label %1816, label %1508
1478: ; preds = %1328, %1478
%1479 = phi i8* [ %1505, %1478 ], [ %1331, %1328 ]
%1480 = phi i8* [ %1503, %1478 ], [ %1332, %1328 ]
%1481 = phi i32 [ %1506, %1478 ], [ %1333, %1328 ]
%1482 = getelementptr inbounds i8, i8* %1480, i64 1
%1483 = load i8, i8* %1480
%1484 = getelementptr inbounds i8, i8* %1479, i64 1
store i8 %1483, i8* %1479
%1485 = getelementptr inbounds i8, i8* %1480, i64 2
%1486 = load i8, i8* %1482
%1487 = getelementptr inbounds i8, i8* %1479, i64 2
store i8 %1486, i8* %1484
%1488 = getelementptr inbounds i8, i8* %1480, i64 3
%1489 = load i8, i8* %1485
%1490 = getelementptr inbounds i8, i8* %1479, i64 3
store i8 %1489, i8* %1487
%1491 = getelementptr inbounds i8, i8* %1480, i64 4
%1492 = load i8, i8* %1488
%1493 = getelementptr inbounds i8, i8* %1479, i64 4
store i8 %1492, i8* %1490
%1494 = getelementptr inbounds i8, i8* %1480, i64 5
%1495 = load i8, i8* %1491
%1496 = getelementptr inbounds i8, i8* %1479, i64 5
store i8 %1495, i8* %1493
%1497 = getelementptr inbounds i8, i8* %1480, i64 6
%1498 = load i8, i8* %1494
%1499 = getelementptr inbounds i8, i8* %1479, i64 6
store i8 %1498, i8* %1496
%1500 = getelementptr inbounds i8, i8* %1480, i64 7
%1501 = load i8, i8* %1497
%1502 = getelementptr inbounds i8, i8* %1479, i64 7
store i8 %1501, i8* %1499
%1503 = getelementptr inbounds i8, i8* %1480, i64 8
%1504 = load i8, i8* %1500
%1505 = getelementptr inbounds i8, i8* %1479, i64 8
store i8 %1504, i8* %1502
%1506 = add nuw nsw i32 %1481, 8
%1507 = icmp eq i32 %1506, %20
br i1 %1507, label %1335, label %1478
1508: ; preds = %1472, %1508
%1509 = phi i8* [ %1536, %1508 ], [ %1473, %1472 ]
%1510 = phi i8* [ %1540, %1508 ], [ %1474, %1472 ]
%1511 = phi i8* [ %1534, %1508 ], [ %1475, %1472 ]
%1512 = phi i32 [ %1541, %1508 ], [ %1476, %1472 ]
%1513 = getelementptr inbounds i8, i8* %1511, i64 1
%1514 = load i8, i8* %1511
%1515 = getelementptr inbounds i8, i8* %1509, i64 1
%1516 = load i8, i8* %1509
%1517 = lshr i8 %1516, 1
%1518 = add i8 %1517, %1514
%1519 = getelementptr inbounds i8, i8* %1510, i64 1
store i8 %1518, i8* %1510
%1520 = getelementptr inbounds i8, i8* %1511, i64 2
%1521 = load i8, i8* %1513
%1522 = getelementptr inbounds i8, i8* %1509, i64 2
%1523 = load i8, i8* %1515
%1524 = lshr i8 %1523, 1
%1525 = add i8 %1524, %1521
%1526 = getelementptr inbounds i8, i8* %1510, i64 2
store i8 %1525, i8* %1519
%1527 = getelementptr inbounds i8, i8* %1511, i64 3
%1528 = load i8, i8* %1520
%1529 = getelementptr inbounds i8, i8* %1509, i64 3
%1530 = load i8, i8* %1522
%1531 = lshr i8 %1530, 1
%1532 = add i8 %1531, %1528
%1533 = getelementptr inbounds i8, i8* %1510, i64 3
store i8 %1532, i8* %1526
%1534 = getelementptr inbounds i8, i8* %1511, i64 4
%1535 = load i8, i8* %1527
%1536 = getelementptr inbounds i8, i8* %1509, i64 4
%1537 = load i8, i8* %1529
%1538 = lshr i8 %1537, 1
%1539 = add i8 %1538, %1535
%1540 = getelementptr inbounds i8, i8* %1510, i64 4
store i8 %1539, i8* %1533
%1541 = add nsw i32 %1512, 4
%1542 = icmp eq i32 %1541, %9
br i1 %1542, label %1816, label %1508
1543: ; preds = %1222, %1668, %1195, %1114
%1544 = phi i8* [ %353, %1114 ], [ %1124, %1195 ], [ %1223, %1222 ], [ %1694, %1668 ]
%1545 = phi i8* [ %351, %1114 ], [ %1123, %1195 ], [ %1225, %1222 ], [ %1700, %1668 ]
%1546 = phi i8* [ %352, %1114 ], [ %1122, %1195 ], [ %1224, %1222 ], [ %1696, %1668 ]
br i1 %18, label %1547, label %1816
1547: ; preds = %1543
br i1 %164, label %1636, label %1548
1548: ; preds = %1547
%1549 = getelementptr i8, i8* %1545, i64 %117
%1550 = getelementptr i8, i8* %1544, i64 %117
%1551 = getelementptr i8, i8* %1546, i64 %117
%1552 = icmp ult i8* %1545, %1550
%1553 = icmp ult i8* %1544, %1549
%1554 = and i1 %1552, %1553
%1555 = icmp ult i8* %1545, %1551
%1556 = icmp ult i8* %1546, %1549
%1557 = and i1 %1555, %1556
%1558 = or i1 %1554, %1557
%1559 = icmp ult i8* %1545, %284
%1560 = icmp ult i8* %283, %1549
%1561 = and i1 %1559, %1560
%1562 = or i1 %1558, %1561
br i1 %1562, label %1636, label %1563
1563: ; preds = %1548
br i1 %165, label %1608, label %1564
1564: ; preds = %1563, %1564
%1565 = phi i64 [ %1600, %1564 ], [ 0, %1563 ]
%1566 = getelementptr i8, i8* %1546, i64 %1565
%1567 = getelementptr i8, i8* %351, i64 %1565
%1568 = getelementptr i8, i8* %1545, i64 %1565
%1569 = getelementptr i8, i8* %1544, i64 %1565
%1570 = bitcast i8* %1569 to <16 x i8>*
%1571 = load <16 x i8>, <16 x i8>* %1570
%1572 = getelementptr i8, i8* %1569, i64 16
%1573 = bitcast i8* %1572 to <16 x i8>*
%1574 = load <16 x i8>, <16 x i8>* %1573
%1575 = bitcast i8* %1566 to <16 x i8>*
%1576 = load <16 x i8>, <16 x i8>* %1575
%1577 = getelementptr i8, i8* %1566, i64 16
%1578 = bitcast i8* %1577 to <16 x i8>*
%1579 = load <16 x i8>, <16 x i8>* %1578
%1580 = zext <16 x i8> %1576 to <16 x i16>
%1581 = zext <16 x i8> %1579 to <16 x i16>
%1582 = bitcast i8* %1567 to <16 x i8>*
%1583 = load <16 x i8>, <16 x i8>* %1582
%1584 = getelementptr i8, i8* %1567, i64 16
%1585 = bitcast i8* %1584 to <16 x i8>*
%1586 = load <16 x i8>, <16 x i8>* %1585
%1587 = zext <16 x i8> %1583 to <16 x i16>
%1588 = zext <16 x i8> %1586 to <16 x i16>
%1589 = add nuw nsw <16 x i16> %1587, %1580
%1590 = add nuw nsw <16 x i16> %1588, %1581
%1591 = lshr <16 x i16> %1589, <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>
%1592 = lshr <16 x i16> %1590, <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>
%1593 = trunc <16 x i16> %1591 to <16 x i8>
%1594 = trunc <16 x i16> %1592 to <16 x i8>
%1595 = add <16 x i8> %1571, %1593
%1596 = add <16 x i8> %1574, %1594
%1597 = bitcast i8* %1568 to <16 x i8>*
store <16 x i8> %1595, <16 x i8>* %1597
%1598 = getelementptr i8, i8* %1568, i64 16
%1599 = bitcast i8* %1598 to <16 x i8>*
store <16 x i8> %1596, <16 x i8>* %1599
%1600 = add nuw i64 %1565, 32
%1601 = icmp eq i64 %1600, %166
br i1 %1601, label %1602, label %1564
1602: ; preds = %1564
br i1 %167, label %1816, label %1603
1603: ; preds = %1602
%1604 = getelementptr i8, i8* %1544, i64 %166
%1605 = getelementptr i8, i8* %1545, i64 %166
%1606 = getelementptr i8, i8* %351, i64 %166
%1607 = getelementptr i8, i8* %1546, i64 %166
br i1 %171, label %1636, label %1608
1608: ; preds = %1563, %1603
%1609 = phi i64 [ %166, %1603 ], [ 0, %1563 ]
%1610 = getelementptr i8, i8* %1546, i64 %172
%1611 = getelementptr i8, i8* %351, i64 %172
%1612 = getelementptr i8, i8* %1545, i64 %172
%1613 = getelementptr i8, i8* %1544, i64 %172
br label %1614
1614: ; preds = %1614, %1608
%1615 = phi i64 [ %1609, %1608 ], [ %1633, %1614 ]
%1616 = getelementptr i8, i8* %1546, i64 %1615
%1617 = getelementptr i8, i8* %351, i64 %1615
%1618 = getelementptr i8, i8* %1545, i64 %1615
%1619 = getelementptr i8, i8* %1544, i64 %1615
%1620 = bitcast i8* %1619 to <8 x i8>*
%1621 = load <8 x i8>, <8 x i8>* %1620
%1622 = bitcast i8* %1616 to <8 x i8>*
%1623 = load <8 x i8>, <8 x i8>* %1622
%1624 = zext <8 x i8> %1623 to <8 x i16>
%1625 = bitcast i8* %1617 to <8 x i8>*
%1626 = load <8 x i8>, <8 x i8>* %1625
%1627 = zext <8 x i8> %1626 to <8 x i16>
%1628 = add nuw nsw <8 x i16> %1627, %1624
%1629 = lshr <8 x i16> %1628, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%1630 = trunc <8 x i16> %1629 to <8 x i8>
%1631 = add <8 x i8> %1621, %1630
%1632 = bitcast i8* %1618 to <8 x i8>*
store <8 x i8> %1631, <8 x i8>* %1632
%1633 = add nuw i64 %1615, 8
%1634 = icmp eq i64 %1633, %172
br i1 %1634, label %1635, label %1614
1635: ; preds = %1614
br i1 %175, label %1816, label %1636
1636: ; preds = %1548, %1547, %1603, %1635
%1637 = phi i8* [ %1546, %1547 ], [ %1546, %1548 ], [ %1607, %1603 ], [ %1610, %1635 ]
%1638 = phi i8* [ %351, %1547 ], [ %351, %1548 ], [ %1606, %1603 ], [ %1611, %1635 ]
%1639 = phi i8* [ %1545, %1547 ], [ %1545, %1548 ], [ %1605, %1603 ], [ %1612, %1635 ]
%1640 = phi i8* [ %1544, %1547 ], [ %1544, %1548 ], [ %1604, %1603 ], [ %1613, %1635 ]
%1641 = phi i32 [ %11, %1547 ], [ %11, %1548 ], [ %169, %1603 ], [ %174, %1635 ]
%1642 = sub i32 %9, %1641
%1643 = add i32 %1641, 1
%1644 = and i32 %1642, 1
%1645 = icmp eq i32 %1644, 0
br i1 %1645, label %1661, label %1646
1646: ; preds = %1636
%1647 = getelementptr inbounds i8, i8* %1640, i64 1
%1648 = load i8, i8* %1640
%1649 = getelementptr inbounds i8, i8* %1637, i64 1
%1650 = load i8, i8* %1637
%1651 = zext i8 %1650 to i16
%1652 = getelementptr inbounds i8, i8* %1638, i64 1
%1653 = load i8, i8* %1638
%1654 = zext i8 %1653 to i16
%1655 = add nuw nsw i16 %1654, %1651
%1656 = lshr i16 %1655, 1
%1657 = trunc i16 %1656 to i8
%1658 = add i8 %1648, %1657
%1659 = getelementptr inbounds i8, i8* %1639, i64 1
store i8 %1658, i8* %1639
%1660 = add nsw i32 %1641, 1
br label %1661
1661: ; preds = %1646, %1636
%1662 = phi i8* [ %1637, %1636 ], [ %1649, %1646 ]
%1663 = phi i8* [ %1638, %1636 ], [ %1652, %1646 ]
%1664 = phi i8* [ %1639, %1636 ], [ %1659, %1646 ]
%1665 = phi i8* [ %1640, %1636 ], [ %1647, %1646 ]
%1666 = phi i32 [ %1641, %1636 ], [ %1660, %1646 ]
%1667 = icmp eq i32 %9, %1643
br i1 %1667, label %1816, label %1703
1668: ; preds = %1222, %1668
%1669 = phi i8* [ %1696, %1668 ], [ %1226, %1222 ]
%1670 = phi i8* [ %1700, %1668 ], [ %1227, %1222 ]
%1671 = phi i8* [ %1694, %1668 ], [ %1228, %1222 ]
%1672 = phi i32 [ %1701, %1668 ], [ %1229, %1222 ]
%1673 = getelementptr inbounds i8, i8* %1671, i64 1
%1674 = load i8, i8* %1671
%1675 = getelementptr inbounds i8, i8* %1669, i64 1
%1676 = load i8, i8* %1669
%1677 = lshr i8 %1676, 1
%1678 = add i8 %1677, %1674
%1679 = getelementptr inbounds i8, i8* %1670, i64 1
store i8 %1678, i8* %1670
%1680 = getelementptr inbounds i8, i8* %1671, i64 2
%1681 = load i8, i8* %1673
%1682 = getelementptr inbounds i8, i8* %1669, i64 2
%1683 = load i8, i8* %1675
%1684 = lshr i8 %1683, 1
%1685 = add i8 %1684, %1681
%1686 = getelementptr inbounds i8, i8* %1670, i64 2
store i8 %1685, i8* %1679
%1687 = getelementptr inbounds i8, i8* %1671, i64 3
%1688 = load i8, i8* %1680
%1689 = getelementptr inbounds i8, i8* %1669, i64 3
%1690 = load i8, i8* %1682
%1691 = lshr i8 %1690, 1
%1692 = add i8 %1691, %1688
%1693 = getelementptr inbounds i8, i8* %1670, i64 3
store i8 %1692, i8* %1686
%1694 = getelementptr inbounds i8, i8* %1671, i64 4
%1695 = load i8, i8* %1687
%1696 = getelementptr inbounds i8, i8* %1669, i64 4
%1697 = load i8, i8* %1689
%1698 = lshr i8 %1697, 1
%1699 = add i8 %1698, %1695
%1700 = getelementptr inbounds i8, i8* %1670, i64 4
store i8 %1699, i8* %1693
%1701 = add nuw nsw i32 %1672, 4
%1702 = icmp eq i32 %1701, %20
br i1 %1702, label %1543, label %1668
1703: ; preds = %1661, %1703
%1704 = phi i8* [ %1724, %1703 ], [ %1662, %1661 ]
%1705 = phi i8* [ %1727, %1703 ], [ %1663, %1661 ]
%1706 = phi i8* [ %1734, %1703 ], [ %1664, %1661 ]
%1707 = phi i8* [ %1722, %1703 ], [ %1665, %1661 ]
%1708 = phi i32 [ %1735, %1703 ], [ %1666, %1661 ]
%1709 = getelementptr inbounds i8, i8* %1707, i64 1
%1710 = load i8, i8* %1707
%1711 = getelementptr inbounds i8, i8* %1704, i64 1
%1712 = load i8, i8* %1704
%1713 = zext i8 %1712 to i16
%1714 = getelementptr inbounds i8, i8* %1705, i64 1
%1715 = load i8, i8* %1705
%1716 = zext i8 %1715 to i16
%1717 = add nuw nsw i16 %1716, %1713
%1718 = lshr i16 %1717, 1
%1719 = trunc i16 %1718 to i8
%1720 = add i8 %1710, %1719
%1721 = getelementptr inbounds i8, i8* %1706, i64 1
store i8 %1720, i8* %1706
%1722 = getelementptr inbounds i8, i8* %1707, i64 2
%1723 = load i8, i8* %1709
%1724 = getelementptr inbounds i8, i8* %1704, i64 2
%1725 = load i8, i8* %1711
%1726 = zext i8 %1725 to i16
%1727 = getelementptr inbounds i8, i8* %1705, i64 2
%1728 = load i8, i8* %1714
%1729 = zext i8 %1728 to i16
%1730 = add nuw nsw i16 %1729, %1726
%1731 = lshr i16 %1730, 1
%1732 = trunc i16 %1731 to i8
%1733 = add i8 %1723, %1732
%1734 = getelementptr inbounds i8, i8* %1706, i64 2
store i8 %1733, i8* %1721
%1735 = add nsw i32 %1708, 2
%1736 = icmp eq i32 %1735, %9
br i1 %1736, label %1816, label %1703
1737: ; preds = %269
%1738 = icmp eq i64 %270, 0
br i1 %1738, label %1740, label %1739
1739: ; preds = %1737
br i1 %17, label %1776, label %1772
1740: ; preds = %1737
br i1 %17, label %1744, label %1741
1741: ; preds = %1744, %1740
%1742 = phi i8* [ %353, %1740 ], [ %1748, %1744 ]
%1743 = phi i8* [ %351, %1740 ], [ %1753, %1744 ]
br i1 %18, label %1756, label %1816
1744: ; preds = %1740, %1744
%1745 = phi i8* [ %1753, %1744 ], [ %351, %1740 ]
%1746 = phi i8* [ %1748, %1744 ], [ %353, %1740 ]
%1747 = phi i32 [ %1754, %1744 ], [ 0, %1740 ]
%1748 = getelementptr inbounds i8, i8* %1746, i64 1
%1749 = load i8, i8* %1746
%1750 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 0, i32 0, i32 0)
%1751 = trunc i32 %1750 to i8
%1752 = add i8 %1749, %1751
%1753 = getelementptr inbounds i8, i8* %1745, i64 1
store i8 %1752, i8* %1745
%1754 = add nuw nsw i32 %1747, 1
%1755 = icmp eq i32 %1754, %20
br i1 %1755, label %1741, label %1744
1756: ; preds = %1741, %1756
%1757 = phi i8* [ %1763, %1756 ], [ %351, %1741 ]
%1758 = phi i8* [ %1769, %1756 ], [ %1743, %1741 ]
%1759 = phi i8* [ %1761, %1756 ], [ %1742, %1741 ]
%1760 = phi i32 [ %1770, %1756 ], [ %11, %1741 ]
%1761 = getelementptr inbounds i8, i8* %1759, i64 1
%1762 = load i8, i8* %1759
%1763 = getelementptr inbounds i8, i8* %1757, i64 1
%1764 = load i8, i8* %1757
%1765 = zext i8 %1764 to i32
%1766 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 %1765, i32 0, i32 0)
%1767 = trunc i32 %1766 to i8
%1768 = add i8 %1762, %1767
%1769 = getelementptr inbounds i8, i8* %1758, i64 1
store i8 %1768, i8* %1758
%1770 = add nsw i32 %1760, 1
%1771 = icmp eq i32 %1770, %9
br i1 %1771, label %1816, label %1756
1772: ; preds = %1776, %1739
%1773 = phi i8* [ %353, %1739 ], [ %1781, %1776 ]
%1774 = phi i8* [ %351, %1739 ], [ %1789, %1776 ]
%1775 = phi i8* [ %352, %1739 ], [ %1783, %1776 ]
br i1 %18, label %1792, label %1816
1776: ; preds = %1739, %1776
%1777 = phi i8* [ %1783, %1776 ], [ %352, %1739 ]
%1778 = phi i8* [ %1789, %1776 ], [ %351, %1739 ]
%1779 = phi i8* [ %1781, %1776 ], [ %353, %1739 ]
%1780 = phi i32 [ %1790, %1776 ], [ 0, %1739 ]
%1781 = getelementptr inbounds i8, i8* %1779, i64 1
%1782 = load i8, i8* %1779
%1783 = getelementptr inbounds i8, i8* %1777, i64 1
%1784 = load i8, i8* %1777
%1785 = zext i8 %1784 to i32
%1786 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 0, i32 %1785, i32 0)
%1787 = trunc i32 %1786 to i8
%1788 = add i8 %1782, %1787
%1789 = getelementptr inbounds i8, i8* %1778, i64 1
store i8 %1788, i8* %1778
%1790 = add nuw nsw i32 %1780, 1
%1791 = icmp eq i32 %1790, %20
br i1 %1791, label %1772, label %1776
1792: ; preds = %1772, %1792
%1793 = phi i8* [ %1807, %1792 ], [ %352, %1772 ]
%1794 = phi i8* [ %1804, %1792 ], [ %1775, %1772 ]
%1795 = phi i8* [ %1801, %1792 ], [ %351, %1772 ]
%1796 = phi i8* [ %1813, %1792 ], [ %1774, %1772 ]
%1797 = phi i8* [ %1799, %1792 ], [ %1773, %1772 ]
%1798 = phi i32 [ %1814, %1792 ], [ %11, %1772 ]
%1799 = getelementptr inbounds i8, i8* %1797, i64 1
%1800 = load i8, i8* %1797
%1801 = getelementptr inbounds i8, i8* %1795, i64 1
%1802 = load i8, i8* %1795
%1803 = zext i8 %1802 to i32
%1804 = getelementptr inbounds i8, i8* %1794, i64 1
%1805 = load i8, i8* %1794
%1806 = zext i8 %1805 to i32
%1807 = getelementptr inbounds i8, i8* %1793, i64 1
%1808 = load i8, i8* %1793
%1809 = zext i8 %1808 to i32
%1810 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @paeth to i32 (i32, i32, i32, ...)*)(i32 %1803, i32 %1806, i32 %1809)
%1811 = trunc i32 %1810 to i8
%1812 = add i8 %1800, %1811
%1813 = getelementptr inbounds i8, i8* %1796, i64 1
store i8 %1812, i8* %1796
%1814 = add nsw i32 %1798, 1
%1815 = icmp eq i32 %1814, %9
br i1 %1815, label %1816, label %1792
1816: ; preds = %1661, %1703, %1472, %1508, %927, %1081, %1046, %1051, %736, %772, %1792, %1756, %572, %577, %1602, %1635, %1421, %1445, %878, %901, %1008, %1025, %687, %710, %534, %551, %1543, %1335, %805, %933, %607, %1772, %1741, %459
%1817 = add nuw nsw i64 %270, 1
%1818 = icmp eq i64 %1817, %22
br i1 %1818, label %1819, label %269
1819: ; preds = %1816, %5
ret void
}