#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_encode(uint8_t *buf, uint8_t *out,
                                        uint8_t colors, uint8_t bpc,
                                        uint16_t columns, uint16_t rows,
                                        uint8_t tag) {
  int row_size = (colors * bpc * columns + 7) / 8;
  int idx = 0;
  int n = 0;
  int row;
  if (tag == 15) {
    tag = 4;
  } else if (tag >= 10 && tag <= 14) {
    tag -= 10;
  }
  if (tag > 5) {
    fprintf(stderr, "bad PNG predictor tag: %d\n", tag);
    return;
  }
  for (row = 0; row < rows; row++) {
    int i;
    out[n++] = tag;
    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 = buf[idx - colors];
        out[n++] = buf[idx++] - left_val;
      }
      break;
    }
    case 2: {
      for (i = 0; i < row_size; i++) {
        uint8_t up_val = row ? buf[idx - 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 : buf[idx - colors];
        uint8_t up_val = row ? buf[idx - 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 : buf[idx - colors];
        int up_val = row ? buf[idx - row_size] : 0;
        int up_left_val = row && i >= colors ? buf[idx - 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;
    }
    }
  }
}


x86 assembly (clang, -O0):
<pdf_filt_predict_png_encode>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%eax
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)
cmpl   $0xf,0x10(%rbp)
jne    1181 <pdf_filt_predict_png_encode+0x61>
movl   $0x4,0x10(%rbp)
jmp    11a3 <pdf_filt_predict_png_encode+0x83>
cmpl   $0xa,0x10(%rbp)
jl     119e <pdf_filt_predict_png_encode+0x7e>
cmpl   $0xe,0x10(%rbp)
jg     119e <pdf_filt_predict_png_encode+0x7e>
mov    0x10(%rbp),%eax
sub    $0xa,%eax
mov    %eax,0x10(%rbp)
jmp    11a3 <pdf_filt_predict_png_encode+0x83>
cmpl   $0x5,0x10(%rbp)
jle    11ca <pdf_filt_predict_png_encode+0xaa>
mov    0x2e2c(%rip),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%edx
lea    0xe54(%rip),%rsi
call   1040 <fprintf@plt>
jmp    161e <pdf_filt_predict_png_encode+0x4fe>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    161e <pdf_filt_predict_png_encode+0x4fe>
mov    0x10(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%eax
mov    %rax,-0x70(%rbp)
sub    $0x4,%rax
ja     160b <pdf_filt_predict_png_encode+0x4eb>
mov    -0x70(%rbp),%rax
lea    0xdf1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1263 <pdf_filt_predict_png_encode+0x143>
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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121f <pdf_filt_predict_png_encode+0xff>
jmp    160b <pdf_filt_predict_png_encode+0x4eb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b3 <pdf_filt_predict_png_encode+0x193>
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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126f <pdf_filt_predict_png_encode+0x14f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1316 <pdf_filt_predict_png_encode+0x1f6>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%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
sub    -0x38(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12bc <pdf_filt_predict_png_encode+0x19c>
jmp    160b <pdf_filt_predict_png_encode+0x4eb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    139b <pdf_filt_predict_png_encode+0x27b>
cmpl   $0x0,-0x30(%rbp)
je     1350 <pdf_filt_predict_png_encode+0x230>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
jmp    135a <pdf_filt_predict_png_encode+0x23a>
xor    %eax,%eax
mov    %eax,-0x74(%rbp)
jmp    135a <pdf_filt_predict_png_encode+0x23a>
mov    -0x74(%rbp),%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
sub    -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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1322 <pdf_filt_predict_png_encode+0x202>
jmp    160b <pdf_filt_predict_png_encode+0x4eb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1462 <pdf_filt_predict_png_encode+0x342>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13c9 <pdf_filt_predict_png_encode+0x2a9>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    13dc <pdf_filt_predict_png_encode+0x2bc>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1404 <pdf_filt_predict_png_encode+0x2e4>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    140e <pdf_filt_predict_png_encode+0x2ee>
xor    %eax,%eax
mov    %eax,-0x7c(%rbp)
jmp    140e <pdf_filt_predict_png_encode+0x2ee>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x44(%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    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x80(%rbp),%edx
sub    %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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a7 <pdf_filt_predict_png_encode+0x287>
jmp    160b <pdf_filt_predict_png_encode+0x4eb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1606 <pdf_filt_predict_png_encode+0x4e6>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1493 <pdf_filt_predict_png_encode+0x373>
xor    %eax,%eax
mov    %eax,-0x84(%rbp)
jmp    14a9 <pdf_filt_predict_png_encode+0x389>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     14d7 <pdf_filt_predict_png_encode+0x3b7>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
jmp    14e4 <pdf_filt_predict_png_encode+0x3c4>
xor    %eax,%eax
mov    %eax,-0x88(%rbp)
jmp    14e4 <pdf_filt_predict_png_encode+0x3c4>
mov    -0x88(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1521 <pdf_filt_predict_png_encode+0x401>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1521 <pdf_filt_predict_png_encode+0x401>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    152e <pdf_filt_predict_png_encode+0x40e>
xor    %eax,%eax
mov    %eax,-0x8c(%rbp)
jmp    152e <pdf_filt_predict_png_encode+0x40e>
mov    -0x8c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
sub    -0x48(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%edi
sub    -0x4c(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%edi
sub    -0x50(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1593 <pdf_filt_predict_png_encode+0x473>
mov    -0x58(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1593 <pdf_filt_predict_png_encode+0x473>
mov    -0x48(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    15c2 <pdf_filt_predict_png_encode+0x4a2>
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     15ad <pdf_filt_predict_png_encode+0x48d>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    15b6 <pdf_filt_predict_png_encode+0x496>
mov    -0x50(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x64(%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
sub    -0x64(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    146e <pdf_filt_predict_png_encode+0x34e>
jmp    160b <pdf_filt_predict_png_encode+0x4eb>
jmp    1610 <pdf_filt_predict_png_encode+0x4f0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d1 <pdf_filt_predict_png_encode+0xb1>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pdf_filt_predict_png_encode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x110,%rsp
mov    %rsi,%r14
mov    0x148(%rsp),%eax
imul   %edx,%ecx
imul   %r8d,%ecx
lea    0x7(%rcx),%esi
lea    0xe(%rcx),%ebx
test   %esi,%esi
cmovns %esi,%ebx
lea    -0xa(%rax),%esi
cmp    $0x5,%esi
cmovae %eax,%esi
cmp    $0xf,%eax
mov    $0x4,%r8d
cmovne %esi,%r8d
cmp    $0x5,%r8d
jle    1182 <pdf_filt_predict_png_encode+0x72>
mov    0x2e80(%rip),%rax
mov    (%rax),%edi
lea    0xeab(%rip),%rsi
mov    %r8d,%edx
add    $0x110,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fprintf@plt>
test   %r9d,%r9d
jle    1d7f <pdf_filt_predict_png_encode+0xc6f>
mov    %rdi,%r15
sar    $0x3,%ebx
mov    %rbx,-0x78(%rsp)
movslq %ebx,%r10
cmp    $0x2,%r10d
mov    $0x1,%esi
cmovge %ebx,%esi
movslq %edx,%rbp
mov    %ebp,%edi
not    %edi
add    %ebx,%edi
lea    0x1(%rdi),%r13
mov    %rcx,-0x60(%rsp)
lea    0x0(,%rbp,4),%r11
mov    %r15,%rax
sub    %r11,%rax
mov    %rax,-0x40(%rsp)
mov    %r13,%rax
sub    %rbp,%rax
lea    (%r15,%rax,4),%rax
mov    %rax,0xb8(%rsp)
lea    -0x1(%rbp),%eax
mov    %rax,-0x10(%rsp)
add    $0x1,%rax
mov    %rax,0x80(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0x78(%rsp)
lea    -0x8(%rax),%r12
mov    %r12,0x70(%rsp)
shr    $0x3,%r12
add    $0x1,%r12
lea    0x0(,%r10,4),%rax
mov    %r15,%rbx
sub    %rax,%rbx
mov    %rbx,(%rsp)
mov    %r13,0x40(%rsp)
and    $0xfffffffffffffff8,%r13
lea    -0x8(%r13),%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %r9d,-0x80(%rsp)
lea    -0x1(%rsi),%r9d
lea    0x1(%r9),%rax
mov    %rax,0x60(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rsp)
lea    -0x8(%rax),%rcx
mov    %rcx,0x50(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r12,%rax
mov    %r12,0x68(%rsp)
and    $0xfffffffffffffffe,%r12
mov    %r12,0x20(%rsp)
mov    %rbx,%rax
mov    %rbx,0x28(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
mov    -0x78(%rsp),%rax
add    %edx,%eax
neg    %eax
mov    %rax,0xe8(%rsp)
mov    $0x1,%eax
mov    %r10,0x88(%rsp)
sub    %r10,%rax
lea    (%r15,%rax,4),%rax
mov    %rax,0xd0(%rsp)
mov    %esi,%r12d
and    $0x7ffffffe,%r12d
mov    %ebp,%eax
neg    %eax
mov    %eax,-0x2c(%rsp)
neg    %r11
mov    %r11,0x10(%rsp)
mov    -0x60(%rsp),%r10
mov    $0x1,%eax
mov    %rbp,-0x28(%rsp)
sub    %rbp,%rax
lea    (%r15,%rax,4),%rax
mov    %rax,0x90(%rsp)
mov    %rsi,-0x58(%rsp)
mov    %esi,%eax
neg    %eax
mov    %eax,-0x30(%rsp)
lea    (%r14,%r9,4),%rax
add    $0x4,%rax
mov    %rax,0xa0(%rsp)
mov    %r9,-0x8(%rsp)
lea    0x4(%r15,%r9,4),%rax
mov    %rax,0xc8(%rsp)
mov    -0x80(%rsp),%r11d
lea    0x4(%r14,%rdi,4),%rax
mov    %rax,0xb0(%rsp)
mov    %rdi,0xd8(%rsp)
lea    0x4(%r15,%rdi,4),%rax
mov    %rax,0xa8(%rsp)
mov    -0x10(%rsp),%rsi
lea    0x4(%r14,%rsi,4),%rax
mov    %rax,0x98(%rsp)
lea    0x4(%r15,%rsi,4),%rax
mov    %rax,0xc0(%rsp)
mov    -0x78(%rsp),%rbx
mov    %r15,%rbp
mov    %r13,0x38(%rsp)
lea    0x0(%r13,%rdx,1),%eax
mov    %eax,-0x34(%rsp)
lea    0x4(%r14),%rax
mov    %rax,-0x18(%rsp)
lea    0x4(%r15),%rax
mov    %rax,-0x20(%rsp)
lea    0x30(%r14),%rax
mov    %rax,-0x48(%rsp)
lea    0x30(%r15),%rax
mov    %rax,-0x50(%rsp)
xor    %ecx,%ecx
xor    %r9d,%r9d
xor    %r13d,%r13d
mov    %rdx,0x108(%rsp)
mov    %r8d,-0x7c(%rsp)
mov    %r14,-0x68(%rsp)
mov    %r15,-0x70(%rsp)
mov    %r12,0xe0(%rsp)
jmp    142d <pdf_filt_predict_png_encode+0x31d>
mov    0xf0(%rsp),%r9
add    %r8d,%r9d
mov    0xf8(%rsp),%rcx
add    %r8d,%ecx
mov    -0x80(%rsp),%r11d
mov    -0x60(%rsp),%r10
mov    -0x68(%rsp),%r14
mov    -0x70(%rsp),%rbp
mov    -0x78(%rsp),%rbx
mov    -0x7c(%rsp),%r8d
mov    0xe0(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13d
cmp    %r11d,%r13d
je     1d7f <pdf_filt_predict_png_encode+0xc6f>
movslq %r9d,%rax
add    $0x1,%r9d
mov    %r8d,(%r14,%rax,4)
cmp    $0x4,%r8d
ja     1420 <pdf_filt_predict_png_encode+0x310>
mov    %r8d,%eax
lea    0xbb8(%rip),%rsi
movslq (%rsi,%rax,4),%rax
add    %rsi,%rax
jmp    *%rax
test   %r10d,%r10d
jle    1420 <pdf_filt_predict_png_encode+0x310>
xor    %ebx,%ebx
movslq %ecx,%rcx
movslq %r9d,%r9
cmpl   $0x7,-0x8(%rsp)
jb     184d <pdf_filt_predict_png_encode+0x73d>
mov    %rbp,%r15
lea    (%r14,%r9,4),%rax
mov    %rcx,%rbp
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rbp,4),%rcx
cmp    %rcx,%rax
jae    17a7 <pdf_filt_predict_png_encode+0x697>
mov    0xa0(%rsp),%rax
lea    (%rax,%r9,4),%rax
lea    (%r15,%rbp,4),%rcx
cmp    %rax,%rcx
jae    17a7 <pdf_filt_predict_png_encode+0x697>
mov    %rbp,%rcx
mov    %r15,%rbp
jmp    184d <pdf_filt_predict_png_encode+0x73d>
test   %edx,%edx
jle    1ac6 <pdf_filt_predict_png_encode+0x9b6>
xor    %ebx,%ebx
movslq %ecx,%rcx
movslq %r9d,%r9
cmpl   $0x7,-0x10(%rsp)
jb     19e0 <pdf_filt_predict_png_encode+0x8d0>
mov    %rbp,%r15
lea    (%r14,%r9,4),%rax
mov    %rcx,%rbp
mov    0xc0(%rsp),%rcx
lea    (%rcx,%rbp,4),%rcx
cmp    %rcx,%rax
jae    193b <pdf_filt_predict_png_encode+0x82b>
mov    0x98(%rsp),%rax
lea    (%rax,%r9,4),%rax
lea    (%r15,%rbp,4),%rcx
cmp    %rax,%rcx
jae    193b <pdf_filt_predict_png_encode+0x82b>
mov    %rbp,%rcx
mov    %r15,%rbp
jmp    19e0 <pdf_filt_predict_png_encode+0x8d0>
test   %r10d,%r10d
jle    1420 <pdf_filt_predict_png_encode+0x310>
movslq %ecx,%rcx
movslq %r9d,%r9
cmpl   $0x0,-0x8(%rsp)
je     177f <pdf_filt_predict_png_encode+0x66f>
mov    %rbp,%r11
mov    %r10,%r15
mov    -0x18(%rsp),%rax
mov    %r9,%r10
lea    (%rax,%r9,4),%rsi
mov    0xd0(%rsp),%rax
lea    (%rax,%rcx,4),%r8
mov    -0x20(%rsp),%rax
mov    %rcx,%r9
lea    (%rax,%rcx,4),%rbp
xor    %ecx,%ecx
jmp    1576 <pdf_filt_predict_png_encode+0x466>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp,%rcx,4),%eax
sub    %ebx,%eax
mov    %eax,(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %ecx,%r12d
je     175e <pdf_filt_predict_png_encode+0x64e>
xor    %ebx,%ebx
mov    $0x0,%eax
test   %r13d,%r13d
je     1587 <pdf_filt_predict_png_encode+0x477>
mov    -0x4(%r8,%rcx,4),%eax
mov    -0x4(%rbp,%rcx,4),%edi
sub    %eax,%edi
mov    %edi,-0x4(%rsi,%rcx,4)
test   %r13d,%r13d
je     1560 <pdf_filt_predict_png_encode+0x450>
mov    (%r8,%rcx,4),%ebx
jmp    1560 <pdf_filt_predict_png_encode+0x450>
test   %r10d,%r10d
jle    1420 <pdf_filt_predict_png_encode+0x310>
mov    %r9,%rsi
mov    %rcx,%r9
movslq %ecx,%rax
mov    %r14,%rdi
mov    %rsi,%r14
movslq %esi,%rcx
mov    %rdi,%r10
lea    (%rdi,%rcx,4),%rsi
mov    %rbp,%r15
lea    0x0(%rbp,%rax,4),%rbx
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%r11
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%r8
xor    %ecx,%ecx
jmp    1601 <pdf_filt_predict_png_encode+0x4f1>
nopl   0x0(%rax,%rax,1)
add    %ebp,%edi
mov    (%rbx,%rcx,4),%ebp
mov    %edi,%eax
shr    $0x1f,%eax
add    %edi,%eax
sar    %eax
sub    %eax,%ebp
mov    %ebp,(%rsi,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,-0x58(%rsp)
je     1733 <pdf_filt_predict_png_encode+0x623>
xor    %edi,%edi
mov    $0x0,%ebp
cmp    %edx,%ecx
jl     1610 <pdf_filt_predict_png_encode+0x500>
mov    (%r8,%rcx,4),%ebp
test   %r13d,%r13d
je     15e0 <pdf_filt_predict_png_encode+0x4d0>
mov    (%r11,%rcx,4),%edi
jmp    15e0 <pdf_filt_predict_png_encode+0x4d0>
test   %r10d,%r10d
jle    1420 <pdf_filt_predict_png_encode+0x310>
movslq %ecx,%rax
mov    %rcx,%rsi
mov    %r9,0xf0(%rsp)
movslq %r9d,%rcx
lea    (%r14,%rcx,4),%rbx
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%r12
mov    0xe8(%rsp),%rcx
mov    %rsi,0xf8(%rsp)
add    %esi,%ecx
mov    %rcx,0x100(%rsp)
mov    %rbp,%r15
lea    0x0(,%rax,4),%r15
add    %rbp,%r15
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%r9
xor    %r8d,%r8d
jmp    16ad <pdf_filt_predict_png_encode+0x59d>
nopw   0x0(%rax,%rax,1)
cmp    %r11d,%ebp
cmova  %edi,%ecx
cmp    %r14d,%ebp
cmova  %edi,%ecx
mov    (%r15,%r8,4),%eax
sub    %ecx,%eax
mov    %eax,(%rbx,%r8,4)
add    $0x1,%r8
cmp    %r8d,-0x58(%rsp)
mov    0x108(%rsp),%rdx
je     13d5 <pdf_filt_predict_png_encode+0x2c5>
cmp    %edx,%r8d
jge    16c0 <pdf_filt_predict_png_encode+0x5b0>
xor    %ecx,%ecx
test   %r13d,%r13d
je     16f0 <pdf_filt_predict_png_encode+0x5e0>
mov    (%r12,%r8,4),%esi
jmp    16f2 <pdf_filt_predict_png_encode+0x5e2>
nop
mov    (%r9,%r8,4),%ecx
test   %r13d,%r13d
je     16f0 <pdf_filt_predict_png_encode+0x5e0>
mov    (%r12,%r8,4),%esi
mov    0x100(%rsp),%rax
add    %r8d,%eax
cltq
mov    -0x70(%rsp),%rdx
mov    (%rdx,%rax,4),%edi
jmp    16f4 <pdf_filt_predict_png_encode+0x5e4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %esi,%esi
xor    %edi,%edi
lea    (%rsi,%rcx,1),%r10d
sub    %edi,%r10d
mov    %r10d,%eax
sub    %ecx,%eax
mov    %eax,%ebp
neg    %ebp
cmovs  %eax,%ebp
mov    %r10d,%eax
sub    %esi,%eax
mov    %eax,%r14d
neg    %r14d
cmovs  %eax,%r14d
sub    %edi,%r10d
mov    %r10d,%r11d
neg    %r11d
cmovs  %r10d,%r11d
cmp    %r11d,%r14d
ja     1680 <pdf_filt_predict_png_encode+0x570>
mov    %esi,%edi
jmp    1680 <pdf_filt_predict_png_encode+0x570>
add    %ecx,%r14d
add    %ecx,%r9d
mov    %r9,%rcx
mov    %r14,%r9
mov    -0x7c(%rsp),%r8d
mov    -0x78(%rsp),%rbx
mov    %r10,%r14
mov    -0x60(%rsp),%r10
mov    %r15,%rbp
mov    -0x80(%rsp),%r11d
jmp    1420 <pdf_filt_predict_png_encode+0x310>
add    %rcx,%r10
add    %rcx,%r9
mov    %r9,%rcx
mov    %r10,%r9
mov    -0x7c(%rsp),%r8d
mov    %r15,%r10
mov    %r11,%rbp
mov    -0x80(%rsp),%r11d
mov    -0x78(%rsp),%rbx
testb  $0x1,-0x58(%rsp)
je     1420 <pdf_filt_predict_png_encode+0x310>
test   %r13d,%r13d
je     1c92 <pdf_filt_predict_png_encode+0xb82>
mov    %rcx,%rax
sub    0x88(%rsp),%rax
mov    0x0(%rbp,%rax,4),%eax
jmp    1c94 <pdf_filt_predict_png_encode+0xb84>
cmpq   $0x0,0x50(%rsp)
je     1cb1 <pdf_filt_predict_png_encode+0xba1>
mov    -0x48(%rsp),%rax
lea    (%rax,%r9,4),%rsi
mov    -0x50(%rsp),%rax
lea    (%rax,%rbp,4),%rdi
mov    0x18(%rsp),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x30(%rdi,%rcx,4),%xmm0
movups -0x20(%rdi,%rcx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rcx,4)
movups %xmm1,-0x20(%rsi,%rcx,4)
movdqu -0x10(%rdi,%rcx,4),%xmm0
movdqu (%rdi,%rcx,4),%xmm1
movdqu %xmm0,-0x10(%rsi,%rcx,4)
movdqu %xmm1,(%rsi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    17d0 <pdf_filt_predict_png_encode+0x6c0>
testb  $0x1,0x48(%rsp)
je     182f <pdf_filt_predict_png_encode+0x71f>
lea    (%rcx,%r9,1),%rax
add    %rbp,%rcx
mov    %r15,%rsi
movdqu (%r15,%rcx,4),%xmm0
movdqu 0x10(%r15,%rcx,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
mov    0x58(%rsp),%rax
add    %rax,%r9
mov    %rbp,%rcx
add    %rax,%rcx
mov    %eax,%ebx
cmp    %rax,0x60(%rsp)
mov    %r15,%rbp
je     1931 <pdf_filt_predict_png_encode+0x821>
mov    -0x58(%rsp),%rax
mov    %eax,%esi
sub    %ebx,%esi
mov    %ebx,%r8d
not    %r8d
add    %eax,%r8d
and    $0x3,%esi
je     18ae <pdf_filt_predict_png_encode+0x79e>
mov    %r10,%r15
mov    %r9,%r10
mov    %rbp,%rax
lea    (%r14,%r9,4),%rbp
mov    %rcx,%r9
mov    %rax,%r11
lea    (%rax,%rcx,4),%rcx
neg    %esi
xor    %edi,%edi
nop
mov    (%rcx),%eax
mov    %eax,0x0(%rbp)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rdi
add    $0x4,%rcx
cmp    %edi,%esi
jne    1880 <pdf_filt_predict_png_encode+0x770>
sub    %rdi,%r10
mov    %r9,%rcx
mov    %r10,%r9
sub    %rdi,%rcx
sub    %edi,%ebx
mov    %r15,%r10
mov    %r11,%rbp
mov    -0x80(%rsp),%r11d
cmp    $0x3,%r8d
mov    -0x7c(%rsp),%r8d
jb     1931 <pdf_filt_predict_png_encode+0x821>
mov    %r10,%r15
mov    %rcx,%rax
mov    %r9,%r10
lea    (%r14,%r9,4),%rcx
mov    %rax,%r9
mov    %rbp,%r11
lea    0x0(,%rax,4),%rsi
add    %rbp,%rsi
add    -0x30(%rsp),%ebx
mov    $0xc,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0xc(%rsi,%rbp,1),%eax
mov    %eax,-0xc(%rcx,%rbp,1)
mov    -0x8(%rsi,%rbp,1),%eax
mov    %eax,-0x8(%rcx,%rbp,1)
mov    -0x4(%rsi,%rbp,1),%eax
mov    %eax,-0x4(%rcx,%rbp,1)
mov    (%rsi,%rbp,1),%eax
mov    %eax,(%rcx,%rbp,1)
add    $0xfffffffffffffffc,%rdi
add    $0x10,%rbp
cmp    %edi,%ebx
jne    18f0 <pdf_filt_predict_png_encode+0x7e0>
sub    %rdi,%r10
mov    %r9,%rcx
mov    %r10,%r9
sub    %rdi,%rcx
mov    %r15,%r10
mov    %r11,%rbp
mov    -0x80(%rsp),%r11d
mov    -0x78(%rsp),%rbx
jmp    1420 <pdf_filt_predict_png_encode+0x310>
cmpq   $0x0,0x70(%rsp)
je     1cc3 <pdf_filt_predict_png_encode+0xbb3>
mov    -0x48(%rsp),%rax
lea    (%rax,%r9,4),%rsi
mov    -0x50(%rsp),%rax
lea    (%rax,%rbp,4),%rdi
mov    0x20(%rsp),%rax
xor    %ecx,%ecx
movups -0x30(%rdi,%rcx,4),%xmm0
movups -0x20(%rdi,%rcx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rcx,4)
movups %xmm1,-0x20(%rsi,%rcx,4)
movdqu -0x10(%rdi,%rcx,4),%xmm0
movdqu (%rdi,%rcx,4),%xmm1
movdqu %xmm0,-0x10(%rsi,%rcx,4)
movdqu %xmm1,(%rsi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1960 <pdf_filt_predict_png_encode+0x850>
testb  $0x1,0x68(%rsp)
je     19bf <pdf_filt_predict_png_encode+0x8af>
lea    (%rcx,%r9,1),%rax
add    %rbp,%rcx
mov    %r15,%rsi
movdqu (%r15,%rcx,4),%xmm0
movdqu 0x10(%r15,%rcx,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
mov    0x78(%rsp),%rax
add    %rax,%r9
mov    %rbp,%rcx
add    %rax,%rcx
mov    %eax,%ebx
cmp    %rax,0x80(%rsp)
mov    %r15,%rbp
je     1ac1 <pdf_filt_predict_png_encode+0x9b1>
mov    %edx,%esi
sub    %ebx,%esi
mov    %ebx,%r8d
not    %r8d
add    %edx,%r8d
and    $0x3,%esi
je     1a3e <pdf_filt_predict_png_encode+0x92e>
mov    %r10,%r15
mov    %r9,%r10
mov    %rbp,%rax
lea    (%r14,%r9,4),%rbp
mov    %rcx,%r9
mov    %rax,%r11
lea    (%rax,%rcx,4),%rcx
neg    %esi
xor    %edi,%edi
nopl   (%rax)
mov    (%rcx),%eax
mov    %eax,0x0(%rbp)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rdi
add    $0x4,%rcx
cmp    %edi,%esi
jne    1a10 <pdf_filt_predict_png_encode+0x900>
sub    %rdi,%r10
mov    %r9,%rcx
mov    %r10,%r9
sub    %rdi,%rcx
sub    %edi,%ebx
mov    %r15,%r10
mov    %r11,%rbp
mov    -0x80(%rsp),%r11d
cmp    $0x3,%r8d
mov    -0x7c(%rsp),%r8d
jb     1ac1 <pdf_filt_predict_png_encode+0x9b1>
mov    %r10,%r15
mov    %rcx,%rax
mov    %r9,%r10
lea    (%r14,%r9,4),%rcx
mov    %rax,%r9
mov    %rbp,%r11
lea    0x0(,%rax,4),%rsi
add    %rbp,%rsi
add    -0x2c(%rsp),%ebx
mov    $0xc,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0xc(%rsi,%rbp,1),%eax
mov    %eax,-0xc(%rcx,%rbp,1)
mov    -0x8(%rsi,%rbp,1),%eax
mov    %eax,-0x8(%rcx,%rbp,1)
mov    -0x4(%rsi,%rbp,1),%eax
mov    %eax,-0x4(%rcx,%rbp,1)
mov    (%rsi,%rbp,1),%eax
mov    %eax,(%rcx,%rbp,1)
add    $0xfffffffffffffffc,%rdi
add    $0x10,%rbp
cmp    %edi,%ebx
jne    1a80 <pdf_filt_predict_png_encode+0x970>
sub    %rdi,%r10
mov    %r9,%rcx
mov    %r10,%r9
sub    %rdi,%rcx
mov    %r15,%r10
mov    %r11,%rbp
mov    -0x80(%rsp),%r11d
mov    -0x78(%rsp),%rbx
cmp    %edx,%ebx
jle    1420 <pdf_filt_predict_png_encode+0x310>
movslq %ecx,%rcx
movslq %r9d,%r9
cmpl   $0x7,0xd8(%rsp)
07
jae    1b84 <pdf_filt_predict_png_encode+0xa74>
mov    %rcx,%r10
mov    %edx,%ecx
mov    %ebx,%eax
sub    %ecx,%eax
lea    0x1(%rcx),%esi
test   $0x1,%al
je     1b11 <pdf_filt_predict_png_encode+0xa01>
mov    %r10,%rax
sub    -0x28(%rsp),%rax
mov    0x0(%rbp,%r10,4),%ecx
add    $0x1,%r10
sub    0x0(%rbp,%rax,4),%ecx
mov    %ecx,(%r14,%r9,4)
add    $0x1,%r9
mov    %esi,%ecx
cmp    %esi,%ebx
je     1d72 <pdf_filt_predict_png_encode+0xc62>
mov    %rbp,%r11
mov    -0x18(%rsp),%rax
lea    (%rax,%r9,4),%rsi
mov    0x90(%rsp),%rax
mov    %r10,%rbp
lea    (%rax,%r10,4),%rdi
mov    -0x20(%rsp),%rax
lea    (%rax,%r10,4),%rbp
mov    %rbx,%r15
sub    %ecx,%ebx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x4(%rbp,%rcx,4),%eax
sub    -0x4(%rdi,%rcx,4),%eax
mov    %eax,-0x4(%rsi,%rcx,4)
mov    0x0(%rbp,%rcx,4),%eax
sub    (%rdi,%rcx,4),%eax
mov    %eax,(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %ecx,%ebx
jne    1b50 <pdf_filt_predict_png_encode+0xa40>
add    %rcx,%r9
add    %rcx,%r10
mov    %r11,%rbp
mov    -0x80(%rsp),%r11d
mov    %r15,%rbx
jmp    1d72 <pdf_filt_predict_png_encode+0xc62>
mov    %rbx,%r15
lea    (%r14,%r9,4),%rax
mov    %rcx,%rsi
mov    0xb0(%rsp),%rcx
mov    %r9,%r14
lea    (%rcx,%r9,4),%rcx
lea    0x0(%rbp,%rsi,4),%r9
mov    0xa8(%rsp),%rdi
lea    (%rdi,%rsi,4),%rdi
mov    -0x40(%rsp),%rbp
lea    0x0(%rbp,%rsi,4),%rbp
mov    0xb8(%rsp),%rbx
mov    %rsi,%r10
lea    (%rbx,%rsi,4),%rbx
cmp    %rdi,%rax
setb   %dil
cmp    %rcx,%r9
setb   %sil
cmp    %rbx,%rax
setb   %al
cmp    %rcx,%rbp
setb   %cl
test   %sil,%dil
jne    1cd5 <pdf_filt_predict_png_encode+0xbc5>
and    %cl,%al
jne    1cec <pdf_filt_predict_png_encode+0xbdc>
cmpq   $0x0,0x30(%rsp)
je     1d03 <pdf_filt_predict_png_encode+0xbf3>
mov    -0x48(%rsp),%rax
mov    %r14,%r9
lea    (%rax,%r14,4),%rsi
mov    -0x50(%rsp),%rax
lea    (%rax,%r10,4),%rdi
mov    0x10(%rsp),%rax
lea    (%rdi,%rax,1),%rbp
mov    0x8(%rsp),%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x30(%rbp,%rcx,4),%xmm0
movdqu -0x20(%rbp,%rcx,4),%xmm1
movdqu -0x30(%rdi,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rcx,4)
movdqu %xmm0,-0x20(%rsi,%rcx,4)
movdqu -0x10(%rbp,%rcx,4),%xmm0
movdqu 0x0(%rbp,%rcx,4),%xmm1
movdqu -0x10(%rdi,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu (%rdi,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rcx,4)
movdqu %xmm0,(%rsi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1c30 <pdf_filt_predict_png_encode+0xb20>
jmp    1d08 <pdf_filt_predict_png_encode+0xbf8>
xor    %eax,%eax
mov    %rcx,%rsi
mov    0x0(%rbp,%rcx,4),%ecx
add    $0x1,%rsi
sub    %eax,%ecx
mov    %ecx,(%r14,%r9,4)
mov    %rsi,%rcx
add    $0x1,%r9
jmp    1420 <pdf_filt_predict_png_encode+0x310>
xor    %ecx,%ecx
testb  $0x1,0x48(%rsp)
jne    180b <pdf_filt_predict_png_encode+0x6fb>
jmp    182f <pdf_filt_predict_png_encode+0x71f>
xor    %ecx,%ecx
testb  $0x1,0x68(%rsp)
jne    199b <pdf_filt_predict_png_encode+0x88b>
jmp    19bf <pdf_filt_predict_png_encode+0x8af>
mov    %edx,%ecx
mov    %r14,%r9
mov    -0x68(%rsp),%r14
mov    -0x70(%rsp),%rbp
mov    %r15,%rbx
jmp    1ae7 <pdf_filt_predict_png_encode+0x9d7>
mov    %r15,%rbx
mov    %edx,%ecx
mov    %r14,%r9
mov    -0x68(%rsp),%r14
mov    -0x70(%rsp),%rbp
jmp    1ae7 <pdf_filt_predict_png_encode+0x9d7>
xor    %ecx,%ecx
mov    %r14,%r9
testb  $0x1,0x28(%rsp)
mov    -0x68(%rsp),%r14
mov    -0x70(%rsp),%rbp
je     1d55 <pdf_filt_predict_png_encode+0xc45>
lea    (%rcx,%r9,1),%rax
add    %r10,%rcx
mov    %rcx,%rsi
sub    -0x28(%rsp),%rsi
movdqu 0x0(%rbp,%rsi,4),%xmm0
movdqu 0x10(%rbp,%rsi,4),%xmm1
movdqu 0x0(%rbp,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbp,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,(%r14,%rax,4)
movdqu %xmm0,0x10(%r14,%rax,4)
mov    0x38(%rsp),%rax
add    %rax,%r9
add    %rax,%r10
mov    -0x34(%rsp),%ecx
cmp    %rax,0x40(%rsp)
mov    %r15,%rbx
jne    1ae7 <pdf_filt_predict_png_encode+0x9d7>
mov    %r10,%rcx
mov    -0x60(%rsp),%r10
jmp    1420 <pdf_filt_predict_png_encode+0x310>
add    $0x110,%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_encode(i32* %0, i32* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%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
%31 = alloca i32
store i32* %0, i32** %8
store i32* %1, i32** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%32 = load i32, i32* %10
%33 = load i32, i32* %11
%34 = mul nsw i32 %32, %33
%35 = load i32, i32* %12
%36 = mul nsw i32 %34, %35
%37 = add nsw i32 %36, 7
%38 = sdiv i32 %37, 8
store i32 %38, i32* %15
store i32 0, i32* %16
store i32 0, i32* %17
%39 = load i32, i32* %14
%40 = icmp eq i32 %39, 15
br i1 %40, label %41, label %42
41: ; preds = %7
store i32 4, i32* %14
br label %52
42: ; preds = %7
%43 = load i32, i32* %14
%44 = icmp sge i32 %43, 10
br i1 %44, label %45, label %51
45: ; preds = %42
%46 = load i32, i32* %14
%47 = icmp sle i32 %46, 14
br i1 %47, label %48, label %51
48: ; preds = %45
%49 = load i32, i32* %14
%50 = sub nsw i32 %49, 10
store i32 %50, i32* %14
br label %51
51: ; preds = %48, %45, %42
br label %52
52: ; preds = %51, %41
%53 = load i32, i32* %14
%54 = icmp sgt i32 %53, 5
br i1 %54, label %55, label %59
55: ; preds = %52
%56 = load i32, i32* @stderr
%57 = load i32, i32* %14
%58 = call i32 @fprintf(i32 %56, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 %57)
br label %345
59: ; preds = %52
store i32 0, i32* %18
br label %60
60: ; preds = %342, %59
%61 = load i32, i32* %18
%62 = load i32, i32* %13
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %345
64: ; preds = %60
%65 = load i32, i32* %14
%66 = load i32*, i32** %9
%67 = load i32, i32* %17
%68 = add nsw i32 %67, 1
store i32 %68, i32* %17
%69 = sext i32 %67 to i64
%70 = getelementptr inbounds i32, i32* %66, i64 %69
store i32 %65, i32* %70
%71 = load i32, i32* %14
switch i32 %71, label %341 [
i32 0, label %72
i32 1, label %93
i32 2, label %145
i32 3, label %181
i32 4, label %234
]
72: ; preds = %64
store i32 0, i32* %19
br label %73
73: ; preds = %89, %72
%74 = load i32, i32* %19
%75 = load i32, i32* %15
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %92
77: ; preds = %73
%78 = load i32*, i32** %8
%79 = load i32, i32* %16
%80 = add nsw i32 %79, 1
store i32 %80, i32* %16
%81 = sext i32 %79 to i64
%82 = getelementptr inbounds i32, i32* %78, i64 %81
%83 = load i32, i32* %82
%84 = load i32*, i32** %9
%85 = load i32, i32* %17
%86 = add nsw i32 %85, 1
store i32 %86, i32* %17
%87 = sext i32 %85 to i64
%88 = getelementptr inbounds i32, i32* %84, i64 %87
store i32 %83, i32* %88
br label %89
89: ; preds = %77
%90 = load i32, i32* %19
%91 = add nsw i32 %90, 1
store i32 %91, i32* %19
br label %73
92: ; preds = %73
br label %341
93: ; preds = %64
store i32 0, i32* %19
br label %94
94: ; preds = %110, %93
%95 = load i32, i32* %19
%96 = load i32, i32* %10
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %113
98: ; preds = %94
%99 = load i32*, i32** %8
%100 = load i32, i32* %16
%101 = add nsw i32 %100, 1
store i32 %101, i32* %16
%102 = sext i32 %100 to i64
%103 = getelementptr inbounds i32, i32* %99, i64 %102
%104 = load i32, i32* %103
%105 = load i32*, i32** %9
%106 = load i32, i32* %17
%107 = add nsw i32 %106, 1
store i32 %107, i32* %17
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds i32, i32* %105, i64 %108
store i32 %104, i32* %109
br label %110
110: ; preds = %98
%111 = load i32, i32* %19
%112 = add nsw i32 %111, 1
store i32 %112, i32* %19
br label %94
113: ; preds = %94
%114 = load i32, i32* %10
%115 = add nsw i32 %114, 1
store i32 %115, i32* %19
br label %116
116: ; preds = %141, %113
%117 = load i32, i32* %19
%118 = load i32, i32* %15
%119 = icmp sle i32 %117, %118
br i1 %119, label %120, label %144
120: ; preds = %116
%121 = load i32*, i32** %8
%122 = load i32, i32* %16
%123 = load i32, i32* %10
%124 = sub nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %121, i64 %125
%127 = load i32, i32* %126
store i32 %127, i32* %20
%128 = load i32*, i32** %8
%129 = load i32, i32* %16
%130 = add nsw i32 %129, 1
store i32 %130, i32* %16
%131 = sext i32 %129 to i64
%132 = getelementptr inbounds i32, i32* %128, i64 %131
%133 = load i32, i32* %132
%134 = load i32, i32* %20
%135 = sub nsw i32 %133, %134
%136 = load i32*, i32** %9
%137 = load i32, i32* %17
%138 = add nsw i32 %137, 1
store i32 %138, i32* %17
%139 = sext i32 %137 to i64
%140 = getelementptr inbounds i32, i32* %136, i64 %139
store i32 %135, i32* %140
br label %141
141: ; preds = %120
%142 = load i32, i32* %19
%143 = add nsw i32 %142, 1
store i32 %143, i32* %19
br label %116
144: ; preds = %116
br label %341
145: ; preds = %64
store i32 0, i32* %19
br label %146
146: ; preds = %177, %145
%147 = load i32, i32* %19
%148 = load i32, i32* %15
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %180
150: ; preds = %146
%151 = load i32, i32* %18
%152 = icmp ne i32 %151, 0
br i1 %152, label %153, label %161
153: ; preds = %150
%154 = load i32*, i32** %8
%155 = load i32, i32* %16
%156 = load i32, i32* %15
%157 = sub nsw i32 %155, %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %154, i64 %158
%160 = load i32, i32* %159
br label %162
161: ; preds = %150
br label %162
162: ; preds = %161, %153
%163 = phi i32 [ %160, %153 ], [ 0, %161 ]
store i32 %163, i32* %21
%164 = load i32*, i32** %8
%165 = load i32, i32* %16
%166 = add nsw i32 %165, 1
store i32 %166, i32* %16
%167 = sext i32 %165 to i64
%168 = getelementptr inbounds i32, i32* %164, i64 %167
%169 = load i32, i32* %168
%170 = load i32, i32* %21
%171 = sub nsw i32 %169, %170
%172 = load i32*, i32** %9
%173 = load i32, i32* %17
%174 = add nsw i32 %173, 1
store i32 %174, i32* %17
%175 = sext i32 %173 to i64
%176 = getelementptr inbounds i32, i32* %172, i64 %175
store i32 %171, i32* %176
br label %177
177: ; preds = %162
%178 = load i32, i32* %19
%179 = add nsw i32 %178, 1
store i32 %179, i32* %19
br label %146
180: ; preds = %146
br label %341
181: ; preds = %64
store i32 0, i32* %19
br label %182
182: ; preds = %230, %181
%183 = load i32, i32* %19
%184 = load i32, i32* %15
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %233
186: ; preds = %182
%187 = load i32, i32* %19
%188 = load i32, i32* %10
%189 = icmp slt i32 %187, %188
br i1 %189, label %190, label %191
190: ; preds = %186
br label %199
191: ; preds = %186
%192 = load i32*, i32** %8
%193 = load i32, i32* %16
%194 = load i32, i32* %10
%195 = sub nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i32, i32* %192, i64 %196
%198 = load i32, i32* %197
br label %199
199: ; preds = %191, %190
%200 = phi i32 [ 0, %190 ], [ %198, %191 ]
store i32 %200, i32* %22
%201 = load i32, i32* %18
%202 = icmp ne i32 %201, 0
br i1 %202, label %203, label %211
203: ; preds = %199
%204 = load i32*, i32** %8
%205 = load i32, i32* %16
%206 = load i32, i32* %15
%207 = sub nsw i32 %205, %206
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %204, i64 %208
%210 = load i32, i32* %209
br label %212
211: ; preds = %199
br label %212
212: ; preds = %211, %203
%213 = phi i32 [ %210, %203 ], [ 0, %211 ]
store i32 %213, i32* %23
%214 = load i32*, i32** %8
%215 = load i32, i32* %16
%216 = add nsw i32 %215, 1
store i32 %216, i32* %16
%217 = sext i32 %215 to i64
%218 = getelementptr inbounds i32, i32* %214, i64 %217
%219 = load i32, i32* %218
%220 = load i32, i32* %22
%221 = load i32, i32* %23
%222 = add nsw i32 %220, %221
%223 = sdiv i32 %222, 2
%224 = sub nsw i32 %219, %223
%225 = load i32*, i32** %9
%226 = load i32, i32* %17
%227 = add nsw i32 %226, 1
store i32 %227, i32* %17
%228 = sext i32 %226 to i64
%229 = getelementptr inbounds i32, i32* %225, i64 %228
store i32 %224, i32* %229
br label %230
230: ; preds = %212
%231 = load i32, i32* %19
%232 = add nsw i32 %231, 1
store i32 %232, i32* %19
br label %182
233: ; preds = %182
br label %341
234: ; preds = %64
store i32 0, i32* %19
br label %235
235: ; preds = %337, %234
%236 = load i32, i32* %19
%237 = load i32, i32* %15
%238 = icmp slt i32 %236, %237
br i1 %238, label %239, label %340
239: ; preds = %235
%240 = load i32, i32* %19
%241 = load i32, i32* %10
%242 = icmp slt i32 %240, %241
br i1 %242, label %243, label %244
243: ; preds = %239
br label %252
244: ; preds = %239
%245 = load i32*, i32** %8
%246 = load i32, i32* %16
%247 = load i32, i32* %10
%248 = sub nsw i32 %246, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %245, i64 %249
%251 = load i32, i32* %250
br label %252
252: ; preds = %244, %243
%253 = phi i32 [ 0, %243 ], [ %251, %244 ]
store i32 %253, i32* %24
%254 = load i32, i32* %18
%255 = icmp ne i32 %254, 0
br i1 %255, label %256, label %264
256: ; preds = %252
%257 = load i32*, i32** %8
%258 = load i32, i32* %16
%259 = load i32, i32* %15
%260 = sub nsw i32 %258, %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i32, i32* %257, i64 %261
%263 = load i32, i32* %262
br label %265
264: ; preds = %252
br label %265
265: ; preds = %264, %256
%266 = phi i32 [ %263, %256 ], [ 0, %264 ]
store i32 %266, i32* %25
%267 = load i32, i32* %18
%268 = icmp ne i32 %267, 0
br i1 %268, label %269, label %283
269: ; preds = %265
%270 = load i32, i32* %19
%271 = load i32, i32* %10
%272 = icmp sge i32 %270, %271
br i1 %272, label %273, label %283
273: ; preds = %269
%274 = load i32*, i32** %8
%275 = load i32, i32* %16
%276 = load i32, i32* %10
%277 = sub nsw i32 %275, %276
%278 = load i32, i32* %15
%279 = sub nsw i32 %277, %278
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32, i32* %274, i64 %280
%282 = load i32, i32* %281
br label %284
283: ; preds = %269, %265
br label %284
284: ; preds = %283, %273
%285 = phi i32 [ %282, %273 ], [ 0, %283 ]
store i32 %285, i32* %26
%286 = load i32, i32* %24
%287 = load i32, i32* %25
%288 = add nsw i32 %286, %287
%289 = load i32, i32* %26
%290 = sub nsw i32 %288, %289
store i32 %290, i32* %27
%291 = load i32, i32* %27
%292 = load i32, i32* %24
%293 = sub nsw i32 %291, %292
%294 = call i32 @abs(i32 %293)
store i32 %294, i32* %28
%295 = load i32, i32* %27
%296 = load i32, i32* %25
%297 = sub nsw i32 %295, %296
%298 = call i32 @abs(i32 %297)
store i32 %298, i32* %29
%299 = load i32, i32* %27
%300 = load i32, i32* %26
%301 = sub nsw i32 %299, %300
%302 = call i32 @abs(i32 %301)
store i32 %302, i32* %30
%303 = load i32, i32* %28
%304 = load i32, i32* %29
%305 = icmp sle i32 %303, %304
br i1 %305, label %306, label %312
306: ; preds = %284
%307 = load i32, i32* %28
%308 = load i32, i32* %30
%309 = icmp sle i32 %307, %308
br i1 %309, label %310, label %312
310: ; preds = %306
%311 = load i32, i32* %24
br label %322
312: ; preds = %306, %284
%313 = load i32, i32* %29
%314 = load i32, i32* %30
%315 = icmp sle i32 %313, %314
br i1 %315, label %316, label %318
316: ; preds = %312
%317 = load i32, i32* %25
br label %320
318: ; preds = %312
%319 = load i32, i32* %26
br label %320
320: ; preds = %318, %316
%321 = phi i32 [ %317, %316 ], [ %319, %318 ]
br label %322
322: ; preds = %320, %310
%323 = phi i32 [ %311, %310 ], [ %321, %320 ]
store i32 %323, i32* %31
%324 = load i32*, i32** %8
%325 = load i32, i32* %16
%326 = add nsw i32 %325, 1
store i32 %326, i32* %16
%327 = sext i32 %325 to i64
%328 = getelementptr inbounds i32, i32* %324, i64 %327
%329 = load i32, i32* %328
%330 = load i32, i32* %31
%331 = sub nsw i32 %329, %330
%332 = load i32*, i32** %9
%333 = load i32, i32* %17
%334 = add nsw i32 %333, 1
store i32 %334, i32* %17
%335 = sext i32 %333 to i64
%336 = getelementptr inbounds i32, i32* %332, i64 %335
store i32 %331, i32* %336
br label %337
337: ; preds = %322
%338 = load i32, i32* %19
%339 = add nsw i32 %338, 1
store i32 %339, i32* %19
br label %235
340: ; preds = %235
br label %341
341: ; preds = %64, %340, %233, %180, %144, %92
br label %342
342: ; preds = %341
%343 = load i32, i32* %18
%344 = add nsw i32 %343, 1
store i32 %344, i32* %18
br label %60
345: ; preds = %55, %60
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_encode(i32* nocapture %0, i32* nocapture writeonly %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = mul nsw i32 %3, %2
%9 = mul nsw i32 %8, %4
%10 = add nsw i32 %9, 7
%11 = sdiv i32 %10, 8
%12 = icmp eq i32 %6, 15
%13 = add i32 %6, -10
%14 = icmp ult i32 %13, 5
%15 = select i1 %14, i32 %13, i32 %6
%16 = select i1 %12, i32 4, i32 %15
%17 = icmp sgt i32 %16, 5
br i1 %17, label %99, label %18
18: ; preds = %7
%19 = icmp sgt i32 %5, 0
br i1 %19, label %20, label %660
20: ; preds = %18
%21 = icmp sgt i32 %9, 0
%22 = add i32 %11, %2
%23 = icmp sgt i32 %2, 0
%24 = icmp sgt i32 %11, %2
%25 = sext i32 %2 to i64
%26 = sext i32 %11 to i64
%27 = call i32 @llvm.smax.i32(i32 %11, i32 1)
%28 = add nsw i32 %27, -1
%29 = zext i32 %28 to i64
%30 = add nuw nsw i64 %29, 1
%31 = getelementptr i32, i32* %1, i64 %30
%32 = getelementptr i32, i32* %0, i64 %30
%33 = add nsw i32 %27, -1
%34 = zext i32 %33 to i64
%35 = add nuw nsw i64 %34, 1
%36 = xor i32 %2, -1
%37 = add i32 %11, %36
%38 = zext i32 %37 to i64
%39 = add nuw nsw i64 %38, 1
%40 = getelementptr i32, i32* %1, i64 %39
%41 = getelementptr i32, i32* %0, i64 %39
%42 = sub nsw i64 0, %25
%43 = getelementptr i32, i32* %0, i64 %42
%44 = add nuw nsw i64 %38, 1
%45 = sub nsw i64 %44, %25
%46 = getelementptr i32, i32* %0, i64 %45
%47 = xor i32 %2, -1
%48 = add i32 %11, %47
%49 = zext i32 %48 to i64
%50 = add nuw nsw i64 %49, 1
%51 = add i32 %2, -1
%52 = zext i32 %51 to i64
%53 = add nuw nsw i64 %52, 1
%54 = getelementptr i32, i32* %1, i64 %53
%55 = getelementptr i32, i32* %0, i64 %53
%56 = zext i32 %51 to i64
%57 = add nuw nsw i64 %56, 1
%58 = and i64 %57, 8589934584
%59 = add nsw i64 %58, -8
%60 = lshr exact i64 %59, 3
%61 = add nuw nsw i64 %60, 1
%62 = and i64 %50, 8589934584
%63 = add nsw i64 %62, -8
%64 = lshr exact i64 %63, 3
%65 = add nuw nsw i64 %64, 1
%66 = and i64 %30, 8589934584
%67 = add nsw i64 %66, -8
%68 = lshr exact i64 %67, 3
%69 = add nuw nsw i64 %68, 1
%70 = and i32 %27, 1
%71 = icmp eq i32 %28, 0
%72 = and i32 %27, 2147483646
%73 = icmp eq i32 %70, 0
%74 = icmp ult i32 %51, 7
%75 = and i64 %57, 8589934584
%76 = trunc i64 %75 to i32
%77 = and i64 %61, 1
%78 = icmp eq i64 %59, 0
%79 = and i64 %61, 4611686018427387902
%80 = icmp eq i64 %77, 0
%81 = icmp eq i64 %57, %75
%82 = icmp ult i32 %48, 7
%83 = and i64 %50, 8589934584
%84 = trunc i64 %83 to i32
%85 = add i32 %84, %2
%86 = and i64 %65, 1
%87 = icmp eq i64 %63, 0
%88 = and i64 %65, 4611686018427387902
%89 = icmp eq i64 %86, 0
%90 = icmp eq i64 %50, %83
%91 = icmp ult i32 %33, 7
%92 = and i64 %35, 8589934584
%93 = trunc i64 %92 to i32
%94 = and i64 %69, 1
%95 = icmp eq i64 %67, 0
%96 = and i64 %69, 4611686018427387902
%97 = icmp eq i64 %94, 0
%98 = icmp eq i64 %35, %92
br label %102
99: ; preds = %7
%100 = load i32, i32* @stderr
%101 = tail call i32 @fprintf(i32 %100, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 %16)
br label %660
102: ; preds = %20, %655
%103 = phi i32 [ 0, %20 ], [ %657, %655 ]
%104 = phi i32 [ 0, %20 ], [ %656, %655 ]
%105 = phi i32 [ 0, %20 ], [ %658, %655 ]
%106 = add i32 %104, 1
%107 = sext i32 %104 to i64
%108 = getelementptr inbounds i32, i32* %1, i64 %107
store i32 %16, i32* %108
switch i32 %16, label %655 [
i32 0, label %215
i32 1, label %124
i32 2, label %119
i32 3, label %114
i32 4, label %109
]
109: ; preds = %102
br i1 %21, label %110, label %655
110: ; preds = %109
%111 = icmp eq i32 %105, 0
%112 = sext i32 %103 to i64
%113 = sext i32 %106 to i64
br label %567
114: ; preds = %102
br i1 %21, label %115, label %655
115: ; preds = %114
%116 = icmp eq i32 %105, 0
%117 = sext i32 %103 to i64
%118 = sext i32 %106 to i64
br label %540
119: ; preds = %102
br i1 %21, label %120, label %655
120: ; preds = %119
%121 = icmp eq i32 %105, 0
%122 = sext i32 %103 to i64
%123 = sext i32 %106 to i64
br i1 %71, label %626, label %510
124: ; preds = %102
br i1 %23, label %125, label %337
125: ; preds = %124
%126 = sext i32 %103 to i64
%127 = sext i32 %106 to i64
br i1 %74, label %186, label %128
128: ; preds = %125
%129 = getelementptr i32, i32* %1, i64 %127
%130 = getelementptr i32, i32* %54, i64 %127
%131 = getelementptr i32, i32* %0, i64 %126
%132 = getelementptr i32, i32* %55, i64 %126
%133 = icmp ult i32* %129, %132
%134 = icmp ult i32* %131, %130
%135 = and i1 %133, %134
br i1 %135, label %186, label %136
136: ; preds = %128
%137 = add nsw i64 %75, %127
%138 = add nsw i64 %75, %126
br i1 %78, label %170, label %139
139: ; preds = %136, %139
%140 = phi i64 [ %167, %139 ], [ 0, %136 ]
%141 = phi i64 [ %168, %139 ], [ 0, %136 ]
%142 = add i64 %140, %127
%143 = add i64 %140, %126
%144 = getelementptr inbounds i32, i32* %0, i64 %143
%145 = bitcast i32* %144 to <4 x i32>*
%146 = load <4 x i32>, <4 x i32>* %145
%147 = getelementptr inbounds i32, i32* %144, i64 4
%148 = bitcast i32* %147 to <4 x i32>*
%149 = load <4 x i32>, <4 x i32>* %148
%150 = getelementptr inbounds i32, i32* %1, i64 %142
%151 = bitcast i32* %150 to <4 x i32>*
store <4 x i32> %146, <4 x i32>* %151
%152 = getelementptr inbounds i32, i32* %150, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> %149, <4 x i32>* %153
%154 = or i64 %140, 8
%155 = add i64 %154, %127
%156 = add i64 %154, %126
%157 = getelementptr inbounds i32, i32* %0, i64 %156
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = getelementptr inbounds i32, i32* %157, i64 4
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = getelementptr inbounds i32, i32* %1, i64 %155
%164 = bitcast i32* %163 to <4 x i32>*
store <4 x i32> %159, <4 x i32>* %164
%165 = getelementptr inbounds i32, i32* %163, i64 4
%166 = bitcast i32* %165 to <4 x i32>*
store <4 x i32> %162, <4 x i32>* %166
%167 = add nuw i64 %140, 16
%168 = add i64 %141, 2
%169 = icmp eq i64 %168, %79
br i1 %169, label %170, label %139
170: ; preds = %139, %136
%171 = phi i64 [ 0, %136 ], [ %167, %139 ]
br i1 %80, label %185, label %172
172: ; preds = %170
%173 = add i64 %171, %127
%174 = add i64 %171, %126
%175 = getelementptr inbounds i32, i32* %0, i64 %174
%176 = bitcast i32* %175 to <4 x i32>*
%177 = load <4 x i32>, <4 x i32>* %176
%178 = getelementptr inbounds i32, i32* %175, i64 4
%179 = bitcast i32* %178 to <4 x i32>*
%180 = load <4 x i32>, <4 x i32>* %179
%181 = getelementptr inbounds i32, i32* %1, i64 %173
%182 = bitcast i32* %181 to <4 x i32>*
store <4 x i32> %177, <4 x i32>* %182
%183 = getelementptr inbounds i32, i32* %181, i64 4
%184 = bitcast i32* %183 to <4 x i32>*
store <4 x i32> %180, <4 x i32>* %184
br label %185
185: ; preds = %170, %172
br i1 %81, label %332, label %186
186: ; preds = %128, %125, %185
%187 = phi i64 [ %127, %128 ], [ %127, %125 ], [ %137, %185 ]
%188 = phi i64 [ %126, %128 ], [ %126, %125 ], [ %138, %185 ]
%189 = phi i32 [ 0, %128 ], [ 0, %125 ], [ %76, %185 ]
%190 = sub i32 %2, %189
%191 = xor i32 %189, -1
%192 = add i32 %191, %2
%193 = and i32 %190, 3
%194 = icmp eq i32 %193, 0
br i1 %194, label %208, label %195
195: ; preds = %186, %195
%196 = phi i64 [ %203, %195 ], [ %187, %186 ]
%197 = phi i64 [ %200, %195 ], [ %188, %186 ]
%198 = phi i32 [ %205, %195 ], [ %189, %186 ]
%199 = phi i32 [ %206, %195 ], [ 0, %186 ]
%200 = add nsw i64 %197, 1
%201 = getelementptr inbounds i32, i32* %0, i64 %197
%202 = load i32, i32* %201
%203 = add nsw i64 %196, 1
%204 = getelementptr inbounds i32, i32* %1, i64 %196
store i32 %202, i32* %204
%205 = add nuw nsw i32 %198, 1
%206 = add i32 %199, 1
%207 = icmp eq i32 %206, %193
br i1 %207, label %208, label %195
208: ; preds = %195, %186
%209 = phi i64 [ undef, %186 ], [ %200, %195 ]
%210 = phi i64 [ undef, %186 ], [ %203, %195 ]
%211 = phi i64 [ %187, %186 ], [ %203, %195 ]
%212 = phi i64 [ %188, %186 ], [ %200, %195 ]
%213 = phi i32 [ %189, %186 ], [ %205, %195 ]
%214 = icmp ult i32 %192, 3
br i1 %214, label %332, label %460
215: ; preds = %102
br i1 %21, label %216, label %655
216: ; preds = %215
%217 = sext i32 %103 to i64
%218 = sext i32 %106 to i64
br i1 %91, label %277, label %219
219: ; preds = %216
%220 = getelementptr i32, i32* %1, i64 %218
%221 = getelementptr i32, i32* %31, i64 %218
%222 = getelementptr i32, i32* %0, i64 %217
%223 = getelementptr i32, i32* %32, i64 %217
%224 = icmp ult i32* %220, %223
%225 = icmp ult i32* %222, %221
%226 = and i1 %224, %225
br i1 %226, label %277, label %227
227: ; preds = %219
%228 = add nsw i64 %92, %218
%229 = add nsw i64 %92, %217
br i1 %95, label %261, label %230
230: ; preds = %227, %230
%231 = phi i64 [ %258, %230 ], [ 0, %227 ]
%232 = phi i64 [ %259, %230 ], [ 0, %227 ]
%233 = add i64 %231, %218
%234 = add i64 %231, %217
%235 = getelementptr inbounds i32, i32* %0, i64 %234
%236 = bitcast i32* %235 to <4 x i32>*
%237 = load <4 x i32>, <4 x i32>* %236
%238 = getelementptr inbounds i32, i32* %235, i64 4
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = getelementptr inbounds i32, i32* %1, i64 %233
%242 = bitcast i32* %241 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %242
%243 = getelementptr inbounds i32, i32* %241, i64 4
%244 = bitcast i32* %243 to <4 x i32>*
store <4 x i32> %240, <4 x i32>* %244
%245 = or i64 %231, 8
%246 = add i64 %245, %218
%247 = add i64 %245, %217
%248 = getelementptr inbounds i32, i32* %0, i64 %247
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = getelementptr inbounds i32, i32* %248, i64 4
%252 = bitcast i32* %251 to <4 x i32>*
%253 = load <4 x i32>, <4 x i32>* %252
%254 = getelementptr inbounds i32, i32* %1, i64 %246
%255 = bitcast i32* %254 to <4 x i32>*
store <4 x i32> %250, <4 x i32>* %255
%256 = getelementptr inbounds i32, i32* %254, i64 4
%257 = bitcast i32* %256 to <4 x i32>*
store <4 x i32> %253, <4 x i32>* %257
%258 = add nuw i64 %231, 16
%259 = add i64 %232, 2
%260 = icmp eq i64 %259, %96
br i1 %260, label %261, label %230
261: ; preds = %230, %227
%262 = phi i64 [ 0, %227 ], [ %258, %230 ]
br i1 %97, label %276, label %263
263: ; preds = %261
%264 = add i64 %262, %218
%265 = add i64 %262, %217
%266 = getelementptr inbounds i32, i32* %0, i64 %265
%267 = bitcast i32* %266 to <4 x i32>*
%268 = load <4 x i32>, <4 x i32>* %267
%269 = getelementptr inbounds i32, i32* %266, i64 4
%270 = bitcast i32* %269 to <4 x i32>*
%271 = load <4 x i32>, <4 x i32>* %270
%272 = getelementptr inbounds i32, i32* %1, i64 %264
%273 = bitcast i32* %272 to <4 x i32>*
store <4 x i32> %268, <4 x i32>* %273
%274 = getelementptr inbounds i32, i32* %272, i64 4
%275 = bitcast i32* %274 to <4 x i32>*
store <4 x i32> %271, <4 x i32>* %275
br label %276
276: ; preds = %261, %263
br i1 %98, label %616, label %277
277: ; preds = %219, %216, %276
%278 = phi i64 [ %218, %219 ], [ %218, %216 ], [ %228, %276 ]
%279 = phi i64 [ %217, %219 ], [ %217, %216 ], [ %229, %276 ]
%280 = phi i32 [ 0, %219 ], [ 0, %216 ], [ %93, %276 ]
%281 = sub i32 %27, %280
%282 = xor i32 %280, -1
%283 = add i32 %27, %282
%284 = and i32 %281, 3
%285 = icmp eq i32 %284, 0
br i1 %285, label %299, label %286
286: ; preds = %277, %286
%287 = phi i64 [ %294, %286 ], [ %278, %277 ]
%288 = phi i64 [ %291, %286 ], [ %279, %277 ]
%289 = phi i32 [ %296, %286 ], [ %280, %277 ]
%290 = phi i32 [ %297, %286 ], [ 0, %277 ]
%291 = add nsw i64 %288, 1
%292 = getelementptr inbounds i32, i32* %0, i64 %288
%293 = load i32, i32* %292
%294 = add nsw i64 %287, 1
%295 = getelementptr inbounds i32, i32* %1, i64 %287
store i32 %293, i32* %295
%296 = add nuw nsw i32 %289, 1
%297 = add i32 %290, 1
%298 = icmp eq i32 %297, %284
br i1 %298, label %299, label %286
299: ; preds = %286, %277
%300 = phi i64 [ undef, %277 ], [ %291, %286 ]
%301 = phi i64 [ undef, %277 ], [ %294, %286 ]
%302 = phi i64 [ %278, %277 ], [ %294, %286 ]
%303 = phi i64 [ %279, %277 ], [ %291, %286 ]
%304 = phi i32 [ %280, %277 ], [ %296, %286 ]
%305 = icmp ult i32 %283, 3
br i1 %305, label %616, label %306
306: ; preds = %299, %306
%307 = phi i64 [ %328, %306 ], [ %302, %299 ]
%308 = phi i64 [ %325, %306 ], [ %303, %299 ]
%309 = phi i32 [ %330, %306 ], [ %304, %299 ]
%310 = add nsw i64 %308, 1
%311 = getelementptr inbounds i32, i32* %0, i64 %308
%312 = load i32, i32* %311
%313 = add nsw i64 %307, 1
%314 = getelementptr inbounds i32, i32* %1, i64 %307
store i32 %312, i32* %314
%315 = add nsw i64 %308, 2
%316 = getelementptr inbounds i32, i32* %0, i64 %310
%317 = load i32, i32* %316
%318 = add nsw i64 %307, 2
%319 = getelementptr inbounds i32, i32* %1, i64 %313
store i32 %317, i32* %319
%320 = add nsw i64 %308, 3
%321 = getelementptr inbounds i32, i32* %0, i64 %315
%322 = load i32, i32* %321
%323 = add nsw i64 %307, 3
%324 = getelementptr inbounds i32, i32* %1, i64 %318
store i32 %322, i32* %324
%325 = add nsw i64 %308, 4
%326 = getelementptr inbounds i32, i32* %0, i64 %320
%327 = load i32, i32* %326
%328 = add nsw i64 %307, 4
%329 = getelementptr inbounds i32, i32* %1, i64 %323
store i32 %327, i32* %329
%330 = add nuw nsw i32 %309, 4
%331 = icmp eq i32 %330, %27
br i1 %331, label %616, label %306
332: ; preds = %208, %460, %185
%333 = phi i64 [ %138, %185 ], [ %209, %208 ], [ %479, %460 ]
%334 = phi i64 [ %137, %185 ], [ %210, %208 ], [ %482, %460 ]
%335 = trunc i64 %334 to i32
%336 = trunc i64 %333 to i32
br label %337
337: ; preds = %332, %124
%338 = phi i32 [ %106, %124 ], [ %335, %332 ]
%339 = phi i32 [ %103, %124 ], [ %336, %332 ]
br i1 %24, label %340, label %655
340: ; preds = %337
%341 = sext i32 %339 to i64
%342 = sext i32 %338 to i64
br i1 %82, label %434, label %343
343: ; preds = %340
%344 = getelementptr i32, i32* %1, i64 %342
%345 = getelementptr i32, i32* %40, i64 %342
%346 = getelementptr i32, i32* %0, i64 %341
%347 = getelementptr i32, i32* %41, i64 %341
%348 = getelementptr i32, i32* %43, i64 %341
%349 = getelementptr i32, i32* %46, i64 %341
%350 = icmp ult i32* %344, %347
%351 = icmp ult i32* %346, %345
%352 = and i1 %350, %351
%353 = icmp ult i32* %344, %349
%354 = icmp ult i32* %348, %345
%355 = and i1 %353, %354
%356 = or i1 %352, %355
br i1 %356, label %434, label %357
357: ; preds = %343
%358 = add nsw i64 %83, %342
%359 = add nsw i64 %83, %341
br i1 %87, label %409, label %360
360: ; preds = %357, %360
%361 = phi i64 [ %406, %360 ], [ 0, %357 ]
%362 = phi i64 [ %407, %360 ], [ 0, %357 ]
%363 = add i64 %361, %342
%364 = add i64 %361, %341
%365 = sub nsw i64 %364, %25
%366 = getelementptr inbounds i32, i32* %0, i64 %365
%367 = bitcast i32* %366 to <4 x i32>*
%368 = load <4 x i32>, <4 x i32>* %367
%369 = getelementptr inbounds i32, i32* %366, i64 4
%370 = bitcast i32* %369 to <4 x i32>*
%371 = load <4 x i32>, <4 x i32>* %370
%372 = getelementptr inbounds i32, i32* %0, i64 %364
%373 = bitcast i32* %372 to <4 x i32>*
%374 = load <4 x i32>, <4 x i32>* %373
%375 = getelementptr inbounds i32, i32* %372, i64 4
%376 = bitcast i32* %375 to <4 x i32>*
%377 = load <4 x i32>, <4 x i32>* %376
%378 = sub nsw <4 x i32> %374, %368
%379 = sub nsw <4 x i32> %377, %371
%380 = getelementptr inbounds i32, i32* %1, i64 %363
%381 = bitcast i32* %380 to <4 x i32>*
store <4 x i32> %378, <4 x i32>* %381
%382 = getelementptr inbounds i32, i32* %380, i64 4
%383 = bitcast i32* %382 to <4 x i32>*
store <4 x i32> %379, <4 x i32>* %383
%384 = or i64 %361, 8
%385 = add i64 %384, %342
%386 = add i64 %384, %341
%387 = sub nsw i64 %386, %25
%388 = getelementptr inbounds i32, i32* %0, i64 %387
%389 = bitcast i32* %388 to <4 x i32>*
%390 = load <4 x i32>, <4 x i32>* %389
%391 = getelementptr inbounds i32, i32* %388, i64 4
%392 = bitcast i32* %391 to <4 x i32>*
%393 = load <4 x i32>, <4 x i32>* %392
%394 = getelementptr inbounds i32, i32* %0, i64 %386
%395 = bitcast i32* %394 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = getelementptr inbounds i32, i32* %394, i64 4
%398 = bitcast i32* %397 to <4 x i32>*
%399 = load <4 x i32>, <4 x i32>* %398
%400 = sub nsw <4 x i32> %396, %390
%401 = sub nsw <4 x i32> %399, %393
%402 = getelementptr inbounds i32, i32* %1, i64 %385
%403 = bitcast i32* %402 to <4 x i32>*
store <4 x i32> %400, <4 x i32>* %403
%404 = getelementptr inbounds i32, i32* %402, i64 4
%405 = bitcast i32* %404 to <4 x i32>*
store <4 x i32> %401, <4 x i32>* %405
%406 = add nuw i64 %361, 16
%407 = add i64 %362, 2
%408 = icmp eq i64 %407, %88
br i1 %408, label %409, label %360
409: ; preds = %360, %357
%410 = phi i64 [ 0, %357 ], [ %406, %360 ]
br i1 %89, label %433, label %411
411: ; preds = %409
%412 = add i64 %410, %342
%413 = add i64 %410, %341
%414 = sub nsw i64 %413, %25
%415 = getelementptr inbounds i32, i32* %0, i64 %414
%416 = bitcast i32* %415 to <4 x i32>*
%417 = load <4 x i32>, <4 x i32>* %416
%418 = getelementptr inbounds i32, i32* %415, i64 4
%419 = bitcast i32* %418 to <4 x i32>*
%420 = load <4 x i32>, <4 x i32>* %419
%421 = getelementptr inbounds i32, i32* %0, i64 %413
%422 = bitcast i32* %421 to <4 x i32>*
%423 = load <4 x i32>, <4 x i32>* %422
%424 = getelementptr inbounds i32, i32* %421, i64 4
%425 = bitcast i32* %424 to <4 x i32>*
%426 = load <4 x i32>, <4 x i32>* %425
%427 = sub nsw <4 x i32> %423, %417
%428 = sub nsw <4 x i32> %426, %420
%429 = getelementptr inbounds i32, i32* %1, i64 %412
%430 = bitcast i32* %429 to <4 x i32>*
store <4 x i32> %427, <4 x i32>* %430
%431 = getelementptr inbounds i32, i32* %429, i64 4
%432 = bitcast i32* %431 to <4 x i32>*
store <4 x i32> %428, <4 x i32>* %432
br label %433
433: ; preds = %409, %411
br i1 %90, label %621, label %434
434: ; preds = %343, %340, %433
%435 = phi i64 [ %342, %343 ], [ %342, %340 ], [ %358, %433 ]
%436 = phi i64 [ %341, %343 ], [ %341, %340 ], [ %359, %433 ]
%437 = phi i32 [ %2, %343 ], [ %2, %340 ], [ %85, %433 ]
%438 = sub i32 %11, %437
%439 = add i32 %437, 1
%440 = and i32 %438, 1
%441 = icmp eq i32 %440, 0
br i1 %441, label %453, label %442
442: ; preds = %434
%443 = add nsw i32 %437, 1
%444 = sub nsw i64 %436, %25
%445 = getelementptr inbounds i32, i32* %0, i64 %444
%446 = load i32, i32* %445
%447 = add nsw i64 %436, 1
%448 = getelementptr inbounds i32, i32* %0, i64 %436
%449 = load i32, i32* %448
%450 = sub nsw i32 %449, %446
%451 = add nsw i64 %435, 1
%452 = getelementptr inbounds i32, i32* %1, i64 %435
store i32 %450, i32* %452
br label %453
453: ; preds = %442, %434
%454 = phi i64 [ undef, %434 ], [ %447, %442 ]
%455 = phi i64 [ undef, %434 ], [ %451, %442 ]
%456 = phi i64 [ %435, %434 ], [ %451, %442 ]
%457 = phi i64 [ %436, %434 ], [ %447, %442 ]
%458 = phi i32 [ %437, %434 ], [ %443, %442 ]
%459 = icmp eq i32 %11, %439
br i1 %459, label %621, label %486
460: ; preds = %208, %460
%461 = phi i64 [ %482, %460 ], [ %211, %208 ]
%462 = phi i64 [ %479, %460 ], [ %212, %208 ]
%463 = phi i32 [ %484, %460 ], [ %213, %208 ]
%464 = add nsw i64 %462, 1
%465 = getelementptr inbounds i32, i32* %0, i64 %462
%466 = load i32, i32* %465
%467 = add nsw i64 %461, 1
%468 = getelementptr inbounds i32, i32* %1, i64 %461
store i32 %466, i32* %468
%469 = add nsw i64 %462, 2
%470 = getelementptr inbounds i32, i32* %0, i64 %464
%471 = load i32, i32* %470
%472 = add nsw i64 %461, 2
%473 = getelementptr inbounds i32, i32* %1, i64 %467
store i32 %471, i32* %473
%474 = add nsw i64 %462, 3
%475 = getelementptr inbounds i32, i32* %0, i64 %469
%476 = load i32, i32* %475
%477 = add nsw i64 %461, 3
%478 = getelementptr inbounds i32, i32* %1, i64 %472
store i32 %476, i32* %478
%479 = add nsw i64 %462, 4
%480 = getelementptr inbounds i32, i32* %0, i64 %474
%481 = load i32, i32* %480
%482 = add nsw i64 %461, 4
%483 = getelementptr inbounds i32, i32* %1, i64 %477
store i32 %481, i32* %483
%484 = add nuw nsw i32 %463, 4
%485 = icmp eq i32 %484, %2
br i1 %485, label %332, label %460
486: ; preds = %453, %486
%487 = phi i64 [ %507, %486 ], [ %456, %453 ]
%488 = phi i64 [ %503, %486 ], [ %457, %453 ]
%489 = phi i32 [ %499, %486 ], [ %458, %453 ]
%490 = sub nsw i64 %488, %25
%491 = getelementptr inbounds i32, i32* %0, i64 %490
%492 = load i32, i32* %491
%493 = add nsw i64 %488, 1
%494 = getelementptr inbounds i32, i32* %0, i64 %488
%495 = load i32, i32* %494
%496 = sub nsw i32 %495, %492
%497 = add nsw i64 %487, 1
%498 = getelementptr inbounds i32, i32* %1, i64 %487
store i32 %496, i32* %498
%499 = add nsw i32 %489, 2
%500 = sub nsw i64 %493, %25
%501 = getelementptr inbounds i32, i32* %0, i64 %500
%502 = load i32, i32* %501
%503 = add nsw i64 %488, 2
%504 = getelementptr inbounds i32, i32* %0, i64 %493
%505 = load i32, i32* %504
%506 = sub nsw i32 %505, %502
%507 = add nsw i64 %487, 2
%508 = getelementptr inbounds i32, i32* %1, i64 %497
store i32 %506, i32* %508
%509 = icmp eq i32 %499, %11
br i1 %509, label %621, label %486
510: ; preds = %120, %530
%511 = phi i64 [ %536, %530 ], [ %123, %120 ]
%512 = phi i64 [ %532, %530 ], [ %122, %120 ]
%513 = phi i32 [ %538, %530 ], [ 0, %120 ]
br i1 %121, label %518, label %514
514: ; preds = %510
%515 = sub nsw i64 %512, %26
%516 = getelementptr inbounds i32, i32* %0, i64 %515
%517 = load i32, i32* %516
br label %518
518: ; preds = %510, %514
%519 = phi i32 [ %517, %514 ], [ 0, %510 ]
%520 = add nsw i64 %512, 1
%521 = getelementptr inbounds i32, i32* %0, i64 %512
%522 = load i32, i32* %521
%523 = sub nsw i32 %522, %519
%524 = add nsw i64 %511, 1
%525 = getelementptr inbounds i32, i32* %1, i64 %511
store i32 %523, i32* %525
br i1 %121, label %530, label %526
526: ; preds = %518
%527 = sub nsw i64 %520, %26
%528 = getelementptr inbounds i32, i32* %0, i64 %527
%529 = load i32, i32* %528
br label %530
530: ; preds = %526, %518
%531 = phi i32 [ %529, %526 ], [ 0, %518 ]
%532 = add nsw i64 %512, 2
%533 = getelementptr inbounds i32, i32* %0, i64 %520
%534 = load i32, i32* %533
%535 = sub nsw i32 %534, %531
%536 = add nsw i64 %511, 2
%537 = getelementptr inbounds i32, i32* %1, i64 %524
store i32 %535, i32* %537
%538 = add i32 %513, 2
%539 = icmp eq i32 %538, %72
br i1 %539, label %626, label %510
540: ; preds = %115, %555
%541 = phi i64 [ %118, %115 ], [ %563, %555 ]
%542 = phi i64 [ %117, %115 ], [ %557, %555 ]
%543 = phi i32 [ 0, %115 ], [ %565, %555 ]
%544 = icmp slt i32 %543, %2
br i1 %544, label %549, label %545
545: ; preds = %540
%546 = sub nsw i64 %542, %25
%547 = getelementptr inbounds i32, i32* %0, i64 %546
%548 = load i32, i32* %547
br label %549
549: ; preds = %540, %545
%550 = phi i32 [ %548, %545 ], [ 0, %540 ]
br i1 %116, label %555, label %551
551: ; preds = %549
%552 = sub nsw i64 %542, %26
%553 = getelementptr inbounds i32, i32* %0, i64 %552
%554 = load i32, i32* %553
br label %555
555: ; preds = %549, %551
%556 = phi i32 [ %554, %551 ], [ 0, %549 ]
%557 = add nsw i64 %542, 1
%558 = getelementptr inbounds i32, i32* %0, i64 %542
%559 = load i32, i32* %558
%560 = add nsw i32 %556, %550
%561 = sdiv i32 %560, -2
%562 = add i32 %561, %559
%563 = add nsw i64 %541, 1
%564 = getelementptr inbounds i32, i32* %1, i64 %541
store i32 %562, i32* %564
%565 = add nuw nsw i32 %543, 1
%566 = icmp eq i32 %565, %27
br i1 %566, label %649, label %540
567: ; preds = %110, %590
%568 = phi i64 [ %113, %110 ], [ %612, %590 ]
%569 = phi i64 [ %112, %110 ], [ %608, %590 ]
%570 = phi i32 [ 0, %110 ], [ %614, %590 ]
%571 = icmp slt i32 %570, %2
br i1 %571, label %572, label %573
572: ; preds = %567
br i1 %111, label %590, label %577
573: ; preds = %567
%574 = sub nsw i64 %569, %25
%575 = getelementptr inbounds i32, i32* %0, i64 %574
%576 = load i32, i32* %575
br i1 %111, label %590, label %581
577: ; preds = %572
%578 = sub nsw i64 %569, %26
%579 = getelementptr inbounds i32, i32* %0, i64 %578
%580 = load i32, i32* %579
br label %590
581: ; preds = %573
%582 = sub nsw i64 %569, %26
%583 = getelementptr inbounds i32, i32* %0, i64 %582
%584 = load i32, i32* %583
%585 = trunc i64 %569 to i32
%586 = sub i32 %585, %22
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i32, i32* %0, i64 %587
%589 = load i32, i32* %588
br label %590
590: ; preds = %577, %573, %572, %581
%591 = phi i32 [ %576, %581 ], [ 0, %577 ], [ 0, %572 ], [ %576, %573 ]
%592 = phi i32 [ %584, %581 ], [ %580, %577 ], [ 0, %572 ], [ 0, %573 ]
%593 = phi i32 [ %589, %581 ], [ 0, %577 ], [ 0, %572 ], [ 0, %573 ]
%594 = add nsw i32 %592, %591
%595 = sub i32 %594, %593
%596 = sub nsw i32 %595, %591
%597 = tail call i32 @llvm.abs.i32(i32 %596, i1 true)
%598 = sub nsw i32 %595, %592
%599 = tail call i32 @llvm.abs.i32(i32 %598, i1 true)
%600 = sub nsw i32 %595, %593
%601 = tail call i32 @llvm.abs.i32(i32 %600, i1 true)
%602 = icmp ugt i32 %597, %599
%603 = icmp ugt i32 %597, %601
%604 = select i1 %602, i1 true, i1 %603
%605 = icmp ugt i32 %599, %601
%606 = select i1 %605, i32 %593, i32 %592
%607 = select i1 %604, i32 %606, i32 %591
%608 = add nsw i64 %569, 1
%609 = getelementptr inbounds i32, i32* %0, i64 %569
%610 = load i32, i32* %609
%611 = sub nsw i32 %610, %607
%612 = add nsw i64 %568, 1
%613 = getelementptr inbounds i32, i32* %1, i64 %568
store i32 %611, i32* %613
%614 = add nuw nsw i32 %570, 1
%615 = icmp eq i32 %614, %27
br i1 %615, label %652, label %567
616: ; preds = %299, %306, %276
%617 = phi i64 [ %229, %276 ], [ %300, %299 ], [ %325, %306 ]
%618 = phi i64 [ %228, %276 ], [ %301, %299 ], [ %328, %306 ]
%619 = trunc i64 %618 to i32
%620 = trunc i64 %617 to i32
br label %655
621: ; preds = %453, %486, %433
%622 = phi i64 [ %359, %433 ], [ %454, %453 ], [ %503, %486 ]
%623 = phi i64 [ %358, %433 ], [ %455, %453 ], [ %507, %486 ]
%624 = trunc i64 %623 to i32
%625 = trunc i64 %622 to i32
br label %655
626: ; preds = %530, %120
%627 = phi i64 [ undef, %120 ], [ %532, %530 ]
%628 = phi i64 [ undef, %120 ], [ %536, %530 ]
%629 = phi i64 [ %123, %120 ], [ %536, %530 ]
%630 = phi i64 [ %122, %120 ], [ %532, %530 ]
br i1 %73, label %644, label %631
631: ; preds = %626
br i1 %121, label %636, label %632
632: ; preds = %631
%633 = sub nsw i64 %630, %26
%634 = getelementptr inbounds i32, i32* %0, i64 %633
%635 = load i32, i32* %634
br label %636
636: ; preds = %632, %631
%637 = phi i32 [ %635, %632 ], [ 0, %631 ]
%638 = add nsw i64 %630, 1
%639 = getelementptr inbounds i32, i32* %0, i64 %630
%640 = load i32, i32* %639
%641 = sub nsw i32 %640, %637
%642 = add nsw i64 %629, 1
%643 = getelementptr inbounds i32, i32* %1, i64 %629
store i32 %641, i32* %643
br label %644
644: ; preds = %626, %636
%645 = phi i64 [ %627, %626 ], [ %638, %636 ]
%646 = phi i64 [ %628, %626 ], [ %642, %636 ]
%647 = trunc i64 %646 to i32
%648 = trunc i64 %645 to i32
br label %655
649: ; preds = %555
%650 = trunc i64 %563 to i32
%651 = trunc i64 %557 to i32
br label %655
652: ; preds = %590
%653 = trunc i64 %612 to i32
%654 = trunc i64 %608 to i32
br label %655
655: ; preds = %652, %649, %644, %621, %616, %109, %114, %119, %337, %215, %102
%656 = phi i32 [ %106, %102 ], [ %106, %215 ], [ %338, %337 ], [ %106, %119 ], [ %106, %114 ], [ %106, %109 ], [ %619, %616 ], [ %624, %621 ], [ %647, %644 ], [ %650, %649 ], [ %653, %652 ]
%657 = phi i32 [ %103, %102 ], [ %103, %215 ], [ %339, %337 ], [ %103, %119 ], [ %103, %114 ], [ %103, %109 ], [ %620, %616 ], [ %625, %621 ], [ %648, %644 ], [ %651, %649 ], [ %654, %652 ]
%658 = add nuw nsw i32 %105, 1
%659 = icmp eq i32 %658, %5
br i1 %659, label %660, label %102
660: ; preds = %655, %18, %99
ret void
}