#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 extract_bits_little(unsigned char const **, int *, int *, int);
int /*<<< orphan*/ zlib_extract_huffman_code(unsigned char const **, int *,
                                             int *, int *, int *);
int zlib_read_huffman_codelen(const unsigned char **data, int *bit, int *size,
                              int count, int *hm, int *codelen) {
  int i, j, lit;
  for (i = 0; i < count;) {
    if (*size <= 4)
      return 0;
    if (!zlib_extract_huffman_code(data, bit, size, hm, &lit) || lit > 18)
      return 0;
    if (lit < 16)
      codelen[i++] = lit;
    else if (lit == 16) {
      if (i == 0)
        return 0;
      j = j = 3 + extract_bits_little(data, bit, size, 2);
      if (i + j > count)
        return 0;
      for (; j > 0; i++, j--)
        codelen[i] = codelen[i - 1];
    } else if (lit == 17) {
      j = 3 + extract_bits_little(data, bit, size, 3);
      if (i + j > count)
        return 0;
      for (; j > 0; j--)
        codelen[i++] = 0;
    } else {
      j = 11 + extract_bits_little(data, bit, size, 7);
      if (i + j > count)
        return 0;
      for (; j > 0; j--)
        codelen[i++] = 0;
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<zlib_read_huffman_codelen>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1367 <zlib_read_huffman_codelen+0x247>
mov    -0x20(%rbp),%rax
cmpl   $0x4,(%rax)
jg     116b <zlib_read_huffman_codelen+0x4b>
movl   $0x0,-0x4(%rbp)
jmp    136e <zlib_read_huffman_codelen+0x24e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rcx
lea    -0x44(%rbp),%r8
call   1040 <zlib_extract_huffman_code@plt>
cmp    $0x0,%eax
je     1197 <zlib_read_huffman_codelen+0x77>
cmpl   $0x12,-0x44(%rbp)
jle    11a3 <zlib_read_huffman_codelen+0x83>
movl   $0x0,-0x4(%rbp)
jmp    136e <zlib_read_huffman_codelen+0x24e>
cmpl   $0x10,-0x44(%rbp)
jge    11ca <zlib_read_huffman_codelen+0xaa>
mov    -0x44(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1362 <zlib_read_huffman_codelen+0x242>
cmpl   $0x10,-0x44(%rbp)
jne    126a <zlib_read_huffman_codelen+0x14a>
cmpl   $0x0,-0x3c(%rbp)
jne    11ea <zlib_read_huffman_codelen+0xca>
movl   $0x0,-0x4(%rbp)
jmp    136e <zlib_read_huffman_codelen+0x24e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    $0x2,%ecx
call   1030 <extract_bits_little@plt>
add    $0x3,%eax
mov    %eax,-0x40(%rbp)
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    1224 <zlib_read_huffman_codelen+0x104>
movl   $0x0,-0x4(%rbp)
jmp    136e <zlib_read_huffman_codelen+0x24e>
jmp    1229 <zlib_read_huffman_codelen+0x109>
cmpl   $0x0,-0x40(%rbp)
jle    1265 <zlib_read_huffman_codelen+0x145>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1229 <zlib_read_huffman_codelen+0x109>
jmp    135d <zlib_read_huffman_codelen+0x23d>
cmpl   $0x11,-0x44(%rbp)
jne    12e6 <zlib_read_huffman_codelen+0x1c6>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    $0x3,%ecx
call   1030 <extract_bits_little@plt>
add    $0x3,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    12ab <zlib_read_huffman_codelen+0x18b>
movl   $0x0,-0x4(%rbp)
jmp    136e <zlib_read_huffman_codelen+0x24e>
jmp    12b0 <zlib_read_huffman_codelen+0x190>
cmpl   $0x0,-0x40(%rbp)
jle    12e1 <zlib_read_huffman_codelen+0x1c1>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    12b0 <zlib_read_huffman_codelen+0x190>
jmp    1358 <zlib_read_huffman_codelen+0x238>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    $0x7,%ecx
call   1030 <extract_bits_little@plt>
add    $0xb,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    131d <zlib_read_huffman_codelen+0x1fd>
movl   $0x0,-0x4(%rbp)
jmp    136e <zlib_read_huffman_codelen+0x24e>
jmp    1322 <zlib_read_huffman_codelen+0x202>
cmpl   $0x0,-0x40(%rbp)
jle    1353 <zlib_read_huffman_codelen+0x233>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1322 <zlib_read_huffman_codelen+0x202>
jmp    1358 <zlib_read_huffman_codelen+0x238>
jmp    135d <zlib_read_huffman_codelen+0x23d>
jmp    1362 <zlib_read_huffman_codelen+0x242>
jmp    1146 <zlib_read_huffman_codelen+0x26>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<zlib_read_huffman_codelen>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,0x18(%rsp)
test   %ecx,%ecx
jle    14a6 <zlib_read_huffman_codelen+0x376>
mov    %r9,%rbx
mov    %r8,%rbp
mov    %ecx,%r12d
mov    %rdx,%r14
mov    %rsi,%r15
xor    %r13d,%r13d
mov    %rsi,(%rsp)
mov    %r9,0x10(%rsp)
mov    %r8,0x8(%rsp)
jmp    1183 <zlib_read_huffman_codelen+0x53>
nopl   (%rax)
movslq %r13d,%rcx
add    $0x1,%r13d
mov    %eax,(%rbx,%rcx,4)
cmp    %r12d,%r13d
jge    14a6 <zlib_read_huffman_codelen+0x376>
cmpl   $0x5,(%r14)
jl     14ad <zlib_read_huffman_codelen+0x37d>
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %rbp,%rcx
lea    0x24(%rsp),%r8
call   1050 <zlib_extract_huffman_code@plt>
test   %eax,%eax
je     14ad <zlib_read_huffman_codelen+0x37d>
mov    0x24(%rsp),%eax
cmp    $0x12,%eax
jg     14ad <zlib_read_huffman_codelen+0x37d>
cmp    $0xf,%eax
jle    1170 <zlib_read_huffman_codelen+0x40>
cmp    $0x11,%eax
je     1237 <zlib_read_huffman_codelen+0x107>
cmp    $0x10,%eax
jne    12af <zlib_read_huffman_codelen+0x17f>
test   %r13d,%r13d
je     14ad <zlib_read_huffman_codelen+0x37d>
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    $0x2,%ecx
call   1030 <extract_bits_little@plt>
lea    (%rax,%r13,1),%ecx
add    $0x3,%ecx
cmp    %r12d,%ecx
jg     14ad <zlib_read_huffman_codelen+0x37d>
cmp    $0xfffffffe,%eax
jl     117a <zlib_read_huffman_codelen+0x4a>
movslq %r13d,%rdx
mov    -0x4(%rbx,%rdx,4),%ecx
lea    (%rbx,%rdx,4),%rdx
add    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,(%rdx)
add    $0x4,%rdx
add    $0x1,%r13d
add    $0xffffffff,%eax
cmp    $0x1,%eax
ja     1220 <zlib_read_huffman_codelen+0xf0>
jmp    117a <zlib_read_huffman_codelen+0x4a>
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    $0x3,%ecx
call   1030 <extract_bits_little@plt>
mov    %eax,%r15d
lea    (%r15,%r13,1),%eax
add    $0x3,%eax
cmp    %r12d,%eax
jg     14ad <zlib_read_huffman_codelen+0x37d>
cmp    $0xfffffffe,%r15d
jl     131c <zlib_read_huffman_codelen+0x1ec>
mov    %rbx,%rax
lea    0x3(%r15),%ebx
movslq %r13d,%r13
lea    (%rax,%r13,4),%rdi
test   %ebx,%ebx
mov    $0x1,%ebp
cmovle %ebx,%ebp
mov    %ebx,%eax
sub    %ebp,%eax
lea    0x4(,%rax,4),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
sub    %ebp,%r15d
add    $0x4,%r15d
cmp    $0x4,%r15d
jae    1325 <zlib_read_huffman_codelen+0x1f5>
mov    0x8(%rsp),%rbp
jmp    145c <zlib_read_huffman_codelen+0x32c>
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    $0x7,%ecx
call   1030 <extract_bits_little@plt>
mov    %eax,%r15d
lea    (%r15,%r13,1),%eax
add    $0xb,%eax
cmp    %r12d,%eax
jg     14ad <zlib_read_huffman_codelen+0x37d>
cmp    $0xfffffff6,%r15d
jl     131c <zlib_read_huffman_codelen+0x1ec>
lea    0xb(%r15),%ebp
movslq %r13d,%r13
lea    (%rbx,%r13,4),%rdi
test   %ebp,%ebp
mov    $0x1,%ebx
cmovle %ebp,%ebx
mov    %ebp,%eax
sub    %ebx,%eax
lea    0x4(,%rax,4),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
sub    %ebx,%r15d
add    $0xc,%r15d
cmp    $0x4,%r15d
jae    1354 <zlib_read_huffman_codelen+0x224>
mov    0x10(%rsp),%rbx
jmp    1488 <zlib_read_huffman_codelen+0x358>
mov    (%rsp),%r15
jmp    117a <zlib_read_huffman_codelen+0x4a>
mov    %r15d,%eax
and    $0xfffffffc,%eax
movq   %r13,%xmm0
lea    -0x4(%rax),%esi
mov    %esi,%edx
shr    $0x2,%edx
add    $0x1,%edx
mov    %edx,%ecx
and    $0x7,%ecx
pxor   %xmm1,%xmm1
cmp    $0x1c,%esi
pcmpeqd %xmm2,%xmm2
jae    1386 <zlib_read_huffman_codelen+0x256>
mov    0x8(%rsp),%rbp
jmp    13ad <zlib_read_huffman_codelen+0x27d>
mov    %r15d,%eax
and    $0xfffffffc,%eax
movq   %r13,%xmm0
lea    -0x4(%rax),%esi
mov    %esi,%edx
shr    $0x2,%edx
add    $0x1,%edx
mov    %edx,%ecx
and    $0x7,%ecx
pxor   %xmm1,%xmm1
cmp    $0x1c,%esi
pcmpeqd %xmm2,%xmm2
jae    13f2 <zlib_read_huffman_codelen+0x2c2>
mov    0x10(%rsp),%rbx
jmp    141d <zlib_read_huffman_codelen+0x2ed>
and    $0xfffffff8,%edx
pxor   %xmm1,%xmm1
mov    0x8(%rsp),%rbp
movdqa 0xc66(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
paddq  %xmm3,%xmm0
paddq  %xmm3,%xmm1
add    $0xfffffff8,%edx
jne    13a0 <zlib_read_huffman_codelen+0x270>
test   %ecx,%ecx
je     13cd <zlib_read_huffman_codelen+0x29d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
psubq  %xmm2,%xmm0
psubq  %xmm2,%xmm1
add    $0xffffffff,%ecx
jne    13c0 <zlib_read_huffman_codelen+0x290>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%r13
cmp    %eax,%r15d
jne    145a <zlib_read_huffman_codelen+0x32a>
mov    (%rsp),%r15
mov    0x10(%rsp),%rbx
jmp    117a <zlib_read_huffman_codelen+0x4a>
and    $0xfffffff8,%edx
pxor   %xmm1,%xmm1
mov    0x10(%rsp),%rbx
movdqa 0xbfa(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
paddq  %xmm3,%xmm0
paddq  %xmm3,%xmm1
add    $0xfffffff8,%edx
jne    1410 <zlib_read_huffman_codelen+0x2e0>
test   %ecx,%ecx
je     143d <zlib_read_huffman_codelen+0x30d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
psubq  %xmm2,%xmm0
psubq  %xmm2,%xmm1
add    $0xffffffff,%ecx
jne    1430 <zlib_read_huffman_codelen+0x300>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%r13
cmp    %eax,%r15d
jne    1486 <zlib_read_huffman_codelen+0x356>
mov    (%rsp),%r15
jmp    149c <zlib_read_huffman_codelen+0x36c>
sub    %eax,%ebx
mov    (%rsp),%r15
add    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
add    $0xffffffff,%ebx
cmp    $0x1,%ebx
jg     1470 <zlib_read_huffman_codelen+0x340>
mov    0x10(%rsp),%rbx
jmp    117a <zlib_read_huffman_codelen+0x4a>
sub    %eax,%ebp
mov    (%rsp),%r15
add    $0x1,%ebp
nop
add    $0x1,%r13
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
jg     1490 <zlib_read_huffman_codelen+0x360>
mov    0x8(%rsp),%rbp
jmp    117a <zlib_read_huffman_codelen+0x4a>
mov    $0x1,%eax
jmp    14af <zlib_read_huffman_codelen+0x37f>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @zlib_read_huffman_codelen(i8** %0, i32* %1, i32* %2, i32 %3, i32* %4, i32* nocapture %5) {
%7 = alloca i32
%8 = bitcast i32* %7 to i8*
%9 = icmp sgt i32 %3, 0
br i1 %9, label %10, label %196
10: ; preds = %6
%11 = getelementptr i32, i32* %5, i64 -1
br label %12
12: ; preds = %10, %193
%13 = phi i32 [ %194, %193 ], [ 0, %10 ]
%14 = load i32, i32* %2
%15 = icmp slt i32 %14, 5
br i1 %15, label %196, label %16
16: ; preds = %12
%17 = call i32 @zlib_extract_huffman_code(i8** %0, i32* %1, i32* %2, i32* %4, i32* %7)
%18 = icmp eq i32 %17, 0
%19 = load i32, i32* %7
%20 = icmp sgt i32 %19, 18
%21 = select i1 %18, i1 true, i1 %20
br i1 %21, label %196, label %22
22: ; preds = %16
%23 = icmp slt i32 %19, 16
br i1 %23, label %24, label %28
24: ; preds = %22
%25 = add nsw i32 %13, 1
%26 = sext i32 %13 to i64
%27 = getelementptr inbounds i32, i32* %5, i64 %26
store i32 %19, i32* %27
br label %193
28: ; preds = %22
switch i32 %19, label %117 [
i32 16, label %29
i32 17, label %49
]
29: ; preds = %28
%30 = icmp eq i32 %13, 0
br i1 %30, label %196, label %31
31: ; preds = %29
%32 = call i32 @extract_bits_little(i8** %0, i32* %1, i32* %2, i32 2)
%33 = add nsw i32 %32, 3
%34 = add nsw i32 %33, %13
%35 = icmp sgt i32 %34, %3
br i1 %35, label %196, label %36
36: ; preds = %31
%37 = icmp sgt i32 %32, -3
br i1 %37, label %38, label %193
38: ; preds = %36
%39 = sext i32 %13 to i64
%40 = getelementptr i32, i32* %11, i64 %39
%41 = load i32, i32* %40
br label %42
42: ; preds = %38, %42
%43 = phi i64 [ %39, %38 ], [ %46, %42 ]
%44 = phi i32 [ %33, %38 ], [ %47, %42 ]
%45 = getelementptr inbounds i32, i32* %5, i64 %43
store i32 %41, i32* %45
%46 = add nsw i64 %43, 1
%47 = add nsw i32 %44, -1
%48 = icmp ugt i32 %44, 1
br i1 %48, label %42, label %188
49: ; preds = %28
%50 = call i32 @extract_bits_little(i8** %0, i32* %1, i32* %2, i32 3)
%51 = add i32 %50, 3
%52 = add nsw i32 %51, %13
%53 = icmp sgt i32 %52, %3
br i1 %53, label %196, label %54
54: ; preds = %49
%55 = icmp sgt i32 %50, -3
br i1 %55, label %56, label %193
56: ; preds = %54
%57 = sext i32 %13 to i64
%58 = getelementptr i32, i32* %5, i64 %57
%59 = bitcast i32* %58 to i8*
%60 = call i32 @llvm.smin.i32(i32 %51, i32 1)
%61 = sub i32 %51, %60
%62 = zext i32 %61 to i64
%63 = shl nuw nsw i64 %62, 2
%64 = add nuw nsw i64 %63, 4
%65 = add i32 %50, 4
%66 = call i32 @llvm.smin.i32(i32 %51, i32 1)
%67 = sub i32 %65, %66
%68 = icmp ult i32 %67, 4
br i1 %68, label %108, label %69
69: ; preds = %56
%70 = and i32 %67, -4
%71 = sub i32 %51, %70
%72 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %57, i64 0
%73 = add i32 %70, -4
%74 = lshr exact i32 %73, 2
%75 = add nuw nsw i32 %74, 1
%76 = and i32 %75, 7
%77 = icmp ult i32 %73, 28
br i1 %77, label %88, label %78
78: ; preds = %69
%79 = and i32 %75, 2147483640
br label %80
80: ; preds = %80, %78
%81 = phi <2 x i64> [ %72, %78 ], [ %84, %80 ]
%82 = phi <2 x i64> [ zeroinitializer, %78 ], [ %85, %80 ]
%83 = phi i32 [ 0, %78 ], [ %86, %80 ]
%84 = add <2 x i64> %81, <i64 8, i64 8>
%85 = add <2 x i64> %82, <i64 8, i64 8>
%86 = add i32 %83, 8
%87 = icmp eq i32 %86, %79
br i1 %87, label %88, label %80
88: ; preds = %80, %69
%89 = phi <2 x i64> [ undef, %69 ], [ %84, %80 ]
%90 = phi <2 x i64> [ undef, %69 ], [ %85, %80 ]
%91 = phi <2 x i64> [ %72, %69 ], [ %84, %80 ]
%92 = phi <2 x i64> [ zeroinitializer, %69 ], [ %85, %80 ]
%93 = icmp eq i32 %76, 0
br i1 %93, label %102, label %94
94: ; preds = %88, %94
%95 = phi <2 x i64> [ %98, %94 ], [ %91, %88 ]
%96 = phi <2 x i64> [ %99, %94 ], [ %92, %88 ]
%97 = phi i32 [ %100, %94 ], [ 0, %88 ]
%98 = add <2 x i64> %95, <i64 1, i64 1>
%99 = add <2 x i64> %96, <i64 1, i64 1>
%100 = add i32 %97, 1
%101 = icmp eq i32 %100, %76
br i1 %101, label %102, label %94
102: ; preds = %94, %88
%103 = phi <2 x i64> [ %89, %88 ], [ %98, %94 ]
%104 = phi <2 x i64> [ %90, %88 ], [ %99, %94 ]
%105 = add <2 x i64> %104, %103
%106 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %105)
%107 = icmp eq i32 %67, %70
br i1 %107, label %190, label %108
108: ; preds = %56, %102
%109 = phi i64 [ %57, %56 ], [ %106, %102 ]
%110 = phi i32 [ %51, %56 ], [ %71, %102 ]
br label %111
111: ; preds = %108, %111
%112 = phi i64 [ %114, %111 ], [ %109, %108 ]
%113 = phi i32 [ %115, %111 ], [ %110, %108 ]
%114 = add nsw i64 %112, 1
%115 = add nsw i32 %113, -1
%116 = icmp sgt i32 %113, 1
br i1 %116, label %111, label %190
117: ; preds = %28
%118 = call i32 @extract_bits_little(i8** %0, i32* %1, i32* %2, i32 7)
%119 = add i32 %118, 11
%120 = add nsw i32 %119, %13
%121 = icmp sgt i32 %120, %3
br i1 %121, label %196, label %122
122: ; preds = %117
%123 = icmp sgt i32 %118, -11
br i1 %123, label %124, label %193
124: ; preds = %122
%125 = sext i32 %13 to i64
%126 = getelementptr i32, i32* %5, i64 %125
%127 = bitcast i32* %126 to i8*
%128 = call i32 @llvm.smin.i32(i32 %119, i32 1)
%129 = sub i32 %119, %128
%130 = zext i32 %129 to i64
%131 = shl nuw nsw i64 %130, 2
%132 = add nuw nsw i64 %131, 4
%133 = add i32 %118, 12
%134 = call i32 @llvm.smin.i32(i32 %119, i32 1)
%135 = sub i32 %133, %134
%136 = icmp ult i32 %135, 4
br i1 %136, label %176, label %137
137: ; preds = %124
%138 = and i32 %135, -4
%139 = sub i32 %119, %138
%140 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %125, i64 0
%141 = add i32 %138, -4
%142 = lshr exact i32 %141, 2
%143 = add nuw nsw i32 %142, 1
%144 = and i32 %143, 7
%145 = icmp ult i32 %141, 28
br i1 %145, label %156, label %146
146: ; preds = %137
%147 = and i32 %143, 2147483640
br label %148
148: ; preds = %148, %146
%149 = phi <2 x i64> [ %140, %146 ], [ %152, %148 ]
%150 = phi <2 x i64> [ zeroinitializer, %146 ], [ %153, %148 ]
%151 = phi i32 [ 0, %146 ], [ %154, %148 ]
%152 = add <2 x i64> %149, <i64 8, i64 8>
%153 = add <2 x i64> %150, <i64 8, i64 8>
%154 = add i32 %151, 8
%155 = icmp eq i32 %154, %147
br i1 %155, label %156, label %148
156: ; preds = %148, %137
%157 = phi <2 x i64> [ undef, %137 ], [ %152, %148 ]
%158 = phi <2 x i64> [ undef, %137 ], [ %153, %148 ]
%159 = phi <2 x i64> [ %140, %137 ], [ %152, %148 ]
%160 = phi <2 x i64> [ zeroinitializer, %137 ], [ %153, %148 ]
%161 = icmp eq i32 %144, 0
br i1 %161, label %170, label %162
162: ; preds = %156, %162
%163 = phi <2 x i64> [ %166, %162 ], [ %159, %156 ]
%164 = phi <2 x i64> [ %167, %162 ], [ %160, %156 ]
%165 = phi i32 [ %168, %162 ], [ 0, %156 ]
%166 = add <2 x i64> %163, <i64 1, i64 1>
%167 = add <2 x i64> %164, <i64 1, i64 1>
%168 = add i32 %165, 1
%169 = icmp eq i32 %168, %144
br i1 %169, label %170, label %162
170: ; preds = %162, %156
%171 = phi <2 x i64> [ %157, %156 ], [ %166, %162 ]
%172 = phi <2 x i64> [ %158, %156 ], [ %167, %162 ]
%173 = add <2 x i64> %172, %171
%174 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %173)
%175 = icmp eq i32 %135, %138
br i1 %175, label %185, label %176
176: ; preds = %124, %170
%177 = phi i64 [ %125, %124 ], [ %174, %170 ]
%178 = phi i32 [ %119, %124 ], [ %139, %170 ]
br label %179
179: ; preds = %176, %179
%180 = phi i64 [ %182, %179 ], [ %177, %176 ]
%181 = phi i32 [ %183, %179 ], [ %178, %176 ]
%182 = add nsw i64 %180, 1
%183 = add nsw i32 %181, -1
%184 = icmp sgt i32 %181, 1
br i1 %184, label %179, label %185
185: ; preds = %179, %170
%186 = phi i64 [ %174, %170 ], [ %182, %179 ]
%187 = trunc i64 %186 to i32
br label %193
188: ; preds = %42
%189 = trunc i64 %46 to i32
br label %193
190: ; preds = %111, %102
%191 = phi i64 [ %106, %102 ], [ %114, %111 ]
%192 = trunc i64 %191 to i32
br label %193
193: ; preds = %190, %188, %185, %54, %36, %122, %24
%194 = phi i32 [ %25, %24 ], [ %13, %122 ], [ %13, %36 ], [ %13, %54 ], [ %187, %185 ], [ %189, %188 ], [ %192, %190 ]
%195 = icmp slt i32 %194, %3
br i1 %195, label %12, label %196
196: ; preds = %12, %16, %29, %31, %49, %117, %193, %6
%197 = phi i32 [ 1, %6 ], [ 1, %193 ], [ 0, %117 ], [ 0, %49 ], [ 0, %31 ], [ 0, %29 ], [ 0, %16 ], [ 0, %12 ]
ret i32 %197
}