#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 removeRowFilters(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; x < 4 * wide; x++) {
        srcPtr[x] += srcPtr[x - 4];
      }
      break;
    case 2:
      upPtr = srcPtr - 4 * wide - 1;
      if (y > 0) {
        for (x = 0; x < 4 * wide; x++) {
          srcPtr[x] += upPtr[x];
        }
      }
      break;
    case 3:
      upPtr = srcPtr - 4 * wide - 1;
      if (y == 0) {
        for (x = 4; x < 4 * wide; x++) {
          srcPtr[x] += (srcPtr[x - 4] >> 1);
        }
      } else {
        srcPtr[0] += (upPtr[x] >> 1);
        for (x = 4; x < 4 * wide; x++) {
          srcPtr[x] += ((upPtr[x] + srcPtr[x - 4]) >> 1);
        }
      }
      break;
    case 4:
      upPtr = srcPtr - 4 * wide - 1;
      {
        int p, pa, pb, pc, value;
        int leftpix, toppix, topleftpix;
        for (x = 0; x < 4 * wide; 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("removerowfilter() : Unknown row filter %d\n", rowfilter);
    }
    srcPtr += 4 * wide;
  }
}


x86 assembly (clang, -O0):
<removeRowFilters>:
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    14d0 <removeRowFilters+0x3c0>
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     149f <removeRowFilters+0x38f>
mov    -0x58(%rbp),%rax
lea    0xe91(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    14ae <removeRowFilters+0x39e>
movl   $0x4,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    11c5 <removeRowFilters+0xb5>
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
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1184 <removeRowFilters+0x74>
jmp    14ae <removeRowFilters+0x39e>
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)
jle    1239 <removeRowFilters+0x129>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    1234 <removeRowFilters+0x124>
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
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11f8 <removeRowFilters+0xe8>
jmp    1239 <removeRowFilters+0x129>
jmp    14ae <removeRowFilters+0x39e>
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    12b5 <removeRowFilters+0x1a5>
movl   $0x4,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    12b0 <removeRowFilters+0x1a0>
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
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    126c <removeRowFilters+0x15c>
jmp    132d <removeRowFilters+0x21d>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sar    $0x1,%edx
mov    -0x28(%rbp),%rax
movzbl (%rax),%ecx
add    %edx,%ecx
mov    %cl,(%rax)
movl   $0x4,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    1328 <removeRowFilters+0x218>
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
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12d6 <removeRowFilters+0x1c6>
jmp    132d <removeRowFilters+0x21d>
jmp    14ae <removeRowFilters+0x39e>
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)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    149a <removeRowFilters+0x38a>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    139a <removeRowFilters+0x28a>
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    13d6 <removeRowFilters+0x2c6>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x4,-0x14(%rbp)
jl     13d1 <removeRowFilters+0x2c1>
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
jmp    13d6 <removeRowFilters+0x2c6>
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    13fd <removeRowFilters+0x2ed>
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    1418 <removeRowFilters+0x308>
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    1433 <removeRowFilters+0x323>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1456 <removeRowFilters+0x346>
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1456 <removeRowFilters+0x346>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1478 <removeRowFilters+0x368>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     146d <removeRowFilters+0x35d>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1473 <removeRowFilters+0x363>
mov    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1478 <removeRowFilters+0x368>
mov    -0x44(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1356 <removeRowFilters+0x246>
jmp    14ae <removeRowFilters+0x39e>
mov    -0x1c(%rbp),%esi
lea    0xb6b(%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 <removeRowFilters+0x21>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<removeRowFilters>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rdx,0x18(%rsp)
mov    %rdi,0x38(%rsp)
mov    %esi,0x6c(%rsp)
test   %esi,%esi
jle    1c30 <removeRowFilters+0xb20>
mov    0x38(%rsp),%rax
lea    0x0(,%rax,4),%eax
mov    %eax,0x68(%rsp)
cltq
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0x60(%rsp)
cmp    $0x2,%eax
mov    $0x1,%ebx
cmovge %eax,%ebx
cmp    $0x6,%eax
mov    $0x5,%edx
cmovge %eax,%edx
lea    -0x4(%rdx),%rsi
mov    %rbx,%rdi
sub    %rax,%rdi
mov    %rdi,0xf8(%rsp)
mov    $0x4,%r8d
sub    %rax,%r8
mov    %rdx,%rbp
sub    %rax,%rbp
mov    %rbp,0xe0(%rsp)
lea    -0x8(%rdx),%rbp
mov    %rbp,0x58(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %ebx,%ecx
and    $0x7fffffe0,%ecx
mov    %rcx,0x70(%rsp)
add    $0xffffffffffffffe0,%rcx
mov    %rcx,0xc0(%rsp)
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %rsi,0x20(%rsp)
mov    %rsi,%r9
and    $0xfffffffffffffffc,%r9
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
and    %rbp,%rcx
mov    %rcx,0xb0(%rsp)
mov    %rdx,%rcx
neg    %rcx
mov    %rcx,0x100(%rsp)
mov    %ebp,%ecx
and    $0x3,%ecx
mov    %rcx,0x40(%rsp)
mov    %rbp,%rsi
mov    %rbp,0x80(%rsp)
and    $0xfffffffffffffffc,%rbp
mov    %rbp,0x78(%rsp)
mov    %rdi,%rcx
mov    %rdi,0xb8(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xa8(%rsp)
mov    %ebx,%ecx
and    $0x7ffffff8,%ecx
mov    %rcx,0xc8(%rsp)
mov    %ebx,%ecx
and    $0x1,%ecx
mov    %rcx,0x108(%rsp)
mov    0x18(%rsp),%rsi
mov    %rsi,%r14
sub    %rax,%r14
movdqa 0xda0(%rip),%xmm4
pxor   %xmm5,%xmm5
mov    %rax,0x88(%rsp)
add    $0x1,%rax
mov    %rax,0x90(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0xf0(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xd8(%rsp)
mov    %rdx,0x8(%rsp)
lea    -0x3(%rdx),%rax
mov    %rax,0xd0(%rsp)
mov    %r9,0x50(%rsp)
lea    0x4(%r9),%rax
mov    %rax,0x48(%rsp)
lea    0x5(%rsi),%r15
mov    %r8,0xe8(%rsp)
lea    (%rsi,%r8,1),%r9
mov    %rbx,0x10(%rsp)
lea    -0x4(%rbx),%rax
mov    %rax,0x110(%rsp)
lea    0x9(%rsi),%r11
lea    0x2(%rsi),%r13
lea    0x1(%r14),%rcx
lea    0x30(%r14),%rdx
lea    0x1(%rsi),%r12
xor    %ebx,%ebx
mov    %rsi,%rax
jmp    1379 <removeRowFilters+0x269>
lea    0xd2f(%rip),%rdi
mov    %rbx,0x30(%rsp)
mov    %r9,%rbx
mov    %r13,0x28(%rsp)
mov    %r11,%r13
mov    %r10,%rbp
call   1030 <printf@plt>
mov    %rbp,%r10
mov    %r13,%r11
mov    0x28(%rsp),%r13
mov    %rbx,%r9
pxor   %xmm5,%xmm5
movdqa 0xcd9(%rip),%xmm4
mov    0x30(%rsp),%rbx
nopl   0x0(%rax)
add    0x88(%rsp),%r10
add    $0x1,%rbx
mov    0x90(%rsp),%rax
add    %rax,%r15
add    %rax,%r9
add    %rax,%r11
add    %rax,%r13
mov    0xa0(%rsp),%rcx
add    %rax,%rcx
mov    0x98(%rsp),%rdx
add    %rax,%rdx
add    %rax,%r14
add    %rax,%r12
mov    %r10,%rax
cmp    0x6c(%rsp),%ebx
je     1c30 <removeRowFilters+0xb20>
mov    %rdx,0x98(%rsp)
mov    %rcx,0xa0(%rsp)
movzbl (%rax),%esi
lea    0x1(%rax),%r10
cmp    $0x4,%rsi
ja     12ee <removeRowFilters+0x1de>
mov    0x90(%rsp),%rcx
imul   %rbx,%rcx
mov    0x18(%rsp),%rdx
lea    (%rcx,%rdx,1),%rdi
add    $0x1,%rdi
lea    0xc56(%rip),%rbp
movslq 0x0(%rbp,%rsi,4),%rdx
add    %rbp,%rdx
jmp    *%rdx
movl   $0x4,0x4(%rsp)
cmpl   $0x2,0x38(%rsp)
jl     1330 <removeRowFilters+0x220>
mov    $0x4,%eax
cmpq   $0x4,0x20(%rsp)
jb     1732 <removeRowFilters+0x622>
mov    0x18(%rsp),%rax
movd   0x1(%rax,%rcx,1),%xmm0
cmpq   $0xc,0x58(%rsp)
jae    1683 <removeRowFilters+0x573>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x40(%rsp),%rsi
jmp    16e7 <removeRowFilters+0x5d7>
test   %ebx,%ebx
mov    $0x0,%edx
mov    0x4(%rsp),%esi
cmovne %edx,%esi
mov    %esi,0x4(%rsp)
je     1330 <removeRowFilters+0x220>
cmpl   $0x0,0x38(%rsp)
jle    1330 <removeRowFilters+0x220>
mov    0x10(%rsp),%rsi
cmp    $0x8,%esi
jb     147d <removeRowFilters+0x36d>
mov    0xf8(%rsp),%rdx
add    %rcx,%rdx
add    0x18(%rsp),%rdx
cmp    %rdx,%rdi
jae    175e <removeRowFilters+0x64e>
mov    0xf0(%rsp),%rdx
add    %rcx,%rdx
mov    0x18(%rsp),%rdi
add    %rdi,%rdx
sub    0x88(%rsp),%rcx
add    %rdi,%rcx
cmp    %rdx,%rcx
jae    175e <removeRowFilters+0x64e>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
mov    0x10(%rsp),%rsi
add    %rsi,%rax
mov    0x108(%rsp),%rdx
mov    %rbx,%rdi
test   %rdx,%rdx
je     14b3 <removeRowFilters+0x3a3>
nopl   (%rax)
movzbl (%r14,%rcx,1),%ebx
add    %bl,(%r12,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    14a0 <removeRowFilters+0x390>
mov    %esi,%edx
mov    %esi,0x4(%rsp)
cmp    $0x3,%rax
mov    %rdi,%rbx
jb     1330 <removeRowFilters+0x220>
mov    0x10(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%eax
add    %al,(%r12,%rcx,1)
movzbl 0x1(%r14,%rcx,1),%eax
add    %al,0x1(%r12,%rcx,1)
movzbl 0x2(%r14,%rcx,1),%eax
add    %al,0x2(%r12,%rcx,1)
movzbl 0x3(%r14,%rcx,1),%eax
add    %al,0x3(%r12,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    14d0 <removeRowFilters+0x3c0>
jmp    1753 <removeRowFilters+0x643>
test   %ebx,%ebx
je     160e <removeRowFilters+0x4fe>
mov    0x60(%rsp),%rax
lea    (%r10,%rax,1),%r8
add    $0xffffffffffffffff,%r8
movslq 0x4(%rsp),%rdx
mov    (%r8,%rdx,1),%dl
shr    %dl
add    %dl,(%r10)
movl   $0x4,0x4(%rsp)
cmpl   $0x2,0x38(%rsp)
jl     1330 <removeRowFilters+0x220>
mov    $0x4,%edx
cmpq   $0x4,0x20(%rsp)
jb     1b86 <removeRowFilters+0xa76>
mov    %r10,0x28(%rsp)
mov    %rbx,0x30(%rsp)
mov    0x18(%rsp),%r10
lea    (%rcx,%r10,1),%rsi
add    $0x5,%rsi
mov    0xd8(%rsp),%rax
lea    (%rax,%rcx,1),%rbp
add    %r10,%rbp
mov    0xe8(%rsp),%rax
lea    (%rax,%rcx,1),%rbx
add    %r10,%rbx
mov    0xe0(%rsp),%rax
add    %rcx,%rax
add    %r10,%rax
add    0xd0(%rsp),%rcx
add    %r10,%rcx
cmp    %rax,%rsi
setb   %al
cmp    %rbp,%rbx
setb   %bl
cmp    %rcx,%rsi
setb   %cl
cmp    %rbp,%rdi
setb   %sil
test   %bl,%al
jne    1a99 <removeRowFilters+0x989>
and    %sil,%cl
mov    0x30(%rsp),%rbx
mov    0x28(%rsp),%r10
jne    1b86 <removeRowFilters+0xa76>
cmpq   $0x4,0x58(%rsp)
jae    1aa8 <removeRowFilters+0x998>
xor    %ecx,%ecx
jmp    1b2a <removeRowFilters+0xa1a>
cmpl   $0x0,0x38(%rsp)
jle    1601 <removeRowFilters+0x4f1>
mov    0x60(%rsp),%rcx
lea    (%r10,%rcx,1),%r8
add    $0xffffffffffffffff,%r8
test   %ebx,%ebx
je     165a <removeRowFilters+0x54a>
mov    (%r8),%cl
jmp    165c <removeRowFilters+0x54c>
movl   $0x0,0x4(%rsp)
jmp    1330 <removeRowFilters+0x220>
movl   $0x4,0x4(%rsp)
cmpl   $0x2,0x38(%rsp)
jl     1330 <removeRowFilters+0x220>
mov    $0x4,%edx
cmpq   $0x4,0x20(%rsp)
jb     1a7b <removeRowFilters+0x96b>
mov    0x18(%rsp),%rdx
movd   0x1(%rdx,%rcx,1),%xmm0
cmpq   $0xc,0x58(%rsp)
jae    19ab <removeRowFilters+0x89b>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
mov    0x40(%rsp),%rdi
jmp    1a33 <removeRowFilters+0x923>
xor    %ecx,%ecx
add    %cl,(%r10)
movl   $0x1,0x4(%rsp)
cmpl   $0x2,0x68(%rsp)
jl     1330 <removeRowFilters+0x220>
test   %ebx,%ebx
je     176e <removeRowFilters+0x65e>
mov    0x1(%r8),%cl
jmp    1770 <removeRowFilters+0x660>
mov    0x78(%rsp),%rcx
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x40(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   (%r15,%rax,1),%xmm1
paddb  %xmm0,%xmm1
movd   0x4(%r15,%rax,1),%xmm2
paddb  %xmm1,%xmm2
movd   0x8(%r15,%rax,1),%xmm3
paddb  %xmm2,%xmm3
movd   0xc(%r15,%rax,1),%xmm0
paddb  %xmm3,%xmm0
punpckldq %xmm0,%xmm3
punpckldq %xmm2,%xmm1
punpcklqdq %xmm3,%xmm1
movdqu %xmm1,(%r15,%rax,1)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    16a0 <removeRowFilters+0x590>
testb  $0x3,0x80(%rsp)
03
je     1717 <removeRowFilters+0x607>
add    %r15,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movd   (%rax,%rcx,4),%xmm1
paddb  %xmm1,%xmm0
movd   %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1700 <removeRowFilters+0x5f0>
mov    0x48(%rsp),%rax
mov    %edx,%ecx
mov    %edx,0x4(%rsp)
mov    0x50(%rsp),%rcx
cmp    %rcx,0x20(%rsp)
je     1330 <removeRowFilters+0x220>
mov    0x8(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movzbl -0x4(%r12,%rax,1),%ecx
add    %cl,(%r12,%rax,1)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1740 <removeRowFilters+0x630>
mov    %edx,%eax
mov    %edx,0x4(%rsp)
jmp    1330 <removeRowFilters+0x220>
cmp    $0x20,%esi
jae    1878 <removeRowFilters+0x768>
xor    %edx,%edx
jmp    1968 <removeRowFilters+0x858>
xor    %ecx,%ecx
mov    -0x2(%rax),%dl
cmp    %dl,%cl
movzbl %cl,%ecx
movzbl %dl,%edx
cmova  %ecx,%edx
add    %dl,0x2(%rax)
test   %ebx,%ebx
je     178b <removeRowFilters+0x67b>
mov    0x2(%r8),%cl
jmp    178d <removeRowFilters+0x67d>
xor    %ecx,%ecx
mov    -0x1(%rax),%dl
cmp    %dl,%cl
movzbl %cl,%ecx
movzbl %dl,%edx
cmova  %ecx,%edx
add    %dl,0x3(%rax)
test   %ebx,%ebx
je     17a8 <removeRowFilters+0x698>
mov    0x3(%r8),%cl
jmp    17aa <removeRowFilters+0x69a>
xor    %ecx,%ecx
mov    (%rax),%dl
cmp    %dl,%cl
movzbl %cl,%ecx
movzbl %dl,%edx
cmova  %ecx,%edx
add    %dl,0x4(%rax)
mov    0x10(%rsp),%rax
mov    %eax,%ecx
mov    %eax,0x4(%rsp)
cmp    $0x4,%eax
je     1330 <removeRowFilters+0x220>
mov    %r10,0x28(%rsp)
mov    %r11,0x30(%rsp)
xor    %eax,%eax
jmp    1802 <removeRowFilters+0x6f2>
nopl   0x0(%rax)
cmp    %edi,%ecx
cmova  %edx,%esi
cmp    %ebx,%ecx
cmova  %edx,%esi
add    %sil,(%r15,%rax,1)
add    $0x1,%rax
cmp    %rax,0x110(%rsp)
mov    %r11,%r9
mov    %r10,%rbx
je     1860 <removeRowFilters+0x750>
mov    %rbx,%r10
test   %ebx,%ebx
je     1820 <removeRowFilters+0x710>
mov    %r9,%r11
movzbl (%r9,%rax,1),%ecx
mov    %eax,%edx
movzbl (%r8,%rdx,1),%edx
jmp    1827 <removeRowFilters+0x717>
nopw   0x0(%rax,%rax,1)
mov    %r9,%r11
xor    %ecx,%ecx
xor    %edx,%edx
movzbl -0x4(%r15,%rax,1),%esi
movzbl %cl,%r9d
lea    (%r9,%rsi,1),%ebp
sub    %edx,%ebp
mov    %ebp,%edi
sub    %esi,%edi
mov    %edi,%ecx
neg    %ecx
cmovs  %edi,%ecx
mov    %ebp,%edi
sub    %r9d,%edi
mov    %edi,%ebx
neg    %ebx
cmovs  %edi,%ebx
sub    %edx,%ebp
mov    %ebp,%edi
neg    %edi
cmovs  %ebp,%edi
cmp    %edi,%ebx
ja     17e0 <removeRowFilters+0x6d0>
mov    %r9d,%edx
jmp    17e0 <removeRowFilters+0x6d0>
mov    0x10(%rsp),%rax
mov    %eax,0x4(%rsp)
mov    0x30(%rsp),%r11
mov    0x28(%rsp),%r10
jmp    1330 <removeRowFilters+0x220>
cmpq   $0x0,0xc0(%rsp)
je     1c1b <removeRowFilters+0xb0b>
mov    0xa8(%rsp),%rdx
xor    %ecx,%ecx
mov    0x98(%rsp),%rdi
nopl   0x0(%rax)
movdqu -0x30(%rdi,%rcx,1),%xmm0
movdqu -0x20(%rdi,%rcx,1),%xmm1
movdqu 0x1(%rax,%rcx,1),%xmm2
paddb  %xmm0,%xmm2
movdqu 0x11(%rax,%rcx,1),%xmm0
paddb  %xmm1,%xmm0
movdqu 0x21(%rax,%rcx,1),%xmm1
movdqu 0x31(%rax,%rcx,1),%xmm3
movdqu %xmm2,0x1(%rax,%rcx,1)
movdqu %xmm0,0x11(%rax,%rcx,1)
movdqu -0x10(%rdi,%rcx,1),%xmm0
paddb  %xmm1,%xmm0
movdqu (%rdi,%rcx,1),%xmm1
paddb  %xmm3,%xmm1
movdqu %xmm0,0x21(%rax,%rcx,1)
movdqu %xmm1,0x31(%rax,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    18a0 <removeRowFilters+0x790>
testb  $0x1,0xb8(%rsp)
01
je     1944 <removeRowFilters+0x834>
mov    0x60(%rsp),%rdx
add    %r10,%rdx
add    $0xffffffffffffffff,%rdx
movdqu (%rdx,%rcx,1),%xmm0
movdqu 0x10(%rdx,%rcx,1),%xmm1
movdqu (%r10,%rcx,1),%xmm2
paddb  %xmm0,%xmm2
movdqu 0x10(%r10,%rcx,1),%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm2,(%r10,%rcx,1)
movdqu %xmm0,0x10(%r10,%rcx,1)
mov    %esi,%ecx
mov    %esi,0x4(%rsp)
cmp    %rsi,0x70(%rsp)
je     1330 <removeRowFilters+0x220>
mov    0x70(%rsp),%rcx
mov    %rcx,%rdx
testb  $0x18,0x10(%rsp)
je     147f <removeRowFilters+0x36f>
mov    0xc8(%rsp),%rsi
movq   (%r14,%rdx,1),%xmm0
movq   0x1(%rax,%rdx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,0x1(%rax,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1970 <removeRowFilters+0x860>
mov    %rsi,%rcx
mov    0x10(%rsp),%rax
mov    %eax,%edx
mov    %eax,0x4(%rsp)
cmp    %rax,%rsi
je     1330 <removeRowFilters+0x220>
jmp    147f <removeRowFilters+0x36f>
mov    0x78(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
mov    0x40(%rsp),%rdi
nopl   0x0(%rax)
psrlw  $0x1,%xmm0
pand   %xmm4,%xmm0
movd   (%r15,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x1,%xmm0
pand   %xmm4,%xmm0
movd   0x4(%r15,%rcx,1),%xmm2
paddb  %xmm0,%xmm2
punpckldq %xmm2,%xmm1
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
movd   0x8(%r15,%rcx,1),%xmm3
paddb  %xmm2,%xmm3
movdqa %xmm3,%xmm2
psrlw  $0x1,%xmm2
pand   %xmm4,%xmm2
movd   0xc(%r15,%rcx,1),%xmm0
paddb  %xmm2,%xmm0
punpckldq %xmm0,%xmm3
punpcklqdq %xmm3,%xmm1
movdqu %xmm1,(%r15,%rcx,1)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    19c0 <removeRowFilters+0x8b0>
test   %rdi,%rdi
je     1a60 <removeRowFilters+0x950>
add    %r15,%rcx
xor    %edx,%edx
nopl   (%rax)
psrlw  $0x1,%xmm0
pand   %xmm4,%xmm0
movd   (%rcx,%rdx,4),%xmm1
paddb  %xmm1,%xmm0
movd   %xmm0,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1a40 <removeRowFilters+0x930>
mov    0x48(%rsp),%rdx
mov    %esi,%ecx
mov    %esi,0x4(%rsp)
mov    0x50(%rsp),%rcx
cmp    %rcx,0x20(%rsp)
je     1330 <removeRowFilters+0x220>
mov    0x8(%rsp),%rsi
movzbl -0x3(%rax,%rdx,1),%ecx
shr    %cl
add    %cl,0x1(%rax,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1a80 <removeRowFilters+0x970>
jmp    1c10 <removeRowFilters+0xb00>
mov    0x30(%rsp),%rbx
mov    0x28(%rsp),%r10
jmp    1b86 <removeRowFilters+0xa76>
mov    0xb0(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%r9,%rcx,1),%xmm0
punpcklbw %xmm5,%xmm0
movd   -0x8(%r11,%rcx,1),%xmm1
punpcklbw %xmm5,%xmm1
paddw  %xmm0,%xmm1
psrlw  $0x1,%xmm1
packuswb %xmm1,%xmm1
movd   -0x4(%r11,%rcx,1),%xmm0
paddb  %xmm1,%xmm0
movd   %xmm0,-0x4(%r11,%rcx,1)
movd   0x4(%r9,%rcx,1),%xmm1
punpcklbw %xmm5,%xmm1
punpcklbw %xmm5,%xmm0
paddw  %xmm1,%xmm0
psrlw  $0x1,%xmm0
packuswb %xmm0,%xmm0
movd   (%r11,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movd   %xmm1,(%r11,%rcx,1)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1ac0 <removeRowFilters+0x9b0>
testb  $0x1,0x80(%rsp)
01
mov    0x8(%rsp),%rax
je     1b6d <removeRowFilters+0xa5d>
movd   0x4(%r8,%rcx,1),%xmm0
punpcklbw %xmm5,%xmm0
movd   (%r10,%rcx,1),%xmm1
punpcklbw %xmm5,%xmm1
paddw  %xmm0,%xmm1
psrlw  $0x1,%xmm1
packuswb %xmm1,%xmm1
movd   0x4(%r10,%rcx,1),%xmm0
paddb  %xmm1,%xmm0
movd   %xmm0,0x4(%r10,%rcx,1)
mov    0x48(%rsp),%rdx
mov    %eax,0x4(%rsp)
mov    0x50(%rsp),%rax
cmp    %rax,0x20(%rsp)
je     1330 <removeRowFilters+0x220>
mov    0x8(%rsp),%rsi
mov    %esi,%eax
sub    %edx,%eax
mov    %rdx,%rcx
test   $0x1,%al
je     1bad <removeRowFilters+0xa9d>
movzbl (%r8,%rdx,1),%eax
movzbl -0x4(%r10,%rdx,1),%ecx
add    %eax,%ecx
shr    %ecx
add    %cl,(%r10,%rdx,1)
lea    0x1(%rdx),%rcx
not    %rdx
mov    %esi,%eax
mov    %esi,0x4(%rsp)
cmp    0x100(%rsp),%rdx
je     1330 <removeRowFilters+0x220>
mov    0x8(%rsp),%rsi
mov    0xa0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rdi,%rcx,1),%eax
movzbl -0x5(%r13,%rcx,1),%edx
add    %eax,%edx
shr    %edx
add    %dl,-0x1(%r13,%rcx,1)
movzbl (%rdi,%rcx,1),%eax
movzbl -0x4(%r13,%rcx,1),%edx
add    %eax,%edx
shr    %edx
add    %dl,0x0(%r13,%rcx,1)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1be0 <removeRowFilters+0xad0>
mov    %esi,%eax
mov    %esi,0x4(%rsp)
jmp    1330 <removeRowFilters+0x220>
xor    %ecx,%ecx
testb  $0x1,0xb8(%rsp)
01
jne    190b <removeRowFilters+0x7fb>
jmp    1944 <removeRowFilters+0x834>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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