LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/j84guo[P]cake/cake.cpp
// Function: processTargets(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Target, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Target>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool processTargets(TargetMap& nodes, vector<string>& order)
{
    for (const string& name : order) {
        if (!processTarget(nodes.at(name))) {
            targetError(name);
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movb $0x1, %bl
cmpq %r12, %r14
je 0x2f5b
movq %rdi, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e4c
testq %rax, %rax
je 0x2f66
addq $0x28, %rax
movq %rax, %rdi
callq 0x2e61
testb %al, %al
je 0x2f51
addq $0x20, %r14
cmpq %r12, %r14
jne 0x2f26
jmp 0x2f5b
movq %r14, %rdi
callq 0x27ea
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21d0(%rip), %rdi      # 0x513d
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/j84guo[P]cake/cake.cpp
// Function: main
int main()
{
    vector<string> lines;
    if (!readFile("Cakefile", lines)) {
        perror("readFile");
        return 1;
    }

    TargetMap nodes;
    if (!parseTargets(nodes, lines))
        return 1;

    vector<string> order;
    sortTargets(nodes, order);

    cout << "[...Target Order...]\n";
    for (auto& name : order)
        cout << name << "\n";

    cout << "[...Processing...]\n";
    return processTargets(nodes, order) ? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x88(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x20d4(%rip), %rsi      # 0x5079
leaq 0x20d5(%rip), %rdx      # 0x5081
leaq -0x98(%rbp), %rdi
callq 0x3494
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x25a1
movl %eax, %ebx
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0x2fe5
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2180
testb %bl, %bl
je 0x3102
leaq -0x68(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2a39
movl $0x1, %ebx
testb %al, %al
je 0x30db
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq -0x98(%rbp), %rdi
callq 0x2d00
movq 0x4f7f(%rip), %rdi      # 0x7fd0
leaq 0x2033(%rip), %rsi      # 0x508b
movl $0x15, %edx
callq 0x21b0
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
cmpq %r12, %r15
je 0x30a5
movq 0x4f5a(%rip), %rbx      # 0x7fd0
leaq 0x2036(%rip), %r14      # 0x50b3
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x21b0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21b0
addq $0x20, %r15
cmpq %r12, %r15
jne 0x307d
movq 0x4f24(%rip), %rdi      # 0x7fd0
leaq 0x1fee(%rip), %rsi      # 0x50a1
movl $0x13, %edx
callq 0x21b0
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2f0a
xorb $0x1, %al
movzbl %al, %ebx
leaq -0x40(%rbp), %rdi
callq 0x31b6
leaq -0x98(%rbp), %rdi
callq 0x32e8
leaq -0x60(%rbp), %rdi
callq 0x31b6
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f79(%rip), %rdi      # 0x5082
callq 0x2130
movl $0x1, %ebx
jmp 0x30e7
movq %rax, %rbx
jmp 0x314d
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0x3159
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2180
jmp 0x3159
movq %rax, %rbx
jmp 0x3159
jmp 0x3141
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x31b6
leaq -0x98(%rbp), %rdi
callq 0x32e8
leaq -0x60(%rbp), %rdi
callq 0x31b6
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 3ul>(std::shared_ptr<swxJson::Json>, char const*, char const*, bool)
void test_array(JsonPtr json, const char* key, const char* desc, bool compatibleMode)
{
	cout<<endl<<desc<<endl;

	std::array<K, N> elemArray = (*json)[key].wantArray<K, N>(compatibleMode);
	for (auto& element: elemArray)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e141(%rip), %r12     # 0x33fd8
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r12
testq %r13, %r13
je 0x15edf
movq %r13, %rdi
callq 0x120e0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x15efa
movq (%r12), %rax
movq -0x18(%rax), %rax
movq %r12, %rdi
addq %rax, %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r15), %rdi
movq %r14, %rsi
callq 0x21ff8
movzbl %bl, %edx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x18f9a
movl $0x8, %r13d
leaq 0x60(%rsp), %rbx
movq 0x1e08b(%rip), %r14     # 0x33fd8
leaq 0x136b9(%rip), %r15     # 0x2960d
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x122f0
movq -0x8(%rsp,%r13), %rsi
movq (%rsp,%r13), %rdx
movq %r14, %rdi
callq 0x122f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
addq $0x20, %r13
cmpq $0x68, %r13
jne 0x15f54
movq $-0x60, %rbx
leaq 0x50(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x15fc9
movq (%r14), %rsi
incq %rsi
callq 0x122a0
addq $-0x20, %r14
addq $0x20, %rbx
jne 0x15fb5
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12470
movq %r14, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_queue<int>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_queue(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::queue<K> elemQueue = (*json)[key].wantQueue<K>();
	while (elemQueue.size())
	{
		cout<<"Element: "<<elemQueue.front()<<endl;
		elemQueue.pop();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d788(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x16897
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x168b1
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a232
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rax
movq 0x1d6d6(%rip), %rbx     # 0x33fd8
leaq 0x12d04(%rip), %r14     # 0x2960d
movq 0x38(%rsp), %rdx
movq 0x50(%rsp), %rsi
movq %rsi, %rdi
subq 0x30(%rsp), %rdi
shrq $0x3, %rdi
cmpq $0x1, %rsi
adcq $-0x1, %rdi
shlq $0x7, %rdi
subq 0x40(%rsp), %rdx
sarq $0x2, %rdx
addq %rdi, %rdx
subq %rcx, %rax
sarq $0x2, %rax
addq %rdx, %rax
je 0x169e5
movl $0x9, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x122f0
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
leaq -0x4(%rax), %rdx
cmpq %rdx, %rcx
je 0x169a9
addq $0x4, %rcx
jmp 0x169db
movq 0x20(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x122a0
movq 0x30(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
leaq 0x200(%rcx), %rax
movq %rax, 0x28(%rsp)
movq %rcx, 0x18(%rsp)
jmp 0x16909
leaq 0x8(%rsp), %rdi
callq 0x1a744
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a744
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_deque<int>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_deque(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::deque<K> elemQueue = (*json)[key].wantDeque<K>();
	while (elemQueue.size())
	{
		cout<<"Element: "<<elemQueue.front()<<endl;
		elemQueue.pop_front();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d41a(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x16c05
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x16c1f
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a902
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rax
movq 0x1d368(%rip), %rbx     # 0x33fd8
leaq 0x12996(%rip), %r14     # 0x2960d
movq 0x38(%rsp), %rdx
movq 0x50(%rsp), %rsi
movq %rsi, %rdi
subq 0x30(%rsp), %rdi
shrq $0x3, %rdi
cmpq $0x1, %rsi
adcq $-0x1, %rdi
shlq $0x7, %rdi
subq 0x40(%rsp), %rdx
sarq $0x2, %rdx
addq %rdi, %rdx
subq %rcx, %rax
sarq $0x2, %rax
addq %rdx, %rax
je 0x16d53
movl $0x9, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x122f0
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
leaq -0x4(%rax), %rdx
cmpq %rdx, %rcx
je 0x16d17
addq $0x4, %rcx
jmp 0x16d49
movq 0x20(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x122a0
movq 0x30(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
leaq 0x200(%rcx), %rax
movq %rax, 0x28(%rsp)
movq %rcx, 0x18(%rsp)
jmp 0x16c77
leaq 0x8(%rsp), %rdi
callq 0x1a744
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a744
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_list<int>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_list(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::list<K> elemList = (*json)[key].wantList<K>();
	for (auto& element: elemList)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d0ea(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x16f35
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x16f4f
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ac26
movq 0x1d040(%rip), %r14     # 0x33fd8
leaq 0x1266e(%rip), %r15     # 0x2960d
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x16ff3
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x122f0
movl 0x10(%r13), %esi
movq %r14, %rdi
callq 0x12420
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
jmp 0x16fa2
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x17015
movq (%rdi), %r14
movl $0x18, %esi
callq 0x122a0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x17000
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x17048
movq (%rdi), %r15
movl $0x18, %esi
callq 0x122a0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x17033
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_vector<int>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_vector(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::vector<K> elemVector = (*json)[key].wantVector<K>();
	for (auto& element: elemVector)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1ce10(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x1720f
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x17229
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b25a
movq (%r14), %rbx
movq 0x8(%r14), %r13
cmpq %r13, %rbx
je 0x172d7
movq 0x1cd5a(%rip), %r14     # 0x33fd8
leaq 0x12388(%rip), %r15     # 0x2960d
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x122f0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x12420
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
addq $0x4, %rbx
cmpq %r13, %rbx
jne 0x17285
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x172ec
movq 0x18(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x122a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17314
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x122a0
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_set(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::set<K> elemSet = (*json)[key].wantSet<K>();
	for (auto& element: elemSet)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1cc9f(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x17380
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x1739a
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
movq %rsp, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b558
movq 0x18(%rbx), %rbx
leaq 0x8(%rsp), %r13
cmpq %r13, %rbx
je 0x17450
movq 0x1cbe9(%rip), %r14     # 0x33fd8
leaq 0x12217(%rip), %r15     # 0x2960d
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x122f0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x122f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rbx, %rdi
callq 0x12300
movq %rax, %rbx
cmpq %r13, %rax
jne 0x173f6
movq %rsp, %rdi
callq 0x1b850
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b850
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_unordered_set(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::unordered_set<K> elemSet = (*json)[key].wantUnorderedSet<K>();
	for (auto& element: elemSet)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c9ec(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x17633
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x1764d
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
movq %rsp, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1bb4a
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x176f9
movq 0x1c93b(%rip), %rbx     # 0x33fd8
leaq 0x11f69(%rip), %r14     # 0x2960d
movl $0x9, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x122f0
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x122f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r12), %r12
testq %r12, %r12
jne 0x176a4
movq %rsp, %rdi
callq 0x1c0e8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1c0e8
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_dict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_dict(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::map<std::string, K> elemMap = (*json)[key].wantDict<K>();
	for (auto& pp: elemMap)
		cout<<"Element: "<<pp.first<<":"<<pp.second<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c750(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x178cf
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x178e9
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c59a
movq 0x18(%rbx), %rbx
leaq 0x10(%rsp), %rbp
cmpq %rbp, %rbx
je 0x179cf
movq 0x1c694(%rip), %r14     # 0x33fd8
leaq 0x11cc2(%rip), %r15     # 0x2960d
leaq 0x11e44(%rip), %r12     # 0x29796
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x122f0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x122f0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x122f0
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %r13, %rdi
callq 0x122f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r13, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rbx, %rdi
callq 0x121a0
movq %rax, %rbx
cmpq %rbp, %rax
jne 0x17952
leaq 0x8(%rsp), %rdi
callq 0x1cb4e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1cb4e
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_unordered_dict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_unordered_dict(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::unordered_map<std::string, K> elemMap = (*json)[key].wantUnorderedDict<K>();
	for (auto& pp: elemMap)
		cout<<"Element: "<<pp.first<<":"<<pp.second<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c430(%rip), %r15     # 0x33fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq %rax, %r15
testq %r12, %r12
je 0x17bef
movq %r12, %rdi
callq 0x120e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x122f0
jmp 0x17c09
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x12400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r15, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21ff8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d126
movq 0x10(%rbx), %r13
testq %r13, %r13
je 0x17ce3
movq 0x1c379(%rip), %rbx     # 0x33fd8
leaq 0x119a7(%rip), %r14     # 0x2960d
leaq 0x11b29(%rip), %r15     # 0x29796
movl $0x9, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x122f0
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
movq %rbx, %rdi
callq 0x122f0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x122f0
movq 0x28(%r13), %rsi
movq 0x30(%r13), %rdx
movq %r12, %rdi
callq 0x122f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x12260
movsbl %al, %esi
movq %r12, %rdi
callq 0x12030
movq %rax, %rdi
callq 0x12190
movq (%r13), %r13
testq %r13, %r13
jne 0x17c6d
leaq 0x8(%rsp), %rdi
callq 0x1d6f6
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d6f6
movq %rbx, %rdi
callq 0x12430
// File: /workspace/github_cpp_makefile_star2_O3/fieryzig[P]GameServer/TestClient/TestClient.cpp
// Function: recv_thread()
void recv_thread()
{
    PacketInfo pi;
    string content;
    for (;;) {
        int ret = client->Recv();
        bool flag = client->hasMsg(&pi, content);
        if (flag) {
            cout << "Recv: ";
            cout << content << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x60(%rbp), %rbx
leaq -0x48(%rbp), %r14
movq 0x3ae9(%rip), %r15      # 0x5fd0
leaq 0x1b3c(%rip), %r12      # 0x402a
movq 0x3c7b(%rip), %rdi      # 0x6170
callq 0x29c4
movq 0x3c6f(%rip), %rdi      # 0x6170
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2a5a
testb %al, %al
je 0x24ee
movl $0x6, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x2180
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
jmp 0x24ee
jmp 0x255e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2573
callq 0x2130
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/huffman-encoder.cpp
// Function: HuffmanEncoder::buildHuffmanTree()
void HuffmanEncoder :: buildHuffmanTree() {
	Log(this, "Started...");

	MinHeapNode<byte, double> *left, *right, *top;

	// Create a min heap & inserts all characters of data[]
	//@@@ MinHeap<byte, double> minHeap;
	for(auto& x : *m_frequencyTable)
		m_huffmanTree->push(new MinHeapNode<byte, double>(x.first, x.second));
	//printMinheap(*m_huffmanTree);

	// Iterate while size of heap doesn't become 1
	while (m_huffmanTree->size() != 1)
	{
		// Extract the two minimum freq items from min heap
		left = m_huffmanTree->top();
		m_huffmanTree->pop();

		right = m_huffmanTree->top();
		m_huffmanTree->pop();

		// Create a new internal node with frequency equal to the
		// sum of the two nodes frequencies. Make the two extracted
		// node as left and right children of this new node. Add
		// this node to the min heap.
		// 0x00 is a special value for internal nodes.
		top = new MinHeapNode<byte, double>(0x00, left->freq + right->freq, true);
		top->left = left;
		top->right = right;
		m_huffmanTree->push(top);
	}
	//printMinheap(*m_huffmanTree);
	//traversePreorder(m_huffmanTree->top(), "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x2879
movq %rsp, %r14
movq 0x38(%rbx), %r15
movl $0x28, %edi
callq 0x21e0
movb 0x8(%r12), %cl
movsd 0x10(%r12), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rax)
movb %cl, (%rax)
movsd %xmm0, 0x8(%rax)
movb $0x0, 0x20(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b92
movq (%r12), %r12
testq %r12, %r12
jne 0x2835
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
je 0x28f6
movq %rsp, %r14
movq (%rax), %r15
callq 0x2bec
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %r12
callq 0x2bec
movl $0x28, %edi
callq 0x21e0
movsd 0x8(%r15), %xmm0
addsd 0x8(%r12), %xmm0
movb $0x0, (%rax)
movsd %xmm0, 0x8(%rax)
movb $0x1, 0x20(%rax)
movq %rax, (%rsp)
movq %r15, 0x10(%rax)
movq %r12, 0x18(%rax)
movq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x2c2e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x2890
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/huffman-encoder.cpp
// Function: HuffmanEncoder::buildCodewordTable()
void HuffmanEncoder :: buildCodewordTable()
{
	Log(this, "Started...");

	/* --- This code is unlikely to happen unless someone really forgets ---
	 * -- Avoided! Since it will unnecessarily occupy each recursion stack --
	 *
	 * If prerequisites doesn't exist
	if(!m_codewordTable || !m_frequencyTable || !m_huffmanTree)
		throw 10;
	*/

	// Huffman tree parser lambda
	std::function<void(MinHeapNode<byte, double>*, const std::string&)>
		huffmanTreeParser;
	huffmanTreeParser =
			[&](MinHeapNode<byte, double>* root, const std::string &codeword) {
				if(root) {
					if(!root->isInternalNode()) {
						(*m_codewordTable)[root->data] = codeword;
						//@@@ std::cout << root->data << ": " << codeword << std::endl;
					}
					huffmanTreeParser(root->left, codeword + "0");
					huffmanTreeParser(root->right, codeword + "1");
				}
			};

	huffmanTreeParser(m_huffmanTree->top(), "");

	/* Just testing
	for(auto &x : *m_codewordTable)
		std::cout << x.first << " : " << x.second << std::endl;
	*/
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x28(%rsp), %rax
movq %rdi, (%rax)
movq %rax, 0x8(%rax)
leaq 0x242(%rip), %rcx       # 0x2b5e
movq %rcx, 0x10(%rax)
leaq 0xcf(%rip), %rcx        # 0x29f6
movq %rcx, 0x18(%rax)
movq 0x38(%rdi), %rax
movq (%rax), %rax
movq (%rax), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x382c(%rip), %rdx      # 0x6171
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x360a
movq %rbx, (%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x29a6
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
callq *0x18(%rdi)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2985
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x299e
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
callq 0x20d0
jmp 0x29ed
movq %rax, %rbx
jmp 0x29cc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x29cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x29e5
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2b86
nop
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/compression-driver.cpp
// Function: CompressionDriver::setCompressor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CompressionDriver :: setCompressor(const std::string& algo) {
	// TODO... Find valid compressor and register it
	Log(this, "Started...");

	// --- This code is just for initial testing purpose ---
	// --- Yea it is currently hard-coded kinda ---
	// --- Later we will add separate module for maintaining registered algorithms ---
	if(algo.compare("Huffman-Coding") == 0)
		m_Compressor = new HuffmanCompressor();
	else
		std::cerr << "[Fatal Error] Invalid compression algorithm \"" << algo << "\"" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x295b(%rip), %rsi      # 0x6128
movq %r14, %rdi
callq 0x20b0
testl %eax, %eax
je 0x3848
movq 0x5810(%rip), %rbx      # 0x8ff0
leaq 0x2950(%rip), %rsi      # 0x6137
movl $0x2d, %edx
movq %rbx, %rdi
callq 0x2200
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
leaq 0x29c1(%rip), %rsi      # 0x61ce
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2150
movl $0x50, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x40ac
movq %r14, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/compression-driver.cpp
// Function: CompressionDriver::getCompressorName[abi:cxx11]() const
std::string CompressionDriver :: getCompressorName() const {
	Log(this, "Started...");
	if(!m_Compressor) {
		Log(this, "[Fatal Error] Unable to get compression name.");
		return "";
	}

	return m_Compressor->name();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x38ab
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3574
jmp 0x38c4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x28b8(%rip), %rdx      # 0x6171
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x360a
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: build_header(HeaderStruct*, std::unordered_map<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<unsigned char>, std::equal_to<unsigned char>, std::allocator<std::pair<unsigned char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void build_header(HeaderStruct *hdr, CodewordTable &cw_table) {
    Log_static("Started...");
    if(!hdr)
        return;

    memset(hdr, 0, sizeof(*hdr));

    hdr->nSyms = cw_table.size();
    hdr->cw_table = new HeaderStruct::codeword_table[hdr->nSyms];

    // Migrate the CodewordTable contents to codeword_table contents
    int i = 0;
    for(auto &x : cw_table) {
        hdr->cw_table[i].symbol = x.first;
        hdr->cw_table[i].codeword = str2bits(x.second);
        hdr->cw_table[i].nBits = x.second.length();
        ++i;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4537
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x18(%rsi), %rax
movzbl %al, %eax
movb %al, 0x18(%rdi)
leaq (%rax,%rax,2), %rdi
callq 0x2030
movq %rax, 0x20(%r14)
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x4530
xorl %esi, %esi
movb 0x8(%rdx), %cl
leaq (%rsi,%rsi,2), %rdi
movb %cl, (%rax,%rdi)
movq 0x18(%rdx), %r8
testq %r8, %r8
je 0x4515
movq 0x10(%rdx), %r10
leal -0x1(%r8), %ecx
movl $0x1, %r11d
xorl %r9d, %r9d
movzbl -0x1(%r10,%r11), %ebx
cmpl $0x30, %ebx
je 0x44f9
cmpl $0x31, %ebx
jne 0x4505
movl $0x1, %ebx
shll %cl, %ebx
orb %bl, %r9b
jmp 0x4505
movl $0x1, %ebx
shll %cl, %ebx
notb %bl
andb %bl, %r9b
movzbl %r11b, %ebx
incq %r11
decb %cl
cmpq %r8, %rbx
jb 0x44dd
jmp 0x451b
xorl %r8d, %r8d
xorl %r9d, %r9d
movb %r9b, 0x1(%rax,%rdi)
movb %r8b, 0x2(%rax,%rdi)
incq %rsi
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x44b9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: get_compressed_size(HeaderStruct*, std::unordered_map<unsigned char, double, std::hash<unsigned char>, std::equal_to<unsigned char>, std::allocator<std::pair<unsigned char const, double>>> const&)
size_t get_compressed_size(HeaderStruct * const hdr, const FrequencyTable &freqsym_map) {
    Log_static("Started...");
    if(!hdr)
        return -1;

    size_t ret;
    double temp1 = 0, temp2 = 0;

    // XXX... Note that this calculates the size in terms of bits.
    // Convert it to bytes before returning.
    for(uint8_t i = 0; i < hdr->nSyms; i++) {
        temp1 = ( (double)freqsym_map.at(hdr->cw_table[i].symbol) * hdr->original_size ) / 100.0; // % to number
        temp2 += (double)hdr->cw_table[i].nBits * temp1;
    }

    temp2 /= 8;
    ret = ceil(temp2);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x45eb
movq %rdi, %r14
cmpb $0x0, 0x18(%rdi)
je 0x45f4
movq %rsi, %rbx
movq 0x20(%r14), %rsi
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
xorl %r12d, %r12d
movsd %xmm0, (%rsp)
addq %r15, %rsi
movq %rbx, %rdi
callq 0x47b2
testq %rax, %rax
je 0x4628
movsd 0x8(%r14), %xmm0
unpcklps 0x1c73(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1c7b(%rip), %xmm0     # 0x6210
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x10(%rax), %xmm1
divsd 0x1a62(%rip), %xmm1     # 0x6010
movq 0x20(%r14), %rsi
movzbl 0x2(%rsi,%r15), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incq %r12
movzbl 0x18(%r14), %eax
addq $0x3, %r15
cmpq %rax, %r12
jb 0x4567
mulsd 0x1c37(%rip), %xmm0     # 0x6220
jmp 0x45f8
movq $-0x1, %rax
jmp 0x461c
xorpd %xmm0, %xmm0
callq 0x2060
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x1c17(%rip), %xmm0     # 0x6228
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1c15(%rip), %rdi      # 0x6244
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: dump_content(HeaderStruct*, unsigned char*, unsigned long, unsigned char*)
void dump_content(HeaderStruct* header, byte *ibuff, size_t ibuff_size, byte* obuff) {
    Log_static("Started...");
    if(!header || !ibuff || !obuff)
        return; // TODO... Create a NullArgumentException class

    // Push the bits into buff according to
    // the codeword_table in the header.
    HeaderStruct::codeword_table *cw_entry;
    //@ BitStream bit_stream(header->compressed_size); // FIXME... Incorrect argument
    BitVector bit_vector;
    uint32_t i;
    for(i = 0; i < ibuff_size; i++) {
        cw_entry = get_cw_entry(header, ibuff+i);

        try {
            bit_vector.appendByte(cw_entry->codeword, cw_entry->nBits);
        } catch(std::overflow_error *e) {
        	Log_static(e->what());
        	exit(1);
            break;
        }

    }

    ::memcpy(obuff, bit_vector.toCharArray(), bit_vector.getNumberOfBytes());

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0x476c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %rdi
callq 0x4a58
testq %r14, %r14
je 0x4736
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movb (%r15,%rbp), %cl
cmpb %cl, 0x4b03(%rip)       # 0x91d0
jne 0x46d8
movq 0x4b22(%rip), %rax      # 0x91f8
jmp 0x471f
movzbl 0x18(%r12), %esi
movq 0x20(%r12), %rax
testq %rsi, %rsi
je 0x470f
movq %rax, %rdi
xorl %edx, %edx
movb (%rdi), %r8b
cmpb %cl, %r8b
je 0x4707
incq %rdx
addq $0x3, %rdi
cmpq %rdx, %rsi
jne 0x46ed
movq %rsi, %rdx
movl %r8d, %ecx
movb %cl, 0x4ac3(%rip)       # 0x91d0
jmp 0x4711
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rcx
addq %rcx, %rax
movq %rax, 0x4ad9(%rip)      # 0x91f8
movzbl 0x1(%rax), %esi
movzbl 0x2(%rax), %edx
movq %r13, %rdi
callq 0x4f2e
incl %ebp
cmpq %r14, %rbp
jb 0x46c3
leaq 0x8(%rsp), %rdi
callq 0x4ffc
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %r14
subl %r14d, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2190
testq %r14, %r14
je 0x476c
movq 0x18(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x21f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4792
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x4792
movq %rbx, %rdi
movl %edx, %esi
callq 0x23a3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x47a9
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/main.cpp
// Function: main
int main(int argc, char **argv) {

	cout << " --- Still under construction ---" << endl;
	Log_static("Started...");
	
	try {
		CompressionDriver driver(argc, (const char**)(argv+1));
		driver.setCompressor("Huffman-Coding");
		cout << "Selected algorithm: " << driver.getCompressorName() << endl;
		driver.compressAll();
	}
	catch(exception &e) {
		Log_static(e.what());
		return FATAR_ERROR;
	}

	return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq 0x4796(%rip), %r14      # 0x8fc0
leaq 0x1a21(%rip), %rsi      # 0x6252
movl $0x21, %edx
movq %r14, %rdi
callq 0x2200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
addq $0x8, %rbx
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x36ac
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18a0(%rip), %rsi      # 0x6128
leaq 0x18a7(%rip), %rdx      # 0x6136
leaq 0x8(%rsp), %rdi
callq 0x360a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x37bc
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x48bf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x46fa(%rip), %rdi      # 0x8fc0
leaq 0x19a7(%rip), %rsi      # 0x6274
movl $0x14, %edx
callq 0x2200
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3882
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x46c9(%rip), %rdi      # 0x8fc0
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x493d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x3c02
leaq 0x28(%rsp), %rdi
callq 0x49ba
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x496c
jmp 0x4974
jmp 0x496c
movq %rdx, %r14
movq %rax, %rbx
jmp 0x499b
movq %rdx, %r14
movq %rax, %rbx
jmp 0x4991
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4991
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x49ba
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x49b5
callq 0x20e0
callq 0x22e0
movl $0x2, %eax
jmp 0x4953
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::stringToBitVector(char const*)
void BitVector::stringToBitVector(const char *str)
{
    int strSize = strlen(str);
    for (int i = 0; i < strSize; i++)
    {
        if (str[i] == '1')
            appendBit(true);
        else if (str[i] == '0')
            appendBit(false);
        else
            //@ throw cRuntimeError("str must represent a binary number");
            throw (new std::overflow_error("BitVector::stringToBitVector(): str must represent a binary number"));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20f0
movq %rax, %r15
testl %r15d, %r15d
jle 0x4b2e
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movzbl (%rbx,%r12), %ecx
movb $0x1, %al
cmpl $0x31, %ecx
je 0x4b17
cmpl $0x30, %ecx
jne 0x4b3a
xorl %eax, %eax
movl 0x18(%r14), %esi
movzbl %al, %edx
movq %r14, %rdi
callq 0x4cbe
incq %r12
cmpq %r12, %r15
jne 0x4b04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x2110
movq %rax, %rbx
movl $0x10, %edi
callq 0x21e0
movq %rax, %r14
leaq 0x1785(%rip), %rsi      # 0x62e0
movq %rax, %rdi
callq 0x2070
movq %r14, (%rbx)
leaq 0x4203(%rip), %rsi      # 0x8d70
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x21f0
jmp 0x4b8c
movq %rax, %r15
movq %rbx, %rdi
callq 0x2170
movq %r15, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::BitVector(unsigned int)
BitVector::BitVector(unsigned int bits)
{
    size = 0;
    if (bits == 0)
        appendBit(false);
    while (bits > 0)
    {
        appendBit(bits % 2);
        bits /= 2;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movups %xmm0, (%rdi)
testl %esi, %esi
je 0x4bd0
movl %esi, %ebp
movl %ebp, %edx
andl $0x1, %edx
movl 0x18(%rbx), %esi
movq %rbx, %rdi
callq 0x4cbe
movl %ebp, %eax
shrl %eax
cmpl $0x1, %ebp
movl %eax, %ebp
ja 0x4bb3
jmp 0x4bdc
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4cbe
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4be3
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4bfa
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::BitVector(unsigned int, unsigned int)
BitVector::BitVector(unsigned int bits, unsigned int size)
{
    this->size = 0;
    if (bits == 0)
        appendBit(false);
    while (bits > 0)
    {
        appendBit(bits % 2);
        bits /= 2;
    }
    if (getSize() < size)
        appendBit(false, size - getSize());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movups %xmm0, (%rdi)
testl %esi, %esi
je 0x4c47
movl %esi, %r14d
movl %r14d, %edx
andl $0x1, %edx
movl 0x18(%rbx), %esi
movq %rbx, %rdi
callq 0x4cbe
movl %r14d, %eax
shrl %eax
cmpl $0x1, %r14d
movl %eax, %r14d
ja 0x4c26
jmp 0x4c53
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4cbe
movl 0x18(%rbx), %r14d
subl %ebp, %r14d
jae 0x4c6e
movl 0x18(%rbx), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4cbe
incl %r14d
jne 0x4c5c
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4c77
jmp 0x4c77
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4c8e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::setBit(int, bool)
void BitVector::setBit(int pos, bool value)
{
    while (containerSize() <= pos)
        bytes.push_back(uint8_t(0));
    if (pos + 1 > size)
        size = pos + 1;
    uint8_t& field = bytes[pos / UINT8_LENGTH];
    if (value)
        field |= 1 << (pos % UINT8_LENGTH);
    else
        field &= ~(1 << (pos % UINT8_LENGTH));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl 0x8(%rdi), %ecx
movq (%rdi), %rax
subl %eax, %ecx
shll $0x3, %ecx
cmpl %esi, %ecx
jg 0x4d03
leaq 0x7(%rsp), %r12
movb $0x0, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5222
movl 0x8(%r15), %ecx
movq (%r15), %rax
subl %eax, %ecx
shll $0x3, %ecx
cmpl %r14d, %ecx
jle 0x4ce2
cmpl %r14d, 0x18(%r15)
jg 0x4d11
leal 0x1(%r14), %ecx
movl %ecx, 0x18(%r15)
leal 0x7(%r14), %edx
testl %r14d, %r14d
cmovnsl %r14d, %edx
sarl $0x3, %edx
andb $0x7, %r14b
movl $0x1, %esi
movl %r14d, %ecx
shll %cl, %esi
movslq %edx, %rcx
movb (%rax,%rcx), %dl
movl %esi, %edi
notb %dil
andb %dl, %dil
orb %sil, %dl
movzbl %dl, %edx
movzbl %dil, %esi
testb %bl, %bl
cmovnel %edx, %esi
movb %sil, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::toggleBit(int)
void BitVector::toggleBit(int pos)
{
    if (pos >= size)
        throw (new std::overflow_error("BitVector::toggleBit(): Bit out of range."));
        //@ throw cRuntimeError("Out of range with bit position %d", pos);

    uint8_t& field = bytes[pos / UINT8_LENGTH];
    field ^= 1 << (pos % UINT8_LENGTH);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl %esi, 0x18(%rdi)
jle 0x4d8a
leal 0x7(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x3, %eax
cltq
andb $0x7, %sil
movl $0x1, %edx
movl %esi, %ecx
shll %cl, %edx
movq (%rdi), %rcx
xorb %dl, (%rcx,%rax)
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x2110
movq %rax, %rbx
movl $0x10, %edi
callq 0x21e0
movq %rax, %r14
leaq 0x14de(%rip), %rsi      # 0x6289
movq %rax, %rdi
callq 0x2070
movq %r14, (%rbx)
leaq 0x3fb3(%rip), %rsi      # 0x8d70
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x21f0
jmp 0x4ddc
movq %rax, %r15
movq %rbx, %rdi
callq 0x2170
movq %r15, %rdi
callq 0x2320