LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/core/Core.cpp
// Function: Core::Core(int, char**)
Core::Core(int ac, char **av) : parser(Parser(ac, av))
{
	std::map<std::string, std::string> map = this->parser.getMap();
	this->updateActivate(this->parser.getMap());
	if (!parser.isGraphicMode()) {

		this->terminal =  new Curses(this->data);
		this->terminalInterface();
	} else {
		execve("graphic/myHpot", av, av);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rdi, %r15
leaq 0xc24c(%rip), %rax      # 0x10ab0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x6190
leaq 0x68(%r15), %r14
movq %r14, %rdi
callq 0x57d2
movq %rbx, %rdi
callq 0x6ca6
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5ac0
movq %rbx, %rdi
callq 0x6ca6
movq %r15, %rdi
movq %rax, %rsi
callq 0x493e
movq %rbx, %rdi
callq 0x6d6a
testb %al, %al
je 0x48db
leaq 0x674a(%rip), %rdi      # 0xb004
movq %r12, %rsi
movq %r12, %rdx
callq 0x4570
leaq 0x8(%rsp), %rdi
callq 0x5daa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x6d8, %edi            # imm = 0x6D8
callq 0x4350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x88b8
movq %r12, 0x700(%r15)
movq %r15, %rdi
callq 0x51be
movq %rax, %r15
movq %r12, %rdi
callq 0x4330
jmp 0x491c
movq %rax, %r15
jmp 0x492e
movq %rax, %r15
jmp 0x4926
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x5daa
movq %r14, %rdi
callq 0x58ec
movq %rbx, %rdi
callq 0x594a
movq %r15, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/core/Core.cpp
// Function: Core::terminalInterface()
void Core::terminalInterface()
{
	std::map<std::string, std::string> map = this->parser.getMap();

	while(true) {
		(*terminal).clearTerminal();
		if(data.clock.isActive())
			(*terminal).printTime();
		if(data.cpu.isActive())
			(*terminal).printCpu();
		if(data.ram.isActive())
			(*terminal).printRam();
		if(data.user.isActive())
			(*terminal).printUser();
		if(data.network.isActive())
			(*terminal).printNet();
		(*terminal).refreshTerminal();
		usleep(30000);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x6ca6
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5ac0
leaq 0xa0(%rbx), %r14
leaq 0x70(%rbx), %r15
leaq 0x238(%rbx), %r12
leaq 0x2b0(%rbx), %r13
leaq 0xd0(%rbx), %rbp
movq 0x700(%rbx), %rdi
callq 0xa2e6
movq %r14, %rdi
callq 0x71a8
testb %al, %al
je 0x5229
movq 0x700(%rbx), %rdi
callq 0xa0e0
movq %r15, %rdi
callq 0x71a8
testb %al, %al
je 0x5241
movq 0x700(%rbx), %rdi
callq 0x9c90
movq %r12, %rdi
callq 0x71a8
testb %al, %al
je 0x5259
movq 0x700(%rbx), %rdi
callq 0x8fd4
movq %r13, %rdi
callq 0x71a8
testb %al, %al
je 0x5271
movq 0x700(%rbx), %rdi
callq 0x9752
movq %rbp, %rdi
callq 0x71a8
testb %al, %al
je 0x5289
movq 0x700(%rbx), %rdi
callq 0x9a32
movq 0x700(%rbx), %rdi
callq 0x8bc8
movl $0x7530, %edi           # imm = 0x7530
callq 0x44a0
jmp 0x5205
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5daa
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Parser::parse(std::string file)
{
	std::ifstream input(file);
	std::string line;

	if (!input.is_open())
		return (1);
	while (!input.eof()) {
		getline(input, line);
		if (line.find('=') == std::string::npos)
			return (1);
		this->_map[line.substr(0, line.find('='))] =
		line.substr(line.find('=') + 1);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %r14
leaq 0x60(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x4540
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xd8(%rsp), %rdi
callq 0x40e0
pushq $0x1
popq %rbx
testb %al, %al
je 0x6523
addq $0x8, %r14
movq %rsp, %r12
pushq $0x3d
popq %rbp
leaq 0x40(%rsp), %r13
pushq $-0x1
popq %rbx
leaq 0x20(%rsp), %r15
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x80(%rsp,%rax)
jne 0x651c
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x40b0
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x4480
cmpq $-0x1, %rax
je 0x6520
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x4380
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x4480
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4380
movq %r14, %rdi
movq %r15, %rsi
callq 0x596e
movq %rax, %rdi
movq %r13, %rsi
callq 0x4420
movq %r15, %rdi
callq 0x41f0
movq %r13, %rdi
callq 0x41f0
jmp 0x6481
xorl %ebx, %ebx
jmp 0x6523
pushq $0x1
popq %rbx
movq %rsp, %rdi
callq 0x41f0
leaq 0x60(%rsp), %rdi
callq 0x4110
movl %ebx, %eax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6569
movq %rax, %rbx
jmp 0x655d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x41f0
leaq 0x40(%rsp), %rdi
callq 0x41f0
jmp 0x656c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41f0
leaq 0x60(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::flagHandler(int, char**)
void Parser::flagHandler(int ac, char **av)
{
	std::vector<std::string> argv;

	for (int i = 1; i < ac; i += 1)
		argv.emplace_back(av[i]);

	for (unsigned int i = 0; i < argv.size(); i += 1) {
		if (argv[i] == "--help")
			exit(printUsage());
		else if (argv[i] == "-terminal") {
			this->_graphicMode = false;
		}
		else if (argv[i] == "-graphic") {
			this->_graphicMode = true;
		}
		else if (argv[i][0] != '-' || this->setModuleActive(
			argv[i].substr(1))) {
			std::cout << "htop: invalid option "
				<< argv[i].substr(1)
				<< "\nTry 'htop --help' for more information"
				<< std::endl;
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
movslq %esi, %r12
addq $0x8, %r14
pushq $0x1
popq %r13
cmpq %r12, %r13
jge 0x65cd
movq %r15, %rdi
movq %r14, %rsi
callq 0x6d6e
incq %r13
addq $0x8, %r14
jmp 0x65b4
xorl %r13d, %r13d
leaq 0x4b8f(%rip), %r15      # 0xb166
leaq 0x38(%rsp), %r12
movl %r13d, %r13d
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x668c
movq %r13, %rbp
shlq $0x5, %rbp
addq %rbp, %rdi
leaq 0x4b56(%rip), %rsi      # 0xb15f
callq 0x59d4
testb %al, %al
jne 0x66a3
movq (%rsp), %rdi
addq %rbp, %rdi
movq %r15, %rsi
callq 0x59d4
testb %al, %al
je 0x662d
xorl %ecx, %ecx
jmp 0x6646
movq (%rsp), %rdi
addq %rbp, %rdi
leaq 0x4b1b(%rip), %rsi      # 0xb156
callq 0x59d4
movb $0x1, %cl
testb %al, %al
je 0x664b
movb %cl, 0x58(%rbx)
jmp 0x6684
movq (%rsp), %rsi
movq (%rsi,%rbp), %rax
cmpb $0x2d, (%rax)
jne 0x66b0
addq %rbp, %rsi
movq %r12, %rdi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6af8
movl %eax, %r14d
movq %r12, %rdi
callq 0x41f0
testl %r14d, %r14d
jne 0x66b0
incl %r13d
jmp 0x65dc
movq %rsp, %rdi
callq 0x6d98
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6740
pushq $0x1
popq %rdi
callq 0x4400
movq 0xa921(%rip), %rdi      # 0x10fd8
leaq 0x4ab2(%rip), %rsi      # 0xb170
callq 0x4340
movq %rax, %rbx
addq (%rsp), %rbp
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbp, %rsi
callq 0x4380
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4310
leaq 0x4a95(%rip), %rsi      # 0xb186
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x4220
leaq 0x18(%rsp), %rdi
callq 0x41f0
jmp 0x66a8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x6721
jmp 0x672c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x41f0
jmp 0x672f
jmp 0x672c
jmp 0x672c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6d98
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::setModuleActive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Parser::setModuleActive(std::string str) {
	if (str.find('=') == std::string::npos ||
		!isMandatoryModule(str.substr(0, str.find('='))))
		return (1);
	if (!this->isBool(str.substr(str.find('=') + 1)))
		return (1);
	this->_map[str.substr(0, str.find('='))] =
		str.substr(str.find('=') + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x3d
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4480
pushq $0x1
popq %rbp
cmpq $-0x1, %rax
je 0x6c16
pushq $0x3d
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4480
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4380
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6762
movl %eax, %r15d
leaq 0x40(%rsp), %rdi
callq 0x41f0
testb %r15b, %r15b
je 0x6c16
pushq $0x3d
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
leaq 0x60(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4380
movq %r15, %rsi
callq 0x6c54
movl %eax, %r12d
movq %r15, %rdi
callq 0x41f0
testb %r12b, %r12b
je 0x6c16
pushq $0x3d
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
leaq 0x20(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x4380
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x4480
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4380
addq $0x8, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x596e
leaq 0x20(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4420
movq %rsp, %rdi
callq 0x41f0
movq %rbx, %rdi
callq 0x41f0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41f0
jmp 0x6c38
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x6c47
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x41f0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::isBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Parser::isBool(std::string boolean) const
{
	return (boolean == "1" ||
		boolean == "0" ||
		boolean == "true" ||
		boolean == "false");
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x454f(%rip), %rsi      # 0xb1ae
movq %rbx, %rdi
callq 0x59d4
testb %al, %al
jne 0x6c91
leaq 0x453e(%rip), %rsi      # 0xb1b0
movq %rbx, %rdi
callq 0x59d4
testb %al, %al
jne 0x6c91
leaq 0x43e2(%rip), %rsi      # 0xb067
movq %rbx, %rdi
callq 0x59d4
testb %al, %al
je 0x6c95
movb $0x1, %al
popq %rbx
retq
leaq 0x4516(%rip), %rsi      # 0xb1b2
movq %rbx, %rdi
popq %rbx
jmp 0x59d4
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/CPU.cpp
// Function: Cpu::updateCpu(std::vector<CPUData_s, std::allocator<CPUData_s>>&, std::vector<CPUData_s, std::allocator<CPUData_s>>&)
void Cpu::updateCpu(std::vector<CPUData> &stat1, std::vector<CPUData> &stat2)
{
	ReadStatsCpu(stat1);

	// 100ms pause
	std::this_thread::sleep_for(std::chrono::milliseconds(100));

	ReadStatsCpu(stat2);

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdi
callq 0x7226
leaq 0x8(%rsp), %rdi
movq $0x64, (%rdi)
callq 0x7862
movq %rbx, %rdi
callq 0x7226
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/CPU.cpp
// Function: GetActiveTime(CPUData_s const&)
static size_t GetActiveTime(const CPUData &data)
{
	return  (data.times[S_USER] +
		data.times[S_NICE] +
		data.times[S_SYSTEM] +
		data.times[S_IRQ] +
		data.times[S_SOFTIRQ] +
		data.times[S_STEAL] +
		data.times[S_GUEST] +
		data.times[S_GUEST_NICE]);
}

// Assembly:
movq 0x20(%rdi), %rax
movdqu 0x58(%rdi), %xmm0
movdqu 0x48(%rdi), %xmm1
paddq %xmm0, %xmm1
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
paddq %xmm1, %xmm0
movq %xmm0, %rcx
addq 0x28(%rdi), %rcx
addq 0x30(%rdi), %rax
addq %rcx, %rax
addq 0x68(%rdi), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/CPU.cpp
// Function: Cpu::PrintStats()
void Cpu::PrintStats()
{
	std::vector<CPUData> cpu = this->getStats();
	const size_t NUM_STAT = cpu.size();

	for(size_t i = 0; i < NUM_STAT; ++i) {

		std::cout.width(3);
		std::cout << cpu[i].cpu << "] ";
		std::cout << "active: ";
		std::cout.setf(std::ios::fixed, std::ios::floatfield);
		std::cout.width(6);
		std::cout.precision(2);
		std::cout << cpu[i].active << "%";

		std::cout << " - idle: ";
		std::cout.setf(std::ios::fixed, std::ios::floatfield);
		std::cout.width(6);
		std::cout.precision(2);
		std::cout << cpu[i].active << "%" << std::endl;

		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7480
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
movq %rax, %rbx
xorl %r15d, %r15d
movq 0x98e9(%rip), %r14      # 0x10fd8
movl $0xfffffefb, %r12d      # imm = 0xFFFFFEFB
leaq 0x4095(%rip), %r13      # 0xb791
leaq 0x3b2c(%rip), %rbp      # 0xb22f
subq $0x1, %rbx
jb 0x780c
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r14,%rax)
movq (%rsp), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x4310
movq %rax, %rdi
leaq 0x3aed(%rip), %rsi      # 0xb223
callq 0x4340
movq %r14, %rdi
leaq 0x3ae1(%rip), %rsi      # 0xb226
callq 0x4340
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl %r12d, %edx
orl $0x4, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rcx
movq $0x6, 0x10(%r14,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%r14,%rax)
movq (%rsp), %rax
movss 0x70(%rax,%r15), %xmm0
movq %r14, %rdi
callq 0x42a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x4340
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4340
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl %r12d, %edx
orl $0x4, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rcx
movq $0x6, 0x10(%r14,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%r14,%rax)
movq (%rsp), %rax
movss 0x70(%rax,%r15), %xmm0
movq %r14, %rdi
callq 0x42a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x4340
movq %rax, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4220
addq $0x78, %r15
jmp 0x7703
movq %rsp, %rdi
callq 0x78b8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x78b8
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/Clock.cpp
// Function: Clock::getTime[abi:cxx11]()
std::string Clock::getTime()
{
	time_t rawTime;
	struct tm *localTime;
	std::stringstream now;

	time(&rawTime);
	localTime = localtime(&rawTime);
	now << formatTime(localTime->tm_hour) << ":";
	now << formatTime(1 + localTime->tm_min) << ":";
	now << formatTime(1 + localTime->tm_sec);
	return now.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4270
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x4320
movq %r14, %rdi
callq 0x4290
movq %rax, %r15
movl 0x8(%rax), %esi
movq %rsp, %rdi
callq 0x7ce2
leaq 0x38(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4310
leaq 0x36b4(%rip), %rsi      # 0xb269
movq %rax, %rdi
callq 0x4340
movq %rsp, %rdi
callq 0x41f0
movl 0x4(%r15), %esi
incl %esi
movq %rsp, %rdi
callq 0x7ce2
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4310
leaq 0x3684(%rip), %rsi      # 0xb269
movq %rax, %rdi
callq 0x4340
movq %rsp, %rdi
callq 0x41f0
movl (%r15), %esi
incl %esi
movq %rsp, %rdi
callq 0x7ce2
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4310
movq %rsp, %rdi
callq 0x41f0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x4510
leaq 0x28(%rsp), %rdi
callq 0x42b0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7c44
jmp 0x7c4b
jmp 0x7c44
jmp 0x7c44
movq %rax, %rbx
jmp 0x7c56
jmp 0x7c4b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41f0
leaq 0x28(%rsp), %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/Clock.cpp
// Function: Clock::getUtc[abi:cxx11]()
std::string Clock::getUtc()
{
	time_t now;
	struct tm *localTime;
	std::string utc;
	char buff[128];

	time(&now);
	localTime = localtime(&now);
	strftime(buff, 128, "%a %d %b %Y", localTime);
	utc = buff;
	return utc;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4320
movq %r14, %rdi
callq 0x4290
leaq 0x35a3(%rip), %rdx      # 0xb244
leaq 0x10(%rsp), %r14
movl $0x80, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x42e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45e0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x41f0
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/Clock.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> formatTime<int>(int)
std::string formatTime(T time)
{
	std::stringstream str;
	if (time < 10) {
		str << 0;
	}

	str << time;
	return str.str();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4270
cmpl $0x9, %ebp
jg 0x7d09
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x4590
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x4590
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4510
movq %rsp, %rdi
callq 0x42b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/Network.cpp
// Function: Network::refreshCpuData()
void  Network::refreshCpuData()
{
	std::ifstream file("/proc/net/dev", std::ifstream::in);
	std::string line;

	while (!file.eof())
	{
		std::getline(file, line);
		if (line.find("wlo1:") != std::string::npos)
			break;
	}
	std::string array[STAT_COLUMNS];
	std::size_t i = 0;
	std::stringstream ssin(line);
	while (ssin.good() && i < STAT_COLUMNS)
	{
		ssin >> array[i];
		i++;
	}
	fillValue(array[IN_BYTES], _inBytes);
	fillValue(array[IN_PACKETS], _inPackets);
	fillValue(array[OUT_BYTES], _outBytes);
	fillValue(array[OUT_PACKETS], _outPackets);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5d8, %rsp            # imm = 0x5D8
movq %rdi, %rbx
leaq 0x34e3(%rip), %rsi      # 0xb257
leaq 0x3d0(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x45c0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
leaq 0x34c1(%rip), %r12      # 0xb265
movq 0x3d0(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x3f0(%rsp,%rax)
jne 0x7dd8
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b0
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4600
cmpq $-0x1, %rax
je 0x7da4
pushq $0x10
popq %rax
leaq (%rsp,%rax), %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
addq $0x20, %rax
cmpq $0x230, %rax            # imm = 0x230
jne 0x7ddb
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x4520
leaq 0x1b0(%rsp), %r14
xorl %r12d, %r12d
leaq 0x28(%rsp), %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x7e4a
cmpq $0x10, %r12
ja 0x7e4a
movq %r15, %rdi
movq %r14, %rsi
callq 0x4430
incq %r12
addq $0x20, %r14
jmp 0x7e20
leaq 0x1d0(%rsp), %rdi
leaq 0x30(%rbx), %rsi
callq 0x8006
leaq 0x1f0(%rsp), %rdi
leaq 0x38(%rbx), %rsi
callq 0x8006
leaq 0x2d0(%rsp), %rdi
leaq 0x40(%rbx), %rsi
callq 0x8006
leaq 0x2f0(%rsp), %rdi
addq $0x48, %rbx
movq %rbx, %rsi
callq 0x8006
leaq 0x28(%rsp), %rdi
callq 0x42b0
movl $0x200, %ebx            # imm = 0x200
leaq (%rsp,%rbx), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x41f0
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x7ea0
leaq 0x8(%rsp), %rdi
callq 0x41f0
leaq 0x3d0(%rsp), %rdi
callq 0x4110
addq $0x5d8, %rsp            # imm = 0x5D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x7ef9
jmp 0x7eec
movq %rax, %rbx
jmp 0x7f19
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x42b0
movl $0x200, %r14d           # imm = 0x200
leaq (%rsp,%r14), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x41f0
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x7eff
leaq 0x8(%rsp), %rdi
callq 0x41f0
leaq 0x3d0(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/OperatingSystem.cpp
// Function: OperatingSystem::OperatingSystem()
OperatingSystem::OperatingSystem() : AMonitorModule(true, "OS")
{
	struct utsname data;
	uname(&data);
	_kernel = data.release;
	_name = data.sysname;
	_domain = data.domainname;
	_machine = data.machine;
	_version = data.version;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x3209(%rip), %rsi      # 0xb27c
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x41a0
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x717c
leaq 0x10(%rsp), %rdi
callq 0x41f0
leaq 0x8a6d(%rip), %rax      # 0x10b10
movq %rax, (%rbx)
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
xorl %eax, %eax
movb %al, 0x40(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
leaq 0x30(%rbx), %r14
leaq 0x50(%rbx), %r15
movb %al, 0x60(%rbx)
leaq 0x80(%rbx), %rcx
movq %rcx, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
leaq 0x70(%rbx), %r12
movb %al, 0x80(%rbx)
leaq 0x90(%rbx), %r13
leaq 0xa0(%rbx), %rcx
movq %rcx, 0x90(%rbx)
andq $0x0, 0x98(%rbx)
movb %al, 0xa0(%rbx)
leaq 0xb0(%rbx), %rbp
leaq 0xc0(%rbx), %rcx
movq %rcx, 0xb0(%rbx)
andq $0x0, 0xb8(%rbx)
movb %al, 0xc0(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x4060
leaq 0x92(%rsp), %rsi
movq %r14, %rdi
callq 0x45e0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x45e0
leaq 0x155(%rsp), %rsi
movq %rbp, %rdi
callq 0x45e0
leaq 0x114(%rsp), %rsi
movq %r13, %rdi
callq 0x45e0
leaq 0xd3(%rsp), %rsi
movq %r12, %rdi
callq 0x45e0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x41f0
jmp 0x81e6
movq %rax, 0x8(%rsp)
jmp 0x81e6
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x41f0
movq %r13, %rdi
callq 0x41f0
movq %r12, %rdi
callq 0x41f0
movq %r15, %rdi
callq 0x41f0
movq %r14, %rdi
callq 0x41f0
movq %rbx, %rdi
callq 0x5a78
movq 0x8(%rsp), %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/modules/RAM.cpp
// Function: RAM::refresh()
void RAM::refresh()
{
	struct sysinfo _sysInfo;
	sysinfo(&_sysInfo);
	int minute = 60;
	int hour = minute * 60;
	int day = hour * 24;

	_upTime = std::to_string(_sysInfo.uptime / day) +
		" days " + std::to_string((_sysInfo.uptime % day) / hour) +
		" hours " + std::to_string((_sysInfo.uptime % hour) / minute) +
		" min.";
	_totalRam = _sysInfo.totalram / MB;
	_totalSwap = _sysInfo.totalswap / MB;
	_freeRam = _sysInfo.freeram / MB;
	_freeSwap = _sysInfo.freeswap / MB;
	_processes = _sysInfo.procs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rdi, %rbx
leaq 0x100(%rsp), %r14
movq %r14, %rdi
callq 0x4460
movq (%r14), %rax
movl $0x15180, %r15d         # imm = 0x15180
cqto
idivq %r15
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x8672
leaq 0x2fe5(%rip), %rdx      # 0xb290
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x85ec
movq 0x100(%rsp), %rax
cqto
idivq %r15
movq %rdx, %rax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movslq %eax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x8672
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x860b
leaq 0x2f9f(%rip), %rdx      # 0xb297
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x85ec
movq 0x100(%rsp), %rax
movl $0xe10, %ecx            # imm = 0xE10
cqto
idivq %rcx
movq %rdx, %rax
cwtd
movw $0x3c, %cx
idivw %cx
movswq %ax, %rsi
movq %rsp, %rdi
callq 0x8672
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
callq 0x860b
leaq 0x2f4c(%rip), %rdx      # 0xb29f
leaq 0xe0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x85ec
leaq 0x30(%rbx), %rdi
leaq 0xe0(%rsp), %r14
movq %r14, %rsi
callq 0x4420
movq %r14, %rdi
callq 0x41f0
leaq 0xa0(%rsp), %rdi
callq 0x41f0
movq %rsp, %rdi
callq 0x41f0
leaq 0x80(%rsp), %rdi
callq 0x41f0
leaq 0x60(%rsp), %rdi
callq 0x41f0
leaq 0x20(%rsp), %rdi
callq 0x41f0
leaq 0x40(%rsp), %rdi
callq 0x41f0
leaq 0xc0(%rsp), %rdi
callq 0x41f0
movups 0x120(%rsp), %xmm0
movaps 0x2ea0(%rip), %xmm1     # 0xb280
andps %xmm1, %xmm0
movups %xmm0, 0x50(%rbx)
movups 0x140(%rsp), %xmm0
andps %xmm1, %xmm0
movups %xmm0, 0x60(%rbx)
movzwl 0x150(%rsp), %eax
movq %rax, 0x70(%rbx)
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x41f0
jmp 0x8424
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41f0
jmp 0x8431
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x41f0
jmp 0x8443
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x41f0
jmp 0x8452
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x41f0
leaq 0x40(%rsp), %rdi
callq 0x41f0
leaq 0xc0(%rsp), %rdi
callq 0x41f0
movq %rbx, %rdi
callq 0x45a0
movq %rax, %rbx
jmp 0x845c
movq %rax, %rbx
jmp 0x8466
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::Curses(Data&)
Curses::Curses(Data &newData)
{
	_status = true;
	_xlogo = 70;
	_side = false;
	data = newData;
	initscr();
	noecho();
	curs_set(FALSE);
	keypad(stdscr,TRUE);

	_time = newwin(10, 26, LINES - 10, COLS - 27);
	_ram = newwin(20, 36, 1, COLS - 38);
	_user = newwin(15, 65, LINES - 15, 1);
	_cpu = newwin(20, 58, 1, 1);
	_net = newwin(15, 65, LINES - 15 - 18,1);

	assume_default_colors(COLOR_RED, COLOR_BLACK);
	start_color();
	init_pair(0, COLOR_GREEN, COLOR_GREEN);
	init_pair(1, COLOR_YELLOW, COLOR_YELLOW);
	init_pair(2, COLOR_RED, COLOR_RED);
	init_pair(4, COLOR_GREEN, COLOR_BLACK);
	init_pair(5, COLOR_RED, COLOR_BLACK);
	init_pair(6, COLOR_WHITE, COLOR_WHITE);
	init_pair(7, COLOR_YELLOW, COLOR_BLACK);
	init_pair(8, COLOR_WHITE, COLOR_BLACK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x57d2
movb $0x1, 0x14(%r14)
movq $0x46, 0xc(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa55a
callq 0x44d0
callq 0x43d0
xorl %edi, %edi
callq 0x42d0
movq 0x86ce(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
pushq $0x1
popq %rsi
callq 0x4190
movq 0x868c(%rip), %r15      # 0x10fa0
movl (%r15), %edx
addl $-0xa, %edx
movq 0x868f(%rip), %r12      # 0x10fb0
movl (%r12), %ecx
addl $-0x1b, %ecx
pushq $0xa
popq %rdi
pushq $0x1a
popq %rsi
callq 0x4390
movq %rax, 0x6c0(%r14)
movl (%r12), %ecx
addl $-0x26, %ecx
pushq $0x14
popq %rdi
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x4390
movq %rax, 0x6b0(%r14)
movl (%r15), %edx
addl $-0xf, %edx
pushq $0xf
popq %rdi
pushq $0x41
popq %rsi
pushq $0x1
popq %rcx
callq 0x4390
movq %rax, 0x6c8(%r14)
pushq $0x14
popq %rdi
pushq $0x3a
popq %rsi
pushq $0x1
popq %rcx
movl %ecx, %edx
callq 0x4390
movq %rax, 0x6b8(%r14)
movl (%r15), %edx
addl $-0x21, %edx
pushq $0xf
popq %rdi
pushq $0x41
popq %rsi
pushq $0x1
popq %rcx
callq 0x4390
movq %rax, 0x6d0(%r14)
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x41e0
callq 0x40c0
pushq $0x2
popq %rdx
xorl %edi, %edi
movl %edx, %esi
callq 0x4090
pushq $0x1
popq %rdi
pushq $0x3
popq %rdx
movl %edx, %esi
callq 0x4090
pushq $0x2
popq %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x4090
pushq $0x4
popq %rdi
pushq $0x2
popq %rsi
xorl %edx, %edx
callq 0x4090
pushq $0x5
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x4090
pushq $0x6
popq %rdi
pushq $0x7
popq %rdx
movl %edx, %esi
callq 0x4090
pushq $0x7
popq %rdi
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0x4090
pushq $0x8
popq %rdi
pushq $0x7
popq %rsi
xorl %edx, %edx
callq 0x4090
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x58ec
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::refreshTerminal()
void Curses::refreshTerminal()
{

	refresh();
	refreshTerminal(_ram);
	refreshTerminal(_user);
	refreshTerminal(_cpu);
	refreshTerminal(_time);
	refreshTerminal(_net);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4580
movq 0x6b0(%rbx), %rdi
callq 0x43c0
movq 0x6c8(%rbx), %rdi
callq 0x43c0
movq 0x6b8(%rbx), %rdi
callq 0x43c0
movq 0x6c0(%rbx), %rdi
callq 0x43c0
movq 0x6d0(%rbx), %rdi
popq %rbx
jmp 0x43c0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::printTime()
void Curses::printTime()
{
	int i = 0;
	print(_time, i++, 2, "                        ", 2);
	print(_time, i++, 2, ("          " + data.clock.getModuleName()
		+  "         ").c_str(), 8);
	print(_time, i++, 2, "                        ", 2);
	i++;
	print(_time, i++, 2, ("  Local Time: " +
		data.clock.getTime()).c_str(), 4);
	i++;
	print(_time, i++, 2, ("  Date: " + data.clock.getUtc()).c_str(), 7);
	i++;
	print(_time, i++, 2, "                        ", 2);
	mvwin(_time , LINES - 10, COLS - 27);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x6c0(%rdi), %rsi
leaq 0x1739(%rip), %r8       # 0xb835
pushq $0x2
popq %rcx
xorl %edx, %edx
movl %ecx, %r9d
callq 0x8c16
movq 0x6c0(%rbx), %r15
leaq 0x50(%rbx), %r14
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7196
leaq 0x1718(%rip), %rsi      # 0xb843
leaq 0x28(%rsp), %rdi
movq %r12, %rdx
callq 0xa5dd
leaq 0x1705(%rip), %rdx      # 0xb844
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x85ec
movq 0x8(%rsp), %r8
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
pushq $0x8
popq %r9
movq %r15, %rsi
callq 0x8c16
leaq 0x8(%rsp), %rdi
callq 0x41f0
leaq 0x28(%rsp), %rdi
callq 0x41f0
leaq 0x48(%rsp), %rdi
callq 0x41f0
movq 0x6c0(%rbx), %rsi
leaq 0x16a4(%rip), %r8       # 0xb835
pushq $0x2
popq %rcx
movl %ecx, %edx
movl %ecx, %r9d
callq 0x8c16
movq 0x6c0(%rbx), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7b62
leaq 0x1783(%rip), %rsi      # 0xb93f
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0xa5dd
movq 0x8(%rsp), %r8
pushq $0x2
popq %rcx
pushq $0x4
popq %rdx
movq %r15, %rsi
movl %edx, %r9d
callq 0x8c16
leaq 0x8(%rsp), %rdi
callq 0x41f0
leaq 0x28(%rsp), %rdi
callq 0x41f0
movq 0x6c0(%rbx), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7c68
leaq 0x173d(%rip), %rsi      # 0xb94e
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0xa5dd
movq 0x8(%rsp), %r8
pushq $0x6
popq %rdx
pushq $0x2
popq %rcx
pushq $0x7
popq %r9
movq %r15, %rsi
callq 0x8c16
leaq 0x8(%rsp), %rdi
callq 0x41f0
leaq 0x28(%rsp), %rdi
callq 0x41f0
movq 0x6c0(%rbx), %rsi
leaq 0x15de(%rip), %r8       # 0xb835
pushq $0x8
popq %rdx
pushq $0x2
popq %rcx
movl %ecx, %r9d
callq 0x8c16
movq 0x6c0(%rbx), %rdi
movq 0x6d2d(%rip), %rax      # 0x10fa0
movl (%rax), %esi
addl $-0xa, %esi
movq 0x6d31(%rip), %rax      # 0x10fb0
movl (%rax), %edx
addl $-0x1b, %edx
callq 0x41c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa299
jmp 0xa2a8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x41f0
jmp 0xa2ab
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xa2d8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x41f0
jmp 0xa2c4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41f0
jmp 0xa2d3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x41f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::clearTerminal()
void Curses::clearTerminal()
{
	int i = 4;
	wclear(stdscr);
	wclear(_ram);
	wclear(_cpu);
	wclear(_user);
	wclear(_time);
	wclear(_net);
	if(COLS > 200)
	{
		print(stdscr, i++, _xlogo, "  _____  _____  _____  _____  ", 5);
		print(stdscr, i++, _xlogo, " |  |  ||  _  ||     ||_   _| ", 4);
		print(stdscr, i++, _xlogo, " |     ||   __||  |  |  | |   ", 7);
		print(stdscr, i++, _xlogo, " |__|__||__|   |_____|  |_|   ", 5);
		print(stdscr, i++, _xlogo, " |__|__||__|   |_____|  |_|   ", 4);
		print(stdscr, i++, _xlogo, "       The Lion Monitor       ", 7);
		print(stdscr, i++, _xlogo, "                              ", 7);
		printLion();
	}
	if(_xlogo == COLS - 30 - 45)
		_side = false;
	else if(_xlogo == 69)
		_side = true;
	if(_side != 0)
		_xlogo++;
	else
		_xlogo--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6cd5(%rip), %r13      # 0x10fd0
movq (%r13), %rdi
callq 0x4370
movq 0x6b0(%rbx), %rdi
callq 0x4370
movq 0x6b8(%rbx), %rdi
callq 0x4370
movq 0x6c8(%rbx), %rdi
callq 0x4370
movq 0x6c0(%rbx), %rdi
callq 0x4370
movq 0x6d0(%rbx), %rdi
callq 0x4370
movq 0x6c69(%rip), %rax      # 0x10fb0
movl (%rax), %ecx
cmpl $0xc9, %ecx
jl 0xa41e
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1382(%rip), %r8       # 0xb6e5
pushq $0x4
popq %rbp
pushq $0x5
popq %r15
movl %ebp, %edx
movl %r15d, %r9d
callq 0x8c16
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1386(%rip), %r8       # 0xb708
movl %r15d, %edx
movl %ebp, %r9d
callq 0x8c16
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1390(%rip), %r8       # 0xb72b
pushq $0x6
popq %rdx
pushq $0x7
popq %r14
movl %r14d, %r9d
callq 0x8c16
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1396(%rip), %r12      # 0xb74e
movl %r14d, %edx
movq %r12, %r8
movl %r15d, %r9d
callq 0x8c16
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
pushq $0x8
popq %rdx
movq %r12, %r8
movl %ebp, %r9d
callq 0x8c16
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1388(%rip), %r8       # 0xb771
pushq $0x9
popq %rdx
movl %r14d, %r9d
callq 0x8c16
movq (%r13), %rsi
movl 0xc(%rbx), %ecx
leaq 0x142d(%rip), %r8       # 0xb82f
pushq $0xa
popq %rdx
movl %r14d, %r9d
callq 0x8c16
movq %rbx, %rdi
callq 0x8c66
movq 0x6b94(%rip), %rax      # 0x10fb0
movl (%rax), %ecx
movl 0xc(%rbx), %eax
addl $-0x4b, %ecx
cmpl %ecx, %eax
jne 0xa430
andl $0x0, 0x10(%rbx)
pushq $-0x1
jmp 0xa43e
cmpl $0x45, %eax
jne 0xa441
movl $0x1, 0x10(%rbx)
pushq $0x1
popq %rcx
jmp 0xa44c
xorl %ecx, %ecx
cmpl $0x1, 0x10(%rbx)
sbbl %ecx, %ecx
orl $0x1, %ecx
addl %eax, %ecx
movl %ecx, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::closeTerminal()
void Curses::closeTerminal()
{
	closeTerminal(_ram);
	closeTerminal(_user);
	closeTerminal(_cpu);
	closeTerminal(_time);
//	clearTerminal(_net);
	endwin();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x6b0(%rdi), %rdi
callq 0x4080
movq 0x6c8(%rbx), %rdi
callq 0x4080
movq 0x6b8(%rbx), %rdi
callq 0x4080
movq 0x6c0(%rbx), %rdi
callq 0x4080
popq %rbx
jmp 0x43f0
// File: /workspace/github_cpp_makefile_star2_O2/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::getchTerminal()
int Curses::getchTerminal()
{
	_ch = getch();
	if (_ch == KEY_ENTER)
	{
		printw("UP");
	}
	else if(_ch == KEY_DOWN)
	{
		wprintw(_ram, "DOWN");
		waddch(_ram, 'B');
	}
	wclear(stdscr);
	wclear(_ram);
	wclear(_cpu);
	wclear(_user);
	wclear(_time);
	return _ch;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6b20(%rip), %r14      # 0x10fd0
movq (%r14), %rdi
callq 0x4170
movl %eax, 0x8(%rbx)
cmpl $0x102, %eax            # imm = 0x102
je 0xa4d9
cmpl $0x157, %eax            # imm = 0x157
jne 0xa4fd
leaq 0x1487(%rip), %rdi      # 0xb957
xorl %eax, %eax
callq 0x4360
jmp 0xa4fd
movq 0x6b0(%rbx), %rdi
leaq 0x1473(%rip), %rsi      # 0xb95a
xorl %eax, %eax
callq 0x4050
movq 0x6b0(%rbx), %rdi
pushq $0x42
popq %rsi
callq 0x4140
movq (%r14), %rdi
callq 0x4370
movq 0x6b0(%rbx), %rdi
callq 0x4370
movq 0x6b8(%rbx), %rdi
callq 0x4370
movq 0x6c8(%rbx), %rdi
callq 0x4370
movq 0x6c0(%rbx), %rdi
callq 0x4370
movl 0x8(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::load(int, char**)
void CConfig::load( int argc, char * argv[] ) {
	const char * iniFile;
	if ( argc > 1 )
		iniFile = argv[1];
	else
		iniFile = DEFAULT_INIFILE;

	ifstream ifile( iniFile );
	if ( !ifile.is_open() )
		throw FileNotFoundException( iniFile, MSG_CRIT_ERR );

	ini_struct_t defVals;
	loadDefVals( defVals );
	parse( CParserINI( ifile, defVals ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, %rbx
cmpl $0x2, %esi
jge 0x5a9c
leaq 0x1b9be(%rip), %rdx     # 0x21458
jmp 0x5aa0
addq $0x8, %rdx
movq (%rdx), %r14
leaq 0xb8(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x57b0
leaq 0x130(%rsp), %rdi
callq 0x5100
testb %al, %al
je 0x5b62
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x8(%rsp), %rsi
callq 0x5c3e
leaq 0x38(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9094
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x77f2
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x617e
leaq 0x88(%rsp), %rdi
callq 0x7d8a
leaq 0x38(%rsp), %rdi
callq 0x71a0
leaq 0x8(%rsp), %rdi
callq 0x7d8a
leaq 0xb8(%rsp), %rdi
callq 0x5140
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x712a
leaq 0x1b8ca(%rip), %rax     # 0x21450
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x712a
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x7166
xorl %ebp, %ebp
leaq 0x1a8aa(%rip), %rsi     # 0x20460
leaq 0x15bf(%rip), %rdx      # 0x717c
movq %rbx, %rdi
callq 0x5740
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5210
jmp 0x5bda
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x5210
testb %bpl, %bpl
jne 0x5bee
jmp 0x5c28
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
jmp 0x5c28
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x7d8a
jmp 0x5c0d
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x71a0
jmp 0x5c1e
jmp 0x5c1b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7d8a
leaq 0xb8(%rsp), %rdi
callq 0x5140
movq %r14, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: operator<<(std::ostream&, CConfig&)
ostream& operator <<( ostream& out, CConfig& c ) {
	out << "Ports:";
	for ( auto it = c.getPorts().begin(); it != c.getPorts().end(); it++ ) {
		out << ' ' << *it;
	}
	out << endl;

	out << "Working directory: " << c.getWorkDir() << endl;

	out << "Logger flags:";
	for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
		if ( c.logFlags_m[i] )
			out << ' ' << logflagsNS::logFlagsToString( (ELogFlags) i );

	out << endl;
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xdb7b(%rip), %rsi      # 0x14045
callq 0x5400
movq 0x18(%r14), %r15
pushq $0x20
popq %rbp
cmpq 0x20(%r14), %r15
je 0x64f7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5480
movq %rax, %rdi
movq %r15, %rsi
callq 0x5390
addq $0x20, %r15
jmp 0x64d6
movq %rbx, %rdi
callq 0x5220
leaq 0xdb46(%rip), %rsi      # 0x1404c
movq %rbx, %rdi
callq 0x5400
leaq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
callq 0x5220
leaq 0xdb37(%rip), %rsi      # 0x14060
movq %rbx, %rdi
callq 0x5400
xorl %r15d, %r15d
pushq $0x20
popq %rbp
cmpq $0xc, %r15
je 0x6569
cmpb $0x1, (%r14,%r15)
jne 0x6564
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5480
movq %rax, %r12
movl %r15d, %edi
callq 0xdfb0
movq %r12, %rdi
movq %rax, %rsi
callq 0x5400
incq %r15
jmp 0x6537
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseMapper(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<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, 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>>>>>>>>>&)
void CConfig::parseMapper( map<string, map<string, vector<string>>>::iterator& data ) {
	for ( auto it = data->second.begin(); it != data->second.end(); it++ )
		fileMapping_m.push_back( make_pair( it->first, it->second.front() ) );

	auto comp = []( const pair<string, string>& a, const pair<string, string>& b ) -> bool {
		return a.first.length() > b.first.length();
	};

	sort( fileMapping_m.begin(), fileMapping_m.end(), comp );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x58(%rax), %r13
leaq 0x78(%rdi), %r15
movq %rsp, %r12
addq $0x48, %rax
cmpq %rax, %r13
je 0x6b6d
leaq 0x20(%r13), %rsi
movq 0x40(%r13), %rdx
movq %r12, %rdi
callq 0x7ee2
movq %r15, %rdi
movq %r12, %rsi
callq 0x83b8
movq %r12, %rdi
callq 0x747e
movq %r13, %rdi
callq 0x52c0
movq %rax, %r13
movq (%r14), %rax
jmp 0x6b31
movq 0x78(%rbx), %r14
movq 0x80(%rbx), %rbx
cmpq %rbx, %r14
je 0x6bdb
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x6, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6cea
cmpq $0x401, %r15            # imm = 0x401
jl 0x6bd0
leaq 0x400(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7010
cmpq %rbx, %r15
je 0x6bdb
movq %r15, %rdi
callq 0x709c
addq $0x40, %r15
jmp 0x6bbd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7010
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x747e
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseExec(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<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, 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>>>>>>>>>&)
void CConfig::parseExec( map<string, map<string, vector<string>>>::iterator& data ) {
	auto it = data->second.find( "regular_exe_ext" );
	if ( it != data->second.end() ) {
		regExeExt_m.insert( it->second.begin(), it->second.end() );
	}
	it = data->second.find( "script_exe_ext" );
	if ( it != data->second.end() ) {
		scriptExeExt_m.insert( it->second.begin(), it->second.end() );
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0xd501(%rip), %rsi      # 0x14118
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x712a
addq $0x40, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x8642
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x5210
movq (%r14), %r15
leaq 0x48(%r15), %rax
cmpq %rax, %r12
je 0x6c69
leaq 0x90(%rbx), %rdi
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdx
callq 0x8680
movq (%r14), %r15
leaq 0xd4b8(%rip), %rsi      # 0x14128
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x712a
addq $0x40, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x8642
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x5210
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
je 0x6cc0
addq $0xc0, %rbx
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
movq %rbx, %rdi
callq 0x8680
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6cd0
jmp 0x6cdf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
jmp 0x6ce2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5770
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CParserINI::parseLine( string& line ) {
	unsigned int pos = 0;
	skipWS( line, pos );
	if ( pos == line.size() )
		return;

	switch ( line[pos] ) {
		case ';':
		case '#':
			return;
		case '[':
			parseNewBlock( line, pos );
			return;
		default:
			string id = getID( line, pos );
			vector<string> args = getArgs( line, pos );
			addParam( id, args );
			return;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
movq %r15, %rdx
callq 0x9350
movl (%r15), %eax
cmpq %rax, 0x8(%r14)
jne 0x91e3
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rcx
movzbl (%rcx,%rax), %eax
cmpl $0x23, %eax
je 0x91d6
cmpl $0x3b, %eax
je 0x91d6
cmpl $0x5b, %eax
jne 0x920b
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9376
jmp 0x91d6
leaq 0x60(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x94aa
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x956e
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x55d0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7408
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x92d6
leaq 0x10(%rsp), %rdi
callq 0x745c
leaq 0x40(%rsp), %rdi
callq 0x5210
leaq 0x28(%rsp), %rdi
callq 0x745c
leaq 0x60(%rsp), %rdi
callq 0x5210
jmp 0x91d6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x745c
jmp 0x92a5
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5210
jmp 0x92b4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x745c
jmp 0x92c3
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop
// File: /workspace/github_cpp_makefile_star2_O2/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseNewBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
void CParserINI::parseNewBlock( string& line, unsigned int& pos ) {
	string newBlock( "" );
	pos++;
	for ( ; pos < line.size() && isValidArgChar( line[pos] ); pos++ )
		newBlock.insert( newBlock.end(), line[pos] );
	if ( pos == line.size() )
		throw INIParserException( "End of line reached (']' expected)" );
	if ( line[pos] != ']' )
		throw INIParserException( "Unrecognized symbol (']' expected): ", line[pos] );

	currentBlock = newBlock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xbb5f(%rip), %rsi      # 0x14ef0
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x712a
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jbe 0x93f8
movq (%rbx), %rdx
movb (%rdx,%rax), %dl
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0x93e1
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setae %sil
cmpb $0x5f, %dl
setne %dil
testb %sil, %dil
jne 0x93f8
movq 0x8(%rsp), %rsi
addq 0x10(%rsp), %rsi
movsbl %dl, %edx
movq %r12, %rdi
callq 0x57c0
jmp 0x93a3
cmpq %rax, %rcx
je 0x942d
movq (%rbx), %rcx
cmpb $0x5d, (%rcx,%rax)
jne 0x9449
addq $0x30, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x5270
leaq 0x8(%rsp), %rdi
callq 0x5210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r15
leaq 0xae5d(%rip), %rsi      # 0x1429c
movq %rax, %rdi
callq 0x991e
jmp 0x946d
pushq $0x48
popq %rdi
callq 0x5230
movq %rax, %r15
movl (%r14), %eax
movq (%rbx), %rcx
movsbl (%rcx,%rax), %edx
leaq 0xae5a(%rip), %rsi      # 0x142bf
movq %r15, %rdi
callq 0x9a42
leaq 0x17114(%rip), %rsi     # 0x20588
leaq -0x2097(%rip), %rdx     # 0x73e4
movq %r15, %rdi
callq 0x5740
jmp 0x9485
movq %rax, %rbx
movq %r15, %rdi
callq 0x5300
jmp 0x9497
jmp 0x9494
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5770
nop