LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]MQSim/src/main.cpp
// Function: command_line_args(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>>&)
void command_line_args(char* argv[], string& input_file_path, string& workload_file_path)
{

	for (int arg_cntr = 1; arg_cntr < 5; arg_cntr++) {
		string arg = argv[arg_cntr];

		char file_path_switch[] = "-i";
		if (arg.compare(0, strlen(file_path_switch), file_path_switch) == 0) {
			input_file_path.assign(argv[++arg_cntr]);
			//cout << input_file_path << endl;
			continue;
		}

		char workload_path_switch[] = "-w";
		if (arg.compare(0, strlen(workload_path_switch), workload_path_switch) == 0) {
			workload_file_path.assign(argv[++arg_cntr]);
			//cout << workload_file_path << endl;
			continue;
		}
	}
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movl $0x1, 0x7c(%rsp)
cmpl $0x5, 0x7c(%rsp)
jge 0x9c7a
movq 0x90(%rsp), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x8780
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x85d0
jmp 0x9b1d
leaq 0x57(%rsp), %rdi
callq 0x84a0
movb $0x0, 0x42(%rsp)
movw $0x692d, 0x40(%rsp)     # imm = 0x692D
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x81b0
movq 0x18(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq 0x58(%rsp), %rdi
callq 0x85a0
movl %eax, 0x24(%rsp)
jmp 0x9b5e
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jne 0x9bd7
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rax
movslq 0x7c(%rsp), %rcx
movl %ecx, %edx
incl %edx
movl %edx, 0x7c(%rsp)
movq 0x8(%rax,%rcx,8), %rsi
callq 0x87f0
jmp 0x9b90
movl $0x4, 0x3c(%rsp)
jmp 0x9c52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x84a0
jmp 0x9c82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x8848
jmp 0x9c82
movb $0x0, 0x3a(%rsp)
movw $0x772d, 0x38(%rsp)     # imm = 0x772D
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x81b0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq 0x58(%rsp), %rdi
callq 0x85a0
movl %eax, 0x14(%rsp)
jmp 0x9c0e
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jne 0x9c4a
movq 0x80(%rsp), %rdi
movq 0x90(%rsp), %rax
movslq 0x7c(%rsp), %rcx
movl %ecx, %edx
incl %edx
movl %edx, 0x7c(%rsp)
movq 0x8(%rax,%rcx,8), %rsi
callq 0x87f0
jmp 0x9c40
movl $0x4, 0x3c(%rsp)
jmp 0x9c52
movl $0x0, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x8848
movl 0x3c(%rsp), %eax
testl %eax, %eax
je 0x9c68
jmp 0x9c66
jmp 0x9c6a
jmp 0x9c6a
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x9ad7
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x8770
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/exec/Execution_Parameter_Set.cpp
// Function: Execution_Parameter_Set::XML_serialize(Utils::XmlWriter&)
void Execution_Parameter_Set::XML_serialize(Utils::XmlWriter& xmlwriter)
{
	std::string tmp;
	tmp = "Execution_Parameter_Set";
	xmlwriter.Write_open_tag(tmp);

	Host_Configuration.XML_serialize(xmlwriter);
	SSD_Device_Configuration.XML_serialize(xmlwriter);

	xmlwriter.Write_close_tag();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x85e0
movq 0x10(%rsp), %rdi
leaq 0x8f08a(%rip), %rsi     # 0xa90f3
callq 0x85c0
jmp 0x1a070
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x81a0
jmp 0x1a08b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa7d60
jmp 0x1a09c
leaq 0x18(%rsp), %rdi
callq 0x8848
movq 0x68(%rsp), %rsi
leaq 0xc0426(%rip), %rdi     # 0xda4d8
callq 0x1cfe0
jmp 0x1a0b9
movq 0x68(%rsp), %rsi
leaq 0xc041b(%rip), %rdi     # 0xda4e0
callq 0x123a0
jmp 0x1a0cc
movq 0x68(%rsp), %rdi
callq 0xa80f0
jmp 0x1a0d8
leaq 0x48(%rsp), %rdi
callq 0x8848
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1a10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x8848
leaq 0x48(%rsp), %rdi
callq 0x8848
movq 0x40(%rsp), %rdi
callq 0x8770
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/exec/Execution_Parameter_Set.cpp
// Function: Execution_Parameter_Set::XML_deserialize(rapidxml::xml_node<char>*)
void Execution_Parameter_Set::XML_deserialize(rapidxml::xml_node<> *node)
{
	try {
		for (auto param = node->first_node(); param; param = param->next_sibling()) {
			if (strcmp(param->name(), "Host_Parameter_Set") == 0) {
				Host_Configuration.XML_deserialize(param);
			} else if (strcmp(param->name(), "Device_Parameter_Set") == 0) {
				SSD_Device_Configuration.XML_deserialize(param);
			}
		}
	} catch (...) {
		PRINT_ERROR("Error in the Execution_Parameter_Set!")
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0xc960
movq %rax, 0x28(%rsp)
jmp 0x1a15b
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x1a292
movq 0x40(%rsp), %rdi
callq 0xcac0
movq %rax, 0x20(%rsp)
jmp 0x1a182
movq 0x20(%rsp), %rdi
leaq 0x90beb(%rip), %rsi     # 0xaad79
callq 0x85f0
cmpl $0x0, %eax
jne 0x1a226
movq 0x40(%rsp), %rsi
leaq 0xc0330(%rip), %rdi     # 0xda4d8
callq 0x1d680
jmp 0x1a1af
jmp 0x1a264
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8180
movq 0xbfe1d(%rip), %rdi     # 0xd9ff0
leaq 0x9070e(%rip), %rsi     # 0xaa8e8
callq 0x8440
jmp 0x1a1e1
movq 0xbfe08(%rip), %rdi     # 0xd9ff0
leaq 0x90b9d(%rip), %rsi     # 0xaad8c
callq 0x8440
movq %rax, 0x18(%rsp)
jmp 0x1a1fb
movq 0x18(%rsp), %rdi
movq 0xbfd51(%rip), %rsi     # 0xd9f58
callq 0x8480
jmp 0x1a20e
movq 0xbfdbb(%rip), %rdi     # 0xd9fd0
callq 0x84f0
jmp 0x1a21c
movl $0x1, %edi
callq 0x8500
movq 0x40(%rsp), %rdi
callq 0xcac0
movq %rax, 0x10(%rsp)
jmp 0x1a237
movq 0x10(%rsp), %rdi
leaq 0x90205(%rip), %rsi     # 0xaa448
callq 0x85f0
cmpl $0x0, %eax
jne 0x1a262
movq 0x40(%rsp), %rsi
leaq 0xc0287(%rip), %rdi     # 0xda4e0
callq 0x15120
jmp 0x1a260
jmp 0x1a262
jmp 0x1a264
jmp 0x1a266
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0xcc00
movq %rax, 0x8(%rsp)
jmp 0x1a283
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1a165
jmp 0x1a2ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x86d0
jmp 0x1a2a9
jmp 0x1a2b0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8770
movq %rax, %rdi
callq 0xd460
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::~Host_System()
Host_System::~Host_System() 
{
	delete this->Link;
	delete this->PCIe_root_complex;
	delete this->PCIe_switch;
	if (ssd_device->Host_interface->GetType() == HostInterface_Types::SATA) {
		delete this->SATA_hba;
	}
	for (uint16_t flow_id = 0; flow_id < this->IO_flows.size(); flow_id++) {
		delete this->IO_flows[flow_id];
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xb96be(%rip), %rcx     # 0xd8968
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0xb96b0(%rip), %rcx     # 0xd8968
addq $0x48, %rcx
movq %rcx, 0x30(%rax)
movq 0x40(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x1f2e3
movq 0x40(%rsp), %rdi
callq 0x1ffc0
movq 0x40(%rsp), %rdi
callq 0x8410
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1f301
movq 0x30(%rsp), %rdi
callq 0x8410
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x1f31f
movq 0x28(%rsp), %rdi
callq 0x8410
movq 0x38(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x40(%rax), %rdi
callq 0x1fe10
movl %eax, 0x24(%rsp)
jmp 0x1f337
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jne 0x1f36a
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1f368
movq 0x18(%rsp), %rdi
callq 0x3fc10
movq 0x18(%rsp), %rdi
callq 0x8410
jmp 0x1f36a
movw $0x0, 0x4e(%rsp)
movq 0x38(%rsp), %rdi
movzwl 0x4e(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x58, %rdi
callq 0xcdb0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1f3df
movq 0x38(%rsp), %rdi
addq $0x58, %rdi
movzwl 0x4e(%rsp), %eax
movl %eax, %esi
callq 0xcdd0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1f3cd
movq 0x8(%rsp), %rdi
callq 0x305d0
movq 0x8(%rsp), %rdi
callq 0x8410
jmp 0x1f3cf
movw 0x4e(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x4e(%rsp)
jmp 0x1f371
movq 0x38(%rsp), %rdi
addq $0x58, %rdi
callq 0xce20
movq 0x38(%rsp), %rdi
callq 0x1ff90
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0xd460
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::get_workloads_statistics()
std::vector<Utils::Workload_Statistics*> Host_System::get_workloads_statistics()
{
	std::vector<Utils::Workload_Statistics*> stats;

	for (auto &workload : IO_flows) {
		Utils::Workload_Statistics* s = new Utils::Workload_Statistics;
		workload->Get_statistics(*s, ssd_device->Convert_host_logical_address_to_device_address, ssd_device->Find_NVM_subunit_access_bitmap);
		stats.push_back(s);
	}

	return stats;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x204b0
movq 0x20(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x203e0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x20410
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20440
testb $0x1, %al
jne 0x1f833
jmp 0x1f8c9
leaq 0x50(%rsp), %rdi
callq 0x20480
movq %rax, 0x40(%rsp)
movl $0x1b0, %edi            # imm = 0x1B0
callq 0x8450
movq %rax, 0x8(%rsp)
jmp 0x1f853
movq 0x8(%rsp), %rdi
callq 0x204c0
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq 0xd6be(%rip), %rdx      # 0x2cf40
leaq 0xd6d7(%rip), %rcx      # 0x2cf60
callq *%rax
jmp 0x1f88d
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x20550
jmp 0x1f89e
jmp 0x1f8a0
leaq 0x50(%rsp), %rdi
callq 0x20490
jmp 0x1f81b
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x20220
jmp 0x1f8e9
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x1f8df
movq 0x10(%rsp), %rdi
callq 0x20220
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8770
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::Validate_simulation_config()
void Host_System::Validate_simulation_config() 
{
	if (this->IO_flows.size() == 0) {
		PRINT_ERROR("No IO flow is set for host system")
	}
	if (this->PCIe_root_complex == NULL) {
		PRINT_ERROR("PCIe Root Complex is not set for host system");
	}
	if (this->Link == NULL) {
		PRINT_ERROR("PCIe Link is not set for host system");
	}
	if (this->PCIe_switch == NULL) {
		PRINT_ERROR("PCIe Switch is not set for host system")
	}
	if (!this->PCIe_switch->Is_ssd_connected()) {
		PRINT_ERROR("No SSD is connected to the host system")
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x58, %rdi
callq 0xcdb0
cmpq $0x0, %rax
jne 0x1f96d
movq 0xba6c7(%rip), %rdi     # 0xd9ff0
leaq 0x8afb8(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0xba6b4(%rip), %rdi     # 0xd9ff0
leaq 0x8b819(%rip), %rsi     # 0xab15c
callq 0x8440
movq %rax, %rdi
movq 0xba606(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0xba672(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1f9c4
movq 0xba670(%rip), %rdi     # 0xd9ff0
leaq 0x8af61(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0xba65d(%rip), %rdi     # 0xd9ff0
leaq 0x8b7e4(%rip), %rsi     # 0xab17e
callq 0x8440
movq %rax, %rdi
movq 0xba5af(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0xba61b(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x1fa1b
movq 0xba619(%rip), %rdi     # 0xd9ff0
leaq 0x8af0a(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0xba606(%rip), %rdi     # 0xd9ff0
leaq 0x8b7ba(%rip), %rsi     # 0xab1ab
callq 0x8440
movq %rax, %rdi
movq 0xba558(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0xba5c4(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x1fa72
movq 0xba5c2(%rip), %rdi     # 0xd9ff0
leaq 0x8aeb3(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0xba5af(%rip), %rdi     # 0xd9ff0
leaq 0x8b788(%rip), %rsi     # 0xab1d0
callq 0x8440
movq %rax, %rdi
movq 0xba501(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0xba56d(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x3f8b0
testb $0x1, %al
jne 0x1facf
movq 0xba565(%rip), %rdi     # 0xd9ff0
leaq 0x8ae56(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0xba552(%rip), %rdi     # 0xd9ff0
leaq 0x8b752(%rip), %rsi     # 0xab1f7
callq 0x8440
movq %rax, %rdi
movq 0xba4a4(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0xba510(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::Report_results_in_XML(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Utils::XmlWriter&)
void Host_System::Report_results_in_XML(std::string name_prefix, Utils::XmlWriter& xmlwriter)
{
	std::string tmp;
	tmp = ID();
	xmlwriter.Write_open_tag(tmp);

	for (auto &flow : IO_flows) {
		flow->Report_results_in_XML("Host", xmlwriter);
	}

	xmlwriter.Write_close_tag();
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x85e0
movq 0x30(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0xcdf0
jmp 0x1fb3d
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0xb0(%rsp), %rsi
movq %rsi, 0x18(%rsp)
callq 0x8510
movq 0x18(%rsp), %rdi
callq 0x8848
movq 0x20(%rsp), %rsi
movq 0xf0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x81a0
jmp 0x1fb87
movq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xa7d60
jmp 0x1fb9b
leaq 0x80(%rsp), %rdi
callq 0x8848
movq 0x30(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x203e0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x20410
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x20440
testb $0x1, %al
jne 0x1fbec
jmp 0x1fceb
leaq 0x70(%rsp), %rdi
callq 0x20480
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8780
movq 0x10(%rsp), %rdx
leaq 0x8b4bd(%rip), %rsi     # 0xab0e0
leaq 0x40(%rsp), %rdi
callq 0x85d0
jmp 0x1fc2f
movq 0x8(%rsp), %rdi
movq 0xf0(%rsp), %rdx
movq (%rdi), %rax
movq 0x38(%rax), %rax
leaq 0x40(%rsp), %rsi
callq *%rax
jmp 0x1fc4c
leaq 0x40(%rsp), %rdi
callq 0x8848
leaq 0x3f(%rsp), %rdi
callq 0x84a0
leaq 0x70(%rsp), %rdi
callq 0x20490
jmp 0x1fbd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x1fd0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x8848
jmp 0x1fd0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x1fcdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8848
leaq 0x3f(%rsp), %rdi
callq 0x84a0
jmp 0x1fd0f
movq 0xf0(%rsp), %rdi
callq 0xa80f0
jmp 0x1fcfa
leaq 0xd0(%rsp), %rdi
callq 0x8848
addq $0x108, %rsp            # imm = 0x108
retq
leaq 0xd0(%rsp), %rdi
callq 0x8848
movq 0xa8(%rsp), %rdi
callq 0x8770
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Base.cpp
// Function: Host_Components::IO_Flow_Base::Start_simulation()
void IO_Flow_Base::Start_simulation()
	{
		next_logging_milestone = logging_period;
		if (enabled_logging) {
			log_file.open(logging_file_path, std::ofstream::out);
		}
		log_file << "SimulationTime(us)\t" << "ReponseTime(us)\t" << "EndToEndDelay(us)"<< std::endl;
		STAT_sum_device_response_time_short_term = 0;
		STAT_serviced_request_count_short_term = 0;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x228(%rax), %rcx
movq %rcx, 0x230(%rax)
testb $0x1, 0x220(%rax)
je 0x3090a
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x258, %rdi            # imm = 0x258
addq $0x238, %rsi            # imm = 0x238
movl $0x10, %edx
callq 0x81f0
movq 0x8(%rsp), %rdi
addq $0x258, %rdi            # imm = 0x258
leaq 0x7b13e(%rip), %rsi     # 0xaba5b
callq 0x8440
movq %rax, %rdi
leaq 0x7b143(%rip), %rsi     # 0xaba6f
callq 0x8440
movq %rax, %rdi
leaq 0x7b145(%rip), %rsi     # 0xaba80
callq 0x8440
movq %rax, %rdi
movq 0xa960e(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x8(%rsp), %rax
movq $0x0, 0x458(%rax)
movl $0x0, 0x468(%rax)
addq $0x18, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Base.cpp
// Function: Host_Components::IO_Flow_Base::NVMe_update_and_submit_completion_queue_tail()
void IO_Flow_Base::NVMe_update_and_submit_completion_queue_tail()
	{
		nvme_queue_pair.Completion_queue_head++;
		if (nvme_queue_pair.Completion_queue_head == nvme_queue_pair.Completion_queue_size) {
			nvme_queue_pair.Completion_queue_head = 0;
		}
		pcie_root_complex->Write_to_device(nvme_queue_pair.Completion_head_register_address_on_device, nvme_queue_pair.Completion_queue_head);//Based on NVMe protocol definition, the updated head pointer should be informed to the device
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movw 0x98(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x98(%rcx)
movzwl 0x98(%rcx), %eax
movzwl 0x9c(%rcx), %ecx
cmpl %ecx, %eax
jne 0x323d5
movq 0x8(%rsp), %rax
movw $0x0, 0x98(%rax)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0xa0(%rax), %rsi
movzwl 0x98(%rax), %edx
callq 0x3f620
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::~IO_Flow_Synthetic()
IO_Flow_Synthetic::~IO_Flow_Synthetic()
	{
		delete random_request_type_generator;
		delete random_address_generator;
		delete random_hot_cold_generator;
		delete random_hot_address_generator;
		delete random_request_size_generator;
		delete random_time_interval_generator;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xa0756(%rip), %rcx     # 0xd8c30
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0xa0748(%rip), %rcx     # 0xd8c30
addq $0x68, %rcx
movq %rcx, 0x30(%rax)
movq 0x480(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x3850c
movq 0x38(%rsp), %rdi
callq 0x8410
movq 0x30(%rsp), %rax
movq 0x498(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x3852d
movq 0x28(%rsp), %rdi
callq 0x8410
movq 0x30(%rsp), %rax
movq 0x4a8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x3854e
movq 0x20(%rsp), %rdi
callq 0x8410
movq 0x30(%rsp), %rax
movq 0x4b8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x3856f
movq 0x18(%rsp), %rdi
callq 0x8410
movq 0x30(%rsp), %rax
movq 0x4e8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x38590
movq 0x10(%rsp), %rdi
callq 0x8410
movq 0x30(%rsp), %rax
movq 0x4f8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x385b1
movq 0x8(%rsp), %rdi
callq 0x8410
movq 0x30(%rsp), %rdi
callq 0x305d0
addq $0x48, %rsp
retq
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::NVMe_consume_io_request(Completion_Queue_Entry*)
void IO_Flow_Synthetic::NVMe_consume_io_request(Completion_Queue_Entry* io_request)
	{
		IO_Flow_Base::NVMe_consume_io_request(io_request);
		IO_Flow_Base::NVMe_update_and_submit_completion_queue_tail();
		if (generator_type == Utils::Request_Generator_Type::QUEUE_DEPTH) {
			Host_IO_Request* request = Generate_next_request();
			
			/* In the demand based execution mode, the Generate_next_request() function may return NULL
			* if 1) the simulation stop is met, or 2) the number of generated I/O requests reaches its threshold.*/
			if (request != NULL) {
				Submit_io_request(request);
			}
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x31200
movq 0x8(%rsp), %rdi
callq 0x32390
movq 0x8(%rsp), %rax
cmpl $0x1, 0x4f4(%rax)
jne 0x38c73
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x38c71
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x320b0
jmp 0x38c73
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::SATA_consume_io_request(Host_Components::Host_IO_Request*)
void IO_Flow_Synthetic::SATA_consume_io_request(Host_IO_Request* io_request)
	{
		IO_Flow_Base::SATA_consume_io_request(io_request);
		if (generator_type == Utils::Request_Generator_Type::QUEUE_DEPTH) {
			Host_IO_Request* request = Generate_next_request();
			/* In the demand based execution mode, the Generate_next_request() function may return NULL
			* if 1) the simulation stop is met, or 2) the number of generated I/O requests reaches its threshold.*/
			if (request != NULL) {
				Submit_io_request(request);
			}
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x30970
movq 0x8(%rsp), %rax
cmpl $0x1, 0x4f4(%rax)
jne 0x38cd9
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x38cd7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x320b0
jmp 0x38cd9
addq $0x28, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::Start_simulation()
void IO_Flow_Synthetic::Start_simulation() 
	{
		IO_Flow_Base::Start_simulation();

		if (address_distribution == Utils::Address_Distribution_Type::STREAMING) {
			streaming_next_address = random_address_generator->Uniform_ulong(start_lsa_on_device, end_lsa_on_device);
			if (generate_aligned_addresses) {
				streaming_next_address -= streaming_next_address % alignment_value;
			}
		}

		if (generator_type == Utils::Request_Generator_Type::BANDWIDTH) {
			Simulator->Register_sim_event((sim_time_type)random_time_interval_generator->Exponential((double)Average_inter_arrival_time_nano_sec), this, 0, 0);
		} else {
			Simulator->Register_sim_event((sim_time_type)1, this, 0, 0);
		}
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x308c0
movq 0x8(%rsp), %rax
cmpl $0x1, 0x48c(%rax)
jne 0x38d66
movq 0x8(%rsp), %rax
movq 0x498(%rax), %rdi
movq 0x68(%rax), %rsi
movq 0x70(%rax), %rdx
callq 0xa70a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x4d0(%rax)
testb $0x1, 0x514(%rax)
je 0x38d64
movq 0x8(%rsp), %rcx
movq 0x4d0(%rcx), %rax
movl 0x518(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq 0x8(%rsp), %rax
movq 0x4d0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x4d0(%rax)
jmp 0x38d66
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4f4(%rax)
jne 0x38dfc
callq 0x46500
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rsp)
movq 0x4f8(%rax), %rdi
movq 0x508(%rax), %xmm0
movaps 0x72c11(%rip), %xmm1    # 0xab9b0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x72c15(%rip), %xmm1    # 0xab9c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0xa7140
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x70229(%rip), %xmm1    # 0xa9008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x46c60
jmp 0x38e1a
callq 0x46500
movq 0x8(%rsp), %rdx
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x46c60
addq $0x18, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::Execute_simulator_event(MQSimEngine::Sim_Event*)
void IO_Flow_Synthetic::Execute_simulator_event(MQSimEngine::Sim_Event* event)
	{
		if (generator_type == Utils::Request_Generator_Type::BANDWIDTH) {
			Host_IO_Request* req = Generate_next_request();
			if (req != NULL) {
				Submit_io_request(req);
				Simulator->Register_sim_event(Simulator->Time() + (sim_time_type)random_time_interval_generator->Exponential((double)Average_inter_arrival_time_nano_sec), this, 0, 0);
			}
		} else {
			for (unsigned int i = 0; i < average_number_of_enqueued_requests; i++) {
				Submit_io_request(Generate_next_request());
			}
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x4f4(%rax)
jne 0x38f1e
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x38f1c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x320b0
callq 0x46500
movq %rax, 0x8(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq 0x4f8(%rax), %rdi
movq 0x508(%rax), %xmm0
movaps 0x72af7(%rip), %xmm1    # 0xab9b0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x72afb(%rip), %xmm1    # 0xab9c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0xa7140
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %r8
sarq $0x3f, %r8
movsd 0x7010a(%rip), %xmm1    # 0xa9008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %r8, %rcx
orq %rcx, %rax
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x46c60
jmp 0x38f5e
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x510(%rcx), %eax
jae 0x38f5c
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x320b0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x38f26
jmp 0x38f5e
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/../utils/StringTools.h
// Function: Utils::Helper_Functions::Tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&)
static void Tokenize(const std::string& str, char delimiter, std::vector<std::string>& output_tokens_list)
		{
			int size = (int) str.size();
			int start = 0, end = 0;
			while (end < size) {
				if (str[end] == delimiter && start <= end) {
					output_tokens_list.push_back(std::string(str.substr(start, end - start + 1)));
					start = end + 1;
				}
				end++;
			}
			if (str[end - 1] != delimiter) {
				output_tokens_list.push_back(std::string(str.substr(start, end - start)));
			}
		}

// Assembly:
subq $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
movb %al, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
callq 0x8310
movl %eax, 0x7c(%rsp)
movl $0x0, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jge 0x3b0ca
movq 0x90(%rsp), %rdi
movslq 0x74(%rsp), %rsi
callq 0x84c0
movsbl (%rax), %eax
movsbl 0x8f(%rsp), %ecx
cmpl %ecx, %eax
jne 0x3b0ba
movl 0x78(%rsp), %eax
cmpl 0x74(%rsp), %eax
jg 0x3b0ba
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rsi
movslq 0x78(%rsp), %rdx
movl %edx, %ecx
movl 0x74(%rsp), %eax
subl %ecx, %eax
incl %eax
movslq %eax, %rcx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8460
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3b400
jmp 0x3b086
leaq 0x50(%rsp), %rdi
callq 0x8848
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x78(%rsp)
jmp 0x3b0ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8848
jmp 0x3b161
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x3b002
movq 0x90(%rsp), %rdi
movl 0x74(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x84c0
movsbl (%rax), %eax
movsbl 0x8f(%rsp), %ecx
cmpl %ecx, %eax
je 0x3b159
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq 0x90(%rsp), %rsi
movslq 0x78(%rsp), %rdx
movl %edx, %ecx
movl 0x74(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8460
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3b400
jmp 0x3b133
leaq 0x20(%rsp), %rdi
callq 0x8848
jmp 0x3b159
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8848
jmp 0x3b161
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x8770
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Link.cpp
// Function: Host_Components::PCIe_Link::Deliver(Host_Components::PCIe_Message*)
void PCIe_Link::Deliver(PCIe_Message* message)
	{
		switch (message->Destination) {
			case PCIe_Destination_Type::HOST://Message from SSD device to the host
				Message_buffer_toward_root_complex.push(message);
				if (Message_buffer_toward_root_complex.size() > 1) {//There are active transfers
					return;
				}
				Simulator->Register_sim_event(Simulator->Time() + estimate_transfer_time(message), this, (void*)(intptr_t)PCIe_Destination_Type::HOST, static_cast<int>(PCIe_Link_Event_Type::DELIVER));
				break;
			case PCIe_Destination_Type::DEVICE://Message from Host to the SSD device
				Message_buffer_toward_ssd_device.push(message);
				if (Message_buffer_toward_ssd_device.size() > 1) {
					return;
				}
				Simulator->Register_sim_event(Simulator->Time() + estimate_transfer_time(message), this, (void*)(intptr_t)PCIe_Destination_Type::DEVICE, static_cast<int>(PCIe_Link_Event_Type::DELIVER));
				break;
			default:
				break;
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
testl %eax, %eax
je 0x3dfdb
jmp 0x3dfc9
movl 0x34(%rsp), %eax
subl $0x1, %eax
je 0x3e058
jmp 0x3e0cd
movq 0x28(%rsp), %rdi
addq $0xb0, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3e2e0
movq 0x28(%rsp), %rdi
addq $0xb0, %rdi
callq 0x3e310
cmpq $0x1, %rax
jbe 0x3e00d
jmp 0x3e0cf
callq 0x46500
movq %rax, 0x20(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq 0x28(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rsi
callq 0x3e320
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x46c60
jmp 0x3e0cf
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3e2e0
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
callq 0x3e310
cmpq $0x1, %rax
jbe 0x3e081
jmp 0x3e0cf
callq 0x46500
movq %rax, 0x10(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x3e320
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq %rax, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x46c60
jmp 0x3e0cf
jmp 0x3e0cf
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Link.cpp
// Function: Host_Components::PCIe_Link::Execute_simulator_event(MQSimEngine::Sim_Event*)
void PCIe_Link::Execute_simulator_event(MQSimEngine::Sim_Event* event)
	{
		PCIe_Message* message = NULL;
		PCIe_Destination_Type destination = (PCIe_Destination_Type)(intptr_t)event->Parameters;
		switch (destination) {
			case PCIe_Destination_Type::HOST:
				message = Message_buffer_toward_root_complex.front();
				Message_buffer_toward_root_complex.pop();
				root_complex->Consume_pcie_message(message);
				if (Message_buffer_toward_root_complex.size() > 0) {//There are active transfers
					Simulator->Register_sim_event(Simulator->Time() + estimate_transfer_time(Message_buffer_toward_root_complex.front()),
						this, (void*)(intptr_t)PCIe_Destination_Type::HOST, static_cast<int>(PCIe_Link_Event_Type::DELIVER));
				}
				break;
			case PCIe_Destination_Type::DEVICE:
				message = Message_buffer_toward_ssd_device.front();
				Message_buffer_toward_ssd_device.pop();
				pcie_switch->Deliver_to_device(message);
				if (Message_buffer_toward_ssd_device.size() > 0) {
					Simulator->Register_sim_event(Simulator->Time() + estimate_transfer_time(Message_buffer_toward_ssd_device.front()),
						this, (void*)(intptr_t)PCIe_Destination_Type::DEVICE, static_cast<int>(PCIe_Link_Event_Type::DELIVER));
				}
				break;
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
testl %eax, %eax
je 0x3e14d
jmp 0x3e13b
movl 0x28(%rsp), %eax
subl $0x1, %eax
je 0x3e1fe
jmp 0x3e29f
movq 0x20(%rsp), %rdi
addq $0xb0, %rdi
callq 0x3e480
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
addq $0xb0, %rdi
callq 0x3e490
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x3e4a0
movq 0x20(%rsp), %rdi
addq $0xb0, %rdi
callq 0x3e310
cmpq $0x0, %rax
jbe 0x3e1f9
callq 0x46500
movq %rax, 0x18(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0xb0, %rdi
callq 0x3e480
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
callq 0x3e320
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x46c60
jmp 0x3e29f
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
callq 0x3e480
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
addq $0x60, %rdi
callq 0x3e490
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x3f830
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
callq 0x3e310
cmpq $0x0, %rax
jbe 0x3e29d
callq 0x46500
movq %rax, 0x8(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
addq $0x60, %rdi
callq 0x3e480
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
callq 0x3e320
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rdx
addq %rax, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x46c60
jmp 0x3e29f
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Link.h
// Function: Host_Components::PCIe_Link::estimate_transfer_time(Host_Components::PCIe_Message*)
sim_time_type estimate_transfer_time(PCIe_Message* message)
		{
			switch (message->Type) {
				case PCIe_Message_Type::READ_COMP:
				case PCIe_Message_Type::WRITE_REQ:
				{
					int total_transfered_bytes = (message->Payload_size / tlp_max_payload_size) * (tlp_max_payload_size + packet_overhead)
						+ (message->Payload_size % tlp_max_payload_size == 0 ? 0 : message->Payload_size % tlp_max_payload_size + packet_overhead);
					return (sim_time_type)(((double)((total_transfered_bytes / lane_count) + (total_transfered_bytes % lane_count == 0 ? 0 : 1))) / lane_bandwidth_GBPs);
				}
				case PCIe_Message_Type::READ_REQ:
					return (sim_time_type)((((packet_overhead + 4) / lane_count) + ((packet_overhead + 4) % lane_count == 0 ? 0 : 1)) / lane_bandwidth_GBPs);
			}
			
			return 0;
		}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rsp)
testl %eax, %eax
je 0x3e413
jmp 0x3e34a
movl -0x20(%rsp), %eax
decl %eax
subl $0x1, %eax
ja 0x3e46b
jmp 0x3e35b
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x10(%rax), %eax
xorl %edx, %edx
divl 0x50(%rcx)
movl 0x50(%rcx), %edx
addl 0x5c(%rcx), %edx
imull %edx, %eax
movl %eax, -0x2c(%rsp)
movq -0x18(%rsp), %rax
movl 0x10(%rax), %eax
xorl %edx, %edx
divl 0x50(%rcx)
cmpl $0x0, %edx
jne 0x3e394
xorl %eax, %eax
movl %eax, -0x30(%rsp)
jmp 0x3e3af
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movl 0x10(%rax), %eax
xorl %edx, %edx
divl 0x50(%rcx)
movl %edx, %eax
addl 0x5c(%rcx), %eax
movl %eax, -0x30(%rsp)
movq -0x28(%rsp), %rcx
movl -0x2c(%rsp), %eax
movl -0x30(%rsp), %edx
addl %edx, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl 0x48(%rcx), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rsp), %rax
subl $0x1, %edx
sbbl $-0x1, %ecx
cvtsi2sd %ecx, %xmm0
movsd 0x40(%rax), %xmm1
divsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x6ac0b(%rip), %xmm1    # 0xa9008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x3e474
movq -0x28(%rsp), %rcx
movl 0x5c(%rcx), %eax
addl $0x4, %eax
movl 0x48(%rcx), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rsp), %rax
subl $0x1, %edx
sbbl $-0x1, %ecx
cvtsi2sd %ecx, %xmm0
movsd 0x40(%rax), %xmm1
divsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x6abb3(%rip), %xmm1    # 0xa9008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x3e474
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Root_Complex.h
// Function: Host_Components::PCIe_Root_Complex::Consume_pcie_message(Host_Components::PCIe_Message*)
void Consume_pcie_message(PCIe_Message* messages)//Modern processors support DDIO, where all writes to memory are going through LLC
		{
			switch (messages->Type)
			{
			case PCIe_Message_Type::READ_REQ:
				Read_from_memory(messages->Address, (unsigned int)(intptr_t)messages->Payload);
				break;
			case PCIe_Message_Type::WRITE_REQ:
				Write_to_memory(messages->Address, messages->Payload);
				break;
			default:
				break;
			}
			delete messages;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x3e4d5
jmp 0x3e4ca
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x3e4f5
jmp 0x3e513
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
callq 0x3f6b0
jmp 0x3e515
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x3f530
jmp 0x3e515
jmp 0x3e515
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3e52d
movq (%rsp), %rdi
callq 0x8410
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Root_Complex.cpp
// Function: Host_Components::PCIe_Root_Complex::Write_to_memory(unsigned long, void const*)
void PCIe_Root_Complex::Write_to_memory(const uint64_t address, const void* payload)
	{
		//This is a request to write back a read request data into memory (in modern systems the write is done to LLC)
		if (address >= DATA_MEMORY_REGION) {
			//nothing to do
		} else {
			switch (SSD_device_type) {
				case HostInterface_Types::NVME:
				{
					unsigned int flow_id = QUEUE_ID_TO_FLOW_ID(((Completion_Queue_Entry*)payload)->SQ_ID);
					((*IO_flows)[flow_id])->NVMe_consume_io_request((Completion_Queue_Entry*)payload);
					break;
				}
				case HostInterface_Types::SATA:
					sata_hba->SATA_consume_io_request((Completion_Queue_Entry*)payload);
					break;
				default:
					PRINT_ERROR("Uknown Host Interface type in PCIe_Root_Complex")
			}
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $0xff0000000000, %rax   # imm = 0xFF0000000000
cmpq %rax, 0x28(%rsp)
jb 0x3f563
jmp 0x3f616
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x3f5b4
jmp 0x3f575
movl 0xc(%rsp), %eax
subl $0x1, %eax
jne 0x3f5c9
jmp 0x3f580
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movzwl 0xa(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, 0x1c(%rsp)
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xcdd0
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x3f614
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x40640
jmp 0x3f614
movq 0x9aa20(%rip), %rdi     # 0xd9ff0
leaq 0x6b311(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x9aa0d(%rip), %rdi     # 0xd9ff0
leaq 0x6caa8(%rip), %rsi     # 0xac092
callq 0x8440
movq %rax, %rdi
movq 0x9a95f(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x9a9cb(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
jmp 0x3f616
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Root_Complex.cpp
// Function: Host_Components::PCIe_Root_Complex::Write_to_device(unsigned long, unsigned short)
void PCIe_Root_Complex::Write_to_device(uint64_t address, uint16_t write_value)
	{
		PCIe_Message* pcie_message = new Host_Components::PCIe_Message;
		pcie_message->Type = PCIe_Message_Type::WRITE_REQ;
		pcie_message->Destination = Host_Components::PCIe_Destination_Type::DEVICE;
		pcie_message->Address = address;
		pcie_message->Payload = (void*)(intptr_t)write_value;
		pcie_message->Payload_size = sizeof(write_value);
		pcie_link->Deliver(pcie_message);
	}

// Assembly:
subq $0x28, %rsp
movw %dx, %ax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x20, %edi
callq 0x8450
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movl $0x1, 0x4(%rcx)
movq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movzwl 0x16(%rsp), %ecx
movl %ecx, %edx
movq 0x8(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x8(%rsp), %rcx
movl $0x2, 0x10(%rcx)
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3dfa0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/PCIe_Root_Complex.cpp
// Function: Host_Components::PCIe_Root_Complex::Read_from_memory(unsigned long, unsigned int)
void PCIe_Root_Complex::Read_from_memory(const uint64_t address, const unsigned int read_size)
	{
		PCIe_Message* new_pcie_message = new Host_Components::PCIe_Message;
		new_pcie_message->Type = PCIe_Message_Type::READ_COMP;
		new_pcie_message->Destination = Host_Components::PCIe_Destination_Type::DEVICE;
		new_pcie_message->Address = address;

		//This is a request to read the data of a write request
		if (address >= DATA_MEMORY_REGION) {
			//nothing to do
			new_pcie_message->Payload_size = read_size;
			new_pcie_message->Payload = NULL;//No need to transfer data in the standalone mode of MQSim
		} else {
			switch (SSD_device_type) {
				case HostInterface_Types::NVME:
				{
					uint16_t flow_id = QUEUE_ID_TO_FLOW_ID(uint16_t(address >> NVME_COMP_Q_MEMORY_REGION));
					new_pcie_message->Payload = (*IO_flows)[flow_id]->NVMe_read_sqe(address);
					new_pcie_message->Payload_size = sizeof(Submission_Queue_Entry);
					break;
				}
				case HostInterface_Types::SATA:
					new_pcie_message->Payload = sata_hba->Read_ncq_entry(address);
					new_pcie_message->Payload_size = sizeof(Submission_Queue_Entry);
					break;
			}
		}

		pcie_link->Deliver(new_pcie_message);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x20, %edi
callq 0x8450
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl $0x2, 0x4(%rax)
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movabsq $0xff0000000000, %rax   # imm = 0xFF0000000000
cmpq %rax, 0x28(%rsp)
jb 0x3f72f
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x3f7c9
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x3f79c
jmp 0x3f741
movl 0x4(%rsp), %eax
subl $0x1, %eax
jne 0x3f7c7
jmp 0x3f74c
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
shrq $0x28, %rcx
movzwl %cx, %ecx
subl $0x1, %ecx
movw %cx, 0x16(%rsp)
movq 0x18(%rax), %rdi
movzwl 0x16(%rsp), %eax
movl %eax, %esi
callq 0xcdd0
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x31e50
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0x48, 0x10(%rax)
jmp 0x3f7c7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x406c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0x48, 0x10(%rax)
jmp 0x3f7c9
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x3dfa0
addq $0x38, %rsp
retq
// File: CMU-SAFARI[P]MQSim/src/host/../ssd/Host_Interface_Base.h
// Function: SSD_Components::Host_Interface_Base::Consume_pcie_message(Host_Components::PCIe_Message*)
void Consume_pcie_message(Host_Components::PCIe_Message* message)
		{
			if (message->Type == Host_Components::PCIe_Message_Type::READ_COMP) {
				request_fetch_unit->Process_pcie_read_message(message->Address, message->Payload, message->Payload_size);
			} else {
				request_fetch_unit->Process_pcie_write_message(message->Address, message->Payload, message->Payload_size);
			}
			delete message;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x3f91e
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0x3f947
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3f961
movq 0x8(%rsp), %rdi
callq 0x8410
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/host/SATA_HBA.cpp
// Function: Host_Components::SATA_HBA::~SATA_HBA()
SATA_HBA::~SATA_HBA()
	{
		for (auto &req : sata_ncq.queue) {
			if (req.second) {
				delete req.second;
			}
		}
		for (auto &req : waiting_requests_for_submission) {
			if (req) {
				delete req;
			}
		}
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x9915e(%rip), %rcx     # 0xd8d88
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x48, %rax
addq $0x30, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x34240
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x34270
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x342a0
testb $0x1, %al
jne 0x3fc71
jmp 0x3fcba
leaq 0x50(%rsp), %rdi
callq 0x342c0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3fcac
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3fcaa
movq 0x10(%rsp), %rdi
callq 0x8410
jmp 0x3fcac
jmp 0x3fcae
leaq 0x50(%rsp), %rdi
callq 0x342e0
jmp 0x3fc5c
movq 0x18(%rsp), %rax
addq $0xf8, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x34180
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x341b0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x341e0
testb $0x1, %al
jne 0x3fcfd
jmp 0x3fd44
leaq 0x30(%rsp), %rdi
callq 0x34200
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x3fd36
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3fd34
movq 0x8(%rsp), %rdi
callq 0x8410
jmp 0x3fd36
jmp 0x3fd38
leaq 0x30(%rsp), %rdi
callq 0x34220
jmp 0x3fce8
movq 0x18(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x40960
movq 0x18(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x40970
movq 0x18(%rsp), %rdi
addq $0xf8, %rdi
callq 0x34100
movq 0x18(%rsp), %rdi
addq $0xe0, %rdi
callq 0x34110
movq 0x18(%rsp), %rdi
addq $0xb0, %rdi
callq 0x34170
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x40980
movq 0x18(%rsp), %rdi
callq 0x1ff90
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)