#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 */
int /*<<< orphan*/ printf(char *, int);
void applyRowFilters(int wide, int high, unsigned char *data) {
  int x, y, rowfilter;
  unsigned char *srcPtr, *upPtr;
  srcPtr = data;
  for (y = 0; y < high; y++) {
    rowfilter = *srcPtr;
    srcPtr++;
    switch (rowfilter) {
    case 0:
      break;
    case 1:
      for (x = 4 * wide - 1; x >= 4; x--) {
        srcPtr[x] -= srcPtr[x - 4];
      }
      break;
    case 2:
      if (y > 0) {
        upPtr = srcPtr - 1;
        for (x = 4 * wide - 1; x >= 0; x--) {
          srcPtr[x] -= upPtr[x];
        }
      }
      break;
    case 3:
      upPtr = srcPtr - 4 * wide - 1;
      if (y == 0) {
        for (x = 4 * wide - 1; x >= 4; x--) {
          srcPtr[x] -= (srcPtr[x - 4] >> 1);
        }
      } else {
        srcPtr[0] -= (upPtr[x] >> 1);
        for (x = 4 * wide - 1; x >= 4; x--) {
          srcPtr[x] -= ((upPtr[x] + srcPtr[x - 4]) >> 1);
        }
      }
      break;
    case 4:
      upPtr = srcPtr - 1;
      {
        int p, pa, pb, pc, value;
        int leftpix, toppix, topleftpix;
        for (x = 4 * wide - 1; x >= 0; x--) {
          leftpix = 0;
          toppix = 0;
          topleftpix = 0;
          if (x > 0)
            leftpix = srcPtr[x - 4];
          if (y > 0) {
            toppix = upPtr[x];
            if (x >= 4)
              topleftpix = upPtr[x - 4];
          }
          p = leftpix + toppix - topleftpix;
          pa = p - leftpix;
          if (pa < 0)
            pa = -pa;
          pb = p - toppix;
          if (pb < 0)
            pb = -pb;
          pc = p - topleftpix;
          if (pc < 0)
            pc = -pc;
          if (pa <= pb && pa <= pc)
            value = leftpix;
          else if (pb <= pc)
            value = toppix;
          else
            value = topleftpix;
          srcPtr[x] -= value;
        }
      }
      break;
    default:
      printf("applyrowfilter : Unknown row filter %d\n", rowfilter);
    }
    srcPtr += 4 * wide;
  }
}


x86 assembly (clang, -O0):
<applyRowFilters>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14a4 <applyRowFilters+0x394>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %rax,-0x58(%rbp)
sub    $0x4,%rax
ja     1473 <applyRowFilters+0x363>
mov    -0x58(%rbp),%rax
lea    0xe91(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1482 <applyRowFilters+0x372>
mov    -0x4(%rbp),%eax
shl    $0x2,%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jl     11c3 <applyRowFilters+0xb3>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1189 <applyRowFilters+0x79>
jmp    1482 <applyRowFilters+0x372>
cmpl   $0x0,-0x18(%rbp)
jle    1224 <applyRowFilters+0x114>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x2,%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     121f <applyRowFilters+0x10f>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    11ea <applyRowFilters+0xda>
jmp    1224 <applyRowFilters+0x114>
jmp    1482 <applyRowFilters+0x372>
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    129e <applyRowFilters+0x18e>
mov    -0x4(%rbp),%eax
shl    $0x2,%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jl     1299 <applyRowFilters+0x189>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
sar    $0x1,%esi
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    125c <applyRowFilters+0x14c>
jmp    1314 <applyRowFilters+0x204>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sar    $0x1,%edx
mov    -0x28(%rbp),%rax
movzbl (%rax),%ecx
sub    %edx,%ecx
mov    %cl,(%rax)
mov    -0x4(%rbp),%eax
shl    $0x2,%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jl     130f <applyRowFilters+0x1ff>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
add    %eax,%esi
sar    $0x1,%esi
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    12c4 <applyRowFilters+0x1b4>
jmp    1314 <applyRowFilters+0x204>
jmp    1482 <applyRowFilters+0x372>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x2,%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     146e <applyRowFilters+0x35e>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    136e <applyRowFilters+0x25e>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    13aa <applyRowFilters+0x29a>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x4,-0x14(%rbp)
jl     13a5 <applyRowFilters+0x295>
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
jmp    13aa <applyRowFilters+0x29a>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jge    13d1 <applyRowFilters+0x2c1>
xor    %eax,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    13ec <applyRowFilters+0x2dc>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    1407 <applyRowFilters+0x2f7>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     142a <applyRowFilters+0x31a>
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     142a <applyRowFilters+0x31a>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    144c <applyRowFilters+0x33c>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1441 <applyRowFilters+0x331>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1447 <applyRowFilters+0x337>
mov    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    144c <applyRowFilters+0x33c>
mov    -0x44(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1331 <applyRowFilters+0x221>
jmp    1482 <applyRowFilters+0x372>
mov    -0x1c(%rbp),%esi
lea    0xb97(%rip),%rdi
call   1030 <printf@plt>
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1131 <applyRowFilters+0x21>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<applyRowFilters>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %rdx,0x38(%rsp)
mov    %rdi,0x18(%rsp)
mov    %esi,0x6c(%rsp)
test   %esi,%esi
jle    1bdc <applyRowFilters+0xacc>
mov    0x18(%rsp),%r8
lea    0x0(,%r8,4),%eax
lea    -0x1(,%r8,4),%r10d
ff
mov    %rax,0x10(%rsp)
movslq %eax,%r14
mov    %r14,%rax
neg    %rax
mov    %rax,0x110(%rsp)
movslq %r10d,%r13
xor    %r12d,%r12d
test   %r13d,%r13d
mov    $0x0,%eax
cmovs  %r13d,%eax
cmp    $0x4,%r13d
mov    $0x4,%ecx
cmovl  %r13d,%ecx
mov    %r13d,%ebp
sub    %ecx,%ebp
not    %ecx
lea    (%rcx,%r8,4),%edx
lea    0x1(%r10),%rcx
lea    -0x8(,%r8,4),%r15d
ff
lea    0x4(%r15),%rdi
mov    %rcx,%rsi
sub    %rdx,%rsi
mov    %rsi,0x130(%rsp)
mov    %r10,%rsi
sub    %r14,%rsi
sub    %rdx,%rsi
mov    %rsi,0xf0(%rsp)
mov    %rdi,0x138(%rsp)
sub    %rdx,%rdi
mov    %rdi,0x128(%rsp)
mov    %r10,%rsi
sub    %r14,%rsi
mov    %rsi,0xf8(%rsp)
mov    %rcx,0x140(%rsp)
sub    %r14,%rcx
mov    %rcx,0xe8(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0xe0(%rsp)
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rsi
mov    %rsi,0xa0(%rsp)
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %eax,%edi
neg    %edi
lea    -0x1(%rax),%ebx
mov    %ebx,0x34(%rsp)
not    %eax
lea    (%rax,%r8,4),%eax
mov    %eax,0x64(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x28(%rsp)
mov    %r10,%rax
sub    %rcx,%rax
mov    %rax,0xd0(%rsp)
mov    %r14d,%eax
sub    %ecx,%eax
mov    %eax,0x5c(%rsp)
mov    %rbp,0xb0(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x90(%rsp)
and    $0xfffffffffffffff0,%rax
mov    %r10,%rbp
sub    %rax,%rbp
mov    %rbp,0x80(%rsp)
mov    %r14d,%ebp
mov    %rax,0x88(%rsp)
sub    %eax,%ebp
mov    %ebp,0x30(%rsp)
mov    %rsi,%rax
mov    %rsi,0x98(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x78(%rsp)
and    $0x3,%edi
mov    %rdx,0x100(%rsp)
neg    %rdx
mov    %rdx,0xa8(%rsp)
add    $0xfffffffffffffffd,%r13
mov    %r13,0x150(%rsp)
lea    0x5(%r15),%rax
mov    %rax,0x120(%rsp)
or     $0x3,%r15
mov    %r15,0x48(%rsp)
lea    -0x4(,%r8,4),%eax
ff
or     $0x3,%rax
mov    %rax,0x108(%rsp)
mov    %rcx,0xd8(%rsp)
neg    %rcx
mov    %rcx,0xc8(%rsp)
lea    -0x3(%r10),%rax
sub    %r14,%rax
mov    0x38(%rsp),%rcx
add    %rcx,%rax
add    $0xfffffffffffffff4,%rax
mov    %rcx,%rdx
sub    %r14,%rdx
lea    -0x18(,%r8,4),%esi
ff
or     $0x3,%rsi
mov    %rsi,0x70(%rsp)
mov    %edi,0x68(%rsp)
neg    %edi
mov    %edi,0x60(%rsp)
movdqa 0xcd1(%rip),%xmm4
pxor   %xmm5,%xmm5
mov    %r14,0x148(%rsp)
lea    0x1(%r14),%r11
lea    0x2(%r10),%rsi
mov    %rsi,0x118(%rsp)
mov    %r10,0x8(%rsp)
lea    -0xe(%r10,%rcx,1),%rsi
lea    0x1(%rcx),%rdi
mov    %rdi,0x20(%rsp)
mov    %rcx,%r10
mov    %r11,0xb8(%rsp)
jmp    13ca <applyRowFilters+0x2ba>
lea    0xcb2(%rip),%rdi
call   1030 <printf@plt>
mov    0xb8(%rsp),%r11
pxor   %xmm5,%xmm5
movdqa 0xc75(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
add    0x148(%rsp),%r14
add    $0x1,%r12
mov    0x40(%rsp),%rsi
add    %r11,%rsi
mov    0xc0(%rsp),%rax
add    %r11,%rax
add    %r11,0x20(%rsp)
mov    0x50(%rsp),%rdx
add    %r11,%rdx
mov    %r14,%r10
cmp    0x6c(%rsp),%r12d
je     1bdc <applyRowFilters+0xacc>
mov    %rsi,0x40(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rax,0xc0(%rsp)
movzbl (%r10),%esi
lea    0x1(%r10),%r14
cmp    $0x4,%rsi
ja     136b <applyRowFilters+0x25b>
mov    %r11,%rcx
imul   %r12,%rcx
mov    0x130(%rsp),%rax
lea    (%rax,%rcx,1),%r15
mov    0x38(%rsp),%rdi
add    %rdi,%r15
mov    0x118(%rsp),%rax
lea    (%rax,%rcx,1),%r8
add    %rdi,%r8
mov    0x128(%rsp),%rax
lea    (%rax,%rcx,1),%r9
add    %rdi,%r9
mov    0x120(%rsp),%rax
lea    (%rax,%rcx,1),%rbx
add    %rdi,%rbx
mov    0x140(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
add    %rdi,%rdx
mov    0x138(%rsp),%rax
lea    (%rax,%rcx,1),%rbp
add    %rdi,%rbp
lea    0xbb9(%rip),%rdi
movslq (%rdi,%rsi,4),%rax
add    %rdi,%rax
jmp    *%rax
mov    0x8(%rsp),%r13
cmpl   $0x2,0x18(%rsp)
jl     1390 <applyRowFilters+0x280>
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmpl   $0xf,0xb0(%rsp)
0f
mov    0x20(%rsp),%rsi
jae    1755 <applyRowFilters+0x645>
nopl   (%rax)
add    $0xfffffffb,%ecx
movzbl (%r14,%rcx,1),%eax
sub    %al,(%rsi,%r13,1)
mov    %r13d,%eax
add    $0xffffffffffffffff,%r13
lea    0x1(%r13),%edx
mov    %eax,%ecx
cmp    $0x4,%edx
jg     1490 <applyRowFilters+0x380>
jmp    1390 <applyRowFilters+0x280>
test   %r12d,%r12d
cmovne 0x8(%rsp),%r13d
je     1390 <applyRowFilters+0x280>
cmpl   $0x0,0x18(%rsp)
jle    1390 <applyRowFilters+0x280>
mov    0x8(%rsp),%rcx
cmpl   $0x0,0x68(%rsp)
je     1502 <applyRowFilters+0x3f2>
mov    0x60(%rsp),%edx
mov    0x8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r10,%rcx,1),%eax
sub    %al,0x1(%r10,%rcx,1)
add    $0xffffffffffffffff,%rcx
inc    %edx
jne    14f0 <applyRowFilters+0x3e0>
mov    0x34(%rsp),%eax
mov    %eax,%r13d
cmpl   $0x3,0x64(%rsp)
jb     1390 <applyRowFilters+0x280>
add    $0x1,%rcx
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%r10,%rcx,1),%eax
sub    %al,(%r10,%rcx,1)
movzbl -0x3(%r10,%rcx,1),%edx
movzbl -0x2(%r10,%rcx,1),%ebx
sub    %bl,%al
mov    %al,-0x1(%r10,%rcx,1)
sub    %dl,%bl
mov    %bl,-0x2(%r10,%rcx,1)
sub    -0x4(%r10,%rcx,1),%dl
mov    %dl,-0x3(%r10,%rcx,1)
add    $0xfffffffffffffffc,%rcx
test   %ecx,%ecx
jg     1520 <applyRowFilters+0x410>
mov    0x34(%rsp),%eax
mov    %eax,%r13d
jmp    1390 <applyRowFilters+0x280>
test   %r12d,%r12d
je     1702 <applyRowFilters+0x5f2>
mov    0x110(%rsp),%rax
add    %r14,%rax
add    $0xffffffffffffffff,%rax
movslq %r13d,%rsi
mov    (%rax,%rsi,1),%al
shr    %al
sub    %al,(%r14)
mov    0x8(%rsp),%r13
cmpl   $0x2,0x18(%rsp)
jl     1390 <applyRowFilters+0x280>
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rsi
cmpl   $0xf,0x100(%rsp)
0f
mov    0x50(%rsp),%r11
jae    1880 <applyRowFilters+0x770>
mov    0x20(%rsp),%rax
add    %r13,%rax
nopw   0x0(%rax,%rax,1)
mov    %r13d,%ecx
movzbl (%r11,%r13,1),%edx
add    $0xfffffffb,%esi
movzbl (%r14,%rsi,1),%esi
add    %edx,%esi
shr    %esi
sub    %sil,(%rax)
add    $0xffffffffffffffff,%r13
lea    0x1(%r13),%edx
add    $0xffffffffffffffff,%rax
mov    %ecx,%esi
cmp    $0x4,%edx
jg     15c0 <applyRowFilters+0x4b0>
mov    0xb8(%rsp),%r11
jmp    1390 <applyRowFilters+0x280>
mov    0x8(%rsp),%r13
cmpl   $0x0,0x18(%rsp)
jle    1390 <applyRowFilters+0x280>
xor    %r13d,%r13d
mov    0x10(%rsp),%r9
jmp    163e <applyRowFilters+0x52e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %ecx,%ebp
cmova  %edx,%esi
cmp    %ebx,%ebp
cmova  %edx,%esi
mov    %r8d,%eax
sub    %sil,(%r14,%rax,1)
add    $0xffffffffffffffff,%r13
test   %r8,%r8
jle    16f5 <applyRowFilters+0x5e5>
mov    0x150(%rsp),%rax
lea    (%rax,%r13,1),%r8
add    $0x3,%r8
lea    (%r9,%r13,1),%rbp
cmp    $0x1,%ebp
je     1690 <applyRowFilters+0x580>
mov    0x48(%rsp),%rax
lea    (%rax,%r13,1),%rbx
xor    %edx,%edx
movslq %ebx,%rax
movzbl (%r14,%rax,1),%esi
test   %r12d,%r12d
je     16b0 <applyRowFilters+0x5a0>
mov    %r8d,%eax
movzbl (%r10,%rax,1),%edi
cmp    $0x5,%ebp
jb     16ba <applyRowFilters+0x5aa>
mov    %ebx,%eax
movzbl (%r10,%rax,1),%edx
jmp    16ba <applyRowFilters+0x5aa>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r12d,%r12d
je     16b4 <applyRowFilters+0x5a4>
mov    %r8d,%eax
movzbl (%r10,%rax,1),%edi
xor    %esi,%esi
jmp    16b8 <applyRowFilters+0x5a8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
jmp    16ba <applyRowFilters+0x5aa>
xor    %esi,%esi
xor    %edi,%edi
xor    %edx,%edx
movzbl %sil,%esi
movzbl %dil,%edi
lea    (%rdi,%rsi,1),%eax
sub    %edx,%eax
mov    %eax,%ecx
sub    %esi,%ecx
mov    %ecx,%ebp
neg    %ebp
cmovs  %ecx,%ebp
mov    %eax,%ecx
sub    %edi,%ecx
mov    %ecx,%ebx
neg    %ebx
cmovs  %ecx,%ebx
sub    %edx,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    %ecx,%ebx
ja     1620 <applyRowFilters+0x510>
mov    %edi,%edx
jmp    1620 <applyRowFilters+0x510>
add    0x108(%rsp),%r13d
jmp    1390 <applyRowFilters+0x280>
mov    0x8(%rsp),%r13
cmpl   $0x2,0x18(%rsp)
jl     1390 <applyRowFilters+0x280>
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmpl   $0xf,0xb0(%rsp)
0f
mov    0x20(%rsp),%rsi
jae    1a72 <applyRowFilters+0x962>
nop
add    $0xfffffffb,%ecx
movzbl (%r14,%rcx,1),%eax
shr    %al
sub    %al,(%rsi,%r13,1)
mov    %r13d,%eax
add    $0xffffffffffffffff,%r13
lea    0x1(%r13),%edx
mov    %eax,%ecx
cmp    $0x4,%edx
jg     1730 <applyRowFilters+0x620>
jmp    1390 <applyRowFilters+0x280>
mov    0xa8(%rsp),%rax
add    %rdx,%rax
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmp    %rdx,%rax
ja     1490 <applyRowFilters+0x380>
mov    0xa8(%rsp),%rax
add    %rbp,%rax
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmp    %rbp,%rax
ja     1490 <applyRowFilters+0x380>
cmp    %rbx,%r15
jae    17a9 <applyRowFilters+0x699>
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmp    %r8,%r9
jb     1490 <applyRowFilters+0x380>
cmpq   $0x0,0xa0(%rsp)
je     1bab <applyRowFilters+0xa9b>
mov    0x78(%rsp),%rdx
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
mov    0x48(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    0x40(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdi,%rcx,1),%eax
movdqu -0xe(%r10,%rax,1),%xmm0
movdqu -0x10(%rbx,%rcx,1),%xmm1
movdqu (%rbx,%rcx,1),%xmm2
psubb  %xmm0,%xmm2
movdqu %xmm2,(%rbx,%rcx,1)
lea    0x0(%rbp,%rcx,1),%eax
movdqu -0xe(%r10,%rax,1),%xmm0
psubb  %xmm0,%xmm1
movdqu %xmm1,-0x10(%rbx,%rcx,1)
add    $0xffffffffffffffe0,%rcx
add    $0xfffffffffffffffe,%rdx
jne    17e0 <applyRowFilters+0x6d0>
neg    %rcx
testb  $0x1,0x98(%rsp)
01
je     1852 <applyRowFilters+0x742>
mov    0x8(%rsp),%rax
sub    %rcx,%rax
mov    %esi,%edx
sub    %ecx,%edx
add    $0xfffffffb,%edx
movdqu -0xe(%r10,%rdx,1),%xmm0
movdqu -0xe(%r10,%rax,1),%xmm1
psubb  %xmm0,%xmm1
movdqu %xmm1,-0xe(%r10,%rax,1)
mov    0x80(%rsp),%r13
mov    0x30(%rsp),%eax
mov    %eax,%ecx
mov    0x88(%rsp),%rax
cmp    %rax,0x90(%rsp)
mov    0x20(%rsp),%rsi
jne    1490 <applyRowFilters+0x380>
jmp    1390 <applyRowFilters+0x280>
mov    0x28(%rsp),%rax
add    %rdx,%rax
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rsi
cmp    %rdx,%rax
ja     15b2 <applyRowFilters+0x4a2>
mov    0xf8(%rsp),%rax
add    %rcx,%rax
add    0x38(%rsp),%rax
mov    0x28(%rsp),%rdx
add    %rax,%rdx
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rsi
cmp    %rax,%rdx
ja     15b2 <applyRowFilters+0x4a2>
mov    0x28(%rsp),%rax
add    %rbp,%rax
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rsi
cmp    %rbp,%rax
ja     15b2 <applyRowFilters+0x4a2>
mov    0xf0(%rsp),%rax
add    %rcx,%rax
mov    0x38(%rsp),%rdx
add    %rdx,%rax
add    0xe8(%rsp),%rcx
add    %rdx,%rcx
cmp    %rcx,%r15
setb   %dl
cmp    %r8,%rax
setb   %al
cmp    %rbx,%r15
setb   %cl
cmp    %r8,%r9
setb   %bl
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rsi
test   %al,%dl
jne    15b2 <applyRowFilters+0x4a2>
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rsi
and    %bl,%cl
jne    15b2 <applyRowFilters+0x4a2>
xor    %ecx,%ecx
mov    0x48(%rsp),%rdx
mov    0xc8(%rsp),%rsi
mov    0xc0(%rsp),%rdi
mov    0x40(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movdqu (%rdi,%rcx,1),%xmm0
movdqa %xmm0,%xmm1
punpcklbw %xmm5,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm5,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm1,%xmm0
movdqa %xmm0,%xmm1
punpckhbw %xmm5,%xmm1
punpcklbw %xmm5,%xmm0
lea    (%rdx,%rcx,1),%eax
movdqu -0xe(%r10,%rax,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm5,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm5,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm2,%xmm3
punpckhbw %xmm5,%xmm3
paddw  %xmm1,%xmm3
punpcklbw %xmm5,%xmm2
paddw  %xmm0,%xmm2
psrlw  $0x1,%xmm3
psrlw  $0x1,%xmm2
packuswb %xmm3,%xmm2
movdqu 0x0(%rbp,%rcx,1),%xmm0
movdqa %xmm2,%xmm1
punpcklbw %xmm5,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm5,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
psubb  %xmm2,%xmm0
movdqu %xmm0,0x0(%rbp,%rcx,1)
add    $0xfffffffffffffff0,%rcx
cmp    %rcx,%rsi
jne    1960 <applyRowFilters+0x850>
mov    0xd0(%rsp),%r13
mov    0x5c(%rsp),%eax
mov    %eax,%esi
mov    0xd8(%rsp),%rax
cmp    %rax,0xe0(%rsp)
mov    0x50(%rsp),%r11
jne    15b2 <applyRowFilters+0x4a2>
jmp    15ea <applyRowFilters+0x4da>
mov    0x28(%rsp),%rax
add    %rdx,%rax
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmp    %rdx,%rax
ja     1730 <applyRowFilters+0x620>
mov    0x28(%rsp),%rax
add    %rbp,%rax
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmp    %rbp,%rax
ja     1730 <applyRowFilters+0x620>
cmp    %rbx,%r15
jae    1ac0 <applyRowFilters+0x9b0>
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rcx
cmp    %r8,%r9
jb     1730 <applyRowFilters+0x620>
cmpq   $0x0,0xa0(%rsp)
je     1bc5 <applyRowFilters+0xab5>
mov    0x78(%rsp),%rdx
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
mov    0x48(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    0x40(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%eax
movdqu -0xe(%r10,%rax,1),%xmm0
psrlw  $0x1,%xmm0
pand   %xmm4,%xmm0
movdqu -0x10(%rbx,%rcx,1),%xmm1
movdqu (%rbx,%rcx,1),%xmm2
psubb  %xmm0,%xmm2
movdqu %xmm2,(%rbx,%rcx,1)
lea    0x0(%rbp,%rcx,1),%eax
movdqu -0xe(%r10,%rax,1),%xmm0
psrlw  $0x1,%xmm0
pand   %xmm4,%xmm0
psubb  %xmm0,%xmm1
movdqu %xmm1,-0x10(%rbx,%rcx,1)
add    $0xffffffffffffffe0,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1af0 <applyRowFilters+0x9e0>
neg    %rcx
testb  $0x1,0x98(%rsp)
01
je     1b7d <applyRowFilters+0xa6d>
mov    0x8(%rsp),%rax
sub    %rcx,%rax
mov    %esi,%edx
sub    %ecx,%edx
add    $0xfffffffb,%edx
movdqu -0xe(%r10,%rdx,1),%xmm0
psrlw  $0x1,%xmm0
pand   %xmm4,%xmm0
movdqu -0xe(%r10,%rax,1),%xmm1
psubb  %xmm0,%xmm1
movdqu %xmm1,-0xe(%r10,%rax,1)
mov    0x80(%rsp),%r13
mov    0x30(%rsp),%eax
mov    %eax,%ecx
mov    0x88(%rsp),%rax
cmp    %rax,0x90(%rsp)
mov    0x20(%rsp),%rsi
jne    1730 <applyRowFilters+0x620>
jmp    1390 <applyRowFilters+0x280>
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
testb  $0x1,0x98(%rsp)
01
jne    182a <applyRowFilters+0x71a>
jmp    1852 <applyRowFilters+0x742>
xor    %ecx,%ecx
mov    0x10(%rsp),%rsi
testb  $0x1,0x98(%rsp)
01
jne    1b4c <applyRowFilters+0xa3c>
jmp    1b7d <applyRowFilters+0xa6d>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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