LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::translate_lpa_to_ppa(unsigned short, SSD_Components::NVM_Transaction_Flash*)
bool Address_Mapping_Unit_Page_Level::translate_lpa_to_ppa(stream_id_type streamID, NVM_Transaction_Flash* transaction)
	{
		PPA_type ppa = domains[streamID]->Get_ppa(ideal_mapping_table, streamID, transaction->LPA);

		if (transaction->Type == Transaction_Type::READ) {
			if (ppa == NO_PPA) {
				ppa = online_create_entry_for_reads(transaction->LPA, streamID, transaction->Address, ((NVM_Transaction_Flash_RD*)transaction)->read_sectors_bitmap);
			}
			transaction->PPA = ppa;
			Convert_ppa_to_address(transaction->PPA, transaction->Address);
			block_manager->Read_transaction_issued(transaction->Address);
			transaction->Physical_address_determined = true;
			
			return true;
		} else {//This is a write transaction
			allocate_plane_for_user_write((NVM_Transaction_Flash_WR*)transaction);
			//there are too few free pages remaining only for GC
			if (ftl->GC_and_WL_Unit->Stop_servicing_writes(transaction->Address)){
				return false;
			}
			allocate_page_in_plane_for_user_write((NVM_Transaction_Flash_WR*)transaction, false);
			transaction->Physical_address_determined = true;
			
			return true;
		}
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rax), %rcx
movzwl 0x26(%rsp), %edx
movq (%rcx,%rdx,8), %rdi
movb 0x4c(%rax), %dl
movw 0x26(%rsp), %ax
movq 0x18(%rsp), %rcx
movq 0x58(%rcx), %rcx
andb $0x1, %dl
movzbl %dl, %esi
movzwl %ax, %edx
callq 0x59a80
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x4d8f9
cmpq $-0x1, 0x10(%rsp)
jne 0x4d8a4
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rsi
movw 0x26(%rsp), %dx
movq 0x18(%rsp), %rcx
addq $0x38, %rcx
movq 0x18(%rsp), %rax
movq 0x90(%rax), %r8
movq (%rdi), %rax
movzwl %dx, %edx
callq *0xd0(%rax)
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x18(%rsp), %rdx
addq $0x38, %rdx
movq (%rdi), %rax
callq *0x88(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rsp), %rsi
addq $0x38, %rsi
callq 0x7cd70
movq 0x18(%rsp), %rax
movb $0x1, 0x69(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x4d94f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4e2d0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x48(%rax), %rdi
movq 0x18(%rsp), %rsi
addq $0x38, %rsi
callq 0x81a30
testb $0x1, %al
jne 0x4d929
jmp 0x4d930
movb $0x0, 0x37(%rsp)
jmp 0x4d94f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x50a40
movq 0x18(%rsp), %rax
movb $0x1, 0x69(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::Start_servicing_writes_for_overfull_plane(NVM::FlashMemory::Physical_Page_Address)
void Address_Mapping_Unit_Page_Level::Start_servicing_writes_for_overfull_plane(const NVM::FlashMemory::Physical_Page_Address plane_address)
	{
		std::set<NVM_Transaction_Flash_WR*>& waiting_write_list = Write_transactions_for_overfull_planes[plane_address.ChannelID][plane_address.ChipID][plane_address.DieID][plane_address.PlaneID];

		ftl->TSU->Prepare_for_transaction_submit();
		auto program = waiting_write_list.begin();
		while (program != waiting_write_list.end()) {
			if (translate_lpa_to_ppa((*program)->Stream_id, *program)) {
				ftl->TSU->Submit_transaction(*program);
				if ((*program)->RelatedRead != NULL) {
					ftl->TSU->Submit_transaction((*program)->RelatedRead);
				}
				waiting_write_list.erase(program++);
			}
			else {
				break;
			}
		}
		ftl->TSU->Schedule();
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rax), %rcx
movl (%rsi), %edx
movq (%rcx,%rdx,8), %rcx
movl 0x4(%rsi), %edx
movq (%rcx,%rdx,8), %rcx
movl 0x8(%rsi), %edx
movq (%rcx,%rdx,8), %rcx
movl 0xc(%rsi), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, 0x50(%rsp)
movq 0x30(%rax), %rax
movq 0x50(%rax), %rdi
callq 0x59940
movq 0x50(%rsp), %rdi
callq 0x5a480
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5a4d0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5a4b0
testb $0x1, %al
jne 0x588c5
jmp 0x589ad
leaq 0x48(%rsp), %rdi
callq 0x5a500
movq (%rax), %rax
movw (%rax), %ax
movw %ax, 0x26(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5a500
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movw 0x26(%rsp), %ax
movq (%rcx), %rdx
movzwl %ax, %esi
callq 0x4d800
testb $0x1, %al
jne 0x58905
jmp 0x589a6
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5a500
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x59980
leaq 0x48(%rsp), %rdi
callq 0x5a500
movq (%rax), %rax
cmpq $0x0, 0x88(%rax)
je 0x58975
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5a500
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq 0x88(%rax), %rsi
callq 0x59980
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x5a570
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
callq 0x5a520
movq %rax, 0x30(%rsp)
jmp 0x589a8
jmp 0x589ad
jmp 0x5889e
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Cached_Mapping_Table::Exists(unsigned short, unsigned long)
inline bool Cached_Mapping_Table::Exists(const stream_id_type streamID, const LPA_type lpa)
	{
		LPA_type key = LPN_TO_UNIQUE_KEY(streamID, lpa);
		auto it = addressMap.find(key);
		if (it == addressMap.end()) {
			DEBUG("Address mapping table query - Stream ID:" << streamID << ", LPA:" << lpa << ", MISS")
				return false;
		}
		if (it->second->Status != CMTEntryStatus::VALID) {
			DEBUG("Address mapping table query - Stream ID:" << streamID << ", LPA:" << lpa << ", MISS")
			return false;
		}

		DEBUG("Address mapping table query - Stream ID:" << streamID << ", LPA:" << lpa << ", HIT")
		return true;
	}

// Assembly:
subq $0x48, %rsp
movw %si, %ax
movq %rdi, 0x38(%rsp)
movw %ax, 0x36(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movzwl 0x36(%rsp), %eax
shlq $0x38, %rax
orq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x58b20
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x58a40
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x58c10
testb $0x1, %al
jne 0x597c6
jmp 0x597cd
movb $0x0, 0x47(%rsp)
jmp 0x597ed
leaq 0x18(%rsp), %rdi
callq 0x58b50
movq 0x8(%rax), %rax
cmpl $0x2, 0x14(%rax)
je 0x597e8
movb $0x0, 0x47(%rsp)
jmp 0x597ed
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/TSU_Base.h
// Function: SSD_Components::TSU_Base::Prepare_for_transaction_submit()
void Prepare_for_transaction_submit()
	{
		opened_scheduling_reqs++;
		if (opened_scheduling_reqs > 1)
		{
			return;
		}
		transaction_receive_slots.clear();
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xa8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa8(%rax)
cmpl $0x1, 0xa8(%rax)
jle 0x5996d
jmp 0x5997b
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x5d190
addq $0x18, %rsp
retq
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::AddressMappingDomain::Update_mapping_info(bool, unsigned short, unsigned long, unsigned long, unsigned long)
inline void AddressMappingDomain::Update_mapping_info(const bool ideal_mapping, const stream_id_type stream_id, const LPA_type lpa, const PPA_type ppa, const page_status_type page_status_bitmap)
	{
		if (ideal_mapping) {
			GlobalMappingTable[lpa].PPA = ppa;
			GlobalMappingTable[lpa].WrittenStateBitmap = page_status_bitmap;
			GlobalMappingTable[lpa].TimeStamp = CurrentTimeStamp;
		} else {
			CMT->Update_mapping_info(stream_id, lpa, ppa, page_status_bitmap);
		}
	}

// Assembly:
subq $0x38, %rsp
movw %dx, %ax
movb %sil, %dl
movq %rdi, 0x30(%rsp)
andb $0x1, %dl
movb %dl, 0x2f(%rsp)
movw %ax, 0x2c(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x5a0c3
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rax), %rcx
imulq $0x18, 0x20(%rsp), %rsi
addq %rsi, %rcx
movq %rdx, (%rcx)
movq 0x10(%rsp), %rcx
movq 0x20(%rax), %rax
imulq $0x18, 0x20(%rsp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
imulq $0x18, 0x20(%rsp), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
jmp 0x5a0e8
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movw 0x2c(%rsp), %ax
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movzwl %ax, %esi
callq 0x4a620
addq $0x38, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/SSD_Defs.h
// Function: count_sector_no_from_status_bitmap(unsigned long)
inline unsigned int count_sector_no_from_status_bitmap(const page_status_type page_status)
{
	unsigned int size = 0;
	for (int i = 0; i < 64; i++) {
		if ((((page_status_type)1) << i) & page_status) {
			size++;
		}
	}

	return size;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x40, -0x10(%rsp)
jge 0x5a1bf
movl -0x10(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
andq -0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x5a1b0
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x5a1b2
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x5a185
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::Get_data_mapping_info_for_gc(unsigned short, unsigned long, unsigned long&, unsigned long&)
inline void Address_Mapping_Unit_Page_Level::Get_data_mapping_info_for_gc(const stream_id_type stream_id, const LPA_type lpa, PPA_type& ppa, page_status_type& page_state)
	{
		if (domains[stream_id]->Mapping_entry_accessible(ideal_mapping_table, stream_id, lpa)) {
			ppa = domains[stream_id]->Get_ppa(ideal_mapping_table, stream_id, lpa);
			page_state = domains[stream_id]->Get_page_status(ideal_mapping_table, stream_id, lpa);
		} else {
			ppa = domains[stream_id]->GlobalMappingTable[lpa].PPA;
			page_state = domains[stream_id]->GlobalMappingTable[lpa].WrittenStateBitmap;
		}
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rax), %rcx
movzwl 0x2e(%rsp), %edx
movq (%rcx,%rdx,8), %rdi
movb 0x4c(%rax), %dl
movw 0x2e(%rsp), %ax
movq 0x20(%rsp), %rcx
andb $0x1, %dl
movzbl %dl, %esi
movzwl %ax, %edx
callq 0x599b0
testb $0x1, %al
jne 0x5a60b
jmp 0x5a683
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rcx
movzwl 0x2e(%rsp), %edx
movq (%rcx,%rdx,8), %rdi
movb 0x4c(%rax), %dl
movw 0x2e(%rsp), %ax
movq 0x20(%rsp), %rcx
andb $0x1, %dl
movzbl %dl, %esi
movzwl %ax, %edx
callq 0x59a80
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rcx)
movq 0xa8(%rax), %rcx
movzwl 0x2e(%rsp), %edx
movq (%rcx,%rdx,8), %rdi
movb 0x4c(%rax), %dl
movw 0x2e(%rsp), %ax
movq 0x20(%rsp), %rcx
andb $0x1, %dl
movzbl %dl, %esi
movzwl %ax, %edx
callq 0x5a0f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x5a6d9
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rcx
movzwl 0x2e(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movq 0x20(%rcx), %rcx
imulq $0x18, 0x20(%rsp), %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, (%rcx)
movq 0xa8(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
imulq $0x18, 0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::Set_barrier_for_accessing_lpa(unsigned short, unsigned long)
inline void Address_Mapping_Unit_Page_Level::Set_barrier_for_accessing_lpa(stream_id_type stream_id, LPA_type lpa)
	{
		auto itr = domains[stream_id]->Locked_LPAs.find(lpa);
		if (itr != domains[stream_id]->Locked_LPAs.end()) {
			PRINT_ERROR("Illegal operation: Locking an LPA that has already been locked!");
		}
		domains[stream_id]->Locked_LPAs.insert(lpa);
	}

// Assembly:
subq $0x48, %rsp
movw %si, %ax
movq %rdi, 0x40(%rsp)
movw %ax, 0x3e(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rax), %rax
movzwl 0x3e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0xe8, %rdi
leaq 0x30(%rsp), %rsi
callq 0x5e3d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0xa8(%rax), %rax
movzwl 0x3e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0xe8, %rdi
callq 0x5e430
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5e410
testb $0x1, %al
jne 0x5aef4
jmp 0x5af3f
movq 0x7f0f5(%rip), %rdi     # 0xd9ff0
leaq 0x4f9e6(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x7f0e2(%rip), %rdi     # 0xd9ff0
leaq 0x51eae(%rip), %rsi     # 0xacdc3
callq 0x8440
movq %rax, %rdi
movq 0x7f034(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x7f0a0(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movzwl 0x3e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0xe8, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3b360
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::Set_barrier_for_accessing_mvpn(unsigned short, unsigned int)
inline void Address_Mapping_Unit_Page_Level::Set_barrier_for_accessing_mvpn(stream_id_type stream_id, MVPN_type mvpn)
	{
		auto itr = domains[stream_id]->Locked_MVPNs.find(mvpn);
		if (itr != domains[stream_id]->Locked_MVPNs.end()) {
			PRINT_ERROR("Illegal operation: Locking an MVPN that has already been locked!");
		}
		domains[stream_id]->Locked_MVPNs.insert(mvpn);
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0xa8(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0x28(%rsp), %rsi
callq 0x5a300
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0xa8(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x5a340
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5a2e0
testb $0x1, %al
jne 0x5b001
jmp 0x5b04c
movq 0x7efe8(%rip), %rdi     # 0xd9ff0
leaq 0x4f8d9(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x7efd5(%rip), %rdi     # 0xd9ff0
leaq 0x51de1(%rip), %rsi     # 0xace03
callq 0x8440
movq %rax, %rdi
movq 0x7ef27(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x7ef93(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq (%rsp), %rax
movq 0xa8(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0x28(%rsp), %rsi
callq 0x5e630
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
addq $0x38, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::manage_user_transaction_facing_barrier(SSD_Components::NVM_Transaction_Flash*)
inline void Address_Mapping_Unit_Page_Level::manage_user_transaction_facing_barrier(NVM_Transaction_Flash* transaction)
	{
		std::pair<LPA_type, NVM_Transaction_Flash*> entry(transaction->LPA, transaction);
		if (transaction->Type == Transaction_Type::READ) {
			domains[transaction->Stream_id]->Read_transactions_behind_LPA_barrier.insert(entry);
		} else {
			domains[transaction->Stream_id]->Write_transactions_behind_LPA_barrier.insert(entry);
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
addq $0x58, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x59a50
movq 0x28(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x5bd09
movq (%rsp), %rax
movq 0xa8(%rax), %rax
movq 0x28(%rsp), %rcx
movzwl (%rcx), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq 0x18(%rsp), %rsi
callq 0x5ef50
movq %rax, 0x10(%rsp)
jmp 0x5bd36
movq (%rsp), %rax
movq 0xa8(%rax), %rax
movq 0x28(%rsp), %rcx
movzwl (%rcx), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x178, %rdi            # imm = 0x178
leaq 0x18(%rsp), %rsi
callq 0x5ef50
movq %rax, 0x8(%rsp)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Address_Mapping_Unit_Page_Level.cpp
// Function: SSD_Components::Address_Mapping_Unit_Page_Level::manage_mapping_transaction_facing_barrier(unsigned short, unsigned int, bool)
inline void Address_Mapping_Unit_Page_Level::manage_mapping_transaction_facing_barrier(stream_id_type stream_id, MVPN_type mvpn, bool read)
	{
		if (read) {
			domains[stream_id]->MVPN_read_transactions_waiting_behind_barrier.insert(mvpn);
		} else {
			domains[stream_id]->MVPN_write_transaction_waiting_behind_barrier.insert(mvpn);
		}
	}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movw %si, %cx
movq %rdi, 0x40(%rsp)
movw %cx, 0x3e(%rsp)
movl %edx, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x37(%rsp)
je 0x5bd9f
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movzwl 0x3e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
leaq 0x38(%rsp), %rsi
callq 0x5e630
movq %rax, 0x20(%rsp)
movb %dl, 0x28(%rsp)
jmp 0x5bdce
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movzwl 0x3e(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
leaq 0x38(%rsp), %rsi
callq 0x5e630
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Exists(unsigned short, unsigned long)
bool Data_Cache_Flash::Exists(const stream_id_type stream_id, const LPA_type lpn)
	{
		LPA_type key = LPN_TO_UNIQUE_KEY(stream_id, lpn);
		auto it = slots.find(key);
		if (it == slots.end()) {
			return false;
		}

		return true;
	}

// Assembly:
subq $0x48, %rsp
movw %si, %ax
movq %rdi, 0x38(%rsp)
movw %ax, 0x36(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movzwl 0x36(%rsp), %eax
shlq $0x38, %rax
orq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x65190
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x651e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x651c0
testb $0x1, %al
jne 0x643f6
jmp 0x643fd
movb $0x0, 0x47(%rsp)
jmp 0x64402
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Get_slot(unsigned short, unsigned long)
Data_Cache_Slot_Type Data_Cache_Flash::Get_slot(const stream_id_type stream_id, const LPA_type lpn)
	{
		LPA_type key = LPN_TO_UNIQUE_KEY(stream_id, lpn);
		auto it = slots.find(key);
		assert(it != slots.end());
		if (lru_list.begin()->first != key) {
			lru_list.splice(lru_list.begin(), lru_list, it->second->lru_list_ptr);
		}

		return *(it->second);
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movw %dx, %ax
movq %rdi, 0x18(%rsp)
movq %rsi, 0x70(%rsp)
movw %ax, 0x6e(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movzwl 0x6e(%rsp), %eax
shlq $0x38, %rax
orq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x65190
movq 0x20(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x651e0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x65240
testb $0x1, %al
jne 0x64530
jmp 0x64532
jmp 0x64551
leaq 0x48988(%rip), %rdi     # 0xacec1
leaq 0x48993(%rip), %rsi     # 0xaced3
movl $0x1e, %edx
leaq 0x489a4(%rip), %rcx     # 0xacef0
callq 0x82d0
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
callq 0x652d0
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x65300
movq (%rax), %rax
cmpq 0x58(%rsp), %rax
je 0x645e7
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, (%rsp)
addq $0x38, %rdi
callq 0x652d0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x65370
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x65390
movq 0x8(%rax), %rsi
addq $0x28, %rsi
leaq 0x28(%rsp), %rdi
callq 0x65370
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rcx
callq 0x65320
leaq 0x50(%rsp), %rdi
callq 0x65390
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rsi
movl $0x30, %edx
callq 0x8390
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Evict_one_dirty_slot()
Data_Cache_Slot_Type Data_Cache_Flash::Evict_one_dirty_slot()
	{
		assert(slots.size() > 0);
		auto itr = lru_list.rbegin();
		while (itr != lru_list.rend()) {
			if ((*itr).second->Status == Cache_Slot_Status::DIRTY_NO_FLASH_WRITEBACK) {
				break;
			}
			itr++;
		}

		Data_Cache_Slot_Type evicted_item = *lru_list.back().second;
		if (itr == lru_list.rend()) {
			evicted_item.Status = Cache_Slot_Status::EMPTY;
			return evicted_item;
		}

		slots.erase(lru_list.back().first);
		delete lru_list.back().second;
		lru_list.pop_back();
		
		return evicted_item;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x653b0
cmpq $0x0, %rax
jbe 0x646fa
jmp 0x64719
leaq 0x48855(%rip), %rdi     # 0xacf56
leaq 0x487cb(%rip), %rsi     # 0xaced3
movl $0x3c, %edx
leaq 0x48853(%rip), %rcx     # 0xacf67
callq 0x82d0
movq 0x18(%rsp), %rsi
addq $0x38, %rsi
leaq 0x38(%rsp), %rdi
callq 0x653c0
movq 0x18(%rsp), %rsi
addq $0x38, %rsi
leaq 0x30(%rsp), %rdi
callq 0x65440
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x65410
testb $0x1, %al
jne 0x64754
jmp 0x6477d
leaq 0x38(%rsp), %rdi
callq 0x65490
movq 0x8(%rax), %rax
cmpl $0x2, 0x20(%rax)
jne 0x6476a
jmp 0x6477d
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x654c0
jmp 0x6472c
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x65500
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rsi
movl $0x30, %edx
callq 0x8390
movq 0x18(%rsp), %rsi
addq $0x38, %rsi
leaq 0x20(%rsp), %rdi
callq 0x65440
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x65540
testb $0x1, %al
jne 0x647c6
jmp 0x647d4
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
jmp 0x64822
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x65500
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x65590
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x65500
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x64814
movq (%rsp), %rdi
callq 0x8410
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x655c0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Evict_one_slot_lru()
Data_Cache_Slot_Type Data_Cache_Flash::Evict_one_slot_lru()
	{
		assert(slots.size() > 0);
		slots.erase(lru_list.back().first);
		Data_Cache_Slot_Type evicted_item = *lru_list.back().second;
		delete lru_list.back().second;
		lru_list.pop_back();

		return evicted_item;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x653b0
cmpq $0x0, %rax
jbe 0x6485a
jmp 0x64879
leaq 0x486f5(%rip), %rdi     # 0xacf56
leaq 0x4866b(%rip), %rsi     # 0xaced3
movl $0x54, %edx
leaq 0x48741(%rip), %rcx     # 0xacfb5
callq 0x82d0
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x65500
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x65590
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x65500
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rsi
movl $0x30, %edx
callq 0x8390
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x65500
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x648da
movq (%rsp), %rdi
callq 0x8410
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x655c0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Change_slot_status_to_writeback(unsigned short, unsigned long)
void Data_Cache_Flash::Change_slot_status_to_writeback(const stream_id_type stream_id, const LPA_type lpn)
	{
		LPA_type key = LPN_TO_UNIQUE_KEY(stream_id, lpn);
		auto it = slots.find(key);
		assert(it != slots.end());
		it->second->Status = Cache_Slot_Status::DIRTY_FLASH_WRITEBACK;
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movzwl 0x2e(%rsp), %eax
shlq $0x38, %rax
orq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x65190
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x651e0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x65240
testb $0x1, %al
jne 0x64964
jmp 0x64966
jmp 0x64985
leaq 0x48554(%rip), %rdi     # 0xacec1
leaq 0x4855f(%rip), %rsi     # 0xaced3
movl $0x61, %edx
leaq 0x48681(%rip), %rcx     # 0xad001
callq 0x82d0
leaq 0x10(%rsp), %rdi
callq 0x65390
movq 0x8(%rax), %rax
movl $0x3, 0x20(%rax)
addq $0x38, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Update_data(unsigned short, unsigned long, unsigned long, unsigned long, unsigned long)
void Data_Cache_Flash::Update_data(const stream_id_type stream_id, const LPA_type lpn, const data_cache_content_type content,
		const data_timestamp_type timestamp, const page_status_type state_bitmap_of_write_sectors)
	{
		LPA_type key = LPN_TO_UNIQUE_KEY(stream_id, lpn);
		auto it = slots.find(key);
		assert(it != slots.end());

		it->second->LPA = lpn;
		it->second->State_bitmap_of_existing_sectors = state_bitmap_of_write_sectors;
		it->second->Content = content;
		it->second->Timestamp = timestamp;
		it->second->Status = Cache_Slot_Status::DIRTY_NO_FLASH_WRITEBACK;
		if (lru_list.begin()->first != key) {
			lru_list.splice(lru_list.begin(), lru_list, it->second->lru_list_ptr);
		}
	}

// Assembly:
subq $0xa8, %rsp
movw %si, %ax
movq %rdi, 0xa0(%rsp)
movw %ax, 0x9e(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movzwl 0x9e(%rsp), %eax
shlq $0x38, %rax
orq 0x90(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x65190
movq 0x38(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x651e0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x65240
testb $0x1, %al
jne 0x64ef0
jmp 0x64ef2
jmp 0x64f11
leaq 0x47fc8(%rip), %rdi     # 0xacec1
leaq 0x47fd3(%rip), %rsi     # 0xaced3
movl $0x99, %edx
leaq 0x481ca(%rip), %rcx     # 0xad0d6
callq 0x82d0
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x65390
movq 0x18(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x65390
movq 0x20(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x65390
movq 0x28(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x65390
movq 0x30(%rsp), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0x68(%rsp), %rdi
callq 0x65390
movq 0x38(%rsp), %rdi
movq 0x8(%rax), %rax
movl $0x2, 0x20(%rax)
addq $0x38, %rdi
callq 0x652d0
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x65300
movq (%rax), %rax
cmpq 0x70(%rsp), %rax
je 0x6504a
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
callq 0x652d0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x65370
movq 0x38(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x65390
movq 0x8(%rax), %rsi
addq $0x28, %rsi
leaq 0x40(%rsp), %rdi
callq 0x65370
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rcx
callq 0x65320
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Flash.cpp
// Function: SSD_Components::Data_Cache_Flash::Remove_slot(unsigned short, unsigned long)
void Data_Cache_Flash::Remove_slot(const stream_id_type stream_id, const LPA_type lpn)
	{
		LPA_type key = LPN_TO_UNIQUE_KEY(stream_id, lpn);
		auto it = slots.find(key);
		assert(it != slots.end());
		lru_list.erase(it->second->lru_list_ptr);
		delete it->second;
		slots.erase(it);
	}

// Assembly:
subq $0x68, %rsp
movw %si, %ax
movq %rdi, 0x60(%rsp)
movw %ax, 0x5e(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movzwl 0x5e(%rsp), %eax
shlq $0x38, %rax
orq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x65190
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x651e0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x65240
testb $0x1, %al
jne 0x650c6
jmp 0x650c8
jmp 0x650e7
leaq 0x47df2(%rip), %rdi     # 0xacec1
leaq 0x47dfd(%rip), %rsi     # 0xaced3
movl $0xa9, %edx
leaq 0x4809f(%rip), %rcx     # 0xad181
callq 0x82d0
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x65390
movq 0x8(%rax), %rsi
addq $0x28, %rsi
leaq 0x30(%rsp), %rdi
callq 0x65370
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x656c0
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x65390
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x65146
movq 0x8(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x65710
movq %rax, 0x18(%rsp)
addq $0x68, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Manager_Flash_Advanced.cpp
// Function: SSD_Components::Data_Cache_Manager_Flash_Advanced::service_dram_access_request(SSD_Components::Memory_Transfer_Info*)
void Data_Cache_Manager_Flash_Advanced::service_dram_access_request(Memory_Transfer_Info* request_info)
	{
		if (memory_channel_is_busy) {
			if(shared_dram_request_queue) {
				dram_execution_queue[0].push(request_info);
			} else {
				dram_execution_queue[request_info->Stream_id].push(request_info);
			}
		} else {
			Simulator->Register_sim_event(Simulator->Time() + estimate_dram_access_time(request_info->Size_in_bytes, dram_row_size,
				dram_busrt_size, dram_burst_transfer_time_ddr, dram_tRCD, dram_tCL, dram_tRP),
				this, request_info, static_cast<int>(request_info->next_event_type));
			memory_channel_is_busy = true;
			dram_execution_list_turn = request_info->Stream_id;
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0xc8(%rax)
je 0x6b292
movq 0x10(%rsp), %rax
testb $0x1, 0xe0(%rax)
je 0x6b267
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6c4b0
jmp 0x6b28d
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rdi
movq 0x18(%rsp), %rax
movzwl 0x14(%rax), %eax
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x6c4b0
jmp 0x6b317
callq 0x46500
movq %rax, 0x8(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq 0x18(%rsp), %rcx
movl (%rcx), %edi
movl 0x40(%rax), %esi
movl 0x48(%rax), %edx
movsd 0x50(%rax), %xmm0
movq 0x58(%rax), %rcx
movq 0x60(%rax), %r8
movq 0x68(%rax), %r9
callq 0x6c4e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
addq %rax, %rsi
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %r8d
callq 0x46c60
movq 0x10(%rsp), %rax
movb $0x1, 0xc8(%rax)
movq 0x18(%rsp), %rcx
movzwl 0x14(%rcx), %ecx
movl %ecx, 0xe4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Data_Cache_Manager_Flash_Simple.cpp
// Function: SSD_Components::Data_Cache_Manager_Flash_Simple::service_dram_access_request(SSD_Components::Memory_Transfer_Info*)
void Data_Cache_Manager_Flash_Simple::service_dram_access_request(Memory_Transfer_Info* request_info)
	{
		dram_execution_queue[request_info->Stream_id].push(request_info);
		if(dram_execution_queue[request_info->Stream_id].size() == 1) {
			Simulator->Register_sim_event(Simulator->Time() + estimate_dram_access_time(request_info->Size_in_bytes, dram_row_size,
				dram_busrt_size, dram_burst_transfer_time_ddr, dram_tRCD, dram_tCL, dram_tRP),
				this, request_info, static_cast<int>(request_info->next_event_type));
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc8(%rax), %rdi
movq 0x18(%rsp), %rax
movzwl 0x14(%rax), %eax
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x6c4b0
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rdi
movq 0x18(%rsp), %rax
movzwl 0x14(%rax), %eax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x6bfa0
cmpq $0x1, %rax
jne 0x6ff7a
callq 0x46500
movq %rax, 0x8(%rsp)
callq 0x46500
movq %rax, %rdi
callq 0x46c50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq 0x18(%rsp), %rcx
movl (%rcx), %edi
movl 0x40(%rax), %esi
movl 0x48(%rax), %edx
movsd 0x50(%rax), %xmm0
movq 0x58(%rax), %rcx
movq 0x60(%rax), %r8
movq 0x68(%rax), %r9
callq 0x6c4e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
addq %rax, %rsi
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %r8d
callq 0x46c60
addq $0x28, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/FTL.cpp
// Function: SSD_Components::FTL::Validate_simulation_config()
void FTL::Validate_simulation_config()
	{
		NVM_Firmware::Validate_simulation_config();
		if (this->Data_cache_manager == NULL)
			throw std::logic_error("The cache manager is not set for FTL!");
		if (this->Address_Mapping_Unit == NULL)
			throw std::logic_error("The mapping module is not set for FTL!");
		if (this->BlockManager == NULL)
			throw std::logic_error("The block manager is not set for FTL!");
		if (this->GC_and_WL_Unit == NULL)
			throw std::logic_error("The garbage collector is not set for FTL!");
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8bbf0
movq 0x28(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x7113c
movl $0x10, %edi
callq 0x8200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x3c2b8(%rip), %rsi     # 0xad3b8
callq 0x8610
jmp 0x71107
movq 0x20(%rsp), %rdi
movq 0x68ead(%rip), %rsi     # 0xd9fc0
movq 0x68e76(%rip), %rdx     # 0xd9f90
callq 0x8710
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x8330
jmp 0x71267
movq 0x28(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x711a0
movl $0x10, %edi
callq 0x8200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x3c27a(%rip), %rsi     # 0xad3de
callq 0x8610
jmp 0x7116b
movq 0x18(%rsp), %rdi
movq 0x68e49(%rip), %rsi     # 0xd9fc0
movq 0x68e12(%rip), %rdx     # 0xd9f90
callq 0x8710
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x8330
jmp 0x71267
movq 0x28(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x71201
movl $0x10, %edi
callq 0x8200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x3c23d(%rip), %rsi     # 0xad405
callq 0x8610
jmp 0x711cf
movq 0x10(%rsp), %rdi
movq 0x68de5(%rip), %rsi     # 0xd9fc0
movq 0x68dae(%rip), %rdx     # 0xd9f90
callq 0x8710
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x8330
jmp 0x71267
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x71262
movl $0x10, %edi
callq 0x8200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x3c202(%rip), %rsi     # 0xad42b
callq 0x8610
jmp 0x71230
movq 0x8(%rsp), %rdi
movq 0x68d84(%rip), %rsi     # 0xd9fc0
movq 0x68d4d(%rip), %rdx     # 0xd9f90
callq 0x8710
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x8330
jmp 0x71267
addq $0x48, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8770
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager.cpp
// Function: SSD_Components::Flash_Block_Manager::Allocate_block_and_page_in_plane_for_user_write(unsigned short, NVM::FlashMemory::Physical_Page_Address&)
void Flash_Block_Manager::Allocate_block_and_page_in_plane_for_user_write(const stream_id_type stream_id, NVM::FlashMemory::Physical_Page_Address& page_address)
	{
		PlaneBookKeepingType *plane_record = &plane_manager[page_address.ChannelID][page_address.ChipID][page_address.DieID][page_address.PlaneID];
		plane_record->Valid_pages_count++;
		plane_record->Free_pages_count--;		
		page_address.BlockID = plane_record->Data_wf[stream_id]->BlockID;
		page_address.PageID = plane_record->Data_wf[stream_id]->Current_page_write_index++;
		program_transaction_issued(page_address);

		//The current write frontier block is written to the end
		if(plane_record->Data_wf[stream_id]->Current_page_write_index == pages_no_per_block) {
			//Assign a new write frontier block
			plane_record->Data_wf[stream_id] = plane_record->Get_a_free_block(stream_id, false);
			gc_and_wl_unit->Check_gc_required(plane_record->Get_free_block_pool_size(), page_address);
		}

		plane_record->Check_bookkeeping_correctness(page_address);
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x8(%rdi), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rax)
movq 0x20(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x20(%rsp), %rsi
callq 0x7cd00
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movzwl 0x2e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl 0x4(%rax), %eax
cmpl 0x34(%rcx), %eax
jne 0x7a994
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movzwl 0x2e(%rsp), %esi
callq 0x7c270
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x48(%rcx), %rcx
movzwl 0x2e(%rsp), %edx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7c950
movq 0x8(%rsp), %rdi
movl %eax, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7c7c0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager.cpp
// Function: SSD_Components::Flash_Block_Manager::Allocate_block_and_page_in_plane_for_gc_write(unsigned short, NVM::FlashMemory::Physical_Page_Address&)
void Flash_Block_Manager::Allocate_block_and_page_in_plane_for_gc_write(const stream_id_type stream_id, NVM::FlashMemory::Physical_Page_Address& page_address)
	{
		PlaneBookKeepingType *plane_record = &plane_manager[page_address.ChannelID][page_address.ChipID][page_address.DieID][page_address.PlaneID];
		plane_record->Valid_pages_count++;
		plane_record->Free_pages_count--;		
		page_address.BlockID = plane_record->GC_wf[stream_id]->BlockID;
		page_address.PageID = plane_record->GC_wf[stream_id]->Current_page_write_index++;

		
		//The current write frontier block is written to the end
		if (plane_record->GC_wf[stream_id]->Current_page_write_index == pages_no_per_block) {
			//Assign a new write frontier block
			plane_record->GC_wf[stream_id] = plane_record->Get_a_free_block(stream_id, false);
			gc_and_wl_unit->Check_gc_required(plane_record->Get_free_block_pool_size(), page_address);
		}
		plane_record->Check_bookkeeping_correctness(page_address);
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %rax
movq 0x20(%rsp), %rdx
movl (%rdx), %edx
movq (%rax,%rdx,8), %rax
movq 0x20(%rsp), %rdx
movl 0x4(%rdx), %edx
movq (%rax,%rdx,8), %rax
movq 0x20(%rsp), %rdx
movl 0x8(%rdx), %edx
movq (%rax,%rdx,8), %rax
movq 0x20(%rsp), %rdx
movl 0xc(%rdx), %edx
imulq $0xe0, %rdx, %rdx
addq %rdx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
addl $0x1, %edx
movl %edx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %edx
addl $-0x1, %edx
movl %edx, 0x4(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movzwl 0x2e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl (%rax), %edx
movq 0x20(%rsp), %rax
movl %edx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movzwl 0x2e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl 0x4(%rax), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, 0x4(%rax)
movq 0x20(%rsp), %rax
movl %edx, 0x14(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movzwl 0x2e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl 0x4(%rax), %eax
cmpl 0x34(%rcx), %eax
jne 0x7aad5
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movzwl 0x2e(%rsp), %esi
callq 0x7c270
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x50(%rcx), %rcx
movzwl 0x2e(%rsp), %edx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7c950
movq 0x8(%rsp), %rdi
movl %eax, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7c7c0
addq $0x38, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager.cpp
// Function: SSD_Components::Flash_Block_Manager::Allocate_block_and_page_in_plane_for_translation_write(unsigned short, NVM::FlashMemory::Physical_Page_Address&, bool)
void Flash_Block_Manager::Allocate_block_and_page_in_plane_for_translation_write(const stream_id_type streamID, NVM::FlashMemory::Physical_Page_Address& page_address, bool is_for_gc)
	{
		PlaneBookKeepingType *plane_record = &plane_manager[page_address.ChannelID][page_address.ChipID][page_address.DieID][page_address.PlaneID];
		plane_record->Valid_pages_count++;
		plane_record->Free_pages_count--;
		page_address.BlockID = plane_record->Translation_wf[streamID]->BlockID;
		page_address.PageID = plane_record->Translation_wf[streamID]->Current_page_write_index++;
		program_transaction_issued(page_address);

		//The current write frontier block for translation pages is written to the end
		if (plane_record->Translation_wf[streamID]->Current_page_write_index == pages_no_per_block) {
			//Assign a new write frontier block
			plane_record->Translation_wf[streamID] = plane_record->Get_a_free_block(streamID, true);
			if (!is_for_gc) {
				gc_and_wl_unit->Check_gc_required(plane_record->Get_free_block_pool_size(), page_address);
			}
		}
		plane_record->Check_bookkeeping_correctness(page_address);
	}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movw %si, %cx
movq %rdi, 0x30(%rsp)
movw %cx, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rax)
movq 0x20(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x20(%rsp), %rsi
callq 0x7cd00
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movzwl 0x2e(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl 0x4(%rax), %eax
cmpl 0x34(%rcx), %eax
jne 0x7af16
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movzwl 0x2e(%rsp), %esi
callq 0x7c270
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movzwl 0x2e(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
testb $0x1, 0x1f(%rsp)
jne 0x7af14
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x7c950
movq (%rsp), %rdi
movl %eax, %esi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x7af16
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7c7c0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager.cpp
// Function: SSD_Components::Flash_Block_Manager::Add_erased_block_to_pool(NVM::FlashMemory::Physical_Page_Address const&)
void Flash_Block_Manager::Add_erased_block_to_pool(const NVM::FlashMemory::Physical_Page_Address& block_address)
	{
		PlaneBookKeepingType *plane_record = &plane_manager[block_address.ChannelID][block_address.ChipID][block_address.DieID][block_address.PlaneID];
		Block_Pool_Slot_Type* block = &(plane_record->Blocks[block_address.BlockID]);
		plane_record->Free_pages_count += block->Invalid_page_count;
		plane_record->Invalid_pages_count -= block->Invalid_page_count;

		Stats::Block_erase_histogram[block_address.ChannelID][block_address.ChipID][block_address.DieID][block_address.PlaneID][block->Erase_count]--;
		block->Erase();
		Stats::Block_erase_histogram[block_address.ChannelID][block_address.ChipID][block_address.DieID][block_address.PlaneID][block->Erase_count]++;
		plane_record->Add_to_free_block_pool(block, gc_and_wl_unit->Use_dynamic_wearleveling());
		plane_record->Check_bookkeeping_correctness(block_address);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x20(%rsp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %edx
movq 0x20(%rsp), %rax
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
leaq 0x6081f(%rip), %rax     # 0xdb7f0
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movl 0xc(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x18(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x18(%rsp), %rdi
callq 0x7c740
movq (%rsp), %rax
leaq 0x607c7(%rip), %rcx     # 0xdb7f0
movq (%rcx), %rcx
movq 0x28(%rsp), %rdx
movl (%rdx), %edx
movq (%rcx,%rdx,8), %rcx
movq 0x28(%rsp), %rdx
movl 0x4(%rdx), %edx
movq (%rcx,%rdx,8), %rcx
movq 0x28(%rsp), %rdx
movl 0x8(%rdx), %edx
movq (%rcx,%rdx,8), %rcx
movq 0x28(%rsp), %rdx
movl 0xc(%rdx), %edx
movq (%rcx,%rdx,8), %rcx
movq 0x18(%rsp), %rdx
movl 0x10(%rdx), %edx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rdi
callq 0x81b70
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movzbl %al, %edx
andl $0x1, %edx
callq 0x7c1e0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7c7c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)