#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned char PaethPredictor(unsigned char, unsigned char, unsigned char);
int png_apply_specific_filter_8(int filtermode, unsigned char *dest,
                                unsigned char *src, unsigned width) {
  int pos2 = 0;
  int pos = 0;
  int srcwidth = width;
  int x;
  if (filtermode == 0) {
    for (x = 0; x < width; x++) {
      dest[pos2++] = src[pos++];
    }
  } else if (filtermode == 1) {
    dest[pos2++] = src[pos++];
    for (x = 1; x < width; x++) {
      dest[pos2++] = src[pos] - src[pos - 1];
      pos++;
    }
  } else if (filtermode == 2) {
    for (x = 0; x < width; x++) {
      dest[pos2++] = src[pos + 0] - src[pos - srcwidth + 0];
      pos++;
    }
  } else if (filtermode == 3) {
    dest[pos2++] = src[pos + 0] - src[pos - srcwidth + 0] / 2;
    pos++;
    for (x = 1; x < width; x++) {
      dest[pos2++] =
          src[pos + 0] - (src[pos - 1 + 0] + src[pos - srcwidth + 0]) / 2;
      pos++;
    }
  } else if (filtermode == 4) {
    dest[pos2++] = src[pos + 0] - PaethPredictor(0, src[pos - srcwidth + 0], 0);
    pos++;
    for (x = 1; x < width; x++) {
      dest[pos2++] = src[pos + 0] - PaethPredictor(src[pos - 1 + 0],
                                                   src[pos - srcwidth + 0],
                                                   src[pos - 1 - srcwidth + 0]);
      pos++;
    }
  }
  return filtermode;
}


x86 assembly (clang, -O0):
<png_apply_specific_filter_8>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    1194 <png_apply_specific_filter_8+0x84>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    118f <png_apply_specific_filter_8+0x7f>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114b <png_apply_specific_filter_8+0x3b>
jmp    14bf <png_apply_specific_filter_8+0x3af>
cmpl   $0x1,-0x4(%rbp)
jne    122d <png_apply_specific_filter_8+0x11d>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1228 <png_apply_specific_filter_8+0x118>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11cf <png_apply_specific_filter_8+0xbf>
jmp    14ba <png_apply_specific_filter_8+0x3aa>
cmpl   $0x2,-0x4(%rbp)
jne    12a4 <png_apply_specific_filter_8+0x194>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    129f <png_apply_specific_filter_8+0x18f>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123e <png_apply_specific_filter_8+0x12e>
jmp    14b5 <png_apply_specific_filter_8+0x3a5>
cmpl   $0x3,-0x4(%rbp)
jne    1398 <png_apply_specific_filter_8+0x288>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1393 <png_apply_specific_filter_8+0x283>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    130c <png_apply_specific_filter_8+0x1fc>
jmp    14b0 <png_apply_specific_filter_8+0x3a0>
cmpl   $0x4,-0x4(%rbp)
jne    14ab <png_apply_specific_filter_8+0x39b>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
mov    %edx,%edi
movzbl (%rax,%rcx,1),%esi
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x38(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    14a6 <png_apply_specific_filter_8+0x396>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl (%rax,%rcx,1),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x3c(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1404 <png_apply_specific_filter_8+0x2f4>
jmp    14ab <png_apply_specific_filter_8+0x39b>
jmp    14b0 <png_apply_specific_filter_8+0x3a0>
jmp    14b5 <png_apply_specific_filter_8+0x3a5>
jmp    14ba <png_apply_specific_filter_8+0x3aa>
jmp    14bf <png_apply_specific_filter_8+0x3af>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<png_apply_specific_filter_8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edi,0x4(%rsp)
cmp    $0x4,%edi
ja     1a88 <png_apply_specific_filter_8+0x978>
mov    %rdx,%r13
mov    %rsi,%r15
mov    0x4(%rsp),%eax
lea    0xec7(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add    %rdx,%rax
jmp    *%rax
test   %ecx,%ecx
je     1a88 <png_apply_specific_filter_8+0x978>
mov    %ecx,%eax
cmp    $0x8,%ecx
jb     116b <png_apply_specific_filter_8+0x5b>
lea    (%rax,%r13,1),%rdx
cmp    %r15,%rdx
jbe    14cc <png_apply_specific_filter_8+0x3bc>
lea    (%r15,%rax,1),%rdx
cmp    %r13,%rdx
jbe    14cc <png_apply_specific_filter_8+0x3bc>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     1477 <png_apply_specific_filter_8+0x367>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rcx),%rdx
movzbl 0x0(%r13,%rcx,1),%ebx
mov    %bl,(%r15,%rcx,1)
mov    %rdx,%rcx
add    $0xffffffffffffffff,%rdi
jne    1190 <png_apply_specific_filter_8+0x80>
cmp    $0x3,%rsi
jae    1490 <png_apply_specific_filter_8+0x380>
jmp    1a88 <png_apply_specific_filter_8+0x978>
mov    0x0(%r13),%al
mov    %al,(%r15)
cmp    $0x2,%ecx
jb     1a88 <png_apply_specific_filter_8+0x978>
mov    %ecx,%eax
lea    -0x1(%rax),%rcx
mov    $0x1,%esi
cmp    $0x8,%rcx
jb     1a38 <png_apply_specific_filter_8+0x928>
lea    0x1(%r15),%rdx
lea    (%rax,%r13,1),%rdi
cmp    %rdi,%rdx
jae    11f5 <png_apply_specific_filter_8+0xe5>
lea    (%r15,%rax,1),%rdx
cmp    %r13,%rdx
ja     1a38 <png_apply_specific_filter_8+0x928>
cmp    $0x20,%rcx
jae    15a2 <png_apply_specific_filter_8+0x492>
xor    %edx,%edx
jmp    196c <png_apply_specific_filter_8+0x85c>
test   %ecx,%ecx
je     1a88 <png_apply_specific_filter_8+0x978>
movslq %ecx,%r9
mov    %ecx,%r11d
cmp    $0x8,%ecx
jae    1360 <png_apply_specific_filter_8+0x250>
xor    %esi,%esi
jmp    18b9 <png_apply_specific_filter_8+0x7a9>
mov    0x0(%r13),%al
movslq %ecx,%r10
mov    %r10,%rdx
neg    %rdx
mov    0x0(%r13,%rdx,1),%dl
shr    %dl
sub    %dl,%al
mov    %al,(%r15)
cmp    $0x2,%ecx
jb     1a88 <png_apply_specific_filter_8+0x978>
mov    %ecx,%eax
lea    -0x1(%rax),%r8
mov    $0x1,%r9d
cmp    $0x8,%r8
jae    13b3 <png_apply_specific_filter_8+0x2a3>
mov    %r9,%rcx
not    %rcx
test   $0x1,%al
jne    128c <png_apply_specific_filter_8+0x17c>
mov    0x0(%r13,%r9,1),%dl
movzbl -0x1(%r13,%r9,1),%esi
mov    %r9,%rdi
sub    %r10,%rdi
movzbl 0x0(%r13,%rdi,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%dl
mov    %dl,(%r15,%r9,1)
add    $0x1,%r9
add    %rax,%rcx
je     1a88 <png_apply_specific_filter_8+0x978>
sub    %r9,%rax
add    %r9,%r13
mov    $0x1,%ecx
sub    %r10,%rcx
lea    (%r9,%r15,1),%rdx
add    $0x1,%rdx
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13),%ebx
movzbl -0x1(%r13),%esi
movzbl -0x1(%r13,%rcx,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%bl
mov    %bl,-0x1(%rdx)
movzbl 0x1(%r13),%ebx
movzbl 0x0(%r13),%esi
movzbl 0x0(%r13,%rcx,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%bl
mov    %bl,(%rdx)
add    $0x2,%r13
add    $0x2,%rdx
add    $0xfffffffffffffffe,%rax
jne    12b0 <png_apply_specific_filter_8+0x1a0>
jmp    1a88 <png_apply_specific_filter_8+0x978>
mov    0x0(%r13),%bl
movslq %ecx,%rbp
mov    %rbp,%rax
neg    %rax
movzbl 0x0(%r13,%rax,1),%esi
xor    %edi,%edi
xor    %edx,%edx
call   1030 <PaethPredictor@plt>
sub    %al,%bl
mov    %bl,(%r15)
cmp    $0x2,%ebp
jb     1a88 <png_apply_specific_filter_8+0x978>
mov    %ebp,%r14d
mov    %r13,%r12
sub    %rbp,%r12
mov    $0x1,%ebp
xchg   %ax,%ax
movzbl 0x0(%r13,%rbp,1),%ebx
movzbl -0x1(%r13,%rbp,1),%edi
movzbl (%r12,%rbp,1),%esi
movzbl -0x1(%r12,%rbp,1),%edx
call   1030 <PaethPredictor@plt>
sub    %al,%bl
mov    %bl,(%r15,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1330 <png_apply_specific_filter_8+0x220>
jmp    1a88 <png_apply_specific_filter_8+0x978>
lea    (%r15,%r11,1),%rdx
mov    %r13,%r10
sub    %r9,%r10
mov    %r11,%rax
sub    %r9,%rax
add    %r13,%rax
lea    (%r11,%r13,1),%rsi
cmp    %r15,%rax
seta   %dil
cmp    %rdx,%r10
setb   %bl
cmp    %r15,%rsi
seta   %al
cmp    %r13,%rdx
seta   %dl
xor    %esi,%esi
test   %bl,%dil
jne    18b9 <png_apply_specific_filter_8+0x7a9>
and    %dl,%al
jne    18b9 <png_apply_specific_filter_8+0x7a9>
cmp    $0x20,%ecx
jae    14dc <png_apply_specific_filter_8+0x3cc>
xor    %esi,%esi
jmp    187e <png_apply_specific_filter_8+0x76e>
lea    0x1(%r15),%rdx
lea    (%r15,%rax,1),%rsi
mov    %r13,%rcx
sub    %r10,%rcx
lea    0x1(%rcx),%rdi
mov    %rax,%rbp
sub    %r10,%rbp
add    %r13,%rbp
lea    (%rax,%r13,1),%rbx
cmp    %rbp,%rdx
setb   %r11b
cmp    %rsi,%rdi
setb   %dil
cmp    %rbx,%rdx
setb   %dl
cmp    %r13,%rsi
seta   %bl
test   %dil,%r11b
jne    125c <png_apply_specific_filter_8+0x14c>
and    %bl,%dl
jne    125c <png_apply_specific_filter_8+0x14c>
cmp    $0x10,%r8
jae    1643 <png_apply_specific_filter_8+0x533>
xor    %esi,%esi
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    0x1(%rcx),%r9
lea    0x1(%r13),%rdx
mov    %rdx,%rdi
sub    %r10,%rdi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   (%rdx,%rsi,1),%xmm1
movq   -0x1(%rdx,%rsi,1),%xmm2
punpcklbw %xmm0,%xmm2
movq   (%rdi,%rsi,1),%xmm3
punpcklbw %xmm0,%xmm3
paddw  %xmm2,%xmm3
psrlw  $0x1,%xmm3
packuswb %xmm3,%xmm3
psubb  %xmm3,%xmm1
movq   %xmm1,0x1(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1430 <png_apply_specific_filter_8+0x320>
cmp    %rcx,%r8
jne    125c <png_apply_specific_filter_8+0x14c>
jmp    1a88 <png_apply_specific_filter_8+0x978>
mov    %rcx,%rdx
cmp    $0x3,%rsi
jb     1a88 <png_apply_specific_filter_8+0x978>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x0(%r13,%rdx,1),%ecx
mov    %cl,(%r15,%rdx,1)
movzbl 0x1(%r13,%rdx,1),%ecx
mov    %cl,0x1(%r15,%rdx,1)
movzbl 0x2(%r13,%rdx,1),%ecx
mov    %cl,0x2(%r15,%rdx,1)
movzbl 0x3(%r13,%rdx,1),%ecx
mov    %cl,0x3(%r15,%rdx,1)
lea    0x4(%rdx),%rcx
mov    %rcx,%rdx
cmp    %rcx,%rax
jne    1490 <png_apply_specific_filter_8+0x380>
jmp    1a88 <png_apply_specific_filter_8+0x978>
cmp    $0x20,%ecx
jae    1578 <png_apply_specific_filter_8+0x468>
xor    %ecx,%ecx
jmp    1800 <png_apply_specific_filter_8+0x6f0>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rax,%rax
je     1830 <png_apply_specific_filter_8+0x720>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x30(%r13),%rax
mov    %rax,%rdi
sub    %r9,%rdi
xor    %ecx,%ecx
nopl   (%rax)
movdqu -0x30(%rax,%rcx,1),%xmm0
movdqu -0x20(%rax,%rcx,1),%xmm1
movdqu -0x30(%rdi,%rcx,1),%xmm2
psubb  %xmm2,%xmm0
movdqu -0x20(%rdi,%rcx,1),%xmm2
psubb  %xmm2,%xmm1
movdqu %xmm0,(%r15,%rcx,1)
movdqu %xmm1,0x10(%r15,%rcx,1)
movdqu -0x10(%rax,%rcx,1),%xmm0
movdqu (%rax,%rcx,1),%xmm1
movdqu -0x10(%rdi,%rcx,1),%xmm2
psubb  %xmm2,%xmm0
movdqu (%rdi,%rcx,1),%xmm2
psubb  %xmm2,%xmm1
movdqu %xmm0,0x20(%r15,%rcx,1)
movdqu %xmm1,0x30(%r15,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1510 <png_apply_specific_filter_8+0x400>
jmp    1832 <png_apply_specific_filter_8+0x722>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    172c <png_apply_specific_filter_8+0x61c>
xor    %edi,%edi
jmp    17ad <png_apply_specific_filter_8+0x69d>
mov    %rcx,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     191a <png_apply_specific_filter_8+0x80a>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu 0x0(%r13,%rsi,1),%xmm0
movdqu 0x1(%r13,%rsi,1),%xmm1
psubb  %xmm0,%xmm1
movdqu 0x10(%r13,%rsi,1),%xmm0
movdqu 0x11(%r13,%rsi,1),%xmm2
psubb  %xmm0,%xmm2
movdqu %xmm1,0x1(%r15,%rsi,1)
movdqu %xmm2,0x11(%r15,%rsi,1)
movdqu 0x20(%r13,%rsi,1),%xmm0
movdqu 0x21(%r13,%rsi,1),%xmm1
psubb  %xmm0,%xmm1
movdqu 0x30(%r13,%rsi,1),%xmm0
movdqu 0x31(%r13,%rsi,1),%xmm2
psubb  %xmm0,%xmm2
movdqu %xmm1,0x21(%r15,%rsi,1)
movdqu %xmm2,0x31(%r15,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    15d0 <png_apply_specific_filter_8+0x4c0>
jmp    191c <png_apply_specific_filter_8+0x80c>
mov    %r8,%rsi
and    $0xfffffffffffffff0,%rsi
lea    -0x10(%rsi),%rdx
mov    %rdx,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     19b0 <png_apply_specific_filter_8+0x8a0>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
add    $0x11,%rcx
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu 0x0(%r13,%rdi,1),%xmm1
movdqu 0x1(%r13,%rdi,1),%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm0,%xmm3
punpcklbw %xmm0,%xmm1
movdqu -0x10(%rcx,%rdi,1),%xmm4
movdqa %xmm4,%xmm5
punpckhbw %xmm0,%xmm5
paddw  %xmm3,%xmm5
punpcklbw %xmm0,%xmm4
paddw  %xmm1,%xmm4
psrlw  $0x1,%xmm5
psrlw  $0x1,%xmm4
packuswb %xmm5,%xmm4
psubb  %xmm4,%xmm2
movdqu %xmm2,0x1(%r15,%rdi,1)
movdqu 0x10(%r13,%rdi,1),%xmm1
movdqu 0x11(%r13,%rdi,1),%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm0,%xmm3
punpcklbw %xmm0,%xmm1
movdqu (%rcx,%rdi,1),%xmm4
movdqa %xmm4,%xmm5
punpckhbw %xmm0,%xmm5
paddw  %xmm3,%xmm5
punpcklbw %xmm0,%xmm4
paddw  %xmm1,%xmm4
psrlw  $0x1,%xmm5
psrlw  $0x1,%xmm4
packuswb %xmm5,%xmm4
psubb  %xmm4,%xmm2
movdqu %xmm2,0x11(%r15,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1680 <png_apply_specific_filter_8+0x570>
jmp    19b2 <png_apply_specific_filter_8+0x8a2>
movabs $0xffffffffffffffe,%rdi
ff ff 0f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
nop
movups 0x0(%r13,%rdi,1),%xmm0
movups 0x10(%r13,%rdi,1),%xmm1
movups %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
movups 0x20(%r13,%rdi,1),%xmm0
movups 0x30(%r13,%rdi,1),%xmm1
movups %xmm0,0x20(%r15,%rdi,1)
movups %xmm1,0x30(%r15,%rdi,1)
movups 0x40(%r13,%rdi,1),%xmm0
movups 0x50(%r13,%rdi,1),%xmm1
movups %xmm0,0x40(%r15,%rdi,1)
movups %xmm1,0x50(%r15,%rdi,1)
movdqu 0x60(%r13,%rdi,1),%xmm0
movdqu 0x70(%r13,%rdi,1),%xmm1
movdqu %xmm0,0x60(%r15,%rdi,1)
movdqu %xmm1,0x70(%r15,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1740 <png_apply_specific_filter_8+0x630>
test   %rdx,%rdx
je     17ef <png_apply_specific_filter_8+0x6df>
lea    (%r15,%rdi,1),%rsi
add    $0x10,%rsi
add    %r13,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rbp,1),%xmm0
movdqu (%rdi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    17d0 <png_apply_specific_filter_8+0x6c0>
cmp    %rax,%rcx
je     1a88 <png_apply_specific_filter_8+0x978>
test   $0x18,%al
je     116d <png_apply_specific_filter_8+0x5d>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rdx,1),%rsi
mov    %rsi,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1810 <png_apply_specific_filter_8+0x700>
cmp    %rax,%rcx
je     1a88 <png_apply_specific_filter_8+0x978>
jmp    116d <png_apply_specific_filter_8+0x5d>
xor    %ecx,%ecx
test   $0x1,%r8b
je     186f <png_apply_specific_filter_8+0x75f>
movdqu 0x0(%r13,%rcx,1),%xmm0
movdqu 0x10(%r13,%rcx,1),%xmm1
mov    %rcx,%rax
sub    %r9,%rax
movdqu 0x0(%r13,%rax,1),%xmm2
psubb  %xmm2,%xmm0
movdqu 0x10(%r13,%rax,1),%xmm2
psubb  %xmm2,%xmm1
movdqu %xmm0,(%r15,%rcx,1)
movdqu %xmm1,0x10(%r15,%rcx,1)
cmp    %r11,%rsi
je     1a88 <png_apply_specific_filter_8+0x978>
test   $0x18,%r11b
je     18b9 <png_apply_specific_filter_8+0x7a9>
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
nopw   0x0(%rax,%rax,1)
movq   0x0(%r13,%rax,1),%xmm0
movq   (%r10,%rax,1),%xmm1
psubb  %xmm1,%xmm0
movq   %xmm0,(%r15,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1890 <png_apply_specific_filter_8+0x780>
cmp    %r11,%rsi
je     1a88 <png_apply_specific_filter_8+0x978>
mov    %rsi,%rax
not    %rax
test   $0x1,%r11b
je     18dd <png_apply_specific_filter_8+0x7cd>
mov    0x0(%r13,%rsi,1),%cl
mov    %rsi,%rdx
sub    %r9,%rdx
sub    0x0(%r13,%rdx,1),%cl
mov    %cl,(%r15,%rsi,1)
or     $0x1,%rsi
add    %r11,%rax
je     1a88 <png_apply_specific_filter_8+0x978>
mov    %r13,%rax
sub    %r9,%rax
add    $0x1,%rax
movzbl 0x0(%r13,%rsi,1),%ecx
sub    -0x1(%rax,%rsi,1),%cl
mov    %cl,(%r15,%rsi,1)
movzbl 0x1(%r13,%rsi,1),%ecx
sub    (%rax,%rsi,1),%cl
mov    %cl,0x1(%r15,%rsi,1)
add    $0x2,%rsi
cmp    %rsi,%r11
jne    18f0 <png_apply_specific_filter_8+0x7e0>
jmp    1a88 <png_apply_specific_filter_8+0x978>
xor    %esi,%esi
test   $0x1,%r8b
je     195a <png_apply_specific_filter_8+0x84a>
mov    %rsi,%rdi
or     $0x1,%rdi
movdqu 0x0(%r13,%rdi,1),%xmm0
movdqu 0x10(%r13,%rdi,1),%xmm1
movdqu 0x0(%r13,%rsi,1),%xmm2
psubb  %xmm2,%xmm0
movdqu 0x10(%r13,%rsi,1),%xmm2
psubb  %xmm2,%xmm1
movdqu %xmm0,(%r15,%rdi,1)
movdqu %xmm1,0x10(%r15,%rdi,1)
cmp    %rdx,%rcx
je     1a88 <png_apply_specific_filter_8+0x978>
test   $0x18,%cl
je     1a31 <png_apply_specific_filter_8+0x921>
mov    %rcx,%rdi
and    $0xfffffffffffffff8,%rdi
lea    0x1(%rdi),%rsi
nopw   0x0(%rax,%rax,1)
movq   0x1(%r13,%rdx,1),%xmm0
movq   0x0(%r13,%rdx,1),%xmm1
psubb  %xmm1,%xmm0
movq   %xmm0,0x1(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    1980 <png_apply_specific_filter_8+0x870>
cmp    %rdi,%rcx
jne    1a38 <png_apply_specific_filter_8+0x928>
jmp    1a88 <png_apply_specific_filter_8+0x978>
xor    %edi,%edi
test   $0x1,%r9b
je     1a16 <png_apply_specific_filter_8+0x906>
mov    %rdi,%rcx
or     $0x1,%rcx
movdqu 0x0(%r13,%rcx,1),%xmm0
movdqu 0x0(%r13,%rdi,1),%xmm1
pxor   %xmm2,%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm2,%xmm3
punpcklbw %xmm2,%xmm1
mov    %rcx,%rdx
sub    %r10,%rdx
movdqu 0x0(%r13,%rdx,1),%xmm4
movdqa %xmm4,%xmm5
punpckhbw %xmm2,%xmm5
paddw  %xmm3,%xmm5
punpcklbw %xmm2,%xmm4
paddw  %xmm1,%xmm4
psrlw  $0x1,%xmm5
psrlw  $0x1,%xmm4
packuswb %xmm5,%xmm4
psubb  %xmm4,%xmm0
movdqu %xmm0,(%r15,%rcx,1)
cmp    %rsi,%r8
je     1a88 <png_apply_specific_filter_8+0x978>
test   $0x8,%r8b
jne    1409 <png_apply_specific_filter_8+0x2f9>
or     $0x1,%rsi
mov    %rsi,%r9
jmp    125c <png_apply_specific_filter_8+0x14c>
or     $0x1,%rdx
mov    %rdx,%rsi
mov    %rsi,%rcx
not    %rcx
test   $0x1,%al
jne    1a54 <png_apply_specific_filter_8+0x944>
mov    0x0(%r13,%rsi,1),%dl
sub    -0x1(%r13,%rsi,1),%dl
mov    %dl,(%r15,%rsi,1)
add    $0x1,%rsi
add    %rax,%rcx
je     1a88 <png_apply_specific_filter_8+0x978>
nopl   0x0(%rax)
movzbl 0x0(%r13,%rsi,1),%ecx
sub    -0x1(%r13,%rsi,1),%cl
mov    %cl,(%r15,%rsi,1)
movzbl 0x1(%r13,%rsi,1),%ecx
sub    0x0(%r13,%rsi,1),%cl
mov    %cl,0x1(%r15,%rsi,1)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1a60 <png_apply_specific_filter_8+0x950>
mov    0x4(%rsp),%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @png_apply_specific_filter_8(i32 returned %0, i8* nocapture writeonly %1, i8* nocapture %2, i32 %3) {
switch i32 %0, label %701 [
i32 0, label %146
i32 1, label %292
i32 2, label %5
i32 3, label %467
i32 4, label %671
]
5: ; preds = %4
%6 = icmp eq i32 %3, 0
br i1 %6, label %701, label %7
7: ; preds = %5
%8 = sext i32 %3 to i64
%9 = zext i32 %3 to i64
%10 = icmp ult i32 %3, 8
br i1 %10, label %128, label %11
11: ; preds = %7
%12 = getelementptr i8, i8* %1, i64 %9
%13 = sub nsw i64 0, %8
%14 = getelementptr i8, i8* %2, i64 %13
%15 = sub nsw i64 %9, %8
%16 = getelementptr i8, i8* %2, i64 %15
%17 = getelementptr i8, i8* %2, i64 %9
%18 = icmp ugt i8* %16, %1
%19 = icmp ult i8* %14, %12
%20 = and i1 %18, %19
%21 = icmp ugt i8* %17, %1
%22 = icmp ugt i8* %12, %2
%23 = and i1 %21, %22
%24 = or i1 %20, %23
br i1 %24, label %128, label %25
25: ; preds = %11
%26 = icmp ult i32 %3, 32
br i1 %26, label %109, label %27
27: ; preds = %25
%28 = and i64 %9, 4294967264
%29 = add nsw i64 %28, -32
%30 = lshr exact i64 %29, 5
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 1
%33 = icmp eq i64 %29, 0
br i1 %33, label %81, label %34
34: ; preds = %27
%35 = and i64 %31, 1152921504606846974
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %78, %36 ]
%38 = phi i64 [ 0, %34 ], [ %79, %36 ]
%39 = getelementptr inbounds i8, i8* %2, i64 %37
%40 = bitcast i8* %39 to <16 x i8>*
%41 = load <16 x i8>, <16 x i8>* %40
%42 = getelementptr inbounds i8, i8* %39, i64 16
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = sub nsw i64 %37, %8
%46 = getelementptr inbounds i8, i8* %2, i64 %45
%47 = bitcast i8* %46 to <16 x i8>*
%48 = load <16 x i8>, <16 x i8>* %47
%49 = getelementptr inbounds i8, i8* %46, i64 16
%50 = bitcast i8* %49 to <16 x i8>*
%51 = load <16 x i8>, <16 x i8>* %50
%52 = sub <16 x i8> %41, %48
%53 = sub <16 x i8> %44, %51
%54 = getelementptr inbounds i8, i8* %1, i64 %37
%55 = bitcast i8* %54 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %55
%56 = getelementptr inbounds i8, i8* %54, i64 16
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %57
%58 = or i64 %37, 32
%59 = getelementptr inbounds i8, i8* %2, i64 %58
%60 = bitcast i8* %59 to <16 x i8>*
%61 = load <16 x i8>, <16 x i8>* %60
%62 = getelementptr inbounds i8, i8* %59, i64 16
%63 = bitcast i8* %62 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = sub nsw i64 %58, %8
%66 = getelementptr inbounds i8, i8* %2, i64 %65
%67 = bitcast i8* %66 to <16 x i8>*
%68 = load <16 x i8>, <16 x i8>* %67
%69 = getelementptr inbounds i8, i8* %66, i64 16
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = sub <16 x i8> %61, %68
%73 = sub <16 x i8> %64, %71
%74 = getelementptr inbounds i8, i8* %1, i64 %58
%75 = bitcast i8* %74 to <16 x i8>*
store <16 x i8> %72, <16 x i8>* %75
%76 = getelementptr inbounds i8, i8* %74, i64 16
%77 = bitcast i8* %76 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %77
%78 = add nuw i64 %37, 64
%79 = add i64 %38, 2
%80 = icmp eq i64 %79, %35
br i1 %80, label %81, label %36
81: ; preds = %36, %27
%82 = phi i64 [ 0, %27 ], [ %78, %36 ]
%83 = icmp eq i64 %32, 0
br i1 %83, label %104, label %84
84: ; preds = %81
%85 = getelementptr inbounds i8, i8* %2, i64 %82
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %85, i64 16
%89 = bitcast i8* %88 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = sub nsw i64 %82, %8
%92 = getelementptr inbounds i8, i8* %2, i64 %91
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr inbounds i8, i8* %92, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
%97 = load <16 x i8>, <16 x i8>* %96
%98 = sub <16 x i8> %87, %94
%99 = sub <16 x i8> %90, %97
%100 = getelementptr inbounds i8, i8* %1, i64 %82
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %101
%102 = getelementptr inbounds i8, i8* %100, i64 16
%103 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> %99, <16 x i8>* %103
br label %104
104: ; preds = %81, %84
%105 = icmp eq i64 %28, %9
br i1 %105, label %701, label %106
106: ; preds = %104
%107 = and i64 %9, 24
%108 = icmp eq i64 %107, 0
br i1 %108, label %128, label %109
109: ; preds = %25, %106
%110 = phi i64 [ %28, %106 ], [ 0, %25 ]
%111 = and i64 %9, 4294967288
br label %112
112: ; preds = %112, %109
%113 = phi i64 [ %110, %109 ], [ %124, %112 ]
%114 = getelementptr inbounds i8, i8* %2, i64 %113
%115 = bitcast i8* %114 to <8 x i8>*
%116 = load <8 x i8>, <8 x i8>* %115
%117 = sub nsw i64 %113, %8
%118 = getelementptr inbounds i8, i8* %2, i64 %117
%119 = bitcast i8* %118 to <8 x i8>*
%120 = load <8 x i8>, <8 x i8>* %119
%121 = sub <8 x i8> %116, %120
%122 = getelementptr inbounds i8, i8* %1, i64 %113
%123 = bitcast i8* %122 to <8 x i8>*
store <8 x i8> %121, <8 x i8>* %123
%124 = add nuw i64 %113, 8
%125 = icmp eq i64 %124, %111
br i1 %125, label %126, label %112
126: ; preds = %112
%127 = icmp eq i64 %111, %9
br i1 %127, label %701, label %128
128: ; preds = %11, %7, %106, %126
%129 = phi i64 [ 0, %7 ], [ 0, %11 ], [ %28, %106 ], [ %111, %126 ]
%130 = xor i64 %129, -1
%131 = and i64 %9, 1
%132 = icmp eq i64 %131, 0
br i1 %132, label %142, label %133
133: ; preds = %128
%134 = getelementptr inbounds i8, i8* %2, i64 %129
%135 = load i8, i8* %134
%136 = sub nsw i64 %129, %8
%137 = getelementptr inbounds i8, i8* %2, i64 %136
%138 = load i8, i8* %137
%139 = sub i8 %135, %138
%140 = or i64 %129, 1
%141 = getelementptr inbounds i8, i8* %1, i64 %129
store i8 %139, i8* %141
br label %142
142: ; preds = %133, %128
%143 = phi i64 [ %129, %128 ], [ %140, %133 ]
%144 = sub nsw i64 0, %9
%145 = icmp eq i64 %130, %144
br i1 %145, label %701, label %448
146: ; preds = %4
%147 = icmp eq i32 %3, 0
br i1 %147, label %701, label %148
148: ; preds = %146
%149 = zext i32 %3 to i64
%150 = icmp ult i32 %3, 8
br i1 %150, label %255, label %151
151: ; preds = %148
%152 = getelementptr i8, i8* %1, i64 %149
%153 = getelementptr i8, i8* %2, i64 %149
%154 = icmp ugt i8* %153, %1
%155 = icmp ugt i8* %152, %2
%156 = and i1 %154, %155
br i1 %156, label %255, label %157
157: ; preds = %151
%158 = icmp ult i32 %3, 32
br i1 %158, label %241, label %159
159: ; preds = %157
%160 = and i64 %149, 4294967264
%161 = add nsw i64 %160, -32
%162 = lshr exact i64 %161, 5
%163 = add nuw nsw i64 %162, 1
%164 = and i64 %163, 3
%165 = icmp ult i64 %161, 96
br i1 %165, label %217, label %166
166: ; preds = %159
%167 = and i64 %163, 1152921504606846972
br label %168
168: ; preds = %168, %166
%169 = phi i64 [ 0, %166 ], [ %214, %168 ]
%170 = phi i64 [ 0, %166 ], [ %215, %168 ]
%171 = getelementptr inbounds i8, i8* %2, i64 %169
%172 = bitcast i8* %171 to <16 x i8>*
%173 = load <16 x i8>, <16 x i8>* %172
%174 = getelementptr inbounds i8, i8* %171, i64 16
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = getelementptr inbounds i8, i8* %1, i64 %169
%178 = bitcast i8* %177 to <16 x i8>*
store <16 x i8> %173, <16 x i8>* %178
%179 = getelementptr inbounds i8, i8* %177, i64 16
%180 = bitcast i8* %179 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %180
%181 = or i64 %169, 32
%182 = getelementptr inbounds i8, i8* %2, i64 %181
%183 = bitcast i8* %182 to <16 x i8>*
%184 = load <16 x i8>, <16 x i8>* %183
%185 = getelementptr inbounds i8, i8* %182, i64 16
%186 = bitcast i8* %185 to <16 x i8>*
%187 = load <16 x i8>, <16 x i8>* %186
%188 = getelementptr inbounds i8, i8* %1, i64 %181
%189 = bitcast i8* %188 to <16 x i8>*
store <16 x i8> %184, <16 x i8>* %189
%190 = getelementptr inbounds i8, i8* %188, i64 16
%191 = bitcast i8* %190 to <16 x i8>*
store <16 x i8> %187, <16 x i8>* %191
%192 = or i64 %169, 64
%193 = getelementptr inbounds i8, i8* %2, i64 %192
%194 = bitcast i8* %193 to <16 x i8>*
%195 = load <16 x i8>, <16 x i8>* %194
%196 = getelementptr inbounds i8, i8* %193, i64 16
%197 = bitcast i8* %196 to <16 x i8>*
%198 = load <16 x i8>, <16 x i8>* %197
%199 = getelementptr inbounds i8, i8* %1, i64 %192
%200 = bitcast i8* %199 to <16 x i8>*
store <16 x i8> %195, <16 x i8>* %200
%201 = getelementptr inbounds i8, i8* %199, i64 16
%202 = bitcast i8* %201 to <16 x i8>*
store <16 x i8> %198, <16 x i8>* %202
%203 = or i64 %169, 96
%204 = getelementptr inbounds i8, i8* %2, i64 %203
%205 = bitcast i8* %204 to <16 x i8>*
%206 = load <16 x i8>, <16 x i8>* %205
%207 = getelementptr inbounds i8, i8* %204, i64 16
%208 = bitcast i8* %207 to <16 x i8>*
%209 = load <16 x i8>, <16 x i8>* %208
%210 = getelementptr inbounds i8, i8* %1, i64 %203
%211 = bitcast i8* %210 to <16 x i8>*
store <16 x i8> %206, <16 x i8>* %211
%212 = getelementptr inbounds i8, i8* %210, i64 16
%213 = bitcast i8* %212 to <16 x i8>*
store <16 x i8> %209, <16 x i8>* %213
%214 = add nuw i64 %169, 128
%215 = add i64 %170, 4
%216 = icmp eq i64 %215, %167
br i1 %216, label %217, label %168
217: ; preds = %168, %159
%218 = phi i64 [ 0, %159 ], [ %214, %168 ]
%219 = icmp eq i64 %164, 0
br i1 %219, label %236, label %220
220: ; preds = %217, %220
%221 = phi i64 [ %233, %220 ], [ %218, %217 ]
%222 = phi i64 [ %234, %220 ], [ 0, %217 ]
%223 = getelementptr inbounds i8, i8* %2, i64 %221
%224 = bitcast i8* %223 to <16 x i8>*
%225 = load <16 x i8>, <16 x i8>* %224
%226 = getelementptr inbounds i8, i8* %223, i64 16
%227 = bitcast i8* %226 to <16 x i8>*
%228 = load <16 x i8>, <16 x i8>* %227
%229 = getelementptr inbounds i8, i8* %1, i64 %221
%230 = bitcast i8* %229 to <16 x i8>*
store <16 x i8> %225, <16 x i8>* %230
%231 = getelementptr inbounds i8, i8* %229, i64 16
%232 = bitcast i8* %231 to <16 x i8>*
store <16 x i8> %228, <16 x i8>* %232
%233 = add nuw i64 %221, 32
%234 = add i64 %222, 1
%235 = icmp eq i64 %234, %164
br i1 %235, label %236, label %220
236: ; preds = %220, %217
%237 = icmp eq i64 %160, %149
br i1 %237, label %701, label %238
238: ; preds = %236
%239 = and i64 %149, 24
%240 = icmp eq i64 %239, 0
br i1 %240, label %255, label %241
241: ; preds = %157, %238
%242 = phi i64 [ %160, %238 ], [ 0, %157 ]
%243 = and i64 %149, 4294967288
br label %244
244: ; preds = %244, %241
%245 = phi i64 [ %242, %241 ], [ %251, %244 ]
%246 = getelementptr inbounds i8, i8* %2, i64 %245
%247 = bitcast i8* %246 to <8 x i8>*
%248 = load <8 x i8>, <8 x i8>* %247
%249 = getelementptr inbounds i8, i8* %1, i64 %245
%250 = bitcast i8* %249 to <8 x i8>*
store <8 x i8> %248, <8 x i8>* %250
%251 = add nuw i64 %245, 8
%252 = icmp eq i64 %251, %243
br i1 %252, label %253, label %244
253: ; preds = %244
%254 = icmp eq i64 %243, %149
br i1 %254, label %701, label %255
255: ; preds = %151, %148, %238, %253
%256 = phi i64 [ 0, %148 ], [ 0, %151 ], [ %160, %238 ], [ %243, %253 ]
%257 = xor i64 %256, -1
%258 = add nsw i64 %257, %149
%259 = and i64 %149, 3
%260 = icmp eq i64 %259, 0
br i1 %260, label %270, label %261
261: ; preds = %255, %261
%262 = phi i64 [ %264, %261 ], [ %256, %255 ]
%263 = phi i64 [ %268, %261 ], [ 0, %255 ]
%264 = add nuw nsw i64 %262, 1
%265 = getelementptr inbounds i8, i8* %2, i64 %262
%266 = load i8, i8* %265
%267 = getelementptr inbounds i8, i8* %1, i64 %262
store i8 %266, i8* %267
%268 = add i64 %263, 1
%269 = icmp eq i64 %268, %259
br i1 %269, label %270, label %261
270: ; preds = %261, %255
%271 = phi i64 [ %256, %255 ], [ %264, %261 ]
%272 = icmp ult i64 %258, 3
br i1 %272, label %701, label %273
273: ; preds = %270, %273
%274 = phi i64 [ %287, %273 ], [ %271, %270 ]
%275 = add nuw nsw i64 %274, 1
%276 = getelementptr inbounds i8, i8* %2, i64 %274
%277 = load i8, i8* %276
%278 = getelementptr inbounds i8, i8* %1, i64 %274
store i8 %277, i8* %278
%279 = add nuw nsw i64 %274, 2
%280 = getelementptr inbounds i8, i8* %2, i64 %275
%281 = load i8, i8* %280
%282 = getelementptr inbounds i8, i8* %1, i64 %275
store i8 %281, i8* %282
%283 = add nuw nsw i64 %274, 3
%284 = getelementptr inbounds i8, i8* %2, i64 %279
%285 = load i8, i8* %284
%286 = getelementptr inbounds i8, i8* %1, i64 %279
store i8 %285, i8* %286
%287 = add nuw nsw i64 %274, 4
%288 = getelementptr inbounds i8, i8* %2, i64 %283
%289 = load i8, i8* %288
%290 = getelementptr inbounds i8, i8* %1, i64 %283
store i8 %289, i8* %290
%291 = icmp eq i64 %287, %149
br i1 %291, label %701, label %273
292: ; preds = %4
%293 = load i8, i8* %2
store i8 %293, i8* %1
%294 = icmp ugt i32 %3, 1
br i1 %294, label %295, label %701
295: ; preds = %292
%296 = zext i32 %3 to i64
%297 = add nsw i64 %296, -1
%298 = icmp ult i64 %297, 8
br i1 %298, label %412, label %299
299: ; preds = %295
%300 = getelementptr i8, i8* %1, i64 1
%301 = getelementptr i8, i8* %1, i64 %296
%302 = getelementptr i8, i8* %2, i64 %296
%303 = icmp ult i8* %300, %302
%304 = icmp ugt i8* %301, %2
%305 = and i1 %303, %304
br i1 %305, label %412, label %306
306: ; preds = %299
%307 = icmp ult i64 %297, 32
br i1 %307, label %391, label %308
308: ; preds = %306
%309 = and i64 %297, -32
%310 = add nsw i64 %309, -32
%311 = lshr exact i64 %310, 5
%312 = add nuw nsw i64 %311, 1
%313 = and i64 %312, 1
%314 = icmp eq i64 %310, 0
br i1 %314, label %362, label %315
315: ; preds = %308
%316 = and i64 %312, 1152921504606846974
br label %317
317: ; preds = %317, %315
%318 = phi i64 [ 0, %315 ], [ %359, %317 ]
%319 = phi i64 [ 0, %315 ], [ %360, %317 ]
%320 = or i64 %318, 1
%321 = getelementptr inbounds i8, i8* %2, i64 %320
%322 = bitcast i8* %321 to <16 x i8>*
%323 = load <16 x i8>, <16 x i8>* %322
%324 = getelementptr inbounds i8, i8* %321, i64 16
%325 = bitcast i8* %324 to <16 x i8>*
%326 = load <16 x i8>, <16 x i8>* %325
%327 = getelementptr inbounds i8, i8* %2, i64 %318
%328 = bitcast i8* %327 to <16 x i8>*
%329 = load <16 x i8>, <16 x i8>* %328
%330 = getelementptr inbounds i8, i8* %327, i64 16
%331 = bitcast i8* %330 to <16 x i8>*
%332 = load <16 x i8>, <16 x i8>* %331
%333 = sub <16 x i8> %323, %329
%334 = sub <16 x i8> %326, %332
%335 = getelementptr inbounds i8, i8* %1, i64 %320
%336 = bitcast i8* %335 to <16 x i8>*
store <16 x i8> %333, <16 x i8>* %336
%337 = getelementptr inbounds i8, i8* %335, i64 16
%338 = bitcast i8* %337 to <16 x i8>*
store <16 x i8> %334, <16 x i8>* %338
%339 = or i64 %318, 32
%340 = or i64 %318, 33
%341 = getelementptr inbounds i8, i8* %2, i64 %340
%342 = bitcast i8* %341 to <16 x i8>*
%343 = load <16 x i8>, <16 x i8>* %342
%344 = getelementptr inbounds i8, i8* %341, i64 16
%345 = bitcast i8* %344 to <16 x i8>*
%346 = load <16 x i8>, <16 x i8>* %345
%347 = getelementptr inbounds i8, i8* %2, i64 %339
%348 = bitcast i8* %347 to <16 x i8>*
%349 = load <16 x i8>, <16 x i8>* %348
%350 = getelementptr inbounds i8, i8* %347, i64 16
%351 = bitcast i8* %350 to <16 x i8>*
%352 = load <16 x i8>, <16 x i8>* %351
%353 = sub <16 x i8> %343, %349
%354 = sub <16 x i8> %346, %352
%355 = getelementptr inbounds i8, i8* %1, i64 %340
%356 = bitcast i8* %355 to <16 x i8>*
store <16 x i8> %353, <16 x i8>* %356
%357 = getelementptr inbounds i8, i8* %355, i64 16
%358 = bitcast i8* %357 to <16 x i8>*
store <16 x i8> %354, <16 x i8>* %358
%359 = add nuw i64 %318, 64
%360 = add i64 %319, 2
%361 = icmp eq i64 %360, %316
br i1 %361, label %362, label %317
362: ; preds = %317, %308
%363 = phi i64 [ 0, %308 ], [ %359, %317 ]
%364 = icmp eq i64 %313, 0
br i1 %364, label %385, label %365
365: ; preds = %362
%366 = or i64 %363, 1
%367 = getelementptr inbounds i8, i8* %2, i64 %366
%368 = bitcast i8* %367 to <16 x i8>*
%369 = load <16 x i8>, <16 x i8>* %368
%370 = getelementptr inbounds i8, i8* %367, i64 16
%371 = bitcast i8* %370 to <16 x i8>*
%372 = load <16 x i8>, <16 x i8>* %371
%373 = getelementptr inbounds i8, i8* %2, i64 %363
%374 = bitcast i8* %373 to <16 x i8>*
%375 = load <16 x i8>, <16 x i8>* %374
%376 = getelementptr inbounds i8, i8* %373, i64 16
%377 = bitcast i8* %376 to <16 x i8>*
%378 = load <16 x i8>, <16 x i8>* %377
%379 = sub <16 x i8> %369, %375
%380 = sub <16 x i8> %372, %378
%381 = getelementptr inbounds i8, i8* %1, i64 %366
%382 = bitcast i8* %381 to <16 x i8>*
store <16 x i8> %379, <16 x i8>* %382
%383 = getelementptr inbounds i8, i8* %381, i64 16
%384 = bitcast i8* %383 to <16 x i8>*
store <16 x i8> %380, <16 x i8>* %384
br label %385
385: ; preds = %362, %365
%386 = icmp eq i64 %297, %309
br i1 %386, label %701, label %387
387: ; preds = %385
%388 = or i64 %309, 1
%389 = and i64 %297, 24
%390 = icmp eq i64 %389, 0
br i1 %390, label %412, label %391
391: ; preds = %306, %387
%392 = phi i64 [ %309, %387 ], [ 0, %306 ]
%393 = add nsw i64 %296, -1
%394 = and i64 %393, -8
%395 = or i64 %394, 1
br label %396
396: ; preds = %396, %391
%397 = phi i64 [ %392, %391 ], [ %408, %396 ]
%398 = or i64 %397, 1
%399 = getelementptr inbounds i8, i8* %2, i64 %398
%400 = bitcast i8* %399 to <8 x i8>*
%401 = load <8 x i8>, <8 x i8>* %400
%402 = getelementptr inbounds i8, i8* %2, i64 %397
%403 = bitcast i8* %402 to <8 x i8>*
%404 = load <8 x i8>, <8 x i8>* %403
%405 = sub <8 x i8> %401, %404
%406 = getelementptr inbounds i8, i8* %1, i64 %398
%407 = bitcast i8* %406 to <8 x i8>*
store <8 x i8> %405, <8 x i8>* %407
%408 = add nuw i64 %397, 8
%409 = icmp eq i64 %408, %394
br i1 %409, label %410, label %396
410: ; preds = %396
%411 = icmp eq i64 %393, %394
br i1 %411, label %701, label %412
412: ; preds = %299, %295, %387, %410
%413 = phi i64 [ 1, %295 ], [ 1, %299 ], [ %388, %387 ], [ %395, %410 ]
%414 = xor i64 %413, -1
%415 = and i64 %296, 1
%416 = icmp eq i64 %415, 0
br i1 %416, label %417, label %426
417: ; preds = %412
%418 = getelementptr inbounds i8, i8* %2, i64 %413
%419 = load i8, i8* %418
%420 = add nsw i64 %413, -1
%421 = getelementptr inbounds i8, i8* %2, i64 %420
%422 = load i8, i8* %421
%423 = sub i8 %419, %422
%424 = add nuw nsw i64 %413, 1
%425 = getelementptr inbounds i8, i8* %1, i64 %413
store i8 %423, i8* %425
br label %426
426: ; preds = %417, %412
%427 = phi i64 [ %413, %412 ], [ %424, %417 ]
%428 = sub nsw i64 0, %296
%429 = icmp eq i64 %414, %428
br i1 %429, label %701, label %430
430: ; preds = %426, %430
%431 = phi i64 [ %445, %430 ], [ %427, %426 ]
%432 = getelementptr inbounds i8, i8* %2, i64 %431
%433 = load i8, i8* %432
%434 = add nsw i64 %431, -1
%435 = getelementptr inbounds i8, i8* %2, i64 %434
%436 = load i8, i8* %435
%437 = sub i8 %433, %436
%438 = add nuw nsw i64 %431, 1
%439 = getelementptr inbounds i8, i8* %1, i64 %431
store i8 %437, i8* %439
%440 = getelementptr inbounds i8, i8* %2, i64 %438
%441 = load i8, i8* %440
%442 = getelementptr inbounds i8, i8* %2, i64 %431
%443 = load i8, i8* %442
%444 = sub i8 %441, %443
%445 = add nuw nsw i64 %431, 2
%446 = getelementptr inbounds i8, i8* %1, i64 %438
store i8 %444, i8* %446
%447 = icmp eq i64 %445, %296
br i1 %447, label %701, label %430
448: ; preds = %142, %448
%449 = phi i64 [ %464, %448 ], [ %143, %142 ]
%450 = getelementptr inbounds i8, i8* %2, i64 %449
%451 = load i8, i8* %450
%452 = sub nsw i64 %449, %8
%453 = getelementptr inbounds i8, i8* %2, i64 %452
%454 = load i8, i8* %453
%455 = sub i8 %451, %454
%456 = add nuw nsw i64 %449, 1
%457 = getelementptr inbounds i8, i8* %1, i64 %449
store i8 %455, i8* %457
%458 = getelementptr inbounds i8, i8* %2, i64 %456
%459 = load i8, i8* %458
%460 = sub nsw i64 %456, %8
%461 = getelementptr inbounds i8, i8* %2, i64 %460
%462 = load i8, i8* %461
%463 = sub i8 %459, %462
%464 = add nuw nsw i64 %449, 2
%465 = getelementptr inbounds i8, i8* %1, i64 %456
store i8 %463, i8* %465
%466 = icmp eq i64 %464, %9
br i1 %466, label %701, label %448
467: ; preds = %4
%468 = load i8, i8* %2
%469 = sub nsw i32 0, %3
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds i8, i8* %2, i64 %470
%472 = load i8, i8* %471
%473 = lshr i8 %472, 1
%474 = sub i8 %468, %473
store i8 %474, i8* %1
%475 = icmp ugt i32 %3, 1
br i1 %475, label %476, label %701
476: ; preds = %467
%477 = sext i32 %3 to i64
%478 = zext i32 %3 to i64
%479 = add nsw i64 %478, -1
%480 = icmp ult i64 %479, 8
br i1 %480, label %611, label %481
481: ; preds = %476
%482 = getelementptr i8, i8* %1, i64 1
%483 = getelementptr i8, i8* %1, i64 %478
%484 = sub nsw i64 1, %477
%485 = getelementptr i8, i8* %2, i64 %484
%486 = sub nsw i64 %478, %477
%487 = getelementptr i8, i8* %2, i64 %486
%488 = getelementptr i8, i8* %2, i64 %478
%489 = icmp ult i8* %482, %487
%490 = icmp ult i8* %485, %483
%491 = and i1 %489, %490
%492 = icmp ult i8* %482, %488
%493 = icmp ugt i8* %483, %2
%494 = and i1 %492, %493
%495 = or i1 %491, %494
br i1 %495, label %611, label %496
496: ; preds = %481
%497 = icmp ult i64 %479, 16
br i1 %497, label %581, label %498
498: ; preds = %496
%499 = and i64 %479, -16
%500 = add nsw i64 %499, -16
%501 = lshr exact i64 %500, 4
%502 = add nuw nsw i64 %501, 1
%503 = and i64 %502, 1
%504 = icmp eq i64 %500, 0
br i1 %504, label %552, label %505
505: ; preds = %498
%506 = and i64 %502, 2305843009213693950
br label %507
507: ; preds = %507, %505
%508 = phi i64 [ 0, %505 ], [ %549, %507 ]
%509 = phi i64 [ 0, %505 ], [ %550, %507 ]
%510 = or i64 %508, 1
%511 = getelementptr inbounds i8, i8* %2, i64 %510
%512 = bitcast i8* %511 to <16 x i8>*
%513 = load <16 x i8>, <16 x i8>* %512
%514 = getelementptr inbounds i8, i8* %2, i64 %508
%515 = bitcast i8* %514 to <16 x i8>*
%516 = load <16 x i8>, <16 x i8>* %515
%517 = zext <16 x i8> %516 to <16 x i16>
%518 = sub nsw i64 %510, %477
%519 = getelementptr inbounds i8, i8* %2, i64 %518
%520 = bitcast i8* %519 to <16 x i8>*
%521 = load <16 x i8>, <16 x i8>* %520
%522 = zext <16 x i8> %521 to <16 x i16>
%523 = add nuw nsw <16 x i16> %522, %517
%524 = lshr <16 x i16> %523, <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>
%525 = trunc <16 x i16> %524 to <16 x i8>
%526 = sub <16 x i8> %513, %525
%527 = getelementptr inbounds i8, i8* %1, i64 %510
%528 = bitcast i8* %527 to <16 x i8>*
store <16 x i8> %526, <16 x i8>* %528
%529 = or i64 %508, 16
%530 = or i64 %508, 17
%531 = getelementptr inbounds i8, i8* %2, i64 %530
%532 = bitcast i8* %531 to <16 x i8>*
%533 = load <16 x i8>, <16 x i8>* %532
%534 = getelementptr inbounds i8, i8* %2, i64 %529
%535 = bitcast i8* %534 to <16 x i8>*
%536 = load <16 x i8>, <16 x i8>* %535
%537 = zext <16 x i8> %536 to <16 x i16>
%538 = sub nsw i64 %530, %477
%539 = getelementptr inbounds i8, i8* %2, i64 %538
%540 = bitcast i8* %539 to <16 x i8>*
%541 = load <16 x i8>, <16 x i8>* %540
%542 = zext <16 x i8> %541 to <16 x i16>
%543 = add nuw nsw <16 x i16> %542, %537
%544 = lshr <16 x i16> %543, <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>
%545 = trunc <16 x i16> %544 to <16 x i8>
%546 = sub <16 x i8> %533, %545
%547 = getelementptr inbounds i8, i8* %1, i64 %530
%548 = bitcast i8* %547 to <16 x i8>*
store <16 x i8> %546, <16 x i8>* %548
%549 = add nuw i64 %508, 32
%550 = add i64 %509, 2
%551 = icmp eq i64 %550, %506
br i1 %551, label %552, label %507
552: ; preds = %507, %498
%553 = phi i64 [ 0, %498 ], [ %549, %507 ]
%554 = icmp eq i64 %503, 0
br i1 %554, label %575, label %555
555: ; preds = %552
%556 = or i64 %553, 1
%557 = getelementptr inbounds i8, i8* %2, i64 %556
%558 = bitcast i8* %557 to <16 x i8>*
%559 = load <16 x i8>, <16 x i8>* %558
%560 = getelementptr inbounds i8, i8* %2, i64 %553
%561 = bitcast i8* %560 to <16 x i8>*
%562 = load <16 x i8>, <16 x i8>* %561
%563 = zext <16 x i8> %562 to <16 x i16>
%564 = sub nsw i64 %556, %477
%565 = getelementptr inbounds i8, i8* %2, i64 %564
%566 = bitcast i8* %565 to <16 x i8>*
%567 = load <16 x i8>, <16 x i8>* %566
%568 = zext <16 x i8> %567 to <16 x i16>
%569 = add nuw nsw <16 x i16> %568, %563
%570 = lshr <16 x i16> %569, <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>
%571 = trunc <16 x i16> %570 to <16 x i8>
%572 = sub <16 x i8> %559, %571
%573 = getelementptr inbounds i8, i8* %1, i64 %556
%574 = bitcast i8* %573 to <16 x i8>*
store <16 x i8> %572, <16 x i8>* %574
br label %575
575: ; preds = %552, %555
%576 = icmp eq i64 %479, %499
br i1 %576, label %701, label %577
577: ; preds = %575
%578 = or i64 %499, 1
%579 = and i64 %479, 8
%580 = icmp eq i64 %579, 0
br i1 %580, label %611, label %581
581: ; preds = %496, %577
%582 = phi i64 [ %499, %577 ], [ 0, %496 ]
%583 = add nsw i64 %478, -1
%584 = and i64 %583, -8
%585 = or i64 %584, 1
br label %586
586: ; preds = %586, %581
%587 = phi i64 [ %582, %581 ], [ %607, %586 ]
%588 = or i64 %587, 1
%589 = getelementptr inbounds i8, i8* %2, i64 %588
%590 = bitcast i8* %589 to <8 x i8>*
%591 = load <8 x i8>, <8 x i8>* %590
%592 = getelementptr inbounds i8, i8* %2, i64 %587
%593 = bitcast i8* %592 to <8 x i8>*
%594 = load <8 x i8>, <8 x i8>* %593
%595 = zext <8 x i8> %594 to <8 x i16>
%596 = sub nsw i64 %588, %477
%597 = getelementptr inbounds i8, i8* %2, i64 %596
%598 = bitcast i8* %597 to <8 x i8>*
%599 = load <8 x i8>, <8 x i8>* %598
%600 = zext <8 x i8> %599 to <8 x i16>
%601 = add nuw nsw <8 x i16> %600, %595
%602 = lshr <8 x i16> %601, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%603 = trunc <8 x i16> %602 to <8 x i8>
%604 = sub <8 x i8> %591, %603
%605 = getelementptr inbounds i8, i8* %1, i64 %588
%606 = bitcast i8* %605 to <8 x i8>*
store <8 x i8> %604, <8 x i8>* %606
%607 = add nuw i64 %587, 8
%608 = icmp eq i64 %607, %584
br i1 %608, label %609, label %586
609: ; preds = %586
%610 = icmp eq i64 %583, %584
br i1 %610, label %701, label %611
611: ; preds = %481, %476, %577, %609
%612 = phi i64 [ 1, %476 ], [ 1, %481 ], [ %578, %577 ], [ %585, %609 ]
%613 = xor i64 %612, -1
%614 = and i64 %478, 1
%615 = icmp eq i64 %614, 0
br i1 %615, label %616, label %633
616: ; preds = %611
%617 = getelementptr inbounds i8, i8* %2, i64 %612
%618 = load i8, i8* %617
%619 = add nsw i64 %612, -1
%620 = getelementptr inbounds i8, i8* %2, i64 %619
%621 = load i8, i8* %620
%622 = zext i8 %621 to i16
%623 = sub nsw i64 %612, %477
%624 = getelementptr inbounds i8, i8* %2, i64 %623
%625 = load i8, i8* %624
%626 = zext i8 %625 to i16
%627 = add nuw nsw i16 %626, %622
%628 = lshr i16 %627, 1
%629 = trunc i16 %628 to i8
%630 = sub i8 %618, %629
%631 = add nuw nsw i64 %612, 1
%632 = getelementptr inbounds i8, i8* %1, i64 %612
store i8 %630, i8* %632
br label %633
633: ; preds = %616, %611
%634 = phi i64 [ %612, %611 ], [ %631, %616 ]
%635 = sub nsw i64 0, %478
%636 = icmp eq i64 %613, %635
br i1 %636, label %701, label %637
637: ; preds = %633, %637
%638 = phi i64 [ %668, %637 ], [ %634, %633 ]
%639 = getelementptr inbounds i8, i8* %2, i64 %638
%640 = load i8, i8* %639
%641 = add nsw i64 %638, -1
%642 = getelementptr inbounds i8, i8* %2, i64 %641
%643 = load i8, i8* %642
%644 = zext i8 %643 to i16
%645 = sub nsw i64 %638, %477
%646 = getelementptr inbounds i8, i8* %2, i64 %645
%647 = load i8, i8* %646
%648 = zext i8 %647 to i16
%649 = add nuw nsw i16 %648, %644
%650 = lshr i16 %649, 1
%651 = trunc i16 %650 to i8
%652 = sub i8 %640, %651
%653 = add nuw nsw i64 %638, 1
%654 = getelementptr inbounds i8, i8* %1, i64 %638
store i8 %652, i8* %654
%655 = getelementptr inbounds i8, i8* %2, i64 %653
%656 = load i8, i8* %655
%657 = getelementptr inbounds i8, i8* %2, i64 %638
%658 = load i8, i8* %657
%659 = zext i8 %658 to i16
%660 = sub nsw i64 %653, %477
%661 = getelementptr inbounds i8, i8* %2, i64 %660
%662 = load i8, i8* %661
%663 = zext i8 %662 to i16
%664 = add nuw nsw i16 %663, %659
%665 = lshr i16 %664, 1
%666 = trunc i16 %665 to i8
%667 = sub i8 %656, %666
%668 = add nuw nsw i64 %638, 2
%669 = getelementptr inbounds i8, i8* %1, i64 %653
store i8 %667, i8* %669
%670 = icmp eq i64 %668, %478
br i1 %670, label %701, label %637
671: ; preds = %4
%672 = load i8, i8* %2
%673 = sub nsw i32 0, %3
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds i8, i8* %2, i64 %674
%676 = load i8, i8* %675
%677 = tail call zeroext i8 @PaethPredictor(i8 zeroext 0, i8 zeroext %676, i8 zeroext 0)
%678 = sub i8 %672, %677
store i8 %678, i8* %1
%679 = icmp ugt i32 %3, 1
br i1 %679, label %680, label %701
680: ; preds = %671
%681 = sext i32 %3 to i64
%682 = zext i32 %3 to i64
br label %683
683: ; preds = %680, %683
%684 = phi i64 [ 1, %680 ], [ %698, %683 ]
%685 = getelementptr inbounds i8, i8* %2, i64 %684
%686 = load i8, i8* %685
%687 = add nsw i64 %684, -1
%688 = getelementptr inbounds i8, i8* %2, i64 %687
%689 = load i8, i8* %688
%690 = sub nsw i64 %684, %681
%691 = getelementptr inbounds i8, i8* %2, i64 %690
%692 = load i8, i8* %691
%693 = sub nsw i64 %687, %681
%694 = getelementptr inbounds i8, i8* %2, i64 %693
%695 = load i8, i8* %694
%696 = tail call zeroext i8 @PaethPredictor(i8 zeroext %689, i8 zeroext %692, i8 zeroext %695)
%697 = sub i8 %686, %696
%698 = add nuw nsw i64 %684, 1
%699 = getelementptr inbounds i8, i8* %1, i64 %684
store i8 %697, i8* %699
%700 = icmp eq i64 %698, %682
br i1 %700, label %701, label %683
701: ; preds = %683, %633, %637, %142, %448, %426, %430, %270, %273, %575, %609, %104, %126, %385, %410, %236, %253, %671, %467, %5, %292, %146, %4
ret i32 %0
}