#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*/ lz77_memcpy(unsigned char *, int, unsigned char *, int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ printf(char *, unsigned char);
int lz77_inflate(unsigned char *src, int len, unsigned char *dst, int dst_len,
                 unsigned char **sd) {
  int type = 0;
  unsigned char *s = src, *d = dst;
  unsigned char *de = dst + dst_len;
  unsigned char *se = src + len - 1;
  int u_i = 0;
  if (!src || len < 4 || !dst)
    return -1;
  switch (*s++) {
  case (0xF0):
    while (s < se) {
      u_i = 0;
      type = *s++;
      while (u_i++ < 8 && s < se) {
        if (type & 0x01) {
          int l = (s[0] & 0xF0) >> 4;
          int bd = (s[0] & 0x0F) << 8;
          bd |= s[1];
          bd &= 0xFFF;
          l = ({
            static int len_table[1 << ((4))] = {3,  4,  5,  6,  7,  8,  9,  10,
                                                11, 12, 13, 14, 15, 16, 32, 64};
            len_table[l];
          });
          s += 2;
          if (bd)
            d += lz77_memcpy(d - bd, l, d, (int)(de - d));
          else {
            ;
            goto inflate_end;
          }
        } else {
          *d++ = *s++;
        }
        type >>= 1;
      }
    }
    break;
  case (0x0F): {
    int l = s[1] | (s[2] << 8);
    s += 3;
    l = dst_len > (l) ? (l) : dst_len;
    memcpy(d, s, l);
    d += l;
    s += l;
    ;
  } break;
  default:
    printf("error compress method: %02x!\n", s[-1]);
    break;
  };
inflate_end:;
  if (sd)
    *sd = s;
  return (d - dst);
}


x86 assembly (clang, -O0):
<lz77_inflate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     11ad <lz77_inflate+0x7d>
cmpl   $0x4,-0x14(%rbp)
jl     11ad <lz77_inflate+0x7d>
cmpq   $0x0,-0x20(%rbp)
jne    11b9 <lz77_inflate+0x89>
movl   $0xffffffff,-0x4(%rbp)
jmp    1409 <lz77_inflate+0x2d9>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x70(%rbp)
sub    $0xf,%eax
je     134e <lz77_inflate+0x21e>
jmp    11dc <lz77_inflate+0xac>
mov    -0x70(%rbp),%eax
sub    $0xf0,%eax
jne    13cc <lz77_inflate+0x29c>
jmp    11ef <lz77_inflate+0xbf>
jmp    11f4 <lz77_inflate+0xc4>
mov    -0x40(%rbp),%rax
cmp    -0x58(%rbp),%rax
jae    1349 <lz77_inflate+0x219>
movl   $0x0,-0x5c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x5c(%rbp),%ecx
mov    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
xor    %eax,%eax
cmp    $0x8,%ecx
mov    %al,-0x71(%rbp)
jge    1245 <lz77_inflate+0x115>
mov    -0x40(%rbp),%rax
cmp    -0x58(%rbp),%rax
setb   %al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    1255 <lz77_inflate+0x125>
jmp    1344 <lz77_inflate+0x214>
mov    -0x34(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1314 <lz77_inflate+0x1e4>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
and    $0xf0,%eax
sar    $0x4,%eax
mov    %eax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
and    $0xf,%eax
shl    $0x8,%eax
mov    %eax,-0x64(%rbp)
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
or     -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
and    $0xfff,%eax
mov    %eax,-0x64(%rbp)
movslq -0x60(%rbp),%rcx
lea    0x2d96(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x0,-0x64(%rbp)
je     130a <lz77_inflate+0x1da>
mov    -0x48(%rbp),%rdi
movslq -0x64(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x60(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%ecx
call   1050 <lz77_memcpy@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    130f <lz77_inflate+0x1df>
jmp    13e5 <lz77_inflate+0x2b5>
jmp    1336 <lz77_inflate+0x206>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x34(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121e <lz77_inflate+0xee>
jmp    11f4 <lz77_inflate+0xc4>
jmp    13e0 <lz77_inflate+0x2b0>
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x40(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jle    1389 <lz77_inflate+0x259>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    138f <lz77_inflate+0x25f>
mov    -0x24(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x6c(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x6c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x6c(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    13e0 <lz77_inflate+0x2b0>
mov    -0x40(%rbp),%rax
lea    0xc29(%rip),%rdi
movzbl -0x1(%rax),%esi
call   1030 <printf@plt>
jmp    13e5 <lz77_inflate+0x2b5>
cmpq   $0x0,-0x30(%rbp)
je     13fb <lz77_inflate+0x2cb>
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lz77_inflate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    $0xffffffff,%ebx
test   %rdi,%rdi
je     1293 <lz77_inflate+0x163>
cmp    $0x4,%esi
jl     1293 <lz77_inflate+0x163>
mov    %rdx,%rbp
test   %rdx,%rdx
je     1293 <lz77_inflate+0x163>
mov    %ecx,%r15d
mov    %rdi,%r12
mov    (%rdi),%al
cmp    $0xf,%al
mov    %rbp,0x10(%rsp)
mov    %r8,0x8(%rsp)
je     123f <lz77_inflate+0x10f>
lea    0x1(%r12),%r14
cmp    $0xf0,%al
jne    126d <lz77_inflate+0x13d>
movslq %r15d,%r13
add    %rbp,%r13
movslq %esi,%rax
add    %rax,%r12
add    $0xffffffffffffffff,%r12
mov    %rbp,%rbx
jmp    11ac <lz77_inflate+0x7c>
nopl   (%rax)
mov    %rbp,%r14
cmp    %r12,%rbp
jae    1282 <lz77_inflate+0x152>
lea    0x1(%r14),%rbp
cmp    %r12,%rbp
jae    11a0 <lz77_inflate+0x70>
movzbl (%r14),%r15d
mov    $0x1,%r14d
nop
test   $0x1,%r15b
jne    11e0 <lz77_inflate+0xb0>
movzbl 0x0(%rbp),%eax
add    $0x1,%rbp
mov    %al,(%rbx)
add    $0x1,%rbx
cmp    $0x7,%r14d
jbe    122e <lz77_inflate+0xfe>
jmp    11a0 <lz77_inflate+0x70>
nopl   0x0(%rax)
movzbl 0x0(%rbp),%eax
movzbl 0x1(%rbp),%edx
mov    %eax,%ecx
and    $0xf,%ecx
shl    $0x8,%rcx
add    $0x2,%rbp
or     %rdx,%rcx
je     1282 <lz77_inflate+0x152>
shr    $0x4,%rax
lea    0xdf7(%rip),%rdx
mov    (%rdx,%rax,4),%esi
mov    %rbx,%rdi
sub    %rcx,%rdi
mov    %r13d,%ecx
sub    %ebx,%ecx
mov    %rbx,%rdx
call   1050 <lz77_memcpy@plt>
cltq
add    %rax,%rbx
cmp    $0x7,%r14d
ja     11a0 <lz77_inflate+0x70>
shr    %r15d
add    $0x1,%r14d
cmp    %r12,%rbp
jb     11c0 <lz77_inflate+0x90>
jmp    11a0 <lz77_inflate+0x70>
movzwl 0x2(%r12),%eax
lea    0x4(%r12),%rsi
cmp    %r15d,%eax
cmovl  %eax,%r15d
mov    %rbp,%rdi
mov    %r15d,%edx
call   1040 <memcpy@plt>
movslq %r15d,%rax
lea    (%rax,%rbp,1),%rbx
lea    (%r12,%rax,1),%rbp
add    $0x4,%rbp
jmp    1282 <lz77_inflate+0x152>
movzbl %al,%esi
lea    0xdc9(%rip),%rdi
call   1030 <printf@plt>
mov    %rbp,%rbx
mov    %r14,%rbp
mov    0x8(%rsp),%rax
test   %rax,%rax
je     128f <lz77_inflate+0x15f>
mov    %rbp,(%rax)
sub    0x10(%rsp),%ebx
mov    %ebx,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@lz77_inflate.len_table = internal global [16 x i32] [i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 32, i32 64]
@.str = [30 x i8] c"error compress method: %02x!\0A\00"
define i32 @lz77_inflate(i8* %0, i32 %1, i8* %2, i32 %3, i8** %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i8**
%12 = alloca i32
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i8** %4, i8*** %11
store i32 0, i32* %12
%22 = load i8*, i8** %7
store i8* %22, i8** %13
%23 = load i8*, i8** %9
store i8* %23, i8** %14
%24 = load i8*, i8** %9
%25 = load i32, i32* %10
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %24, i64 %26
store i8* %27, i8** %15
%28 = load i8*, i8** %7
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
%32 = getelementptr inbounds i8, i8* %31, i64 -1
store i8* %32, i8** %16
store i32 0, i32* %17
%33 = load i8*, i8** %7
%34 = icmp ne i8* %33, null
br i1 %34, label %35, label %41
35: ; preds = %5
%36 = load i32, i32* %8
%37 = icmp slt i32 %36, 4
br i1 %37, label %41, label %38
38: ; preds = %35
%39 = load i8*, i8** %9
%40 = icmp ne i8* %39, null
br i1 %40, label %42, label %41
41: ; preds = %38, %35, %5
store i32 -1, i32* %6
br label %185
42: ; preds = %38
%43 = load i8*, i8** %13
%44 = getelementptr inbounds i8, i8* %43, i32 1
store i8* %44, i8** %13
%45 = load i8, i8* %43
%46 = zext i8 %45 to i32
switch i32 %46, label %166 [
i32 240, label %47
i32 15, label %132
]
47: ; preds = %42
br label %48
48: ; preds = %130, %47
%49 = load i8*, i8** %13
%50 = load i8*, i8** %16
%51 = icmp ult i8* %49, %50
br i1 %51, label %52, label %131
52: ; preds = %48
store i32 0, i32* %17
%53 = load i8*, i8** %13
%54 = getelementptr inbounds i8, i8* %53, i32 1
store i8* %54, i8** %13
%55 = load i8, i8* %53
%56 = zext i8 %55 to i32
store i32 %56, i32* %12
br label %57
57: ; preds = %127, %52
%58 = load i32, i32* %17
%59 = add nsw i32 %58, 1
store i32 %59, i32* %17
%60 = icmp slt i32 %58, 8
br i1 %60, label %61, label %65
61: ; preds = %57
%62 = load i8*, i8** %13
%63 = load i8*, i8** %16
%64 = icmp ult i8* %62, %63
br label %65
65: ; preds = %61, %57
%66 = phi i1 [ false, %57 ], [ %64, %61 ]
br i1 %66, label %67, label %130
67: ; preds = %65
%68 = load i32, i32* %12
%69 = and i32 %68, 1
%70 = icmp ne i32 %69, 0
br i1 %70, label %71, label %121
71: ; preds = %67
%72 = load i8*, i8** %13
%73 = getelementptr inbounds i8, i8* %72, i64 0
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = and i32 %75, 240
%77 = ashr i32 %76, 4
store i32 %77, i32* %18
%78 = load i8*, i8** %13
%79 = getelementptr inbounds i8, i8* %78, i64 0
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = and i32 %81, 15
%83 = shl i32 %82, 8
store i32 %83, i32* %19
%84 = load i8*, i8** %13
%85 = getelementptr inbounds i8, i8* %84, i64 1
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = load i32, i32* %19
%89 = or i32 %88, %87
store i32 %89, i32* %19
%90 = load i32, i32* %19
%91 = and i32 %90, 4095
store i32 %91, i32* %19
%92 = load i32, i32* %18
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [16 x i32], [16 x i32]* @lz77_inflate.len_table, i64 0, i64 %93
%95 = load i32, i32* %94
store i32 %95, i32* %20
%96 = load i32, i32* %20
store i32 %96, i32* %18
%97 = load i8*, i8** %13
%98 = getelementptr inbounds i8, i8* %97, i64 2
store i8* %98, i8** %13
%99 = load i32, i32* %19
%100 = icmp ne i32 %99, 0
br i1 %100, label %101, label %119
101: ; preds = %71
%102 = load i8*, i8** %14
%103 = load i32, i32* %19
%104 = sext i32 %103 to i64
%105 = sub i64 0, %104
%106 = getelementptr inbounds i8, i8* %102, i64 %105
%107 = load i32, i32* %18
%108 = load i8*, i8** %14
%109 = load i8*, i8** %15
%110 = load i8*, i8** %14
%111 = ptrtoint i8* %109 to i64
%112 = ptrtoint i8* %110 to i64
%113 = sub i64 %111, %112
%114 = trunc i64 %113 to i32
%115 = call i32 @lz77_memcpy(i8* %106, i32 %107, i8* %108, i32 %114)
%116 = load i8*, i8** %14
%117 = sext i32 %115 to i64
%118 = getelementptr inbounds i8, i8* %116, i64 %117
store i8* %118, i8** %14
br label %120
119: ; preds = %71
br label %172
120: ; preds = %101
br label %127
121: ; preds = %67
%122 = load i8*, i8** %13
%123 = getelementptr inbounds i8, i8* %122, i32 1
store i8* %123, i8** %13
%124 = load i8, i8* %122
%125 = load i8*, i8** %14
%126 = getelementptr inbounds i8, i8* %125, i32 1
store i8* %126, i8** %14
store i8 %124, i8* %125
br label %127
127: ; preds = %121, %120
%128 = load i32, i32* %12
%129 = ashr i32 %128, 1
store i32 %129, i32* %12
br label %57
130: ; preds = %65
br label %48
131: ; preds = %48
br label %171
132: ; preds = %42
%133 = load i8*, i8** %13
%134 = getelementptr inbounds i8, i8* %133, i64 1
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = load i8*, i8** %13
%138 = getelementptr inbounds i8, i8* %137, i64 2
%139 = load i8, i8* %138
%140 = zext i8 %139 to i32
%141 = shl i32 %140, 8
%142 = or i32 %136, %141
store i32 %142, i32* %21
%143 = load i8*, i8** %13
%144 = getelementptr inbounds i8, i8* %143, i64 3
store i8* %144, i8** %13
%145 = load i32, i32* %10
%146 = load i32, i32* %21
%147 = icmp sgt i32 %145, %146
br i1 %147, label %148, label %150
148: ; preds = %132
%149 = load i32, i32* %21
br label %152
150: ; preds = %132
%151 = load i32, i32* %10
br label %152
152: ; preds = %150, %148
%153 = phi i32 [ %149, %148 ], [ %151, %150 ]
store i32 %153, i32* %21
%154 = load i8*, i8** %14
%155 = load i8*, i8** %13
%156 = load i32, i32* %21
%157 = call i32 @memcpy(i8* %154, i8* %155, i32 %156)
%158 = load i32, i32* %21
%159 = load i8*, i8** %14
%160 = sext i32 %158 to i64
%161 = getelementptr inbounds i8, i8* %159, i64 %160
store i8* %161, i8** %14
%162 = load i32, i32* %21
%163 = load i8*, i8** %13
%164 = sext i32 %162 to i64
%165 = getelementptr inbounds i8, i8* %163, i64 %164
store i8* %165, i8** %13
br label %171
166: ; preds = %42
%167 = load i8*, i8** %13
%168 = getelementptr inbounds i8, i8* %167, i64 -1
%169 = load i8, i8* %168
%170 = call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i8 zeroext %169)
br label %171
171: ; preds = %166, %152, %131
br label %172
172: ; preds = %171, %119
%173 = load i8**, i8*** %11
%174 = icmp ne i8** %173, null
br i1 %174, label %175, label %178
175: ; preds = %172
%176 = load i8*, i8** %13
%177 = load i8**, i8*** %11
store i8* %176, i8** %177
br label %178
178: ; preds = %175, %172
%179 = load i8*, i8** %14
%180 = load i8*, i8** %9
%181 = ptrtoint i8* %179 to i64
%182 = ptrtoint i8* %180 to i64
%183 = sub i64 %181, %182
%184 = trunc i64 %183 to i32
store i32 %184, i32* %6
br label %185
185: ; preds = %178, %41
%186 = load i32, i32* %6
ret i32 %186
}

LLVM IR (-O2):
@lz77_inflate.len_table = internal unnamed_addr constant [16 x i32] [i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 32, i32 64]
@.str = [30 x i8] c"error compress method: %02x!\0A\00"
define i32 @lz77_inflate(i8* %0, i32 %1, i8* %2, i32 %3, i8** writeonly %4) {
%6 = sext i32 %3 to i64
%7 = getelementptr inbounds i8, i8* %2, i64 %6
%8 = sext i32 %1 to i64
%9 = add nsw i64 %8, -1
%10 = getelementptr inbounds i8, i8* %0, i64 %9
%11 = icmp ne i8* %0, null
%12 = icmp sgt i32 %1, 3
%13 = and i1 %11, %12
%14 = icmp ne i8* %2, null
%15 = and i1 %13, %14
br i1 %15, label %16, label %105
16: ; preds = %5
%17 = getelementptr inbounds i8, i8* %0, i64 1
%18 = load i8, i8* %0
switch i8 %18, label %93 [
i8 -16, label %19
i8 15, label %77
]
19: ; preds = %16
%20 = ptrtoint i8* %7 to i64
br label %25
21: ; preds = %69, %25
%22 = phi i8* [ %27, %25 ], [ %70, %69 ]
%23 = phi i8* [ %28, %25 ], [ %71, %69 ]
%24 = icmp ult i8* %23, %10
br i1 %24, label %25, label %95
25: ; preds = %19, %21
%26 = phi i8* [ %17, %19 ], [ %23, %21 ]
%27 = phi i8* [ %2, %19 ], [ %22, %21 ]
%28 = getelementptr inbounds i8, i8* %26, i64 1
%29 = icmp ult i8* %28, %10
br i1 %29, label %30, label %21
30: ; preds = %25
%31 = load i8, i8* %26
%32 = zext i8 %31 to i32
br label %33
33: ; preds = %30, %69
%34 = phi i32 [ %73, %69 ], [ 1, %30 ]
%35 = phi i32 [ %72, %69 ], [ %32, %30 ]
%36 = phi i8* [ %71, %69 ], [ %28, %30 ]
%37 = phi i8* [ %70, %69 ], [ %27, %30 ]
%38 = and i32 %35, 1
%39 = icmp eq i32 %38, 0
br i1 %39, label %65, label %40
40: ; preds = %33
%41 = load i8, i8* %36
%42 = zext i8 %41 to i32
%43 = shl nuw nsw i32 %42, 8
%44 = getelementptr inbounds i8, i8* %36, i64 1
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = and i32 %43, 3840
%48 = or i32 %47, %46
%49 = getelementptr inbounds i8, i8* %36, i64 2
%50 = icmp eq i32 %48, 0
br i1 %50, label %95, label %51
51: ; preds = %40
%52 = lshr i32 %42, 4
%53 = zext i32 %52 to i64
%54 = getelementptr inbounds [16 x i32], [16 x i32]* @lz77_inflate.len_table, i64 0, i64 %53
%55 = load i32, i32* %54
%56 = zext i32 %48 to i64
%57 = sub nsw i64 0, %56
%58 = getelementptr inbounds i8, i8* %37, i64 %57
%59 = ptrtoint i8* %37 to i64
%60 = sub i64 %20, %59
%61 = trunc i64 %60 to i32
%62 = tail call i32 @lz77_memcpy(i8* %58, i32 %55, i8* %37, i32 %61)
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %37, i64 %63
br label %69
65: ; preds = %33
%66 = getelementptr inbounds i8, i8* %36, i64 1
%67 = load i8, i8* %36
%68 = getelementptr inbounds i8, i8* %37, i64 1
store i8 %67, i8* %37
br label %69
69: ; preds = %51, %65
%70 = phi i8* [ %68, %65 ], [ %64, %51 ]
%71 = phi i8* [ %66, %65 ], [ %49, %51 ]
%72 = lshr i32 %35, 1
%73 = add nuw nsw i32 %34, 1
%74 = icmp ult i32 %34, 8
%75 = icmp ult i8* %71, %10
%76 = select i1 %74, i1 %75, i1 false
br i1 %76, label %33, label %21
77: ; preds = %16
%78 = getelementptr inbounds i8, i8* %0, i64 2
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = getelementptr inbounds i8, i8* %0, i64 3
%82 = load i8, i8* %81
%83 = zext i8 %82 to i32
%84 = shl nuw nsw i32 %83, 8
%85 = or i32 %84, %80
%86 = getelementptr inbounds i8, i8* %0, i64 4
%87 = icmp slt i32 %85, %3
%88 = select i1 %87, i32 %85, i32 %3
%89 = tail call i32 @memcpy(i8* %2, i8* %86, i32 %88)
%90 = sext i32 %88 to i64
%91 = getelementptr inbounds i8, i8* %2, i64 %90
%92 = getelementptr inbounds i8, i8* %86, i64 %90
br label %95
93: ; preds = %16
%94 = tail call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i8 zeroext %18)
br label %95
95: ; preds = %21, %40, %77, %93
%96 = phi i8* [ %2, %93 ], [ %91, %77 ], [ %37, %40 ], [ %22, %21 ]
%97 = phi i8* [ %17, %93 ], [ %92, %77 ], [ %49, %40 ], [ %23, %21 ]
%98 = icmp eq i8** %4, null
br i1 %98, label %100, label %99
99: ; preds = %95
store i8* %97, i8** %4
br label %100
100: ; preds = %99, %95
%101 = ptrtoint i8* %96 to i64
%102 = ptrtoint i8* %2 to i64
%103 = sub i64 %101, %102
%104 = trunc i64 %103 to i32
br label %105
105: ; preds = %5, %100
%106 = phi i32 [ %104, %100 ], [ -1, %5 ]
ret i32 %106
}