#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 */
typedef int uint8_t;
typedef int uint16_t;

/* Variables and functions */
int abs(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
int /*<<< orphan*/ stderr;
extern void pdf_filt_predict_png_decode(uint8_t *buf, uint8_t *out,
                                        uint8_t colors, uint8_t bpc,
                                        uint16_t columns, uint16_t rows) {
  int row_size = (colors * bpc * columns + 7) / 8;
  int idx = 0;
  int n = 0;
  int row;
  for (row = 0; row < rows; row++) {
    uint8_t tag = buf[idx++];
    int i;
    switch (tag) {
    case 0: {
      for (i = 0; i < row_size; i++) {
        out[n++] = buf[idx++];
      }
      break;
    }
    case 1: {
      for (i = 0; i < colors; i++) {
        out[n++] = buf[idx++];
      }
      for (i = colors + 1; i <= row_size; i++) {
        uint8_t left_val = out[n - colors];
        out[n++] = buf[idx++] + left_val;
      }
      break;
    }
    case 2: {
      for (i = 0; i < row_size; i++) {
        uint8_t up_val = row ? out[n - row_size] : 0;
        out[n++] = buf[idx++] + up_val;
      }
      break;
    }
    case 3: {
      for (i = 0; i < row_size; i++) {
        uint8_t left_val = i < colors ? 0 : out[n - colors];
        uint8_t up_val = row ? out[n - row_size] : 0;
        out[n++] = (buf[idx++] + (left_val + up_val) / 2);
      }
      break;
    }
    case 4: {
      for (i = 0; i < row_size; i++) {
        int left_val = i < colors ? 0 : out[n - colors];
        int up_val = row ? out[n - row_size] : 0;
        int up_left_val = row && i >= colors ? out[n - colors - row_size] : 0;
        int p = left_val + up_val - up_left_val;
        int pa = abs(p - left_val);
        int pb = abs(p - up_val);
        int pc = abs(p - up_left_val);
        int nearest =
            pa <= pb && pa <= pc ? left_val : (pb <= pc ? up_val : up_left_val);
        out[n++] = buf[idx++] + nearest;
      }
      break;
    }
    default: {
      fprintf(stderr, "bad PNG predictor tag: %d\n", tag);
    }
    }
  }
}


x86 assembly (clang, -O0):
<pdf_filt_predict_png_decode>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    15d4 <pdf_filt_predict_png_decode+0x4b4>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %rax,-0x70(%rbp)
sub    $0x4,%rax
ja     15a9 <pdf_filt_predict_png_decode+0x489>
mov    -0x70(%rbp),%rax
lea    0xe53(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1201 <pdf_filt_predict_png_decode+0xe1>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11bd <pdf_filt_predict_png_decode+0x9d>
jmp    15c1 <pdf_filt_predict_png_decode+0x4a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1251 <pdf_filt_predict_png_decode+0x131>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    120d <pdf_filt_predict_png_decode+0xed>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12b4 <pdf_filt_predict_png_decode+0x194>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    125a <pdf_filt_predict_png_decode+0x13a>
jmp    15c1 <pdf_filt_predict_png_decode+0x4a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1339 <pdf_filt_predict_png_decode+0x219>
cmpl   $0x0,-0x30(%rbp)
je     12ee <pdf_filt_predict_png_decode+0x1ce>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
jmp    12f8 <pdf_filt_predict_png_decode+0x1d8>
xor    %eax,%eax
mov    %eax,-0x74(%rbp)
jmp    12f8 <pdf_filt_predict_png_decode+0x1d8>
mov    -0x74(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    -0x40(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12c0 <pdf_filt_predict_png_decode+0x1a0>
jmp    15c1 <pdf_filt_predict_png_decode+0x4a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1400 <pdf_filt_predict_png_decode+0x2e0>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1367 <pdf_filt_predict_png_decode+0x247>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    137a <pdf_filt_predict_png_decode+0x25a>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     13a2 <pdf_filt_predict_png_decode+0x282>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    13ac <pdf_filt_predict_png_decode+0x28c>
xor    %eax,%eax
mov    %eax,-0x7c(%rbp)
jmp    13ac <pdf_filt_predict_png_decode+0x28c>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x80(%rbp),%edx
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1345 <pdf_filt_predict_png_decode+0x225>
jmp    15c1 <pdf_filt_predict_png_decode+0x4a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15a4 <pdf_filt_predict_png_decode+0x484>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1431 <pdf_filt_predict_png_decode+0x311>
xor    %eax,%eax
mov    %eax,-0x84(%rbp)
jmp    1447 <pdf_filt_predict_png_decode+0x327>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1475 <pdf_filt_predict_png_decode+0x355>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
jmp    1482 <pdf_filt_predict_png_decode+0x362>
xor    %eax,%eax
mov    %eax,-0x88(%rbp)
jmp    1482 <pdf_filt_predict_png_decode+0x362>
mov    -0x88(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     14bf <pdf_filt_predict_png_decode+0x39f>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     14bf <pdf_filt_predict_png_decode+0x39f>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    14cc <pdf_filt_predict_png_decode+0x3ac>
xor    %eax,%eax
mov    %eax,-0x8c(%rbp)
jmp    14cc <pdf_filt_predict_png_decode+0x3ac>
mov    -0x8c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x50(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%edi
sub    -0x4c(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%edi
sub    -0x50(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%edi
sub    -0x54(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1531 <pdf_filt_predict_png_decode+0x411>
mov    -0x5c(%rbp),%eax
cmp    -0x64(%rbp),%eax
jg     1531 <pdf_filt_predict_png_decode+0x411>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    1560 <pdf_filt_predict_png_decode+0x440>
mov    -0x60(%rbp),%eax
cmp    -0x64(%rbp),%eax
jg     154b <pdf_filt_predict_png_decode+0x42b>
mov    -0x50(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    1554 <pdf_filt_predict_png_decode+0x434>
mov    -0x54(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    -0x68(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    140c <pdf_filt_predict_png_decode+0x2ec>
jmp    15c1 <pdf_filt_predict_png_decode+0x4a1>
mov    0x2a30(%rip),%rax
mov    (%rax),%edi
mov    -0x34(%rbp),%edx
lea    0xa58(%rip),%rsi
call   1040 <fprintf@plt>
jmp    15c6 <pdf_filt_predict_png_decode+0x4a6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116f <pdf_filt_predict_png_decode+0x4f>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pdf_filt_predict_png_decode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %edx,%r14d
imul   %edx,%ecx
imul   %r8d,%ecx
lea    0x7(%rcx),%eax
lea    0xe(%rcx),%edx
test   %eax,%eax
cmovns %eax,%edx
test   %r9d,%r9d
jle    1ccf <pdf_filt_predict_png_decode+0xbbf>
mov    %rsi,%r11
sar    $0x3,%edx
movslq %edx,%rax
cmp    $0x2,%eax
mov    %rax,%r13
mov    $0x1,%r15d
cmovge %edx,%r15d
mov    %rdi,0x20(%rsp)
movslq %r14d,%rbp
mov    %ebp,%edi
not    %edi
add    %edx,%edi
lea    0x1(%rdi),%r8
lea    0x0(,%rbp,4),%rax
mov    %rax,0x58(%rsp)
sub    %rax,%rsi
mov    %r8,%rax
sub    %rbp,%rax
lea    (%r11,%rax,4),%rax
mov    %rax,0x28(%rsp)
mov    %rcx,0x18(%rsp)
lea    -0x1(%rbp),%eax
mov    %rax,0x78(%rsp)
add    $0x1,%rax
mov    %rax,0x110(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0x108(%rsp)
lea    -0x8(%rax),%r10
mov    %r10,0x100(%rsp)
mov    %r9d,0x14(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r8,0xd0(%rsp)
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%r9
mov    %r9,0xc0(%rsp)
shr    $0x3,%r9
add    $0x1,%r9
lea    -0x1(%r15),%r12d
lea    0x1(%r12),%rax
mov    %rax,0xf0(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0xe8(%rsp)
lea    -0x8(%rax),%rcx
mov    %rcx,0xe0(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r10,%rax
mov    %r10,0xf8(%rsp)
and    $0xfffffffffffffffe,%r10
mov    %r10,0xb0(%rsp)
cmp    %r11,0x28(%rsp)
seta   0x28(%rsp)
lea    (%r11,%rdi,4),%rax
add    $0x4,%rax
mov    %rsi,0x90(%rsp)
mov    %rax,0x140(%rsp)
cmp    %rax,%rsi
setb   %al
mov    %r13,%rbx
lea    0x0(,%r13,4),%rsi
mov    %r11,%r10
sub    %rsi,%r10
mov    %r10,0x80(%rsp)
mov    0x14(%rsp),%r13d
and    0x28(%rsp),%al
mov    %al,0x7(%rsp)
mov    %r9,%rax
mov    %r9,0xb8(%rsp)
and    $0xfffffffffffffffe,%r9
mov    %r9,0xa0(%rsp)
mov    %rcx,%rax
mov    %rcx,0xd8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa8(%rsp)
mov    %rdx,0x30(%rsp)
lea    (%rdx,%r14,1),%eax
neg    %eax
mov    %rax,0x168(%rsp)
mov    $0x1,%eax
mov    %rbx,%rcx
mov    %rbx,0x118(%rsp)
sub    %rbx,%rax
lea    (%r11,%rax,4),%rax
mov    %rax,0x158(%rsp)
mov    %r15d,%r9d
and    $0x7ffffffe,%r9d
mov    %ebp,%eax
neg    %eax
mov    %eax,0x54(%rsp)
negq   0x58(%rsp)
mov    $0x1,%eax
mov    %rbp,0x60(%rsp)
sub    %rbp,%rax
mov    0x20(%rsp),%rbp
lea    (%r11,%rax,4),%rax
mov    %rax,0x120(%rsp)
mov    %r15d,%eax
neg    %eax
mov    %eax,0x50(%rsp)
lea    (%r11,%r12,4),%rax
add    $0x4,%rax
mov    %rax,0x130(%rsp)
mov    %r12,0x88(%rsp)
lea    0x4(%rbp,%r12,4),%rax
mov    %rax,0x150(%rsp)
mov    %rdi,0x160(%rsp)
lea    0x4(%rbp,%rdi,4),%rax
mov    %rax,0x138(%rsp)
mov    0x78(%rsp),%rcx
lea    0x4(%r11,%rcx,4),%rax
mov    %rax,0x128(%rsp)
lea    0x4(%rbp,%rcx,4),%rax
mov    %rax,0x148(%rsp)
mov    0x18(%rsp),%rcx
mov    %r8,0xc8(%rsp)
lea    (%r8,%r14,1),%eax
mov    %eax,0x4c(%rsp)
mov    %r11,%rdi
lea    0x4(%r11),%rax
mov    %rax,0x70(%rsp)
lea    0x4(%rbp),%rax
mov    %rax,0x68(%rsp)
lea    0x30(%r11),%rax
mov    %rax,0x40(%rsp)
lea    0x30(%rbp),%rax
mov    %rax,0x38(%rsp)
xor    %r8d,%r8d
lea    0xc46(%rip),%r10
xor    %ebx,%ebx
xor    %r12d,%r12d
mov    %r14,0x28(%rsp)
mov    %r11,0x8(%rsp)
mov    %r15,0x180(%rsp)
mov    %r9,0x98(%rsp)
jmp    142d <pdf_filt_predict_png_decode+0x31d>
mov    0x2bfe(%rip),%rax
mov    (%rax),%edi
lea    0xc29(%rip),%rsi
mov    %rbp,%r13
mov    %rbx,%rbp
mov    %r8,%rbx
call   1030 <fprintf@plt>
lea    0xc00(%rip),%r10
mov    %rbx,%r8
mov    %rbp,%rbx
mov    %r13,%rbp
mov    0x98(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rcx
mov    0x14(%rsp),%r13d
add    $0x1,%r12d
cmp    %r13d,%r12d
je     1ccf <pdf_filt_predict_png_decode+0xbbf>
movslq %r8d,%rax
add    $0x1,%r8d
mov    0x0(%rbp,%rax,4),%edx
cmp    $0x4,%rdx
ja     13db <pdf_filt_predict_png_decode+0x2cb>
movslq (%r10,%rdx,4),%rax
add    %r10,%rax
jmp    *%rax
test   %ecx,%ecx
jle    1420 <pdf_filt_predict_png_decode+0x310>
xor    %eax,%eax
movslq %r8d,%r8
movslq %ebx,%rbx
cmpl   $0x7,0x88(%rsp)
07
jb     154a <pdf_filt_predict_png_decode+0x43a>
lea    (%rdi,%rbx,4),%rcx
mov    0x150(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
cmp    %rdx,%rcx
jae    1496 <pdf_filt_predict_png_decode+0x386>
mov    0x130(%rsp),%rcx
lea    (%rcx,%rbx,4),%rcx
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
cmp    %rcx,%rdx
jb     154a <pdf_filt_predict_png_decode+0x43a>
cmpq   $0x0,0xe0(%rsp)
je     1c38 <pdf_filt_predict_png_decode+0xb28>
mov    0x40(%rsp),%rax
lea    (%rax,%rbx,4),%rcx
mov    0x38(%rsp),%rax
lea    (%rax,%r8,4),%rdx
mov    0xa8(%rsp),%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rax,4),%xmm0
movups -0x20(%rdx,%rax,4),%xmm1
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movdqu -0x10(%rdx,%rax,4),%xmm0
movdqu (%rdx,%rax,4),%xmm1
movdqu %xmm0,-0x10(%rcx,%rax,4)
movdqu %xmm1,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rsi
jne    14d0 <pdf_filt_predict_png_decode+0x3c0>
testb  $0x1,0xd8(%rsp)
01
je     152c <pdf_filt_predict_png_decode+0x41c>
lea    (%rax,%rbx,1),%rcx
add    %r8,%rax
movdqu 0x0(%rbp,%rax,4),%xmm0
movdqu 0x10(%rbp,%rax,4),%xmm1
movdqu %xmm0,(%rdi,%rcx,4)
movdqu %xmm1,0x10(%rdi,%rcx,4)
mov    0xe8(%rsp),%rcx
add    %rcx,%rbx
add    %rcx,%r8
mov    %ecx,%eax
cmp    %rcx,0xf0(%rsp)
je     18cb <pdf_filt_predict_png_decode+0x7bb>
mov    %r15d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r15d,%ecx
and    $0x3,%edx
je     15ac <pdf_filt_predict_png_decode+0x49c>
mov    %r13d,%r11d
mov    %rbx,%r13
lea    (%rdi,%rbx,4),%rdi
mov    %rbp,%rbx
lea    0x0(,%r8,4),%rbx
add    %rbp,%rbx
neg    %edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%ebp
mov    %ebp,(%rdi)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rsi
add    $0x4,%rbx
cmp    %esi,%edx
jne    1580 <pdf_filt_predict_png_decode+0x470>
mov    %r13,%rbx
sub    %rsi,%rbx
sub    %rsi,%r8
sub    %esi,%eax
mov    0x20(%rsp),%rbp
mov    %r11d,%r13d
mov    0x8(%rsp),%rdi
cmp    $0x3,%ecx
jb     18cb <pdf_filt_predict_png_decode+0x7bb>
lea    (%rdi,%rbx,4),%rcx
mov    %rbp,%r11
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
add    0x50(%rsp),%eax
mov    $0xc,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0xc(%rdx,%rdi,1),%ebp
mov    %ebp,-0xc(%rcx,%rdi,1)
mov    -0x8(%rdx,%rdi,1),%ebp
mov    %ebp,-0x8(%rcx,%rdi,1)
mov    -0x4(%rdx,%rdi,1),%ebp
mov    %ebp,-0x4(%rcx,%rdi,1)
mov    (%rdx,%rdi,1),%ebp
mov    %ebp,(%rcx,%rdi,1)
add    $0xfffffffffffffffc,%rsi
add    $0x10,%rdi
cmp    %esi,%eax
jne    15e0 <pdf_filt_predict_png_decode+0x4d0>
sub    %rsi,%rbx
sub    %rsi,%r8
jmp    18c3 <pdf_filt_predict_png_decode+0x7b3>
test   %r14d,%r14d
jle    17dd <pdf_filt_predict_png_decode+0x6cd>
xor    %eax,%eax
movslq %r8d,%r8
movslq %ebx,%rbx
cmpl   $0x7,0x78(%rsp)
jb     171a <pdf_filt_predict_png_decode+0x60a>
lea    (%rdi,%rbx,4),%rcx
mov    0x148(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
cmp    %rdx,%rcx
jae    1666 <pdf_filt_predict_png_decode+0x556>
mov    0x128(%rsp),%rcx
lea    (%rcx,%rbx,4),%rcx
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
cmp    %rcx,%rdx
jb     171a <pdf_filt_predict_png_decode+0x60a>
cmpq   $0x0,0x100(%rsp)
je     1c4d <pdf_filt_predict_png_decode+0xb3d>
mov    0x40(%rsp),%rax
lea    (%rax,%rbx,4),%rcx
mov    0x38(%rsp),%rax
lea    (%rax,%r8,4),%rdx
mov    0xb0(%rsp),%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rax,4),%xmm0
movups -0x20(%rdx,%rax,4),%xmm1
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movdqu -0x10(%rdx,%rax,4),%xmm0
movdqu (%rdx,%rax,4),%xmm1
movdqu %xmm0,-0x10(%rcx,%rax,4)
movdqu %xmm1,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rsi
jne    16a0 <pdf_filt_predict_png_decode+0x590>
testb  $0x1,0xf8(%rsp)
01
je     16fc <pdf_filt_predict_png_decode+0x5ec>
lea    (%rax,%rbx,1),%rcx
add    %r8,%rax
movdqu 0x0(%rbp,%rax,4),%xmm0
movdqu 0x10(%rbp,%rax,4),%xmm1
movdqu %xmm0,(%rdi,%rcx,4)
movdqu %xmm1,0x10(%rdi,%rcx,4)
mov    0x108(%rsp),%rcx
add    %rcx,%rbx
add    %rcx,%r8
mov    %ecx,%eax
cmp    %rcx,0x110(%rsp)
je     17d8 <pdf_filt_predict_png_decode+0x6c8>
mov    %r14d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r14d,%ecx
and    $0x3,%edx
je     177c <pdf_filt_predict_png_decode+0x66c>
mov    %r13d,%r11d
mov    %rbx,%r13
lea    (%rdi,%rbx,4),%rdi
mov    %rbp,%rbx
lea    0x0(,%r8,4),%rbx
add    %rbp,%rbx
neg    %edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%ebp
mov    %ebp,(%rdi)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rsi
add    $0x4,%rbx
cmp    %esi,%edx
jne    1750 <pdf_filt_predict_png_decode+0x640>
mov    %r13,%rbx
sub    %rsi,%rbx
sub    %rsi,%r8
sub    %esi,%eax
mov    0x20(%rsp),%rbp
mov    %r11d,%r13d
mov    0x8(%rsp),%rdi
cmp    $0x3,%ecx
jb     17d8 <pdf_filt_predict_png_decode+0x6c8>
lea    (%rdi,%rbx,4),%rcx
mov    %rbp,%r11
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
add    0x54(%rsp),%eax
mov    $0xc,%edi
xor    %esi,%esi
xchg   %ax,%ax
mov    -0xc(%rdx,%rdi,1),%ebp
mov    %ebp,-0xc(%rcx,%rdi,1)
mov    -0x8(%rdx,%rdi,1),%ebp
mov    %ebp,-0x8(%rcx,%rdi,1)
mov    -0x4(%rdx,%rdi,1),%ebp
mov    %ebp,-0x4(%rcx,%rdi,1)
mov    (%rdx,%rdi,1),%ebp
mov    %ebp,(%rcx,%rdi,1)
add    $0xfffffffffffffffc,%rsi
add    $0x10,%rdi
cmp    %esi,%eax
jne    17a0 <pdf_filt_predict_png_decode+0x690>
sub    %rsi,%rbx
sub    %rsi,%r8
mov    %r11,%rbp
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rcx
cmp    %r14d,0x30(%rsp)
jle    1420 <pdf_filt_predict_png_decode+0x310>
movslq %r8d,%r8
movslq %ebx,%rbx
cmpl   $0x7,0x160(%rsp)
07
jb     1837 <pdf_filt_predict_png_decode+0x727>
lea    (%rdi,%rbx,4),%rax
mov    0x140(%rsp),%rcx
lea    (%rcx,%rbx,4),%rcx
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
mov    0x138(%rsp),%rsi
lea    (%rsi,%r8,4),%rsi
cmp    %rsi,%rax
setb   %al
cmp    %rcx,%rdx
setb   %cl
and    %al,%cl
or     0x7(%rsp),%cl
je     1b82 <pdf_filt_predict_png_decode+0xa72>
mov    %r14d,%eax
mov    0x30(%rsp),%rcx
mov    %ecx,%edx
sub    %eax,%edx
lea    0x1(%rax),%ecx
test   $0x1,%dl
je     1868 <pdf_filt_predict_png_decode+0x758>
mov    %rbx,%rax
sub    0x60(%rsp),%rax
mov    0x0(%rbp,%r8,4),%edx
add    $0x1,%r8
add    (%rdi,%rax,4),%edx
mov    %edx,(%rdi,%rbx,4)
add    $0x1,%rbx
mov    %ecx,%eax
cmp    %ecx,0x30(%rsp)
je     18cb <pdf_filt_predict_png_decode+0x7bb>
mov    %rbp,%r11
mov    0x120(%rsp),%rcx
lea    (%rcx,%rbx,4),%rcx
mov    0x70(%rsp),%rdx
lea    (%rdx,%rbx,4),%rdx
mov    0x68(%rsp),%rsi
lea    (%rsi,%r8,4),%rsi
mov    0x30(%rsp),%rdi
sub    %eax,%edi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rsi,%rax,4),%ebp
add    -0x4(%rcx,%rax,4),%ebp
mov    %ebp,-0x4(%rdx,%rax,4)
mov    (%rsi,%rax,4),%ebp
add    (%rcx,%rax,4),%ebp
mov    %ebp,(%rdx,%rax,4)
add    $0x2,%rax
cmp    %eax,%edi
jne    18a0 <pdf_filt_predict_png_decode+0x790>
add    %rax,%rbx
add    %rax,%r8
mov    %r11,%rbp
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rcx
jmp    1420 <pdf_filt_predict_png_decode+0x310>
test   %ecx,%ecx
jle    1420 <pdf_filt_predict_png_decode+0x310>
movslq %r8d,%r8
movslq %ebx,%rbx
cmpl   $0x0,0x88(%rsp)
je     1b5c <pdf_filt_predict_png_decode+0xa4c>
mov    %rbp,%r11
mov    0x158(%rsp),%rax
lea    (%rax,%rbx,4),%rcx
mov    0x70(%rsp),%rax
lea    (%rax,%rbx,4),%rdx
mov    0x68(%rsp),%rax
lea    (%rax,%r8,4),%rsi
xor    %eax,%eax
jmp    1933 <pdf_filt_predict_png_decode+0x823>
cs nopw 0x0(%rax,%rax,1)
add    (%rsi,%rax,4),%edi
mov    %edi,(%rdx,%rax,4)
add    $0x2,%rax
cmp    %eax,%r9d
je     1b49 <pdf_filt_predict_png_decode+0xa39>
xor    %edi,%edi
mov    $0x0,%ebp
test   %r12d,%r12d
je     1943 <pdf_filt_predict_png_decode+0x833>
mov    -0x4(%rcx,%rax,4),%ebp
add    -0x4(%rsi,%rax,4),%ebp
mov    %ebp,-0x4(%rdx,%rax,4)
test   %r12d,%r12d
je     1920 <pdf_filt_predict_png_decode+0x810>
mov    (%rcx,%rax,4),%edi
jmp    1920 <pdf_filt_predict_png_decode+0x810>
test   %ecx,%ecx
jle    1420 <pdf_filt_predict_png_decode+0x310>
mov    %r8,%r10
movslq %r8d,%rax
mov    %rbx,%r13
movslq %ebx,%rsi
mov    %rdi,%r11
lea    (%rdi,%rsi,4),%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
mov    0x90(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
lea    0x0(,%rax,4),%rdi
add    %rbp,%rdi
xor    %eax,%eax
jmp    19be <pdf_filt_predict_png_decode+0x8ae>
nopw   0x0(%rax,%rax,1)
add    %ebx,%esi
mov    %esi,%ebp
shr    $0x1f,%ebp
add    %esi,%ebp
sar    %ebp
add    (%rdi,%rax,4),%ebp
mov    %ebp,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %eax,%r15d
je     1ae3 <pdf_filt_predict_png_decode+0x9d3>
xor    %esi,%esi
mov    $0x0,%ebx
cmp    %r14d,%eax
jl     19ce <pdf_filt_predict_png_decode+0x8be>
mov    (%r8,%rax,4),%ebx
test   %r12d,%r12d
je     19a0 <pdf_filt_predict_png_decode+0x890>
mov    (%rdx,%rax,4),%esi
jmp    19a0 <pdf_filt_predict_png_decode+0x890>
test   %ecx,%ecx
jle    1420 <pdf_filt_predict_png_decode+0x310>
mov    %r8,0x178(%rsp)
movslq %r8d,%rax
movslq %ebx,%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%rcx,4),%r10
mov    0x168(%rsp),%rdx
mov    %rbx,0x170(%rsp)
lea    (%rdx,%rbx,1),%r8d
mov    %rdi,%r11
lea    (%rdi,%rcx,4),%r11
mov    0x90(%rsp),%rdx
lea    (%rdx,%rcx,4),%r9
mov    %rbp,%rbx
lea    0x0(,%rax,4),%rbx
add    %rbp,%rbx
xor    %edx,%edx
jmp    1a6d <pdf_filt_predict_png_decode+0x95d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %r13d,%ebp
cmova  %eax,%ecx
cmp    %r14d,%ebp
cmova  %eax,%ecx
add    (%rbx,%rdx,4),%ecx
mov    %ecx,(%r11,%rdx,4)
add    $0x1,%rdx
mov    0x180(%rsp),%r15
cmp    %edx,%r15d
mov    0x28(%rsp),%r14
je     1b0c <pdf_filt_predict_png_decode+0x9fc>
cmp    %r14d,%edx
jge    1a80 <pdf_filt_predict_png_decode+0x970>
xor    %ecx,%ecx
test   %r12d,%r12d
je     1aa0 <pdf_filt_predict_png_decode+0x990>
mov    (%r10,%rdx,4),%edi
jmp    1aa2 <pdf_filt_predict_png_decode+0x992>
nop
mov    (%r9,%rdx,4),%ecx
test   %r12d,%r12d
je     1aa0 <pdf_filt_predict_png_decode+0x990>
mov    (%r10,%rdx,4),%edi
lea    (%r8,%rdx,1),%eax
cltq
mov    0x8(%rsp),%rsi
mov    (%rsi,%rax,4),%eax
jmp    1aa4 <pdf_filt_predict_png_decode+0x994>
nopl   (%rax)
xor    %edi,%edi
xor    %eax,%eax
lea    (%rdi,%rcx,1),%r15d
sub    %eax,%r15d
mov    %r15d,%esi
sub    %ecx,%esi
mov    %esi,%ebp
neg    %ebp
cmovs  %esi,%ebp
mov    %r15d,%esi
sub    %edi,%esi
mov    %esi,%r14d
neg    %r14d
cmovs  %esi,%r14d
sub    %eax,%r15d
mov    %r15d,%r13d
neg    %r13d
cmovs  %r15d,%r13d
cmp    %r13d,%r14d
ja     1a40 <pdf_filt_predict_png_decode+0x930>
mov    %edi,%eax
jmp    1a40 <pdf_filt_predict_png_decode+0x930>
mov    %r13,%rbx
add    %eax,%ebx
mov    %r10,%r8
add    %eax,%r8d
mov    0x20(%rsp),%rbp
lea    0x506(%rip),%r10
mov    0x14(%rsp),%r13d
mov    %r11,%rdi
mov    0x18(%rsp),%rcx
jmp    1420 <pdf_filt_predict_png_decode+0x310>
mov    0x170(%rsp),%rbx
add    %edx,%ebx
mov    0x178(%rsp),%r8
add    %edx,%r8d
mov    0x14(%rsp),%r13d
mov    0x18(%rsp),%rcx
mov    0x8(%rsp),%rdi
mov    0x20(%rsp),%rbp
mov    0x98(%rsp),%r9
lea    0x4bc(%rip),%r10
jmp    1420 <pdf_filt_predict_png_decode+0x310>
add    %rax,%rbx
add    %rax,%r8
mov    %r11,%rbp
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rcx
test   $0x1,%r15b
je     1420 <pdf_filt_predict_png_decode+0x310>
test   %r12d,%r12d
je     1c21 <pdf_filt_predict_png_decode+0xb11>
mov    %rbx,%rax
sub    0x118(%rsp),%rax
mov    (%rdi,%rax,4),%eax
jmp    1c23 <pdf_filt_predict_png_decode+0xb13>
mov    %rdi,%r11
cmpq   $0x0,0xc0(%rsp)
je     1c62 <pdf_filt_predict_png_decode+0xb52>
mov    0x40(%rsp),%rax
lea    (%rax,%rbx,4),%rcx
mov    0x58(%rsp),%rax
lea    (%rcx,%rax,1),%rdx
mov    0x38(%rsp),%rax
lea    (%rax,%r8,4),%rsi
mov    0xa0(%rsp),%rdi
xor    %eax,%eax
nopl   0x0(%rax)
movdqu -0x30(%rdx,%rax,4),%xmm0
movdqu -0x20(%rdx,%rax,4),%xmm1
movdqu -0x30(%rsi,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rsi,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rcx,%rax,4)
movdqu %xmm0,-0x20(%rcx,%rax,4)
movdqu -0x10(%rdx,%rax,4),%xmm0
movdqu (%rdx,%rax,4),%xmm1
movdqu -0x10(%rsi,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rsi,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rcx,%rax,4)
movdqu %xmm0,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
jne    1bc0 <pdf_filt_predict_png_decode+0xab0>
jmp    1c64 <pdf_filt_predict_png_decode+0xb54>
xor    %eax,%eax
add    0x0(%rbp,%r8,4),%eax
add    $0x1,%r8
mov    %eax,(%rdi,%rbx,4)
add    $0x1,%rbx
jmp    1420 <pdf_filt_predict_png_decode+0x310>
xor    %eax,%eax
testb  $0x1,0xd8(%rsp)
01
jne    150e <pdf_filt_predict_png_decode+0x3fe>
jmp    152c <pdf_filt_predict_png_decode+0x41c>
xor    %eax,%eax
testb  $0x1,0xf8(%rsp)
01
jne    16de <pdf_filt_predict_png_decode+0x5ce>
jmp    16fc <pdf_filt_predict_png_decode+0x5ec>
xor    %eax,%eax
testb  $0x1,0xb8(%rsp)
01
mov    %r11,%rdi
je     1caa <pdf_filt_predict_png_decode+0xb9a>
lea    (%rax,%rbx,1),%rcx
add    %r8,%rax
mov    %rcx,%rdx
sub    0x60(%rsp),%rdx
movdqu (%rdi,%rdx,4),%xmm0
movdqu 0x10(%rdi,%rdx,4),%xmm1
movdqu 0x0(%rbp,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbp,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rdi,%rcx,4)
movdqu %xmm0,0x10(%rdi,%rcx,4)
mov    0xc8(%rsp),%rcx
add    %rcx,%rbx
add    %rcx,%r8
mov    0x4c(%rsp),%eax
cmp    %rcx,0xd0(%rsp)
je     18cb <pdf_filt_predict_png_decode+0x7bb>
jmp    183a <pdf_filt_predict_png_decode+0x72a>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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