LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager.cpp
// Function: SSD_Components::Flash_Block_Manager::Invalidate_page_in_block(unsigned short, NVM::FlashMemory::Physical_Page_Address const&)
inline void Flash_Block_Manager::Invalidate_page_in_block(const stream_id_type stream_id, const 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->Invalid_pages_count++;
		plane_record->Valid_pages_count--;
		if (plane_record->Blocks[page_address.BlockID].Stream_id != stream_id) {
			PRINT_ERROR("Inconsistent status in the Invalidate_page_in_block function! The accessed block is not allocated to stream " << stream_id)
		}
		plane_record->Blocks[page_address.BlockID].Invalid_page_count++;
		plane_record->Blocks[page_address.BlockID].Invalid_page_bitmap[page_address.PageID / 64] |= ((uint64_t)0x1) << (page_address.PageID % 64);
	}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movzwl 0x20(%rax), %eax
movzwl 0x1e(%rsp), %ecx
cmpl %ecx, %eax
je 0x7b1b2
movq 0x5ee8f(%rip), %rdi     # 0xd9ff0
leaq 0x2f780(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x5ee7c(%rip), %rdi     # 0xd9ff0
leaq 0x32969(%rip), %rsi     # 0xadae4
callq 0x8440
movq %rax, %rdi
movzwl 0x1e(%rsp), %esi
callq 0x86f0
movq %rax, %rdi
movq 0x5edc1(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x5ee2d(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
andl $0x3f, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
shrl $0x6, %ecx
movl %ecx, %ecx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager.cpp
// Function: SSD_Components::Flash_Block_Manager::Invalidate_page_in_block_for_preconditioning(unsigned short, NVM::FlashMemory::Physical_Page_Address const&)
inline void Flash_Block_Manager::Invalidate_page_in_block_for_preconditioning(const stream_id_type stream_id, const 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->Invalid_pages_count++;
		if (plane_record->Blocks[page_address.BlockID].Stream_id != stream_id) {
			PRINT_ERROR("Inconsistent status in the Invalidate_page_in_block function! The accessed block is not allocated to stream " << stream_id)
		}
		plane_record->Blocks[page_address.BlockID].Invalid_page_count++;
		plane_record->Blocks[page_address.BlockID].Invalid_page_bitmap[page_address.PageID / 64] |= ((uint64_t)0x1) << (page_address.PageID % 64);
	}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movzwl 0x20(%rax), %eax
movzwl 0x1e(%rsp), %ecx
cmpl %ecx, %eax
je 0x7b304
movq 0x5ed3d(%rip), %rdi     # 0xd9ff0
leaq 0x2f62e(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x5ed2a(%rip), %rdi     # 0xd9ff0
leaq 0x32817(%rip), %rsi     # 0xadae4
callq 0x8440
movq %rax, %rdi
movzwl 0x1e(%rsp), %esi
callq 0x86f0
movq %rax, %rdi
movq 0x5ec6f(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x5ecdb(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
andl $0x3f, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
shrl $0x6, %ecx
movl %ecx, %ecx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager_Base.cpp
// Function: SSD_Components::PlaneBookKeepingType::Add_to_free_block_pool(SSD_Components::Block_Pool_Slot_Type*, bool)
void PlaneBookKeepingType::Add_to_free_block_pool(Block_Pool_Slot_Type* block, bool consider_dynamic_wl)
	{
		if (consider_dynamic_wl) {
			std::pair<unsigned int, Block_Pool_Slot_Type*> entry(block->Erase_count, block);
			Free_block_pool.insert(entry);
		} else {
			std::pair<unsigned int, Block_Pool_Slot_Type*> entry(0, block);
			Free_block_pool.insert(entry);
		}
	}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x47(%rsp)
je 0x7c237
movq 0x48(%rsp), %rsi
addq $0x10, %rsi
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x7d190
movq (%rsp), %rdi
addq $0x18, %rdi
leaq 0x30(%rsp), %rsi
callq 0x7d1c0
movq %rax, 0x28(%rsp)
jmp 0x7c26a
movl $0x0, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x7d1f0
movq (%rsp), %rdi
addq $0x18, %rdi
leaq 0x18(%rsp), %rsi
callq 0x7d1c0
movq %rax, 0x8(%rsp)
addq $0x58, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager_Base.cpp
// Function: SSD_Components::PlaneBookKeepingType::Get_a_free_block(unsigned short, bool)
Block_Pool_Slot_Type* PlaneBookKeepingType::Get_a_free_block(stream_id_type stream_id, bool for_mapping_data)
	{
		Block_Pool_Slot_Type* new_block = NULL;
		new_block = (*Free_block_pool.begin()).second;//Assign a new write frontier block
		if (Free_block_pool.size() == 0) {
			PRINT_ERROR("Requesting a free block from an empty pool!")
		}
		Free_block_pool.erase(Free_block_pool.begin());
		new_block->Stream_id = stream_id;
		new_block->Holds_mapping_data = for_mapping_data;
		Block_usage_history.push(new_block->BlockID);

		return new_block;
	}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, 0x40(%rsp)
movw %cx, 0x3e(%rsp)
andb $0x1, %al
movb %al, 0x3d(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
addq $0x18, %rdi
callq 0x7d0d0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7d100
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
addq $0x18, %rdi
callq 0x7b3e0
cmpq $0x0, %rax
jne 0x7c31c
movq 0x5dd18(%rip), %rdi     # 0xd9ff0
leaq 0x2e609(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x5dd05(%rip), %rdi     # 0xd9ff0
leaq 0x31887(%rip), %rsi     # 0xadb79
callq 0x8440
movq %rax, %rdi
movq 0x5dc57(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x5dcc3(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x7d0d0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x7d120
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movw 0x3e(%rsp), %cx
movq 0x30(%rsp), %rax
movw %cx, 0x20(%rax)
movb 0x3d(%rsp), %cl
movq 0x30(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x22(%rax)
addq $0x60, %rdi
movq 0x30(%rsp), %rsi
callq 0x7d160
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager_Base.cpp
// Function: SSD_Components::Block_Pool_Slot_Type::Erase()
void Block_Pool_Slot_Type::Erase()
	{
		Current_page_write_index = 0;
		Invalid_page_count = 0;
		Erase_count++;
		for (unsigned int i = 0; i < Block_Pool_Slot_Type::Page_vector_size; i++) {
			Invalid_page_bitmap[i] = All_VALID_PAGE;
		}
		Stream_id = NO_STREAM;
		Holds_mapping_data = false;
		Erase_transaction = NULL;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, 0x4(%rax)
movl $0x0, 0xc(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl 0x5df80(%rip), %eax     # 0xda6f8
jae 0x7c79c
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x7c76e
movq -0x18(%rsp), %rax
movw $0xff, 0x20(%rax)
movb $0x0, 0x22(%rax)
movq $0x0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager_Base.cpp
// Function: SSD_Components::PlaneBookKeepingType::Check_bookkeeping_correctness(NVM::FlashMemory::Physical_Page_Address const&)
void PlaneBookKeepingType::Check_bookkeeping_correctness(const NVM::FlashMemory::Physical_Page_Address& plane_address)
	{
		if (Total_pages_count != Free_pages_count + Valid_pages_count + Invalid_pages_count) {
			PRINT_ERROR("Inconsistent status in the plane bookkeeping record!")
		}
		if (Free_pages_count == 0) {
			PRINT_ERROR("Plane " << "@" << plane_address.ChannelID << "@" << plane_address.ChipID << "@" << plane_address.DieID << "@" << plane_address.PlaneID << " pool size: " << Get_free_block_pool_size() << " ran out of free pages! Bad resource management! It is not safe to continue simulation!");
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdx
movq %rdx, 0x10(%rsp)
movl (%rdx), %eax
movl 0x4(%rdx), %ecx
addl 0x8(%rdx), %ecx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
je 0x7c832
movq 0x5d802(%rip), %rdi     # 0xd9ff0
leaq 0x2e0f3(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x5d7ef(%rip), %rdi     # 0xd9ff0
leaq 0x3139d(%rip), %rsi     # 0xadba5
callq 0x8440
movq %rax, %rdi
movq 0x5d741(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x5d7ad(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7c940
movq 0x5d7a8(%rip), %rdi     # 0xd9ff0
leaq 0x2e099(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x5d795(%rip), %rdi     # 0xd9ff0
leaq 0x31378(%rip), %rsi     # 0xadbda
callq 0x8440
movq %rax, %rdi
leaq 0x3201f(%rip), %rsi     # 0xae890
callq 0x8440
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x85b0
movq %rax, %rdi
leaq 0x32001(%rip), %rsi     # 0xae890
callq 0x8440
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x85b0
movq %rax, %rdi
leaq 0x31fe2(%rip), %rsi     # 0xae890
callq 0x8440
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x85b0
movq %rax, %rdi
leaq 0x31fc3(%rip), %rsi     # 0xae890
callq 0x8440
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0xc(%rax), %esi
callq 0x85b0
movq %rax, %rdi
leaq 0x312f5(%rip), %rsi     # 0xadbe1
callq 0x8440
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x7c950
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x85b0
movq %rax, %rdi
leaq 0x312d8(%rip), %rsi     # 0xadbee
callq 0x8440
movq %rax, %rdi
movq 0x5d633(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x5d69f(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager_Base.cpp
// Function: SSD_Components::Flash_Block_Manager_Base::Get_min_max_erase_difference(NVM::FlashMemory::Physical_Page_Address const&)
unsigned int Flash_Block_Manager_Base::Get_min_max_erase_difference(const NVM::FlashMemory::Physical_Page_Address& plane_address)
	{
		unsigned int min_erased_block = 0;
		unsigned int max_erased_block = 0;
		PlaneBookKeepingType *plane_record = &plane_manager[plane_address.ChannelID][plane_address.ChipID][plane_address.DieID][plane_address.PlaneID];

		for (unsigned int i = 1; i < block_no_per_plane; i++) {
			if (plane_record->Blocks[i].Erase_count > plane_record->Blocks[max_erased_block].Erase_count) {
				max_erased_block = i;
			}
			if (plane_record->Blocks[i].Erase_count < plane_record->Blocks[min_erased_block].Erase_count) {
				min_erased_block = i;
			}
		}

		return max_erased_block - min_erased_block;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movl $0x1, -0x24(%rsp)
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %eax
cmpl 0x30(%rcx), %eax
jae 0x7ca6e
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movl -0x18(%rsp), %edx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jbe 0x7ca24
movl -0x24(%rsp), %eax
movl %eax, -0x18(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movl -0x14(%rsp), %edx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jae 0x7ca5c
movl -0x24(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x7ca5e
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x7c9da
movl -0x18(%rsp), %eax
subl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Flash_Block_Manager_Base.cpp
// Function: SSD_Components::Flash_Block_Manager_Base::Get_coldest_block_id(NVM::FlashMemory::Physical_Page_Address const&)
flash_block_ID_type Flash_Block_Manager_Base::Get_coldest_block_id(const NVM::FlashMemory::Physical_Page_Address& plane_address)
	{
		unsigned int min_erased_block = 0;
		PlaneBookKeepingType *plane_record = &plane_manager[plane_address.ChannelID][plane_address.ChipID][plane_address.DieID][plane_address.PlaneID];

		for (unsigned int i = 1; i < block_no_per_plane; i++) {
			if (plane_record->Blocks[i].Erase_count < plane_record->Blocks[min_erased_block].Erase_count) {
				min_erased_block = i;
			}
		}
		
		return min_erased_block;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x14(%rsp)
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movl $0x1, -0x24(%rsp)
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %eax
cmpl 0x30(%rcx), %eax
jae 0x7cb37
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movl -0x14(%rsp), %edx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jae 0x7cb28
movl -0x24(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x7cb2a
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x7cae2
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/GC_and_WL_Unit_Base.cpp
// Function: SSD_Components::GC_and_WL_Unit_Base::Get_GC_policy_specific_parameter()
unsigned int GC_and_WL_Unit_Base::Get_GC_policy_specific_parameter()
	{
		switch (block_selection_policy) {
			case GC_Block_Selection_Policy_Type::RGA:
				return rga_set_size;
			case GC_Block_Selection_Policy_Type::RANDOM_PP:
				return random_pp_threshold;
		}

		return 0;
	}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl 0x2c(%rax), %eax
movl %eax, -0x14(%rsp)
subl $0x1, %eax
je 0x81b28
jmp 0x81b1d
movl -0x14(%rsp), %eax
subl $0x4, %eax
je 0x81b39
jmp 0x81b4a
movq -0x20(%rsp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x81b52
movq -0x20(%rsp), %rax
movl 0xf0(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x81b52
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/GC_and_WL_Unit_Base.cpp
// Function: SSD_Components::GC_and_WL_Unit_Base::is_safe_gc_wl_candidate(SSD_Components::PlaneBookKeepingType const*, unsigned int)
bool GC_and_WL_Unit_Base::is_safe_gc_wl_candidate(const PlaneBookKeepingType* plane_record, const flash_block_ID_type gc_wl_candidate_block_id)
	{
		//The block shouldn't be a current write frontier
		for (unsigned int stream_id = 0; stream_id < address_mapping_unit->Get_no_of_input_streams(); stream_id++) {
			if ((&plane_record->Blocks[gc_wl_candidate_block_id]) == plane_record->Data_wf[stream_id]
				|| (&plane_record->Blocks[gc_wl_candidate_block_id]) == plane_record->Translation_wf[stream_id]
				|| (&plane_record->Blocks[gc_wl_candidate_block_id]) == plane_record->GC_wf[stream_id]) {
				return false;
			}
		}

		//The block shouldn't have an ongoing program request (all pages must already be written)
		if (plane_record->Blocks[gc_wl_candidate_block_id].Ongoing_user_program_count > 0) {
			return false;
		}

		if (plane_record->Blocks[gc_wl_candidate_block_id].Has_ongoing_gc_wl) {
			return false;
		}

		return true;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rsp)
movq 0x30(%rax), %rdi
callq 0x81e80
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x81c56
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movq 0x48(%rcx), %rcx
movl 0x18(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
je 0x81c3d
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movq 0x58(%rcx), %rcx
movl 0x18(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
je 0x81c3d
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movq 0x50(%rcx), %rcx
movl 0x18(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
jne 0x81c44
movb $0x0, 0x37(%rsp)
jmp 0x81c9d
jmp 0x81c46
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x81ba4
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $0x0, 0x38(%rax)
jle 0x81c77
movb $0x0, 0x37(%rsp)
jmp 0x81c9d
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
testb $0x1, 0x23(%rax)
je 0x81c98
movb $0x0, 0x37(%rsp)
jmp 0x81c9d
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/GC_and_WL_Unit_Page_Level.cpp
// Function: SSD_Components::GC_and_WL_Unit_Page_Level::GC_is_in_urgent_mode(NVM::FlashMemory::Flash_Chip const*)
bool GC_and_WL_Unit_Page_Level::GC_is_in_urgent_mode(const NVM::FlashMemory::Flash_Chip* chip)
	{
		if (!preemptible_gc_enabled) {
			return true;
		}

		NVM::FlashMemory::Physical_Page_Address addr;
		addr.ChannelID = chip->ChannelID; addr.ChipID = chip->ChipID;
		for (unsigned int die_id = 0; die_id < die_no_per_chip; die_id++) {
			for (unsigned int plane_id = 0; plane_id < plane_no_per_die; plane_id++) {
				addr.DieID = die_id; addr.PlaneID = plane_id;
				if (block_manager->Get_pool_size(addr) < block_pool_gc_hard_threshold)
					return true;
			}
		}

		return false;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x6c(%rax)
jne 0x83218
movb $0x1, 0x47(%rsp)
jmp 0x832da
leaq 0x18(%rsp), %rdi
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
callq 0x4a220
movq 0x30(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0xfc(%rcx), %eax
jae 0x832d5
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x100(%rcx), %eax
jae 0x832c6
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x20(%rsp)
movl 0x10(%rsp), %ecx
movl %ecx, 0x24(%rsp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
callq *0x48(%rax)
movq 0x8(%rsp), %rcx
cmpl 0x78(%rcx), %eax
jae 0x832b7
movb $0x1, 0x47(%rsp)
jmp 0x832da
jmp 0x832b9
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x83271
jmp 0x832c8
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x83258
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_Base.cpp
// Function: SSD_Components::Host_Interface_Base::Send_read_message_to_host(unsigned long, unsigned int)
void Host_Interface_Base::Send_read_message_to_host(uint64_t addresss, unsigned int request_read_data_size)
	{
		Host_Components::PCIe_Message* pcie_message = new Host_Components::PCIe_Message;
		pcie_message->Type = Host_Components::PCIe_Message_Type::READ_REQ;
		pcie_message->Destination = Host_Components::PCIe_Destination_Type::HOST;
		pcie_message->Address = addresss;
		pcie_message->Payload = (void*)(intptr_t)request_read_data_size;
		pcie_message->Payload_size = sizeof(request_read_data_size);
		pcie_switch->Send_to_host(pcie_message);
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%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 $0x0, 0x4(%rcx)
movq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movl 0x14(%rsp), %ecx
movl %ecx, %edx
movq 0x8(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x8(%rsp), %rcx
movl $0x4, 0x10(%rcx)
movq 0x80(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3f860
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_Base.cpp
// Function: SSD_Components::Host_Interface_Base::Send_write_message_to_host(unsigned long, void*, unsigned int)
void Host_Interface_Base::Send_write_message_to_host(uint64_t addresss, void* message, unsigned int message_size)
	{
		Host_Components::PCIe_Message* pcie_message = new Host_Components::PCIe_Message;
		pcie_message->Type = Host_Components::PCIe_Message_Type::WRITE_REQ;
		pcie_message->Destination = Host_Components::PCIe_Destination_Type::HOST;
		pcie_message->Address = addresss;
		COPYDATA(pcie_message->Payload, message, pcie_message->Payload_size);
		pcie_message->Payload_size = message_size;
		pcie_switch->Send_to_host(pcie_message);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x20, %edi
callq 0x8450
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x46500
movq %rax, %rdi
callq 0x46d20
testb $0x1, %al
jne 0x847e8
jmp 0x84822
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
callq 0x8030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x8390
jmp 0x84830
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %edx, 0x10(%rcx)
movq 0x80(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x3f860
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_Base.cpp
// Function: SSD_Components::Input_Stream_Manager_Base::Get_average_read_transaction_turnaround_time(unsigned short)
uint32_t Input_Stream_Manager_Base::Get_average_read_transaction_turnaround_time(stream_id_type stream_id)//in microseconds
	{
		if (input_streams[stream_id]->STAT_number_of_read_transactions == 0) {
			return 0;
		}
		return (uint32_t)((input_streams[stream_id]->STAT_sum_of_read_transactions_execution_time + input_streams[stream_id]->STAT_sum_of_read_transactions_transfer_time + input_streams[stream_id]->STAT_sum_of_read_transactions_waiting_time)
			/ input_streams[stream_id]->STAT_number_of_read_transactions / SIM_TIME_TO_MICROSECONDS_COEFF);
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x84af1
movl $0x0, 0x34(%rsp)
jmp 0x84b98
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
addq 0x20(%rcx), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
addq 0x28(%rcx), %rax
movq %rax, 0x10(%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_Base.cpp
// Function: SSD_Components::Input_Stream_Manager_Base::Get_average_write_transaction_turnaround_time(unsigned short)
uint32_t Input_Stream_Manager_Base::Get_average_write_transaction_turnaround_time(stream_id_type stream_id)//in microseconds
	{
		if (input_streams[stream_id]->STAT_number_of_write_transactions == 0) {
			return 0;
		}
		return (uint32_t)((input_streams[stream_id]->STAT_sum_of_write_transactions_execution_time + input_streams[stream_id]->STAT_sum_of_write_transactions_transfer_time + input_streams[stream_id]->STAT_sum_of_write_transactions_waiting_time)
			/ input_streams[stream_id]->STAT_number_of_write_transactions / SIM_TIME_TO_MICROSECONDS_COEFF);
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rax
cmpl $0x0, 0x14(%rax)
jne 0x84dd1
movl $0x0, 0x34(%rsp)
jmp 0x84e78
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
addq 0x38(%rcx), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
addq 0x40(%rcx), %rax
movq %rax, 0x10(%rsp)
addq $0x10, %rdi
movzwl 0x26(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movl 0x14(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Input_Stream_NVMe::~Input_Stream_NVMe()
Input_Stream_NVMe::~Input_Stream_NVMe()
{
	for (auto &user_request : Waiting_user_requests)
		delete user_request;
	for (auto &user_request : Completed_user_requests)
		delete user_request;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x53ebe(%rip), %rcx     # 0xd9708
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x88, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x6bfd0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x6c000
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6c030
testb $0x1, %al
jne 0x8588f
jmp 0x858d3
leaq 0x50(%rsp), %rdi
callq 0x6c050
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x858c5
movq 0x10(%rsp), %rdi
callq 0x6c070
movq 0x10(%rsp), %rdi
callq 0x8410
jmp 0x858c7
leaq 0x50(%rsp), %rdi
callq 0x6c0a0
jmp 0x8587a
movq 0x18(%rsp), %rax
addq $0xa0, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6bfd0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6c000
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6c030
testb $0x1, %al
jne 0x85916
jmp 0x8595a
leaq 0x30(%rsp), %rdi
callq 0x6c050
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8594c
movq 0x8(%rsp), %rdi
callq 0x6c070
movq 0x8(%rsp), %rdi
callq 0x8410
jmp 0x8594e
leaq 0x30(%rsp), %rdi
callq 0x6c0a0
jmp 0x85901
movq 0x18(%rsp), %rdi
addq $0xb8, %rdi
callq 0x6c0c0
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0x6c0c0
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
callq 0x6c0c0
movq 0x18(%rsp), %rdi
callq 0x84450
addq $0x68, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Input_Stream_Manager_NVMe::Create_new_stream(IO_Flow_Priority_Class::Priority, unsigned long, unsigned long, unsigned long, unsigned short, unsigned long, unsigned short)
stream_id_type Input_Stream_Manager_NVMe::Create_new_stream(IO_Flow_Priority_Class::Priority priority_class,
															LHA_type start_logical_sector_address,
															LHA_type end_logical_sector_address,
															uint64_t submission_queue_base_address,
															uint16_t submission_queue_size,
															uint64_t completion_queue_base_address,
															uint16_t completion_queue_size)
{
	if (end_logical_sector_address < start_logical_sector_address)
	{
		PRINT_ERROR("Error in allocating address range to a stream in host interface: the start address should be smaller than the end address.")
	}
	Input_Stream_NVMe *input_stream = new Input_Stream_NVMe(priority_class, start_logical_sector_address, end_logical_sector_address,
															submission_queue_base_address, submission_queue_size, completion_queue_base_address, completion_queue_size);
	this->input_streams.push_back(input_stream);

	return (stream_id_type)(this->input_streams.size() - 1);
}

// Assembly:
subq $0x78, %rsp
movw %r9w, %ax
movw 0x88(%rsp), %r9w
movq 0x80(%rsp), %r9
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movw %ax, 0x4e(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0x85ab7
movq 0x5457d(%rip), %rdi     # 0xd9ff0
leaq 0x24e6e(%rip), %rsi     # 0xaa8e8
callq 0x8440
movq 0x5456a(%rip), %rdi     # 0xd9ff0
leaq 0x28719(%rip), %rsi     # 0xae1a6
callq 0x8440
movq %rax, %rdi
movq 0x544bc(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x54528(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
movl $0xd8, %edi
callq 0x8450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl 0x6c(%rsp), %esi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
movzwl 0x4e(%rsp), %r9d
movq 0x80(%rsp), %r10
movzwl 0x88(%rsp), %r11d
movq %rsp, %rax
movl %r11d, 0x8(%rax)
movq %r10, (%rax)
callq 0x87d10
jmp 0x85b07
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x10, %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x87e00
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0x87e30
subq $0x1, %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x8410
movq 0x38(%rsp), %rdi
callq 0x8770
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Request_Fetch_Unit_NVMe::Fetch_next_request(unsigned short)
void Request_Fetch_Unit_NVMe::Fetch_next_request(stream_id_type stream_id)
{
	DMA_Req_Item *dma_req_item = new DMA_Req_Item;
	dma_req_item->Type = DMA_Req_Type::REQUEST_INFO;
	dma_req_item->object = (void *)(intptr_t)stream_id;
	dma_list.push_back(dma_req_item);

	Host_Interface_NVMe *hi = (Host_Interface_NVMe *)host_interface;
	Input_Stream_NVMe *im = ((Input_Stream_NVMe *)hi->input_stream_manager->input_streams[stream_id]);
	host_interface->Send_read_message_to_host(im->Submission_queue_base_address + im->Submission_head * sizeof(Submission_Queue_Entry), sizeof(Submission_Queue_Entry));
}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x10, %edi
callq 0x8450
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movzwl 0x2e(%rsp), %eax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rdi
leaq 0x20(%rsp), %rsi
callq 0x88310
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rdi
addq $0x10, %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x10(%rsp), %rax
movzwl 0x7a(%rax), %eax
imulq $0x48, %rax, %rax
addq %rax, %rsi
movl $0x48, %edx
callq 0x846f0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Request_Fetch_Unit_NVMe::Fetch_write_data(SSD_Components::User_Request*)
void Request_Fetch_Unit_NVMe::Fetch_write_data(User_Request *request)
{
	DMA_Req_Item *dma_req_item = new DMA_Req_Item;
	dma_req_item->Type = DMA_Req_Type::WRITE_DATA;
	dma_req_item->object = (void *)request;
	dma_list.push_back(dma_req_item);

	Submission_Queue_Entry *sqe = (Submission_Queue_Entry *)request->IO_command_info;
	host_interface->Send_read_message_to_host((sqe->PRP_entry_2 << 31) | sqe->PRP_entry_1, request->Size_in_byte);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x10, %edi
callq 0x8450
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
callq 0x88310
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x70(%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
shlq $0x1f, %rsi
movq 0x8(%rsp), %rax
orq 0x20(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x5c(%rax), %edx
callq 0x846f0
addq $0x28, %rsp
retq
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Request_Fetch_Unit_NVMe::Send_completion_queue_element(SSD_Components::User_Request*, unsigned short)
void Request_Fetch_Unit_NVMe::Send_completion_queue_element(User_Request *request, uint16_t sq_head_value)
{
	Host_Interface_NVMe *hi = (Host_Interface_NVMe *)host_interface;
	Completion_Queue_Entry *cqe = new Completion_Queue_Entry;
	cqe->SQ_Head = sq_head_value;
	cqe->SQ_ID = FLOW_ID_TO_Q_ID(request->Stream_id);
	cqe->SF_P = 0x0001 & current_phase;
	cqe->Command_Identifier = ((Submission_Queue_Entry *)request->IO_command_info)->Command_Identifier;
	Input_Stream_NVMe *im = ((Input_Stream_NVMe *)hi->input_stream_manager->input_streams[request->Stream_id]);
	host_interface->Send_write_message_to_host(im->Completion_queue_base_address + im->Completion_tail * sizeof(Completion_Queue_Entry), cqe, sizeof(Completion_Queue_Entry));
	number_of_sent_cqe++;
	if (number_of_sent_cqe % im->Completion_queue_size == 0)
	{
		//According to protocol specification, the value of the Phase Tag is inverted each pass through the Completion Queue
		if (current_phase == 0xffff)
		{
			current_phase = 0xfffe;
		}
		else
		{
			current_phase = 0xffff;
		}
	}
}

// Assembly:
subq $0x38, %rsp
movw %dx, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x10, %edi
callq 0x8450
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movw 0x26(%rsp), %dx
movq 0x10(%rsp), %rcx
movw %dx, 0x8(%rcx)
movq 0x28(%rsp), %rcx
movzwl 0x68(%rcx), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x10(%rsp), %rcx
movw %dx, 0xa(%rcx)
movzwl 0x28(%rax), %eax
andl $0x1, %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0xe(%rax)
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rax
movw 0x2(%rax), %cx
movq 0x10(%rsp), %rax
movw %cx, 0xc(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rax
movzwl 0x68(%rax), %eax
movl %eax, %esi
callq 0x85300
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rsi
movq 0x8(%rsp), %rax
movzwl 0x82(%rax), %eax
shlq $0x4, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
movl $0x10, %ecx
callq 0x84780
movq (%rsp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movl 0x2c(%rax), %eax
movq 0x8(%rsp), %rcx
movzwl 0x78(%rcx), %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x86b11
movq (%rsp), %rax
movzwl 0x28(%rax), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x86b05
movq (%rsp), %rax
movw $0xfffe, 0x28(%rax)     # imm = 0xFFFE
jmp 0x86b0f
movq (%rsp), %rax
movw $0xffff, 0x28(%rax)     # imm = 0xFFFF
jmp 0x86b11
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Host_Interface_NVMe::Validate_simulation_config()
void Host_Interface_NVMe::Validate_simulation_config()
{
	Host_Interface_Base::Validate_simulation_config();
	if (this->input_stream_manager == NULL)
	{
		throw std::logic_error("Input stream manager is not set for Host Interface");
	}
	if (this->request_fetch_unit == NULL)
	{
		throw std::logic_error("Request fetch unit is not set for Host Interface");
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x846e0
movq 0x18(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x86db9
movl $0x10, %edi
callq 0x8200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x274dd(%rip), %rsi     # 0xae25d
callq 0x8610
jmp 0x86d87
movq 0x10(%rsp), %rdi
movq 0x5322d(%rip), %rsi     # 0xd9fc0
movq 0x531f6(%rip), %rdx     # 0xd9f90
callq 0x8710
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x8330
jmp 0x86e1f
movq 0x18(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x86e1a
movl $0x10, %edi
callq 0x8200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x274af(%rip), %rsi     # 0xae290
callq 0x8610
jmp 0x86de8
movq 0x8(%rsp), %rdi
movq 0x531cc(%rip), %rsi     # 0xd9fc0
movq 0x53195(%rip), %rdx     # 0xd9f90
callq 0x8710
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x8330
jmp 0x86e1f
addq $0x38, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x8770
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Input_Stream_Manager_NVMe::Submission_queue_tail_pointer_update(unsigned short, unsigned short)
inline void Input_Stream_Manager_NVMe::Submission_queue_tail_pointer_update(stream_id_type stream_id, uint16_t tail_pointer_value)
{
	((Input_Stream_NVMe *)input_streams[stream_id])->Submission_tail = tail_pointer_value;

	if (((Input_Stream_NVMe *)input_streams[stream_id])->On_the_fly_requests < Queue_fetch_size)
	{
		((Host_Interface_NVMe *)host_interface)->request_fetch_unit->Fetch_next_request(stream_id);
		((Input_Stream_NVMe *)input_streams[stream_id])->On_the_fly_requests++;
		((Input_Stream_NVMe *)input_streams[stream_id])->Submission_head++; //Update submission queue head after starting fetch request
		if (((Input_Stream_NVMe *)input_streams[stream_id])->Submission_head == ((Input_Stream_NVMe *)input_streams[stream_id])->Submission_queue_size)
		{ //Circular queue implementation
			((Input_Stream_NVMe *)input_streams[stream_id])->Submission_head = 0;
		}
	}
}

// Assembly:
subq $0x28, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, 0x20(%rsp)
movw %cx, 0x1e(%rsp)
movw %ax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movw 0x1c(%rsp), %ax
movw %ax, 0xe(%rsp)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movw 0xe(%rsp), %cx
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movw %cx, 0x7e(%rax)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x10(%rsp), %rcx
movq (%rax), %rax
movzwl 0xd0(%rax), %eax
cmpl 0x28(%rcx), %eax
jae 0x881b6
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rdi
movw 0x1e(%rsp), %cx
movq (%rdi), %rax
movzwl %cx, %esi
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movw 0xd0(%rax), %cx
addw $0x1, %cx
movw %cx, 0xd0(%rax)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movw 0x7a(%rax), %cx
addw $0x1, %cx
movw %cx, 0x7a(%rax)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movzwl 0x7a(%rax), %eax
movl %eax, 0x8(%rsp)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq %rax, %rcx
movl 0x8(%rsp), %eax
movq (%rcx), %rcx
movzwl 0x68(%rcx), %ecx
cmpl %ecx, %eax
jne 0x881b4
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rax
movw $0x0, 0x7a(%rax)
jmp 0x881b6
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Input_Stream_Manager_NVMe::Completion_queue_head_pointer_update(unsigned short, unsigned short)
inline void Input_Stream_Manager_NVMe::Completion_queue_head_pointer_update(stream_id_type stream_id, uint16_t head_pointer_value)
{
	((Input_Stream_NVMe *)input_streams[stream_id])->Completion_head = head_pointer_value;

	//If this check is true, then the host interface couldn't send the completion queue entry, since the completion queue was full
	if (((Input_Stream_NVMe *)input_streams[stream_id])->Completed_user_requests.size() > 0)
	{
		User_Request *request = ((Input_Stream_NVMe *)input_streams[stream_id])->Completed_user_requests.front();
		((Input_Stream_NVMe *)input_streams[stream_id])->Completed_user_requests.pop_front();
		inform_host_request_completed(stream_id, request);
	}
}

// Assembly:
subq $0x28, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, 0x20(%rsp)
movw %cx, 0x1e(%rsp)
movw %ax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movw 0x1c(%rsp), %ax
movw %ax, 0x6(%rsp)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movw 0x6(%rsp), %cx
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movw %cx, 0x80(%rax)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rdi
addq $0xa0, %rdi
callq 0x709b0
cmpq $0x0, %rax
jbe 0x8829d
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rdi
addq $0xa0, %rdi
callq 0x88890
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x10, %rdi
movzwl 0x1e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rdi
addq $0xa0, %rdi
callq 0x888c0
movq 0x8(%rsp), %rdi
movw 0x1e(%rsp), %ax
movq 0x10(%rsp), %rdx
movzwl %ax, %esi
callq 0x888f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_NVMe.cpp
// Function: SSD_Components::Input_Stream_Manager_NVMe::inform_host_request_completed(unsigned short, SSD_Components::User_Request*)
inline void Input_Stream_Manager_NVMe::inform_host_request_completed(stream_id_type stream_id, User_Request *request)
{
	((Request_Fetch_Unit_NVMe *)((Host_Interface_NVMe *)host_interface)->request_fetch_unit)->Send_completion_queue_element(request, ((Input_Stream_NVMe *)input_streams[stream_id])->Submission_head_informed_to_host);
	((Input_Stream_NVMe *)input_streams[stream_id])->Completion_tail++; //Next free slot in the completion queue
	//Circular queue implementation
	if (((Input_Stream_NVMe *)input_streams[stream_id])->Completion_tail == ((Input_Stream_NVMe *)input_streams[stream_id])->Completion_queue_size)
	{
		((Input_Stream_NVMe *)input_streams[stream_id])->Completion_tail = 0;
	}
}

// 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 0x58(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rax), %rax
movzwl 0x7c(%rax), %edx
callq 0x869e0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movw 0x82(%rax), %cx
addw $0x1, %cx
movw %cx, 0x82(%rax)
addq $0x10, %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movzwl 0x82(%rax), %eax
movl %eax, 0x1c(%rsp)
addq $0x10, %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq %rax, %rcx
movl 0x1c(%rsp), %eax
movq (%rcx), %rcx
movzwl 0x78(%rcx), %ecx
cmpl %ecx, %eax
jne 0x889e0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x85300
movq (%rax), %rax
movw $0x0, 0x82(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]MQSim/src/ssd/Host_Interface_SATA.cpp
// Function: SSD_Components::Input_Stream_SATA::~Input_Stream_SATA()
Input_Stream_SATA::~Input_Stream_SATA()
	{
		for (auto &user_request : Waiting_user_requests) {
			delete user_request;
		}
		for (auto &user_request : Completed_user_requests) {
			delete user_request;
		}
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50456(%rip), %rcx     # 0xd9870
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x78, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x6bfd0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x6c000
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6c030
testb $0x1, %al
jne 0x8945d
jmp 0x894a1
leaq 0x50(%rsp), %rdi
callq 0x6c050
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x89493
movq 0x10(%rsp), %rdi
callq 0x6c070
movq 0x10(%rsp), %rdi
callq 0x8410
jmp 0x89495
leaq 0x50(%rsp), %rdi
callq 0x6c0a0
jmp 0x89448
movq 0x18(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6bfd0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6c000
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6c030
testb $0x1, %al
jne 0x894e4
jmp 0x89528
leaq 0x30(%rsp), %rdi
callq 0x6c050
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8951a
movq 0x8(%rsp), %rdi
callq 0x6c070
movq 0x8(%rsp), %rdi
callq 0x8410
jmp 0x8951c
leaq 0x30(%rsp), %rdi
callq 0x6c0a0
jmp 0x894cf
movq 0x18(%rsp), %rdi
addq $0xa8, %rdi
callq 0x6c0c0
movq 0x18(%rsp), %rdi
addq $0x90, %rdi
callq 0x6c0c0
movq 0x18(%rsp), %rdi
addq $0x78, %rdi
callq 0x6c0c0
movq 0x18(%rsp), %rdi
callq 0x84450
addq $0x68, %rsp
retq
nopw (%rax,%rax)