#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*/ Huff_DeleteNode(void **, void **);
void **Huff_GetNode(void **);
int /*<<< orphan*/ Huff_Swap(void **, void *, void **);
int /*<<< orphan*/ Huff_SwapTrees(void **, void *);
void Huff_IncrementFreq_r(void **tree1, void **tree2) {
  void **a, **b;
  if (!tree2) {
    return;
  }
  a = tree2[3];
  if (a && a[6] == tree2[6]) {
    b = tree2[5];
    if (b[0] != tree2[2]) {
      Huff_Swap(tree1, b[0], tree2);
    }
    Huff_SwapTrees(b[0], tree2);
  }
  a = tree2[4];
  if (a && a[6] == tree2[6]) {
    b = tree2[5];
    b[0] = a;
  } else {
    a = tree2[5];
    a[0] = 0;
    Huff_DeleteNode(tree1, a);
  }
  (*(int *)&(tree2[6]))++;
  a = tree2[3];
  if (a && a[6] == tree2[6]) {
    tree2[5] = a[5];
  } else {
    a = Huff_GetNode(tree1);
    tree2[5] = a;
    a[0] = tree2;
  }
  if (tree2[2]) {
    Huff_IncrementFreq_r(tree1, tree2[2]);
    if (tree2[4] == tree2[2]) {
      Huff_SwapTrees(tree2, tree2[2]);
      a = tree2[5];
      if (a[0] == tree2) {
        a[0] = tree2[2];
      }
    }
  }
}


x86 assembly (clang, -O0):
<Huff_IncrementFreq_r>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1170 <Huff_IncrementFreq_r+0x20>
jmp    1342 <Huff_IncrementFreq_r+0x1f2>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     11e2 <Huff_IncrementFreq_r+0x92>
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
cmp    0x30(%rcx),%rax
jne    11e2 <Huff_IncrementFreq_r+0x92>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
cmp    0x10(%rcx),%rax
je     11d2 <Huff_IncrementFreq_r+0x82>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rax
mov    (%rax),%rsi
mov    -0x10(%rbp),%rdx
call   1050 <Huff_Swap@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <Huff_SwapTrees@plt>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     122b <Huff_IncrementFreq_r+0xdb>
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
cmp    0x30(%rcx),%rax
jne    122b <Huff_IncrementFreq_r+0xdb>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
jmp    124f <Huff_IncrementFreq_r+0xff>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1070 <Huff_DeleteNode@plt>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x30(%rax)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     129e <Huff_IncrementFreq_r+0x14e>
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x10(%rbp),%rcx
cmp    0x30(%rcx),%rax
jne    129e <Huff_IncrementFreq_r+0x14e>
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x28(%rax)
jmp    12c2 <Huff_IncrementFreq_r+0x172>
mov    -0x8(%rbp),%rdi
call   1040 <Huff_GetNode@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
cmpq   $0x0,0x10(%rax)
je     1342 <Huff_IncrementFreq_r+0x1f2>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rsi
call   1060 <Huff_IncrementFreq_r@plt>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
cmp    0x10(%rcx),%rax
jne    133d <Huff_IncrementFreq_r+0x1ed>
mov    -0x10(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rsi
call   1030 <Huff_SwapTrees@plt>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
cmp    %rcx,%rax
jne    1338 <Huff_IncrementFreq_r+0x1e8>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
jmp    133d <Huff_IncrementFreq_r+0x1ed>
jmp    1342 <Huff_IncrementFreq_r+0x1f2>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Huff_IncrementFreq_r>:
push   %r15
push   %r14
push   %rbx
test   %rsi,%rsi
je     1234 <Huff_IncrementFreq_r+0xe4>
mov    %rsi,%rbx
mov    %rdi,%r14
mov    0x18(%rsi),%rax
test   %rax,%rax
je     119d <Huff_IncrementFreq_r+0x4d>
mov    0x30(%rax),%rax
cmp    0x30(%rbx),%rax
jne    119d <Huff_IncrementFreq_r+0x4d>
mov    0x28(%rbx),%r15
mov    (%r15),%rsi
cmp    0x10(%rbx),%rsi
je     1192 <Huff_IncrementFreq_r+0x42>
mov    %r14,%rdi
mov    %rbx,%rdx
call   1050 <Huff_Swap@plt>
mov    (%r15),%rsi
mov    %rsi,%rdi
mov    %rbx,%rsi
call   1030 <Huff_SwapTrees@plt>
mov    0x20(%rbx),%rcx
test   %rcx,%rcx
je     11b0 <Huff_IncrementFreq_r+0x60>
mov    0x30(%rbx),%rax
cmp    %rax,0x30(%rcx)
je     11c8 <Huff_IncrementFreq_r+0x78>
mov    0x28(%rbx),%rsi
movq   $0x0,(%rsi)
mov    %r14,%rdi
call   1070 <Huff_DeleteNode@plt>
mov    0x30(%rbx),%eax
jmp    11cf <Huff_IncrementFreq_r+0x7f>
mov    0x28(%rbx),%rdx
mov    %rcx,(%rdx)
add    $0x1,%eax
mov    %eax,0x30(%rbx)
mov    0x18(%rbx),%rax
test   %rax,%rax
je     11e8 <Huff_IncrementFreq_r+0x98>
mov    0x30(%rax),%rcx
cmp    0x30(%rbx),%rcx
je     11f9 <Huff_IncrementFreq_r+0xa9>
mov    %r14,%rdi
call   1040 <Huff_GetNode@plt>
mov    %rax,0x28(%rbx)
mov    %rbx,(%rax)
jmp    1201 <Huff_IncrementFreq_r+0xb1>
mov    0x28(%rax),%rax
mov    %rax,0x28(%rbx)
mov    0x10(%rbx),%rsi
test   %rsi,%rsi
je     1234 <Huff_IncrementFreq_r+0xe4>
mov    %r14,%rdi
call   1060 <Huff_IncrementFreq_r@plt>
mov    0x20(%rbx),%rsi
cmp    0x10(%rbx),%rsi
jne    1234 <Huff_IncrementFreq_r+0xe4>
mov    %rbx,%rdi
call   1030 <Huff_SwapTrees@plt>
mov    0x28(%rbx),%rax
cmp    %rbx,(%rax)
jne    1234 <Huff_IncrementFreq_r+0xe4>
mov    0x10(%rbx),%rcx
mov    %rcx,(%rax)
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @Huff_IncrementFreq_r(i8** %0, i8** %1) {
%3 = icmp eq i8** %1, null
br i1 %3, label %99, label %4
4: ; preds = %2
%5 = getelementptr inbounds i8*, i8** %1, i64 3
%6 = bitcast i8** %5 to i8***
%7 = load i8**, i8*** %6
%8 = icmp eq i8** %7, null
br i1 %8, label %33, label %9
9: ; preds = %4
%10 = getelementptr inbounds i8*, i8** %7, i64 6
%11 = load i8*, i8** %10
%12 = getelementptr inbounds i8*, i8** %1, i64 6
%13 = load i8*, i8** %12
%14 = icmp eq i8* %11, %13
br i1 %14, label %15, label %33
15: ; preds = %9
%16 = getelementptr inbounds i8*, i8** %1, i64 5
%17 = bitcast i8** %16 to i8***
%18 = load i8**, i8*** %17
%19 = load i8*, i8** %18
%20 = getelementptr inbounds i8*, i8** %1, i64 2
%21 = load i8*, i8** %20
%22 = icmp eq i8* %19, %21
br i1 %22, label %23, label %25
23: ; preds = %15
%24 = bitcast i8* %19 to i8**
br label %29
25: ; preds = %15
%26 = tail call i32 @Huff_Swap(i8** %0, i8* %19, i8** %1)
%27 = bitcast i8** %18 to i8***
%28 = load i8**, i8*** %27
br label %29
29: ; preds = %23, %25
%30 = phi i8** [ %28, %25 ], [ %24, %23 ]
%31 = bitcast i8** %1 to i8*
%32 = tail call i32 @Huff_SwapTrees(i8** %30, i8* %31)
br label %33
33: ; preds = %29, %9, %4
%34 = getelementptr inbounds i8*, i8** %1, i64 4
%35 = load i8*, i8** %34
%36 = icmp eq i8* %35, null
br i1 %36, label %51, label %37
37: ; preds = %33
%38 = getelementptr inbounds i8, i8* %35, i64 48
%39 = bitcast i8* %38 to i8**
%40 = load i8*, i8** %39
%41 = getelementptr inbounds i8*, i8** %1, i64 6
%42 = load i8*, i8** %41
%43 = icmp eq i8* %40, %42
br i1 %43, label %44, label %51
44: ; preds = %37
%45 = ptrtoint i8* %42 to i64
%46 = trunc i64 %45 to i32
%47 = getelementptr inbounds i8*, i8** %1, i64 5
%48 = bitcast i8** %47 to i8***
%49 = load i8**, i8*** %48
store i8* %35, i8** %49
%50 = bitcast i8** %41 to i32*
br label %59
51: ; preds = %37, %33
%52 = getelementptr inbounds i8*, i8** %1, i64 5
%53 = bitcast i8** %52 to i8***
%54 = load i8**, i8*** %53
store i8* null, i8** %54
%55 = tail call i32 @Huff_DeleteNode(i8** %0, i8** %54)
%56 = getelementptr inbounds i8*, i8** %1, i64 6
%57 = bitcast i8** %56 to i32*
%58 = load i32, i32* %57
br label %59
59: ; preds = %51, %44
%60 = phi i32* [ %57, %51 ], [ %50, %44 ]
%61 = phi i32 [ %58, %51 ], [ %46, %44 ]
%62 = add nsw i32 %61, 1
store i32 %62, i32* %60
%63 = load i8**, i8*** %6
%64 = icmp eq i8** %63, null
br i1 %64, label %75, label %65
65: ; preds = %59
%66 = getelementptr inbounds i8*, i8** %1, i64 6
%67 = getelementptr inbounds i8*, i8** %63, i64 6
%68 = load i8*, i8** %67
%69 = load i8*, i8** %66
%70 = icmp eq i8* %68, %69
br i1 %70, label %71, label %75
71: ; preds = %65
%72 = getelementptr inbounds i8*, i8** %63, i64 5
%73 = load i8*, i8** %72
%74 = getelementptr inbounds i8*, i8** %1, i64 5
store i8* %73, i8** %74
br label %80
75: ; preds = %65, %59
%76 = tail call i8** @Huff_GetNode(i8** %0)
%77 = getelementptr inbounds i8*, i8** %1, i64 5
%78 = bitcast i8** %77 to i8***
store i8** %76, i8*** %78
%79 = bitcast i8** %76 to i8***
store i8** %1, i8*** %79
br label %80
80: ; preds = %75, %71
%81 = getelementptr inbounds i8*, i8** %1, i64 2
%82 = load i8*, i8** %81
%83 = icmp eq i8* %82, null
br i1 %83, label %99, label %84
84: ; preds = %80
%85 = bitcast i8* %82 to i8**
tail call void @Huff_IncrementFreq_r(i8** %0, i8** %85)
%86 = load i8*, i8** %34
%87 = load i8*, i8** %81
%88 = icmp eq i8* %86, %87
br i1 %88, label %89, label %99
89: ; preds = %84
%90 = tail call i32 @Huff_SwapTrees(i8** %1, i8* %86)
%91 = getelementptr inbounds i8*, i8** %1, i64 5
%92 = bitcast i8** %91 to i8***
%93 = load i8**, i8*** %92
%94 = load i8*, i8** %93
%95 = bitcast i8** %1 to i8*
%96 = icmp eq i8* %94, %95
br i1 %96, label %97, label %99
97: ; preds = %89
%98 = load i8*, i8** %81
store i8* %98, i8** %93
br label %99
99: ; preds = %80, %89, %97, %84, %2
ret void
}