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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ i_errhdlr(char *, int, int);
int img_rle_compact(unsigned short *expbuf, int ibpp, unsigned short *rlebuf,
                    int obpp, int cnt) {
  if (ibpp == 1 && obpp == 1) {
    register unsigned char *iptr = (unsigned char *)expbuf;
    register unsigned char *ibufend = iptr + cnt;
    register unsigned char *sptr;
    register unsigned char *optr = (unsigned char *)rlebuf;
    register unsigned short todo, cc;
    register int count;
    while (iptr < ibufend) {
      sptr = iptr;
      iptr += 2;
      while ((iptr < ibufend) &&
             ((iptr[-2] != iptr[-1]) || (iptr[-1] != iptr[0])))
        iptr++;
      iptr -= 2;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = 0x80 | todo;
        while (todo--)
          *optr++ = *sptr++;
      }
      sptr = iptr;
      cc = *iptr++;
      while ((iptr < ibufend) && (*iptr == cc))
        iptr++;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = todo;
        *optr++ = cc;
      }
    }
    *optr++ = 0;
    ;
    return optr - (unsigned char *)rlebuf;
  } else if (ibpp == 1 && obpp == 2) {
    register unsigned char *iptr = (unsigned char *)expbuf;
    register unsigned char *ibufend = iptr + cnt;
    register unsigned char *sptr;
    register unsigned short *optr = rlebuf;
    register unsigned short todo, cc;
    register int count;
    while (iptr < ibufend) {
      sptr = iptr;
      iptr += 2;
      while ((iptr < ibufend) &&
             ((iptr[-2] != iptr[-1]) || (iptr[-1] != iptr[0])))
        iptr++;
      iptr -= 2;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = 0x80 | todo;
        while (todo--)
          *optr++ = *sptr++;
      }
      sptr = iptr;
      cc = *iptr++;
      while ((iptr < ibufend) && (*iptr == cc))
        iptr++;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = todo;
        *optr++ = cc;
      }
    }
    *optr++ = 0;
    ;
    return optr - rlebuf;
  } else if (ibpp == 2 && obpp == 1) {
    register unsigned short *iptr = expbuf;
    register unsigned short *ibufend = iptr + cnt;
    register unsigned short *sptr;
    register unsigned char *optr = (unsigned char *)rlebuf;
    register unsigned short todo, cc;
    register int count;
    while (iptr < ibufend) {
      sptr = iptr;
      iptr += 2;
      while ((iptr < ibufend) &&
             ((iptr[-2] != iptr[-1]) || (iptr[-1] != iptr[0])))
        iptr++;
      iptr -= 2;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = 0x80 | todo;
        while (todo--)
          *optr++ = *sptr++;
      }
      sptr = iptr;
      cc = *iptr++;
      while ((iptr < ibufend) && (*iptr == cc))
        iptr++;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = todo;
        *optr++ = cc;
      }
    }
    *optr++ = 0;
    ;
    return optr - (unsigned char *)rlebuf;
  } else if (ibpp == 2 && obpp == 2) {
    register unsigned short *iptr = expbuf;
    register unsigned short *ibufend = iptr + cnt;
    register unsigned short *sptr;
    register unsigned short *optr = rlebuf;
    register unsigned short todo, cc;
    register int count;
    while (iptr < ibufend) {
      sptr = iptr;
      iptr += 2;
      while ((iptr < ibufend) &&
             ((iptr[-2] != iptr[-1]) || (iptr[-1] != iptr[0])))
        iptr++;
      iptr -= 2;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = 0x80 | todo;
        while (todo--)
          *optr++ = *sptr++;
      }
      sptr = iptr;
      cc = *iptr++;
      while ((iptr < ibufend) && (*iptr == cc))
        iptr++;
      count = iptr - sptr;
      while (count) {
        todo = count > 126 ? 126 : count;
        count -= todo;
        *optr++ = todo;
        *optr++ = cc;
      }
    }
    *optr++ = 0;
    ;
    return optr - rlebuf;
  } else {
    i_errhdlr("rle_compact: bad bpp: %d %d\n", ibpp, obpp);
    return 0;
  }
}


x86 assembly (clang, -O0):
<img_rle_compact>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    13dc <img_rle_compact+0x2cc>
cmpl   $0x1,-0x24(%rbp)
jne    13dc <img_rle_compact+0x2cc>
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    13b7 <img_rle_compact+0x2a7>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0xc9(%rbp)
jae    11de <img_rle_compact+0xce>
mov    -0x30(%rbp),%rax
movzbl -0x2(%rax),%ecx
mov    -0x30(%rbp),%rax
movzbl -0x1(%rax),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xca(%rbp)
jne    11d2 <img_rle_compact+0xc2>
mov    -0x30(%rbp),%rax
movzbl -0x1(%rax),%eax
mov    -0x30(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xca(%rbp)
mov    -0xca(%rbp),%al
mov    %al,-0xc9(%rbp)
mov    -0xc9(%rbp),%al
test   $0x1,%al
jne    11f1 <img_rle_compact+0xe1>
jmp    1202 <img_rle_compact+0xf2>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1182 <img_rle_compact+0x72>
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     12c0 <img_rle_compact+0x1b0>
cmpl   $0x7e,-0x50(%rbp)
jle    1240 <img_rle_compact+0x130>
mov    $0x7e,%eax
mov    %eax,-0xd0(%rbp)
jmp    1249 <img_rle_compact+0x139>
mov    -0x50(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %ax,-0x4a(%rbp)
movzwl -0x4a(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
movzwl -0x4a(%rbp),%eax
or     $0x80,%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x4a(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x4a(%rbp)
cmp    $0x0,%ax
je     12bb <img_rle_compact+0x1ab>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    127b <img_rle_compact+0x16b>
jmp    121c <img_rle_compact+0x10c>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
mov    %ax,-0x4c(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0xd1(%rbp)
jae    130a <img_rle_compact+0x1fa>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
movzwl -0x4c(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xd1(%rbp)
mov    -0xd1(%rbp),%al
test   $0x1,%al
jne    131d <img_rle_compact+0x20d>
jmp    132e <img_rle_compact+0x21e>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12de <img_rle_compact+0x1ce>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     13b2 <img_rle_compact+0x2a2>
cmpl   $0x7e,-0x50(%rbp)
jle    1360 <img_rle_compact+0x250>
mov    $0x7e,%eax
mov    %eax,-0xd8(%rbp)
jmp    1369 <img_rle_compact+0x259>
mov    -0x50(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    %ax,-0x4a(%rbp)
movzwl -0x4a(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4a(%rbp),%ax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x4c(%rbp),%ax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    133c <img_rle_compact+0x22c>
jmp    1160 <img_rle_compact+0x50>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movb   $0x0,(%rax)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    1d86 <img_rle_compact+0xc76>
cmpl   $0x1,-0x14(%rbp)
jne    1696 <img_rle_compact+0x586>
cmpl   $0x2,-0x24(%rbp)
jne    1696 <img_rle_compact+0x586>
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    166b <img_rle_compact+0x55b>
mov    -0x58(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0xd9(%rbp)
jae    148d <img_rle_compact+0x37d>
mov    -0x58(%rbp),%rax
movzbl -0x2(%rax),%ecx
mov    -0x58(%rbp),%rax
movzbl -0x1(%rax),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xda(%rbp)
jne    1481 <img_rle_compact+0x371>
mov    -0x58(%rbp),%rax
movzbl -0x1(%rax),%eax
mov    -0x58(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xda(%rbp)
mov    -0xda(%rbp),%al
mov    %al,-0xd9(%rbp)
mov    -0xd9(%rbp),%al
test   $0x1,%al
jne    14a0 <img_rle_compact+0x390>
jmp    14b1 <img_rle_compact+0x3a1>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1431 <img_rle_compact+0x321>
mov    -0x58(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x78(%rbp)
cmpl   $0x0,-0x78(%rbp)
je     1576 <img_rle_compact+0x466>
cmpl   $0x7e,-0x78(%rbp)
jle    14ef <img_rle_compact+0x3df>
mov    $0x7e,%eax
mov    %eax,-0xe0(%rbp)
jmp    14f8 <img_rle_compact+0x3e8>
mov    -0x78(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    %ax,-0x72(%rbp)
movzwl -0x72(%rbp),%ecx
mov    -0x78(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x78(%rbp)
movzwl -0x72(%rbp),%eax
or     $0x80,%eax
mov    %ax,%cx
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cx,(%rax)
mov    -0x72(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x72(%rbp)
cmp    $0x0,%ax
je     1571 <img_rle_compact+0x461>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x68(%rbp)
movzbl (%rax),%eax
mov    %ax,%cx
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cx,(%rax)
jmp    152c <img_rle_compact+0x41c>
jmp    14cb <img_rle_compact+0x3bb>
mov    -0x58(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
movzbl (%rax),%eax
mov    %ax,-0x74(%rbp)
mov    -0x58(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0xe1(%rbp)
jae    15c0 <img_rle_compact+0x4b0>
mov    -0x58(%rbp),%rax
movzbl (%rax),%eax
movzwl -0x74(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xe1(%rbp)
mov    -0xe1(%rbp),%al
test   $0x1,%al
jne    15d3 <img_rle_compact+0x4c3>
jmp    15e4 <img_rle_compact+0x4d4>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1594 <img_rle_compact+0x484>
mov    -0x58(%rbp),%rax
mov    -0x68(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x78(%rbp)
cmpl   $0x0,-0x78(%rbp)
je     1666 <img_rle_compact+0x556>
cmpl   $0x7e,-0x78(%rbp)
jle    1616 <img_rle_compact+0x506>
mov    $0x7e,%eax
mov    %eax,-0xe8(%rbp)
jmp    161f <img_rle_compact+0x50f>
mov    -0x78(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
mov    %ax,-0x72(%rbp)
movzwl -0x72(%rbp),%ecx
mov    -0x78(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x72(%rbp),%cx
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cx,(%rax)
mov    -0x74(%rbp),%cx
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cx,(%rax)
jmp    15f2 <img_rle_compact+0x4e2>
jmp    140f <img_rle_compact+0x2ff>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x70(%rbp)
movw   $0x0,(%rax)
mov    -0x70(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x1,%rax
mov    %eax,-0x4(%rbp)
jmp    1d86 <img_rle_compact+0xc76>
cmpl   $0x2,-0x14(%rbp)
jne    19db <img_rle_compact+0x8cb>
cmpl   $0x1,-0x24(%rbp)
jne    19db <img_rle_compact+0x8cb>
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
cmp    -0x88(%rbp),%rax
jae    19ad <img_rle_compact+0x89d>
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rcx
xor    %eax,%eax
cmp    -0x88(%rbp),%rcx
mov    %al,-0xe9(%rbp)
jae    175a <img_rle_compact+0x64a>
mov    -0x80(%rbp),%rax
movzwl -0x4(%rax),%ecx
mov    -0x80(%rbp),%rax
movzwl -0x2(%rax),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xea(%rbp)
jne    174e <img_rle_compact+0x63e>
mov    -0x80(%rbp),%rax
movzwl -0x2(%rax),%eax
mov    -0x80(%rbp),%rcx
movzwl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xea(%rbp)
mov    -0xea(%rbp),%al
mov    %al,-0xe9(%rbp)
mov    -0xe9(%rbp),%al
test   $0x1,%al
jne    176d <img_rle_compact+0x65d>
jmp    177e <img_rle_compact+0x66e>
mov    -0x80(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x80(%rbp)
jmp    16fb <img_rle_compact+0x5eb>
mov    -0x80(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    %rcx,%rax
sar    $0x1,%rax
mov    %eax,-0xa0(%rbp)
cmpl   $0x0,-0xa0(%rbp)
je     1879 <img_rle_compact+0x769>
cmpl   $0x7e,-0xa0(%rbp)
jle    17cc <img_rle_compact+0x6bc>
mov    $0x7e,%eax
mov    %eax,-0xf0(%rbp)
jmp    17d8 <img_rle_compact+0x6c8>
mov    -0xa0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
mov    %ax,-0x9a(%rbp)
movzwl -0x9a(%rbp),%ecx
mov    -0xa0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
movzwl -0x9a(%rbp),%eax
or     $0x80,%eax
mov    %al,%cl
mov    -0x98(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
mov    %cl,(%rax)
mov    -0x9a(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x9a(%rbp)
cmp    $0x0,%ax
je     1874 <img_rle_compact+0x764>
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x90(%rbp)
mov    (%rax),%ax
mov    %al,%cl
mov    -0x98(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
mov    %cl,(%rax)
jmp    181f <img_rle_compact+0x70f>
jmp    17a2 <img_rle_compact+0x692>
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x80(%rbp)
mov    (%rax),%ax
mov    %ax,-0x9c(%rbp)
mov    -0x80(%rbp),%rcx
xor    %eax,%eax
cmp    -0x88(%rbp),%rcx
mov    %al,-0xf1(%rbp)
jae    18cf <img_rle_compact+0x7bf>
mov    -0x80(%rbp),%rax
movzwl (%rax),%eax
movzwl -0x9c(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xf1(%rbp)
mov    -0xf1(%rbp),%al
test   $0x1,%al
jne    18e2 <img_rle_compact+0x7d2>
jmp    18f3 <img_rle_compact+0x7e3>
mov    -0x80(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x80(%rbp)
jmp    189d <img_rle_compact+0x78d>
mov    -0x80(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    %rcx,%rax
sar    $0x1,%rax
mov    %eax,-0xa0(%rbp)
cmpl   $0x0,-0xa0(%rbp)
je     19a8 <img_rle_compact+0x898>
cmpl   $0x7e,-0xa0(%rbp)
jle    1935 <img_rle_compact+0x825>
mov    $0x7e,%eax
mov    %eax,-0xf8(%rbp)
jmp    1941 <img_rle_compact+0x831>
mov    -0xa0(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
mov    %ax,-0x9a(%rbp)
movzwl -0x9a(%rbp),%ecx
mov    -0xa0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x9a(%rbp),%ax
mov    %al,%cl
mov    -0x98(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
mov    %cl,(%rax)
mov    -0x9c(%rbp),%ax
mov    %al,%cl
mov    -0x98(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
mov    %cl,(%rax)
jmp    190b <img_rle_compact+0x7fb>
jmp    16d3 <img_rle_compact+0x5c3>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x98(%rbp)
movb   $0x0,(%rax)
mov    -0x98(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    1d86 <img_rle_compact+0xc76>
cmpl   $0x2,-0x14(%rbp)
jne    1d6d <img_rle_compact+0xc5d>
cmpl   $0x2,-0x24(%rbp)
jne    1d6d <img_rle_compact+0xc5d>
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jae    1d39 <img_rle_compact+0xc29>
mov    -0xa8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rcx
xor    %eax,%eax
cmp    -0xb0(%rbp),%rcx
mov    %al,-0xf9(%rbp)
jae    1ac0 <img_rle_compact+0x9b0>
mov    -0xa8(%rbp),%rax
movzwl -0x4(%rax),%ecx
mov    -0xa8(%rbp),%rax
movzwl -0x2(%rax),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xfa(%rbp)
jne    1ab4 <img_rle_compact+0x9a4>
mov    -0xa8(%rbp),%rax
movzwl -0x2(%rax),%eax
mov    -0xa8(%rbp),%rcx
movzwl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xfa(%rbp)
mov    -0xfa(%rbp),%al
mov    %al,-0xf9(%rbp)
mov    -0xf9(%rbp),%al
test   $0x1,%al
jne    1ad3 <img_rle_compact+0x9c3>
jmp    1aea <img_rle_compact+0x9da>
mov    -0xa8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
jmp    1a52 <img_rle_compact+0x942>
mov    -0xa8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0xb8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x1,%rax
mov    %eax,-0xc8(%rbp)
cmpl   $0x0,-0xc8(%rbp)
je     1bef <img_rle_compact+0xadf>
cmpl   $0x7e,-0xc8(%rbp)
jle    1b41 <img_rle_compact+0xa31>
mov    $0x7e,%eax
mov    %eax,-0x100(%rbp)
jmp    1b4d <img_rle_compact+0xa3d>
mov    -0xc8(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    %ax,-0xc2(%rbp)
movzwl -0xc2(%rbp),%ecx
mov    -0xc8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc8(%rbp)
movzwl -0xc2(%rbp),%eax
or     $0x80,%eax
mov    %ax,%cx
mov    -0xc0(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %cx,(%rax)
mov    -0xc2(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0xc2(%rbp)
cmp    $0x0,%ax
je     1bea <img_rle_compact+0xada>
mov    -0xb8(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0xb8(%rbp)
mov    (%rax),%cx
mov    -0xc0(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %cx,(%rax)
jmp    1b96 <img_rle_compact+0xa86>
jmp    1b17 <img_rle_compact+0xa07>
mov    -0xa8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0xa8(%rbp)
mov    (%rax),%ax
mov    %ax,-0xc4(%rbp)
mov    -0xa8(%rbp),%rcx
xor    %eax,%eax
cmp    -0xb0(%rbp),%rcx
mov    %al,-0x101(%rbp)
jae    1c54 <img_rle_compact+0xb44>
mov    -0xa8(%rbp),%rax
movzwl (%rax),%eax
movzwl -0xc4(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x101(%rbp)
mov    -0x101(%rbp),%al
test   $0x1,%al
jne    1c67 <img_rle_compact+0xb57>
jmp    1c7e <img_rle_compact+0xb6e>
mov    -0xa8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
jmp    1c1c <img_rle_compact+0xb0c>
mov    -0xa8(%rbp),%rax
mov    -0xb8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x1,%rax
mov    %eax,-0xc8(%rbp)
cmpl   $0x0,-0xc8(%rbp)
je     1d34 <img_rle_compact+0xc24>
cmpl   $0x7e,-0xc8(%rbp)
jle    1cc3 <img_rle_compact+0xbb3>
mov    $0x7e,%eax
mov    %eax,-0x108(%rbp)
jmp    1ccf <img_rle_compact+0xbbf>
mov    -0xc8(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    %ax,-0xc2(%rbp)
movzwl -0xc2(%rbp),%ecx
mov    -0xc8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc2(%rbp),%cx
mov    -0xc0(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %cx,(%rax)
mov    -0xc4(%rbp),%cx
mov    -0xc0(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %cx,(%rax)
jmp    1c99 <img_rle_compact+0xb89>
jmp    1a1e <img_rle_compact+0x90e>
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0xc0(%rbp)
movw   $0x0,(%rax)
mov    -0xc0(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x1,%rax
mov    %eax,-0x4(%rbp)
jmp    1d86 <img_rle_compact+0xc76>
mov    -0x14(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    0x286(%rip),%rdi
call   1030 <i_errhdlr@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<img_rle_compact>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
cmp    $0x1,%esi
mov    %rdx,0x8(%rsp)
jne    13e9 <img_rle_compact+0x2d9>
cmp    $0x1,%ecx
jne    13e9 <img_rle_compact+0x2d9>
movslq %r8d,%rcx
lea    (%rdi,%rcx,1),%r10
mov    %rdx,%rax
cmp    %rdi,%r10
jbe    1c2a <img_rle_compact+0xb1a>
lea    (%rdi,%rcx,1),%r8
add    $0x1,%r8
mov    0x8(%rsp),%rax
jmp    1169 <img_rle_compact+0x59>
nopw   0x0(%rax,%rax,1)
cmp    %r10,%rdi
jae    1c2a <img_rle_compact+0xb1a>
lea    0x2(%rdi),%r11
jmp    1174 <img_rle_compact+0x64>
nop
add    $0x1,%r11
cmp    %r10,%r11
jae    1190 <img_rle_compact+0x80>
movzbl -0x2(%r11),%ecx
cmp    -0x1(%r11),%cl
jne    1170 <img_rle_compact+0x60>
cmp    (%r11),%cl
jne    1170 <img_rle_compact+0x60>
nopl   0x0(%rax)
lea    -0x2(%r11),%r9
mov    %r9d,%r12d
sub    %edi,%r12d
jne    1218 <img_rle_compact+0x108>
lea    -0x1(%r11),%rdi
mov    -0x2(%r11),%cl
cmp    %r10,%rdi
jae    11d1 <img_rle_compact+0xc1>
add    %r10,%r11
mov    $0xfffffffffffffffe,%rdx
sub    %r9,%rdx
add    %rdx,%r11
add    %r8,%rdx
nopl   0x0(%rax)
cmp    %cl,(%rdi)
jne    11d1 <img_rle_compact+0xc1>
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    11c0 <img_rle_compact+0xb0>
mov    %r11,%rdi
mov    %edi,%edx
sub    %r9d,%edx
je     1160 <img_rle_compact+0x50>
nopl   0x0(%rax,%rax,1)
cmp    $0x7e,%edx
mov    $0x7e,%esi
cmovl  %edx,%esi
movzwl %si,%ebp
mov    %sil,(%rax)
mov    %cl,0x1(%rax)
add    $0x2,%rax
sub    %ebp,%edx
jne    11e0 <img_rle_compact+0xd0>
jmp    1160 <img_rle_compact+0x50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
test   %r12d,%r12d
je     119c <img_rle_compact+0x8c>
cmp    $0x7e,%r12d
mov    $0x7e,%esi
cmovl  %r12d,%esi
movzwl %si,%ecx
sub    %ecx,%r12d
mov    %esi,%edx
or     $0x80,%dl
mov    %dl,(%rax)
lea    0x1(%rax),%rbx
test   %cx,%cx
je     1210 <img_rle_compact+0x100>
lea    -0x1(%rsi),%ecx
cmp    $0x1f,%cx
jb     1350 <img_rle_compact+0x240>
lea    -0x1(%rsi),%edx
movzwl %dx,%edx
lea    (%rdi,%rdx,1),%rbp
add    $0x1,%rbp
cmp    %rbp,%rbx
jae    126b <img_rle_compact+0x15b>
add    %rax,%rdx
add    $0x2,%rdx
cmp    %rdx,%rdi
jb     1350 <img_rle_compact+0x240>
movzwl %cx,%r14d
add    $0x1,%r14
mov    %r14d,%r15d
and    $0xffffffe0,%r15d
lea    -0x20(%r15),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%r13d
and    $0x3,%r13d
cmp    $0x60,%rdx
jae    129a <img_rle_compact+0x18a>
xor    %ebp,%ebp
jmp    12fd <img_rle_compact+0x1ed>
and    $0xfffffffffffffffc,%rcx
xor    %ebp,%ebp
movups (%rdi,%rbp,1),%xmm0
movups 0x10(%rdi,%rbp,1),%xmm1
movups %xmm0,0x1(%rax,%rbp,1)
movups %xmm1,0x11(%rax,%rbp,1)
movups 0x20(%rdi,%rbp,1),%xmm0
movups 0x30(%rdi,%rbp,1),%xmm1
movups %xmm0,0x21(%rax,%rbp,1)
movups %xmm1,0x31(%rax,%rbp,1)
movups 0x40(%rdi,%rbp,1),%xmm0
movups 0x50(%rdi,%rbp,1),%xmm1
movups %xmm0,0x41(%rax,%rbp,1)
movups %xmm1,0x51(%rax,%rbp,1)
movdqu 0x60(%rdi,%rbp,1),%xmm0
movdqu 0x70(%rdi,%rbp,1),%xmm1
movdqu %xmm0,0x61(%rax,%rbp,1)
movdqu %xmm1,0x71(%rax,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rcx
jne    12a0 <img_rle_compact+0x190>
sub    %r15d,%esi
test   %r13,%r13
je     133f <img_rle_compact+0x22f>
lea    (%rdi,%rbp,1),%rcx
add    $0x10,%rcx
add    %rbp,%rax
add    $0x11,%rax
shl    $0x5,%r13
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r13
jne    1320 <img_rle_compact+0x210>
add    %r15,%rbx
add    %r15,%rdi
cmp    %r15,%r14
je     1210 <img_rle_compact+0x100>
xchg   %ax,%ax
lea    -0x1(%rsi),%ebp
test   $0x7,%sil
je     1388 <img_rle_compact+0x278>
movzwl %si,%edx
and    $0x7,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rcx,1),%eax
mov    %al,(%rbx,%rcx,1)
add    $0x1,%rcx
cmp    %cx,%dx
jne    1370 <img_rle_compact+0x260>
add    %rcx,%rbx
add    %rcx,%rdi
sub    %ecx,%esi
cmp    $0x7,%bp
jb     1210 <img_rle_compact+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdi),%eax
mov    %al,(%rbx)
movzbl 0x1(%rdi),%eax
mov    %al,0x1(%rbx)
movzbl 0x2(%rdi),%eax
mov    %al,0x2(%rbx)
movzbl 0x3(%rdi),%eax
mov    %al,0x3(%rbx)
movzbl 0x4(%rdi),%eax
mov    %al,0x4(%rbx)
movzbl 0x5(%rdi),%eax
mov    %al,0x5(%rbx)
movzbl 0x6(%rdi),%eax
mov    %al,0x6(%rbx)
movzbl 0x7(%rdi),%eax
add    $0x8,%rdi
mov    %al,0x7(%rbx)
add    $0x8,%rbx
add    $0xfff8,%si
jne    13a0 <img_rle_compact+0x290>
jmp    1210 <img_rle_compact+0x100>
cmp    $0x1,%esi
jne    16a1 <img_rle_compact+0x591>
cmp    $0x2,%ecx
jne    16a1 <img_rle_compact+0x591>
movslq %r8d,%rcx
lea    (%rdi,%rcx,1),%r11
mov    %rdx,%rax
cmp    %rdi,%r11
jbe    1c02 <img_rle_compact+0xaf2>
lea    (%rdi,%rcx,1),%rax
add    $0x1,%rax
mov    %rax,0x10(%rsp)
pxor   %xmm0,%xmm0
mov    0x8(%rsp),%rax
jmp    1439 <img_rle_compact+0x329>
cs nopw 0x0(%rax,%rax,1)
cmp    %r11,%rdi
jae    1c02 <img_rle_compact+0xaf2>
lea    0x2(%rdi),%r14
jmp    1444 <img_rle_compact+0x334>
nop
add    $0x1,%r14
cmp    %r11,%r14
jae    1460 <img_rle_compact+0x350>
movzbl -0x2(%r14),%ecx
cmp    -0x1(%r14),%cl
jne    1440 <img_rle_compact+0x330>
cmp    (%r14),%cl
jne    1440 <img_rle_compact+0x330>
nopl   0x0(%rax)
lea    -0x2(%r14),%r10
mov    %r10d,%r9d
sub    %edi,%r9d
jne    14e8 <img_rle_compact+0x3d8>
lea    -0x1(%r14),%rdi
movzbl -0x2(%r14),%ecx
cmp    %r11,%rdi
jae    14a1 <img_rle_compact+0x391>
add    %r11,%r14
mov    $0xfffffffffffffffe,%rdx
sub    %r10,%rdx
add    %rdx,%r14
add    0x10(%rsp),%rdx
nop
cmp    %cl,(%rdi)
jne    14a1 <img_rle_compact+0x391>
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1490 <img_rle_compact+0x380>
mov    %r14,%rdi
mov    %edi,%edx
sub    %r10d,%edx
je     1430 <img_rle_compact+0x320>
nopl   0x0(%rax,%rax,1)
cmp    $0x7e,%edx
mov    $0x7e,%esi
cmovl  %edx,%esi
movzwl %si,%esi
mov    %si,(%rax)
mov    %cx,0x2(%rax)
add    $0x4,%rax
sub    %esi,%edx
jne    14b0 <img_rle_compact+0x3a0>
jmp    1430 <img_rle_compact+0x320>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,%rax
test   %r9d,%r9d
je     146c <img_rle_compact+0x35c>
cmp    $0x7e,%r9d
mov    $0x7e,%ebx
cmovl  %r9d,%ebx
movzwl %bx,%edx
sub    %edx,%r9d
mov    %ebx,%esi
or     $0x80,%esi
mov    %si,(%rax)
lea    0x2(%rax),%rsi
test   %dx,%dx
je     14e0 <img_rle_compact+0x3d0>
lea    -0x1(%rbx),%edx
cmp    $0xf,%dx
jb     1610 <img_rle_compact+0x500>
lea    -0x1(%rbx),%ebp
movzwl %bp,%ebp
lea    (%rdi,%rbp,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    1540 <img_rle_compact+0x430>
lea    (%rax,%rbp,2),%rcx
add    $0x4,%rcx
cmp    %rcx,%rdi
jb     1610 <img_rle_compact+0x500>
movzwl %dx,%r15d
add    $0x1,%r15
mov    %r15d,%r12d
and    $0xfffffff0,%r12d
lea    -0x10(%r12),%rcx
mov    %rcx,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     15cb <img_rle_compact+0x4bb>
mov    %r8,%r13
movabs $0x1ffffffffffffffe,%rcx
ff ff 1f
and    %rcx,%r13
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movq   (%rdi,%rbp,1),%xmm1
movq   0x8(%rdi,%rbp,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x2(%rax,%rbp,2)
movdqu %xmm2,0x12(%rax,%rbp,2)
movq   0x10(%rdi,%rbp,1),%xmm1
movq   0x18(%rdi,%rbp,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x22(%rax,%rbp,2)
movdqu %xmm2,0x32(%rax,%rbp,2)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%r13
jne    1580 <img_rle_compact+0x470>
jmp    15cd <img_rle_compact+0x4bd>
xor    %ebp,%ebp
sub    %r12d,%ebx
test   $0x1,%r8b
je     15f4 <img_rle_compact+0x4e4>
movq   (%rdi,%rbp,1),%xmm1
movq   0x8(%rdi,%rbp,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rsi,%rbp,2)
movdqu %xmm2,0x10(%rsi,%rbp,2)
lea    (%rsi,%r12,2),%rsi
add    %r12,%rdi
cmp    %r12,%r15
je     14e0 <img_rle_compact+0x3d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rbx),%eax
test   $0x7,%bl
je     1639 <img_rle_compact+0x529>
movzwl %bx,%edx
and    $0x7,%edx
xor    %ebp,%ebp
movzbl (%rdi,%rbp,1),%ecx
mov    %cx,(%rsi)
add    $0x2,%rsi
add    $0x1,%rbp
cmp    %bp,%dx
jne    1620 <img_rle_compact+0x510>
sub    %ebp,%ebx
add    %rbp,%rdi
cmp    $0x7,%ax
jb     14e0 <img_rle_compact+0x3d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdi),%eax
mov    %ax,(%rsi)
movzbl 0x1(%rdi),%eax
mov    %ax,0x2(%rsi)
movzbl 0x2(%rdi),%eax
mov    %ax,0x4(%rsi)
movzbl 0x3(%rdi),%eax
mov    %ax,0x6(%rsi)
movzbl 0x4(%rdi),%eax
mov    %ax,0x8(%rsi)
movzbl 0x5(%rdi),%eax
mov    %ax,0xa(%rsi)
movzbl 0x6(%rdi),%eax
mov    %ax,0xc(%rsi)
movzbl 0x7(%rdi),%eax
add    $0x8,%rdi
mov    %ax,0xe(%rsi)
add    $0x10,%rsi
add    $0xfff8,%bx
jne    1650 <img_rle_compact+0x540>
jmp    14e0 <img_rle_compact+0x3d0>
cmp    $0x2,%esi
jne    1921 <img_rle_compact+0x811>
cmp    $0x1,%ecx
jne    1921 <img_rle_compact+0x811>
test   %r8d,%r8d
jle    1c27 <img_rle_compact+0xb17>
movslq %r8d,%rax
lea    (%rdi,%rax,2),%r10
movabs $0x1ffffffffffffffe,%r8
ff ff 1f
movdqa 0x92b(%rip),%xmm0
mov    %rdx,%rax
jmp    16e9 <img_rle_compact+0x5d9>
nopw   0x0(%rax,%rax,1)
cmp    %r10,%rdi
jae    1c2a <img_rle_compact+0xb1a>
lea    0x4(%rdi),%r11
jmp    16f4 <img_rle_compact+0x5e4>
nop
add    $0x2,%r11
cmp    %r10,%r11
jae    1710 <img_rle_compact+0x600>
movzwl -0x4(%r11),%ecx
cmp    -0x2(%r11),%cx
jne    16f0 <img_rle_compact+0x5e0>
cmp    (%r11),%cx
jne    16f0 <img_rle_compact+0x5e0>
nopl   0x0(%rax,%rax,1)
lea    -0x4(%r11),%r9
mov    %r9,%r13
sub    %rdi,%r13
shr    %r13
jmp    1723 <img_rle_compact+0x613>
nop
mov    %rsi,%rax
test   %r13d,%r13d
je     18c0 <img_rle_compact+0x7b0>
cmp    $0x7e,%r13d
mov    $0x7e,%ebx
cmovl  %r13d,%ebx
movzwl %bx,%ecx
sub    %ecx,%r13d
mov    %ebx,%edx
or     $0x80,%dl
mov    %dl,(%rax)
lea    0x1(%rax),%rsi
test   %cx,%cx
je     1720 <img_rle_compact+0x610>
lea    -0x1(%rbx),%ecx
cmp    $0xf,%cx
jb     1830 <img_rle_compact+0x720>
lea    -0x1(%rbx),%edx
movzwl %dx,%edx
lea    (%rdi,%rdx,2),%rbp
add    $0x2,%rbp
cmp    %rbp,%rsi
jae    177f <img_rle_compact+0x66f>
add    %rax,%rdx
add    $0x2,%rdx
cmp    %rdi,%rdx
ja     1830 <img_rle_compact+0x720>
movzwl %cx,%r14d
add    $0x1,%r14
mov    %r14d,%r15d
and    $0xfffffff0,%r15d
lea    -0x10(%r15),%rcx
mov    %rcx,%r12
shr    $0x4,%r12
add    $0x1,%r12
test   %rcx,%rcx
je     17f7 <img_rle_compact+0x6e7>
mov    %r12,%rcx
and    %r8,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu (%rdi,%rbp,2),%xmm1
movdqu 0x10(%rdi,%rbp,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,0x1(%rax,%rbp,1)
movdqu 0x20(%rdi,%rbp,2),%xmm1
movdqu 0x30(%rdi,%rbp,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,0x11(%rax,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rcx
jne    17b0 <img_rle_compact+0x6a0>
jmp    17f9 <img_rle_compact+0x6e9>
xor    %ebp,%ebp
sub    %r15d,%ebx
test   $0x1,%r12b
je     181e <img_rle_compact+0x70e>
movdqu (%rdi,%rbp,2),%xmm1
movdqu 0x10(%rdi,%rbp,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,(%rsi,%rbp,1)
add    %r15,%rsi
lea    (%rdi,%r15,2),%rdi
cmp    %r15,%r14
je     1720 <img_rle_compact+0x610>
xchg   %ax,%ax
lea    -0x1(%rbx),%ebp
mov    %ebx,%edx
and    $0x7,%dx
je     1857 <img_rle_compact+0x747>
xor    %ecx,%ecx
nopl   (%rax)
movzbl (%rdi),%eax
add    $0x2,%rdi
mov    %al,(%rsi)
add    $0x1,%rsi
add    $0x1,%ecx
cmp    %cx,%dx
jne    1840 <img_rle_compact+0x730>
sub    %ecx,%ebx
cmp    $0x7,%bp
jb     1720 <img_rle_compact+0x610>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi),%eax
mov    %al,(%rsi)
movzbl 0x2(%rdi),%eax
mov    %al,0x1(%rsi)
movzbl 0x4(%rdi),%eax
mov    %al,0x2(%rsi)
movzbl 0x6(%rdi),%eax
mov    %al,0x3(%rsi)
movzbl 0x8(%rdi),%eax
mov    %al,0x4(%rsi)
movzbl 0xa(%rdi),%eax
mov    %al,0x5(%rsi)
movzbl 0xc(%rdi),%eax
mov    %al,0x6(%rsi)
movzbl 0xe(%rdi),%eax
add    $0x10,%rdi
mov    %al,0x7(%rsi)
add    $0x8,%rsi
add    $0xfff8,%bx
jne    1870 <img_rle_compact+0x760>
jmp    1720 <img_rle_compact+0x610>
nopl   0x0(%rax)
movzwl -0x4(%r11),%ecx
add    $0xfffffffffffffffe,%r11
mov    %r11,%rdi
cmp    %r10,%r11
jae    18ee <img_rle_compact+0x7de>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %cx,(%rdi)
jne    18ee <img_rle_compact+0x7de>
add    $0x2,%rdi
cmp    %r10,%rdi
jb     18e0 <img_rle_compact+0x7d0>
mov    %rdi,%rdx
sub    %r9,%rdx
shr    %rdx
test   %edx,%edx
je     16e0 <img_rle_compact+0x5d0>
nop
cmp    $0x7e,%edx
mov    $0x7e,%esi
cmovl  %edx,%esi
movzwl %si,%ebp
mov    %sil,(%rax)
mov    %cl,0x1(%rax)
add    $0x2,%rax
sub    %ebp,%edx
jne    1900 <img_rle_compact+0x7f0>
jmp    16e0 <img_rle_compact+0x5d0>
cmp    $0x2,%esi
jne    1c15 <img_rle_compact+0xb05>
cmp    $0x2,%ecx
jne    1c15 <img_rle_compact+0xb05>
mov    %rdx,%rax
test   %r8d,%r8d
jle    1c02 <img_rle_compact+0xaf2>
movslq %r8d,%rax
lea    (%rdi,%rax,2),%r10
movabs $0x1ffffffffffffffe,%r8
ff ff 1f
add    $0xfffffffffffffffe,%r8
mov    0x8(%rsp),%rax
jmp    1969 <img_rle_compact+0x859>
nopl   0x0(%rax,%rax,1)
cmp    %r10,%rdi
jae    1c02 <img_rle_compact+0xaf2>
lea    0x4(%rdi),%r11
jmp    1974 <img_rle_compact+0x864>
nop
add    $0x2,%r11
cmp    %r10,%r11
jae    1990 <img_rle_compact+0x880>
movzwl -0x4(%r11),%ecx
cmp    -0x2(%r11),%cx
jne    1970 <img_rle_compact+0x860>
cmp    (%r11),%cx
jne    1970 <img_rle_compact+0x860>
nopl   0x0(%rax,%rax,1)
lea    -0x4(%r11),%r9
mov    %r9,%r12
sub    %rdi,%r12
shr    %r12
jmp    19a3 <img_rle_compact+0x893>
nop
mov    %rsi,%rax
test   %r12d,%r12d
je     1ba0 <img_rle_compact+0xa90>
cmp    $0x7e,%r12d
mov    $0x7e,%r13d
cmovl  %r12d,%r13d
movzwl %r13w,%ecx
sub    %ecx,%r12d
mov    %r13d,%edx
or     $0x80,%edx
mov    %dx,(%rax)
lea    0x2(%rax),%rsi
test   %cx,%cx
je     19a0 <img_rle_compact+0x890>
lea    -0x1(%r13),%ecx
cmp    $0xf,%cx
jb     1af0 <img_rle_compact+0x9e0>
lea    -0x1(%r13),%edx
movzwl %dx,%edx
lea    (%rdi,%rdx,2),%rbx
add    $0x2,%rbx
cmp    %rbx,%rsi
jae    1a09 <img_rle_compact+0x8f9>
lea    (%rax,%rdx,2),%rdx
add    $0x4,%rdx
cmp    %rdx,%rdi
jb     1af0 <img_rle_compact+0x9e0>
movzwl %cx,%r14d
add    $0x1,%r14
mov    %r14d,%r15d
and    $0xfffffff0,%r15d
lea    -0x10(%r15),%rdx
mov    %rdx,%rbp
shr    $0x4,%rbp
add    $0x1,%rbp
mov    %ebp,%ecx
and    $0x3,%ecx
cmp    $0x30,%rdx
jae    1a36 <img_rle_compact+0x926>
xor    %ebx,%ebx
jmp    1a9d <img_rle_compact+0x98d>
and    %r8,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rbx,2),%xmm0
movups 0x10(%rdi,%rbx,2),%xmm1
movups %xmm0,0x2(%rax,%rbx,2)
movups %xmm1,0x12(%rax,%rbx,2)
movups 0x20(%rdi,%rbx,2),%xmm0
movups 0x30(%rdi,%rbx,2),%xmm1
movups %xmm0,0x22(%rax,%rbx,2)
movups %xmm1,0x32(%rax,%rbx,2)
movups 0x40(%rdi,%rbx,2),%xmm0
movups 0x50(%rdi,%rbx,2),%xmm1
movups %xmm0,0x42(%rax,%rbx,2)
movups %xmm1,0x52(%rax,%rbx,2)
movdqu 0x60(%rdi,%rbx,2),%xmm0
movdqu 0x70(%rdi,%rbx,2),%xmm1
movdqu %xmm0,0x62(%rax,%rbx,2)
movdqu %xmm1,0x72(%rax,%rbx,2)
add    $0x40,%rbx
add    $0xfffffffffffffffc,%rbp
jne    1a40 <img_rle_compact+0x930>
sub    %r15d,%r13d
test   %rcx,%rcx
je     1adf <img_rle_compact+0x9cf>
lea    (%rdi,%rbx,2),%rdx
add    $0x10,%rdx
lea    (%rax,%rbx,2),%rax
add    $0x12,%rax
shl    $0x5,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rbx,1),%xmm0
movdqu (%rdx,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rbx,1)
movdqu %xmm1,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rcx
jne    1ac0 <img_rle_compact+0x9b0>
lea    (%rsi,%r15,2),%rsi
lea    (%rdi,%r15,2),%rdi
cmp    %r15,%r14
je     19a0 <img_rle_compact+0x890>
lea    -0x1(%r13),%eax
mov    %r13d,%edx
and    $0x7,%dx
je     1b19 <img_rle_compact+0xa09>
xor    %ecx,%ecx
nop
movzwl (%rdi),%ebx
add    $0x2,%rdi
mov    %bx,(%rsi)
add    $0x2,%rsi
add    $0x1,%ecx
cmp    %cx,%dx
jne    1b00 <img_rle_compact+0x9f0>
sub    %ecx,%r13d
cmp    $0x7,%ax
jb     19a0 <img_rle_compact+0x890>
movzwl %r13w,%ecx
xor    %edx,%edx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movzwl (%rdi,%rdx,2),%ebx
mov    %bx,(%rsi,%rdx,2)
movzwl 0x2(%rdi,%rdx,2),%ebx
mov    %bx,0x2(%rsi,%rdx,2)
movzwl 0x4(%rdi,%rdx,2),%ebx
mov    %bx,0x4(%rsi,%rdx,2)
movzwl 0x6(%rdi,%rdx,2),%ebx
mov    %bx,0x6(%rsi,%rdx,2)
movzwl 0x8(%rdi,%rdx,2),%ebx
mov    %bx,0x8(%rsi,%rdx,2)
movzwl 0xa(%rdi,%rdx,2),%ebx
mov    %bx,0xa(%rsi,%rdx,2)
movzwl 0xc(%rdi,%rdx,2),%ebx
mov    %bx,0xc(%rsi,%rdx,2)
movzwl 0xe(%rdi,%rdx,2),%ebx
mov    %bx,0xe(%rsi,%rdx,2)
add    $0xfffffffffffffff0,%rax
add    $0x8,%rdx
cmp    %dx,%cx
jne    1b30 <img_rle_compact+0xa20>
sub    %rax,%rsi
sub    %rax,%rdi
jmp    19a0 <img_rle_compact+0x890>
cs nopw 0x0(%rax,%rax,1)
movzwl -0x4(%r11),%ecx
add    $0xfffffffffffffffe,%r11
mov    %r11,%rdi
cmp    %r10,%r11
jae    1bce <img_rle_compact+0xabe>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %cx,(%rdi)
jne    1bce <img_rle_compact+0xabe>
add    $0x2,%rdi
cmp    %r10,%rdi
jb     1bc0 <img_rle_compact+0xab0>
mov    %rdi,%rdx
sub    %r9,%rdx
shr    %rdx
test   %edx,%edx
je     1960 <img_rle_compact+0x850>
nop
cmp    $0x7e,%edx
mov    $0x7e,%esi
cmovl  %edx,%esi
movzwl %si,%esi
mov    %si,(%rax)
mov    %cx,0x2(%rax)
add    $0x4,%rax
sub    %esi,%edx
jne    1be0 <img_rle_compact+0xad0>
jmp    1960 <img_rle_compact+0x850>
movw   $0x0,(%rax)
sub    0x8(%rsp),%rax
add    $0x2,%rax
shr    %rax
jmp    1c34 <img_rle_compact+0xb24>
lea    0x3f4(%rip),%rdi
mov    %ecx,%edx
call   1030 <i_errhdlr@plt>
xor    %eax,%eax
jmp    1c34 <img_rle_compact+0xb24>
mov    %rdx,%rax
movb   $0x0,(%rax)
sub    0x8(%rsp),%eax
add    $0x1,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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