#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*/ free(unsigned char *);
unsigned long he3_get_bit(unsigned char *, unsigned long *);
unsigned long he3_get_bits(unsigned char *, unsigned long *, unsigned int);
unsigned char *malloc(int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int decode_he3_data(unsigned char *data, unsigned char *output, int nb_output,
                    int signature) {
  int output_len = 0;
  if (signature) {
    if ((data[0] == 'H') && (data[1] == 'E') && (data[2] == '3') &&
        (data[3] == 0xD)) {
    } else {
      return (-1);
    }
    nb_output = (((int)(data[8])) & 255);
    nb_output <<= 8;
    nb_output |= (((int)(data[7])) & 255);
    nb_output <<= 8;
    nb_output |= (((int)(data[6])) & 255);
    nb_output <<= 8;
    nb_output |= (((int)(data[5])) & 255);
  } else {
    data -= 4 + 1 + 4;
  }
  unsigned char *decode_array = NULL;
  int pos;
  int nb_couple;
  int max_len = 0;
  int ttl_len = 0;
  unsigned long offset_pattern;
  unsigned long offset_encoded;
  nb_couple = data[9];
  nb_couple += ((((int)(data[10])) & 255) << 8);
  for (pos = 0; pos < nb_couple; pos++) {
    int v;
    v = (((int)(data[12 + pos * 2])) & 255);
    if (v > max_len)
      max_len = v;
    ttl_len += v;
  }
  decode_array = malloc(1 << (max_len + 1));
  if (decode_array != NULL) {
    memset(decode_array, 0, 1 << (max_len + 1));
    offset_pattern = 8 * (11 + nb_couple * 2);
    offset_encoded = offset_pattern + ((ttl_len + 7) & ~7);
    for (pos = 0; pos < nb_couple; pos++) {
      unsigned int v_len;
      unsigned long value;
      v_len = (((int)(data[12 + pos * 2])) & 255);
      value = he3_get_bits(data, &offset_pattern, v_len);
      decode_array[(1 << v_len) + value] = data[11 + pos * 2];
    }
    while (output_len != nb_output) {
      unsigned long cur_val;
      unsigned int nb_bit_val;
      cur_val = he3_get_bit(data, &offset_encoded);
      nb_bit_val = 1;
      while (decode_array[(1 << nb_bit_val) + cur_val] == 0) {
        cur_val = (cur_val << 1) | he3_get_bit(data, &offset_encoded);
        nb_bit_val++;
      }
      if (output_len >= nb_output)
        break;
      output[output_len++] = decode_array[(1 << nb_bit_val) + cur_val];
    }
    free(decode_array);
  }
  return output_len;
}


x86 assembly (clang, -O0):
<decode_he3_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     1237 <decode_he3_data+0xe7>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x48,%eax
jne    11c2 <decode_he3_data+0x72>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x45,%eax
jne    11c2 <decode_he3_data+0x72>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
cmp    $0x33,%eax
jne    11c2 <decode_he3_data+0x72>
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
cmp    $0xd,%eax
jne    11c2 <decode_he3_data+0x72>
jmp    11ce <decode_he3_data+0x7e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1488 <decode_he3_data+0x338>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0xff,%eax
or     -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0xff,%eax
or     -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0xff,%eax
or     -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1243 <decode_he3_data+0xf3>
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff7,%rax
mov    %rax,-0x10(%rbp)
movq   $0x0,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0xff,%eax
shl    $0x8,%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    12d2 <decode_he3_data+0x182>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    12bb <decode_he3_data+0x16b>
mov    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1281 <decode_he3_data+0x131>
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    $0x1,%edi
shl    %cl,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
je     1482 <decode_he3_data+0x332>
mov    -0x30(%rbp),%rdi
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    $0x1,%edx
shl    %cl,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    $0xb,%eax
shl    $0x3,%eax
cltq
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x7,%ecx
and    $0xfffffff8,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13b2 <decode_he3_data+0x262>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%edx
lea    -0x48(%rbp),%rsi
call   1070 <he3_get_bits@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    %esi,%ecx
movslq %ecx,%rcx
add    -0x60(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133b <decode_he3_data+0x1eb>
jmp    13b7 <decode_he3_data+0x267>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1479 <decode_he3_data+0x329>
mov    -0x10(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1040 <he3_get_bit@plt>
mov    %rax,-0x68(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
movslq %ecx,%rcx
add    -0x68(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1434 <decode_he3_data+0x2e4>
mov    -0x68(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1040 <he3_get_bit@plt>
mov    %rax,%rcx
mov    -0x78(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13db <decode_he3_data+0x28b>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     1445 <decode_he3_data+0x2f5>
jmp    1479 <decode_he3_data+0x329>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
movslq %ecx,%rcx
add    -0x68(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    13b7 <decode_he3_data+0x267>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decode_he3_data>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,0x20(%rsp)
mov    %rdi,%r13
test   %ecx,%ecx
je     11a1 <decode_he3_data+0x51>
mov    $0xffffffff,%eax
cmpb   $0x48,0x0(%r13)
jne    148c <decode_he3_data+0x33c>
cmpb   $0x45,0x1(%r13)
jne    148c <decode_he3_data+0x33c>
cmpb   $0x33,0x2(%r13)
jne    148c <decode_he3_data+0x33c>
cmpb   $0xd,0x3(%r13)
jne    148c <decode_he3_data+0x33c>
mov    0x5(%r13),%edx
jmp    11a5 <decode_he3_data+0x55>
add    $0xfffffffffffffff7,%r13
mov    %rdx,0x10(%rsp)
movzwl 0x9(%r13),%r12d
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%r14d
mov    $0x1,%ecx
mov    $0x0,%ebx
test   %r12,%r12
je     1342 <decode_he3_data+0x1f2>
cmp    $0x9,%r12d
jae    11e0 <decode_he3_data+0x90>
xor    %eax,%eax
xor    %ebx,%ebx
xor    %ecx,%ecx
jmp    1320 <decode_he3_data+0x1d0>
mov    %r12d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
mov    %r12,%rax
sub    %rcx,%rax
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
movdqa 0xdf9(%rip),%xmm8
movdqa 0xe00(%rip),%xmm9
pxor   %xmm1,%xmm1
pxor   %xmm5,%xmm5
pxor   %xmm4,%xmm4
nopl   0x0(%rax)
movq   0xc(%r13,%rcx,2),%xmm2
punpcklwd %xmm2,%xmm2
movq   0x14(%r13,%rcx,2),%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm8,%xmm2
pand   %xmm8,%xmm7
movdqa %xmm5,%xmm3
pxor   %xmm9,%xmm5
movdqa %xmm2,%xmm6
por    %xmm9,%xmm6
pcmpgtd %xmm6,%xmm5
pand   %xmm5,%xmm3
pandn  %xmm2,%xmm5
por    %xmm3,%xmm5
movdqa %xmm4,%xmm3
pxor   %xmm9,%xmm4
movdqa %xmm7,%xmm6
por    %xmm9,%xmm6
pcmpgtd %xmm6,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm7,%xmm4
por    %xmm3,%xmm4
paddd  %xmm2,%xmm0
paddd  %xmm7,%xmm1
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1220 <decode_he3_data+0xd0>
movdqa %xmm4,%xmm2
pxor   %xmm9,%xmm2
movdqa %xmm5,%xmm3
pxor   %xmm9,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm5
pandn  %xmm4,%xmm3
por    %xmm5,%xmm3
pshufd $0xee,%xmm3,%xmm2
movdqa %xmm3,%xmm4
pxor   %xmm9,%xmm4
movdqa %xmm2,%xmm5
pxor   %xmm9,%xmm5
pcmpgtd %xmm5,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm2,%xmm4
por    %xmm3,%xmm4
pshufd $0x55,%xmm4,%xmm2
movdqa %xmm4,%xmm3
pxor   %xmm9,%xmm3
pxor   %xmm2,%xmm9
pcmpgtd %xmm9,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm2,%xmm3
por    %xmm4,%xmm3
movd   %xmm3,%ecx
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebx
movzbl 0xc(%r13,%rax,2),%edx
cmp    %edx,%ecx
cmovb  %edx,%ecx
add    %edx,%ebx
add    $0x1,%rax
cmp    %rax,%r12
jne    1320 <decode_he3_data+0x1d0>
add    $0x1,%ecx
add    $0x7,%ebx
and    $0x7ffffff8,%ebx
shl    %cl,%r14d
mov    %r14d,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1487 <decode_he3_data+0x337>
mov    %rax,%rbp
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    %rbp,%rdi
xor    %esi,%esi
mov    %r14d,%edx
call   1050 <memset@plt>
mov    %r12d,%eax
shl    $0x4,%eax
lea    0x58(%rax),%ecx
mov    %rcx,0x30(%rsp)
add    %ebx,%eax
add    $0x58,%eax
mov    %rax,0x28(%rsp)
test   %r12d,%r12d
je     13d5 <decode_he3_data+0x285>
mov    %r12d,%r12d
xor    %r14d,%r14d
lea    0x30(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0xc(%r13,%r14,2),%ebx
mov    %r13,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   1070 <he3_get_bits@plt>
movzbl 0xb(%r13,%r14,2),%edx
mov    $0x1,%esi
mov    %ebx,%ecx
shl    %cl,%esi
movslq %esi,%rcx
add    %rax,%rcx
mov    %dl,0x0(%rbp,%rcx,1)
add    $0x1,%r14
cmp    %r14,%r12
jne    13a0 <decode_he3_data+0x250>
mov    0x10(%rsp),%r15
test   %r15d,%r15d
je     147f <decode_he3_data+0x32f>
mov    %r15d,%eax
mov    %rax,0x18(%rsp)
xor    %ecx,%ecx
test   %r15d,%r15d
mov    $0x0,%eax
mov    %rax,0x8(%rsp)
cmovle %ecx,%r15d
lea    0x28(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
mov    %rbx,%rsi
call   1040 <he3_get_bit@plt>
mov    %rax,%r14
mov    0x2(%rax,%rbp,1),%al
test   %al,%al
jne    145d <decode_he3_data+0x30d>
mov    $0x2,%r12d
nopl   0x0(%rax)
add    %r14,%r14
mov    %r13,%rdi
mov    %rbx,%rsi
call   1040 <he3_get_bit@plt>
or     %rax,%r14
mov    $0x1,%eax
mov    %r12d,%ecx
shl    %cl,%eax
cltq
add    %r14,%rax
movzbl 0x0(%rbp,%rax,1),%eax
add    $0x1,%r12d
test   %al,%al
je     1430 <decode_he3_data+0x2e0>
mov    0x8(%rsp),%rdx
cmp    %r15,%rdx
je     147f <decode_he3_data+0x32f>
mov    0x20(%rsp),%rcx
mov    %al,(%rcx,%rdx,1)
add    $0x1,%rdx
mov    %rdx,0x8(%rsp)
cmp    0x18(%rsp),%rdx
jne    1410 <decode_he3_data+0x2c0>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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