#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned char PaethPredictor(unsigned char, unsigned char, unsigned char);
int png_apply_specific_filter_32(int filtermode, unsigned char *dest,
                                 unsigned char *src, unsigned width) {
  int pos2 = 0;
  int pos = 0;
  int srcwidth = width * 4;
  int x;
  if (filtermode == 0) {
    for (x = 0; x < width; x++) {
      dest[pos2++] = src[pos + 1];
      dest[pos2++] = src[pos + 2];
      dest[pos2++] = src[pos + 3];
      dest[pos2++] = src[pos + 0];
      pos += 4;
    }
  } else if (filtermode == 1) {
    dest[pos2++] = src[pos + 1];
    dest[pos2++] = src[pos + 2];
    dest[pos2++] = src[pos + 3];
    dest[pos2++] = src[pos + 0];
    pos += 4;
    for (x = 1; x < width; x++) {
      dest[pos2++] = src[pos + 1] - src[pos - 4 + 1];
      dest[pos2++] = src[pos + 2] - src[pos - 4 + 2];
      dest[pos2++] = src[pos + 3] - src[pos - 4 + 3];
      dest[pos2++] = src[pos + 0] - src[pos - 4 + 0];
      pos += 4;
    }
  } else if (filtermode == 2) {
    for (x = 0; x < width; x++) {
      dest[pos2++] = src[pos + 1] - src[pos - srcwidth + 1];
      dest[pos2++] = src[pos + 2] - src[pos - srcwidth + 2];
      dest[pos2++] = src[pos + 3] - src[pos - srcwidth + 3];
      dest[pos2++] = src[pos + 0] - src[pos - srcwidth + 0];
      pos += 4;
    }
  } else if (filtermode == 3) {
    dest[pos2++] = src[pos + 1] - src[pos - srcwidth + 1] / 2;
    dest[pos2++] = src[pos + 2] - src[pos - srcwidth + 2] / 2;
    dest[pos2++] = src[pos + 3] - src[pos - srcwidth + 3] / 2;
    dest[pos2++] = src[pos + 0] - src[pos - srcwidth + 0] / 2;
    pos += 4;
    for (x = 1; x < width; x++) {
      dest[pos2++] =
          src[pos + 1] - (src[pos - 4 + 1] + src[pos - srcwidth + 1]) / 2;
      dest[pos2++] =
          src[pos + 2] - (src[pos - 4 + 2] + src[pos - srcwidth + 2]) / 2;
      dest[pos2++] =
          src[pos + 3] - (src[pos - 4 + 3] + src[pos - srcwidth + 3]) / 2;
      dest[pos2++] =
          src[pos + 0] - (src[pos - 4 + 0] + src[pos - srcwidth + 0]) / 2;
      pos += 4;
    }
  } else if (filtermode == 4) {
    dest[pos2++] = src[pos + 1] - PaethPredictor(0, src[pos - srcwidth + 1], 0);
    dest[pos2++] = src[pos + 2] - PaethPredictor(0, src[pos - srcwidth + 2], 0);
    dest[pos2++] = src[pos + 3] - PaethPredictor(0, src[pos - srcwidth + 3], 0);
    dest[pos2++] = src[pos + 0] - PaethPredictor(0, src[pos - srcwidth + 0], 0);
    pos += 4;
    for (x = 1; x < width; x++) {
      dest[pos2++] = src[pos + 1] - PaethPredictor(src[pos - 4 + 1],
                                                   src[pos - srcwidth + 1],
                                                   src[pos - 4 - srcwidth + 1]);
      dest[pos2++] = src[pos + 2] - PaethPredictor(src[pos - 4 + 2],
                                                   src[pos - srcwidth + 2],
                                                   src[pos - 4 - srcwidth + 2]);
      dest[pos2++] = src[pos + 3] - PaethPredictor(src[pos - 4 + 3],
                                                   src[pos - srcwidth + 3],
                                                   src[pos - 4 - srcwidth + 3]);
      dest[pos2++] = src[pos + 0] - PaethPredictor(src[pos - 4 + 0],
                                                   src[pos - srcwidth + 0],
                                                   src[pos - 4 - srcwidth + 0]);
      pos += 4;
    }
  }
  return filtermode;
}


x86 assembly (clang, -O0):
<png_apply_specific_filter_32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    120a <png_apply_specific_filter_32+0xfa>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1205 <png_apply_specific_filter_32+0xf5>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114e <png_apply_specific_filter_32+0x3e>
jmp    1bad <png_apply_specific_filter_32+0xa9d>
cmpl   $0x1,-0x4(%rbp)
jne    13d8 <png_apply_specific_filter_32+0x2c8>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    13d3 <png_apply_specific_filter_32+0x2c3>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x4,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x4,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x4,%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x4,%edx
add    $0x0,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b8 <png_apply_specific_filter_32+0x1a8>
jmp    1ba8 <png_apply_specific_filter_32+0xa98>
cmpl   $0x2,-0x4(%rbp)
jne    1509 <png_apply_specific_filter_32+0x3f9>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1504 <png_apply_specific_filter_32+0x3f4>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13e9 <png_apply_specific_filter_32+0x2d9>
jmp    1ba3 <png_apply_specific_filter_32+0xa93>
cmpl   $0x3,-0x4(%rbp)
jne    1813 <png_apply_specific_filter_32+0x703>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    180e <png_apply_specific_filter_32+0x6fe>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x48(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    165b <png_apply_specific_filter_32+0x54b>
jmp    1b9e <png_apply_specific_filter_32+0xa8e>
cmpl   $0x4,-0x4(%rbp)
jne    1b99 <png_apply_specific_filter_32+0xa89>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
mov    %edx,%edi
movzbl (%rax,%rcx,1),%esi
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x5c(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
mov    %edx,%edi
movzbl (%rax,%rcx,1),%esi
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x58(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
mov    %edx,%edi
movzbl (%rax,%rcx,1),%esi
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x54(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
mov    %edx,%edi
movzbl (%rax,%rcx,1),%esi
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x50(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1b94 <png_apply_specific_filter_32+0xa84>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
sub    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl (%rax,%rcx,1),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x6c(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
sub    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl (%rax,%rcx,1),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x68(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
sub    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl (%rax,%rcx,1),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x64(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%sil
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x4,%ecx
sub    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl %sil,%edi
movzbl %dl,%esi
movzbl (%rax,%rcx,1),%edx
call   1030 <PaethPredictor@plt>
mov    %al,%cl
mov    -0x60(%rbp),%eax
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1975 <png_apply_specific_filter_32+0x865>
jmp    1b99 <png_apply_specific_filter_32+0xa89>
jmp    1b9e <png_apply_specific_filter_32+0xa8e>
jmp    1ba3 <png_apply_specific_filter_32+0xa93>
jmp    1ba8 <png_apply_specific_filter_32+0xa98>
jmp    1bad <png_apply_specific_filter_32+0xa9d>
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<png_apply_specific_filter_32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edi,0xc(%rsp)
cmp    $0x4,%edi
ja     150e <png_apply_specific_filter_32+0x3fe>
mov    %ecx,%ebp
mov    %rdx,%rbx
mov    %rsi,%r15
lea    0x0(,%rbp,4),%r12d
mov    0xc(%rsp),%eax
lea    0xeba(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %ebp,%ebp
je     150e <png_apply_specific_filter_32+0x3fe>
mov    %ebp,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rbx,%rcx,4),%edx
mov    %dl,(%r15,%rcx,4)
movzbl 0x2(%rbx,%rcx,4),%edx
mov    %dl,0x1(%r15,%rcx,4)
movzbl 0x3(%rbx,%rcx,4),%edx
mov    %dl,0x2(%r15,%rcx,4)
movzbl (%rbx,%rcx,4),%edx
mov    %dl,0x3(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1160 <png_apply_specific_filter_32+0x50>
jmp    150e <png_apply_specific_filter_32+0x3fe>
mov    0x1(%rbx),%al
mov    %al,(%r15)
mov    0x2(%rbx),%al
mov    %al,0x1(%r15)
mov    0x3(%rbx),%al
mov    %al,0x2(%r15)
mov    (%rbx),%al
mov    %al,0x3(%r15)
cmp    $0x2,%ebp
jb     150e <png_apply_specific_filter_32+0x3fe>
mov    %ebp,%eax
mov    $0x1,%ecx
nopl   (%rax)
movzbl 0x1(%rbx,%rcx,4),%edx
sub    -0x3(%rbx,%rcx,4),%dl
mov    %dl,(%r15,%rcx,4)
movzbl 0x2(%rbx,%rcx,4),%edx
sub    -0x2(%rbx,%rcx,4),%dl
mov    %dl,0x1(%r15,%rcx,4)
movzbl 0x3(%rbx,%rcx,4),%edx
sub    -0x1(%rbx,%rcx,4),%dl
mov    %dl,0x2(%r15,%rcx,4)
movzbl (%rbx,%rcx,4),%edx
sub    -0x4(%rbx,%rcx,4),%dl
mov    %dl,0x3(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    11c0 <png_apply_specific_filter_32+0xb0>
jmp    150e <png_apply_specific_filter_32+0x3fe>
test   %ebp,%ebp
je     150e <png_apply_specific_filter_32+0x3fe>
movslq %r12d,%rcx
neg    %r12d
mov    %rbx,%rax
sub    %rcx,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl 0x1(%rbx,%rcx,1),%edx
lea    (%r12,%rcx,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
sub    (%rbx,%rsi,1),%dl
mov    %dl,(%r15,%rcx,1)
movzbl 0x2(%rbx,%rcx,1),%edx
lea    (%r12,%rcx,1),%esi
add    $0x2,%esi
movslq %esi,%rsi
sub    (%rbx,%rsi,1),%dl
mov    %dl,0x1(%r15,%rcx,1)
movzbl 0x3(%rbx,%rcx,1),%edx
lea    (%r12,%rcx,1),%esi
add    $0x3,%esi
movslq %esi,%rsi
sub    (%rbx,%rsi,1),%dl
mov    %dl,0x2(%r15,%rcx,1)
movzbl (%rbx,%rcx,1),%edx
sub    (%rax,%rcx,1),%dl
mov    %dl,0x3(%r15,%rcx,1)
add    $0x4,%rcx
add    $0xffffffff,%ebp
jne    1220 <png_apply_specific_filter_32+0x110>
jmp    150e <png_apply_specific_filter_32+0x3fe>
mov    0x1(%rbx),%al
movslq %r12d,%rcx
mov    $0x1,%edx
sub    %r12d,%edx
movslq %edx,%rdx
mov    (%rbx,%rdx,1),%dl
shr    %dl
sub    %dl,%al
mov    %al,(%r15)
mov    0x2(%rbx),%al
mov    $0x2,%edx
sub    %r12d,%edx
movslq %edx,%rdx
mov    (%rbx,%rdx,1),%dl
shr    %dl
sub    %dl,%al
mov    %al,0x1(%r15)
mov    0x3(%rbx),%al
mov    $0x3,%edx
sub    %r12d,%edx
movslq %edx,%rdx
mov    (%rbx,%rdx,1),%dl
shr    %dl
sub    %dl,%al
mov    %al,0x2(%r15)
mov    (%rbx),%al
mov    %rcx,%rdx
neg    %rdx
mov    (%rbx,%rdx,1),%dl
shr    %dl
sub    %dl,%al
mov    %al,0x3(%r15)
cmp    $0x2,%ebp
jb     150e <png_apply_specific_filter_32+0x3fe>
neg    %r12d
mov    %rbx,%rax
sub    %rcx,%rax
add    $0x4,%rax
add    $0xffffffff,%ebp
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl 0x5(%rbx,%rcx,1),%edx
movzbl 0x1(%rbx,%rcx,1),%esi
lea    (%r12,%rcx,1),%edi
add    $0x5,%edi
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%dl
mov    %dl,0x4(%r15,%rcx,1)
movzbl 0x6(%rbx,%rcx,1),%edx
movzbl 0x2(%rbx,%rcx,1),%esi
lea    (%r12,%rcx,1),%edi
add    $0x6,%edi
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%dl
mov    %dl,0x5(%r15,%rcx,1)
movzbl 0x7(%rbx,%rcx,1),%edx
movzbl 0x3(%rbx,%rcx,1),%esi
lea    (%r12,%rcx,1),%edi
add    $0x7,%edi
movslq %edi,%rdi
movzbl (%rbx,%rdi,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%dl
mov    %dl,0x6(%r15,%rcx,1)
movzbl 0x4(%rbx,%rcx,1),%edx
movzbl (%rbx,%rcx,1),%esi
movzbl (%rax,%rcx,1),%edi
add    %esi,%edi
shr    %edi
sub    %dil,%dl
mov    %dl,0x7(%r15,%rcx,1)
add    $0x4,%rcx
add    $0xffffffff,%ebp
jne    1300 <png_apply_specific_filter_32+0x1f0>
jmp    150e <png_apply_specific_filter_32+0x3fe>
mov    0x1(%rbx),%r13b
movslq %r12d,%r14
mov    $0x1,%eax
sub    %r14d,%eax
cltq
movzbl (%rbx,%rax,1),%esi
xor    %edi,%edi
xor    %edx,%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,(%r15)
mov    0x2(%rbx),%r13b
mov    $0x2,%eax
sub    %r14d,%eax
cltq
movzbl (%rbx,%rax,1),%esi
xor    %edi,%edi
xor    %edx,%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x1(%r15)
mov    0x3(%rbx),%r13b
mov    $0x3,%eax
sub    %r14d,%eax
cltq
movzbl (%rbx,%rax,1),%esi
xor    %edi,%edi
xor    %edx,%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x2(%r15)
mov    (%rbx),%r13b
mov    %r14,%rax
neg    %rax
movzbl (%rbx,%rax,1),%esi
xor    %edi,%edi
xor    %edx,%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x3(%r15)
cmp    $0x2,%ebp
jb     150e <png_apply_specific_filter_32+0x3fe>
neg    %r12d
mov    %rbx,%rax
sub    %r14,%rax
add    $0x4,%rax
mov    %rax,0x10(%rsp)
add    $0xffffffff,%ebp
xor    %r14d,%r14d
nopl   (%rax)
movzbl 0x5(%rbx,%r14,1),%r13d
movzbl 0x1(%rbx,%r14,1),%edi
lea    (%r12,%r14,1),%eax
add    $0x5,%eax
cltq
movzbl (%rbx,%rax,1),%esi
lea    (%r12,%r14,1),%eax
add    $0x1,%eax
cltq
movzbl (%rbx,%rax,1),%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x4(%r15,%r14,1)
movzbl 0x6(%rbx,%r14,1),%r13d
movzbl 0x2(%rbx,%r14,1),%edi
lea    (%r12,%r14,1),%eax
add    $0x6,%eax
cltq
movzbl (%rbx,%rax,1),%esi
lea    (%r12,%r14,1),%eax
add    $0x2,%eax
cltq
movzbl (%rbx,%rax,1),%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x5(%r15,%r14,1)
movzbl 0x7(%rbx,%r14,1),%r13d
movzbl 0x3(%rbx,%r14,1),%edi
lea    (%r12,%r14,1),%eax
add    $0x7,%eax
cltq
movzbl (%rbx,%rax,1),%esi
lea    (%r12,%r14,1),%eax
add    $0x3,%eax
cltq
movzbl (%rbx,%rax,1),%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x6(%r15,%r14,1)
movzbl 0x4(%rbx,%r14,1),%r13d
movzbl (%rbx,%r14,1),%edi
mov    0x10(%rsp),%rax
movzbl (%rax,%r14,1),%esi
movzbl -0x4(%rax,%r14,1),%edx
call   1030 <PaethPredictor@plt>
sub    %al,%r13b
mov    %r13b,0x7(%r15,%r14,1)
add    $0x4,%r14
add    $0xffffffff,%ebp
jne    1440 <png_apply_specific_filter_32+0x330>
mov    0xc(%rsp),%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @png_apply_specific_filter_32(i32 %0, i8* %1, i8* %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 %0, i32* %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i32 %3, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
%13 = load i32, i32* %8
%14 = mul i32 %13, 4
store i32 %14, i32* %11
%15 = load i32, i32* %5
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %73
17: ; preds = %4
store i32 0, i32* %12
br label %18
18: ; preds = %69, %17
%19 = load i32, i32* %12
%20 = load i32, i32* %8
%21 = icmp ult i32 %19, %20
br i1 %21, label %22, label %72
22: ; preds = %18
%23 = load i8*, i8** %7
%24 = load i32, i32* %10
%25 = add nsw i32 %24, 1
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %23, i64 %26
%28 = load i8, i8* %27
%29 = load i8*, i8** %6
%30 = load i32, i32* %9
%31 = add nsw i32 %30, 1
store i32 %31, i32* %9
%32 = sext i32 %30 to i64
%33 = getelementptr inbounds i8, i8* %29, i64 %32
store i8 %28, i8* %33
%34 = load i8*, i8** %7
%35 = load i32, i32* %10
%36 = add nsw i32 %35, 2
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %34, i64 %37
%39 = load i8, i8* %38
%40 = load i8*, i8** %6
%41 = load i32, i32* %9
%42 = add nsw i32 %41, 1
store i32 %42, i32* %9
%43 = sext i32 %41 to i64
%44 = getelementptr inbounds i8, i8* %40, i64 %43
store i8 %39, i8* %44
%45 = load i8*, i8** %7
%46 = load i32, i32* %10
%47 = add nsw i32 %46, 3
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %45, i64 %48
%50 = load i8, i8* %49
%51 = load i8*, i8** %6
%52 = load i32, i32* %9
%53 = add nsw i32 %52, 1
store i32 %53, i32* %9
%54 = sext i32 %52 to i64
%55 = getelementptr inbounds i8, i8* %51, i64 %54
store i8 %50, i8* %55
%56 = load i8*, i8** %7
%57 = load i32, i32* %10
%58 = add nsw i32 %57, 0
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %56, i64 %59
%61 = load i8, i8* %60
%62 = load i8*, i8** %6
%63 = load i32, i32* %9
%64 = add nsw i32 %63, 1
store i32 %64, i32* %9
%65 = sext i32 %63 to i64
%66 = getelementptr inbounds i8, i8* %62, i64 %65
store i8 %61, i8* %66
%67 = load i32, i32* %10
%68 = add nsw i32 %67, 4
store i32 %68, i32* %10
br label %69
69: ; preds = %22
%70 = load i32, i32* %12
%71 = add nsw i32 %70, 1
store i32 %71, i32* %12
br label %18
72: ; preds = %18
br label %851
73: ; preds = %4
%74 = load i32, i32* %5
%75 = icmp eq i32 %74, 1
br i1 %75, label %76, label %222
76: ; preds = %73
%77 = load i8*, i8** %7
%78 = load i32, i32* %10
%79 = add nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %77, i64 %80
%82 = load i8, i8* %81
%83 = load i8*, i8** %6
%84 = load i32, i32* %9
%85 = add nsw i32 %84, 1
store i32 %85, i32* %9
%86 = sext i32 %84 to i64
%87 = getelementptr inbounds i8, i8* %83, i64 %86
store i8 %82, i8* %87
%88 = load i8*, i8** %7
%89 = load i32, i32* %10
%90 = add nsw i32 %89, 2
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %88, i64 %91
%93 = load i8, i8* %92
%94 = load i8*, i8** %6
%95 = load i32, i32* %9
%96 = add nsw i32 %95, 1
store i32 %96, i32* %9
%97 = sext i32 %95 to i64
%98 = getelementptr inbounds i8, i8* %94, i64 %97
store i8 %93, i8* %98
%99 = load i8*, i8** %7
%100 = load i32, i32* %10
%101 = add nsw i32 %100, 3
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %99, i64 %102
%104 = load i8, i8* %103
%105 = load i8*, i8** %6
%106 = load i32, i32* %9
%107 = add nsw i32 %106, 1
store i32 %107, i32* %9
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds i8, i8* %105, i64 %108
store i8 %104, i8* %109
%110 = load i8*, i8** %7
%111 = load i32, i32* %10
%112 = add nsw i32 %111, 0
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %110, i64 %113
%115 = load i8, i8* %114
%116 = load i8*, i8** %6
%117 = load i32, i32* %9
%118 = add nsw i32 %117, 1
store i32 %118, i32* %9
%119 = sext i32 %117 to i64
%120 = getelementptr inbounds i8, i8* %116, i64 %119
store i8 %115, i8* %120
%121 = load i32, i32* %10
%122 = add nsw i32 %121, 4
store i32 %122, i32* %10
store i32 1, i32* %12
br label %123
123: ; preds = %218, %76
%124 = load i32, i32* %12
%125 = load i32, i32* %8
%126 = icmp ult i32 %124, %125
br i1 %126, label %127, label %221
127: ; preds = %123
%128 = load i8*, i8** %7
%129 = load i32, i32* %10
%130 = add nsw i32 %129, 1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %128, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = load i8*, i8** %7
%136 = load i32, i32* %10
%137 = sub nsw i32 %136, 4
%138 = add nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8, i8* %135, i64 %139
%141 = load i8, i8* %140
%142 = zext i8 %141 to i32
%143 = sub nsw i32 %134, %142
%144 = trunc i32 %143 to i8
%145 = load i8*, i8** %6
%146 = load i32, i32* %9
%147 = add nsw i32 %146, 1
store i32 %147, i32* %9
%148 = sext i32 %146 to i64
%149 = getelementptr inbounds i8, i8* %145, i64 %148
store i8 %144, i8* %149
%150 = load i8*, i8** %7
%151 = load i32, i32* %10
%152 = add nsw i32 %151, 2
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %150, i64 %153
%155 = load i8, i8* %154
%156 = zext i8 %155 to i32
%157 = load i8*, i8** %7
%158 = load i32, i32* %10
%159 = sub nsw i32 %158, 4
%160 = add nsw i32 %159, 2
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8, i8* %157, i64 %161
%163 = load i8, i8* %162
%164 = zext i8 %163 to i32
%165 = sub nsw i32 %156, %164
%166 = trunc i32 %165 to i8
%167 = load i8*, i8** %6
%168 = load i32, i32* %9
%169 = add nsw i32 %168, 1
store i32 %169, i32* %9
%170 = sext i32 %168 to i64
%171 = getelementptr inbounds i8, i8* %167, i64 %170
store i8 %166, i8* %171
%172 = load i8*, i8** %7
%173 = load i32, i32* %10
%174 = add nsw i32 %173, 3
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8, i8* %172, i64 %175
%177 = load i8, i8* %176
%178 = zext i8 %177 to i32
%179 = load i8*, i8** %7
%180 = load i32, i32* %10
%181 = sub nsw i32 %180, 4
%182 = add nsw i32 %181, 3
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i8, i8* %179, i64 %183
%185 = load i8, i8* %184
%186 = zext i8 %185 to i32
%187 = sub nsw i32 %178, %186
%188 = trunc i32 %187 to i8
%189 = load i8*, i8** %6
%190 = load i32, i32* %9
%191 = add nsw i32 %190, 1
store i32 %191, i32* %9
%192 = sext i32 %190 to i64
%193 = getelementptr inbounds i8, i8* %189, i64 %192
store i8 %188, i8* %193
%194 = load i8*, i8** %7
%195 = load i32, i32* %10
%196 = add nsw i32 %195, 0
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i8, i8* %194, i64 %197
%199 = load i8, i8* %198
%200 = zext i8 %199 to i32
%201 = load i8*, i8** %7
%202 = load i32, i32* %10
%203 = sub nsw i32 %202, 4
%204 = add nsw i32 %203, 0
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8, i8* %201, i64 %205
%207 = load i8, i8* %206
%208 = zext i8 %207 to i32
%209 = sub nsw i32 %200, %208
%210 = trunc i32 %209 to i8
%211 = load i8*, i8** %6
%212 = load i32, i32* %9
%213 = add nsw i32 %212, 1
store i32 %213, i32* %9
%214 = sext i32 %212 to i64
%215 = getelementptr inbounds i8, i8* %211, i64 %214
store i8 %210, i8* %215
%216 = load i32, i32* %10
%217 = add nsw i32 %216, 4
store i32 %217, i32* %10
br label %218
218: ; preds = %127
%219 = load i32, i32* %12
%220 = add nsw i32 %219, 1
store i32 %220, i32* %12
br label %123
221: ; preds = %123
br label %850
222: ; preds = %73
%223 = load i32, i32* %5
%224 = icmp eq i32 %223, 2
br i1 %224, label %225, label %329
225: ; preds = %222
store i32 0, i32* %12
br label %226
226: ; preds = %325, %225
%227 = load i32, i32* %12
%228 = load i32, i32* %8
%229 = icmp ult i32 %227, %228
br i1 %229, label %230, label %328
230: ; preds = %226
%231 = load i8*, i8** %7
%232 = load i32, i32* %10
%233 = add nsw i32 %232, 1
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i8, i8* %231, i64 %234
%236 = load i8, i8* %235
%237 = zext i8 %236 to i32
%238 = load i8*, i8** %7
%239 = load i32, i32* %10
%240 = load i32, i32* %11
%241 = sub nsw i32 %239, %240
%242 = add nsw i32 %241, 1
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i8, i8* %238, i64 %243
%245 = load i8, i8* %244
%246 = zext i8 %245 to i32
%247 = sub nsw i32 %237, %246
%248 = trunc i32 %247 to i8
%249 = load i8*, i8** %6
%250 = load i32, i32* %9
%251 = add nsw i32 %250, 1
store i32 %251, i32* %9
%252 = sext i32 %250 to i64
%253 = getelementptr inbounds i8, i8* %249, i64 %252
store i8 %248, i8* %253
%254 = load i8*, i8** %7
%255 = load i32, i32* %10
%256 = add nsw i32 %255, 2
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i8, i8* %254, i64 %257
%259 = load i8, i8* %258
%260 = zext i8 %259 to i32
%261 = load i8*, i8** %7
%262 = load i32, i32* %10
%263 = load i32, i32* %11
%264 = sub nsw i32 %262, %263
%265 = add nsw i32 %264, 2
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds i8, i8* %261, i64 %266
%268 = load i8, i8* %267
%269 = zext i8 %268 to i32
%270 = sub nsw i32 %260, %269
%271 = trunc i32 %270 to i8
%272 = load i8*, i8** %6
%273 = load i32, i32* %9
%274 = add nsw i32 %273, 1
store i32 %274, i32* %9
%275 = sext i32 %273 to i64
%276 = getelementptr inbounds i8, i8* %272, i64 %275
store i8 %271, i8* %276
%277 = load i8*, i8** %7
%278 = load i32, i32* %10
%279 = add nsw i32 %278, 3
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i8, i8* %277, i64 %280
%282 = load i8, i8* %281
%283 = zext i8 %282 to i32
%284 = load i8*, i8** %7
%285 = load i32, i32* %10
%286 = load i32, i32* %11
%287 = sub nsw i32 %285, %286
%288 = add nsw i32 %287, 3
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %284, i64 %289
%291 = load i8, i8* %290
%292 = zext i8 %291 to i32
%293 = sub nsw i32 %283, %292
%294 = trunc i32 %293 to i8
%295 = load i8*, i8** %6
%296 = load i32, i32* %9
%297 = add nsw i32 %296, 1
store i32 %297, i32* %9
%298 = sext i32 %296 to i64
%299 = getelementptr inbounds i8, i8* %295, i64 %298
store i8 %294, i8* %299
%300 = load i8*, i8** %7
%301 = load i32, i32* %10
%302 = add nsw i32 %301, 0
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i8, i8* %300, i64 %303
%305 = load i8, i8* %304
%306 = zext i8 %305 to i32
%307 = load i8*, i8** %7
%308 = load i32, i32* %10
%309 = load i32, i32* %11
%310 = sub nsw i32 %308, %309
%311 = add nsw i32 %310, 0
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds i8, i8* %307, i64 %312
%314 = load i8, i8* %313
%315 = zext i8 %314 to i32
%316 = sub nsw i32 %306, %315
%317 = trunc i32 %316 to i8
%318 = load i8*, i8** %6
%319 = load i32, i32* %9
%320 = add nsw i32 %319, 1
store i32 %320, i32* %9
%321 = sext i32 %319 to i64
%322 = getelementptr inbounds i8, i8* %318, i64 %321
store i8 %317, i8* %322
%323 = load i32, i32* %10
%324 = add nsw i32 %323, 4
store i32 %324, i32* %10
br label %325
325: ; preds = %230
%326 = load i32, i32* %12
%327 = add nsw i32 %326, 1
store i32 %327, i32* %12
br label %226
328: ; preds = %226
br label %849
329: ; preds = %222
%330 = load i32, i32* %5
%331 = icmp eq i32 %330, 3
br i1 %331, label %332, label %574
332: ; preds = %329
%333 = load i8*, i8** %7
%334 = load i32, i32* %10
%335 = add nsw i32 %334, 1
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds i8, i8* %333, i64 %336
%338 = load i8, i8* %337
%339 = zext i8 %338 to i32
%340 = load i8*, i8** %7
%341 = load i32, i32* %10
%342 = load i32, i32* %11
%343 = sub nsw i32 %341, %342
%344 = add nsw i32 %343, 1
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i8, i8* %340, i64 %345
%347 = load i8, i8* %346
%348 = zext i8 %347 to i32
%349 = sdiv i32 %348, 2
%350 = sub nsw i32 %339, %349
%351 = trunc i32 %350 to i8
%352 = load i8*, i8** %6
%353 = load i32, i32* %9
%354 = add nsw i32 %353, 1
store i32 %354, i32* %9
%355 = sext i32 %353 to i64
%356 = getelementptr inbounds i8, i8* %352, i64 %355
store i8 %351, i8* %356
%357 = load i8*, i8** %7
%358 = load i32, i32* %10
%359 = add nsw i32 %358, 2
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i8, i8* %357, i64 %360
%362 = load i8, i8* %361
%363 = zext i8 %362 to i32
%364 = load i8*, i8** %7
%365 = load i32, i32* %10
%366 = load i32, i32* %11
%367 = sub nsw i32 %365, %366
%368 = add nsw i32 %367, 2
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds i8, i8* %364, i64 %369
%371 = load i8, i8* %370
%372 = zext i8 %371 to i32
%373 = sdiv i32 %372, 2
%374 = sub nsw i32 %363, %373
%375 = trunc i32 %374 to i8
%376 = load i8*, i8** %6
%377 = load i32, i32* %9
%378 = add nsw i32 %377, 1
store i32 %378, i32* %9
%379 = sext i32 %377 to i64
%380 = getelementptr inbounds i8, i8* %376, i64 %379
store i8 %375, i8* %380
%381 = load i8*, i8** %7
%382 = load i32, i32* %10
%383 = add nsw i32 %382, 3
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i8, i8* %381, i64 %384
%386 = load i8, i8* %385
%387 = zext i8 %386 to i32
%388 = load i8*, i8** %7
%389 = load i32, i32* %10
%390 = load i32, i32* %11
%391 = sub nsw i32 %389, %390
%392 = add nsw i32 %391, 3
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds i8, i8* %388, i64 %393
%395 = load i8, i8* %394
%396 = zext i8 %395 to i32
%397 = sdiv i32 %396, 2
%398 = sub nsw i32 %387, %397
%399 = trunc i32 %398 to i8
%400 = load i8*, i8** %6
%401 = load i32, i32* %9
%402 = add nsw i32 %401, 1
store i32 %402, i32* %9
%403 = sext i32 %401 to i64
%404 = getelementptr inbounds i8, i8* %400, i64 %403
store i8 %399, i8* %404
%405 = load i8*, i8** %7
%406 = load i32, i32* %10
%407 = add nsw i32 %406, 0
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i8, i8* %405, i64 %408
%410 = load i8, i8* %409
%411 = zext i8 %410 to i32
%412 = load i8*, i8** %7
%413 = load i32, i32* %10
%414 = load i32, i32* %11
%415 = sub nsw i32 %413, %414
%416 = add nsw i32 %415, 0
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i8, i8* %412, i64 %417
%419 = load i8, i8* %418
%420 = zext i8 %419 to i32
%421 = sdiv i32 %420, 2
%422 = sub nsw i32 %411, %421
%423 = trunc i32 %422 to i8
%424 = load i8*, i8** %6
%425 = load i32, i32* %9
%426 = add nsw i32 %425, 1
store i32 %426, i32* %9
%427 = sext i32 %425 to i64
%428 = getelementptr inbounds i8, i8* %424, i64 %427
store i8 %423, i8* %428
%429 = load i32, i32* %10
%430 = add nsw i32 %429, 4
store i32 %430, i32* %10
store i32 1, i32* %12
br label %431
431: ; preds = %570, %332
%432 = load i32, i32* %12
%433 = load i32, i32* %8
%434 = icmp ult i32 %432, %433
br i1 %434, label %435, label %573
435: ; preds = %431
%436 = load i8*, i8** %7
%437 = load i32, i32* %10
%438 = add nsw i32 %437, 1
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i8, i8* %436, i64 %439
%441 = load i8, i8* %440
%442 = zext i8 %441 to i32
%443 = load i8*, i8** %7
%444 = load i32, i32* %10
%445 = sub nsw i32 %444, 4
%446 = add nsw i32 %445, 1
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i8, i8* %443, i64 %447
%449 = load i8, i8* %448
%450 = zext i8 %449 to i32
%451 = load i8*, i8** %7
%452 = load i32, i32* %10
%453 = load i32, i32* %11
%454 = sub nsw i32 %452, %453
%455 = add nsw i32 %454, 1
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i8, i8* %451, i64 %456
%458 = load i8, i8* %457
%459 = zext i8 %458 to i32
%460 = add nsw i32 %450, %459
%461 = sdiv i32 %460, 2
%462 = sub nsw i32 %442, %461
%463 = trunc i32 %462 to i8
%464 = load i8*, i8** %6
%465 = load i32, i32* %9
%466 = add nsw i32 %465, 1
store i32 %466, i32* %9
%467 = sext i32 %465 to i64
%468 = getelementptr inbounds i8, i8* %464, i64 %467
store i8 %463, i8* %468
%469 = load i8*, i8** %7
%470 = load i32, i32* %10
%471 = add nsw i32 %470, 2
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds i8, i8* %469, i64 %472
%474 = load i8, i8* %473
%475 = zext i8 %474 to i32
%476 = load i8*, i8** %7
%477 = load i32, i32* %10
%478 = sub nsw i32 %477, 4
%479 = add nsw i32 %478, 2
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i8, i8* %476, i64 %480
%482 = load i8, i8* %481
%483 = zext i8 %482 to i32
%484 = load i8*, i8** %7
%485 = load i32, i32* %10
%486 = load i32, i32* %11
%487 = sub nsw i32 %485, %486
%488 = add nsw i32 %487, 2
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i8, i8* %484, i64 %489
%491 = load i8, i8* %490
%492 = zext i8 %491 to i32
%493 = add nsw i32 %483, %492
%494 = sdiv i32 %493, 2
%495 = sub nsw i32 %475, %494
%496 = trunc i32 %495 to i8
%497 = load i8*, i8** %6
%498 = load i32, i32* %9
%499 = add nsw i32 %498, 1
store i32 %499, i32* %9
%500 = sext i32 %498 to i64
%501 = getelementptr inbounds i8, i8* %497, i64 %500
store i8 %496, i8* %501
%502 = load i8*, i8** %7
%503 = load i32, i32* %10
%504 = add nsw i32 %503, 3
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i8, i8* %502, i64 %505
%507 = load i8, i8* %506
%508 = zext i8 %507 to i32
%509 = load i8*, i8** %7
%510 = load i32, i32* %10
%511 = sub nsw i32 %510, 4
%512 = add nsw i32 %511, 3
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds i8, i8* %509, i64 %513
%515 = load i8, i8* %514
%516 = zext i8 %515 to i32
%517 = load i8*, i8** %7
%518 = load i32, i32* %10
%519 = load i32, i32* %11
%520 = sub nsw i32 %518, %519
%521 = add nsw i32 %520, 3
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i8, i8* %517, i64 %522
%524 = load i8, i8* %523
%525 = zext i8 %524 to i32
%526 = add nsw i32 %516, %525
%527 = sdiv i32 %526, 2
%528 = sub nsw i32 %508, %527
%529 = trunc i32 %528 to i8
%530 = load i8*, i8** %6
%531 = load i32, i32* %9
%532 = add nsw i32 %531, 1
store i32 %532, i32* %9
%533 = sext i32 %531 to i64
%534 = getelementptr inbounds i8, i8* %530, i64 %533
store i8 %529, i8* %534
%535 = load i8*, i8** %7
%536 = load i32, i32* %10
%537 = add nsw i32 %536, 0
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i8, i8* %535, i64 %538
%540 = load i8, i8* %539
%541 = zext i8 %540 to i32
%542 = load i8*, i8** %7
%543 = load i32, i32* %10
%544 = sub nsw i32 %543, 4
%545 = add nsw i32 %544, 0
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i8, i8* %542, i64 %546
%548 = load i8, i8* %547
%549 = zext i8 %548 to i32
%550 = load i8*, i8** %7
%551 = load i32, i32* %10
%552 = load i32, i32* %11
%553 = sub nsw i32 %551, %552
%554 = add nsw i32 %553, 0
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i8, i8* %550, i64 %555
%557 = load i8, i8* %556
%558 = zext i8 %557 to i32
%559 = add nsw i32 %549, %558
%560 = sdiv i32 %559, 2
%561 = sub nsw i32 %541, %560
%562 = trunc i32 %561 to i8
%563 = load i8*, i8** %6
%564 = load i32, i32* %9
%565 = add nsw i32 %564, 1
store i32 %565, i32* %9
%566 = sext i32 %564 to i64
%567 = getelementptr inbounds i8, i8* %563, i64 %566
store i8 %562, i8* %567
%568 = load i32, i32* %10
%569 = add nsw i32 %568, 4
store i32 %569, i32* %10
br label %570
570: ; preds = %435
%571 = load i32, i32* %12
%572 = add nsw i32 %571, 1
store i32 %572, i32* %12
br label %431
573: ; preds = %431
br label %848
574: ; preds = %329
%575 = load i32, i32* %5
%576 = icmp eq i32 %575, 4
br i1 %576, label %577, label %847
577: ; preds = %574
%578 = load i8*, i8** %7
%579 = load i32, i32* %10
%580 = add nsw i32 %579, 1
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds i8, i8* %578, i64 %581
%583 = load i8, i8* %582
%584 = zext i8 %583 to i32
%585 = load i8*, i8** %7
%586 = load i32, i32* %10
%587 = load i32, i32* %11
%588 = sub nsw i32 %586, %587
%589 = add nsw i32 %588, 1
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds i8, i8* %585, i64 %590
%592 = load i8, i8* %591
%593 = call zeroext i8 @PaethPredictor(i8 zeroext 0, i8 zeroext %592, i8 zeroext 0)
%594 = zext i8 %593 to i32
%595 = sub nsw i32 %584, %594
%596 = trunc i32 %595 to i8
%597 = load i8*, i8** %6
%598 = load i32, i32* %9
%599 = add nsw i32 %598, 1
store i32 %599, i32* %9
%600 = sext i32 %598 to i64
%601 = getelementptr inbounds i8, i8* %597, i64 %600
store i8 %596, i8* %601
%602 = load i8*, i8** %7
%603 = load i32, i32* %10
%604 = add nsw i32 %603, 2
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds i8, i8* %602, i64 %605
%607 = load i8, i8* %606
%608 = zext i8 %607 to i32
%609 = load i8*, i8** %7
%610 = load i32, i32* %10
%611 = load i32, i32* %11
%612 = sub nsw i32 %610, %611
%613 = add nsw i32 %612, 2
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds i8, i8* %609, i64 %614
%616 = load i8, i8* %615
%617 = call zeroext i8 @PaethPredictor(i8 zeroext 0, i8 zeroext %616, i8 zeroext 0)
%618 = zext i8 %617 to i32
%619 = sub nsw i32 %608, %618
%620 = trunc i32 %619 to i8
%621 = load i8*, i8** %6
%622 = load i32, i32* %9
%623 = add nsw i32 %622, 1
store i32 %623, i32* %9
%624 = sext i32 %622 to i64
%625 = getelementptr inbounds i8, i8* %621, i64 %624
store i8 %620, i8* %625
%626 = load i8*, i8** %7
%627 = load i32, i32* %10
%628 = add nsw i32 %627, 3
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i8, i8* %626, i64 %629
%631 = load i8, i8* %630
%632 = zext i8 %631 to i32
%633 = load i8*, i8** %7
%634 = load i32, i32* %10
%635 = load i32, i32* %11
%636 = sub nsw i32 %634, %635
%637 = add nsw i32 %636, 3
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds i8, i8* %633, i64 %638
%640 = load i8, i8* %639
%641 = call zeroext i8 @PaethPredictor(i8 zeroext 0, i8 zeroext %640, i8 zeroext 0)
%642 = zext i8 %641 to i32
%643 = sub nsw i32 %632, %642
%644 = trunc i32 %643 to i8
%645 = load i8*, i8** %6
%646 = load i32, i32* %9
%647 = add nsw i32 %646, 1
store i32 %647, i32* %9
%648 = sext i32 %646 to i64
%649 = getelementptr inbounds i8, i8* %645, i64 %648
store i8 %644, i8* %649
%650 = load i8*, i8** %7
%651 = load i32, i32* %10
%652 = add nsw i32 %651, 0
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds i8, i8* %650, i64 %653
%655 = load i8, i8* %654
%656 = zext i8 %655 to i32
%657 = load i8*, i8** %7
%658 = load i32, i32* %10
%659 = load i32, i32* %11
%660 = sub nsw i32 %658, %659
%661 = add nsw i32 %660, 0
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds i8, i8* %657, i64 %662
%664 = load i8, i8* %663
%665 = call zeroext i8 @PaethPredictor(i8 zeroext 0, i8 zeroext %664, i8 zeroext 0)
%666 = zext i8 %665 to i32
%667 = sub nsw i32 %656, %666
%668 = trunc i32 %667 to i8
%669 = load i8*, i8** %6
%670 = load i32, i32* %9
%671 = add nsw i32 %670, 1
store i32 %671, i32* %9
%672 = sext i32 %670 to i64
%673 = getelementptr inbounds i8, i8* %669, i64 %672
store i8 %668, i8* %673
%674 = load i32, i32* %10
%675 = add nsw i32 %674, 4
store i32 %675, i32* %10
store i32 1, i32* %12
br label %676
676: ; preds = %843, %577
%677 = load i32, i32* %12
%678 = load i32, i32* %8
%679 = icmp ult i32 %677, %678
br i1 %679, label %680, label %846
680: ; preds = %676
%681 = load i8*, i8** %7
%682 = load i32, i32* %10
%683 = add nsw i32 %682, 1
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds i8, i8* %681, i64 %684
%686 = load i8, i8* %685
%687 = zext i8 %686 to i32
%688 = load i8*, i8** %7
%689 = load i32, i32* %10
%690 = sub nsw i32 %689, 4
%691 = add nsw i32 %690, 1
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds i8, i8* %688, i64 %692
%694 = load i8, i8* %693
%695 = load i8*, i8** %7
%696 = load i32, i32* %10
%697 = load i32, i32* %11
%698 = sub nsw i32 %696, %697
%699 = add nsw i32 %698, 1
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i8, i8* %695, i64 %700
%702 = load i8, i8* %701
%703 = load i8*, i8** %7
%704 = load i32, i32* %10
%705 = sub nsw i32 %704, 4
%706 = load i32, i32* %11
%707 = sub nsw i32 %705, %706
%708 = add nsw i32 %707, 1
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds i8, i8* %703, i64 %709
%711 = load i8, i8* %710
%712 = call zeroext i8 @PaethPredictor(i8 zeroext %694, i8 zeroext %702, i8 zeroext %711)
%713 = zext i8 %712 to i32
%714 = sub nsw i32 %687, %713
%715 = trunc i32 %714 to i8
%716 = load i8*, i8** %6
%717 = load i32, i32* %9
%718 = add nsw i32 %717, 1
store i32 %718, i32* %9
%719 = sext i32 %717 to i64
%720 = getelementptr inbounds i8, i8* %716, i64 %719
store i8 %715, i8* %720
%721 = load i8*, i8** %7
%722 = load i32, i32* %10
%723 = add nsw i32 %722, 2
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds i8, i8* %721, i64 %724
%726 = load i8, i8* %725
%727 = zext i8 %726 to i32
%728 = load i8*, i8** %7
%729 = load i32, i32* %10
%730 = sub nsw i32 %729, 4
%731 = add nsw i32 %730, 2
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds i8, i8* %728, i64 %732
%734 = load i8, i8* %733
%735 = load i8*, i8** %7
%736 = load i32, i32* %10
%737 = load i32, i32* %11
%738 = sub nsw i32 %736, %737
%739 = add nsw i32 %738, 2
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds i8, i8* %735, i64 %740
%742 = load i8, i8* %741
%743 = load i8*, i8** %7
%744 = load i32, i32* %10
%745 = sub nsw i32 %744, 4
%746 = load i32, i32* %11
%747 = sub nsw i32 %745, %746
%748 = add nsw i32 %747, 2
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds i8, i8* %743, i64 %749
%751 = load i8, i8* %750
%752 = call zeroext i8 @PaethPredictor(i8 zeroext %734, i8 zeroext %742, i8 zeroext %751)
%753 = zext i8 %752 to i32
%754 = sub nsw i32 %727, %753
%755 = trunc i32 %754 to i8
%756 = load i8*, i8** %6
%757 = load i32, i32* %9
%758 = add nsw i32 %757, 1
store i32 %758, i32* %9
%759 = sext i32 %757 to i64
%760 = getelementptr inbounds i8, i8* %756, i64 %759
store i8 %755, i8* %760
%761 = load i8*, i8** %7
%762 = load i32, i32* %10
%763 = add nsw i32 %762, 3
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds i8, i8* %761, i64 %764
%766 = load i8, i8* %765
%767 = zext i8 %766 to i32
%768 = load i8*, i8** %7
%769 = load i32, i32* %10
%770 = sub nsw i32 %769, 4
%771 = add nsw i32 %770, 3
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds i8, i8* %768, i64 %772
%774 = load i8, i8* %773
%775 = load i8*, i8** %7
%776 = load i32, i32* %10
%777 = load i32, i32* %11
%778 = sub nsw i32 %776, %777
%779 = add nsw i32 %778, 3
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds i8, i8* %775, i64 %780
%782 = load i8, i8* %781
%783 = load i8*, i8** %7
%784 = load i32, i32* %10
%785 = sub nsw i32 %784, 4
%786 = load i32, i32* %11
%787 = sub nsw i32 %785, %786
%788 = add nsw i32 %787, 3
%789 = sext i32 %788 to i64
%790 = getelementptr inbounds i8, i8* %783, i64 %789
%791 = load i8, i8* %790
%792 = call zeroext i8 @PaethPredictor(i8 zeroext %774, i8 zeroext %782, i8 zeroext %791)
%793 = zext i8 %792 to i32
%794 = sub nsw i32 %767, %793
%795 = trunc i32 %794 to i8
%796 = load i8*, i8** %6
%797 = load i32, i32* %9
%798 = add nsw i32 %797, 1
store i32 %798, i32* %9
%799 = sext i32 %797 to i64
%800 = getelementptr inbounds i8, i8* %796, i64 %799
store i8 %795, i8* %800
%801 = load i8*, i8** %7
%802 = load i32, i32* %10
%803 = add nsw i32 %802, 0
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds i8, i8* %801, i64 %804
%806 = load i8, i8* %805
%807 = zext i8 %806 to i32
%808 = load i8*, i8** %7
%809 = load i32, i32* %10
%810 = sub nsw i32 %809, 4
%811 = add nsw i32 %810, 0
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds i8, i8* %808, i64 %812
%814 = load i8, i8* %813
%815 = load i8*, i8** %7
%816 = load i32, i32* %10
%817 = load i32, i32* %11
%818 = sub nsw i32 %816, %817
%819 = add nsw i32 %818, 0
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds i8, i8* %815, i64 %820
%822 = load i8, i8* %821
%823 = load i8*, i8** %7
%824 = load i32, i32* %10
%825 = sub nsw i32 %824, 4
%826 = load i32, i32* %11
%827 = sub nsw i32 %825, %826
%828 = add nsw i32 %827, 0
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds i8, i8* %823, i64 %829
%831 = load i8, i8* %830
%832 = call zeroext i8 @PaethPredictor(i8 zeroext %814, i8 zeroext %822, i8 zeroext %831)
%833 = zext i8 %832 to i32
%834 = sub nsw i32 %807, %833
%835 = trunc i32 %834 to i8
%836 = load i8*, i8** %6
%837 = load i32, i32* %9
%838 = add nsw i32 %837, 1
store i32 %838, i32* %9
%839 = sext i32 %837 to i64
%840 = getelementptr inbounds i8, i8* %836, i64 %839
store i8 %835, i8* %840
%841 = load i32, i32* %10
%842 = add nsw i32 %841, 4
store i32 %842, i32* %10
br label %843
843: ; preds = %680
%844 = load i32, i32* %12
%845 = add nsw i32 %844, 1
store i32 %845, i32* %12
br label %676
846: ; preds = %676
br label %847
847: ; preds = %846, %574
br label %848
848: ; preds = %847, %573
br label %849
849: ; preds = %848, %328
br label %850
850: ; preds = %849, %221
br label %851
851: ; preds = %850, %72
%852 = load i32, i32* %5
ret i32 %852
}

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