LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/agentpns.cpp
// Function: AgentPNS::search(double, unsigned long, int)
void AgentPNS::search(double time, uint64_t maxiters, int verbose){
	if(rootboard.won() >= 0)
		return;

	start_threads();

	timeout = false;
	Alarm timer(time, std::bind(&AgentPNS::timedout, this));

	//wait for the timer to stop them
	runbarrier.wait();
	CAS(threadstate, Thread_Wait_End, Thread_Wait_Start);
	assert(threadstate == Thread_Wait_Start);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
vmovsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
cmpb $-0x4, 0x2a(%rdi)
jne 0x2225a
leaq 0x10(%rbx), %rdi
callq 0xdab0
movb %al, 0x2a(%rbx)
cmpb $0x0, 0x2a(%rbx)
jns 0x22316
movq %rbx, %rdi
callq 0x2237a
movb $0x0, 0x8(%rbx)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %r14
vmovups %ymm0, (%r14)
movl $0x18, %edi
vzeroupper
callq 0x42e0
movq $0x59, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, (%r14)
leaq 0x3786(%rip), %rax      # 0x25a2e
movq %rax, 0x18(%r14)
leaq 0x3797(%rip), %rax      # 0x25a4a
movq %rax, 0x10(%r14)
leaq 0x4(%rsp), %rdi
vmovsd 0x8(%rsp), %xmm0
movq %r14, %rsi
callq 0x23b7a
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x222e3
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xa10(%rbx), %rdi
callq 0x1e3ea
movl $0x1, %ecx
movl $0x6, %eax
lock
cmpxchgl %ecx, 0x9f0(%rbx)
movl 0x9f0(%rbx), %eax
cmpl $0x1, %eax
jne 0x2231e
leaq 0x4(%rsp), %rdi
callq 0x1f16a
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0xa428(%rip), %rdi      # 0x2c74d
leaq 0xb1b4(%rip), %rsi      # 0x2d4e0
leaq 0xb1ba(%rip), %rcx      # 0x2d4ed
movl $0x14, %edx
callq 0x41b0
jmp 0x22372
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1f16a
jmp 0x2236a
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2236a
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x45b0
movq %rax, %rdi
callq 0x8d6e
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/agentpns.cpp
// Function: AgentPNS::reset_threads()
void AgentPNS::reset_threads(){ //start and end with threadstate = Thread_Wait_Start
	assert(threadstate == Thread_Wait_Start);

//wait for them to all get to the barrier
	assert(CAS(threadstate, Thread_Wait_Start, Thread_Wait_Start_Cancelled));
	runbarrier.wait();

//make sure they exited cleanly
	for(unsigned int i = 0; i < threads.size(); i++)
		threads[i]->join();

	threads.clear();

	threadstate = Thread_Wait_Start;

	runbarrier.reset(numthreads + 1);
	gcbarrier.reset(numthreads);

//start new threads
	for(int i = 0; i < numthreads; i++)
		threads.push_back(new PNSThread(this));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x9f0(%rdi), %eax
cmpl $0x1, %eax
jne 0x2349c
movq %rdi, %rbx
movl $0x2, %ecx
movl $0x1, %eax
lock
cmpxchgl %ecx, 0x9f0(%rdi)
jne 0x234bb
leaq 0xa10(%rbx), %r14
movq %r14, %rdi
callq 0x1e3ea
movq 0x9f8(%rbx), %rax
movq 0xa00(%rbx), %rdx
cmpq %rax, %rdx
je 0x233f1
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
callq 0x20720
movl %ebp, %ecx
movq 0x9f8(%rbx), %rax
movq 0xa00(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x233c3
cmpq %rax, %rdx
je 0x233fd
movq %rax, 0xa00(%rbx)
movl $0x1, 0x9f0(%rbx)
movl 0xadc(%rbx), %esi
incl %esi
movq %r14, %rdi
callq 0x1f364
leaq 0xa70(%rbx), %rdi
movl 0xadc(%rbx), %esi
callq 0x1f364
cmpl $0x0, 0xadc(%rbx)
jle 0x2348f
leaq 0x9f8(%rbx), %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movl $0x48, %edi
callq 0x42e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2406a
movq %r12, 0x8(%rsp)
movq 0xa00(%rbx), %rsi
cmpq 0xa08(%rbx), %rsi
je 0x2347a
movq %r12, (%rsi)
addq $0x8, 0xa00(%rbx)
jmp 0x23485
movq %r14, %rdi
movq %r15, %rdx
callq 0x25ad8
incl %ebp
cmpl 0xadc(%rbx), %ebp
jl 0x23440
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x92aa(%rip), %rdi      # 0x2c74d
leaq 0xa036(%rip), %rsi      # 0x2d4e0
leaq 0xa0cd(%rip), %rcx      # 0x2d57e
movl $0x76, %edx
callq 0x41b0
leaq 0x9486(%rip), %rdi      # 0x2c948
leaq 0xa017(%rip), %rsi      # 0x2d4e0
leaq 0xa0ae(%rip), %rcx      # 0x2d57e
movl $0x79, %edx
callq 0x41b0
movq %rax, %rbx
movq %r12, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/./agent.h
// Function: Agent::solve1ply(Board const&, unsigned int&)
static int solve1ply(const Board & board, unsigned int & nodes) {
		int outcome = -4;
		int turn = board.toplay();
		for(MoveIterator move(board); !move.done(); ++move){
			++nodes;
			int won = move.board().won();

			if(won == turn)
				return won;
			else if(won == 0)
				outcome = 0;
			else if(outcome == 3 - turn || outcome == -4)
				outcome = won;
		}
		return outcome;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movzbl 0x19(%rdi), %r12d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xd316
movl $0x3, %r13d
subl %r12d, %r13d
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
cmpb $0x23, 0x38(%rsp)
jg 0x24236
incl (%rbx)
cmpb $-0x4, 0x2a(%rsp)
jne 0x241fd
leaq 0x10(%rsp), %rdi
callq 0xdab0
movb %al, 0x2a(%rsp)
movsbl 0x2a(%rsp), %eax
cmpl %r12d, %eax
jne 0x2420c
movl %eax, %r15d
jmp 0x24224
testb %al, %al
je 0x24222
cmpl $-0x4, %ebp
movl %ebp, %ecx
cmovel %eax, %ecx
cmpl %r13d, %ebp
cmovel %eax, %ecx
movl %ecx, %ebp
jmp 0x24224
xorl %ebp, %ebp
cmpl %r12d, %eax
je 0x24233
movq %r14, %rdi
callq 0xd402
jmp 0x241df
movl %r15d, %ebp
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x24245
callq 0x43d0
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x24268
callq 0x43d0
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/./agentpns.h
// Function: AgentPNS::~AgentPNS()
~AgentPNS(){
		stop_threads();

		numthreads = 0;
		reset_threads(); //shut down the theads properly

		root.dealloc(ctmem);
		ctmem.compact();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1200b(%rip), %rax     # 0x36bb0
movq %rax, (%rdi)
callq 0x23304
movl $0x0, 0xadc(%rbx)
movq %rbx, %rdi
callq 0x23364
leaq 0xae0(%rbx), %r15
leaq 0x50(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x24b10
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
movq %r14, %rdi
callq 0x23bfc
movq %r15, %rdi
callq 0xd77e
leaq 0xa70(%rbx), %rdi
callq 0xd7d6
leaq 0xa10(%rbx), %rdi
callq 0xd7d6
movq 0x9f8(%rbx), %rdi
testq %rdi, %rdi
je 0x24c16
callq 0x42b0
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd824
movq %rax, %rdi
callq 0x8d6e
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/./agentpns.h
// Function: AgentPNS::set_board(Board const&, bool)
void set_board(const Board & board, bool clear = true){
		rootboard = board;
		reset();
		if(clear)
			clear_mem();

		reset_threads(); //needed since the threads aren't started before a board it set
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, 0x30(%rdi)
vmovups (%rsi), %ymm0
vmovups %ymm0, 0x10(%rdi)
movl $0x0, 0x9e0(%rdi)
movq $0x0, 0x9e8(%rdi)
movb $0x0, 0x8(%rdi)
testl %edx, %edx
je 0x24c94
movq (%rbx), %rax
movq %rbx, %rdi
vzeroupper
callq *0x38(%rax)
movq %rbx, %rdi
popq %rbx
vzeroupper
jmp 0x23364
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/agentab.cpp
// Function: AgentAB::return_move(Board const&, int) const
Move AgentAB::return_move(const Board & board, int verbose) const {
	if(const Node * n = tt_get(board))
		return n->bestmove;

	int score = SCORE_LOSS;
	Move best = M_RESIGN;
	for(MoveIterator move(board); !move.done(); ++move){
		if(const Node * n = tt_get(move.board())) {
			if(score < n->score){
				score = n->score;
				best = *move;
			}
		} else if (score == SCORE_LOSS && best == M_RESIGN) {
			best = M_UNKNOWN;
		}
	}
	return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x973a
movq %rax, %rcx
shrq $0x11, %rax
xorq %rcx, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
xorq %rdx, %rax
movq 0x38(%rbx), %rsi
xorl %edx, %edx
divq 0x40(%rbx)
xorl %r14d, %r14d
leaq (%rdx,%rdx,2), %rdx
movq (%rsi,%rdx,8), %rax
cmpq %rcx, %rax
jne 0x275a9
leaq (%rsi,%rdx,8), %rdx
movl 0xc(%rdx), %ebp
movl %ebp, %r14d
andl $0xffff0000, %r14d      # imm = 0xFFFF0000
cmpq %rcx, %rax
je 0x27662
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xd316
movl $0xffff8001, %r13d      # imm = 0xFFFF8001
movw $0x8efe, %bp            # imm = 0x8EFE
leaq 0x10(%rsp), %r12
cmpb $0x24, 0x38(%rsp)
jge 0x27653
movq %r12, %rdi
callq 0x973a
movq %rax, %rcx
shrq $0x11, %rax
xorq %rcx, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
xorq %rdx, %rax
movq 0x38(%rbx), %rsi
xorl %edx, %edx
divq 0x40(%rbx)
leaq (%rdx,%rdx,2), %rax
cmpq %rcx, (%rsi,%rax,8)
jne 0x2762e
leaq (%rsi,%rax,8), %rax
movswl 0x8(%rax), %eax
cmpl %eax, %r13d
cmovlw 0x38(%rsp), %bp
cmovlel %eax, %r13d
jmp 0x27649
cmpl $0xffff8001, %r13d      # imm = 0xFFFF8001
jne 0x27649
cmpb $-0x2, %bpl
movl $0x8efc, %eax           # imm = 0x8EFC
cmovel %eax, %ebp
movl $0xffff8001, %r13d      # imm = 0xFFFF8001
movq %r15, %rdi
callq 0xd402
jmp 0x275d6
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x27662
callq 0x43d0
movzwl %bp, %eax
orl %eax, %r14d
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2767c
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2768e
callq 0x43d0
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/agentab.cpp
// Function: AgentAB::get_pv() const
vector<Move> AgentAB::get_pv() const {
	vector<Move> pv;

	Board b = rootboard;
	int i = 20;
	while (i--) {
		Move m = return_move(b);
		if(m == M_UNKNOWN || m == M_RESIGN)
			break;
		pv.push_back(m);
		bool move_success = b.move(m);
		assert(move_success);
	}

	if(pv.size() == 0)
		pv.push_back(Move(M_RESIGN));

	return pv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %rax
leaq 0x10(%rsp), %r15
movq %rax, 0x20(%r15)
vmovups 0x10(%rsi), %ymm0
vmovups %ymm0, (%r15)
movl $0xffffffeb, %r13d      # imm = 0xFFFFFFEB
leaq 0xc(%rsp), %r12
incl %r13d
je 0x2773e
movq %r14, %rdi
movq %r15, %rsi
vzeroupper
callq 0x27544
movl %eax, %ebp
movw %bp, 0xc(%rsp)
andl $0xfd, %ebp
cmpl $0xfc, %ebp
je 0x2773e
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2771b
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rbx)
jmp 0x27726
movq %rbx, %rdi
movq %r12, %rdx
callq 0xdb72
movl 0xc(%rsp), %esi
movq %r15, %rdi
callq 0x9240
testb %al, %al
je 0x27786
cmpl $0xfc, %ebp
jne 0x276dc
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0x27771
movw $0x8efe, 0xc(%rsp)      # imm = 0x8EFE
cmpq 0x10(%rbx), %rsi
je 0x27761
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rbx)
jmp 0x27771
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
vzeroupper
callq 0x20daa
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0x2b07(%rip), %rdi      # 0x2a294
leaq 0x6388(%rip), %rsi      # 0x2db1c
leaq 0x63dc(%rip), %rcx      # 0x2db77
movl $0xb2, %edx
callq 0x41b0
jmp 0x277a9
jmp 0x277a9
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x277b9
callq 0x42b0
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/agentab.cpp
// Function: AgentAB::tt_get(unsigned long) const
uint64_t mix_bits(uint64_t h){
	h ^= (h >> 17);
	h ^= (h << 31);
	h ^= (h >>  8);
	return h;
}

// Assembly:
movq %rsi, %rax
shrq $0x11, %rax
xorq %rsi, %rax
movq %rax, %rcx
shlq $0x1f, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
xorq %rcx, %rax
movq 0x38(%rdi), %rcx
xorl %edx, %edx
divq 0x40(%rdi)
leaq (%rdx,%rdx,2), %rdx
xorl %eax, %eax
leaq (%rcx,%rdx,8), %rcx
cmpq %rsi, (%rcx)
cmoveq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]pentagod/./agentab.h
// Function: AgentAB::clear_mem()
void clear_mem(){
		reset();
		if(TT){
			delete[] TT;
			TT = NULL;
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x8(%rdi)
movl $0x0, 0x50(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x58(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x28110
callq 0x43d0
movq $0x0, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/main.cpp
// Function: command_line_args(char**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void command_line_args(char* argv[], string& input_file_path, string& workload_file_path)
{

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movl $0x1, %r14d
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r13
movslq %r14d, %rbx
movq (%r15,%rbx,8), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x7180
movb $0x0, 0x6(%rsp)
movw $0x692d, 0x4(%rsp)      # imm = 0x692D
movq %r13, %rdi
callq 0x71a0
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r13, %rcx
callq 0x74b0
testl %eax, %eax
je 0x88ac
movb $0x0, 0x2(%rsp)
movw $0x772d, (%rsp)         # imm = 0x772D
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x71a0
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %rbp, %rcx
callq 0x74b0
testl %eax, %eax
jne 0x88de
movq 0x8(%r15,%rbx,8), %rbx
movq 0x8(%rsp), %r12
movq 0x8(%r12), %rbp
movq %rbx, %rdi
callq 0x71a0
movq %r12, %rdi
leaq 0x18(%rsp), %r12
xorl %esi, %esi
movq %rbp, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x7550
jmp 0x88db
movq 0x8(%r15,%rbx,8), %rbx
movq 0x10(%rsp), %r12
movq 0x8(%r12), %rbp
movq %rbx, %rdi
callq 0x71a0
movq %r12, %rdi
leaq 0x18(%rsp), %r12
xorl %esi, %esi
movq %rbp, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x7550
incl %r14d
movl %r14d, %ebx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x88f5
callq 0x7370
leal 0x1(%rbx), %r14d
cmpl $0x4, %ebx
jl 0x8817
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8913
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x892a
callq 0x7370
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/Execution_Parameter_Set.cpp
// Function: Execution_Parameter_Set::XML_serialize(Utils::XmlWriter&)
void Execution_Parameter_Set::XML_serialize(Utils::XmlWriter& xmlwriter)
{
	std::string tmp;
	tmp = "Execution_Parameter_Set";
	xmlwriter.Write_open_tag(tmp);

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

	xmlwriter.Write_close_tag();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x439e3(%rip), %rcx     # 0x5513b
movq %rsp, %rdi
movl $0x17, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x7550
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xb036
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x54454
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x117a5
callq 0x7370
leaq 0x5dc6c(%rip), %rdi     # 0x6f418
movq %rbx, %rsi
callq 0x13f50
leaq 0x5dc65(%rip), %rdi     # 0x6f420
movq %rbx, %rsi
callq 0xca98
movq %rbx, %rdi
callq 0x547fc
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x117d9
callq 0x7370
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x117fa
callq 0x7370
jmp 0x117fa
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11808
callq 0x7370
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/Execution_Parameter_Set.cpp
// Function: Execution_Parameter_Set::XML_deserialize(rapidxml::xml_node<char>*)
void Execution_Parameter_Set::XML_deserialize(rapidxml::xml_node<> *node)
{
	try {
		for (auto param = node->first_node(); param; param = param->next_sibling()) {
			if (strcmp(param->name(), "Host_Parameter_Set") == 0) {
				Host_Configuration.XML_deserialize(param);
			} else if (strcmp(param->name(), "Device_Parameter_Set") == 0) {
				SSD_Device_Configuration.XML_deserialize(param);
			}
		}
	} catch (...) {
		PRINT_ERROR("Error in the Execution_Parameter_Set!")
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x11894
leaq 0x5dd07(%rip), %r13     # 0x6f532
leaq 0x452e7(%rip), %r14     # 0x56b19
leaq 0x5dbdf(%rip), %r15     # 0x6f418
leaq 0x448c8(%rip), %r12     # 0x56108
movq (%rbx), %rbp
testq %rbp, %rbp
cmoveq %r13, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x74d0
testl %eax, %eax
je 0x11879
movq %rbp, %rdi
movq %r12, %rsi
callq 0x74d0
testl %eax, %eax
jne 0x11884
leaq 0x5dbb1(%rip), %rdi     # 0x6f420
movq %rbx, %rsi
callq 0xf9c8
jmp 0x11884
movq %r15, %rdi
movq %rbx, %rsi
callq 0x146c6
cmpq $0x0, 0x20(%rbx)
je 0x118a3
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x11840
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43ecd(%rip), %rdi     # 0x55777
leaq 0x43c98(%rip), %rsi     # 0x55549
leaq 0x43ece(%rip), %rcx     # 0x55786
movl $0x3ee, %edx            # imm = 0x3EE
callq 0x7270
movq %rax, %rdi
callq 0x7190
movq 0x5d71f(%rip), %rdi     # 0x6eff0
leaq 0x44cd0(%rip), %rsi     # 0x565a8
movl $0x6, %edx
callq 0x7400
movq 0x5d707(%rip), %rdi     # 0x6eff0
leaq 0x4523c(%rip), %rsi     # 0x56b2c
movl $0x25, %edx
callq 0x7400
movq 0x5d6ef(%rip), %rdi     # 0x6eff0
callq 0x71c0
movq 0x5d6c3(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
movq %rax, %rbx
callq 0x7590
movq %rbx, %rdi
callq 0x7620
movq %rax, %rdi
callq 0xaf65
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::~Host_System()
Host_System::~Host_System() 
{
	delete this->Link;
	delete this->PCIe_root_complex;
	delete this->PCIe_switch;
	if (ssd_device->Host_interface->GetType() == HostInterface_Types::SATA) {
		delete this->SATA_hba;
	}
	for (uint16_t flow_id = 0; flow_id < this->IO_flows.size(); flow_id++) {
		delete this->IO_flows[flow_id];
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x57b1d(%rip), %rax     # 0x6d9b0
movq %rax, (%rdi)
leaq 0x57b4b(%rip), %rax     # 0x6d9e8
movq %rax, 0x30(%rdi)
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x15ef1
leaq 0x57ec7(%rip), %rax     # 0x6dd78
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xb0(%r14), %rdi
callq 0x1672a
leaq 0x60(%r14), %rdi
callq 0x1672a
leaq 0x57b84(%rip), %rax     # 0x6da58
movq %rax, (%r14)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x15ee9
callq 0x7370
movq %r14, %rdi
callq 0x7370
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x15eff
callq 0x7370
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x15f0d
callq 0x7370
movq 0x70(%rbx), %rax
movq 0x40(%rax), %rax
cmpl $0x0, 0x38(%rax)
jne 0x15f34
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x15f34
movq %r14, %rdi
callq 0x253ba
movq %r14, %rdi
callq 0x7370
movq 0x58(%rbx), %rdi
cmpq %rdi, 0x60(%rbx)
je 0x15f79
movw $0x1, %r15w
xorl %eax, %eax
movq (%rdi,%rax,8), %r14
testq %r14, %r14
je 0x15f5e
movq %r14, %rdi
callq 0x1e798
movq %r14, %rdi
callq 0x7370
movzwl %r15w, %eax
movq 0x58(%rbx), %rdi
movq 0x60(%rbx), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
incl %r15d
cmpq %rax, %rcx
ja 0x15f45
testq %rdi, %rdi
je 0x15f83
callq 0x7370
leaq 0x57ace(%rip), %rax     # 0x6da58
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x15fa4
popq %rbx
popq %r14
popq %r15
jmp 0x7370
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::get_workloads_statistics()
std::vector<Utils::Workload_Statistics*> Host_System::get_workloads_statistics()
{
	std::vector<Utils::Workload_Statistics*> stats;

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

	return stats;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x58(%rsi), %r13
movq 0x60(%rsi), %rbp
cmpq %rbp, %r13
je 0x1632d
xorl %r12d, %r12d
leaq 0x7a5b(%rip), %r14      # 0x1dc8a
leaq 0x7a6c(%rip), %r15      # 0x1dca2
movl $0x1b0, %edi            # imm = 0x1B0
callq 0x73a0
leaq 0x98(%rax), %rcx
movl %r12d, 0x98(%rax)
movq %r12, 0xa0(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movq %rcx, 0xa8(%rax)
movq %rcx, 0xb0(%rax)
movq %r12, 0xb8(%rax)
leaq 0xc8(%rax), %rcx
movl %r12d, 0xc8(%rax)
movq %r12, 0xd0(%rax)
movq %rcx, 0xd8(%rax)
movq %rcx, 0xe0(%rax)
movq %r12, 0xe8(%rax)
movq %rax, %rcx
addq $0xf8, %rcx
movl %r12d, 0xf8(%rax)
movq %r12, 0x100(%rax)
movq %rcx, 0x108(%rax)
movq %rcx, 0x110(%rax)
movq %r12, 0x118(%rax)
movups %xmm0, 0x1a0(%rax)
movups %xmm0, 0x190(%rax)
movups %xmm0, 0x180(%rax)
movq %rax, (%rsp)
movq (%r13), %rdi
movq (%rdi), %r8
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq *0x40(%r8)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x16315
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x16320
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x16954
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x16236
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1634f
callq 0x7370
movq %r14, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/Host_System.cpp
// Function: Host_System::Report_results_in_XML(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Utils::XmlWriter&)
void Host_System::Report_results_in_XML(std::string name_prefix, Utils::XmlWriter& xmlwriter)
{
	std::string tmp;
	tmp = ID();
	xmlwriter.Write_open_tag(tmp);

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

	xmlwriter.Write_close_tag();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, (%rsp)
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x78(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0xb036
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %r15
movq %r15, %rsi
callq 0x7450
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x164af
callq 0x7370
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xb036
leaq 0x48(%rsp), %rsi
movq (%rsp), %rdi
callq 0x54454
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x164ec
callq 0x7370
movq 0x58(%r14), %rbp
movq 0x60(%r14), %rbx
cmpq %rbx, %rbp
je 0x1654e
leaq 0x38(%rsp), %r14
leaq 0x409a7(%rip), %r15     # 0x56eac
leaq 0x28(%rsp), %r12
movq (%rbp), %r13
movq %r14, 0x28(%rsp)
movq %r12, %rdi
leaq 0x4098b(%rip), %rsi     # 0x56ea8
movq %r15, %rdx
callq 0xb0c6
movq (%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq *0x38(%rax)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16545
callq 0x7370
addq $0x8, %rbp
cmpq %rbx, %rbp
jne 0x1650a
movq (%rsp), %rdi
callq 0x547fc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1656b
callq 0x7370
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
jne 0x165a2
jmp 0x165a7
jmp 0x16590
jmp 0x16590
movq %rax, %rbx
jmp 0x165a7
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x165a7
callq 0x7370
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x165bb
callq 0x7370
movq %rbx, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/SSD_Device.cpp
// Function: SSD_Device::~SSD_Device()
SSD_Device::~SSD_Device()
{
	for (unsigned int channel_cntr = 0; channel_cntr < Channel_count; channel_cntr++)
	{
		for (unsigned int chip_cntr = 0; chip_cntr < Chip_no_per_channel; chip_cntr++)
		{
			delete ((SSD_Components::ONFI_Channel_NVDDR2 *)this->Channels[channel_cntr])->Chips[chip_cntr];
		}
		delete this->Channels[channel_cntr];
	}

	delete this->PHY;
	delete ((SSD_Components::FTL *)this->Firmware)->TSU;
	delete ((SSD_Components::FTL *)this->Firmware)->BlockManager;
	delete ((SSD_Components::FTL *)this->Firmware)->Address_Mapping_Unit;
	delete ((SSD_Components::FTL *)this->Firmware)->GC_and_WL_Unit;
	delete this->Firmware;
	delete this->Cache_manager;
	delete this->Host_interface;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5052e(%rip), %rax     # 0x6db48
movq %rax, (%rdi)
leaq 0x5055c(%rip), %rax     # 0x6db80
movq %rax, 0x30(%rdi)
cmpl $0x0, 0x78(%rdi)
je 0x1d687
xorl %r15d, %r15d
cmpl $0x0, 0x7c(%rbx)
je 0x1d66a
xorl %r12d, %r12d
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r14
testq %r14, %r14
je 0x1d65f
movq %r14, %rdi
callq 0x266ca
movq %r14, %rdi
callq 0x7370
incq %r12
movl 0x7c(%rbx), %eax
cmpq %rax, %r12
jb 0x1d63a
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x1d67c
callq 0x7370
incq %r15
movl 0x78(%rbx), %eax
cmpq %rax, %r15
jb 0x1d631
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x1d6a0
movq %r14, %rdi
callq 0x457a6
movq %r14, %rdi
callq 0x7370
movq 0x50(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x1d6b3
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x50(%rbx), %rax
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x1d6c6
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x1d6d9
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x50(%rbx), %rax
movq 0x48(%rax), %r14
testq %r14, %r14
je 0x1d724
leaq 0x50e03(%rip), %rax     # 0x6e4f0
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xa0(%r14), %rdi
callq 0x1ddb8
leaq 0x50351(%rip), %rax     # 0x6da58
movq %rax, (%r14)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x1d71c
callq 0x7370
movq %r14, %rdi
callq 0x7370
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x1d751
leaq 0x50324(%rip), %rax     # 0x6da58
movq %rax, (%r14)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x1d749
callq 0x7370
movq %r14, %rdi
callq 0x7370
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1d760
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1d76f
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1d77d
callq 0x7370
leaq 0x502d4(%rip), %rax     # 0x6da58
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x1d7a4
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7370
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/exec/SSD_Device.cpp
// Function: SSD_Device::Perform_preconditioning(std::vector<Utils::Workload_Statistics*, std::allocator<Utils::Workload_Statistics*>>)
void SSD_Device::Perform_preconditioning(std::vector<Utils::Workload_Statistics *> workload_stats)
{
	if (Preconditioning_required)
	{
		time_t start_time = time(0);
		PRINT_MESSAGE("SSD Device preconditioning started .........");
		this->Firmware->Perform_precondition(workload_stats);
		this->Cache_manager->Do_warmup(workload_stats);
		time_t end_time = time(0);
		uint64_t duration = (uint64_t)difftime(end_time, start_time);
		PRINT_MESSAGE("Finished preconditioning. Duration of preconditioning: " << duration / 3600 << ":" << (duration % 3600) / 60 << ":" << ((duration % 3600) % 60));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpb $0x1, 0x38(%rdi)
jne 0x1d97f
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0x7350
movq %rax, %rbx
movq 0x517ac(%rip), %r12     # 0x6ef90
leaq 0x39f5a(%rip), %rsi     # 0x57745
movl $0x2c, %edx
movq %r12, %rdi
callq 0x7400
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x7380
movsbl %al, %esi
movq %r12, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7290
movq 0x50(%r15), %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x166a4
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x30(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1d850
callq 0x7370
movq 0x48(%r15), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x166a4
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x30(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d87c
callq 0x7370
xorl %edi, %edi
callq 0x7350
movq %rax, %rdi
movq %rbx, %rsi
callq 0x71e0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x377ae(%rip), %xmm0    # 0x55050
cvttsd2si %xmm0, %rbx
andq %rcx, %rbx
orq %rax, %rbx
movq 0x516dc(%rip), %r14     # 0x6ef90
leaq 0x39eb7(%rip), %rsi     # 0x57772
movl $0x37, %edx
movq %r14, %rdi
callq 0x7400
movq %rbx, %rax
shrq $0x4, %rax
movabsq $0x91a2b3c4d5e6f81, %rcx # imm = 0x91A2B3C4D5E6F81
mulq %rcx
movq %rdx, %r15
shrq $0x3, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7280
movq %rax, %r14
leaq 0x38cb5(%rip), %r12     # 0x565ad
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7400
imulq $0xe10, %r15, %rax      # imm = 0xE10
subq %rax, %rbx
movabsq $0x444444444444445, %rcx # imm = 0x444444444444445
movq %rbx, %rax
mulq %rcx
movq %rdx, %r15
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7280
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7400
imulq $0x3c, %r15, %rax
subq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7280
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7290
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x1d99e
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1d9a8
callq 0x7370
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Base.cpp
// Function: Host_Components::IO_Flow_Base::~IO_Flow_Base()
IO_Flow_Base::~IO_Flow_Base()
	{
		log_file.close();
		for(auto &req : waiting_requests) {
			if (req) {
				delete req;
			}
		}

		switch (SSD_device_type) {
			case HostInterface_Types::NVME:
				for (auto &req : nvme_software_request_queue) {
					if (req.second) {
						delete req.second;
					}
				}
				break;
			case HostInterface_Types::SATA:
				break;
			default:
				PRINT_ERROR("Unsupported host interface type in IO_Flow_Base!")
		}

	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4f426(%rip), %rax     # 0x6dbd0
movq %rax, (%rdi)
leaq 0x4f474(%rip), %rax     # 0x6dc28
movq %rax, 0x30(%rdi)
leaq 0x258(%rdi), %r14
movq %r14, %rdi
callq 0x74f0
leaq 0x100(%rbx), %r15
movq 0x100(%rbx), %r12
cmpq %r15, %r12
je 0x1e7ef
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1e7e9
callq 0x7370
movq (%r12), %r12
jmp 0x1e7d5
movl 0x54(%rbx), %eax
testl %eax, %eax
je 0x1e81e
cmpl $0x1, %eax
jne 0x1e8e3
movq 0x128(%rbx), %r14
testq %r14, %r14
je 0x1e81e
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1e819
callq 0x7370
movq (%r14), %r14
jmp 0x1e806
movq 0x5074b(%rip), %rax     # 0x6ef70
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x258(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x258(%rbx,%rcx)
leaq 0x260(%rbx), %rdi
callq 0x7320
leaq 0x350(%rbx), %rdi
callq 0x7150
movq 0x238(%rbx), %rdi
leaq 0x248(%rbx), %rax
cmpq %rax, %rdi
je 0x1e86f
callq 0x7370
leaq 0x118(%rbx), %rdi
callq 0x216de
movq 0x100(%rbx), %rdi
cmpq %r15, %rdi
je 0x1e897
movq (%rdi), %r14
callq 0x7370
movq %r14, %rdi
cmpq %r15, %r14
jne 0x1e887
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e8a8
callq 0x7370
leaq 0xb8(%rbx), %rdi
callq 0x21740
leaq 0x4f19d(%rip), %rax     # 0x6da58
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x1e8db
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7370
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x50706(%rip), %rdi     # 0x6eff0
leaq 0x37cb7(%rip), %rsi     # 0x565a8
movl $0x6, %edx
callq 0x7400
movq 0x506ee(%rip), %rdi     # 0x6eff0
leaq 0x3907d(%rip), %rsi     # 0x57986
movl $0x30, %edx
callq 0x7400
movq 0x506d6(%rip), %rdi     # 0x6eff0
callq 0x71c0
movq 0x506aa(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
movq %rax, %r15
movq %r14, %rdi
callq 0x7530
leaq 0x238(%rbx), %rdi
callq 0x76b8
leaq 0x118(%rbx), %rdi
callq 0x2167c
leaq 0x100(%rbx), %rdi
callq 0x21682
leaq 0xe8(%rbx), %rdi
callq 0x216aa
leaq 0xb8(%rbx), %rdi
callq 0x216b8
movq %rbx, %rdi
callq 0x216be
movq %r15, %rdi
callq 0x7470
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Base.cpp
// Function: Host_Components::IO_Flow_Base::Start_simulation()
void IO_Flow_Base::Start_simulation()
	{
		next_logging_milestone = logging_period;
		if (enabled_logging) {
			log_file.open(logging_file_path, std::ofstream::out);
		}
		log_file << "SimulationTime(us)\t" << "ReponseTime(us)\t" << "EndToEndDelay(us)"<< std::endl;
		STAT_sum_device_response_time_short_term = 0;
		STAT_serviced_request_count_short_term = 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x228(%rdi), %rax
movq %rax, 0x230(%rdi)
cmpb $0x1, 0x220(%rdi)
jne 0x1e9c2
leaq 0x258(%rbx), %rdi
leaq 0x238(%rbx), %rsi
movl $0x10, %edx
callq 0x71b0
leaq 0x258(%rbx), %r14
leaq 0x38fe7(%rip), %rsi     # 0x579b7
movl $0x13, %edx
movq %r14, %rdi
callq 0x7400
leaq 0x38fe7(%rip), %rsi     # 0x579cb
movl $0x10, %edx
movq %r14, %rdi
callq 0x7400
leaq 0x38fe4(%rip), %rsi     # 0x579dc
movl $0x11, %edx
movq %r14, %rdi
callq 0x7400
movq 0x258(%rbx), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7380
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7290
movq $0x0, 0x458(%rbx)
movl $0x0, 0x468(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::~IO_Flow_Synthetic()
IO_Flow_Synthetic::~IO_Flow_Synthetic()
	{
		delete random_request_type_generator;
		delete random_address_generator;
		delete random_hot_cold_generator;
		delete random_hot_address_generator;
		delete random_request_size_generator;
		delete random_time_interval_generator;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4b985(%rip), %rax     # 0x6dc78
movq %rax, (%rdi)
leaq 0x4b9d3(%rip), %rax     # 0x6dcd0
movq %rax, 0x30(%rdi)
movq 0x480(%rdi), %rdi
testq %rdi, %rdi
je 0x22312
callq 0x7370
movq 0x498(%rbx), %rdi
testq %rdi, %rdi
je 0x22323
callq 0x7370
movq 0x4a8(%rbx), %rdi
testq %rdi, %rdi
je 0x22334
callq 0x7370
movq 0x4b8(%rbx), %rdi
testq %rdi, %rdi
je 0x22345
callq 0x7370
movq 0x4e8(%rbx), %rdi
testq %rdi, %rdi
je 0x22356
callq 0x7370
movq 0x4f8(%rbx), %rdi
testq %rdi, %rdi
je 0x22367
callq 0x7370
movq %rbx, %rdi
popq %rbx
jmp 0x1e798
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::NVMe_consume_io_request(Completion_Queue_Entry*)
void IO_Flow_Synthetic::NVMe_consume_io_request(Completion_Queue_Entry* io_request)
	{
		IO_Flow_Base::NVMe_consume_io_request(io_request);
		IO_Flow_Base::NVMe_update_and_submit_completion_queue_tail();
		if (generator_type == Utils::Request_Generator_Type::QUEUE_DEPTH) {
			Host_IO_Request* request = Generate_next_request();
			
			/* In the demand based execution mode, the Generate_next_request() function may return NULL
			* if 1) the simulation stop is met, or 2) the number of generated I/O requests reaches its threshold.*/
			if (request != NULL) {
				Submit_io_request(request);
			}
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1efc2
movq %rbx, %rdi
callq 0x1f9da
cmpl $0x1, 0x4f4(%rbx)
jne 0x22712
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x22712
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x1f82e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::SATA_consume_io_request(Host_Components::Host_IO_Request*)
void IO_Flow_Synthetic::SATA_consume_io_request(Host_IO_Request* io_request)
	{
		IO_Flow_Base::SATA_consume_io_request(io_request);
		if (generator_type == Utils::Request_Generator_Type::QUEUE_DEPTH) {
			Host_IO_Request* request = Generate_next_request();
			/* In the demand based execution mode, the Generate_next_request() function may return NULL
			* if 1) the simulation stop is met, or 2) the number of generated I/O requests reaches its threshold.*/
			if (request != NULL) {
				Submit_io_request(request);
			}
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1ea4e
cmpl $0x1, 0x4f4(%rbx)
jne 0x22740
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x22740
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x1f82e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::Start_simulation()
void IO_Flow_Synthetic::Start_simulation() 
	{
		IO_Flow_Base::Start_simulation();

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1e98c
cmpl $0x1, 0x48c(%rbx)
jne 0x22793
movq 0x498(%rbx), %rdi
movq 0x68(%rbx), %rsi
movq 0x70(%rbx), %rdx
callq 0x53c96
movq %rax, 0x4d0(%rbx)
cmpb $0x1, 0x514(%rbx)
jne 0x22793
movq %rax, %rcx
movl 0x518(%rbx), %esi
xorl %edx, %edx
divq %rsi
subq %rdx, %rcx
movq %rcx, 0x4d0(%rbx)
movl 0x4f4(%rbx), %ebp
callq 0x281b4
movq %rax, %r14
movl $0x1, %esi
testl %ebp, %ebp
jne 0x227f8
movsd 0x508(%rbx), %xmm1
unpcklps 0x35107(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3510f(%rip), %xmm1    # 0x578d0
movq 0x4f8(%rbx), %rdi
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x53d00
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x32863(%rip), %xmm0    # 0x55050
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x285aa
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::Execute_simulator_event(MQSimEngine::Sim_Event*)
void IO_Flow_Synthetic::Execute_simulator_event(MQSimEngine::Sim_Event* event)
	{
		if (generator_type == Utils::Request_Generator_Type::BANDWIDTH) {
			Host_IO_Request* req = Generate_next_request();
			if (req != NULL) {
				Submit_io_request(req);
				Simulator->Register_sim_event(Simulator->Time() + (sim_time_type)random_time_interval_generator->Exponential((double)Average_inter_arrival_time_nano_sec), this, 0, 0);
			}
		} else {
			for (unsigned int i = 0; i < average_number_of_enqueued_requests; i++) {
				Submit_io_request(Generate_next_request());
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4f4(%rdi)
je 0x22853
cmpl $0x0, 0x510(%rbx)
je 0x228f3
xorl %ebp, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1f82e
incl %ebp
cmpl 0x510(%rbx), %ebp
jb 0x22830
jmp 0x228f3
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x228f3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1f82e
callq 0x281b4
movq %rax, %r14
callq 0x281b4
movq %rax, %rdi
callq 0x285a6
movq %rax, %r15
movsd 0x508(%rbx), %xmm1
unpcklps 0x35029(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x35031(%rip), %xmm1    # 0x578d0
movq 0x4f8(%rbx), %rdi
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x53d00
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x32785(%rip), %xmm0    # 0x55050
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
addq %r15, %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x285aa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/IO_Flow_Synthetic.cpp
// Function: Host_Components::IO_Flow_Synthetic::Get_statistics(Utils::Workload_Statistics&, unsigned long (*)(unsigned long), unsigned long (*)(unsigned long))
void IO_Flow_Synthetic::Get_statistics(Utils::Workload_Statistics& stats, LPA_type(*Convert_host_logical_address_to_device_address)(LHA_type lha),
		page_status_type(*Find_NVM_subunit_access_bitmap)(LHA_type lha))
	{
		stats.Type = Utils::Workload_Type::SYNTHETIC;
		stats.generator_type = generator_type;
		stats.Stream_id = io_queue_id - 1;
		stats.Initial_occupancy_ratio = initial_occupancy_ratio;
		stats.Working_set_ratio = working_set_ratio;
		stats.Read_ratio = read_ratio;
		stats.random_request_type_generator_seed = random_request_type_generator_seed;
		stats.Address_distribution_type = address_distribution;
		stats.Ratio_of_hot_addresses_to_whole_working_set = hot_region_ratio;
		stats.Ratio_of_traffic_accessing_hot_region = 1 - hot_region_ratio;
		stats.random_address_generator_seed = random_address_generator_seed;
		stats.random_hot_address_generator_seed = random_hot_address_generator_seed;
		stats.random_hot_cold_generator_seed = random_hot_cold_generator_seed;
		stats.generate_aligned_addresses = generate_aligned_addresses;
		stats.alignment_value = alignment_value;
		stats.Request_size_distribution_type = request_size_distribution;
		stats.Average_request_size_sector = average_request_size;
		stats.STDEV_reuqest_size = variance_request_size;
		stats.random_request_size_generator_seed = random_request_size_generator_seed;
		stats.Request_queue_depth = average_number_of_enqueued_requests;
		stats.random_time_interval_generator_seed = random_time_interval_generator_seed;
		stats.Average_inter_arrival_time_nano_sec = Average_inter_arrival_time_nano_sec;
		stats.Min_LHA = start_lsa_on_device;
		stats.Max_LHA = end_lsa_on_device;
	}

// Assembly:
movl $0x0, (%rsi)
movl 0x4f4(%rdi), %eax
movl %eax, 0x158(%rsi)
movl 0xb0(%rdi), %eax
decl %eax
movw %ax, 0x4(%rsi)
movsd 0x40(%rdi), %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x478(%rdi), %xmm0
movsd %xmm0, 0x60(%rsi)
movsd 0x470(%rdi), %xmm0
movsd %xmm0, 0x20(%rsi)
movl 0x488(%rdi), %eax
movl %eax, 0x18(%rsi)
movl 0x48c(%rdi), %eax
movl %eax, 0x58(%rsi)
movsd 0x490(%rdi), %xmm0
movsd %xmm0, 0x70(%rsi)
movsd 0x352a9(%rip), %xmm1    # 0x57c10
subsd %xmm0, %xmm1
movsd %xmm1, 0x78(%rsi)
movl 0x4a0(%rdi), %eax
movl %eax, 0x80(%rsi)
movl 0x4c0(%rdi), %eax
movl %eax, 0x88(%rsi)
movl 0x4b0(%rdi), %eax
movl %eax, 0x84(%rsi)
movb 0x514(%rdi), %al
movb %al, 0x150(%rsi)
movl 0x518(%rdi), %eax
movl %eax, 0x154(%rsi)
movl 0x4d8(%rdi), %eax
movl %eax, 0x170(%rsi)
movq 0x4dc(%rdi), %rax
movq %rax, 0x178(%rsi)
movl 0x4f0(%rdi), %eax
movl %eax, 0x174(%rsi)
movl 0x510(%rdi), %eax
movl %eax, 0x15c(%rsi)
movl 0x500(%rdi), %eax
movl %eax, 0x160(%rsi)
movq 0x508(%rdi), %rax
movq %rax, 0x168(%rsi)
movups 0x68(%rdi), %xmm0
movups %xmm0, 0x130(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]MQSim/src/host/../utils/StringTools.h
// Function: Utils::Helper_Functions::Tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
static void Tokenize(const std::string& str, char delimiter, std::vector<std::string>& output_tokens_list)
		{
			int size = (int) str.size();
			int start = 0, end = 0;
			while (end < size) {
				if (str[end] == delimiter && start <= end) {
					output_tokens_list.push_back(std::string(str.substr(start, end - start + 1)));
					start = end + 1;
				}
				end++;
			}
			if (str[end - 1] != delimiter) {
				output_tokens_list.push_back(std::string(str.substr(start, end - start)));
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %r13
testl %r13d, %r13d
jle 0x23e3d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movl $0x1, %ebx
leaq 0x8(%rsp), %r15
xorl %eax, %eax
movq (%r14), %rcx
cmpb %bpl, (%rcx,%r12)
jne 0x23e31
movslq %eax, %rdx
cmpq %rdx, %r12
jl 0x23e31
movl %ebx, %eax
subl %edx, %eax
movslq %eax, %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x73c0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x23f2a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x23e2f
callq 0x7370
movl %ebx, %eax
incq %r12
incl %ebx
cmpq %r12, %r13
jne 0x23dec
jmp 0x23e42
xorl %eax, %eax
xorl %r12d, %r12d
movq (%r14), %rcx
movl %r12d, %edx
cmpb %bpl, -0x1(%rcx,%rdx)
je 0x23e87
movslq %eax, %rdx
subl %edx, %r12d
movslq %r12d, %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x73c0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x23f2a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23e87
callq 0x7370
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x23eb1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x23ebb
callq 0x7370
movq %rbx, %rdi
callq 0x7620
nop