#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);
void img_rle_expand(unsigned short *rlebuf, int ibpp, unsigned short *expbuf,
                    int obpp) {
  if (ibpp == 1 && obpp == 1) {
    register unsigned char *iptr = (unsigned char *)rlebuf;
    register unsigned char *optr = (unsigned char *)expbuf;
    register unsigned short pixel, count;
    while (1) {
      pixel = *iptr++;
      if (!(count = (pixel & 0x7f)))
        return;
      if (pixel & 0x80) {
        while (count--)
          *optr++ = *iptr++;
      } else {
        pixel = *iptr++;
        while (count--)
          *optr++ = pixel;
      }
    };
  } else if (ibpp == 1 && obpp == 2) {
    register unsigned char *iptr = (unsigned char *)rlebuf;
    register unsigned short *optr = expbuf;
    register unsigned short pixel, count;
    while (1) {
      pixel = *iptr++;
      if (!(count = (pixel & 0x7f)))
        return;
      if (pixel & 0x80) {
        while (count--)
          *optr++ = *iptr++;
      } else {
        pixel = *iptr++;
        while (count--)
          *optr++ = pixel;
      }
    };
  } else if (ibpp == 2 && obpp == 1) {
    register unsigned short *iptr = rlebuf;
    register unsigned char *optr = (unsigned char *)expbuf;
    register unsigned short pixel, count;
    while (1) {
      pixel = *iptr++;
      if (!(count = (pixel & 0x7f)))
        return;
      if (pixel & 0x80) {
        while (count--)
          *optr++ = *iptr++;
      } else {
        pixel = *iptr++;
        while (count--)
          *optr++ = pixel;
      }
    };
  } else if (ibpp == 2 && obpp == 2) {
    register unsigned short *iptr = rlebuf;
    register unsigned short *optr = expbuf;
    register unsigned short pixel, count;
    while (1) {
      pixel = *iptr++;
      if (!(count = (pixel & 0x7f)))
        return;
      if (pixel & 0x80) {
        while (count--)
          *optr++ = *iptr++;
      } else {
        pixel = *iptr++;
        while (count--)
          *optr++ = pixel;
      }
    };
  } else
    i_errhdlr("rle_expand: bad bpp: %d %d\n", ibpp, obpp);
}


x86 assembly (clang, -O0):
<img_rle_expand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
cmpl   $0x1,-0xc(%rbp)
jne    122e <img_rle_expand+0x11e>
cmpl   $0x1,-0x1c(%rbp)
jne    122e <img_rle_expand+0x11e>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %ax,-0x32(%rbp)
movzwl -0x32(%rbp),%eax
and    $0x7f,%eax
mov    %ax,-0x34(%rbp)
cmp    $0x0,%ax
jne    117d <img_rle_expand+0x6d>
jmp    1566 <img_rle_expand+0x456>
movzwl -0x32(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     11d9 <img_rle_expand+0xc9>
jmp    1194 <img_rle_expand+0x84>
mov    -0x34(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x34(%rbp)
cmp    $0x0,%ax
je     11d4 <img_rle_expand+0xc4>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    1194 <img_rle_expand+0x84>
jmp    1229 <img_rle_expand+0x119>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %ax,-0x32(%rbp)
mov    -0x34(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x34(%rbp)
cmp    $0x0,%ax
je     1224 <img_rle_expand+0x114>
mov    -0x32(%rbp),%ax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    11ef <img_rle_expand+0xdf>
jmp    1229 <img_rle_expand+0x119>
jmp    114d <img_rle_expand+0x3d>
cmpl   $0x1,-0xc(%rbp)
jne    1337 <img_rle_expand+0x227>
cmpl   $0x2,-0x1c(%rbp)
jne    1337 <img_rle_expand+0x227>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%eax
mov    %ax,-0x4a(%rbp)
movzwl -0x4a(%rbp),%eax
and    $0x7f,%eax
mov    %ax,-0x4c(%rbp)
cmp    $0x0,%ax
jne    1282 <img_rle_expand+0x172>
jmp    1566 <img_rle_expand+0x456>
movzwl -0x4a(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     12e3 <img_rle_expand+0x1d3>
jmp    1299 <img_rle_expand+0x189>
mov    -0x4c(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x4c(%rbp)
cmp    $0x0,%ax
je     12de <img_rle_expand+0x1ce>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%eax
mov    %ax,%cx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cx,(%rax)
jmp    1299 <img_rle_expand+0x189>
jmp    1332 <img_rle_expand+0x222>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%eax
mov    %ax,-0x4a(%rbp)
mov    -0x4c(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x4c(%rbp)
cmp    $0x0,%ax
je     132d <img_rle_expand+0x21d>
mov    -0x4a(%rbp),%cx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cx,(%rax)
jmp    12f9 <img_rle_expand+0x1e9>
jmp    1332 <img_rle_expand+0x222>
jmp    1252 <img_rle_expand+0x142>
cmpl   $0x2,-0xc(%rbp)
jne    143f <img_rle_expand+0x32f>
cmpl   $0x1,-0x1c(%rbp)
jne    143f <img_rle_expand+0x32f>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%ax
mov    %ax,-0x62(%rbp)
movzwl -0x62(%rbp),%eax
and    $0x7f,%eax
mov    %ax,-0x64(%rbp)
cmp    $0x0,%ax
jne    138b <img_rle_expand+0x27b>
jmp    1566 <img_rle_expand+0x456>
movzwl -0x62(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     13ea <img_rle_expand+0x2da>
jmp    13a2 <img_rle_expand+0x292>
mov    -0x64(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x64(%rbp)
cmp    $0x0,%ax
je     13e5 <img_rle_expand+0x2d5>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%ax
mov    %al,%cl
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    %cl,(%rax)
jmp    13a2 <img_rle_expand+0x292>
jmp    143a <img_rle_expand+0x32a>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%ax
mov    %ax,-0x62(%rbp)
mov    -0x64(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x64(%rbp)
cmp    $0x0,%ax
je     1435 <img_rle_expand+0x325>
mov    -0x62(%rbp),%ax
mov    %al,%cl
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    %cl,(%rax)
jmp    1400 <img_rle_expand+0x2f0>
jmp    143a <img_rle_expand+0x32a>
jmp    135b <img_rle_expand+0x24b>
cmpl   $0x2,-0xc(%rbp)
jne    1545 <img_rle_expand+0x435>
cmpl   $0x2,-0x1c(%rbp)
jne    1545 <img_rle_expand+0x435>
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x70(%rbp)
mov    (%rax),%ax
mov    %ax,-0x7a(%rbp)
movzwl -0x7a(%rbp),%eax
and    $0x7f,%eax
mov    %ax,-0x7c(%rbp)
cmp    $0x0,%ax
jne    1493 <img_rle_expand+0x383>
jmp    1566 <img_rle_expand+0x456>
movzwl -0x7a(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     14f1 <img_rle_expand+0x3e1>
jmp    14aa <img_rle_expand+0x39a>
mov    -0x7c(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x7c(%rbp)
cmp    $0x0,%ax
je     14ec <img_rle_expand+0x3dc>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x70(%rbp)
mov    (%rax),%cx
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cx,(%rax)
jmp    14aa <img_rle_expand+0x39a>
jmp    1540 <img_rle_expand+0x430>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x70(%rbp)
mov    (%rax),%ax
mov    %ax,-0x7a(%rbp)
mov    -0x7c(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x7c(%rbp)
cmp    $0x0,%ax
je     153b <img_rle_expand+0x42b>
mov    -0x7a(%rbp),%cx
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cx,(%rax)
jmp    1507 <img_rle_expand+0x3f7>
jmp    1540 <img_rle_expand+0x430>
jmp    1463 <img_rle_expand+0x353>
mov    -0xc(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xaae(%rip),%rdi
call   1030 <i_errhdlr@plt>
jmp    155c <img_rle_expand+0x44c>
jmp    1561 <img_rle_expand+0x451>
jmp    1566 <img_rle_expand+0x456>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<img_rle_expand>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%rbx
mov    %rdi,%r14
cmp    $0x1,%esi
jne    1138 <img_rle_expand+0x18>
cmp    $0x1,%ecx
je     1196 <img_rle_expand+0x76>
cmp    $0x1,%esi
jne    16b4 <img_rle_expand+0x594>
cmp    $0x2,%ecx
jne    16b4 <img_rle_expand+0x594>
mov    (%r14),%al
mov    %eax,%edx
and    $0x7f,%dl
je     1c29 <img_rle_expand+0xb09>
movabs $0x1ffffffffffffff8,%r8
ff ff 1f
pxor   %xmm0,%xmm0
jmp    13b2 <img_rle_expand+0x292>
nopl   0x0(%rax,%rax,1)
movzwl %cx,%eax
add    $0xffffffff,%eax
movzwl %ax,%r15d
lea    0x1(%r15),%rdx
movzbl 0x1(%r14),%esi
mov    %rbx,%rdi
call   1030 <memset@plt>
add    $0x2,%r14
add    %r15,%rbx
add    $0x1,%rbx
mov    (%r14),%al
mov    %eax,%ecx
and    $0x7f,%cl
je     1c29 <img_rle_expand+0xb09>
movzbl %cl,%ecx
test   %al,%al
jns    1170 <img_rle_expand+0x50>
lea    0x1(%r14),%rax
movzwl %cx,%r10d
lea    -0x1(%r10),%esi
cmp    $0x1f,%si
jb     12f0 <img_rle_expand+0x1d0>
movzwl %si,%edx
lea    (%r14,%rdx,1),%rdi
add    $0x2,%rdi
cmp    %rdi,%rbx
jae    11e1 <img_rle_expand+0xc1>
add    %rbx,%rdx
add    $0x1,%rdx
cmp    %rdx,%rax
jb     12f0 <img_rle_expand+0x1d0>
movzwl %si,%r8d
add    $0x1,%r8
mov    %r8d,%r9d
and    $0xffffffe0,%r9d
lea    -0x20(%r9),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%esi
and    $0x3,%esi
cmp    $0x60,%rdx
jae    120e <img_rle_expand+0xee>
xor    %edi,%edi
jmp    1285 <img_rle_expand+0x165>
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x1(%r14,%rdi,1),%xmm0
movups 0x11(%r14,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
movups 0x21(%r14,%rdi,1),%xmm0
movups 0x31(%r14,%rdi,1),%xmm1
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm1,0x30(%rbx,%rdi,1)
movups 0x41(%r14,%rdi,1),%xmm0
movups 0x51(%r14,%rdi,1),%xmm1
movups %xmm0,0x40(%rbx,%rdi,1)
movups %xmm1,0x50(%rbx,%rdi,1)
movdqu 0x61(%r14,%rdi,1),%xmm0
movdqu 0x71(%r14,%rdi,1),%xmm1
movdqu %xmm0,0x60(%rbx,%rdi,1)
movdqu %xmm1,0x70(%rbx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1220 <img_rle_expand+0x100>
sub    %r9d,%r10d
test   %rsi,%rsi
je     12cf <img_rle_expand+0x1af>
lea    (%r14,%rdi,1),%rcx
add    $0x11,%rcx
add    %rbx,%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rdx,1)
movdqu %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    12b0 <img_rle_expand+0x190>
add    %r9,%rbx
add    %r9,%rax
mov    %r10d,%ecx
mov    %rax,%r14
cmp    %r9,%r8
je     1196 <img_rle_expand+0x76>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rcx),%r8d
test   $0x7,%cl
je     1338 <img_rle_expand+0x218>
movzwl %cx,%edi
and    $0x7,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rsi,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
cmp    %si,%di
jne    1310 <img_rle_expand+0x1f0>
sub    %esi,%ecx
add    %rsi,%rbx
add    %rsi,%rax
mov    %rax,%r14
cmp    $0x7,%r8w
jb     1196 <img_rle_expand+0x76>
jmp    1350 <img_rle_expand+0x230>
cmp    $0x7,%r8w
jb     1196 <img_rle_expand+0x76>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rax),%edx
mov    %dl,(%rbx)
movzbl 0x1(%rax),%edx
mov    %dl,0x1(%rbx)
movzbl 0x2(%rax),%edx
mov    %dl,0x2(%rbx)
movzbl 0x3(%rax),%edx
mov    %dl,0x3(%rbx)
movzbl 0x4(%rax),%edx
mov    %dl,0x4(%rbx)
movzbl 0x5(%rax),%edx
mov    %dl,0x5(%rbx)
movzbl 0x6(%rax),%edx
mov    %dl,0x6(%rbx)
movzbl 0x7(%rax),%edx
add    $0x8,%rax
mov    %dl,0x7(%rbx)
add    $0x8,%rbx
add    $0xfff8,%cx
jne    1350 <img_rle_expand+0x230>
mov    %rax,%r14
jmp    1196 <img_rle_expand+0x76>
nopl   0x0(%rax)
add    $0x2,%r14
mov    (%r14),%al
mov    %eax,%edx
and    $0x7f,%dl
je     1c29 <img_rle_expand+0xb09>
lea    0x1(%r14),%rcx
movzbl %dl,%edx
test   %al,%al
js     1420 <img_rle_expand+0x300>
movzbl (%rcx),%ecx
movzwl %dx,%r10d
lea    -0x1(%r10),%eax
cmp    $0xf,%ax
jb     15b4 <img_rle_expand+0x494>
movzwl %ax,%r9d
add    $0x1,%r9
mov    %r9d,%edi
and    $0xfffffff0,%edi
movd   %ecx,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pshufd $0x0,%xmm1,%xmm1
lea    -0x10(%rdi),%rsi
mov    %rsi,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%eax
and    $0x7,%eax
cmp    $0x70,%rsi
jae    14e2 <img_rle_expand+0x3c2>
xor    %esi,%esi
jmp    1575 <img_rle_expand+0x455>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzwl %dx,%r11d
lea    -0x1(%r11),%eax
cmp    $0xf,%ax
jb     1620 <img_rle_expand+0x500>
movzwl %ax,%edi
lea    (%r14,%rdi,1),%rsi
add    $0x2,%rsi
cmp    %rbx,%rsi
jbe    1453 <img_rle_expand+0x333>
lea    (%rbx,%rdi,2),%rsi
add    $0x2,%rsi
cmp    %rsi,%rcx
jb     1620 <img_rle_expand+0x500>
movzwl %ax,%r9d
add    $0x1,%r9
mov    %r9d,%r10d
and    $0xfffffff0,%r10d
lea    -0x10(%r10),%rax
mov    %rax,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     15d5 <img_rle_expand+0x4b5>
lea    0x6(%r8),%rdi
and    %rdx,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   0x1(%r14,%rax,1),%xmm1
movq   0x9(%r14,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rax,2)
movdqu %xmm2,0x10(%rbx,%rax,2)
movq   0x11(%r14,%rax,1),%xmm1
movq   0x19(%r14,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x20(%rbx,%rax,2)
movdqu %xmm2,0x30(%rbx,%rax,2)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdi
jne    1490 <img_rle_expand+0x370>
jmp    15d7 <img_rle_expand+0x4b7>
and    %r8,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu %xmm1,(%rbx,%rsi,2)
movdqu %xmm1,0x10(%rbx,%rsi,2)
movdqu %xmm1,0x20(%rbx,%rsi,2)
movdqu %xmm1,0x30(%rbx,%rsi,2)
movdqu %xmm1,0x40(%rbx,%rsi,2)
movdqu %xmm1,0x50(%rbx,%rsi,2)
movdqu %xmm1,0x60(%rbx,%rsi,2)
movdqu %xmm1,0x70(%rbx,%rsi,2)
movdqu %xmm1,0x80(%rbx,%rsi,2)
movdqu %xmm1,0x90(%rbx,%rsi,2)
movdqu %xmm1,0xa0(%rbx,%rsi,2)
movdqu %xmm1,0xb0(%rbx,%rsi,2)
movdqu %xmm1,0xc0(%rbx,%rsi,2)
movdqu %xmm1,0xd0(%rbx,%rsi,2)
movdqu %xmm1,0xe0(%rbx,%rsi,2)
movdqu %xmm1,0xf0(%rbx,%rsi,2)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffff8,%rdx
jne    14f0 <img_rle_expand+0x3d0>
sub    %edi,%r10d
test   %rax,%rax
je     15a4 <img_rle_expand+0x484>
lea    (%rbx,%rsi,2),%rdx
add    $0x10,%rdx
shl    $0x5,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu %xmm1,-0x10(%rdx,%rsi,1)
movdqu %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    1590 <img_rle_expand+0x470>
lea    (%rbx,%rdi,2),%rbx
mov    %r10d,%edx
cmp    %rdi,%r9
je     13a0 <img_rle_expand+0x280>
mov    %rbx,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2(%rax),%rbx
mov    %cx,(%rax)
mov    %rbx,%rax
add    $0xffff,%dx
jne    15c0 <img_rle_expand+0x4a0>
jmp    13a0 <img_rle_expand+0x280>
xor    %eax,%eax
sub    %r10d,%r11d
test   $0x1,%dl
je     15fd <img_rle_expand+0x4dd>
movq   (%rcx,%rax,1),%xmm1
movq   0x8(%rcx,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rax,2)
movdqu %xmm2,0x10(%rbx,%rax,2)
lea    (%rbx,%r10,2),%rbx
add    %r10,%rcx
mov    %r11d,%edx
mov    %rcx,%r14
cmp    %r10,%r9
je     13a4 <img_rle_expand+0x284>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rdx),%r9d
mov    %edx,%edi
and    $0x7,%di
je     1648 <img_rle_expand+0x528>
xor    %esi,%esi
xchg   %ax,%ax
movzbl (%rcx),%eax
add    $0x1,%rcx
mov    %ax,(%rbx)
add    $0x2,%rbx
add    $0x1,%esi
cmp    %si,%di
jne    1630 <img_rle_expand+0x510>
sub    %esi,%edx
mov    %rcx,%r14
cmp    $0x7,%r9w
jb     13a4 <img_rle_expand+0x284>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rcx),%eax
mov    %ax,(%rbx)
movzbl 0x1(%rcx),%eax
mov    %ax,0x2(%rbx)
movzbl 0x2(%rcx),%eax
mov    %ax,0x4(%rbx)
movzbl 0x3(%rcx),%eax
mov    %ax,0x6(%rbx)
movzbl 0x4(%rcx),%eax
mov    %ax,0x8(%rbx)
movzbl 0x5(%rcx),%eax
mov    %ax,0xa(%rbx)
movzbl 0x6(%rcx),%eax
mov    %ax,0xc(%rbx)
movzbl 0x7(%rcx),%eax
add    $0x8,%rcx
mov    %ax,0xe(%rbx)
add    $0x10,%rbx
add    $0xfff8,%dx
jne    1660 <img_rle_expand+0x540>
mov    %rcx,%r14
jmp    13a4 <img_rle_expand+0x284>
cmp    $0x2,%esi
jne    18ac <img_rle_expand+0x78c>
cmp    $0x1,%ecx
jne    18ac <img_rle_expand+0x78c>
movzwl (%r14),%ecx
mov    %ecx,%eax
and    $0x7f,%ax
je     1c29 <img_rle_expand+0xb09>
movabs $0x1ffffffffffffff8,%r15
ff ff 1f
movdqa 0x918(%rip),%xmm2
add    $0x6,%r15
jmp    172c <img_rle_expand+0x60c>
xchg   %ax,%ax
add    $0xffffffff,%eax
movzwl %ax,%r12d
lea    0x1(%r12),%rdx
movzbl 0x2(%r14),%esi
mov    %rbx,%rdi
call   1030 <memset@plt>
movdqa 0x8ef(%rip),%xmm2
add    $0x4,%r14
add    %r12,%rbx
add    $0x1,%rbx
movzwl (%r14),%ecx
mov    %ecx,%eax
and    $0x7f,%ax
je     1c29 <img_rle_expand+0xb09>
test   $0x80,%cl
je     16f0 <img_rle_expand+0x5d0>
lea    0x2(%r14),%rcx
lea    -0x1(%rax),%edx
cmp    $0xf,%dx
jb     1820 <img_rle_expand+0x700>
lea    -0x1(%rax),%esi
movzwl %si,%esi
lea    (%r14,%rsi,2),%rdi
add    $0x4,%rdi
cmp    %rdi,%rbx
jae    1765 <img_rle_expand+0x645>
add    %rbx,%rsi
add    $0x1,%rsi
cmp    %rcx,%rsi
ja     1820 <img_rle_expand+0x700>
movzwl %dx,%r8d
add    $0x1,%r8
mov    %r8d,%r9d
and    $0xfffffff0,%r9d
lea    -0x10(%r9),%rdx
mov    %rdx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     17db <img_rle_expand+0x6bb>
mov    %rsi,%rdi
and    %r15,%rdi
xor    %edx,%edx
movdqu 0x2(%r14,%rdx,2),%xmm0
movdqu 0x12(%r14,%rdx,2),%xmm1
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rbx,%rdx,1)
movdqu 0x22(%r14,%rdx,2),%xmm0
movdqu 0x32(%r14,%rdx,2),%xmm1
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,0x10(%rbx,%rdx,1)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1790 <img_rle_expand+0x670>
jmp    17dd <img_rle_expand+0x6bd>
xor    %edx,%edx
sub    %r9d,%eax
test   $0x1,%sil
je     1802 <img_rle_expand+0x6e2>
movdqu (%rcx,%rdx,2),%xmm0
movdqu 0x10(%rcx,%rdx,2),%xmm1
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rbx,%rdx,1)
add    %r9,%rbx
lea    (%rcx,%r9,2),%rcx
mov    %rcx,%r14
cmp    %r9,%r8
je     171c <img_rle_expand+0x5fc>
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rax),%r8d
mov    %eax,%edi
and    $0x7,%di
je     1847 <img_rle_expand+0x727>
xor    %esi,%esi
xchg   %ax,%ax
movzbl (%rcx),%edx
add    $0x2,%rcx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0x1,%esi
cmp    %si,%di
jne    1830 <img_rle_expand+0x710>
sub    %esi,%eax
mov    %rcx,%r14
cmp    $0x7,%r8w
jb     171c <img_rle_expand+0x5fc>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rcx),%edx
mov    %dl,(%rbx)
movzbl 0x2(%rcx),%edx
mov    %dl,0x1(%rbx)
movzbl 0x4(%rcx),%edx
mov    %dl,0x2(%rbx)
movzbl 0x6(%rcx),%edx
mov    %dl,0x3(%rbx)
movzbl 0x8(%rcx),%edx
mov    %dl,0x4(%rbx)
movzbl 0xa(%rcx),%edx
mov    %dl,0x5(%rbx)
movzbl 0xc(%rcx),%edx
mov    %dl,0x6(%rbx)
movzbl 0xe(%rcx),%edx
add    $0x10,%rcx
mov    %dl,0x7(%rbx)
add    $0x8,%rbx
add    $0xfff8,%ax
jne    1860 <img_rle_expand+0x740>
mov    %rcx,%r14
jmp    171c <img_rle_expand+0x5fc>
cmp    $0x2,%esi
jne    1c35 <img_rle_expand+0xb15>
cmp    $0x2,%ecx
jne    1c35 <img_rle_expand+0xb15>
movzwl (%r14),%eax
mov    %eax,%ecx
and    $0x7f,%cx
je     1c29 <img_rle_expand+0xb09>
movabs $0x1ffffffffffffff8,%r8
ff ff 1f
jmp    18f4 <img_rle_expand+0x7d4>
nopw   0x0(%rax,%rax,1)
add    $0x4,%r14
movzwl (%r14),%eax
mov    %eax,%ecx
and    $0x7f,%cx
je     1c29 <img_rle_expand+0xb09>
lea    0x2(%r14),%rdx
test   $0x80,%al
jne    1950 <img_rle_expand+0x830>
movzwl (%rdx),%edx
lea    -0x1(%rcx),%eax
cmp    $0xf,%ax
jb     1a81 <img_rle_expand+0x961>
movzwl %ax,%r9d
add    $0x1,%r9
mov    %r9d,%r10d
and    $0xfffffff0,%r10d
movd   %edx,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x10(%r10),%rdi
mov    %rdi,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%esi
and    $0x7,%esi
cmp    $0x70,%rdi
jae    19b7 <img_rle_expand+0x897>
xor    %edi,%edi
jmp    1a45 <img_rle_expand+0x925>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rcx),%eax
cmp    $0xf,%ax
jb     1b80 <img_rle_expand+0xa60>
lea    -0x1(%rcx),%esi
movzwl %si,%esi
lea    (%r14,%rsi,2),%rdi
add    $0x4,%rdi
cmp    %rdi,%rbx
jae    1981 <img_rle_expand+0x861>
lea    (%rbx,%rsi,2),%rsi
add    $0x2,%rsi
cmp    %rsi,%rdx
jb     1b80 <img_rle_expand+0xa60>
movzwl %ax,%r9d
add    $0x1,%r9
mov    %r9d,%r10d
and    $0xfffffff0,%r10d
lea    -0x10(%r10),%rsi
mov    %rsi,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r11d
and    $0x3,%r11d
cmp    $0x30,%rsi
jae    1aa5 <img_rle_expand+0x985>
xor    %edi,%edi
jmp    1b15 <img_rle_expand+0x9f5>
and    %r8,%rax
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,(%rbx,%rdi,2)
movdqu %xmm0,0x10(%rbx,%rdi,2)
movdqu %xmm0,0x20(%rbx,%rdi,2)
movdqu %xmm0,0x30(%rbx,%rdi,2)
movdqu %xmm0,0x40(%rbx,%rdi,2)
movdqu %xmm0,0x50(%rbx,%rdi,2)
movdqu %xmm0,0x60(%rbx,%rdi,2)
movdqu %xmm0,0x70(%rbx,%rdi,2)
movdqu %xmm0,0x80(%rbx,%rdi,2)
movdqu %xmm0,0x90(%rbx,%rdi,2)
movdqu %xmm0,0xa0(%rbx,%rdi,2)
movdqu %xmm0,0xb0(%rbx,%rdi,2)
movdqu %xmm0,0xc0(%rbx,%rdi,2)
movdqu %xmm0,0xd0(%rbx,%rdi,2)
movdqu %xmm0,0xe0(%rbx,%rdi,2)
movdqu %xmm0,0xf0(%rbx,%rdi,2)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffff8,%rax
jne    19c0 <img_rle_expand+0x8a0>
sub    %r10d,%ecx
test   %rsi,%rsi
je     1a74 <img_rle_expand+0x954>
lea    (%rbx,%rdi,2),%rax
add    $0x10,%rax
shl    $0x5,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rax,%rdi,1)
movdqu %xmm0,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1a60 <img_rle_expand+0x940>
lea    (%rbx,%r10,2),%rbx
cmp    %r10,%r9
je     18e0 <img_rle_expand+0x7c0>
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x2(%rax),%rbx
mov    %dx,(%rax)
mov    %rbx,%rax
add    $0xffff,%cx
jne    1a90 <img_rle_expand+0x970>
jmp    18e0 <img_rle_expand+0x7c0>
lea    0x4(%r8),%rsi
and    %rsi,%rax
xor    %edi,%edi
xchg   %ax,%ax
movups 0x2(%r14,%rdi,2),%xmm0
movups 0x12(%r14,%rdi,2),%xmm1
movups %xmm0,(%rbx,%rdi,2)
movups %xmm1,0x10(%rbx,%rdi,2)
movups 0x22(%r14,%rdi,2),%xmm0
movups 0x32(%r14,%rdi,2),%xmm1
movups %xmm0,0x20(%rbx,%rdi,2)
movups %xmm1,0x30(%rbx,%rdi,2)
movups 0x42(%r14,%rdi,2),%xmm0
movups 0x52(%r14,%rdi,2),%xmm1
movups %xmm0,0x40(%rbx,%rdi,2)
movups %xmm1,0x50(%rbx,%rdi,2)
movdqu 0x62(%r14,%rdi,2),%xmm0
movdqu 0x72(%r14,%rdi,2),%xmm1
movdqu %xmm0,0x60(%rbx,%rdi,2)
movdqu %xmm1,0x70(%rbx,%rdi,2)
add    $0x40,%rdi
add    $0xfffffffffffffffc,%rax
jne    1ab0 <img_rle_expand+0x990>
sub    %r10d,%ecx
test   %r11,%r11
je     1b5f <img_rle_expand+0xa3f>
lea    (%r14,%rdi,2),%rax
add    $0x12,%rax
lea    (%rbx,%rdi,2),%rdi
add    $0x10,%rdi
shl    $0x5,%r11
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rax,%rsi,1),%xmm0
movdqu (%rax,%rsi,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rsi,1)
movdqu %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    1b40 <img_rle_expand+0xa20>
lea    (%rbx,%r10,2),%rbx
lea    (%rdx,%r10,2),%rdx
mov    %rdx,%r14
cmp    %r10,%r9
je     18e4 <img_rle_expand+0x7c4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rcx),%r9d
mov    %ecx,%edi
and    $0x7,%di
je     1ba8 <img_rle_expand+0xa88>
xor    %esi,%esi
xchg   %ax,%ax
movzwl (%rdx),%eax
add    $0x2,%rdx
mov    %ax,(%rbx)
add    $0x2,%rbx
add    $0x1,%esi
cmp    %si,%di
jne    1b90 <img_rle_expand+0xa70>
sub    %esi,%ecx
mov    %rdx,%r14
cmp    $0x7,%r9w
jb     18e4 <img_rle_expand+0x7c4>
movzwl %cx,%ecx
xor    %eax,%eax
xor    %esi,%esi
nopl   (%rax)
movzwl (%rdx,%rsi,2),%edi
mov    %di,(%rbx,%rsi,2)
movzwl 0x2(%rdx,%rsi,2),%edi
mov    %di,0x2(%rbx,%rsi,2)
movzwl 0x4(%rdx,%rsi,2),%edi
mov    %di,0x4(%rbx,%rsi,2)
movzwl 0x6(%rdx,%rsi,2),%edi
mov    %di,0x6(%rbx,%rsi,2)
movzwl 0x8(%rdx,%rsi,2),%edi
mov    %di,0x8(%rbx,%rsi,2)
movzwl 0xa(%rdx,%rsi,2),%edi
mov    %di,0xa(%rbx,%rsi,2)
movzwl 0xc(%rdx,%rsi,2),%edi
mov    %di,0xc(%rbx,%rsi,2)
movzwl 0xe(%rdx,%rsi,2),%edi
mov    %di,0xe(%rbx,%rsi,2)
add    $0x8,%rsi
add    $0xfffffffffffffff0,%rax
cmp    %si,%cx
jne    1bc0 <img_rle_expand+0xaa0>
sub    %rax,%rbx
sub    %rax,%rdx
mov    %rdx,%r14
jmp    18e4 <img_rle_expand+0x7c4>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
lea    0x3d4(%rip),%rdi
mov    %ecx,%edx
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1040 <i_errhdlr@plt>

LLVM IR (-O0):
@.str = [28 x i8] c"rle_expand: bad bpp: %d %d\0A\00"
define void @img_rle_expand(i16* %0, i32 %1, i16* %2, i32 %3) {
%5 = alloca i16*
%6 = alloca i32
%7 = alloca i16*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i16
%12 = alloca i16
%13 = alloca i8*
%14 = alloca i16*
%15 = alloca i16
%16 = alloca i16
%17 = alloca i16*
%18 = alloca i8*
%19 = alloca i16
%20 = alloca i16
%21 = alloca i16*
%22 = alloca i16*
%23 = alloca i16
%24 = alloca i16
store i16* %0, i16** %5
store i32 %1, i32* %6
store i16* %2, i16** %7
store i32 %3, i32* %8
%25 = load i32, i32* %6
%26 = icmp eq i32 %25, 1
br i1 %26, label %27, label %79
27: ; preds = %4
%28 = load i32, i32* %8
%29 = icmp eq i32 %28, 1
br i1 %29, label %30, label %79
30: ; preds = %27
%31 = load i16*, i16** %5
%32 = bitcast i16* %31 to i8*
store i8* %32, i8** %9
%33 = load i16*, i16** %7
%34 = bitcast i16* %33 to i8*
store i8* %34, i8** %10
br label %35
35: ; preds = %30, %78
%36 = load i8*, i8** %9
%37 = getelementptr inbounds i8, i8* %36, i32 1
store i8* %37, i8** %9
%38 = load i8, i8* %36
%39 = zext i8 %38 to i16
store i16 %39, i16* %11
%40 = load i16, i16* %11
%41 = zext i16 %40 to i32
%42 = and i32 %41, 127
%43 = trunc i32 %42 to i16
store i16 %43, i16* %12
%44 = icmp ne i16 %43, 0
br i1 %44, label %46, label %45
45: ; preds = %35
br label %243
46: ; preds = %35
%47 = load i16, i16* %11
%48 = zext i16 %47 to i32
%49 = and i32 %48, 128
%50 = icmp ne i32 %49, 0
br i1 %50, label %51, label %63
51: ; preds = %46
br label %52
52: ; preds = %56, %51
%53 = load i16, i16* %12
%54 = add i16 %53, -1
store i16 %54, i16* %12
%55 = icmp ne i16 %53, 0
br i1 %55, label %56, label %62
56: ; preds = %52
%57 = load i8*, i8** %9
%58 = getelementptr inbounds i8, i8* %57, i32 1
store i8* %58, i8** %9
%59 = load i8, i8* %57
%60 = load i8*, i8** %10
%61 = getelementptr inbounds i8, i8* %60, i32 1
store i8* %61, i8** %10
store i8 %59, i8* %60
br label %52
62: ; preds = %52
br label %78
63: ; preds = %46
%64 = load i8*, i8** %9
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %9
%66 = load i8, i8* %64
%67 = zext i8 %66 to i16
store i16 %67, i16* %11
br label %68
68: ; preds = %72, %63
%69 = load i16, i16* %12
%70 = add i16 %69, -1
store i16 %70, i16* %12
%71 = icmp ne i16 %69, 0
br i1 %71, label %72, label %77
72: ; preds = %68
%73 = load i16, i16* %11
%74 = trunc i16 %73 to i8
%75 = load i8*, i8** %10
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %10
store i8 %74, i8* %75
br label %68
77: ; preds = %68
br label %78
78: ; preds = %77, %62
br label %35
79: ; preds = %27, %4
%80 = load i32, i32* %6
%81 = icmp eq i32 %80, 1
br i1 %81, label %82, label %133
82: ; preds = %79
%83 = load i32, i32* %8
%84 = icmp eq i32 %83, 2
br i1 %84, label %85, label %133
85: ; preds = %82
%86 = load i16*, i16** %5
%87 = bitcast i16* %86 to i8*
store i8* %87, i8** %13
%88 = load i16*, i16** %7
store i16* %88, i16** %14
br label %89
89: ; preds = %85, %132
%90 = load i8*, i8** %13
%91 = getelementptr inbounds i8, i8* %90, i32 1
store i8* %91, i8** %13
%92 = load i8, i8* %90
%93 = zext i8 %92 to i16
store i16 %93, i16* %15
%94 = load i16, i16* %15
%95 = zext i16 %94 to i32
%96 = and i32 %95, 127
%97 = trunc i32 %96 to i16
store i16 %97, i16* %16
%98 = icmp ne i16 %97, 0
br i1 %98, label %100, label %99
99: ; preds = %89
br label %243
100: ; preds = %89
%101 = load i16, i16* %15
%102 = zext i16 %101 to i32
%103 = and i32 %102, 128
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %118
105: ; preds = %100
br label %106
106: ; preds = %110, %105
%107 = load i16, i16* %16
%108 = add i16 %107, -1
store i16 %108, i16* %16
%109 = icmp ne i16 %107, 0
br i1 %109, label %110, label %117
110: ; preds = %106
%111 = load i8*, i8** %13
%112 = getelementptr inbounds i8, i8* %111, i32 1
store i8* %112, i8** %13
%113 = load i8, i8* %111
%114 = zext i8 %113 to i16
%115 = load i16*, i16** %14
%116 = getelementptr inbounds i16, i16* %115, i32 1
store i16* %116, i16** %14
store i16 %114, i16* %115
br label %106
117: ; preds = %106
br label %132
118: ; preds = %100
%119 = load i8*, i8** %13
%120 = getelementptr inbounds i8, i8* %119, i32 1
store i8* %120, i8** %13
%121 = load i8, i8* %119
%122 = zext i8 %121 to i16
store i16 %122, i16* %15
br label %123
123: ; preds = %127, %118
%124 = load i16, i16* %16
%125 = add i16 %124, -1
store i16 %125, i16* %16
%126 = icmp ne i16 %124, 0
br i1 %126, label %127, label %131
127: ; preds = %123
%128 = load i16, i16* %15
%129 = load i16*, i16** %14
%130 = getelementptr inbounds i16, i16* %129, i32 1
store i16* %130, i16** %14
store i16 %128, i16* %129
br label %123
131: ; preds = %123
br label %132
132: ; preds = %131, %117
br label %89
133: ; preds = %82, %79
%134 = load i32, i32* %6
%135 = icmp eq i32 %134, 2
br i1 %135, label %136, label %186
136: ; preds = %133
%137 = load i32, i32* %8
%138 = icmp eq i32 %137, 1
br i1 %138, label %139, label %186
139: ; preds = %136
%140 = load i16*, i16** %5
store i16* %140, i16** %17
%141 = load i16*, i16** %7
%142 = bitcast i16* %141 to i8*
store i8* %142, i8** %18
br label %143
143: ; preds = %139, %185
%144 = load i16*, i16** %17
%145 = getelementptr inbounds i16, i16* %144, i32 1
store i16* %145, i16** %17
%146 = load i16, i16* %144
store i16 %146, i16* %19
%147 = load i16, i16* %19
%148 = zext i16 %147 to i32
%149 = and i32 %148, 127
%150 = trunc i32 %149 to i16
store i16 %150, i16* %20
%151 = icmp ne i16 %150, 0
br i1 %151, label %153, label %152
152: ; preds = %143
br label %243
153: ; preds = %143
%154 = load i16, i16* %19
%155 = zext i16 %154 to i32
%156 = and i32 %155, 128
%157 = icmp ne i32 %156, 0
br i1 %157, label %158, label %171
158: ; preds = %153
br label %159
159: ; preds = %163, %158
%160 = load i16, i16* %20
%161 = add i16 %160, -1
store i16 %161, i16* %20
%162 = icmp ne i16 %160, 0
br i1 %162, label %163, label %170
163: ; preds = %159
%164 = load i16*, i16** %17
%165 = getelementptr inbounds i16, i16* %164, i32 1
store i16* %165, i16** %17
%166 = load i16, i16* %164
%167 = trunc i16 %166 to i8
%168 = load i8*, i8** %18
%169 = getelementptr inbounds i8, i8* %168, i32 1
store i8* %169, i8** %18
store i8 %167, i8* %168
br label %159
170: ; preds = %159
br label %185
171: ; preds = %153
%172 = load i16*, i16** %17
%173 = getelementptr inbounds i16, i16* %172, i32 1
store i16* %173, i16** %17
%174 = load i16, i16* %172
store i16 %174, i16* %19
br label %175
175: ; preds = %179, %171
%176 = load i16, i16* %20
%177 = add i16 %176, -1
store i16 %177, i16* %20
%178 = icmp ne i16 %176, 0
br i1 %178, label %179, label %184
179: ; preds = %175
%180 = load i16, i16* %19
%181 = trunc i16 %180 to i8
%182 = load i8*, i8** %18
%183 = getelementptr inbounds i8, i8* %182, i32 1
store i8* %183, i8** %18
store i8 %181, i8* %182
br label %175
184: ; preds = %175
br label %185
185: ; preds = %184, %170
br label %143
186: ; preds = %136, %133
%187 = load i32, i32* %6
%188 = icmp eq i32 %187, 2
br i1 %188, label %189, label %236
189: ; preds = %186
%190 = load i32, i32* %8
%191 = icmp eq i32 %190, 2
br i1 %191, label %192, label %236
192: ; preds = %189
%193 = load i16*, i16** %5
store i16* %193, i16** %21
%194 = load i16*, i16** %7
store i16* %194, i16** %22
br label %195
195: ; preds = %192, %235
%196 = load i16*, i16** %21
%197 = getelementptr inbounds i16, i16* %196, i32 1
store i16* %197, i16** %21
%198 = load i16, i16* %196
store i16 %198, i16* %23
%199 = load i16, i16* %23
%200 = zext i16 %199 to i32
%201 = and i32 %200, 127
%202 = trunc i32 %201 to i16
store i16 %202, i16* %24
%203 = icmp ne i16 %202, 0
br i1 %203, label %205, label %204
204: ; preds = %195
br label %243
205: ; preds = %195
%206 = load i16, i16* %23
%207 = zext i16 %206 to i32
%208 = and i32 %207, 128
%209 = icmp ne i32 %208, 0
br i1 %209, label %210, label %222
210: ; preds = %205
br label %211
211: ; preds = %215, %210
%212 = load i16, i16* %24
%213 = add i16 %212, -1
store i16 %213, i16* %24
%214 = icmp ne i16 %212, 0
br i1 %214, label %215, label %221
215: ; preds = %211
%216 = load i16*, i16** %21
%217 = getelementptr inbounds i16, i16* %216, i32 1
store i16* %217, i16** %21
%218 = load i16, i16* %216
%219 = load i16*, i16** %22
%220 = getelementptr inbounds i16, i16* %219, i32 1
store i16* %220, i16** %22
store i16 %218, i16* %219
br label %211
221: ; preds = %211
br label %235
222: ; preds = %205
%223 = load i16*, i16** %21
%224 = getelementptr inbounds i16, i16* %223, i32 1
store i16* %224, i16** %21
%225 = load i16, i16* %223
store i16 %225, i16* %23
br label %226
226: ; preds = %230, %222
%227 = load i16, i16* %24
%228 = add i16 %227, -1
store i16 %228, i16* %24
%229 = icmp ne i16 %227, 0
br i1 %229, label %230, label %234
230: ; preds = %226
%231 = load i16, i16* %23
%232 = load i16*, i16** %22
%233 = getelementptr inbounds i16, i16* %232, i32 1
store i16* %233, i16** %22
store i16 %231, i16* %232
br label %226
234: ; preds = %226
br label %235
235: ; preds = %234, %221
br label %195
236: ; preds = %189, %186
%237 = load i32, i32* %6
%238 = load i32, i32* %8
%239 = call i32 @i_errhdlr(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i32 %237, i32 %238)
br label %240
240: ; preds = %236
br label %241
241: ; preds = %240
br label %242
242: ; preds = %241
br label %243
243: ; preds = %45, %99, %152, %204, %242
ret void
}

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