#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ fwrite(unsigned char *, int, unsigned int,
                          int /*<<< orphan*/ *);
scalar_t__ malloc(unsigned int);
unsigned int min(unsigned int, unsigned int);
int /*<<< orphan*/ printf(char *, ...);
void type_lzw(unsigned int number, FILE *fp, unsigned char *ptr, size_t size) {
  const unsigned char *src;
  unsigned int srcsize;
  unsigned int pos;
  unsigned int arcsize;
  unsigned int dstsize;
  unsigned int arcpos;
  const unsigned char *arc;
  unsigned int apos;
  unsigned int dpos;
  unsigned int bitcnt;
  unsigned int bitdat;
  unsigned int datum;
  unsigned char *dst;
  unsigned int leng;
  src = ptr;
  srcsize = size;
  pos = 0x110 + ((number + 1) * 32);
  if (pos > srcsize) {
    goto lzhsolve_err1;
  }
  arcsize = (((unsigned int)(src + pos - 16)[3]) |
             ((unsigned int)(src + pos - 16)[2] << 8) |
             ((unsigned int)(src + pos - 16)[1] << 16) |
             ((unsigned int)(src + pos - 16)[0] << 24));
  dstsize = (((unsigned int)(src + pos - 12)[3]) |
             ((unsigned int)(src + pos - 12)[2] << 8) |
             ((unsigned int)(src + pos - 12)[1] << 16) |
             ((unsigned int)(src + pos - 12)[0] << 24));
  arcpos = (((unsigned int)(src + pos - 8)[3]) |
            ((unsigned int)(src + pos - 8)[2] << 8) |
            ((unsigned int)(src + pos - 8)[1] << 16) |
            ((unsigned int)(src + pos - 8)[0] << 24));
  if ((arcsize + arcpos) > srcsize) {
    goto lzhsolve_err1;
  }
  arc = src + arcpos;
  dst = (unsigned char *)malloc(dstsize);
  if (dst == NULL) {
    goto lzhsolve_err1;
  }
  printf("* number  : %.x\n", number);
  printf("* arcsize : %.x\n", arcsize);
  printf("* datasize: %.x\n", dstsize);
  printf("* postion : %.x\n", arcpos);
  apos = 0;
  dpos = 0;
  while (dpos < dstsize) {
    bitcnt = 0;
    do {
      bitcnt++;
      if ((apos >> 3) >= arcsize) {
        goto lzhsolve_err2;
      }
      bitdat = (arc[apos >> 3] >> ((~apos) & 7)) & 1;
      apos++;
    } while (bitdat);
    datum = (1 << bitcnt) - 2;
    do {
      bitcnt--;
      if ((apos >> 3) >= arcsize) {
        goto lzhsolve_err2;
      }
      bitdat = (arc[apos >> 3] >> ((~apos) & 7)) & 1;
      apos++;
      datum += bitdat << bitcnt;
    } while (bitcnt);
    if (datum < 0x100) {
      dst[dpos++] = src[datum + 0x10];
    } else {
      bitcnt = 0;
      do {
        bitcnt++;
        if ((apos >> 3) >= arcsize) {
          goto lzhsolve_err2;
        }
        bitdat = (arc[apos >> 3] >> ((~apos) & 7)) & 1;
        apos++;
      } while (bitdat);
      leng = (1 << bitcnt) - 2;
      do {
        bitcnt--;
        if ((apos >> 3) >= arcsize) {
          goto lzhsolve_err2;
        }
        bitdat = (arc[apos >> 3] >> ((~apos) & 7)) & 1;
        apos++;
        leng += bitdat << bitcnt;
      } while (bitcnt);
      datum -= 0x100;
      if (dpos < datum) {
        goto lzhsolve_err2;
      }
      leng = min(leng + 3, dstsize - dpos);
      do {
        dst[dpos] = dst[dpos - datum];
        dpos++;
      } while (--leng);
    }
  }
  printf("* solve succeed.\n");
  fwrite(dst, 1, dstsize, fp);
lzhsolve_err2:
  free(dst);
lzhsolve_err1:
  return;
}


x86 assembly (clang, -O0):
<type_lzw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %eax,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
shl    $0x5,%eax
add    $0x110,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jbe    1198 <type_lzw+0x48>
jmp    1557 <type_lzw+0x407>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
movzbl -0xd(%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0xe(%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0xf(%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0x10(%rcx,%rdx,1),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
movzbl -0x9(%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0xa(%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0xb(%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0xc(%rcx,%rdx,1),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
movzbl -0x5(%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0x6(%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0x7(%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%edx
movzbl -0x8(%rcx,%rdx,1),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jbe    1272 <type_lzw+0x122>
jmp    1557 <type_lzw+0x407>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jne    129c <type_lzw+0x14c>
jmp    1557 <type_lzw+0x407>
mov    -0x4(%rbp),%esi
lea    0xd5a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%esi
lea    0xd5a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x38(%rbp),%esi
lea    0xd5a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0xd5a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x38(%rbp),%eax
jae    152b <type_lzw+0x3db>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
shr    $0x3,%eax
cmp    -0x34(%rbp),%eax
jb     131e <type_lzw+0x1ce>
jmp    154e <type_lzw+0x3fe>
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shr    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x4c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0x7,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x58(%rbp)
jne    1301 <type_lzw+0x1b1>
mov    -0x54(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
shr    $0x3,%eax
cmp    -0x34(%rbp),%eax
jb     137f <type_lzw+0x22f>
jmp    154e <type_lzw+0x3fe>
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shr    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x4c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0x7,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x54(%rbp),%ecx
shl    %cl,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x54(%rbp)
jne    1362 <type_lzw+0x212>
cmpl   $0x100,-0x5c(%rbp)
jae    13f6 <type_lzw+0x2a6>
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x50(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1526 <type_lzw+0x3d6>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
shr    $0x3,%eax
cmp    -0x34(%rbp),%eax
jb     141a <type_lzw+0x2ca>
jmp    154e <type_lzw+0x3fe>
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shr    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x4c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0x7,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x58(%rbp)
jne    13fd <type_lzw+0x2ad>
mov    -0x54(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x2,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
shr    $0x3,%eax
cmp    -0x34(%rbp),%eax
jb     147b <type_lzw+0x32b>
jmp    154e <type_lzw+0x3fe>
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shr    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x4c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0x7,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x54(%rbp),%ecx
shl    %cl,%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x54(%rbp)
jne    145e <type_lzw+0x30e>
mov    -0x5c(%rbp),%eax
sub    $0x100,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jae    14d9 <type_lzw+0x389>
jmp    154e <type_lzw+0x3fe>
mov    -0x6c(%rbp),%edi
add    $0x3,%edi
mov    -0x38(%rbp),%esi
sub    -0x50(%rbp),%esi
call   1050 <min@plt>
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x6c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
cmp    $0x0,%eax
jne    14ed <type_lzw+0x39d>
jmp    1526 <type_lzw+0x3d6>
jmp    12ee <type_lzw+0x19e>
lea    0xb12(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x68(%rbp),%rdi
mov    -0x38(%rbp),%edx
mov    -0x10(%rbp),%rcx
mov    $0x1,%esi
call   1070 <fwrite@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<type_lzw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edi,%eax
shl    $0x5,%eax
add    $0x130,%eax
cmp    %ecx,%eax
ja     15e7 <type_lzw+0x487>
mov    %rdx,%rbp
mov    %eax,%eax
mov    -0x10(%rdx,%rax,1),%edx
bswap  %edx
mov    -0x8(%rbp,%rax,1),%r12d
shl    $0x20,%r12
bswap  %r12
mov    %rdx,0x38(%rsp)
add    %r12d,%edx
cmp    %ecx,%edx
ja     15e7 <type_lzw+0x487>
mov    %rsi,%rbx
mov    %edi,%r14d
mov    -0xc(%rbp,%rax,1),%r13d
bswap  %r13d
mov    %r13d,%edi
call   1070 <malloc@plt>
test   %rax,%rax
je     15e7 <type_lzw+0x487>
mov    %rax,%rcx
lea    0xe30(%rip),%rdi
xor    %r15d,%r15d
mov    %r14d,%esi
xor    %eax,%eax
mov    %rcx,0x10(%rsp)
call   1050 <printf@plt>
lea    0xe28(%rip),%rdi
mov    0x38(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe26(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe26(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%r11
test   %r13d,%r13d
je     15f6 <type_lzw+0x496>
add    %rbp,%r12
lea    0x1(%r11),%r9
xor    %r10d,%r10d
mov    %rbx,0x20(%rsp)
mov    %rbp,0x40(%rsp)
mov    %r13d,0xc(%rsp)
lea    0x2(%r15),%edi
xor    %ecx,%ecx
mov    %r15d,%edx
mov    0x38(%rsp),%r8
nopl   0x0(%rax)
mov    %ecx,%eax
mov    %edi,%esi
lea    (%r15,%rax,1),%ecx
mov    %rcx,%rdi
shr    $0x3,%rdi
cmp    %r8d,%edi
jae    161c <type_lzw+0x4bc>
movzbl (%r12,%rdi,1),%ebp
not    %cl
and    $0x7,%cl
movzbl %cl,%ebx
add    $0x2,%edx
lea    0x1(%rax),%ecx
lea    0x2(%rsi),%edi
bt     %ebx,%ebp
jb     1250 <type_lzw+0xf0>
mov    $0x1,%r13d
shl    %cl,%r13d
add    $0xfffffffe,%r13d
add    %ecx,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15d,%ecx
shr    $0x3,%rcx
cmp    %r8d,%ecx
jae    161c <type_lzw+0x4bc>
mov    %r13d,%r14d
movzbl (%r12,%rcx,1),%ebp
mov    %r15d,%ecx
not    %cl
and    $0x7,%cl
shr    %cl,%ebp
and    $0x1,%ebp
mov    %eax,%ecx
shl    %cl,%ebp
add    $0x1,%r15d
lea    (%r14,%rbp,1),%r13d
add    $0xffffffff,%eax
jb     12a0 <type_lzw+0x140>
cmp    $0x100,%r13d
jae    1311 <type_lzw+0x1b1>
mov    %r13d,%eax
mov    0x40(%rsp),%rbp
mov    0x10(%rax,%rbp,1),%al
mov    %r10d,%ecx
add    $0x1,%r10d
mov    %al,(%r11,%rcx,1)
mov    0x20(%rsp),%rbx
mov    0xc(%rsp),%r13d
mov    %edx,%r15d
cmp    %r10d,%r13d
ja     123e <type_lzw+0xde>
jmp    15f6 <type_lzw+0x496>
xor    %ecx,%ecx
mov    %esi,%r15d
cs nopw 0x0(%rax,%rax,1)
mov    %ecx,%eax
lea    (%rsi,%rax,1),%ecx
mov    %rcx,%rdi
shr    $0x3,%rdi
cmp    %r8d,%edi
jae    161c <type_lzw+0x4bc>
movzbl (%r12,%rdi,1),%edi
not    %cl
and    $0x7,%cl
movzbl %cl,%ebx
add    $0x2,%r15d
lea    0x1(%rax),%ecx
bt     %ebx,%edi
jb     1320 <type_lzw+0x1c0>
mov    $0x1,%edi
shl    %cl,%edi
add    $0xfffffffe,%edi
add    %ecx,%edx
mov    %edx,%ecx
shr    $0x3,%rcx
cmp    %r8d,%ecx
jae    161c <type_lzw+0x4bc>
movzbl (%r12,%rcx,1),%esi
mov    %edx,%ecx
not    %cl
and    $0x7,%cl
shr    %cl,%esi
and    $0x1,%esi
mov    %eax,%ecx
shl    %cl,%esi
add    $0x1,%edx
add    %esi,%edi
add    $0xffffffff,%eax
jb     135a <type_lzw+0x1fa>
lea    -0x100(%r13),%eax
cmp    %eax,%r10d
jb     161c <type_lzw+0x4bc>
mov    %eax,0x2c(%rsp)
mov    %r9,0x18(%rsp)
add    $0x3,%edi
mov    0xc(%rsp),%esi
sub    %r10d,%esi
mov    %r10,%rbx
call   1060 <min@plt>
cmp    $0x20,%eax
jae    13cf <type_lzw+0x26f>
mov    0xc(%rsp),%r13d
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%r9
mov    %rbx,%r10
jmp    1535 <type_lzw+0x3d5>
lea    -0x1(%rax),%ecx
mov    %ebx,%edx
add    %ecx,%edx
mov    0x18(%rsp),%r9
mov    %rbx,%r10
jb     142c <type_lzw+0x2cc>
mov    %r13d,%edx
sub    %r10d,%edx
add    $0xfffffeff,%edx
cmp    %ecx,%edx
mov    0x10(%rsp),%r11
jb     1422 <type_lzw+0x2c2>
mov    %r10d,%edx
lea    (%r11,%rdx,1),%rdi
mov    %r10d,%esi
sub    %r13d,%esi
add    $0x100,%esi
lea    (%rsi,%rcx,1),%rbx
add    %r9,%rbx
cmp    %rbx,%rdi
jae    143b <type_lzw+0x2db>
add    %rcx,%rdx
add    %r9,%rdx
add    %r11,%rsi
cmp    %rdx,%rsi
jae    143b <type_lzw+0x2db>
mov    0xc(%rsp),%r13d
jmp    1535 <type_lzw+0x3d5>
mov    0xc(%rsp),%r13d
mov    0x10(%rsp),%r11
jmp    1535 <type_lzw+0x3d5>
mov    %eax,%r8d
and    $0xffffffe0,%r8d
lea    -0x20(%r8),%ecx
mov    %ecx,%r9d
shr    $0x5,%r9d
add    $0x1,%r9d
test   %ecx,%ecx
mov    0xc(%rsp),%r13d
mov    %r10,0x30(%rsp)
je     14e3 <type_lzw+0x383>
mov    %r15d,0x28(%rsp)
mov    %r11,%rcx
mov    %r9d,%r11d
and    $0xfffffffe,%r11d
lea    0x20(%r10),%r15d
mov    %r10d,%edx
sub    %r14d,%edx
sub    %ebp,%edx
lea    0x120(%rdx),%esi
add    $0x100,%edx
mov    %r10,%rbx
xor    %r10d,%r10d
mov    %ebx,%edi
mov    %edx,%ebx
movups (%rcx,%rbx,1),%xmm0
movups 0x10(%rcx,%rbx,1),%xmm1
mov    %edi,%ebx
movups %xmm0,(%rcx,%rbx,1)
movups %xmm1,0x10(%rcx,%rbx,1)
mov    %esi,%ebx
movups (%rcx,%rbx,1),%xmm0
movups 0x10(%rcx,%rbx,1),%xmm1
mov    %r15d,%ebx
movups %xmm0,(%rcx,%rbx,1)
movups %xmm1,0x10(%rcx,%rbx,1)
add    $0x40,%r15d
add    $0x40,%esi
add    $0xffffffc0,%r10d
add    $0x40,%edx
add    $0x40,%edi
add    $0xfffffffe,%r11d
jne    1492 <type_lzw+0x332>
neg    %r10d
mov    %rcx,%r11
mov    0x28(%rsp),%r15d
jmp    14e6 <type_lzw+0x386>
xor    %r10d,%r10d
test   $0x1,%r9b
je     150e <type_lzw+0x3ae>
add    0x30(%rsp),%r10d
mov    %r10d,%ecx
sub    0x2c(%rsp),%ecx
movups (%r11,%rcx,1),%xmm0
movups 0x10(%r11,%rcx,1),%xmm1
movups %xmm0,(%r11,%r10,1)
movups %xmm1,0x10(%r11,%r10,1)
mov    0x30(%rsp),%r10
add    %r8d,%r10d
cmp    %r8d,%eax
jne    152d <type_lzw+0x3cd>
mov    %r15d,%edx
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%r9
jmp    1300 <type_lzw+0x1a0>
and    $0x1f,%eax
mov    0x18(%rsp),%r9
lea    -0x1(%rax),%r8d
mov    %eax,%edx
and    $0x3,%edx
je     1569 <type_lzw+0x409>
mov    $0x100,%edi
sub    %ebp,%edi
sub    %r14d,%edi
xor    %esi,%esi
lea    (%rdi,%r10,1),%ebx
movzbl (%r11,%rbx,1),%ebx
mov    %r10d,%ecx
mov    %bl,(%r11,%rcx,1)
add    $0x1,%r10d
add    $0x1,%esi
cmp    %esi,%edx
jne    154c <type_lzw+0x3ec>
sub    %esi,%eax
cmp    $0x3,%r8d
jb     15da <type_lzw+0x47a>
mov    %r10d,%ecx
sub    %r14d,%ecx
sub    %ebp,%ecx
xor    %edx,%edx
lea    (%r10,%rdx,1),%esi
lea    (%rcx,%rdx,1),%edi
add    $0x100,%edi
movzbl (%r11,%rdi,1),%ebx
mov    %bl,(%r11,%rsi,1)
lea    0x1(%r10,%rdx,1),%esi
lea    0x101(%rcx,%rdx,1),%edi
movzbl (%r11,%rdi,1),%ebx
mov    %bl,(%r11,%rsi,1)
lea    0x2(%r10,%rdx,1),%esi
lea    0x102(%rcx,%rdx,1),%edi
movzbl (%r11,%rdi,1),%ebx
mov    %bl,(%r11,%rsi,1)
lea    0x3(%r10,%rdx,1),%esi
lea    (%rcx,%rdx,1),%edi
add    $0x103,%edi
movzbl (%r11,%rdi,1),%ebx
mov    %bl,(%r11,%rsi,1)
add    $0x4,%edx
cmp    %edx,%eax
jne    1579 <type_lzw+0x419>
add    %edx,%r10d
mov    %r15d,%edx
mov    0x20(%rsp),%rbx
jmp    1300 <type_lzw+0x1a0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xa47(%rip),%rdi
call   1040 <puts@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %rbx,%rcx
call   1080 <fwrite@plt>
mov    0x10(%rsp),%r11
mov    %r11,%rdi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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