LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::printFreqTable()
void ThresholdSolver::printFreqTable() {
	cout << "Printing Frequency Table." << endl;
	for (int i = 0; i < freqTable.size(); i++)
	{
		for (int j = 0; j<freqTable[i].size(); j++)
			cout << freqTable[i][j] << " ";
		cout << "" << endl;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x195fe(%rip), %rdi     # 0x22fc8
leaq 0xf8d0(%rip), %rsi      # 0x192a1
callq 0x32c0
movq %rax, %rdi
movq 0x195d8(%rip), %rsi     # 0x22fb8
callq 0x3310
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
callq 0xa650
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9aca
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x30, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xa630
movq %rax, %rdi
callq 0x5550
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x9a98
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xa630
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xa000
movl (%rax), %esi
movq 0x19551(%rip), %rdi     # 0x22fc8
callq 0x35a0
movq %rax, %rdi
leaq 0xf690(%rip), %rsi      # 0x19116
callq 0x32c0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x9a1e
movq 0x19529(%rip), %rdi     # 0x22fc8
leaq 0xfc15(%rip), %rsi      # 0x196bb
callq 0x32c0
movq %rax, %rdi
movq 0x19503(%rip), %rsi     # 0x22fb8
callq 0x3310
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x99ed
addq $0x28, %rsp
retq
nop
// File: CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::printTotalFreqTable()
void ThresholdSolver::printTotalFreqTable() {
	cout << "seedNum: " << seedNum << endl;
	for(int i = 0; i < totalFrequency.size(); i++)
	{
		if(totalFrequency[i] != 0)
			cout << i-1 << ": " << totalFrequency[i] << endl;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x194de(%rip), %rdi     # 0x22fc8
leaq 0xf582(%rip), %rsi      # 0x19073
callq 0x32c0
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0xc8(%rax), %esi
callq 0x35a0
movq %rax, %rdi
movq 0x194a5(%rip), %rsi     # 0x22fb8
callq 0x3310
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xa8, %rdi
callq 0x5550
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9bcf
movq 0x10(%rsp), %rdi
addq $0xa8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xa000
cmpl $0x0, (%rax)
je 0x9bbd
movl 0x1c(%rsp), %esi
subl $0x1, %esi
movq 0x19453(%rip), %rdi     # 0x22fc8
callq 0x35a0
movq %rax, %rdi
leaq 0xfbf2(%rip), %rsi      # 0x19776
callq 0x32c0
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
addq $0xa8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xa000
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x35a0
movq %rax, %rdi
movq 0x19400(%rip), %rsi     # 0x22fb8
callq 0x3310
jmp 0x9bbf
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9b20
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: devvoid[P]vini/./vini.hpp
// Function: Vini::Vini(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Vini(std::string path) : ini_file() {
        std::ifstream file;

        file.open(path.c_str());

        std::stringstream stringbuffer;

        stringbuffer << file.rdbuf();

        file.close();
        
        parse_text(stringbuffer.str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq %rsi, -0x3e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3e0(%rbp)
movq %rdi, %rax
movq %rax, -0x3d8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x4690
leaq -0x218(%rbp), %rdi
callq 0x3300
jmp 0x40b0
movq -0x3e8(%rbp), %rdi
callq 0x3100
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3180
jmp 0x40d2
leaq -0x3b0(%rbp), %rdi
callq 0x31c0
jmp 0x40e0
leaq -0x3a0(%rbp), %rax
movq %rax, -0x3f8(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3380
movq %rax, -0x3f0(%rbp)
jmp 0x4103
movq -0x3f0(%rbp), %rsi
movq -0x3f8(%rbp), %rdi
callq 0x3090
jmp 0x4118
leaq -0x218(%rbp), %rdi
callq 0x3080
jmp 0x4126
leaq -0x3d0(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
callq 0x3250
jmp 0x413b
movq -0x3d8(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
callq 0x46b0
jmp 0x4150
leaq -0x3d0(%rbp), %rdi
callq 0x3170
leaq -0x3b0(%rbp), %rdi
callq 0x31e0
leaq -0x218(%rbp), %rdi
callq 0x30b0
addq $0x400, %rsp            # imm = 0x400
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x41ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x41e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x41d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x3170
leaq -0x3b0(%rbp), %rdi
callq 0x31e0
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq -0x3e0(%rbp), %rdi
callq 0x4c90
movq -0x220(%rbp), %rdi
callq 0x33c0
nopw (%rax,%rax)
// File: devvoid[P]vini/./vini.hpp
// Function: Vini::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string get(std::string section, std::string key, std::string default_value) {
        if (ini_file[section][key] != "")
            return ini_file[section][key];
        
        //If it can't find anything, return default value.
        set(section, key, default_value);

        return default_value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %r8, -0xc8(%rbp)
movq %rcx, -0xa0(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, %rax
movq -0xc0(%rbp), %rsi
movq %rdi, -0xb8(%rbp)
movq %rdi, %rdx
movq %rdx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5030
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
leaq 0x5e53(%rip), %rsi      # 0xa0db
callq 0x8e10
testb $0x1, %al
jne 0x4293
jmp 0x42c9
movq -0xc0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x5030
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x5240
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x3110
jmp 0x4398
movq -0xc0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3110
movq -0xa0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3110
jmp 0x42eb
movq -0xc8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x3110
jmp 0x4300
movq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x98(%rbp), %rcx
callq 0x43c0
jmp 0x431d
leaq -0x98(%rbp), %rdi
callq 0x3170
leaq -0x68(%rbp), %rdi
callq 0x3170
leaq -0x48(%rbp), %rdi
callq 0x3170
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x3160
jmp 0x4398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x438d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3170
leaq -0x68(%rbp), %rdi
callq 0x3170
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0x43a8
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: devvoid[P]vini/./vini.hpp
// Function: Vini::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void save(std::string path) {
        std::ofstream file;

        file.open(path.c_str());

        for (vini_file::iterator it = ini_file.begin(); it != ini_file.end(); it++) {
            file << "[" << it->first << "]" << "\n";

            for (vini_content::iterator inner_it = it->second.begin(); inner_it != it->second.end(); inner_it++)
                file << inner_it->first << "=\"" << inner_it->second << "\"\n";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rsi, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x33b0
movq -0x260(%rbp), %rdi
callq 0x3100
movq -0x258(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x3050
jmp 0x446a
movq -0x268(%rbp), %rdi
callq 0x8e40
movq %rax, -0x228(%rbp)
movq -0x268(%rbp), %rdi
callq 0x6390
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x8e70
testb $0x1, %al
jne 0x44ac
jmp 0x464c
leaq 0x5c1f(%rip), %rsi      # 0xa0d2
leaq -0x210(%rbp), %rdi
callq 0x3260
movq %rax, -0x270(%rbp)
jmp 0x44c8
leaq -0x228(%rbp), %rdi
callq 0x8ea0
movq -0x270(%rbp), %rdi
movq %rax, %rsi
callq 0x3240
movq %rax, -0x278(%rbp)
jmp 0x44ec
movq -0x278(%rbp), %rdi
leaq 0x5bda(%rip), %rsi      # 0xa0d4
callq 0x3260
movq %rax, -0x280(%rbp)
jmp 0x4508
movq -0x280(%rbp), %rdi
leaq 0x5bc4(%rip), %rsi      # 0xa0da
callq 0x3260
jmp 0x451d
leaq -0x228(%rbp), %rdi
callq 0x8ea0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x8ec0
movq %rax, -0x238(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x8ea0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x7f70
movq %rax, -0x240(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x8ef0
testb $0x1, %al
jne 0x4577
jmp 0x4630
leaq -0x238(%rbp), %rdi
callq 0x8f20
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
callq 0x3240
movq %rax, -0x288(%rbp)
jmp 0x459b
movq -0x288(%rbp), %rdi
leaq 0x5b2d(%rip), %rsi      # 0xa0d6
callq 0x3260
movq %rax, -0x290(%rbp)
jmp 0x45b7
leaq -0x238(%rbp), %rdi
callq 0x8f20
movq -0x290(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3240
movq %rax, -0x298(%rbp)
jmp 0x45df
movq -0x298(%rbp), %rdi
leaq 0x5aec(%rip), %rsi      # 0xa0d9
callq 0x3260
jmp 0x45f4
jmp 0x45f6
leaq -0x238(%rbp), %rdi
xorl %esi, %esi
callq 0x8f40
movq %rax, -0x248(%rbp)
jmp 0x453c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3350
jmp 0x4661
jmp 0x4632
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
callq 0x8f80
movq %rax, -0x250(%rbp)
jmp 0x447d
leaq -0x210(%rbp), %rdi
callq 0x3350
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: devvoid[P]vini/./vini.hpp
// Function: Vini::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> split(const std::string &s, char delim) {
        std::vector<std::string> elems;

        std::stringstream ss(s);
        std::string item;

        while(std::getline(ss, item, delim)) {
            elems.push_back(item);
        }

        return elems;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1f8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x5380
movq -0x18(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x53a0
movl %eax, -0x1dc(%rbp)
jmp 0x4e48
movl -0x1dc(%rbp), %edx
movq -0x1e8(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
callq 0x3390
jmp 0x4e63
leaq -0x1d8(%rbp), %rdi
callq 0x3330
movsbl -0x19(%rbp), %edx
leaq -0x1a8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x33f0
movq %rax, -0x200(%rbp)
jmp 0x4e8f
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3320
movb %al, -0x201(%rbp)
jmp 0x4ead
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x4eb9
jmp 0x4f10
movq -0x1f8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x53c0
jmp 0x4ece
jmp 0x4e6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x4f4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3170
leaq -0x1a8(%rbp), %rdi
callq 0x31e0
jmp 0x4f4e
movb $0x1, -0x1a(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3170
leaq -0x1a8(%rbp), %rdi
callq 0x31e0
testb $0x1, -0x1a(%rbp)
jne 0x4f3e
movq -0x1f8(%rbp), %rdi
callq 0x5320
movq -0x1f0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1f8(%rbp), %rdi
callq 0x5320
movq -0x1b0(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: bluesky466[P]ResourcesArscDemo/main.cpp
// Function: readResTableHeader(_IO_FILE*)
void readResTableHeader(FILE* pFile) {
	uint16_t type;
	fread((void*)&type, sizeof(type), 1, pFile);
	if(type == RES_TABLE_TYPE) {
		struct ResTable_header header = {RES_TABLE_TYPE};
		fread((void*)(((char*)&header)+2), sizeof(struct ResTable_header)-2, 1, pFile);
		printf("type:%u, headSize:%u, size:%u, packageCount:%u\n",
				header.header.type,
				header.header.headerSize,
				header.header.size,
				header.packageCount);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xa(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x2250
movzwl -0xa(%rbp), %eax
cmpl $0x2, %eax
jne 0x2a78
movq 0x65e9(%rip), %rax      # 0x901c
movq %rax, -0x18(%rbp)
movl 0x65e7(%rip), %eax      # 0x9024
movl %eax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
addq $0x2, %rdi
movq -0x8(%rbp), %rcx
movl $0xa, %esi
movl $0x1, %edx
callq 0x2250
movzwl -0x18(%rbp), %esi
movzwl -0x16(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x6739(%rip), %rdi      # 0x91aa
movb $0x0, %al
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: bluesky466[P]ResourcesArscDemo/main.cpp
// Function: readResStringPoolHeader(_IO_FILE*)
struct ResStringPool_header readResStringPoolHeader(FILE* pFile) {
	struct ResStringPool_header header;
	uint16_t type;
	fread((void*)&header, sizeof(struct ResStringPool_header), 1, pFile);
	printf("type:%u, headSize:%u, size:%u, stringCount:%u, stringStart:%u, styleCount:%u, styleStart:%u\n",
				header.header.type,
				header.header.headerSize,
				header.header.size,
				header.stringCount,
				header.stringsStart,
				header.styleCount,
				header.stylesStart);
	return header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x1c, %esi
movl $0x1, %edx
callq 0x2250
movq -0x20(%rbp), %rdi
movzwl (%rdi), %esi
movzwl 0x2(%rdi), %edx
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x14(%rdi), %r9d
movl 0xc(%rdi), %r10d
movl 0x18(%rdi), %eax
leaq 0x670c(%rip), %rdi      # 0x91da
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: bluesky466[P]ResourcesArscDemo/main.cpp
// Function: readStringsFromStringPool(_IO_FILE*, ResStringPool_header)
unsigned char* readStringsFromStringPool(FILE* pFile,  struct ResStringPool_header header) {
	uint32_t size = header.header.size - sizeof(struct ResStringPool_header);
	unsigned char* pData = (unsigned char*)malloc(size);
	fread((void*)pData, size, 1, pFile);
	uint32_t* pOffsets = (uint32_t*)pData;

	//stringsStart指的是header的起始地址到字符串起始地址的距离
	//pData已经是header末尾的地址了，所以要减去header的大小
	char* pStringsStart = (char*)(pData + header.stringsStart - sizeof(struct ResStringPool_header));

	for(int i = 0 ; i < header.stringCount ; i++) {
		//前面两个字节是长度,要跳过
		char* str = pStringsStart + *(pOffsets + i) + 2;
		if(header.flags & ResStringPool_header::UTF8_FLAG) {
			printf("%s\n", str);
		} else {
			printUtf16String((char16_t*)str);
		}
	}

	return pData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x4(%rax), %eax
subq $0x1c, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
callq 0x2210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x2250
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rcx), %ecx
addq %rcx, %rax
addq $-0x1c, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x2bb9
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
movslq -0x2c(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rcx, -0x38(%rbp)
movl 0x10(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x2ba3
movq -0x38(%rbp), %rsi
leaq 0x6789(%rip), %rdi      # 0x9323
movb $0x0, %al
callq 0x2030
jmp 0x2bac
movq -0x38(%rbp), %rdi
callq 0x2f50
jmp 0x2bae
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2b58
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bluesky466[P]ResourcesArscDemo/main.cpp
// Function: readResTablePackageHeader(_IO_FILE*, ResTable_package*)
int readResTablePackageHeader(FILE* pFile, struct ResTable_package* pHeader) {
	if(fread((void*)pHeader, sizeof(struct ResTable_package), 1, pFile) == 0) {
		return 0;
	}
	printf("type:%u, headSize:%u, size:%u, id:%x, packageName:",
				pHeader->header.type,
				pHeader->header.headerSize,
				pHeader->header.size,
				pHeader->id);
	printUtf16String((char16_t*)pHeader->name);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x120, %esi            # imm = 0x120
movl $0x1, %edx
callq 0x2250
cmpq $0x0, %rax
jne 0x2c06
movl $0x0, -0x4(%rbp)
jmp 0x2c46
movq -0x18(%rbp), %rax
movzwl (%rax), %esi
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r8d
leaq 0x660c(%rip), %rdi      # 0x9237
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
callq 0x2f50
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: bluesky466[P]ResourcesArscDemo/main.cpp
// Function: printStringFromStringsPool(unsigned int*, char*, unsigned int, unsigned int)
void printStringFromStringsPool(uint32_t* pOffsets, char* pStringsStart, uint32_t stringIndex, uint32_t isUtf8) {
	//前面两个字节是长度,要跳过
	char* str = pStringsStart + *(pOffsets + stringIndex) + 2;
	if(isUtf8) {
		printf("%s\n", str);
	} else {
		printUtf16String((char16_t*)str);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2c99
movq -0x20(%rbp), %rsi
leaq 0x6693(%rip), %rdi      # 0x9323
movb $0x0, %al
callq 0x2030
jmp 0x2ca2
movq -0x20(%rbp), %rdi
callq 0x2f50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/StrFolder.cc
// Function: swap(Message&, Message&)
void swap(Message &lhs, Message &rhs)
{
	using std::swap;  // not strictly needed in this case, but good habit

	// remove pointers to each Message from their (original) respective Folders
	for (auto f : lhs.folders)
		f->remMsg(&lhs);
	for (auto f : rhs.folders)
		f->remMsg(&rhs);

	// swap the contents and Folder pointer sets
	swap(lhs.folders, rhs.folders);   // uses swap(set&, set&)
	swap(lhs.contents, rhs.contents); // swap(String&, String&)

	// add pointers to each Message to their (new) respective Folders
	for (auto f : lhs.folders)
		f->addMsg(&lhs);
	for (auto f : rhs.folders)
		f->addMsg(&rhs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ee0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f40
testb $0x1, %al
jne 0x13ec
jmp 0x1414
leaq -0x20(%rbp), %rdi
callq 0x1f70
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1f90
leaq -0x20(%rbp), %rdi
callq 0x1fc0
jmp 0x13d9
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1ee0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1f10
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1f40
testb $0x1, %al
jne 0x144d
jmp 0x1475
leaq -0x40(%rbp), %rdi
callq 0x1f70
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f90
leaq -0x40(%rbp), %rdi
callq 0x1fc0
jmp 0x143a
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1ff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2020
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1ee0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1f10
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1f40
testb $0x1, %al
jne 0x14d0
jmp 0x14f8
leaq -0x60(%rbp), %rdi
callq 0x1f70
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
leaq -0x60(%rbp), %rdi
callq 0x1fc0
jmp 0x14bd
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x1ee0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x1f10
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1f40
testb $0x1, %al
jne 0x1537
jmp 0x1565
leaq -0x80(%rbp), %rdi
callq 0x1f70
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
leaq -0x80(%rbp), %rdi
callq 0x1fc0
jmp 0x1521
addq $0x90, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/StrFolder.cc
// Function: Folder::operator=(Folder&&)
Folder& Folder::operator=(Folder&& f)
{
	if (this != &f) {        // direct check for self-assignment
		remove_from_Msgs();  // remove this Folder from the current msgs
		move_Messages(&f);   // make each Message point to this Folder
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x1694
movq -0x18(%rbp), %rdi
callq 0x16a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(String const&)
String& String::operator=(const String& rhs)
{
	// copying the right-hand operand before deleting the left handles self-assignment
	auto newp = a.allocate(rhs.sz); // copy the underlying string from rhs
	uninitialized_copy(rhs.p, rhs.p + rhs.sz, newp);

	if (p)
		a.deallocate(p, sz); // free the memory used by the left-hand operand
	p = newp;    // p now points to the newly allocated string
	sz = rhs.sz; // update the size

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x761e(%rip), %rdi      # 0x110f4
xorl %eax, %eax
movl %eax, %edx
callq 0x4140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
addq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x41a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9b25
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq (%rax), %rdx
leaq 0x75d4(%rip), %rdi      # 0x110f4
callq 0x4110
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(String&&)
String& String::operator=(String&& rhs) noexcept
{
	// explicit check for self-assignment
	if (this != &rhs) {
		if (p)
			a.deallocate(p, sz);  // do the work of the destructor
		p = rhs.p;    // take over the old memory
		sz = rhs.sz;

		rhs.p = 0;    // deleting rhs.p is safe
		rhs.sz = 0;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x9bc5
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9b94
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq 0x7569(%rip), %rdi      # 0x110f4
callq 0x4110
jmp 0x9b92
jmp 0x9b94
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2470
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(char const*)
String& String::operator=(const char* cp)
{
	if (p) a.deallocate(p, sz);
	p = a.allocate(sz = strlen(cp));
	uninitialized_copy(cp, cp + sz, p);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x9c16
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq (%rax), %rdx
leaq 0x74e3(%rip), %rdi      # 0x110f4
callq 0x4110
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq %rsi, (%rax)
leaq 0x74c4(%rip), %rdi      # 0x110f4
xorl %eax, %eax
movl %eax, %edx
callq 0x4140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x7e80
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(char)
String& String::operator=(char c)
{
	if(p) a.deallocate(p, sz);
	p = a.allocate(sz = 1);
	*p = c;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x9ca8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq (%rax), %rdx
leaq 0x7451(%rip), %rdi      # 0x110f4
callq 0x4110
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
leaq 0x743a(%rip), %rdi      # 0x110f4
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x9(%rbp), %dl
movq 0x8(%rax), %rcx
movb %dl, (%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(std::initializer_list<char>)
String& String::operator=(initializer_list<char> il)
{
	// no need to check for self-assignment
	if (p)
		a.deallocate(p, sz);        // do the work of the destructor
	p = a.allocate(sz = il.size()); // do the work of the copy constructor
	uninitialized_copy(il.begin(), il.end(), p);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x9d2a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq (%rax), %rdx
leaq 0x73cf(%rip), %rdi      # 0x110f4
callq 0x4110
leaq -0x10(%rbp), %rdi
callq 0xa010
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq %rsi, (%rax)
leaq 0x73b0(%rip), %rdi      # 0x110f4
xorl %eax, %eax
movl %eax, %edx
callq 0x4140
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0xa030
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xa050
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x7e80
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: print(std::ostream&, String const&)
ostream& print(ostream& os, const String& s)
{
	auto p = s.begin();
	while (p != s.end())
		os << *p++ ;
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa0b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x9de7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %esi
callq 0x1130
jmp 0x9dad
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: add(String const&, String const&)
String add(const String& lhs, const String& rhs)
{
	String ret;
	ret.sz = rhs.size() + lhs.size();   // size of the combined String
	ret.p = String::a.allocate(ret.sz); // allocate new space
	uninitialized_copy(lhs.begin(), lhs.end(), ret.p); // copy the operands
	uninitialized_copy(rhs.begin(), rhs.end(), ret.p + lhs.sz);
	return ret;  // return a copy of the newly created String
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa0d0
movq -0x18(%rbp), %rdi
callq 0x3ec0
movq %rax, -0x38(%rbp)
jmp 0x9e3a
movq -0x10(%rbp), %rdi
callq 0x3ec0
movq %rax, -0x50(%rbp)
jmp 0x9e49
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movq (%rax), %rsi
leaq 0x728f(%rip), %rdi      # 0x110f4
xorl %eax, %eax
movl %eax, %edx
callq 0x4140
movq %rax, -0x58(%rbp)
jmp 0x9e74
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xa090
movq %rax, -0x60(%rbp)
jmp 0x9e8f
movq -0x10(%rbp), %rdi
callq 0xa0b0
movq %rax, -0x68(%rbp)
jmp 0x9e9e
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x7e80
jmp 0x9eb5
movq -0x18(%rbp), %rdi
callq 0xa090
movq %rax, -0x70(%rbp)
jmp 0x9ec4
movq -0x18(%rbp), %rdi
callq 0xa0b0
movq %rax, -0x78(%rbp)
jmp 0x9ed3
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq %rax, %rdx
callq 0x7e80
jmp 0x9ef4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9f20
jmp 0x9f17
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2330
jmp 0x9f2d
movq -0x48(%rbp), %rdi
callq 0x2330
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1190
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/boardClient.cpp
// Function: BoardClient::BoardClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BoardClient::BoardClient(std::string C2S, std::string S2C)
{
    if((pipeClient2Server = open(C2S.c_str(), O_WRONLY)) < 0)
    {
        perror("fifo C2S not found");
    }

    if((pipeServer2Client = open(S2C.c_str(), O_RDWR)) < 0) //isws kai O_NONBLOCK
    {
        perror("fifo S2C not found");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdx, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x3130
movq %rax, %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x3230
movq -0x20(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0x47f6
leaq 0x6895(%rip), %rdi      # 0xb086
callq 0x3260
movq -0x28(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x3230
movq -0x20(%rbp), %rcx
movl %eax, 0x4(%rcx)
cmpl $0x0, %eax
jge 0x4826
leaq 0x6878(%rip), %rdi      # 0xb099
callq 0x3260
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/boardClient.cpp
// Function: BoardClient::getMessages(int)
void BoardClient::getMessages(int Id)
{
    char convert[24];
    string buff;

    int nwrite;
    if((nwrite = write(pipeClient2Server, "<Message><start>", 16))== -1) //zhtaw apo to server ta messages kai arxeia
    {
        perror("Cant write to pipe C2S");
    }
    sprintf(convert, "%d", Id);
    buff = convert;
    if((nwrite = write(pipeClient2Server, buff.c_str(), buff.size()))== -1)
    {
        perror("Cant write to pipe C2S");
        cout<<nwrite<<endl;
    }

    if((nwrite = write(pipeClient2Server, "<end><Message>", 14))== -1) //telos aitimatos
    {
        perror("Cant write to pipe C2S");
    }

    this->readMessages(); //twra ta diavazw
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x33e0
movq -0x78(%rbp), %rax
movl (%rax), %edi
leaq 0x6620(%rip), %rsi      # 0xb0d0
movl $0x10, %edx
callq 0x3110
movq %rax, -0x70(%rbp)
jmp 0x4ac0
movq -0x70(%rbp), %rax
movl %eax, -0x54(%rbp)
cmpl $-0x1, %eax
jne 0x4af6
leaq 0x65e2(%rip), %rdi      # 0xb0b5
callq 0x3260
jmp 0x4ada
jmp 0x4af6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31f0
jmp 0x4c13
movl -0xc(%rbp), %edx
leaq 0x65e1(%rip), %rsi      # 0xb0e1
xorl %eax, %eax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x30a0
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x33d0
jmp 0x4b1e
movq -0x78(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x94(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3130
movq -0xa0(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x3210
movl -0x94(%rbp), %edi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0x3110
movq %rax, -0x88(%rbp)
jmp 0x4b6b
movq -0x88(%rbp), %rax
movl %eax, -0x54(%rbp)
cmpl $-0x1, %eax
jne 0x4bb7
leaq 0x6534(%rip), %rdi      # 0xb0b5
callq 0x3260
jmp 0x4b88
movl -0x54(%rbp), %esi
movq 0xa43e(%rip), %rdi      # 0xefd0
callq 0x34a0
movq %rax, -0xa8(%rbp)
jmp 0x4ba0
movq -0xa8(%rbp), %rdi
movq 0xa412(%rip), %rsi      # 0xefc0
callq 0x3300
jmp 0x4bb5
jmp 0x4bb7
movq -0x78(%rbp), %rax
movl (%rax), %edi
leaq 0x6520(%rip), %rsi      # 0xb0e4
movl $0xe, %edx
callq 0x3110
movq %rax, -0xb0(%rbp)
jmp 0x4bd7
movq -0xb0(%rbp), %rax
movl %eax, -0x54(%rbp)
cmpl $-0x1, %eax
jne 0x4bf6
leaq 0x64c8(%rip), %rdi      # 0xb0b5
callq 0x3260
jmp 0x4bf4
jmp 0x4bf6
movq -0x78(%rbp), %rdi
callq 0x4c20
jmp 0x4c01
leaq -0x50(%rbp), %rdi
callq 0x31f0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::~BoardServer()
BoardServer::~BoardServer()
{
    Chanel* tmp;

    tmp = chanels->deleteFirstNode();
    while(tmp != NULL)
    {
        delete tmp;
        tmp = chanels->deleteFirstNode();//diagrafoume ta stoixeia tis listas
    }
    delete chanels;
    this->shutDown();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0xa470
movq %rax, -0x18(%rbp)
jmp 0x5c83
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5cd4
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5cb7
movq -0x28(%rbp), %rdi
callq 0xac70
movq -0x28(%rbp), %rdi
movl $0x50, %esi
callq 0x32e0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xa470
movq %rax, -0x30(%rbp)
jmp 0x5cca
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5c8b
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5cfd
movq -0x38(%rbp), %rdi
callq 0xa1e0
movq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x32e0
movq -0x20(%rbp), %rdi
callq 0x5d30
jmp 0x5d08
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x31f0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8890
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::shutDown()
void BoardServer::shutDown() //kleinei ola ta pipes
{
    close(pipeBoardPost2Server);
    close(pipeClient2Server);
    close(pipeServer2BoardPost);
    close(pipeServer2Client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %edi
callq 0x3520
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3520
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3520
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x3520
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::addChanel(Chanel*)
void BoardServer::addChanel(Chanel* inChanel)
{
    if(searchChanel(inChanel->get_id()) != NULL)
    {
        delete inChanel;
        return;
    }

    chanels->insertEnd(inChanel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xada0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x5e80
cmpq $0x0, %rax
je 0x5e69
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5e67
movq -0x20(%rbp), %rdi
callq 0xac70
movq -0x20(%rbp), %rdi
movl $0x50, %esi
callq 0x32e0
jmp 0x5e7a
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xa2e0
addq $0x20, %rsp
popq %rbp
retq
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::searchChanel(int)
Chanel* BoardServer::searchChanel(int Id)
{
    for(Node<Chanel>* i = chanels->get_begin(); i != NULL; i = i->get_next()) //vriskei to chanel me auto to ID
    {
        if(i->get_data()->get_id() == Id)
        {
            return i->get_data();
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xa2a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5edd
movq -0x20(%rbp), %rdi
callq 0xaa50
movq %rax, %rdi
callq 0xada0
cmpl -0x14(%rbp), %eax
jne 0x5ecc
movq -0x20(%rbp), %rdi
callq 0xaa50
movq %rax, -0x8(%rbp)
jmp 0x5ee5
jmp 0x5ece
movq -0x20(%rbp), %rdi
callq 0xaa30
movq %rax, -0x20(%rbp)
jmp 0x5ea0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::addMessageToChanel(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool BoardServer::addMessageToChanel(int Id, string message)
{
    Chanel* tmp = searchChanel(Id);
    if(tmp == NULL) return false; //dn yparxei chanel me auto to id

    tmp->addMessage(message);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5e80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5f24
movb $0x0, -0x1(%rbp)
jmp 0x5f35
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0xae60
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::addFileToChanel(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool BoardServer::addFileToChanel(int Id, string* file)
{
    Chanel* tmp = searchChanel(Id);
    if(tmp == NULL) return false; //dn yparxei chanel me auto to id

    tmp->addFile(file);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5e80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5f70
movb $0x0, -0x1(%rbp)
jmp 0x5f81
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xae30
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::sendMsgAndFiles(int)
void BoardServer::sendMsgAndFiles(int Id)
{
    Chanel* tmp = searchChanel(Id);
    string buff;
    int nwrite;
    if(tmp == NULL) //an den ypaxei to kanali stelnw <NONE>
    {
        write(pipeServer2Client, "<NONE>", 6);
        return;
    }

    this->sendMesg(tmp); //stelnw message
    this->sendFiles(tmp); //stelnw arxeia
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0xc(%rbp), %esi
callq 0x5e80
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33e0
cmpq $0x0, -0x18(%rbp)
jne 0x634d
movq -0x58(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x4dd2(%rip), %rsi      # 0xb0f3
movl $0x6, %edx
callq 0x3110
jmp 0x632d
movl $0x1, -0x50(%rbp)
jmp 0x6372
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31f0
jmp 0x6381
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6390
jmp 0x635c
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6510
jmp 0x636b
movl $0x0, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::sendMesg(Chanel*)
void BoardServer::sendMesg(Chanel* chanelId)
{
    char buff[BUFFERSIZE];
    int file;
    int nread, nwrite;

    file=open(chanelId->get_messagesFile().c_str(), O_RDONLY, 0644);

    if((nwrite = write(pipeServer2Client, "<Message><start>", 16))== -1) //arxh message
    {
        perror("Cant write to pipe S2C");
    }

    while((nread = read(file, buff, BUFFERSIZE)) > 0) //diavazw apo to arxeio kai stelnw to message
    {
        if(write(pipeServer2Client, buff, nread) == -1)
        {
            perror("Cant write to pipe S2C");
        }
    }

    if((nwrite = write(pipeServer2Client, "<end><Message>", 14))== -1) //telos message
    {
        perror("Cant write to pipe S2C");
    }
    close(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x460(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x440(%rbp), %rdi
movq %rdi, -0x458(%rbp)
callq 0xade0
movq -0x458(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
xorl %esi, %esi
movb %sil, %al
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x3230
movl %eax, -0x450(%rbp)
jmp 0x63eb
movl -0x450(%rbp), %eax
movl %eax, -0x414(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x31f0
movq -0x460(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x4cbc(%rip), %rsi      # 0xb0d0
movl $0x10, %edx
callq 0x3110
movl %eax, -0x41c(%rbp)
cmpl $-0x1, %eax
jne 0x645a
leaq 0x4dc6(%rip), %rdi      # 0xb1f6
callq 0x3260
jmp 0x645a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x448(%rbp)
movl %eax, -0x44c(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x31f0
jmp 0x64f5
jmp 0x645c
movl -0x414(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3400
movl %eax, -0x418(%rbp)
cmpl $0x0, %eax
jle 0x64af
movq -0x460(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x410(%rbp), %rsi
movslq -0x418(%rbp), %rdx
callq 0x3110
cmpq $-0x1, %rax
jne 0x64ad
leaq 0x4d4e(%rip), %rdi      # 0xb1f6
callq 0x3260
jmp 0x645c
movq -0x460(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x4c24(%rip), %rsi      # 0xb0e4
movl $0xe, %edx
callq 0x3110
movl %eax, -0x41c(%rbp)
cmpl $-0x1, %eax
jne 0x64e1
leaq 0x4d1a(%rip), %rdi      # 0xb1f6
callq 0x3260
movl -0x414(%rbp), %edi
callq 0x3520
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
movq -0x448(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::parseAddChanel(char*, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void BoardServer::parseAddChanel(char* buffer, int nread, int state, std::string& previousRead) //prosthetw to kanali sthn lista
{
    string  name;
    int id;
    Chanel* ch;

    previousRead.append(buffer, nread); //prosthetw dedomena mporei na xreiastei panw apo ena loop
    if(state == waitingEndCommand)
    {
        istringstream iss(previousRead);
        iss>>id >> name;
        if(iss.fail())
        {
            perror("error detail of chanel");
        }
        else
        {
            Chanel* ch = new Chanel(id, name);
            this->addChanel(ch);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3070
jmp 0x7b14
cmpl $0x3, -0x18(%rbp)
jne 0x7ca9
movq -0x20(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
movl $0x8, %edx
callq 0x3480
jmp 0x7b35
leaq -0x1e0(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x31e0
movq %rax, -0x220(%rbp)
jmp 0x7b4e
movq -0x220(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x33a0
jmp 0x7b60
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1e0(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x221(%rbp)
jmp 0x7b80
movb -0x221(%rbp), %al
testb $0x1, %al
jne 0x7b8c
jmp 0x7bc1
leaq 0x36a9(%rip), %rdi      # 0xb23c
callq 0x3260
jmp 0x7b9a
jmp 0x7c8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7cbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7c9b
movl $0x50, %edi
callq 0x32d0
movq %rax, -0x230(%rbp)
jmp 0x7bd4
movb $0x1, -0x209(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x234(%rbp)
leaq -0x208(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3150
jmp 0x7bf6
movl -0x234(%rbp), %esi
movq -0x230(%rbp), %rdi
leaq -0x208(%rbp), %rdx
callq 0xaab0
jmp 0x7c11
movb $0x0, -0x209(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x31f0
movq -0x230(%rbp), %rax
movq -0x218(%rbp), %rdi
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rsi
callq 0x5e10
jmp 0x7c47
jmp 0x7c8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7c6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x31f0
testb $0x1, -0x209(%rbp)
jne 0x7c7a
jmp 0x7c8b
movq -0x230(%rbp), %rdi
movl $0x50, %esi
callq 0x32e0
jmp 0x7c9b
leaq -0x1e0(%rbp), %rdi
callq 0x31a0
jmp 0x7ca9
leaq -0x1e0(%rbp), %rdi
callq 0x31a0
jmp 0x7cbb
leaq -0x40(%rbp), %rdi
callq 0x31f0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x31f0
movq -0x58(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::parseSendMessage(char*, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void BoardServer::parseSendMessage(char* buffer, int nread, int state, std::string& previousRead) //diavazei apo poio kanali thelei na lavei ta messages o client
{
    int id;

    previousRead.append(buffer, nread);
    if(state == waitingEndCommand)
    {
        istringstream iss(previousRead);
        iss>>id;
        if(iss.fail())
        {
            perror("error detail of chanel");
        }
        else
        {
            this->sendMsgAndFiles(id); //stelnei ta messages tou chanel
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3070
cmpl $0x3, -0x18(%rbp)
jne 0x82fc
movq -0x20(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
movl $0x8, %edx
callq 0x3480
movq -0x1c8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x31e0
jmp 0x8281
movq -0x1a8(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a8(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x1c9(%rbp)
jmp 0x82a1
movb -0x1c9(%rbp), %al
testb $0x1, %al
jne 0x82ad
jmp 0x82dd
leaq 0x2f88(%rip), %rdi      # 0xb23c
callq 0x3260
jmp 0x82bb
jmp 0x82f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31a0
jmp 0x8305
movq -0x1c0(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x62e0
jmp 0x82ee
jmp 0x82f0
leaq -0x1a8(%rbp), %rdi
callq 0x31a0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)