#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 const CPK_get_next_bits(unsigned char *, int *, unsigned char *, int *,
                            int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
int CPK_uncompress(unsigned char *infile, int input_size,
                   unsigned char *output_buffer, int uncompressed_size) {
  if (uncompressed_size < 0x100)
    return (-1);
  uncompressed_size -= 0x100;
  const int input_end = input_size - 0x100 - 1;
  int input_offset = input_end;
  const int output_end = 0x100 + uncompressed_size - 1;
  unsigned char bit_pool = 0;
  int bits_left = 0;
  int bytes_output = 0;
  int i;
  if (input_size < 0x100)
    return (-1);
  memcpy(output_buffer, infile + input_size - 0x100, 0x100);
  while (bytes_output < uncompressed_size) {
    if (input_offset < 0)
      break;
    if (CPK_get_next_bits(infile, &input_offset, &bit_pool, &bits_left, 1)) {
      int backreference_offset =
          output_end - bytes_output +
          CPK_get_next_bits(infile, &input_offset, &bit_pool, &bits_left, 13) +
          3;
      int backreference_length = 3;
      enum { vle_levels = 4 };
      int vle_lens[vle_levels] = {2, 3, 5, 8};
      int vle_level;
      for (vle_level = 0; vle_level < vle_levels; vle_level++) {
        int this_level = CPK_get_next_bits(infile, &input_offset, &bit_pool,
                                           &bits_left, vle_lens[vle_level]);
        backreference_length += this_level;
        if (this_level != ((1 << vle_lens[vle_level]) - 1))
          break;
      }
      if (vle_level == vle_levels) {
        int this_level;
        do {
          this_level = CPK_get_next_bits(infile, &input_offset, &bit_pool,
                                         &bits_left, 8);
          backreference_length += this_level;
        } while (this_level == 255);
      }
      for (i = 0; i < backreference_length; i++) {
        output_buffer[output_end - bytes_output] =
            output_buffer[backreference_offset--];
        bytes_output++;
      }
    } else {
      output_buffer[output_end - bytes_output] =
          CPK_get_next_bits(infile, &input_offset, &bit_pool, &bits_left, 8);
      bytes_output++;
    }
  }
  return 0x100 + bytes_output;
}


x86 assembly (clang, -O0):
<CPK_uncompress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
cmpl   $0x100,-0x24(%rbp)
jge    114f <CPK_uncompress+0x2f>
movl   $0xffffffff,-0x4(%rbp)
jmp    13a8 <CPK_uncompress+0x288>
mov    -0x24(%rbp),%eax
sub    $0x100,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x100,%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x100,%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
movb   $0x0,-0x31(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x100,-0x14(%rbp)
jge    11a7 <CPK_uncompress+0x87>
movl   $0xffffffff,-0x4(%rbp)
jmp    13a8 <CPK_uncompress+0x288>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
add    $0xffffffffffffff00,%rsi
mov    $0x100,%edx
call   1040 <memcpy@plt>
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    139d <CPK_uncompress+0x27d>
cmpl   $0x0,-0x2c(%rbp)
jge    11e2 <CPK_uncompress+0xc2>
jmp    139d <CPK_uncompress+0x27d>
mov    -0x10(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
lea    -0x31(%rbp),%rdx
lea    -0x38(%rbp),%rcx
mov    $0x1,%r8d
call   1030 <CPK_get_next_bits@plt>
cmp    $0x0,%eax
je     1362 <CPK_uncompress+0x242>
mov    -0x30(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
lea    -0x31(%rbp),%rdx
lea    -0x38(%rbp),%rcx
mov    $0xd,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x44(%rbp)
movl   $0x3,-0x48(%rbp)
mov    0xdbb(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xdb8(%rip),%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    12c6 <CPK_uncompress+0x1a6>
mov    -0x10(%rbp),%rdi
movslq -0x64(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%r8d
lea    -0x2c(%rbp),%rsi
lea    -0x31(%rbp),%rdx
lea    -0x38(%rbp),%rcx
call   1030 <CPK_get_next_bits@plt>
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x68(%rbp),%eax
movslq -0x64(%rbp),%rcx
mov    -0x60(%rbp,%rcx,4),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     12b3 <CPK_uncompress+0x193>
jmp    12c6 <CPK_uncompress+0x1a6>
jmp    12b8 <CPK_uncompress+0x198>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    125b <CPK_uncompress+0x13b>
cmpl   $0x4,-0x64(%rbp)
jne    130e <CPK_uncompress+0x1ee>
jmp    12d5 <CPK_uncompress+0x1b5>
mov    -0x10(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
lea    -0x31(%rbp),%rdx
lea    -0x38(%rbp),%rcx
mov    $0x8,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0xff,-0x6c(%rbp)
je     12d5 <CPK_uncompress+0x1b5>
jmp    130e <CPK_uncompress+0x1ee>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    135d <CPK_uncompress+0x23d>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1315 <CPK_uncompress+0x1f5>
jmp    1398 <CPK_uncompress+0x278>
mov    -0x10(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
lea    -0x31(%rbp),%rdx
lea    -0x38(%rbp),%rcx
mov    $0x8,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c7 <CPK_uncompress+0xa7>
mov    -0x3c(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CPK_uncompress>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    $0xffffffff,%r14d
cmp    $0x100,%ecx
jl     1573 <CPK_uncompress+0x453>
mov    %esi,%ebp
mov    %rdx,0x10(%rsp)
lea    -0x101(%rbp),%eax
mov    %eax,0x8(%rsp)
movb   $0x0,0x7(%rsp)
movl   $0x0,0xc(%rsp)
mov    $0xffffffff,%r14d
cmp    $0x100,%esi
jl     1573 <CPK_uncompress+0x453>
mov    %ecx,%r15d
mov    %rdi,%r12
mov    %ebp,%eax
lea    (%rdi,%rax,1),%rsi
add    $0xffffffffffffff00,%rsi
mov    0x10(%rsp),%rdi
mov    $0x100,%edx
call   1040 <memcpy@plt>
xor    %r14d,%r14d
cmp    $0x101,%r15d
jb     156c <CPK_uncompress+0x44c>
cmp    $0x100,%ebp
je     156c <CPK_uncompress+0x44c>
lea    -0x100(%r15),%eax
mov    %eax,0x34(%rsp)
lea    -0x1(%r15),%eax
add    $0x2,%r15d
mov    %eax,0x2c(%rsp)
mov    %eax,%eax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rax,1),%rcx
mov    %rcx,0x20(%rsp)
lea    0x1(%rdx,%rax,1),%rcx
mov    %rcx,0x50(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0x58(%rsp)
mov    %rax,0x60(%rsp)
lea    -0xf(%rdx,%rax,1),%rax
mov    %rax,0x40(%rsp)
lea    -0xf(%rdx),%rax
mov    %rax,0x38(%rsp)
xor    %r14d,%r14d
lea    0x8(%rsp),%r13
lea    0x7(%rsp),%rbp
lea    0xc(%rsp),%rbx
mov    %r15,0x18(%rsp)
mov    %r12,0x48(%rsp)
nopl   0x0(%rax)
mov    %r12,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    $0x1,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    %r12,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
test   %eax,%eax
je     1340 <CPK_uncompress+0x220>
mov    $0xd,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    %eax,0x30(%rsp)
mov    %r12,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    $0x2,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    %r13,%r15
lea    0x3(%rax),%r13d
cmp    $0x3,%eax
jne    1330 <CPK_uncompress+0x210>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    $0x3,%r8d
call   1030 <CPK_get_next_bits@plt>
add    %eax,%r13d
cmp    $0x7,%eax
jne    1330 <CPK_uncompress+0x210>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    $0x5,%r8d
call   1030 <CPK_get_next_bits@plt>
add    %eax,%r13d
cmp    $0x1f,%eax
jne    1366 <CPK_uncompress+0x246>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    $0x8,%r8d
call   1030 <CPK_get_next_bits@plt>
add    %eax,%r13d
cmp    $0xff,%eax
jne    142d <CPK_uncompress+0x30d>
mov    0x18(%rsp),%r15
mov    0x48(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rdi
lea    0x8(%rsp),%rsi
lea    0x7(%rsp),%rdx
lea    0xc(%rsp),%rcx
mov    $0x8,%r8d
call   1030 <CPK_get_next_bits@plt>
add    %eax,%r13d
cmp    $0xff,%eax
je     1300 <CPK_uncompress+0x1e0>
jmp    1370 <CPK_uncompress+0x250>
nopl   0x0(%rax)
mov    0x18(%rsp),%r15
test   %r13d,%r13d
jg     1379 <CPK_uncompress+0x259>
jmp    154b <CPK_uncompress+0x42b>
nop
mov    $0x8,%r8d
call   1030 <CPK_get_next_bits@plt>
mov    0x2c(%rsp),%ecx
sub    %r14d,%ecx
movslq %ecx,%rcx
mov    0x10(%rsp),%rdx
mov    %al,(%rdx,%rcx,1)
add    $0x1,%r14d
jmp    155a <CPK_uncompress+0x43a>
mov    0x18(%rsp),%r15
nopl   0x0(%rax,%rax,1)
test   %r13d,%r13d
jle    154b <CPK_uncompress+0x42b>
mov    %r15d,%eax
sub    %r14d,%eax
add    0x30(%rsp),%eax
cltq
movslq %r14d,%r14
lea    -0x1(%r13),%r8d
xor    %ecx,%ecx
cmp    $0xf,%r8d
jb     14e0 <CPK_uncompress+0x3c0>
mov    0x20(%rsp),%rdx
sub    %r14,%rdx
mov    %rdx,%rsi
sub    %r8,%rsi
cmp    %rdx,%rsi
ja     14e0 <CPK_uncompress+0x3c0>
mov    0x10(%rsp),%rdx
add    %rax,%rdx
mov    %rdx,%rsi
sub    %r8,%rsi
cmp    %rdx,%rsi
ja     14e0 <CPK_uncompress+0x3c0>
mov    0x20(%rsp),%rsi
sub    %r14,%rsi
sub    %r8,%rsi
mov    0x58(%rsp),%rdx
add    %rax,%rdx
cmp    %rdx,%rsi
jae    13fa <CPK_uncompress+0x2da>
mov    0x50(%rsp),%rdx
sub    %r14,%rdx
mov    %rax,%rsi
sub    %r8,%rsi
add    0x10(%rsp),%rsi
cmp    %rdx,%rsi
jb     14e0 <CPK_uncompress+0x3c0>
add    $0x1,%r8
mov    %r8,%rcx
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r9d
and    $0x3,%r9d
cmp    $0x30,%rdx
jae    1445 <CPK_uncompress+0x325>
xor    %edi,%edi
test   %r9,%r9
jne    1498 <CPK_uncompress+0x378>
jmp    14d4 <CPK_uncompress+0x3b4>
mov    0x18(%rsp),%r15
mov    0x48(%rsp),%r12
test   %r13d,%r13d
jg     1379 <CPK_uncompress+0x259>
jmp    154b <CPK_uncompress+0x42b>
mov    %r14,%rbx
neg    %rbx
and    $0xfffffffffffffffc,%rsi
add    0x40(%rsp),%rbx
mov    0x38(%rsp),%rdx
add    %rax,%rdx
xor    %edi,%edi
xchg   %ax,%ax
movups (%rdx,%rdi,1),%xmm0
movups %xmm0,(%rbx,%rdi,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups %xmm0,-0x10(%rbx,%rdi,1)
movups -0x20(%rdx,%rdi,1),%xmm0
movups %xmm0,-0x20(%rbx,%rdi,1)
movups -0x30(%rdx,%rdi,1),%xmm0
movups %xmm0,-0x30(%rbx,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1460 <CPK_uncompress+0x340>
neg    %rdi
test   %r9,%r9
je     14d4 <CPK_uncompress+0x3b4>
mov    %rax,%rdx
sub    %rdi,%rdx
add    0x38(%rsp),%rdx
add    %r14,%rdi
mov    0x40(%rsp),%rsi
sub    %rdi,%rsi
shl    $0x4,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdx,%rdi,1),%xmm0
movups %xmm0,(%rsi,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r9,%rbp
add    %rdi,%rbp
jne    14c0 <CPK_uncompress+0x3a0>
add    %rcx,%r14
cmp    %rcx,%r8
je     154b <CPK_uncompress+0x42b>
sub    %rcx,%rax
nop
mov    %r13d,%esi
sub    %ecx,%esi
lea    0x1(%rcx),%edx
test   $0x1,%sil
je     150b <CPK_uncompress+0x3eb>
mov    0x10(%rsp),%rdi
mov    (%rdi,%rax,1),%cl
add    $0xffffffffffffffff,%rax
mov    0x60(%rsp),%rsi
sub    %r14,%rsi
mov    %cl,(%rdi,%rsi,1)
add    $0x1,%r14
mov    %edx,%ecx
cmp    %edx,%r13d
je     154b <CPK_uncompress+0x42b>
mov    0x20(%rsp),%rdx
sub    %r14,%rdx
add    0x10(%rsp),%rax
sub    %r13d,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rax,%rsi,1),%ebx
mov    %bl,(%rdx,%rsi,1)
movzbl -0x1(%rax,%rsi,1),%ebx
mov    %bl,-0x1(%rdx,%rsi,1)
add    $0xfffffffffffffffe,%rsi
cmp    %esi,%ecx
jne    1530 <CPK_uncompress+0x410>
sub    %rsi,%r14
lea    0x8(%rsp),%r13
lea    0x7(%rsp),%rbp
lea    0xc(%rsp),%rbx
cmp    0x34(%rsp),%r14d
jge    156c <CPK_uncompress+0x44c>
cmpl   $0x0,0x8(%rsp)
jns    1220 <CPK_uncompress+0x100>
add    $0x100,%r14d
mov    %r14d,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.CPK_uncompress.vle_lens = [4 x i32] [i32 2, i32 3, i32 5, i32 8]
define i32 @CPK_uncompress(i8* %0, i32 %1, i8* %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca [4 x i32]
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
%23 = load i32, i32* %9
%24 = icmp slt i32 %23, 256
br i1 %24, label %25, label %26
25: ; preds = %4
store i32 -1, i32* %5
br label %148
26: ; preds = %4
%27 = load i32, i32* %9
%28 = sub nsw i32 %27, 256
store i32 %28, i32* %9
%29 = load i32, i32* %7
%30 = sub nsw i32 %29, 256
%31 = sub nsw i32 %30, 1
store i32 %31, i32* %10
%32 = load i32, i32* %10
store i32 %32, i32* %11
%33 = load i32, i32* %9
%34 = add nsw i32 256, %33
%35 = sub nsw i32 %34, 1
store i32 %35, i32* %12
store i8 0, i8* %13
store i32 0, i32* %14
store i32 0, i32* %15
%36 = load i32, i32* %7
%37 = icmp slt i32 %36, 256
br i1 %37, label %38, label %39
38: ; preds = %26
store i32 -1, i32* %5
br label %148
39: ; preds = %26
%40 = load i8*, i8** %8
%41 = load i8*, i8** %6
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = getelementptr inbounds i8, i8* %44, i64 -256
%46 = call i32 @memcpy(i8* %40, i8* %45, i32 256)
br label %47
47: ; preds = %144, %39
%48 = load i32, i32* %15
%49 = load i32, i32* %9
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %145
51: ; preds = %47
%52 = load i32, i32* %11
%53 = icmp slt i32 %52, 0
br i1 %53, label %54, label %55
54: ; preds = %51
br label %145
55: ; preds = %51
%56 = load i8*, i8** %6
%57 = call i32 @CPK_get_next_bits(i8* %56, i32* %11, i8* %13, i32* %14, i32 1)
%58 = icmp ne i32 %57, 0
br i1 %58, label %59, label %132
59: ; preds = %55
%60 = load i32, i32* %12
%61 = load i32, i32* %15
%62 = sub nsw i32 %60, %61
%63 = load i8*, i8** %6
%64 = call i32 @CPK_get_next_bits(i8* %63, i32* %11, i8* %13, i32* %14, i32 13)
%65 = add nsw i32 %62, %64
%66 = add nsw i32 %65, 3
store i32 %66, i32* %17
store i32 3, i32* %18
%67 = bitcast [4 x i32]* %19 to i8*
store i32 0, i32* %20
br label %68
68: ; preds = %91, %59
%69 = load i32, i32* %20
%70 = icmp slt i32 %69, 4
br i1 %70, label %71, label %94
71: ; preds = %68
%72 = load i8*, i8** %6
%73 = load i32, i32* %20
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [4 x i32], [4 x i32]* %19, i64 0, i64 %74
%76 = load i32, i32* %75
%77 = call i32 @CPK_get_next_bits(i8* %72, i32* %11, i8* %13, i32* %14, i32 %76)
store i32 %77, i32* %21
%78 = load i32, i32* %21
%79 = load i32, i32* %18
%80 = add nsw i32 %79, %78
store i32 %80, i32* %18
%81 = load i32, i32* %21
%82 = load i32, i32* %20
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [4 x i32], [4 x i32]* %19, i64 0, i64 %83
%85 = load i32, i32* %84
%86 = shl i32 1, %85
%87 = sub nsw i32 %86, 1
%88 = icmp ne i32 %81, %87
br i1 %88, label %89, label %90
89: ; preds = %71
br label %94
90: ; preds = %71
br label %91
91: ; preds = %90
%92 = load i32, i32* %20
%93 = add nsw i32 %92, 1
store i32 %93, i32* %20
br label %68
94: ; preds = %89, %68
%95 = load i32, i32* %20
%96 = icmp eq i32 %95, 4
br i1 %96, label %97, label %108
97: ; preds = %94
br label %98
98: ; preds = %104, %97
%99 = load i8*, i8** %6
%100 = call i32 @CPK_get_next_bits(i8* %99, i32* %11, i8* %13, i32* %14, i32 8)
store i32 %100, i32* %22
%101 = load i32, i32* %22
%102 = load i32, i32* %18
%103 = add nsw i32 %102, %101
store i32 %103, i32* %18
br label %104
104: ; preds = %98
%105 = load i32, i32* %22
%106 = icmp eq i32 %105, 255
br i1 %106, label %98, label %107
107: ; preds = %104
br label %108
108: ; preds = %107, %94
store i32 0, i32* %16
br label %109
109: ; preds = %128, %108
%110 = load i32, i32* %16
%111 = load i32, i32* %18
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %131
113: ; preds = %109
%114 = load i8*, i8** %8
%115 = load i32, i32* %17
%116 = add nsw i32 %115, -1
store i32 %116, i32* %17
%117 = sext i32 %115 to i64
%118 = getelementptr inbounds i8, i8* %114, i64 %117
%119 = load i8, i8* %118
%120 = load i8*, i8** %8
%121 = load i32, i32* %12
%122 = load i32, i32* %15
%123 = sub nsw i32 %121, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i8, i8* %120, i64 %124
store i8 %119, i8* %125
%126 = load i32, i32* %15
%127 = add nsw i32 %126, 1
store i32 %127, i32* %15
br label %128
128: ; preds = %113
%129 = load i32, i32* %16
%130 = add nsw i32 %129, 1
store i32 %130, i32* %16
br label %109
131: ; preds = %109
br label %144
132: ; preds = %55
%133 = load i8*, i8** %6
%134 = call i32 @CPK_get_next_bits(i8* %133, i32* %11, i8* %13, i32* %14, i32 8)
%135 = trunc i32 %134 to i8
%136 = load i8*, i8** %8
%137 = load i32, i32* %12
%138 = load i32, i32* %15
%139 = sub nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8, i8* %136, i64 %140
store i8 %135, i8* %141
%142 = load i32, i32* %15
%143 = add nsw i32 %142, 1
store i32 %143, i32* %15
br label %144
144: ; preds = %132, %131
br label %47
145: ; preds = %54, %47
%146 = load i32, i32* %15
%147 = add nsw i32 256, %146
store i32 %147, i32* %5
br label %148
148: ; preds = %145, %38, %25
%149 = load i32, i32* %5
ret i32 %149
}

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