#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 */
void **Huff_GetNode(void **);
int /*<<< orphan*/ Huff_IncrementFreq_r(void **, void *);
void Huff_AddReference(void **tree, int ch) {
  void **a, **b, **c, **d;
  int value;
  ch &= 255;
  if (tree[ch + 5]) {
    Huff_IncrementFreq_r(tree, tree[ch + 5]);
    return;
  }
  value = (*(int *)&(tree[0]))++;
  b = &tree[value * 8 + 263];
  value = (*(int *)&(tree[0]))++;
  a = &tree[value * 8 + 263];
  a[7] = ((void *)(257));
  a[6] = ((void *)(1));
  d = tree[3];
  a[3] = d[3];
  if (a[3]) {
    d = a[3];
    d[4] = a;
    d = a[3];
    if (d[6] == ((void *)(1))) {
      a[5] = d[5];
    } else {
      d = Huff_GetNode(tree);
      a[5] = d;
      d[0] = a;
    }
  } else {
    d = Huff_GetNode(tree);
    a[5] = d;
    d[0] = a;
  }
  d = tree[3];
  d[3] = a;
  a[4] = tree[3];
  b[7] = ((void *)(ch));
  b[6] = ((void *)(1));
  d = tree[3];
  b[3] = d[3];
  if (b[3]) {
    d = b[3];
    d[4] = b;
    if (d[6] == ((void *)(1))) {
      b[5] = d[5];
    } else {
      d = Huff_GetNode(tree);
      b[5] = d;
      d[0] = a;
    }
  } else {
    d = Huff_GetNode(tree);
    b[5] = d;
    d[0] = b;
  }
  d = tree[3];
  d[3] = b;
  b[4] = tree[3];
  b[1] = ((void *)0);
  b[0] = ((void *)0);
  d = tree[3];
  c = d[2];
  if (c) {
    if (c[0] == tree[3]) {
      c[0] = a;
    } else {
      c[1] = a;
    }
  } else {
    tree[2] = a;
  }
  a[1] = b;
  d = tree[3];
  a[0] = d;
  a[2] = d[2];
  b[2] = a;
  d = tree[3];
  d[2] = a;
  tree[ch + 5] = b;
  Huff_IncrementFreq_r(tree, a[2]);
}


x86 assembly (clang, -O0):
<Huff_AddReference>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1171 <Huff_AddReference+0x51>
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <Huff_IncrementFreq_r@plt>
jmp    14c5 <Huff_AddReference+0x3a5>
mov    -0x8(%rbp),%rcx
mov    (%rcx),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,(%rcx)
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x107,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rcx
mov    (%rcx),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,(%rcx)
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x107,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    $0x101,%ecx
mov    %rcx,0x38(%rax)
mov    -0x18(%rbp),%rax
mov    $0x1,%ecx
mov    %rcx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x18(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,0x18(%rax)
je     1287 <Huff_AddReference+0x167>
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    $0x1,%ecx
cmp    %rcx,0x30(%rax)
jne    125e <Huff_AddReference+0x13e>
mov    -0x30(%rbp),%rax
mov    0x28(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x28(%rax)
jmp    1282 <Huff_AddReference+0x162>
mov    -0x8(%rbp),%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
jmp    12ab <Huff_AddReference+0x18b>
mov    -0x8(%rbp),%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x20(%rax)
movslq -0xc(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x38(%rax)
mov    -0x20(%rbp),%rax
mov    $0x1,%ecx
mov    %rcx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x18(%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x20(%rbp),%rax
cmpq   $0x0,0x18(%rax)
je     1380 <Huff_AddReference+0x260>
mov    -0x20(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x30(%rbp),%rax
mov    $0x1,%ecx
cmp    %rcx,0x30(%rax)
jne    1357 <Huff_AddReference+0x237>
mov    -0x30(%rbp),%rax
mov    0x28(%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x28(%rax)
jmp    137b <Huff_AddReference+0x25b>
mov    -0x8(%rbp),%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
jmp    13a4 <Huff_AddReference+0x284>
mov    -0x8(%rbp),%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x20(%rbp),%rax
movq   $0x0,0x8(%rax)
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     143c <Huff_AddReference+0x31c>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
cmp    0x18(%rcx),%rax
jne    142b <Huff_AddReference+0x30b>
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
jmp    1437 <Huff_AddReference+0x317>
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x8(%rax)
jmp    1448 <Huff_AddReference+0x328>
mov    -0x18(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x20(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rsi
call   1040 <Huff_IncrementFreq_r@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Huff_AddReference>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbx
movzbl %sil,%r12d
mov    0x28(%rdi,%r12,8),%rsi
test   %rsi,%rsi
jne    127e <Huff_AddReference+0x15e>
mov    (%rbx),%eax
lea    0x0(,%rax,8),%ecx
movslq %ecx,%rcx
lea    (%rbx,%rcx,8),%r14
add    $0x838,%r14
lea    0x2(%rax),%ecx
mov    %ecx,(%rbx)
lea    0x10f(,%rax,8),%eax
movslq %eax,%rcx
lea    (%rbx,%rcx,8),%r15
movq   $0x101,0x38(%rbx,%rcx,8)
movq   $0x1,0x30(%rbx,%rcx,8)
mov    0x18(%rbx),%rax
mov    0x18(%rax),%rax
mov    %rax,0x18(%rbx,%rcx,8)
test   %rax,%rax
je     119a <Huff_AddReference+0x7a>
mov    %r15,0x20(%rax)
mov    0x18(%r15),%rax
cmpq   $0x1,0x30(%rax)
je     11ab <Huff_AddReference+0x8b>
mov    %rbx,%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,0x28(%r15)
mov    %r15,(%rax)
jmp    11b3 <Huff_AddReference+0x93>
mov    0x28(%rax),%rax
mov    %rax,0x28(%r15)
mov    0x18(%rbx),%rax
mov    %r15,0x18(%rax)
mov    0x18(%rbx),%rax
mov    %rax,0x20(%r15)
mov    %r12d,%eax
mov    %rax,0x38(%r14)
movq   $0x1,0x30(%r14)
mov    0x18(%rbx),%rax
mov    0x18(%rax),%rax
mov    %rax,0x18(%r14)
test   %rax,%rax
je     11ff <Huff_AddReference+0xdf>
mov    %r14,0x20(%rax)
cmpq   $0x1,0x30(%rax)
je     1210 <Huff_AddReference+0xf0>
mov    %rbx,%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,0x28(%r14)
mov    %r15,(%rax)
jmp    1218 <Huff_AddReference+0xf8>
mov    %rbx,%rdi
call   1030 <Huff_GetNode@plt>
mov    %rax,0x28(%r14)
mov    %r14,(%rax)
jmp    1218 <Huff_AddReference+0xf8>
mov    0x28(%rax),%rax
mov    %rax,0x28(%r14)
lea    0x5(%r12),%rax
mov    0x18(%rbx),%rcx
mov    %r14,0x18(%rcx)
mov    0x18(%rbx),%rcx
mov    %rcx,0x20(%r14)
xorps  %xmm0,%xmm0
movups %xmm0,(%r14)
mov    0x18(%rbx),%rdx
mov    0x10(%rdx),%rcx
test   %rcx,%rcx
je     1250 <Huff_AddReference+0x130>
xor    %esi,%esi
cmp    %rdx,(%rcx)
setne  %sil
lea    (%rcx,%rsi,8),%rcx
jmp    1254 <Huff_AddReference+0x134>
lea    0x10(%rbx),%rcx
mov    %r15,(%rcx)
mov    %r14,0x8(%r15)
mov    0x18(%rbx),%rcx
mov    %rcx,(%r15)
mov    0x10(%rcx),%rcx
mov    %rcx,0x10(%r15)
mov    %r15,0x10(%r14)
mov    0x18(%rbx),%rcx
mov    %r15,0x10(%rcx)
mov    %r14,(%rbx,%rax,8)
mov    0x10(%r15),%rsi
mov    %rbx,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1040 <Huff_IncrementFreq_r@plt>

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

LLVM IR (-O2):
define void @Huff_AddReference(i8** %0, i32 %1) {
%3 = and i32 %1, 255
%4 = add nuw nsw i32 %3, 5
%5 = zext i32 %4 to i64
%6 = getelementptr inbounds i8*, i8** %0, i64 %5
%7 = load i8*, i8** %6
%8 = icmp eq i8* %7, null
br i1 %8, label %11, label %9
9: ; preds = %2
%10 = tail call i32 @Huff_IncrementFreq_r(i8** %0, i8* %7)
br label %127
11: ; preds = %2
%12 = bitcast i8** %0 to i32*
%13 = load i32, i32* %12
%14 = shl i32 %13, 3
%15 = add nsw i32 %14, 263
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8*, i8** %0, i64 %16
%18 = add nsw i32 %13, 2
store i32 %18, i32* %12
%19 = add i32 %14, 271
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i8*, i8** %0, i64 %20
%22 = getelementptr inbounds i8*, i8** %21, i64 7
store i8* inttoptr (i64 257 to i8*), i8** %22
%23 = getelementptr inbounds i8*, i8** %21, i64 6
store i8* inttoptr (i64 1 to i8*), i8** %23
%24 = getelementptr inbounds i8*, i8** %0, i64 3
%25 = bitcast i8** %24 to i8***
%26 = load i8**, i8*** %25
%27 = getelementptr inbounds i8*, i8** %26, i64 3
%28 = load i8*, i8** %27
%29 = getelementptr inbounds i8*, i8** %21, i64 3
store i8* %28, i8** %29
%30 = icmp eq i8* %28, null
br i1 %30, label %48, label %31
31: ; preds = %11
%32 = getelementptr inbounds i8, i8* %28, i64 32
%33 = bitcast i8* %32 to i8***
store i8** %21, i8*** %33
%34 = bitcast i8** %29 to i8***
%35 = load i8**, i8*** %34
%36 = getelementptr inbounds i8*, i8** %35, i64 6
%37 = load i8*, i8** %36
%38 = icmp eq i8* %37, inttoptr (i64 1 to i8*)
br i1 %38, label %39, label %43
39: ; preds = %31
%40 = getelementptr inbounds i8*, i8** %35, i64 5
%41 = load i8*, i8** %40
%42 = getelementptr inbounds i8*, i8** %21, i64 5
store i8* %41, i8** %42
br label %53
43: ; preds = %31
%44 = tail call i8** @Huff_GetNode(i8** %0)
%45 = getelementptr inbounds i8*, i8** %21, i64 5
%46 = bitcast i8** %45 to i8***
store i8** %44, i8*** %46
%47 = bitcast i8** %44 to i8***
store i8** %21, i8*** %47
br label %53
48: ; preds = %11
%49 = tail call i8** @Huff_GetNode(i8** %0)
%50 = getelementptr inbounds i8*, i8** %21, i64 5
%51 = bitcast i8** %50 to i8***
store i8** %49, i8*** %51
%52 = bitcast i8** %49 to i8***
store i8** %21, i8*** %52
br label %53
53: ; preds = %39, %43, %48
%54 = load i8**, i8*** %25
%55 = getelementptr inbounds i8*, i8** %54, i64 3
%56 = bitcast i8** %55 to i8***
store i8** %21, i8*** %56
%57 = load i8*, i8** %24
%58 = getelementptr inbounds i8*, i8** %21, i64 4
store i8* %57, i8** %58
%59 = zext i32 %3 to i64
%60 = inttoptr i64 %59 to i8*
%61 = getelementptr inbounds i8*, i8** %17, i64 7
store i8* %60, i8** %61
%62 = getelementptr inbounds i8*, i8** %17, i64 6
store i8* inttoptr (i64 1 to i8*), i8** %62
%63 = load i8**, i8*** %25
%64 = getelementptr inbounds i8*, i8** %63, i64 3
%65 = load i8*, i8** %64
%66 = getelementptr inbounds i8*, i8** %17, i64 3
store i8* %65, i8** %66
%67 = icmp eq i8* %65, null
br i1 %67, label %85, label %68
68: ; preds = %53
%69 = getelementptr inbounds i8, i8* %65, i64 32
%70 = bitcast i8* %69 to i8***
store i8** %17, i8*** %70
%71 = getelementptr inbounds i8, i8* %65, i64 48
%72 = bitcast i8* %71 to i8**
%73 = load i8*, i8** %72
%74 = icmp eq i8* %73, inttoptr (i64 1 to i8*)
br i1 %74, label %75, label %80
75: ; preds = %68
%76 = getelementptr inbounds i8, i8* %65, i64 40
%77 = bitcast i8* %76 to i8**
%78 = load i8*, i8** %77
%79 = getelementptr inbounds i8*, i8** %17, i64 5
store i8* %78, i8** %79
br label %90
80: ; preds = %68
%81 = tail call i8** @Huff_GetNode(i8** %0)
%82 = getelementptr inbounds i8*, i8** %17, i64 5
%83 = bitcast i8** %82 to i8***
store i8** %81, i8*** %83
%84 = bitcast i8** %81 to i8***
store i8** %21, i8*** %84
br label %90
85: ; preds = %53
%86 = tail call i8** @Huff_GetNode(i8** %0)
%87 = getelementptr inbounds i8*, i8** %17, i64 5
%88 = bitcast i8** %87 to i8***
store i8** %86, i8*** %88
%89 = bitcast i8** %86 to i8***
store i8** %17, i8*** %89
br label %90
90: ; preds = %75, %80, %85
%91 = load i8**, i8*** %25
%92 = getelementptr inbounds i8*, i8** %91, i64 3
%93 = bitcast i8** %92 to i8***
store i8** %17, i8*** %93
%94 = load i8*, i8** %24
%95 = getelementptr inbounds i8*, i8** %17, i64 4
store i8* %94, i8** %95
%96 = bitcast i8** %17 to i8*
%97 = load i8*, i8** %24
%98 = getelementptr inbounds i8, i8* %97, i64 16
%99 = bitcast i8* %98 to i8***
%100 = load i8**, i8*** %99
%101 = icmp eq i8** %100, null
br i1 %101, label %107, label %102
102: ; preds = %90
%103 = load i8*, i8** %100
%104 = icmp ne i8* %103, %97
%105 = zext i1 %104 to i64
%106 = getelementptr i8*, i8** %100, i64 %105
br label %109
107: ; preds = %90
%108 = getelementptr inbounds i8*, i8** %0, i64 2
br label %109
109: ; preds = %102, %107
%110 = phi i8** [ %108, %107 ], [ %106, %102 ]
%111 = bitcast i8** %110 to i8***
store i8** %21, i8*** %111
%112 = getelementptr inbounds i8*, i8** %21, i64 1
%113 = bitcast i8** %112 to i8***
store i8** %17, i8*** %113
%114 = load i8*, i8** %24
store i8* %114, i8** %21
%115 = getelementptr inbounds i8, i8* %114, i64 16
%116 = bitcast i8* %115 to i8**
%117 = load i8*, i8** %116
%118 = getelementptr inbounds i8*, i8** %21, i64 2
store i8* %117, i8** %118
%119 = getelementptr inbounds i8*, i8** %17, i64 2
%120 = bitcast i8** %119 to i8***
store i8** %21, i8*** %120
%121 = load i8**, i8*** %25
%122 = getelementptr inbounds i8*, i8** %121, i64 2
%123 = bitcast i8** %122 to i8***
store i8** %21, i8*** %123
%124 = bitcast i8** %6 to i8***
store i8** %17, i8*** %124
%125 = load i8*, i8** %118
%126 = tail call i32 @Huff_IncrementFreq_r(i8** %0, i8* %125)
br label %127
127: ; preds = %109, %9
ret void
}