LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: j84guo[P]cake/cake.cpp
// Function: processTarget(Target&)
bool processTarget(Target& tgt)
{
    for (const string& task : tgt.tasks) {
        if (!doTask(task)) {
            taskError(task);
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3920
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3990
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3950
testb $0x1, %al
jne 0x3295
jmp 0x3311
leaq -0x20(%rbp), %rdi
callq 0x3a80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x20d0
movq -0x68(%rbp), %rdi
callq 0x3140
movb %al, -0x5d(%rbp)
jmp 0x32c1
movb -0x5d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x69(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2140
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x32db
jmp 0x3301
movq -0x30(%rbp), %rdi
callq 0x2a80
movb $0x0, -0x1(%rbp)
jmp 0x3315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2140
jmp 0x3320
jmp 0x3303
leaq -0x20(%rbp), %rdi
callq 0x39e0
jmp 0x3282
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2390
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3920
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3990
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3950
testb $0x1, %al
jne 0x3375
jmp 0x33b7
leaq -0x28(%rbp), %rdi
callq 0x3a80
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3a50
movq %rax, %rdi
callq 0x3250
testb $0x1, %al
jne 0x33aa
movq -0x38(%rbp), %rdi
callq 0x2a40
movb $0x0, -0x1(%rbp)
jmp 0x33bb
jmp 0x33ac
leaq -0x28(%rbp), %rdi
callq 0x39e0
jmp 0x3362
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movb %cl, %al
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
movq 0x45b02(%rip), %rdi     # 0x92fd8
movq 0x45ad3(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0xb0(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x45ab4(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x10(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0xb8(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
movb 0xaf(%rsp), %al
leaq 0x48(%rsp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x51b60
leaq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x51f10
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x51f20
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x4d5df
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x45a5f(%rip), %rdi     # 0x92fd8
leaq 0x30091(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x8(%rsp)
jmp 0x4d58c
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x492c0
movq %rax, (%rsp)
jmp 0x4d5a1
movq (%rsp), %rdi
movq 0x45a04(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4d5b3
jmp 0x4d5b5
movq 0x38(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x38(%rsp)
jmp 0x4d55c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x51f40
jmp 0x4d5f1
leaq 0x48(%rsp), %rdi
callq 0x51f40
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x49520
nopl (%rax,%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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:
subq $0xa8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x453cd(%rip), %rdi     # 0x92fd8
movq 0x4539e(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x90(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x4537f(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x28(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x53590
leaq 0x40(%rsp), %rdi
callq 0x537e0
movq %rax, 0x20(%rsp)
jmp 0x4dc6e
movq 0x20(%rsp), %rax
cmpq $0x0, %rax
je 0x4dcf5
movq 0x45358(%rip), %rdi     # 0x92fd8
leaq 0x2f98a(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x18(%rsp)
jmp 0x4dc93
leaq 0x40(%rsp), %rdi
callq 0x537f0
movq %rax, 0x10(%rsp)
jmp 0x4dca4
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x492c0
movq %rax, 0x8(%rsp)
jmp 0x4dcba
movq 0x8(%rsp), %rdi
movq 0x452ea(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4dccd
leaq 0x40(%rsp), %rdi
callq 0x53800
jmp 0x4dcd9
jmp 0x4dc5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x53810
jmp 0x4dd07
leaq 0x40(%rsp), %rdi
callq 0x53810
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x49520
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x4514d(%rip), %rdi     # 0x92fd8
movq 0x4511e(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x80(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x450ff(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x18(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x88(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x567c0
leaq 0x30(%rsp), %rdi
callq 0x54390
cmpq $0x0, %rax
je 0x4df5e
movq 0x450e4(%rip), %rdi     # 0x92fd8
leaq 0x2f716(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x10(%rsp)
jmp 0x4df07
leaq 0x30(%rsp), %rdi
callq 0x54b90
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x492c0
movq %rax, 0x8(%rsp)
jmp 0x4df25
movq 0x8(%rsp), %rdi
movq 0x4507f(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4df38
leaq 0x30(%rsp), %rdi
callq 0x54bf0
jmp 0x4dedd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x54d30
jmp 0x4df70
leaq 0x30(%rsp), %rdi
callq 0x54d30
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x49520
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x44f19(%rip), %rdi     # 0x92fd8
movq 0x44eea(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x44ece(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x10(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x56c20
leaq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x56e70
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x56ea0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x56ed0
testb $0x1, %al
jne 0x4e148
jmp 0x4e1c0
leaq 0x38(%rsp), %rdi
callq 0x56ef0
movq %rax, 0x28(%rsp)
movq 0x44e7a(%rip), %rdi     # 0x92fd8
leaq 0x2f4ac(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x8(%rsp)
jmp 0x4e171
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x492c0
movq %rax, (%rsp)
jmp 0x4e186
movq (%rsp), %rdi
movq 0x44e1f(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4e198
jmp 0x4e19a
leaq 0x38(%rsp), %rdi
callq 0x56f10
jmp 0x4e133
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x56f30
jmp 0x4e1cf
leaq 0x48(%rsp), %rdi
callq 0x56f30
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x49520
nopl (%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x44c99(%rip), %rdi     # 0x92fd8
movq 0x44c6a(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x44c4e(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x10(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x57e10
leaq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x58070
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x580a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x580d0
testb $0x1, %al
jne 0x4e3c8
jmp 0x4e440
leaq 0x38(%rsp), %rdi
callq 0x58110
movq %rax, 0x28(%rsp)
movq 0x44bfa(%rip), %rdi     # 0x92fd8
leaq 0x2f22c(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x8(%rsp)
jmp 0x4e3f1
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x492c0
movq %rax, (%rsp)
jmp 0x4e406
movq (%rsp), %rdi
movq 0x44b9f(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4e418
jmp 0x4e41a
leaq 0x38(%rsp), %rdi
callq 0x58120
jmp 0x4e3b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x58140
jmp 0x4e44f
leaq 0x48(%rsp), %rdi
callq 0x58140
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x49520
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x44a0d(%rip), %rdi     # 0x92fd8
movq 0x449de(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x80(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x449bf(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x18(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x88(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x59770
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x59a00
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x59a30
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x59a60
testb $0x1, %al
jne 0x4e65a
jmp 0x4e6d4
leaq 0x40(%rsp), %rdi
callq 0x59a80
movq %rax, 0x30(%rsp)
movq 0x44968(%rip), %rdi     # 0x92fd8
leaq 0x2ef9a(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x10(%rsp)
jmp 0x4e683
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x492c0
movq %rax, 0x8(%rsp)
jmp 0x4e699
movq 0x8(%rsp), %rdi
movq 0x4490b(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4e6ac
jmp 0x4e6ae
leaq 0x40(%rsp), %rdi
callq 0x59aa0
jmp 0x4e645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x59ad0
jmp 0x4e6e6
leaq 0x50(%rsp), %rdi
callq 0x59ad0
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x49520
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x4475d(%rip), %rdi     # 0x92fd8
movq 0x4472e(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x80(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x4470f(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x10(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x88(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x5b6e0
leaq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5b970
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5b9a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5b9d0
testb $0x1, %al
jne 0x4e90a
jmp 0x4e982
leaq 0x38(%rsp), %rdi
callq 0x5b9f0
movq %rax, 0x28(%rsp)
movq 0x446b8(%rip), %rdi     # 0x92fd8
leaq 0x2ecea(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x8(%rsp)
jmp 0x4e933
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x492c0
movq %rax, (%rsp)
jmp 0x4e948
movq (%rsp), %rdi
movq 0x4465d(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4e95a
jmp 0x4e95c
leaq 0x38(%rsp), %rdi
callq 0x5ba10
jmp 0x4e8f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5ba40
jmp 0x4e994
leaq 0x48(%rsp), %rdi
callq 0x5ba40
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x49520
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x444bd(%rip), %rdi     # 0x92fd8
movq 0x4448e(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x90(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x4446f(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x28(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x5eae0
leaq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x5ed40
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x5ed70
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5eda0
testb $0x1, %al
jne 0x4ebad
jmp 0x4ec5c
leaq 0x50(%rsp), %rdi
callq 0x5edc0
movq %rax, 0x40(%rsp)
movq 0x44415(%rip), %rdi     # 0x92fd8
leaq 0x2ea47(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x20(%rsp)
jmp 0x4ebd6
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x492c0
movq %rax, 0x18(%rsp)
jmp 0x4ebec
movq 0x18(%rsp), %rdi
leaq 0x2eb62(%rip), %rsi     # 0x7d75a
callq 0x49300
movq %rax, 0x10(%rsp)
jmp 0x4ec04
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x20, %rsi
callq 0x492c0
movq %rax, 0x8(%rsp)
jmp 0x4ec1e
movq 0x8(%rsp), %rdi
movq 0x44386(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4ec31
jmp 0x4ec33
leaq 0x50(%rsp), %rdi
callq 0x5ede0
jmp 0x4eb95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5ee10
jmp 0x4ec6e
leaq 0x60(%rsp), %rdi
callq 0x5ee10
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x49520
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x4419d(%rip), %rdi     # 0x92fd8
movq 0x4416e(%rip), %rsi     # 0x92fb0
callq 0x49360
movq %rax, %rdi
movq 0x90(%rsp), %rsi
callq 0x49300
movq %rax, %rdi
movq 0x4414f(%rip), %rsi     # 0x92fb0
callq 0x49360
movq 0x20(%rsp), %rdi
callq 0x4ca90
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x6b100
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x61860
leaq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x61ac0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x61af0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x61b20
testb $0x1, %al
jne 0x4eecd
jmp 0x4ef7a
leaq 0x48(%rsp), %rdi
callq 0x61b40
movq %rax, 0x38(%rsp)
movq 0x440f5(%rip), %rdi     # 0x92fd8
leaq 0x2e727(%rip), %rsi     # 0x7d611
callq 0x49300
movq %rax, 0x18(%rsp)
jmp 0x4eef6
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x492c0
movq %rax, 0x10(%rsp)
jmp 0x4ef0c
movq 0x10(%rsp), %rdi
leaq 0x2e842(%rip), %rsi     # 0x7d75a
callq 0x49300
movq %rax, 0x8(%rsp)
jmp 0x4ef24
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x20, %rsi
callq 0x492c0
movq %rax, (%rsp)
jmp 0x4ef3d
movq (%rsp), %rdi
movq 0x44068(%rip), %rsi     # 0x92fb0
callq 0x49360
jmp 0x4ef4f
jmp 0x4ef51
leaq 0x48(%rsp), %rdi
callq 0x61b60
jmp 0x4eeb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x61b90
jmp 0x4ef8c
leaq 0x58(%rsp), %rdi
callq 0x61b90
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x49520
nopw %cs:(%rax,%rax)
// File: fieryzig[P]GameServer/TestClient/TestClient.cpp
// Function: init()
void init()
{
    fd = socket(AF_INET, SOCK_STREAM, 0);
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    inet_aton("127.0.0.1", &(addr.sin_addr));
    addr.sin_port = htons(7788);
    int ret = connect(fd, (struct sockaddr*)&addr, sizeof(sockaddr));
    client = new Client(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movl %eax, 0x3ce5(%rip)      # 0x6184
xorps %xmm0, %xmm0
movups %xmm0, 0x3cdf(%rip)     # 0x6188
leaq 0x3cd8(%rip), %rax      # 0x6188
movq %rax, -0x28(%rbp)
movw $0x2, 0x3ccb(%rip)      # 0x6188
leaq 0x1b40(%rip), %rdi      # 0x4004
leaq 0x3cc1(%rip), %rsi      # 0x618c
callq 0x20e0
movl $0x1e6c, %edi           # imm = 0x1E6C
callq 0x2040
movq -0x28(%rbp), %rsi
movw %ax, 0x3ca5(%rip)       # 0x618a
movl 0x3c99(%rip), %edi      # 0x6184
movl $0x10, %edx
callq 0x2100
movl %eax, -0x4(%rbp)
movl $0x2024, %edi           # imm = 0x2024
callq 0x2160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movl 0x3c72(%rip), %esi      # 0x6184
callq 0x28e0
jmp 0x2519
movq -0x20(%rbp), %rax
movq %rax, 0x3c74(%rip)      # 0x6198
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2140
movq -0x10(%rbp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
leaq -0x38(%rbp), %rdi
callq 0x2200
movq 0x3c30(%rip), %rdi      # 0x6198
callq 0x2af0
movl %eax, -0x54(%rbp)
jmp 0x2572
movl -0x54(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq 0x3c19(%rip), %rdi      # 0x6198
leaq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x2b80
movb %al, -0x55(%rbp)
jmp 0x2591
movb -0x55(%rbp), %al
andb $0x1, %al
movb %al, -0x4d(%rbp)
testb $0x1, -0x4d(%rbp)
je 0x25f5
movq 0x3a2a(%rip), %rdi      # 0x5fd0
leaq 0x1a61(%rip), %rsi      # 0x400e
callq 0x2150
jmp 0x25b4
movq 0x3a15(%rip), %rdi      # 0x5fd0
leaq -0x38(%rbp), %rsi
callq 0x2120
movq %rax, -0x60(%rbp)
jmp 0x25ca
movq -0x60(%rbp), %rdi
movq 0x39eb(%rip), %rsi      # 0x5fc0
callq 0x2170
jmp 0x25dc
jmp 0x25f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20c0
jmp 0x25fa
jmp 0x2561
movq -0x48(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: superblocks[P]superblocks/set-lky.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "LKY"; 
	coin_name = "Luckycoin";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 88;

	// superblock (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 8;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 100000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 30000;
	luck_y[1] = 35001;
	reward[1] = 176;

	// superblock (step 2)
	luck_type[2] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[2] = 70000;
	luck_y[2] = 71001;
	reward[2] = 440;

	// superblock (step 3)
	luck_type[3] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[3] = 50000;
	luck_y[3] = 50011;
	reward[3] = 5104;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0x1801(%rip), %rsi      # 0x5e80
callq 0x21a0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0x17f1(%rip), %rsi      # 0x5e84
callq 0x21a0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x58, 0x14c(%rax)
movl $0x2, 0x60(%rax)
movl $0x8, 0x70(%rax)
movl $0x7, 0x80(%rax)
movl $0x1, 0x90(%rax)
movl $0x186a0, 0xa0(%rax)    # imm = 0x186A0
movl $0x3, 0x120(%rax)
movl $0x7530, 0x130(%rax)    # imm = 0x7530
movl $0x88b9, 0x140(%rax)    # imm = 0x88B9
movl $0xb0, 0x150(%rax)
movl $0x3, 0x124(%rax)
movl $0x11170, 0x134(%rax)   # imm = 0x11170
movl $0x11559, 0x144(%rax)   # imm = 0x11559
movl $0x1b8, 0x154(%rax)     # imm = 0x1B8
movl $0x3, 0x128(%rax)
movl $0xc350, 0x138(%rax)    # imm = 0xC350
movl $0xc35b, 0x148(%rax)    # imm = 0xC35B
movl $0x13f0, 0x158(%rax)    # imm = 0x13F0
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x46b0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3e30
movq -0x80(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x45f0
movq %rax, -0x78(%rbp)
jmp 0x3d66
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x33f0
movq -0x90(%rbp), %rdx
leaq 0x93e2(%rip), %rsi      # 0xd174
leaq -0x68(%rbp), %rdi
callq 0x4740
jmp 0x3d9d
movq -0x98(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x46f0
jmp 0x3db3
leaq -0x68(%rbp), %rdi
callq 0x3150
leaq -0x69(%rbp), %rdi
callq 0x3250
leaq -0x28(%rbp), %rdi
callq 0x47f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3e11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3e08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3150
leaq -0x69(%rbp), %rdi
callq 0x3250
leaq -0x28(%rbp), %rdi
callq 0x47f0
movq -0x40(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/min-heap.h
// Function: MinHeapNode<unsigned char, double>::MinHeapNode(unsigned char, double, bool)
MinHeapNode(T data, FrequencyValType freq, bool isInternalNode = false) {
		left = right = NULL;
		this->data = data;
		this->freq = freq;
		m_isInternalNode = isInternalNode;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movsd %xmm0, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
movb -0x9(%rbp), %cl
movb %cl, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/huffman-decoder.cpp
// Function: HuffmanDecoder::decode(unsigned char*, long*)
byte* HuffmanDecoder :: decode(byte *in_buff, fsize_t *buff_len) {
	Log(this, "Started...");

	m_inBuffSize = *buff_len;

	// This will hold bytes of the compressed data;
	// Header + content
	byte *out_buff = NULL;
	
	// Extract header from file buffer.
	HeaderStruct header;
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x28(%rax)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
popq %rbp
retq
nop
nopl (%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/compression-driver.cpp
// Function: CompressionDriver::CompressionDriver(int, char const**)
CompressionDriver :: CompressionDriver(int fCount, const char **fileNames)
					: m_Compressor(0)
{
	Log(this, "Started...");
	if(fCount <= 1)
		throw std::invalid_argument("No input file(s) provided.");

	for(int i = 0; i < fCount - 1; i++) {
		std::string *s = new std::string(fileNames[i]);
		m_fileNames.push_back(*s);
	}
	/* --- Just to check ---
	std::cout << "Filenames: " << std::endl;
	for(std::vector<std::string>::iterator i = m_fileNames.begin(); i != m_fileNames.end(); i++)
		std::cout << *i << std::endl;
	*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x93a0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x93c0
movq -0x40(%rbp), %rax
movq $0x0, 0x38(%rax)
cmpl $0x1, -0xc(%rbp)
jg 0x879c
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x49c2(%rip), %rsi      # 0xd110
callq 0x3420
jmp 0x8755
movq -0x50(%rbp), %rdi
movq 0xb878(%rip), %rsi      # 0x13fd8
movq 0xb861(%rip), %rdx      # 0x13fc8
callq 0x33b0
jmp 0x887e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3180
jmp 0x8863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x8863
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x885d
movl $0x20, %edi
callq 0x3210
movq %rax, -0x58(%rbp)
jmp 0x87c4
movb $0x1, -0x32(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33f0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x4740
jmp 0x87f8
movb $0x0, -0x32(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3250
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
movq -0x30(%rbp), %rsi
callq 0x93e0
jmp 0x8820
jmp 0x8822
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x87a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3250
testb $0x1, -0x32(%rbp)
jne 0x884d
jmp 0x885b
movq -0x58(%rbp), %rdi
movl $0x20, %esi
callq 0x3220
jmp 0x8863
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9450
movq -0x40(%rbp), %rdi
callq 0x94b0
movq -0x20(%rbp), %rdi
callq 0x33e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4888(%rip), %rsi      # 0xd12b
callq 0x30b0
cmpl $0x0, %eax
jne 0x88f2
movl $0x50, %edi
callq 0x3210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x94d0
jmp 0x88c8
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
jmp 0x892f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x50, %esi
callq 0x3220
jmp 0x8935
movq 0xb6f7(%rip), %rdi      # 0x13ff0
leaq 0x483a(%rip), %rsi      # 0xd13a
callq 0x3200
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq 0x48b6(%rip), %rsi      # 0xd1d1
callq 0x3200
movq %rax, %rdi
movq 0xb676(%rip), %rsi      # 0x13fa0
callq 0x3230
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x38(%rax)
jne 0x89af
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x33f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x47ee(%rip), %rsi      # 0xd174
callq 0x4740
jmp 0x898d
leaq -0x11(%rbp), %rdi
callq 0x3250
jmp 0x89c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3250
jmp 0x89ca
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x95b0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/compression-driver.cpp
// Function: getFileSize(std::basic_fstream<char, std::char_traits<char>>&)
static inline fsize_t getFileSize(std::fstream& f) {
	Log_static("Started...");

	if(!f.is_open())
		return -1;
	f.seekg(0, f.end);
	fsize_t file_size = f.tellg(); // This may also return -1
	f.seekg(0, f.beg);
	return file_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33c0
testb $0x1, %al
jne 0x8e03
movq $-0x1, -0x8(%rbp)
jmp 0x8e4a
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3300
movq -0x10(%rbp), %rdi
callq 0x33d0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9e30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3300
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: get_header_size(HeaderStruct*)
size_t get_header_size(HeaderStruct* header) {
    Log_static("Started...");
    if(!header)
        return -1;

    // XXX... Note that this code will work incorrectly if
    // this function is called for some other input file
    // within a lifetime of the program.
    // So I recommend replace the below 3 lines of code with just:
    // size_t ret = 0;
    size_t ret = 0;

    ret = sizeof(int) + sizeof(size_t) * 2 + 1; // header_size + original_size + compressed_size + nSyms
    ret += header->nSyms * sizeof(*header->cw_table); // Total summation of sizes of each cw_table entry.
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa889
movq $-0x1, -0x8(%rbp)
jmp 0xa8b5
movq $0x0, -0x18(%rbp)
movq $0x15, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %eax
imulq $0x3, %rax, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa8dc
jmp 0xa9fa
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3130
movq -0x10(%rbp), %rdi
callq 0xaf10
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x8(%rbp), %rax
movzbl 0x18(%rax), %eax
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaf30
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaf60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf90
testb $0x1, %al
jne 0xa971
jmp 0xa9fa
leaq -0x28(%rbp), %rdi
callq 0xafc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xaa00
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x3360
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaff0
jmp 0xa95b
addq $0x40, %rsp
popq %rbp
retq
// File: irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: str2bits(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static uint8_t str2bits(const std::string &str) {
    Log_static("Started...");

    uint8_t ret = 0,
            l = str.length()-1,
            i = 0;

    while(i < str.length()) {
        if(str[i] == '1')
            ret |= (0x1 << l);
        else if(str[i] == '0')
            ret &= ~(0x1 << l);
        --l; ++i;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3360
subq $0x1, %rax
movb %al, -0xa(%rbp)
movb $0x0, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3360
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0xaab7
movq -0x8(%rbp), %rdi
movzbl -0xb(%rbp), %eax
movl %eax, %esi
callq 0x3270
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0xaa70
movzbl -0xa(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movzbl -0x9(%rbp), %eax
orl %ecx, %eax
movb %al, -0x9(%rbp)
jmp 0xaaa2
movq -0x8(%rbp), %rdi
movzbl -0xb(%rbp), %eax
movl %eax, %esi
callq 0x3270
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xaaa0
movzbl -0xa(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
movzbl -0x9(%rbp), %eax
andl %ecx, %eax
movb %al, -0x9(%rbp)
jmp 0xaaa2
movb -0xa(%rbp), %al
addb $-0x1, %al
movb %al, -0xa(%rbp)
movb -0xb(%rbp), %al
addb $0x1, %al
movb %al, -0xb(%rbp)
jmp 0xaa24
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaae4
movq $-0x1, -0x8(%rbp)
jmp 0xabfb
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jge 0xaba9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movzbl -0x31(%rbp), %eax
leaq (%rax,%rax,2), %rax
addq %rax, %rsi
callq 0xb020
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %xmm1
movaps 0x26d4(%rip), %xmm2     # 0xd210
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x26d8(%rip), %xmm2     # 0xd220
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x24a5(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl -0x31(%rbp), %ecx
leaq (%rcx,%rcx,2), %rcx
movzbl 0x2(%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0xaaf8
movsd -0x30(%rbp), %xmm0
movsd 0x264a(%rip), %xmm1     # 0xd200
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3060
movsd 0x2637(%rip), %xmm2     # 0xd208
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: dump_header(HeaderStruct*, unsigned char*)
void dump_header(HeaderStruct* header, byte* buff) {
    Log_static("Started...");
    if(!header || !buff)
        return; // TODO... Create a NullArgumentException class

    byte *temp = buff;

    // FIXME... Examine in tests properly.
    memcpy((int*)buff, (int*)(&header->header_size), sizeof(int));

    // XXX...Important
    // Move buff ptr as the same no of bytes as the distance between
    // header.header_size and header.original_size.
    // This allows buff to take the exact image of the header structure
    // including structure padding bytes.
    // This is done all other similar steps below.
    buff += (uint64_t)((uint64_t)&header->original_size - (uint64_t)&header->header_size);

    memcpy((size_t*)buff, (size_t*)(&header->original_size), sizeof(size_t));
    buff += (uint64_t)((uint64_t)&header->compressed_size - (uint64_t)&header->original_size);
    memcpy((size_t*)buff, (size_t*)(&header->compressed_size), sizeof(size_t));
    buff += (uint64_t)((uint64_t)&header->nSyms - (uint64_t)&header->compressed_size);

    buff[0] = header->nSyms;
    buff += (uint64_t)((uint64_t)&header->cw_table - (uint64_t)&header->nSyms);

    size_t cw_table_size = sizeof(*header->cw_table) * header->nSyms;
    memcpy(buff, header->cw_table, cw_table_size);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xac2e
cmpq $0x0, -0x10(%rbp)
jne 0xac33
jmp 0xacff
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x18(%rax), %eax
imulq $0x3, %rax, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x31b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xad40
cmpq $0x0, -0x10(%rbp)
je 0xad40
cmpq $0x0, -0x20(%rbp)
jne 0xad45
jmp 0xae34
leaq -0x48(%rbp), %rdi
callq 0xb880
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0xadec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x4c(%rbp), %eax
addq %rax, %rsi
callq 0xae50
movq %rax, -0x70(%rbp)
jmp 0xad7b
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x1(%rax), %esi
movzbl 0x2(%rax), %edx
leaq -0x48(%rbp), %rdi
callq 0xc010
jmp 0xad9a
jmp 0xaddc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xae3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xae3d
movq -0x58(%rbp), %rdi
callq 0x30e0
movq %rax, -0x68(%rbp)
movl $0x1, %edi
callq 0x32a0
jmp 0xadde
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xad55
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc160
movq %rax, -0x78(%rbp)
jmp 0xae03
leaq -0x48(%rbp), %rdi
callq 0xb050
movl %eax, -0x84(%rbp)
jmp 0xae14
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x31b0
leaq -0x48(%rbp), %rdi
callq 0xb070
addq $0x90, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xb070
movq -0x58(%rbp), %rdi
callq 0x33e0
nop