#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);
void applyfilter3(int mode, unsigned char *src, unsigned char *old,
                  unsigned char *dest, unsigned width) {
  int x;
  unsigned char lastr = 0;
  unsigned char lastg = 0;
  unsigned char lastb = 0;
  unsigned char upperlastr = 0;
  unsigned char upperlastg = 0;
  unsigned char upperlastb = 0;
  if (mode == 0) {
    for (x = 0; x < width; x++) {
      dest[0] = 255;
      dest[1] = src[0];
      dest[2] = src[1];
      dest[3] = src[2];
      dest += 4;
      src += 3;
    }
  } else if (mode == 1) {
    for (x = 0; x < width; x++) {
      dest[0] = 255;
      dest[1] = src[0] + lastr;
      dest[2] = src[1] + lastg;
      dest[3] = src[2] + lastb;
      lastr = dest[1];
      lastg = dest[2];
      lastb = dest[3];
      dest += 4;
      src += 3;
    }
  } else if (mode == 2) {
    for (x = 0; x < width; x++) {
      dest[0] = 255;
      dest[1] = src[0] + old[1];
      dest[2] = src[1] + old[2];
      dest[3] = src[2] + old[3];
      dest += 4;
      old += 4;
      src += 3;
    }
  } else if (mode == 3) {
    for (x = 0; x < width; x++) {
      dest[0] = 255;
      dest[1] = src[0] + (old[1] + lastr) / 2;
      dest[2] = src[1] + (old[2] + lastg) / 2;
      dest[3] = src[2] + (old[3] + lastb) / 2;
      lastr = dest[1];
      lastg = dest[2];
      lastb = dest[3];
      dest += 4;
      old += 4;
      src += 3;
    }
  } else if (mode == 4) {
    for (x = 0; x < width; x++) {
      dest[0] = 255;
      dest[1] = src[0] + PaethPredictor(lastr, old[1], upperlastr);
      dest[2] = src[1] + PaethPredictor(lastg, old[2], upperlastg);
      dest[3] = src[2] + PaethPredictor(lastb, old[3], upperlastb);
      lastr = dest[1];
      lastg = dest[2];
      lastb = dest[3];
      upperlastr = old[1];
      upperlastg = old[2];
      upperlastb = old[3];
      dest += 4;
      old += 4;
      src += 3;
    }
  }
}


x86 assembly (clang, -O0):
<applyfilter3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movb   $0x0,-0x29(%rbp)
movb   $0x0,-0x2a(%rbp)
movb   $0x0,-0x2b(%rbp)
movb   $0x0,-0x2c(%rbp)
movb   $0x0,-0x2d(%rbp)
movb   $0x0,-0x2e(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    11bb <applyfilter3+0xab>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    11b6 <applyfilter3+0xa6>
mov    -0x20(%rbp),%rax
movb   $0xff,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1154 <applyfilter3+0x44>
jmp    1571 <applyfilter3+0x461>
cmpl   $0x1,-0x4(%rbp)
jne    126c <applyfilter3+0x15c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1267 <applyfilter3+0x157>
mov    -0x20(%rbp),%rax
movb   $0xff,(%rax)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x29(%rbp),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
movzbl -0x2a(%rbp),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
movzbl -0x2b(%rbp),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x20(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x2a(%rbp)
mov    -0x20(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x2b(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11cc <applyfilter3+0xbc>
jmp    156c <applyfilter3+0x45c>
cmpl   $0x2,-0x4(%rbp)
jne    1317 <applyfilter3+0x207>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1312 <applyfilter3+0x202>
mov    -0x20(%rbp),%rax
movb   $0xff,(%rax)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    127d <applyfilter3+0x16d>
jmp    1567 <applyfilter3+0x457>
cmpl   $0x3,-0x4(%rbp)
jne    1422 <applyfilter3+0x312>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    141d <applyfilter3+0x30d>
mov    -0x20(%rbp),%rax
movb   $0xff,(%rax)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
movzbl -0x29(%rbp),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
movzbl -0x2a(%rbp),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x38(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
movzbl -0x2b(%rbp),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x20(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x2a(%rbp)
mov    -0x20(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x2b(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1328 <applyfilter3+0x218>
jmp    1562 <applyfilter3+0x452>
cmpl   $0x4,-0x4(%rbp)
jne    155d <applyfilter3+0x44d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1558 <applyfilter3+0x448>
mov    -0x20(%rbp),%rax
movb   $0xff,(%rax)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x48(%rbp)
mov    -0x29(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    0x1(%rax),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x2c(%rbp),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x48(%rbp),%eax
movzbl %cl,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x2a(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    0x2(%rax),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x2d(%rbp),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x44(%rbp),%eax
movzbl %cl,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x2b(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    0x3(%rax),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x2e(%rbp),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x40(%rbp),%eax
movzbl %cl,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x20(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x2a(%rbp)
mov    -0x20(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x2b(%rbp)
mov    -0x18(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x2d(%rbp)
mov    -0x18(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x2e(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1433 <applyfilter3+0x323>
jmp    155d <applyfilter3+0x44d>
jmp    1562 <applyfilter3+0x452>
jmp    1567 <applyfilter3+0x457>
jmp    156c <applyfilter3+0x45c>
jmp    1571 <applyfilter3+0x461>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<applyfilter3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
cmp    $0x4,%edi
ja     142b <applyfilter3+0x31b>
mov    %rcx,%r14
mov    %rdx,%r13
mov    %rsi,%r12
mov    %edi,%eax
lea    0xec7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %r8d,%r8d
je     142b <applyfilter3+0x31b>
cmp    $0x1,%r8d
je     11b1 <applyfilter3+0xa1>
mov    %r8d,%eax
and    $0xfffffffe,%eax
nopw   0x0(%rax,%rax,1)
movb   $0xff,(%r14)
movzbl (%r12),%ecx
mov    %cl,0x1(%r14)
movzbl 0x1(%r12),%ecx
mov    %cl,0x2(%r14)
movzbl 0x2(%r12),%ecx
mov    %cl,0x3(%r14)
movb   $0xff,0x4(%r14)
movzbl 0x3(%r12),%ecx
mov    %cl,0x5(%r14)
movzbl 0x4(%r12),%ecx
mov    %cl,0x6(%r14)
movzbl 0x5(%r12),%ecx
mov    %cl,0x7(%r14)
add    $0x8,%r14
add    $0x6,%r12
add    $0xfffffffe,%eax
jne    1160 <applyfilter3+0x50>
test   $0x1,%r8b
je     142b <applyfilter3+0x31b>
movb   $0xff,(%r14)
mov    (%r12),%al
mov    %al,0x1(%r14)
mov    0x1(%r12),%al
mov    %al,0x2(%r14)
mov    0x2(%r12),%al
mov    %al,0x3(%r14)
jmp    142b <applyfilter3+0x31b>
test   %r8d,%r8d
je     142b <applyfilter3+0x31b>
xor    %eax,%eax
cmp    $0x1,%r8d
jne    139d <applyfilter3+0x28d>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1407 <applyfilter3+0x2f7>
test   %r8d,%r8d
je     142b <applyfilter3+0x31b>
mov    %r8d,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movb   $0xff,(%r14,%rcx,4)
movzbl 0x1(%r13,%rcx,4),%edx
add    (%r12),%dl
mov    %dl,0x1(%r14,%rcx,4)
movzbl 0x2(%r13,%rcx,4),%edx
add    0x1(%r12),%dl
mov    %dl,0x2(%r14,%rcx,4)
movzbl 0x3(%r13,%rcx,4),%edx
add    0x2(%r12),%dl
mov    %dl,0x3(%r14,%rcx,4)
add    $0x1,%rcx
add    $0x3,%r12
cmp    %ecx,%eax
jne    1210 <applyfilter3+0x100>
jmp    142b <applyfilter3+0x31b>
test   %r8d,%r8d
je     142b <applyfilter3+0x31b>
mov    %r8d,%eax
xor    %ecx,%ecx
xor    %edx,%edx
xor    %esi,%esi
xor    %edi,%edi
nopl   0x0(%rax)
movb   $0xff,(%r14,%rcx,4)
movzbl 0x1(%r13,%rcx,4),%ebp
movzbl %dil,%edi
add    %ebp,%edi
shr    %edi
add    (%r12),%dil
mov    %dil,0x1(%r14,%rcx,4)
movzbl 0x2(%r13,%rcx,4),%ebp
movzbl %sil,%esi
add    %ebp,%esi
shr    %esi
add    0x1(%r12),%sil
mov    %sil,0x2(%r14,%rcx,4)
movzbl 0x2(%r12),%ebp
movzbl 0x3(%r13,%rcx,4),%ebx
movzbl %dl,%edx
add    %ebx,%edx
shr    %edx
add    %ebp,%edx
mov    %dl,0x3(%r14,%rcx,4)
add    $0x1,%rcx
add    $0x3,%r12
cmp    %ecx,%eax
jne    1270 <applyfilter3+0x160>
jmp    142b <applyfilter3+0x31b>
test   %r8d,%r8d
je     142b <applyfilter3+0x31b>
mov    %r8d,%eax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
xor    %edx,%edx
xor    %esi,%esi
xor    %eax,%eax
xor    %ebx,%ebx
xor    %edi,%edi
xor    %ecx,%ecx
xchg   %ax,%ax
mov    %rdi,0x10(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdx,0x20(%rsp)
movb   $0xff,(%r14,%rbp,4)
movzbl (%r12),%r15d
movzbl 0x1(%r13,%rbp,4),%esi
movzbl %cl,%edi
movzbl %al,%edx
call   1030 <PaethPredictor@plt>
add    %r15b,%al
mov    %al,0x1(%r14,%rbp,4)
movzbl 0x1(%r12),%r15d
movzbl 0x2(%r13,%rbp,4),%esi
movzbl 0x10(%rsp),%edi
movzbl 0x18(%rsp),%edx
call   1030 <PaethPredictor@plt>
add    %r15b,%al
mov    %al,0x2(%r14,%rbp,4)
movzbl 0x2(%r12),%r15d
movzbl 0x3(%r13,%rbp,4),%esi
movzbl %bl,%edi
movzbl 0x20(%rsp),%edx
call   1030 <PaethPredictor@plt>
mov    %eax,%ebx
add    %r15b,%bl
mov    %bl,0x3(%r14,%rbp,4)
movzbl 0x1(%r14,%rbp,4),%ecx
movzbl 0x2(%r14,%rbp,4),%edi
movzbl 0x1(%r13,%rbp,4),%eax
movzbl 0x2(%r13,%rbp,4),%esi
movzbl 0x3(%r13,%rbp,4),%edx
add    $0x1,%rbp
add    $0x3,%r12
cmp    %ebp,0x8(%rsp)
jne    12f0 <applyfilter3+0x1e0>
jmp    142b <applyfilter3+0x31b>
mov    %r8d,%esi
and    $0xfffffffe,%esi
xor    %ecx,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movb   $0xff,(%r14)
add    (%r12),%dl
mov    %dl,0x1(%r14)
add    0x1(%r12),%cl
mov    %cl,0x2(%r14)
movzbl 0x2(%r12),%edi
movzbl %al,%eax
add    %edi,%eax
mov    %al,0x3(%r14)
movb   $0xff,0x4(%r14)
add    0x3(%r12),%dl
mov    %dl,0x5(%r14)
add    0x4(%r12),%cl
mov    %cl,0x6(%r14)
movzbl 0x5(%r12),%edi
movzbl %al,%eax
add    %edi,%eax
mov    %al,0x7(%r14)
add    $0x8,%r14
add    $0x6,%r12
add    $0xfffffffe,%esi
jne    13b0 <applyfilter3+0x2a0>
test   $0x1,%r8b
je     142b <applyfilter3+0x31b>
movb   $0xff,(%r14)
add    (%r12),%dl
mov    %dl,0x1(%r14)
add    0x1(%r12),%cl
mov    %cl,0x2(%r14)
add    0x2(%r12),%al
mov    %al,0x3(%r14)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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