LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::get_pv() const
vector<Move> AgentMCTS::get_pv() const {
	vector<Move> pv;

	const Node * n = & root;
	char turn = rootboard.toplay();
	while(n && !n->children.empty()){
		Move m = return_move(n, turn);
		pv.push_back(m);
		n = find_child(n, m);
		turn = 3 - turn;
	}

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

	return pv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x10(%rdi)
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
movq 0xc8(%rsi), %rax
cmpq $0x2, %rax
jb 0x1d75d
movb 0x99(%rsi), %bpl
leaq 0xc8(%rsi), %r15
addq $0xa8, %rsi
movq %rsp, %r14
cmpw $0x0, 0x6(%rax)
je 0x1d75d
movsbl %bpl, %edx
xorl %ecx, %ecx
callq 0x1d7b6
movq 0x8(%rbx), %rsi
movw %ax, (%rsp)
cmpq 0x10(%rbx), %rsi
je 0x1d6f5
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rbx)
jmp 0x1d704
movq %rbx, %rdi
movq %r14, %rdx
callq 0xdaa6
movzwl (%rsp), %eax
movq (%r15), %rcx
movl $0x0, %r15d
leaq 0x10(%rcx), %rdx
cmpq $0x2, %rcx
cmovaeq %rdx, %r15
addq $0x20, %r15
cmpq $0x2, %rcx
jb 0x1d731
movzwl 0x6(%rcx), %esi
leaq (%rsi,%rsi,4), %rsi
leaq (%rdx,%rsi,8), %rdi
jmp 0x1d733
xorl %edi, %edi
leaq -0x20(%r15), %rsi
cmpq %rdi, %rsi
je 0x1d75d
cmpw %ax, -0xc(%r15)
je 0x1d749
addq $0x28, %r15
jmp 0x1d71d
movq (%r15), %rax
movb $0x3, %cl
subb %bpl, %cl
movl %ecx, %ebp
cmpq $0x1, %rax
ja 0x1d6c5
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0x1d78d
movw $0x8efe, 0x4(%rsp)      # imm = 0x8EFE
cmpq 0x10(%rbx), %rsi
je 0x1d780
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rbx)
jmp 0x1d78d
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x2075a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d79d
movq (%rbx), %rdi
movq %rax, %r14
testq %rdi, %rdi
je 0x1d7ad
callq 0x42b0
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::move_stats[abi:cxx11](std::vector<Move, std::allocator<Move>>) const
string AgentMCTS::move_stats(vector<Move> moves) const {
	string s = "";
	const Node * node = & root;

	for(vector<Move>::iterator m = moves.begin(); node && m != moves.end(); ++m)
		node = find_child(node, *m);

	if(node){
		Node * child = node->children.begin(),
		     * childend = node->children.end();
		for( ; child != childend; child++)
			if(child->move != M_NONE)
				s += child->to_s() + "\n";
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x10(%rdi), %rax
movq %rdx, %r15
leaq 0xaebd(%rip), %rdx      # 0x28ae3
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
callq 0xa810
movq (%r15), %rax
movq 0x8(%r15), %rcx
addq $0xa8, %r14
cmpq %rcx, %rax
je 0x1dc9c
movq 0x20(%r14), %rdx
movzwl (%rax), %edi
movl $0x0, %r14d
leaq 0x10(%rdx), %rsi
cmpq $0x2, %rdx
cmovaeq %rsi, %r14
cmpq $0x2, %rdx
jb 0x1dc7d
movzwl 0x6(%rdx), %r8d
leaq (%r8,%r8,4), %r8
leaq (%rsi,%r8,8), %r8
jmp 0x1dc80
xorl %r8d, %r8d
cmpq %r8, %r14
je 0x1dd80
cmpw %di, 0x14(%r14)
je 0x1dc96
addq $0x28, %r14
jmp 0x1dc68
addq $0x4, %rax
jmp 0x1dc4a
movq 0x20(%r14), %rcx
xorl %r13d, %r13d
movl $0x0, %r14d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r14
jb 0x1dcc3
movzwl 0x6(%rcx), %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %r13
cmpq %r13, %r14
je 0x1dd80
leaq 0x10(%rsp), %rbp
leaq 0x28(%rsp), %r15
leaq 0xae05(%rip), %r12      # 0x28ae2
cmpb $-0x3, 0x14(%r14)
je 0x1dd73
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f004
movq %r15, %rdi
movq %r12, %rsi
callq 0x4610
movq %rbp, (%rsp)
movq %rax, %rcx
addq $0x10, %rcx
movq (%rax), %rdx
cmpq %rcx, %rdx
je 0x1dd1f
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x1dd28
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x40b0
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x1dd5f
callq 0x42b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1dd73
callq 0x42b0
addq $0x28, %r14
cmpq %r13, %r14
jne 0x1dcdd
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1ddad
movq %rax, %r14
jmp 0x1ddc1
movq (%rsp), %rdi
movq %rax, %r14
cmpq %rbp, %rdi
je 0x1ddad
callq 0x42b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1ddc1
callq 0x42b0
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1ddd0
callq 0x42b0
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/./thread.h
// Function: Thread::operator()(std::function<void ()>)
int operator()(function<void()> fn){
		assert(destruct == false);

		func = fn;
		destruct = true;
		return pthread_create(&thread, NULL, (void* (*)(void*)) &Thread::runner, this);
	}

// Assembly:
pushq %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x20130
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x201d4
movb $0x1, 0x8(%rbx)
leaq 0x11e(%rip), %rdx       # 0x20240
movq %rbx, %rdi
xorl %esi, %esi
movq %rbx, %rcx
popq %rbx
jmp 0x45f0
leaq 0xbb37(%rip), %rdi      # 0x2bc6e
leaq 0xba9d(%rip), %rsi      # 0x2bbdb
leaq 0xbb3b(%rip), %rcx      # 0x2bc80
movl $0x5d, %edx
callq 0x41b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/agentmctsthread.cpp
// Function: AgentMCTS::MCTSThread::iterate()
void AgentMCTS::MCTSThread::iterate(){
	if(player->profile){
		timestamps[0] = Time();
		stage = 0;
	}

	movelist.reset(&(player->rootboard));
	player->root.exp.addvloss();
	Board copy = player->rootboard;
	walk_tree(copy, & player->root, 0);
	player->root.exp.addv(movelist.getexp(3-player->rootboard.toplay()));

	if(player->profile){
		times[0] += timestamps[1] - timestamps[0];
		times[1] += timestamps[2] - timestamps[1];
		times[2] += timestamps[3] - timestamps[2];
		times[3] += Time() - timestamps[3];
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x40(%rdi), %rax
movq %rdi, %rbx
cmpb $0x1, 0x48(%rax)
jne 0x2087d
leaq 0x10(%rsp), %r14
xorl %esi, %esi
movq %r14, %rdi
callq 0x4500
vcvtsi2sdq (%r14), %xmm0, %xmm0
vcvtsi2sdq 0x8(%r14), %xmm1, %xmm1
vdivsd 0x77a2(%rip), %xmm1, %xmm1 # 0x28008
vaddsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, 0xd8(%rbx)
movl $0x0, 0x70(%rbx)
movq 0x40(%rbx), %rax
vxorpd %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
vmovupd %ymm0, 0x50(%rbx)
lock
incq 0xb0(%rax)
movq 0x40(%rbx), %rdx
movq 0xa0(%rdx), %rax
movq %rax, 0x20(%rsi)
vmovupd 0x80(%rdx), %ymm0
addq $0xa8, %rdx
vmovupd %ymm0, (%rsi)
vzeroupper
callq 0x2099a
movq 0x40(%rbx), %rax
movl $0x2, %edx
movzbl 0x99(%rax), %ecx
subq %rcx, %rdx
shlq $0x4, %rdx
leaq 0x50(%rbx,%rdx), %rcx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x208ee
lock
addq %rdx, 0xa8(%rax)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x208ff
lock
addq %rcx, 0xb0(%rax)
movq 0x40(%rbx), %rax
cmpb $0x1, 0x48(%rax)
jne 0x20991
vmovupd 0xd8(%rbx), %xmm0
vmovupd 0xe0(%rbx), %xmm1
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
vunpcklpd %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vsubpd %xmm0, %xmm1, %xmm0
vaddpd 0xb8(%rbx), %xmm0, %xmm0
vmovupd %xmm0, 0xb8(%rbx)
vmovsd 0xf0(%rbx), %xmm0
vsubsd 0xe8(%rbx), %xmm0, %xmm0
vaddsd 0xc8(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0xc8(%rbx)
callq 0x4500
vcvtsi2sdq (%r14), %xmm2, %xmm0
vcvtsi2sdq 0x8(%r14), %xmm2, %xmm1
vdivsd 0x7693(%rip), %xmm1, %xmm1 # 0x28008
vaddsd %xmm0, %xmm1, %xmm0
vsubsd 0xf0(%rbx), %xmm0, %xmm0
vaddsd 0xd0(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0xd0(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/agentmctsthread.cpp
// Function: AgentMCTS::MCTSThread::choose_move(AgentMCTS::Node const*, int) const
AgentMCTS::Node * AgentMCTS::MCTSThread::choose_move(const Node * node, int toplay) const {
	float val, maxval = -1000000000;
	float logvisits = log(node->exp.num());

	float explore = player->explore;
	if(player->parentexplore)
		explore *= node->exp.avg();

	Node * ret = NULL,
		 * child = node->children.begin(),
		 * end   = node->children.end();

	for(; child != end; child++){
		if(child->outcome >= 0){
			if(child->outcome == toplay) //return a win immediately
				return child;

			val = (child->outcome == 0 ? -1 : -2); //-1 for tie so any unknown is better, -2 for loss so it's even worse
		}else{
			val = child->value(player->knowledge, player->fpurgency);
			if(explore > 0)
				val += explore*sqrt(logvisits/(child->exp.num() + 1));
		}

		if(maxval < val){
			maxval = val;
			ret = child;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
vcvtusi2sdq 0x8(%rsi), %xmm0, %xmm0
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x4240
movq 0x40(%r14), %rax
vmovss 0x4c(%rax), %xmm3
cmpb $0x1, 0x49(%rax)
jne 0x20dec
vcvtusi2ssq (%r15), %xmm1, %xmm1
vcvtusi2ssq 0x8(%r15), %xmm2, %xmm2
vmulss 0xa874(%rip), %xmm1, %xmm1 # 0x2b658
vdivss %xmm2, %xmm1, %xmm1
vmulss %xmm1, %xmm3, %xmm3
movq 0x20(%r15), %rcx
xorl %r13d, %r13d
movl $0x0, %r15d
leaq 0x10(%rcx), %rax
cmpq $0x2, %rcx
cmovaeq %rax, %r15
jb 0x20e13
movzwl 0x6(%rcx), %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %r13
cmpq %r13, %r15
je 0x20ef7
vmovss 0xb294(%rip), %xmm2     # 0x2c0b8
vcvtsd2ss %xmm0, %xmm0, %xmm0
leaq 0xb281(%rip), %rbp      # 0x2c0b0
xorl %r12d, %r12d
vmovss %xmm3, 0x8(%rsp)
vmovss %xmm0, 0x14(%rsp)
movsbl 0x12(%r15), %eax
testl %eax, %eax
js 0x20e5e
cmpl %ebx, %eax
je 0x20efc
xorl %ecx, %ecx
testb %al, %al
sete %cl
vmovss (%rbp,%rcx,4), %xmm4
jmp 0x20edc
movq 0x40(%r14), %rax
movq %r15, %rdi
vmovss %xmm2, 0xc(%rsp)
vmovss 0x58(%rax), %xmm0
movzbl 0x50(%rax), %esi
callq 0x2170c
vmovss 0x8(%rsp), %xmm3
vmovss 0xc(%rsp), %xmm2
vmovaps %xmm0, %xmm4
vucomiss 0xb22b(%rip), %xmm3     # 0x2c0bc
jbe 0x20edc
movq 0x8(%r15), %rax
vmovss 0x14(%rsp), %xmm1
incq %rax
vcvtusi2ss %rax, %xmm5, %xmm0
vdivss %xmm0, %xmm1, %xmm0
vucomiss 0xb20a(%rip), %xmm0     # 0x2c0bc
jb 0x20eba
vsqrtss %xmm0, %xmm0, %xmm0
jmp 0x20ed7
vmovss %xmm4, 0x10(%rsp)
callq 0x45e0
vmovss 0x10(%rsp), %xmm4
vmovss 0xc(%rsp), %xmm2
vmovss 0x8(%rsp), %xmm3
vfmadd231ss %xmm0, %xmm3, %xmm4 # xmm4 = (xmm3 * xmm0) + xmm4
vucomiss %xmm2, %xmm4
vmaxss %xmm2, %xmm4, %xmm2
cmovaq %r15, %r12
addq $0x28, %r15
cmpq %r13, %r15
jne 0x20e3e
jmp 0x20eff
xorl %r12d, %r12d
jmp 0x20eff
movq %r15, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/agentmctsthread.cpp
// Function: AgentMCTS::MCTSThread::rollout(Board&, Move, int)
int AgentMCTS::MCTSThread::rollout(Board & board, Move move, int depth){
	int won;
	while((won = board.won()) < 0) {
		board.move_rand(rand64);
	}
	gamelen.add(board.num_moves());
	movelist.finishrollout(won);
	return won;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movb 0x1a(%r15), %bpl
cmpb $-0x4, %bpl
jne 0x21499
movq %r15, %rdi
callq 0xd9e4
movl %eax, %ebp
movb %al, 0x1a(%r15)
testb %bpl, %bpl
jns 0x214ab
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21800
jmp 0x21481
movzbl 0x18(%r15), %esi
leaq 0x98(%rbx), %rdi
movzbl %bpl, %r14d
callq 0x216a6
incq 0x58(%rbx)
incq 0x68(%rbx)
testb %bpl, %bpl
je 0x214e3
leal -0x1(%r14), %eax
addq $0x50, %rbx
shlq $0x4, %rax
addq %rax, %rbx
movl $0x2, %eax
jmp 0x214f0
incq 0x50(%rbx)
addq $0x60, %rbx
movl $0x1, %eax
addq %rax, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/./board.h
// Function: Board::score_calc() const
int16_t score_calc() const {
		int16_t s = 0;
		uint64_t ws = sides[1];
		uint64_t bs = sides[2];

		//calculate score from white's perspective
		for(int i = 0; i < 32; i++){
			uint64_t wm = winmaps[i];
			uint64_t w = (ws & wm);
			uint64_t b = (bs & wm);

			if     (w && !b) s += scoremap[bitcount(w)];
			else if(!w && b) s -= scoremap[bitcount(b)];
		}
		//return the score from the perspective of the player that just played
		//ie not the player whose turn it is now
		return (to_play == 1 ? -s : s);
	}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
leaq 0x8967(%rip), %r8       # 0x2a100
leaq 0x8950(%rip), %r9       # 0x2a0f0
xorl %esi, %esi
xorl %edx, %edx
movq (%r8,%rsi,8), %r10
movq %r10, %r11
andq %rax, %r11
sete %bl
andq %rcx, %r10
setne %bpl
orb %bl, %bpl
je 0x217df
testq %r10, %r10
setne %bl
testq %r11, %r11
sete %r11b
andb %bl, %r11b
cmpb $0x1, %r11b
jne 0x217e9
popcntq %r10, %r10
subw (%r9,%r10,2), %dx
jmp 0x217e9
popcntq %r11, %r10
addw (%r9,%r10,2), %dx
incq %rsi
cmpq $0x20, %rsi
jne 0x217a4
movl %edx, %eax
negl %eax
cmpb $0x1, 0x19(%rdi)
cmovnel %edx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/./board.h
// Function: Board::move_rand(XORShift_uint64&)
bool move_rand(XORShift_uint64 & rand){
		//find an empty space, this should take log2(bits set) to converge, assuming a good and fast RNG
		uint64_t move = (~sides[0]) & 0xFFFFFFFFFULL; // bits set for all empty positions
		uint64_t mask;
		do {
			mask = rand();
			if((move & mask) > 0) // don't let it drop to no bits set
				move &= mask;
		} while(move & (move-1));
//		} while(bitcount(move) > 1); // if there's only one bit left, that's our move

		sides[to_play] |= move;

		uint64_t rotation = (mask >> 36); //mask is already a random number, so just re-use the unused high bits
		uint64_t direction = rotation & 0x4;
		uint64_t quadrant = rotation & 0x3;

		if (direction) {
			sides[1] = rotate_quad_ccw(sides[1], quadrant);
			sides[2] = rotate_quad_ccw(sides[2], quadrant);
		} else {
			sides[1] = rotate_quad_cw(sides[1], quadrant);
			sides[2] = rotate_quad_cw(sides[2], quadrant);
		}
		sides[0] = sides[1] | sides[2];

		nummoves++;
		to_play = 3 - to_play;
		outcome = -4;
		cached_score = default_score;
		cached_hash = 0;
		orientation = 8;

		return true;
	}

// Assembly:
movq (%rdi), %rax
movb $0x24, %cl
notq %rax
bzhiq %rcx, %rax, %rdx
movq (%rsi), %rcx
movq %rdx, %rax
movq %rcx, %rdx
shrq $0x11, %rdx
xorq %rcx, %rdx
movq %rdx, %r8
shlq $0x1f, %r8
xorq %rdx, %r8
movq %r8, %rcx
shrq $0x8, %rcx
xorq %r8, %rcx
movq %rcx, %rdx
andq %rax, %rdx
cmoveq %rax, %rdx
blsrq %rdx, %rax
jne 0x21810
movq %rcx, (%rsi)
movq %rcx, %rsi
shrq $0x24, %rsi
movl $0xff, %r8d
movzbl 0x19(%rdi), %eax
orq %rdx, (%rdi,%rax,8)
movabsq $0x4000000000, %rdx     # imm = 0x4000000000
andq %rcx, %rdx
movq 0x10(%rdi), %r9
movq %rdx, %rcx
shrq $0x26, %rcx
testq %rdx, %rdx
sete %dl
andb $0x3, %sil
shlb $0x2, %cl
movzbl %sil, %esi
shlb $0x2, %dl
orb $0x2, %cl
leal (%rsi,%rsi,8), %esi
orb $0x2, %dl
shlxq %rsi, %r8, %rsi
movq 0x8(%rdi), %r8
andnq %r8, %rsi, %r10
andq %rsi, %r8
shrxq %rdx, %r8, %r11
shlxq %rcx, %r8, %r8
orq %r11, %r8
andnq %r9, %rsi, %r11
andq %rsi, %r9
shrxq %rdx, %r9, %rdx
shlxq %rcx, %r9, %rcx
andq %rsi, %r8
orq %rdx, %rcx
orq %r10, %r8
andq %rsi, %rcx
movq %r8, 0x8(%rdi)
orq %r11, %rcx
movq %rcx, 0x10(%rdi)
orq %r8, %rcx
movq %rcx, (%rdi)
incb 0x18(%rdi)
movb $0x3, %cl
subb %al, %cl
movb $0x1, %al
movb %cl, 0x19(%rdi)
movl $0xdead08fc, 0x1a(%rdi) # imm = 0xDEAD08FC
movq $0x0, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movb 0x2a(%rdi), %al
vmovsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
cmpb $-0x4, %al
jne 0x21bb9
leaq 0x10(%rbx), %rdi
callq 0xd9e4
movb %al, 0x2a(%rbx)
testb %al, %al
jns 0x21c6a
movq %rbx, %rdi
callq 0x21cd0
movl $0x18, %edi
leaq 0x10(%rsp), %r14
movb $0x0, 0x8(%rbx)
xorl %r15d, %r15d
movq %r15, 0x8(%r14)
callq 0x42e0
leaq 0x36fa(%rip), %rdx      # 0x252e4
leaq 0x370f(%rip), %rcx      # 0x25300
movq $0x59, (%rax)
movq %r15, 0x8(%rax)
movq %rax, (%r14)
movq %rbx, 0x10(%rax)
movq %rdx, 0x18(%r14)
movq %rcx, 0x10(%r14)
vmovsd 0x8(%rsp), %xmm0
leaq 0x4(%rsp), %rdi
movq %r14, %rsi
callq 0x234ba
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x21c37
leaq 0x10(%rsp), %rdi
movl $0x3, %edx
movq %rdi, %rsi
callq *%rax
leaq 0xa10(%rbx), %rdi
callq 0x1ddd8
movl $0x1, %ecx
movl $0x6, %eax
lock
cmpxchgl %ecx, 0x9f0(%rbx)
movl 0x9f0(%rbx), %eax
cmpl $0x1, %eax
jne 0x21c74
leaq 0x4(%rsp), %rdi
callq 0x1eb34
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9ad2(%rip), %rdi      # 0x2b74d
leaq 0xa85e(%rip), %rsi      # 0x2c4e0
leaq 0xa864(%rip), %rcx      # 0x2c4ed
movl $0x14, %edx
callq 0x41b0
jmp 0x21cc8
leaq 0x4(%rsp), %rdi
movq %rax, %rbx
callq 0x1eb34
jmp 0x21cc0
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x21cc0
leaq 0x10(%rsp), %rdi
movl $0x3, %edx
movq %rdi, %rsi
callq *%rax
movq %rbx, %rdi
callq 0x45b0
movq %rax, %rdi
callq 0x8dae
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22df8
movl $0x2, %ecx
movl $0x1, %eax
movq %rdi, %rbx
lock
cmpxchgl %ecx, 0x9f0(%rdi)
jne 0x22e17
leaq 0xa10(%rbx), %r14
movq %r14, %rdi
callq 0x1ddd8
movq 0x9f8(%rbx), %rax
movq 0xa00(%rbx), %rdx
cmpq %rax, %rdx
je 0x22d4d
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
callq 0x200d0
movq 0xa00(%rbx), %rdx
movq 0x9f8(%rbx), %rax
movl %ebp, %ecx
incl %ebp
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rsi
ja 0x22d1f
cmpq %rax, %rdx
je 0x22d59
movq %rax, 0xa00(%rbx)
movl $0x1, 0x9f0(%rbx)
movq %r14, %rdi
movl 0xadc(%rbx), %esi
incl %esi
callq 0x1ed1e
movl 0xadc(%rbx), %esi
leaq 0xa70(%rbx), %rdi
callq 0x1ed1e
cmpl $0x0, 0xadc(%rbx)
jle 0x22deb
leaq 0x9f8(%rbx), %r14
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movl $0x48, %edi
callq 0x42e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x23982
movq %r12, 0x8(%rsp)
movq 0xa00(%rbx), %rsi
cmpq 0xa08(%rbx), %rsi
je 0x22dd6
movq %r12, (%rsi)
addq $0x8, 0xa00(%rbx)
jmp 0x22de1
movq %r14, %rdi
movq %r15, %rdx
callq 0x2538a
incl %ebp
cmpl 0xadc(%rbx), %ebp
jl 0x22d9c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x894e(%rip), %rdi      # 0x2b74d
leaq 0x96da(%rip), %rsi      # 0x2c4e0
leaq 0x9771(%rip), %rcx      # 0x2c57e
movl $0x76, %edx
callq 0x41b0
leaq 0x8b2a(%rip), %rdi      # 0x2b948
leaq 0x96bb(%rip), %rsi      # 0x2c4e0
leaq 0x9752(%rip), %rcx      # 0x2c57e
movl $0x79, %edx
callq 0x41b0
movq %r12, %rdi
movq %rax, %rbx
callq 0x42b0
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movzbl 0x19(%rdi), %r14d
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xd282
movl $0x3, %r13d
movl $0xfffffffc, %r12d      # imm = 0xFFFFFFFC
xorl %r15d, %r15d
subl %r14d, %r13d
cmpb $0x23, 0x38(%rsp)
jg 0x23b45
incl (%rbx)
movb 0x2a(%rsp), %al
cmpb $-0x4, %al
jne 0x23b15
leaq 0x10(%rsp), %rdi
callq 0xd9e4
movb %al, 0x2a(%rsp)
movsbl %al, %eax
cmpl %r14d, %eax
je 0x23b42
cmpl $-0x4, %r12d
movl %r12d, %ebp
cmovel %eax, %ebp
cmpl %r13d, %r12d
cmovel %eax, %ebp
testb %al, %al
cmovel %r15d, %ebp
leaq 0x8(%rsp), %rdi
callq 0xd39c
movl %ebp, %r12d
jmp 0x23af6
movl %r14d, %r12d
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x23b54
callq 0x43d0
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x50(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x23b78
callq 0x43d0
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x11702(%rip), %rax     # 0x35bb0
movq %rdi, %rbx
movq %rax, (%rdi)
callq 0x22c60
movl $0x0, 0xadc(%rbx)
movq %rbx, %rdi
callq 0x22cc0
leaq 0xae0(%rbx), %r15
leaq 0x50(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2441c
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
movq %r14, %rdi
callq 0x2353c
movq %r15, %rdi
callq 0xd6fe
leaq 0xa70(%rbx), %rdi
callq 0xd756
leaq 0xa10(%rbx), %rdi
callq 0xd756
movq 0x9f8(%rbx), %rdi
testq %rdi, %rdi
je 0x24522
callq 0x42b0
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd7a4
movq %rax, %rdi
callq 0x8dae
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20(%rsi), %rax
movq %rdi, %rbx
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 0x245a0
movq (%rbx), %rax
movq %rbx, %rdi
vzeroupper
callq *0x38(%rax)
movq %rbx, %rdi
popq %rbx
vzeroupper
jmp 0x22cc0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r15
callq 0x96fe
movq %rax, %rcx
shrq $0x11, %rax
movq 0x38(%rbx), %rsi
xorq %rcx, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
xorq %rdx, %rax
xorl %edx, %edx
divq 0x40(%rbx)
leaq (%rdx,%rdx,2), %rax
cmpq %rcx, (%rsi,%rax,8)
jne 0x26e52
leaq (%rsi,%rax,8), %rax
movl 0xc(%rax), %ebp
movl %ebp, %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
jmp 0x26f06
leaq 0x8(%rsp), %r14
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rsi
movq %r14, %rdi
callq 0xd282
movl $0xffff8001, %r13d      # imm = 0xFFFF8001
movw $0x8efe, %bp            # imm = 0x8EFE
leaq 0x10(%rsp), %r15
movl $0x8efc, %r12d          # imm = 0x8EFC
cmpb $0x24, 0x38(%rsp)
jge 0x26ef5
movq %r15, %rdi
callq 0x96fe
movq %rax, %rcx
shrq $0x11, %rax
movq 0x38(%rbx), %rsi
xorq %rcx, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
xorq %rdx, %rax
xorl %edx, %edx
divq 0x40(%rbx)
leaq (%rdx,%rdx,2), %rax
cmpq %rcx, (%rsi,%rax,8)
jne 0x26ed4
leaq (%rsi,%rax,8), %rax
movswl 0x8(%rax), %eax
cmpl %eax, %r13d
cmovlw 0x38(%rsp), %bp
cmovlel %eax, %r13d
jmp 0x26eeb
cmpl $0xffff8001, %r13d      # imm = 0xFFFF8001
jne 0x26eeb
cmpb $-0x2, %bpl
movl $0xffff8001, %r13d      # imm = 0xFFFF8001
cmovel %r12d, %ebp
movq %r14, %rdi
callq 0xd39c
jmp 0x26e7c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x26f04
callq 0x43d0
xorl %ecx, %ecx
movzwl %bp, %eax
orl %ecx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26f1c
movq 0x50(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x26f2e
callq 0x43d0
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x40, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r15
movl $0xffffffec, %ebp       # imm = 0xFFFFFFEC
leaq 0xc(%rsp), %r12
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, (%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x20(%r15)
vmovups 0x10(%rsi), %ymm0
vmovups %ymm0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
vzeroupper
callq 0x26df0
movw %ax, 0xc(%rsp)
andl $0xfd, %eax
cmpl $0xfc, %eax
je 0x26fd1
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x26faf
movl 0xc(%rsp), %esi
movl %esi, (%rax)
addq $0x4, 0x8(%rbx)
jmp 0x26fc1
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xdaa6
movl 0xc(%rsp), %esi
movq %r15, %rdi
callq 0x9282
testb %al, %al
je 0x27011
incl %ebp
jne 0x26f79
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0x27001
movw $0x8efe, 0xc(%rsp)      # imm = 0x8EFE
cmpq 0x10(%rbx), %rsi
je 0x26ff4
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rbx)
jmp 0x27001
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x2075a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x226c(%rip), %rdi      # 0x29284
leaq 0x5afd(%rip), %rsi      # 0x2cb1c
leaq 0x5b51(%rip), %rcx      # 0x2cb77
movl $0xb2, %edx
callq 0x41b0
jmp 0x27034
jmp 0x27034
movq (%rbx), %rdi
movq %rax, %r14
testq %rdi, %rdi
je 0x27044
callq 0x42b0
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %edx, %edx
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
divq 0x40(%rdi)
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,8), %rcx
xorl %eax, %eax
cmpq %rsi, (%rcx)
cmoveq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]pentagod/./agentab.h
// Function: AgentAB::clear_mem()
void clear_mem(){
		reset();
		if(TT){
			delete[] TT;
			TT = NULL;
		}
	}

// Assembly:
pushq %rbx
vxorps %xmm0, %xmm0, %xmm0
movb $0x0, 0x8(%rdi)
movl $0x0, 0x50(%rdi)
movq %rdi, %rbx
vmovups %xmm0, 0x58(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x27998
callq 0x43d0
movq $0x0, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x885c
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 0x888e
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 0x888b
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 0x88a5
callq 0x7370
leal 0x1(%rbx), %r14d
cmpl $0x4, %ebx
jl 0x87c7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x88c3
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x88da
callq 0x7370
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43afb(%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 0xaf32
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x53af8
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1168d
callq 0x7370
leaq 0x5dd84(%rip), %rdi     # 0x6f418
movq %rbx, %rsi
callq 0x13e5c
leaq 0x5dd7d(%rip), %rdi     # 0x6f420
movq %rbx, %rsi
callq 0xc95c
movq %rbx, %rdi
callq 0x53e9a
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x116c1
callq 0x7370
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x116e2
callq 0x7370
jmp 0x116e2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x116f0
callq 0x7370
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1177c
leaq 0x5de1f(%rip), %r13     # 0x6f532
leaq 0x453ff(%rip), %r14     # 0x56b19
leaq 0x5dcf7(%rip), %r15     # 0x6f418
leaq 0x449e0(%rip), %r12     # 0x56108
movq (%rbx), %rbp
testq %rbp, %rbp
cmoveq %r13, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x74d0
testl %eax, %eax
je 0x11761
movq %rbp, %rdi
movq %r12, %rsi
callq 0x74d0
testl %eax, %eax
jne 0x1176c
leaq 0x5dcc9(%rip), %rdi     # 0x6f420
movq %rbx, %rsi
callq 0xf88c
jmp 0x1176c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x145d2
cmpq $0x0, 0x20(%rbx)
je 0x1178b
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x11728
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43fe5(%rip), %rdi     # 0x55777
leaq 0x43db0(%rip), %rsi     # 0x55549
leaq 0x43fe6(%rip), %rcx     # 0x55786
movl $0x3ee, %edx            # imm = 0x3EE
callq 0x7270
movq %rax, %rdi
callq 0x7190
movq 0x5d837(%rip), %rdi     # 0x6eff0
leaq 0x44de8(%rip), %rsi     # 0x565a8
movl $0x6, %edx
callq 0x7400
movq 0x5d81f(%rip), %rdi     # 0x6eff0
leaq 0x45354(%rip), %rsi     # 0x56b2c
movl $0x25, %edx
callq 0x7400
movq 0x5d807(%rip), %rdi     # 0x6eff0
callq 0x71c0
movq 0x5d7db(%rip), %rdi     # 0x6efd0
callq 0x7430
movl $0x1, %edi
callq 0x7440
movq %rax, %rbx
callq 0x7590
movq %rbx, %rdi
callq 0x7620
movq %rax, %rdi
callq 0xae63
// File: /workspace/github_cpp_makefile_star2_O3/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 0x57c2d(%rip), %rax     # 0x6d9c0
movq %rax, (%rdi)
leaq 0x57c5b(%rip), %rax     # 0x6d9f8
movq %rax, 0x30(%rdi)
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x15de9
leaq 0x57fbf(%rip), %rax     # 0x6dd70
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xb0(%r14), %rdi
callq 0x1662a
leaq 0x60(%r14), %rdi
callq 0x1662a
leaq 0x57c94(%rip), %rax     # 0x6da68
movq %rax, (%r14)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x15de9
callq 0x7370
movq %r14, %rdi
callq 0x7370
movq 0x38(%rbx), %rdi
callq 0x7370
movq 0x48(%rbx), %rdi
callq 0x7370
movq 0x70(%rbx), %rax
movq 0x40(%rax), %rax
cmpl $0x0, 0x38(%rax)
jne 0x15e2a
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x15e22
movq %r14, %rdi
callq 0x2521e
movq %r14, %rdi
callq 0x7370
movq 0x58(%rbx), %rdi
cmpq %rdi, 0x60(%rbx)
je 0x15e6f
movw $0x1, %r15w
xorl %eax, %eax
movq (%rdi,%rax,8), %r14
testq %r14, %r14
je 0x15e4c
movq %r14, %rdi
callq 0x1e6e0
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 0x15e3b
testq %rdi, %rdi
je 0x15e79
callq 0x7370
leaq 0x57be8(%rip), %rax     # 0x6da68
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x15e9a
popq %rbx
popq %r14
popq %r15
jmp 0x7370
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1622d
xorl %r12d, %r12d
leaq 0x7aa1(%rip), %r14      # 0x1dbd0
leaq 0x7ab2(%rip), %r15      # 0x1dbe8
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 0x16215
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x16220
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x1685a
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x16136
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 0x1624f
callq 0x7370
movq %r14, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf32
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %r15
movq %r15, %rsi
callq 0x7450
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x163af
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 0xaf32
leaq 0x48(%rsp), %rsi
movq (%rsp), %rdi
callq 0x53af8
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x163ec
callq 0x7370
movq 0x58(%r14), %rbp
movq 0x60(%r14), %rbx
cmpq %rbx, %rbp
je 0x1644e
leaq 0x38(%rsp), %r14
leaq 0x40aa7(%rip), %r15     # 0x56eac
leaq 0x28(%rsp), %r12
movq (%rbp), %r13
movq %r14, 0x28(%rsp)
movq %r12, %rdi
leaq 0x40a8b(%rip), %rsi     # 0x56ea8
movq %r15, %rdx
callq 0xafc8
movq (%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq *0x38(%rax)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16445
callq 0x7370
addq $0x8, %rbp
cmpq %rbx, %rbp
jne 0x1640a
movq (%rsp), %rdi
callq 0x53e9a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1646b
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 0x164a2
jmp 0x164a7
jmp 0x16490
jmp 0x16490
movq %rax, %rbx
jmp 0x164a7
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x164a7
callq 0x7370
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x164bb
callq 0x7370
movq %rbx, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x505de(%rip), %rax     # 0x6db40
movq %rax, (%rdi)
leaq 0x5060c(%rip), %rax     # 0x6db78
movq %rax, 0x30(%rdi)
cmpl $0x0, 0x78(%rdi)
je 0x1d5ca
xorl %r15d, %r15d
cmpl $0x0, 0x7c(%rbx)
je 0x1d5b2
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 0x1d59f
movq %r14, %rdi
callq 0x2653a
movq %r14, %rdi
callq 0x7370
incq %r12
movl 0x7c(%rbx), %eax
cmpq %rax, %r12
jb 0x1d582
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x7370
incq %r15
movl 0x78(%rbx), %eax
cmpq %rax, %r15
jb 0x1d579
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x1d5db
movq %r14, %rdi
callq 0x44d22
movq %r14, %rdi
callq 0x7370
movq 0x50(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x1d5fa
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x50(%rbx), %rax
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x1d60d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x1d620
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x50(%rbx), %rax
movq 0x48(%rax), %r14
testq %r14, %r14
je 0x1d65f
leaq 0x50eb8(%rip), %rax     # 0x6e4e8
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xa0(%r14), %rdi
callq 0x1dd04
leaq 0x5041e(%rip), %rax     # 0x6da68
movq %rax, (%r14)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x1d65f
callq 0x7370
movq %r14, %rdi
callq 0x7370
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x1d68c
leaq 0x503f1(%rip), %rax     # 0x6da68
movq %rax, (%r14)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x1d68c
callq 0x7370
movq %r14, %rdi
callq 0x7370
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1d6a3
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1d6b2
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1d6c0
callq 0x7370
leaq 0x503a1(%rip), %rax     # 0x6da68
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x1d6e7
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7370
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d8bc
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0x7350
movq %rax, %rbx
movq 0x51860(%rip), %r12     # 0x6ef88
leaq 0x3a016(%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 0x165a4
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x30(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1d794
callq 0x7370
movq 0x48(%r15), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x165a4
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x30(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d7c0
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 0x3786a(%rip), %xmm0    # 0x55050
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq 0x51790(%rip), %rbx     # 0x6ef88
leaq 0x39f73(%rip), %rsi     # 0x57772
movl $0x37, %edx
movq %rbx, %rdi
callq 0x7400
movq %r12, %rax
shrq $0x4, %rax
movabsq $0x91a2b3c4d5e6f81, %rcx # imm = 0x91A2B3C4D5E6F81
mulq %rcx
movq %rdx, %r14
shrq $0x3, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7280
movq %rax, %rbx
leaq 0x38d71(%rip), %r15     # 0x565ad
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x7400
imull $0xe10, %r14d, %eax     # imm = 0xE10
subl %eax, %r12d
imull $0x889, %r12d, %r14d    # imm = 0x889
shrl $0x11, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7280
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x7400
imull $0x3c, %r14d, %eax
subl %eax, %r12d
movzwl %r12w, %esi
movq %rbx, %rdi
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 0x1d8db
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1d8e5
callq 0x7370
movq %rbx, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f4d6(%rip), %rax     # 0x6dbc8
movq %rax, (%rdi)
leaq 0x4f524(%rip), %rax     # 0x6dc20
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 0x1e737
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1e731
callq 0x7370
movq (%r12), %r12
jmp 0x1e71d
movl 0x54(%rbx), %eax
testl %eax, %eax
je 0x1e766
cmpl $0x1, %eax
jne 0x1e82b
movq 0x128(%rbx), %r14
testq %r14, %r14
je 0x1e766
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1e761
callq 0x7370
movq (%r14), %r14
jmp 0x1e74e
movq 0x507fb(%rip), %rax     # 0x6ef68
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 0x1e7b7
callq 0x7370
leaq 0x118(%rbx), %rdi
callq 0x21626
movq 0x100(%rbx), %rdi
cmpq %r15, %rdi
je 0x1e7df
movq (%rdi), %r14
callq 0x7370
movq %r14, %rdi
cmpq %r15, %r14
jne 0x1e7cf
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e7f0
callq 0x7370
leaq 0xb8(%rbx), %rdi
callq 0x21688
leaq 0x4f265(%rip), %rax     # 0x6da68
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x1e823
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7370
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x507be(%rip), %rdi     # 0x6eff0
leaq 0x37d6f(%rip), %rsi     # 0x565a8
movl $0x6, %edx
callq 0x7400
movq 0x507a6(%rip), %rdi     # 0x6eff0
leaq 0x39135(%rip), %rsi     # 0x57986
movl $0x30, %edx
callq 0x7400
movq 0x5078e(%rip), %rdi     # 0x6eff0
callq 0x71c0
movq 0x50762(%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 0x215c4
leaq 0x100(%rbx), %rdi
callq 0x215ca
leaq 0xe8(%rbx), %rdi
callq 0x215f2
leaq 0xb8(%rbx), %rdi
callq 0x21600
movq %rbx, %rdi
callq 0x21606
movq %r15, %rdi
callq 0x7470