#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*/ ffpmsg(char *);
scalar_t__ malloc(int);
int fits_rdecomp_byte(unsigned char *c, int clen, unsigned char array[], int nx,
                      int nblock) {
  int i, imax;
  int k;
  int nbits, nzero, fs;
  unsigned char *cend;
  unsigned int b, diff, lastpix;
  int fsmax, fsbits, bbits;
  static int *nonzero_count = (int *)NULL;
  fsbits = 3;
  fsmax = 6;
  bbits = 1 << fsbits;
  ;
  if (nonzero_count == (int *)NULL) {
    nonzero_count = (int *)malloc(256 * sizeof(int));
    if (nonzero_count == (int *)NULL) {
      ffpmsg("rdecomp: insufficient memory");
      ;
      return 1;
    }
    nzero = 8;
    k = 128;
    for (i = 255; i >= 0;) {
      for (; i >= k; i--)
        nonzero_count[i] = nzero;
      k = k / 2;
      nzero--;
    }
  };
  lastpix = c[0];
  c += 1;
  cend = c + clen - 1;
  b = *c++;
  nbits = 8;
  for (i = 0; i < nx;) {
    nbits -= fsbits;
    while (nbits < 0) {
      b = (b << 8) | (*c++);
      nbits += 8;
    }
    fs = (b >> nbits) - 1;
    b &= (1 << nbits) - 1;
    imax = i + nblock;
    if (imax > nx)
      imax = nx;
    if (fs < 0) {
      for (; i < imax; i++)
        array[i] = lastpix;
    } else if (fs == fsmax) {
      for (; i < imax; i++) {
        k = bbits - nbits;
        diff = b << k;
        for (k -= 8; k >= 0; k -= 8) {
          b = *c++;
          diff |= b << k;
        }
        if (nbits > 0) {
          b = *c++;
          diff |= b >> (-k);
          b &= (1 << nbits) - 1;
        } else {
          b = 0;
        }
        if ((diff & 1) == 0) {
          diff = diff >> 1;
        } else {
          diff = ~(diff >> 1);
        }
        array[i] = diff + lastpix;
        lastpix = array[i];
      }
    } else {
      for (; i < imax; i++) {
        while (b == 0) {
          nbits += 8;
          b = *c++;
        }
        nzero = nbits - nonzero_count[b];
        nbits -= nzero + 1;
        b ^= 1 << nbits;
        nbits -= fs;
        while (nbits < 0) {
          b = (b << 8) | (*c++);
          nbits += 8;
        }
        diff = (nzero << fs) | (b >> nbits);
        b &= (1 << nbits) - 1;
        if ((diff & 1) == 0) {
          diff = diff >> 1;
        } else {
          diff = ~(diff >> 1);
        }
        array[i] = diff + lastpix;
        lastpix = array[i];
      }
    }
    if (c > cend) {
      ffpmsg("decompression error: hit end of compressed byte stream");
      return 1;
    }
  }
  if (c < cend) {
    ffpmsg("decompression warning: unused bytes at end of compressed buffer");
  }
  return 0;
}


x86 assembly (clang, -O0):
<fits_rdecomp_byte>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movl   $0x3,-0x5c(%rbp)
movl   $0x6,-0x58(%rbp)
mov    -0x5c(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x60(%rbp)
cmpq   $0x0,0x2edb(%rip)
jne    120a <fits_rdecomp_byte+0xea>
mov    $0x400,%edi
call   1040 <malloc@plt>
mov    %rax,0x2ec4(%rip)
cmpq   $0x0,0x2ebc(%rip)
jne    119a <fits_rdecomp_byte+0x7a>
lea    0xe77(%rip),%rdi
call   1030 <ffpmsg@plt>
movl   $0x1,-0x4(%rbp)
jmp    15ca <fits_rdecomp_byte+0x4aa>
movl   $0x8,-0x3c(%rbp)
movl   $0x80,-0x34(%rbp)
movl   $0xff,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1205 <fits_rdecomp_byte+0xe5>
jmp    11be <fits_rdecomp_byte+0x9e>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     11e9 <fits_rdecomp_byte+0xc9>
mov    -0x3c(%rbp),%edx
mov    0x2e64(%rip),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    11be <fits_rdecomp_byte+0x9e>
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    11af <fits_rdecomp_byte+0x8f>
jmp    120a <fits_rdecomp_byte+0xea>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x8,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15a9 <fits_rdecomp_byte+0x489>
mov    -0x5c(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jge    12a2 <fits_rdecomp_byte+0x182>
mov    -0x4c(%rbp),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    126d <fits_rdecomp_byte+0x14d>
mov    -0x4c(%rbp),%eax
mov    -0x38(%rbp),%ecx
shr    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
and    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    12de <fits_rdecomp_byte+0x1be>
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    131c <fits_rdecomp_byte+0x1fc>
jmp    12ed <fits_rdecomp_byte+0x1cd>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1317 <fits_rdecomp_byte+0x1f7>
mov    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ed <fits_rdecomp_byte+0x1cd>
jmp    157e <fits_rdecomp_byte+0x45e>
mov    -0x40(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    143d <fits_rdecomp_byte+0x31d>
jmp    132d <fits_rdecomp_byte+0x20d>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1438 <fits_rdecomp_byte+0x318>
mov    -0x60(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x34(%rbp),%ecx
shl    %cl,%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1391 <fits_rdecomp_byte+0x271>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x34(%rbp),%ecx
shl    %cl,%eax
or     -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    1356 <fits_rdecomp_byte+0x236>
cmpl   $0x0,-0x38(%rbp)
jle    13d8 <fits_rdecomp_byte+0x2b8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
xor    %ecx,%ecx
sub    -0x34(%rbp),%ecx
shr    %cl,%eax
or     -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
and    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    13df <fits_rdecomp_byte+0x2bf>
movl   $0x0,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    13fc <fits_rdecomp_byte+0x2dc>
mov    -0x50(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1408 <fits_rdecomp_byte+0x2e8>
mov    -0x50(%rbp),%eax
shr    $0x1,%eax
xor    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    132d <fits_rdecomp_byte+0x20d>
jmp    1579 <fits_rdecomp_byte+0x459>
jmp    1442 <fits_rdecomp_byte+0x322>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1574 <fits_rdecomp_byte+0x454>
jmp    1453 <fits_rdecomp_byte+0x333>
cmpl   $0x0,-0x4c(%rbp)
jne    1480 <fits_rdecomp_byte+0x360>
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x4c(%rbp)
jmp    1453 <fits_rdecomp_byte+0x333>
mov    -0x38(%rbp),%eax
mov    0x2bae(%rip),%rcx
mov    -0x4c(%rbp),%edx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
xor    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jge    14f1 <fits_rdecomp_byte+0x3d1>
mov    -0x4c(%rbp),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    14bc <fits_rdecomp_byte+0x39c>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
shl    %cl,%eax
mov    -0x4c(%rbp),%edx
mov    -0x38(%rbp),%ecx
shr    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
and    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1538 <fits_rdecomp_byte+0x418>
mov    -0x50(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1544 <fits_rdecomp_byte+0x424>
mov    -0x50(%rbp),%eax
shr    $0x1,%eax
xor    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1442 <fits_rdecomp_byte+0x322>
jmp    1579 <fits_rdecomp_byte+0x459>
jmp    157e <fits_rdecomp_byte+0x45e>
mov    -0x10(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    15a4 <fits_rdecomp_byte+0x484>
lea    0xa8a(%rip),%rdi
call   1030 <ffpmsg@plt>
movl   $0x1,-0x4(%rbp)
jmp    15ca <fits_rdecomp_byte+0x4aa>
jmp    1256 <fits_rdecomp_byte+0x136>
mov    -0x10(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    15c3 <fits_rdecomp_byte+0x4a3>
lea    0xa96(%rip),%rdi
call   1030 <ffpmsg@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fits_rdecomp_byte>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %ecx,%r11d
mov    %rdx,%r13
mov    %esi,%r12d
mov    %rdi,%rbx
mov    0x2eef(%rip),%rax
mov    %rax,0x20(%rsp)
test   %rax,%rax
mov    %r8,0x18(%rsp)
mov    %ecx,0xc(%rsp)
jne    12da <fits_rdecomp_byte+0x1aa>
mov    $0x400,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ec7(%rip)
test   %rax,%rax
je     1552 <fits_rdecomp_byte+0x422>
mov    %rax,%r8
add    $0xfffffffffffffff4,%r8
mov    $0x8,%edx
mov    $0x80,%r11d
mov    $0xff,%esi
jmp    11b9 <fits_rdecomp_byte+0x89>
nopl   0x0(%rax,%rax,1)
mov    %r11d,%ecx
shr    $0x1f,%ecx
add    %r11d,%ecx
sar    %ecx
add    $0xffffffff,%edx
mov    %ecx,%r11d
test   %esi,%esi
js     12c4 <fits_rdecomp_byte+0x194>
cmp    %r11d,%esi
jl     11a0 <fits_rdecomp_byte+0x70>
mov    %esi,%esi
movslq %r11d,%r15
mov    %rsi,%r10
sub    %r15,%r10
add    $0x1,%r10
cmp    $0x8,%r10
jb     12a3 <fits_rdecomp_byte+0x173>
mov    %r10,%r9
and    $0xfffffffffffffff8,%r9
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r9),%rdi
mov    %rdi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r14d
and    $0x3,%r14d
cmp    $0x18,%rdi
jae    120f <fits_rdecomp_byte+0xdf>
xor    %edi,%edi
test   %r14,%r14
jne    1262 <fits_rdecomp_byte+0x132>
jmp    1297 <fits_rdecomp_byte+0x167>
and    $0xfffffffffffffffc,%rcx
lea    (%r8,%rsi,4),%rbp
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,0x0(%rbp,%rdi,4)
movdqu %xmm0,-0x10(%rbp,%rdi,4)
movdqu %xmm0,-0x20(%rbp,%rdi,4)
movdqu %xmm0,-0x30(%rbp,%rdi,4)
movdqu %xmm0,-0x40(%rbp,%rdi,4)
movdqu %xmm0,-0x50(%rbp,%rdi,4)
movdqu %xmm0,-0x60(%rbp,%rdi,4)
movdqu %xmm0,-0x70(%rbp,%rdi,4)
add    $0xffffffffffffffe0,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1220 <fits_rdecomp_byte+0xf0>
neg    %rdi
test   %r14,%r14
je     1297 <fits_rdecomp_byte+0x167>
mov    %rsi,%rcx
sub    %rdi,%rcx
lea    (%r8,%rcx,4),%rcx
shl    $0x5,%r14
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,(%rcx,%rdi,1)
movdqu %xmm0,-0x10(%rcx,%rdi,1)
add    $0xffffffffffffffe0,%rdi
mov    %r14,%rbp
add    %rdi,%rbp
jne    1280 <fits_rdecomp_byte+0x150>
sub    %r9,%rsi
cmp    %r9,%r10
je     11a0 <fits_rdecomp_byte+0x70>
mov    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
mov    %edx,(%rax,%rcx,4)
lea    -0x1(%rcx),%rsi
cmp    %r15,%rcx
mov    %rsi,%rcx
jg     12b0 <fits_rdecomp_byte+0x180>
jmp    11a0 <fits_rdecomp_byte+0x70>
mov    0x2d75(%rip),%rax
mov    %rax,0x20(%rsp)
mov    0x18(%rsp),%r8
mov    0xc(%rsp),%r11d
movzbl (%rbx),%ebp
movslq %r12d,%rax
lea    (%rbx,%rax,1),%rdi
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdi
movzbl 0x1(%rbx),%r15d
add    $0x2,%rbx
xor    %edx,%edx
mov    $0x8,%r12d
mov    %rdi,0x10(%rsp)
jmp    131f <fits_rdecomp_byte+0x1ef>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edx,%r14d
mov    %r14d,%edx
cmp    %rdi,%rbx
ja     1534 <fits_rdecomp_byte+0x404>
cmp    %r11d,%edx
jge    1542 <fits_rdecomp_byte+0x412>
cmp    $0x2,%r12d
jg     1370 <fits_rdecomp_byte+0x240>
add    $0xfffffff5,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15d,%eax
shl    $0x8,%eax
movzbl (%rbx),%r15d
add    $0x1,%rbx
or     %eax,%r15d
add    $0x8,%r12d
cmp    $0xfffffff8,%r12d
jb     1340 <fits_rdecomp_byte+0x210>
add    $0x8,%r12d
jmp    1374 <fits_rdecomp_byte+0x244>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffffd,%r12d
mov    %r15d,%r9d
mov    %r12d,%ecx
shr    %cl,%r9d
mov    $0xffffffff,%esi
shl    %cl,%esi
not    %esi
and    %esi,%r15d
lea    (%rdx,%r8,1),%r14d
cmp    %r11d,%r14d
cmovg  %r11d,%r14d
add    $0xffffffff,%r9d
js     1440 <fits_rdecomp_byte+0x310>
cmp    $0x6,%r9d
jne    1480 <fits_rdecomp_byte+0x350>
cmp    %r14d,%edx
jge    1310 <fits_rdecomp_byte+0x1e0>
mov    $0x8,%r9d
sub    %r12d,%r9d
movslq %edx,%rdx
movslq %r14d,%r10
jmp    1418 <fits_rdecomp_byte+0x2e8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx),%ecx
add    $0x1,%rbx
or     %ecx,%edi
mov    $0x8,%ecx
test   %r12d,%r12d
je     142d <fits_rdecomp_byte+0x2fd>
movzbl (%rbx),%r15d
mov    %r15d,%eax
shr    %cl,%eax
add    $0x1,%rbx
or     %eax,%edi
and    %esi,%r15d
mov    %edi,%eax
shr    %eax
and    $0x1,%edi
neg    %edi
xor    %eax,%edi
add    %ebp,%edi
mov    %dil,0x0(%r13,%rdx,1)
movzbl %dil,%ebp
add    $0x1,%rdx
cmp    %rdx,%r10
je     152a <fits_rdecomp_byte+0x3fa>
mov    %r15d,%edi
mov    %r9d,%ecx
shl    %cl,%edi
test   %r12d,%r12d
jle    13d0 <fits_rdecomp_byte+0x2a0>
mov    %r12d,%ecx
test   %r12d,%r12d
jne    13e3 <fits_rdecomp_byte+0x2b3>
xor    %r15d,%r15d
jmp    13f5 <fits_rdecomp_byte+0x2c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r14d,%edx
jge    1310 <fits_rdecomp_byte+0x1e0>
movslq %edx,%rdi
add    %r13,%rdi
not    %edx
add    %r14d,%edx
add    $0x1,%rdx
mov    %ebp,%esi
call   1040 <memset@plt>
mov    0x10(%rsp),%rdi
mov    0xc(%rsp),%r11d
mov    0x18(%rsp),%r8
jmp    1313 <fits_rdecomp_byte+0x1e3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %r14d,%edx
jge    1310 <fits_rdecomp_byte+0x1e0>
movslq %edx,%rdx
movslq %r14d,%r10
jmp    14ac <fits_rdecomp_byte+0x37c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x8,%r12d
movzbl (%rbx),%r15d
add    $0x1,%rbx
test   %r15d,%r15d
je     14a0 <fits_rdecomp_byte+0x370>
mov    %r15d,%ecx
mov    %r12d,%edi
mov    0x20(%rsp),%rax
sub    (%rax,%rcx,4),%edi
mov    %edi,%ecx
not    %ecx
add    %ecx,%r12d
btc    %r12d,%r15d
sub    %r9d,%r12d
jns    14ea <fits_rdecomp_byte+0x3ba>
nop
shl    $0x8,%r15d
movzbl (%rbx),%ecx
add    $0x1,%rbx
or     %ecx,%r15d
add    $0x8,%r12d
mov    %r12d,%ecx
add    $0xfffffff8,%ecx
jb     14d0 <fits_rdecomp_byte+0x3a0>
mov    %r9d,%ecx
shl    %cl,%edi
mov    %r15d,%eax
mov    %r15d,%esi
mov    %r12d,%ecx
shr    %cl,%esi
mov    $0xffffffff,%r15d
shl    %cl,%r15d
or     %edi,%esi
not    %r15d
and    %eax,%r15d
mov    %esi,%eax
shr    %eax
and    $0x1,%esi
neg    %esi
xor    %eax,%esi
add    %ebp,%esi
mov    %sil,0x0(%r13,%rdx,1)
movzbl %sil,%ebp
add    $0x1,%rdx
cmp    %r10,%rdx
jne    14ac <fits_rdecomp_byte+0x37c>
mov    0x10(%rsp),%rdi
jmp    1313 <fits_rdecomp_byte+0x1e3>
mov    $0x1,%ebp
lea    0xadd(%rip),%rdi
jmp    155e <fits_rdecomp_byte+0x42e>
xor    %ebp,%ebp
cmp    %rdi,%rbx
jae    1563 <fits_rdecomp_byte+0x433>
lea    0xb04(%rip),%rdi
jmp    155e <fits_rdecomp_byte+0x42e>
mov    $0x1,%ebp
lea    0xaa2(%rip),%rdi
call   1030 <ffpmsg@plt>
mov    %ebp,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@fits_rdecomp_byte.nonzero_count = internal unnamed_addr global i32* null
@.str = [29 x i8] c"rdecomp: insufficient memory\00"
@.str.1 = [55 x i8] c"decompression error: hit end of compressed byte stream\00"
@.str.2 = [64 x i8] c"decompression warning: unused bytes at end of compressed buffer\00"
define i32 @fits_rdecomp_byte(i8* %0, i32 %1, i8* nocapture writeonly %2, i32 %3, i32 %4) {
%6 = load i32*, i32** @fits_rdecomp_byte.nonzero_count
%7 = icmp eq i32* %6, null
br i1 %7, label %8, label %109
8: ; preds = %5
%9 = tail call i64 @malloc(i32 1024)
%10 = inttoptr i64 %9 to i32*
store i32* %10, i32** @fits_rdecomp_byte.nonzero_count
%11 = icmp eq i64 %9, 0
br i1 %11, label %284, label %12
12: ; preds = %8, %102
%13 = phi i32 [ %103, %102 ], [ 255, %8 ]
%14 = phi i32 [ %104, %102 ], [ 128, %8 ]
%15 = phi i32 [ %105, %102 ], [ 8, %8 ]
%16 = icmp slt i32 %13, %14
br i1 %16, label %102, label %17
17: ; preds = %12
%18 = zext i32 %13 to i64
%19 = sext i32 %14 to i64
%20 = add nuw nsw i64 %18, 1
%21 = sub nsw i64 %20, %19
%22 = icmp ult i64 %21, 8
br i1 %22, label %92, label %23
23: ; preds = %17
%24 = and i64 %21, -8
%25 = sub nsw i64 %18, %24
%26 = insertelement <4 x i32> poison, i32 %15, i64 0
%27 = shufflevector <4 x i32> %26, <4 x i32> poison, <4 x i32> zeroinitializer
%28 = insertelement <4 x i32> poison, i32 %15, i64 0
%29 = shufflevector <4 x i32> %28, <4 x i32> poison, <4 x i32> zeroinitializer
%30 = add nsw i64 %24, -8
%31 = lshr exact i64 %30, 3
%32 = add nuw nsw i64 %31, 1
%33 = and i64 %32, 3
%34 = icmp ult i64 %30, 24
br i1 %34, label %74, label %35
35: ; preds = %23
%36 = and i64 %32, 4611686018427387900
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ 0, %35 ], [ %71, %37 ]
%39 = phi i64 [ 0, %35 ], [ %72, %37 ]
%40 = sub i64 %18, %38
%41 = getelementptr inbounds i32, i32* %10, i64 %40
%42 = getelementptr inbounds i32, i32* %41, i64 -3
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %43
%44 = getelementptr inbounds i32, i32* %41, i64 -4
%45 = getelementptr inbounds i32, i32* %44, i64 -3
%46 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %46
%47 = or i64 %38, 8
%48 = sub i64 %18, %47
%49 = getelementptr inbounds i32, i32* %10, i64 %48
%50 = getelementptr inbounds i32, i32* %49, i64 -3
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %51
%52 = getelementptr inbounds i32, i32* %49, i64 -4
%53 = getelementptr inbounds i32, i32* %52, i64 -3
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %54
%55 = or i64 %38, 16
%56 = sub i64 %18, %55
%57 = getelementptr inbounds i32, i32* %10, i64 %56
%58 = getelementptr inbounds i32, i32* %57, i64 -3
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %59
%60 = getelementptr inbounds i32, i32* %57, i64 -4
%61 = getelementptr inbounds i32, i32* %60, i64 -3
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %62
%63 = or i64 %38, 24
%64 = sub i64 %18, %63
%65 = getelementptr inbounds i32, i32* %10, i64 %64
%66 = getelementptr inbounds i32, i32* %65, i64 -3
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %65, i64 -4
%69 = getelementptr inbounds i32, i32* %68, i64 -3
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %70
%71 = add nuw i64 %38, 32
%72 = add i64 %39, 4
%73 = icmp eq i64 %72, %36
br i1 %73, label %74, label %37
74: ; preds = %37, %23
%75 = phi i64 [ 0, %23 ], [ %71, %37 ]
%76 = icmp eq i64 %33, 0
br i1 %76, label %90, label %77
77: ; preds = %74, %77
%78 = phi i64 [ %87, %77 ], [ %75, %74 ]
%79 = phi i64 [ %88, %77 ], [ 0, %74 ]
%80 = sub i64 %18, %78
%81 = getelementptr inbounds i32, i32* %10, i64 %80
%82 = getelementptr inbounds i32, i32* %81, i64 -3
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %83
%84 = getelementptr inbounds i32, i32* %81, i64 -4
%85 = getelementptr inbounds i32, i32* %84, i64 -3
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %86
%87 = add nuw i64 %78, 8
%88 = add i64 %79, 1
%89 = icmp eq i64 %88, %33
br i1 %89, label %90, label %77
90: ; preds = %77, %74
%91 = icmp eq i64 %21, %24
br i1 %91, label %99, label %92
92: ; preds = %17, %90
%93 = phi i64 [ %18, %17 ], [ %25, %90 ]
br label %94
94: ; preds = %92, %94
%95 = phi i64 [ %97, %94 ], [ %93, %92 ]
%96 = getelementptr inbounds i32, i32* %10, i64 %95
store i32 %15, i32* %96
%97 = add nsw i64 %95, -1
%98 = icmp sgt i64 %95, %19
br i1 %98, label %94, label %99
99: ; preds = %94, %90
%100 = phi i64 [ %25, %90 ], [ %97, %94 ]
%101 = trunc i64 %100 to i32
br label %102
102: ; preds = %99, %12
%103 = phi i32 [ %13, %12 ], [ %101, %99 ]
%104 = sdiv i32 %14, 2
%105 = add nsw i32 %15, -1
%106 = icmp sgt i32 %103, -1
br i1 %106, label %12, label %107
107: ; preds = %102
%108 = load i32*, i32** @fits_rdecomp_byte.nonzero_count
br label %109
109: ; preds = %107, %5
%110 = phi i32* [ %108, %107 ], [ %6, %5 ]
%111 = load i8, i8* %0
%112 = zext i8 %111 to i32
%113 = getelementptr inbounds i8, i8* %0, i64 1
%114 = sext i32 %1 to i64
%115 = getelementptr inbounds i8, i8* %113, i64 %114
%116 = getelementptr inbounds i8, i8* %115, i64 -1
%117 = getelementptr inbounds i8, i8* %0, i64 2
%118 = load i8, i8* %113
%119 = zext i8 %118 to i32
br label %120
120: ; preds = %275, %109
%121 = phi i32 [ 8, %109 ], [ %276, %275 ]
%122 = phi i32 [ %119, %109 ], [ %277, %275 ]
%123 = phi i32 [ %112, %109 ], [ %278, %275 ]
%124 = phi i32 [ 0, %109 ], [ %279, %275 ]
%125 = phi i8* [ %117, %109 ], [ %280, %275 ]
%126 = icmp slt i32 %124, %3
br i1 %126, label %127, label %282
127: ; preds = %120
%128 = add nsw i32 %121, -3
%129 = icmp slt i32 %121, 3
br i1 %129, label %130, label %141
130: ; preds = %127, %130
%131 = phi i8* [ %135, %130 ], [ %125, %127 ]
%132 = phi i32 [ %138, %130 ], [ %122, %127 ]
%133 = phi i32 [ %139, %130 ], [ %128, %127 ]
%134 = shl i32 %132, 8
%135 = getelementptr inbounds i8, i8* %131, i64 1
%136 = load i8, i8* %131
%137 = zext i8 %136 to i32
%138 = or i32 %134, %137
%139 = add nsw i32 %133, 8
%140 = icmp ult i32 %133, -8
br i1 %140, label %130, label %141
141: ; preds = %130, %127
%142 = phi i32 [ %128, %127 ], [ %139, %130 ]
%143 = phi i32 [ %122, %127 ], [ %138, %130 ]
%144 = phi i8* [ %125, %127 ], [ %135, %130 ]
%145 = lshr i32 %143, %142
%146 = add i32 %145, -1
%147 = shl nsw i32 -1, %142
%148 = xor i32 %147, -1
%149 = and i32 %143, %148
%150 = add nsw i32 %124, %4
%151 = icmp sgt i32 %150, %3
%152 = select i1 %151, i32 %3, i32 %150
%153 = icmp slt i32 %146, 0
br i1 %153, label %154, label %164
154: ; preds = %141
%155 = icmp slt i32 %124, %152
br i1 %155, label %156, label %275
156: ; preds = %154
%157 = trunc i32 %123 to i8
%158 = sext i32 %124 to i64
%159 = getelementptr i8, i8* %2, i64 %158
%160 = xor i32 %124, -1
%161 = add i32 %152, %160
%162 = zext i32 %161 to i64
%163 = add nuw nsw i64 %162, 1
br label %275
164: ; preds = %141
%165 = icmp eq i32 %146, 6
%166 = icmp slt i32 %124, %152
br i1 %165, label %171, label %167
167: ; preds = %164
br i1 %166, label %168, label %275
168: ; preds = %167
%169 = sext i32 %124 to i64
%170 = sext i32 %152 to i64
br label %214
171: ; preds = %164
br i1 %166, label %172, label %275
172: ; preds = %171
%173 = sub nsw i32 8, %142
%174 = icmp slt i32 %142, 1
%175 = icmp eq i32 %142, 0
%176 = sext i32 %124 to i64
%177 = sext i32 %152 to i64
br label %178
178: ; preds = %172, %200
%179 = phi i64 [ %176, %172 ], [ %212, %200 ]
%180 = phi i8* [ %144, %172 ], [ %203, %200 ]
%181 = phi i32 [ %123, %172 ], [ %211, %200 ]
%182 = phi i32 [ %149, %172 ], [ %201, %200 ]
%183 = shl i32 %182, %173
br i1 %174, label %184, label %189
184: ; preds = %178
%185 = getelementptr inbounds i8, i8* %180, i64 1
%186 = load i8, i8* %180
%187 = zext i8 %186 to i32
%188 = or i32 %183, %187
br label %189
189: ; preds = %184, %178
%190 = phi i32 [ 8, %184 ], [ %142, %178 ]
%191 = phi i32 [ %188, %184 ], [ %183, %178 ]
%192 = phi i8* [ %185, %184 ], [ %180, %178 ]
br i1 %175, label %200, label %193
193: ; preds = %189
%194 = getelementptr inbounds i8, i8* %192, i64 1
%195 = load i8, i8* %192
%196 = zext i8 %195 to i32
%197 = lshr i32 %196, %190
%198 = or i32 %197, %191
%199 = and i32 %196, %148
br label %200
200: ; preds = %189, %193
%201 = phi i32 [ %199, %193 ], [ 0, %189 ]
%202 = phi i32 [ %198, %193 ], [ %191, %189 ]
%203 = phi i8* [ %194, %193 ], [ %192, %189 ]
%204 = lshr i32 %202, 1
%205 = and i32 %202, 1
%206 = sub nsw i32 0, %205
%207 = xor i32 %204, %206
%208 = add i32 %207, %181
%209 = trunc i32 %208 to i8
%210 = getelementptr inbounds i8, i8* %2, i64 %179
store i8 %209, i8* %210
%211 = and i32 %208, 255
%212 = add nsw i64 %179, 1
%213 = icmp eq i64 %212, %177
br i1 %213, label %275, label %178
214: ; preds = %168, %255
%215 = phi i64 [ %169, %168 ], [ %273, %255 ]
%216 = phi i8* [ %144, %168 ], [ %258, %255 ]
%217 = phi i32 [ %123, %168 ], [ %272, %255 ]
%218 = phi i32 [ %149, %168 ], [ %264, %255 ]
%219 = phi i32 [ %142, %168 ], [ %256, %255 ]
%220 = icmp eq i32 %218, 0
br i1 %220, label %221, label %230
221: ; preds = %214, %221
%222 = phi i8* [ %225, %221 ], [ %216, %214 ]
%223 = phi i32 [ %224, %221 ], [ %219, %214 ]
%224 = add nsw i32 %223, 8
%225 = getelementptr inbounds i8, i8* %222, i64 1
%226 = load i8, i8* %222
%227 = icmp eq i8 %226, 0
br i1 %227, label %221, label %228
228: ; preds = %221
%229 = zext i8 %226 to i32
br label %230
230: ; preds = %228, %214
%231 = phi i32 [ %224, %228 ], [ %219, %214 ]
%232 = phi i32 [ %229, %228 ], [ %218, %214 ]
%233 = phi i8* [ %225, %228 ], [ %216, %214 ]
%234 = zext i32 %232 to i64
%235 = getelementptr inbounds i32, i32* %110, i64 %234
%236 = load i32, i32* %235
%237 = sub nsw i32 %231, %236
%238 = xor i32 %237, -1
%239 = add i32 %231, %238
%240 = shl nuw i32 1, %239
%241 = xor i32 %240, %232
%242 = sub nsw i32 %239, %146
%243 = icmp slt i32 %242, 0
br i1 %243, label %244, label %255
244: ; preds = %230, %244
%245 = phi i8* [ %249, %244 ], [ %233, %230 ]
%246 = phi i32 [ %252, %244 ], [ %241, %230 ]
%247 = phi i32 [ %253, %244 ], [ %242, %230 ]
%248 = shl i32 %246, 8
%249 = getelementptr inbounds i8, i8* %245, i64 1
%250 = load i8, i8* %245
%251 = zext i8 %250 to i32
%252 = or i32 %248, %251
%253 = add nsw i32 %247, 8
%254 = icmp ult i32 %247, -8
br i1 %254, label %244, label %255
255: ; preds = %244, %230
%256 = phi i32 [ %242, %230 ], [ %253, %244 ]
%257 = phi i32 [ %241, %230 ], [ %252, %244 ]
%258 = phi i8* [ %233, %230 ], [ %249, %244 ]
%259 = shl i32 %237, %146
%260 = lshr i32 %257, %256
%261 = or i32 %260, %259
%262 = shl nsw i32 -1, %256
%263 = xor i32 %262, -1
%264 = and i32 %257, %263
%265 = lshr i32 %261, 1
%266 = and i32 %261, 1
%267 = sub nsw i32 0, %266
%268 = xor i32 %265, %267
%269 = add i32 %268, %217
%270 = trunc i32 %269 to i8
%271 = getelementptr inbounds i8, i8* %2, i64 %215
store i8 %270, i8* %271
%272 = and i32 %269, 255
%273 = add nsw i64 %215, 1
%274 = icmp eq i64 %273, %170
br i1 %274, label %275, label %214
275: ; preds = %255, %200, %156, %167, %171, %154
%276 = phi i32 [ %142, %154 ], [ %142, %171 ], [ %142, %167 ], [ %142, %156 ], [ %142, %200 ], [ %256, %255 ]
%277 = phi i32 [ %149, %154 ], [ %149, %171 ], [ %149, %167 ], [ %149, %156 ], [ %201, %200 ], [ %264, %255 ]
%278 = phi i32 [ %123, %154 ], [ %123, %171 ], [ %123, %167 ], [ %123, %156 ], [ %211, %200 ], [ %272, %255 ]
%279 = phi i32 [ %124, %154 ], [ %124, %171 ], [ %124, %167 ], [ %152, %156 ], [ %152, %200 ], [ %152, %255 ]
%280 = phi i8* [ %144, %154 ], [ %144, %171 ], [ %144, %167 ], [ %144, %156 ], [ %203, %200 ], [ %258, %255 ]
%281 = icmp ugt i8* %280, %116
br i1 %281, label %284, label %120
282: ; preds = %120
%283 = icmp ult i8* %125, %116
br i1 %283, label %284, label %288
284: ; preds = %275, %282, %8
%285 = phi i8* [ getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), %8 ], [ getelementptr inbounds ([64 x i8], [64 x i8]* @.str.2, i64 0, i64 0), %282 ], [ getelementptr inbounds ([55 x i8], [55 x i8]* @.str.1, i64 0, i64 0), %275 ]
%286 = phi i32 [ 1, %8 ], [ 0, %282 ], [ 1, %275 ]
%287 = tail call i32 @ffpmsg(i8* %285)
br label %288
288: ; preds = %284, %282
%289 = phi i32 [ 0, %282 ], [ %286, %284 ]
ret i32 %289
}