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