LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::~AgentMCTS()
AgentMCTS::~AgentMCTS(){
	stop_threads();

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

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x24cc6(%rip), %rax     # 0x4fa80
movq %rax, (%rdi)
callq 0x2aaa0
jmp 0x2adc4
movq 0x8(%rsp), %rdi
movl $0x0, 0x3c(%rdi)
callq 0x2ae80
jmp 0x2add7
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0xa8, %rdi
addq $0xf0, %rsi
callq 0x2d7c0
jmp 0x2adf4
movq 0x8(%rsp), %rdi
addq $0xf0, %rdi
vpxor %xmm1, %xmm1, %xmm1
vmovaps %xmm1, %xmm0
callq 0x2c720
jmp 0x2ae0f
movq 0x8(%rsp), %rdi
addq $0xb00, %rdi            # imm = 0xB00
callq 0x16420
movq 0x8(%rsp), %rdi
addq $0xaa0, %rdi            # imm = 0xAA0
callq 0x16420
movq 0x8(%rsp), %rdi
addq $0xa88, %rdi            # imm = 0xA88
callq 0x2d670
movq 0x8(%rsp), %rdi
addq $0xf0, %rdi
callq 0x2d6d0
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
callq 0x2d750
movq 0x8(%rsp), %rdi
callq 0x16560
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xb570
nopl (%rax,%rax)
// File: tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::reset_threads()
void AgentMCTS::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 MCTSThread(this));
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0xa80(%rax), %eax
cmpl $0x1, %eax
jne 0x2aea0
jmp 0x2aebf
leaq 0x1580a(%rip), %rdi     # 0x406b1
leaq 0x15824(%rip), %rsi     # 0x406d2
movl $0xe6, %edx
leaq 0x159d2(%rip), %rcx     # 0x4088c
callq 0x4250
movq 0x20(%rsp), %rdi
addq $0xa80, %rdi            # imm = 0xA80
movl $0x1, 0x4c(%rsp)
movl $0x2, 0x48(%rsp)
leaq 0x4c(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x2c6b0
testb $0x1, %al
jne 0x2aef0
jmp 0x2aef2
jmp 0x2af11
leaq 0x159b3(%rip), %rdi     # 0x408ac
leaq 0x157d2(%rip), %rsi     # 0x406d2
movl $0xe9, %edx
leaq 0x15980(%rip), %rcx     # 0x4088c
callq 0x4250
movq 0x20(%rsp), %rdi
addq $0xaa0, %rdi            # imm = 0xAA0
callq 0x2c5d0
movl $0x0, 0x44(%rsp)
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0xa88, %rdi            # imm = 0xA88
callq 0x2cd30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x2af7d
movq 0x20(%rsp), %rdi
addq $0xa88, %rdi            # imm = 0xA88
movl 0x44(%rsp), %eax
movl %eax, %esi
callq 0x2cd50
movq (%rax), %rdi
callq 0x2d880
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2af2a
movq 0x20(%rsp), %rdi
addq $0xa88, %rdi            # imm = 0xA88
callq 0x2d8a0
movq 0x20(%rsp), %rax
movl $0x1, 0xa80(%rax)
movq %rax, %rdi
addq $0xaa0, %rdi            # imm = 0xAA0
movl 0x3c(%rax), %esi
addl $0x1, %esi
callq 0x2d8c0
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0xb00, %rdi            # imm = 0xB00
movl 0x3c(%rax), %esi
callq 0x2d8c0
movl $0x0, 0x40(%rsp)
movq 0x20(%rsp), %rcx
movl 0x40(%rsp), %eax
cmpl 0x3c(%rcx), %eax
jge 0x2b050
movq 0x20(%rsp), %rax
addq $0xa88, %rax            # imm = 0xA88
movq %rax, 0x8(%rsp)
movl $0xf8, %edi
callq 0x43b0
movq 0x20(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x2d950
jmp 0x2b010
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x2d920
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x2afd1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x4360
jmp 0x2b055
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4660
nop
// File: tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::set_ponder(bool)
void AgentMCTS::set_ponder(bool p){
	if(ponder != p){
		ponder = p;
		stop_threads();

		if(ponder)
			start_threads();
	}
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb 0x38(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0xf(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x2b458
movq (%rsp), %rdi
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x38(%rdi)
callq 0x2aaa0
movq (%rsp), %rax
testb $0x1, 0x38(%rax)
je 0x2b456
movq (%rsp), %rdi
callq 0x2ab40
jmp 0x2b458
addq $0x18, %rsp
retq
nopl (%rax)
// File: tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::set_board(Board const&, bool)
void AgentMCTS::set_board(const Board & board, bool clear){
	stop_threads();

	nodes -= root.dealloc(ctmem);
	root = Node();
	root.exp.addwins(visitexpand+1);

	rootboard = board;

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

	if(ponder)
		start_threads();
}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2aaa0
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0xa8, %rdi
movq %rdi, 0x8(%rsp)
addq $0xf0, %rsi
callq 0x2d7c0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0xd0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xd0(%rax)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2d560
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2db10
jmp 0x2b4de
leaq 0x28(%rsp), %rdi
callq 0x2d750
movq (%rsp), %rax
movq %rax, %rdi
addq $0xa8, %rdi
movl 0x68(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x2dbd0
movq (%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x80, %rdi
movl $0x28, %edx
callq 0x4300
movq (%rsp), %rdi
callq 0x2ae80
movq (%rsp), %rax
testb $0x1, 0x38(%rax)
je 0x2b557
movq (%rsp), %rdi
callq 0x2ab40
jmp 0x2b557
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2d750
jmp 0x2b55c
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::gamelen() const
double AgentMCTS::gamelen() const {
	DepthStats len;
	for(unsigned int i = 0; i < threads.size(); i++)
		len += threads[i]->gamelen;
	return len.avg();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2cfa0
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0xa88, %rdi            # imm = 0xA88
callq 0x2cd30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2bc64
movq 0x10(%rsp), %rdi
addq $0xa88, %rdi            # imm = 0xA88
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x2ddb0
movq (%rax), %rsi
addq $0x98, %rsi
leaq 0x20(%rsp), %rdi
callq 0x2cfb0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2bc05
leaq 0x20(%rsp), %rdi
callq 0x2ddd0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xcea0
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, 0x48(%rsp)
subq $-0x80, %rdi
callq 0x17190
movb %al, 0x2b(%rsp)
jmp 0x2bcd1
movb 0x2b(%rsp), %al
movb %al, 0x47(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x48(%rsp)
movb %al, 0xf(%rsp)
je 0x2bd05
movq 0x48(%rsp), %rdi
addq $0x20, %rdi
callq 0x2d520
movb %al, 0xe(%rsp)
jmp 0x2bcfb
movb 0xe(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2bd12
jmp 0x2bd9a
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movsbl 0x47(%rsp), %edx
xorl %ecx, %ecx
callq 0x2be00
movl %eax, 0x8(%rsp)
jmp 0x2bd2e
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
movw %ax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x17300
jmp 0x2bd48
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x2c210
movq %rax, (%rsp)
jmp 0x2bd62
movq (%rsp), %rax
movq %rax, 0x48(%rsp)
movsbl 0x47(%rsp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, 0x47(%rsp)
jmp 0x2bcd9
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xfb50
jmp 0x2bdf3
movq 0x10(%rsp), %rdi
callq 0xd020
cmpq $0x0, %rax
jne 0x2bdd3
leaq 0x2c(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x8, %edx
callq 0x16890
jmp 0x2bdc0
movq 0x10(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x2de20
jmp 0x2bdd1
jmp 0x2bdd3
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x2bde9
movq 0x10(%rsp), %rdi
callq 0xfb50
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4660
nopl (%rax)
// File: tewalds[P]pentagod/agentmcts.cpp
// Function: AgentMCTS::find_child(AgentMCTS::Node const*, Move const&) const
AgentMCTS::Node * AgentMCTS::find_child(const Node * node, const Move & move) const {
	for(Node * i = node->children.begin(); i != node->children.end(); i++)
		if(i->move == move)
			return i;

	return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x2dc40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x2dc90
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x2c292
movq 0x10(%rsp), %rdi
addq $0x14, %rdi
movq 0x18(%rsp), %rsi
callq 0x285a0
testb $0x1, %al
jne 0x2c274
jmp 0x2c280
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2c29b
jmp 0x2c282
movq 0x10(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
jmp 0x2c236
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/./agentmcts.h
// Function: AgentMCTS::MCTSThread::reset()
void reset(){
			treelen.reset();
			gamelen.reset();
			use_explore = false;
			for(int a = 0; a < 4; a++)
				times[a] = 0;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x78, %rdi
callq 0x2e890
movq (%rsp), %rdi
addq $0x98, %rdi
callq 0x2e890
movq (%rsp), %rax
movb $0x0, 0x48(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x2cdd5
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0xb8(%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2cdab
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]pentagod/./board.h
// Function: Board::undo(Move const&)
bool undo(const Move & m) {
		if(valid_move(m))
			return false;

		if(m == M_SWAP){
			swap(sides[1], sides[2]);
			to_play = 1;
			return true;
		}

		to_play = 3 - to_play;
		nummoves--;

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

		sides[to_play] &= ~xybits[m.l];

		sides[0] = sides[1] | sides[2];

		outcome = -4;
		cached_score = default_score;
		cached_hash = 0;
		orientation = 8;

		return true;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x30(%rsp), %rsi
callq 0xd7f0
testb $0x1, %al
jne 0x2e658
jmp 0x2e662
movb $0x0, 0x47(%rsp)
jmp 0x2e7e4
movq 0x30(%rsp), %rdi
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
leaq 0x2c(%rsp), %rsi
callq 0xd870
testb $0x1, %al
jne 0x2e67f
jmp 0x2e6a7
movq 0x20(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x10, %rsi
callq 0xd8a0
movq 0x20(%rsp), %rax
movb $0x1, 0x19(%rax)
movb $0x1, 0x47(%rsp)
jmp 0x2e7e4
movq 0x20(%rsp), %rax
movzbl 0x19(%rax), %edx
movl $0x3, %ecx
subl %edx, %ecx
movb %cl, 0x19(%rax)
movb 0x18(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x18(%rax)
movq 0x30(%rsp), %rdi
callq 0xd8e0
cmpl $0x0, %eax
jne 0x2e72f
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd960
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0xd980
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd960
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0xd980
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2e788
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0xd960
movq (%rsp), %rdi
movl %eax, %esi
callq 0xd900
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd960
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xd900
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
movslq %ecx, %rdx
leaq 0x10796(%rip), %rcx     # 0x3ef40
movq (%rcx,%rdx,8), %rdx
xorq $-0x1, %rdx
movzbl 0x19(%rax), %ecx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rax), %rcx
orq 0x10(%rax), %rcx
movq %rcx, (%rax)
movb $-0x4, 0x1a(%rax)
movw $0xdead, 0x1c(%rax)     # imm = 0xDEAD
movq $0x0, 0x20(%rax)
movb $0x8, 0x1b(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: tewalds[P]pentagod/./compacttree.h
// Function: CompactTree<AgentMCTS::Node>::dealloc(CompactTree<AgentMCTS::Node>::Data*)
void dealloc(Data * d){
		assert(!d->empty() && d->capacity > 0 && d->capacity < MAX_NUM);

		unsigned int size = d->memsize();
		PLUS(memused, -size);

		//call the destructor
		d->~Data();
		d->used = 0;

		//add to the freelist
		freelist.push(d);
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x2ed70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x2ece7
movq 0x18(%rsp), %rax
movzwl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jle 0x2ece7
movq 0x18(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x12c, %eax            # imm = 0x12C
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2ecf1
jmp 0x2ecf3
jmp 0x2ed12
leaq 0x11d52(%rip), %rdi     # 0x40a4c
leaq 0xf398(%rip), %rsi      # 0x3e099
movl $0x167, %edx            # imm = 0x167
leaq 0x11d77(%rip), %rcx     # 0x40a84
callq 0x4250
movq 0x18(%rsp), %rdi
callq 0x2ed90
movq (%rsp), %rdi
movl %eax, 0x14(%rsp)
addq $0x988, %rdi            # imm = 0x988
xorl %eax, %eax
subl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x2edb0
movq 0x18(%rsp), %rdi
callq 0x2ede0
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movw $0x0, 0x6(%rax)
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x2ee70
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2f11c
jmp 0x2f13b
leaq 0x11aaf(%rip), %rdi     # 0x40bd2
leaq 0x11a15(%rip), %rsi     # 0x40b3f
movl $0x5d, %edx
leaq 0x11aae(%rip), %rcx     # 0x40be4
callq 0x4250
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rdi
callq 0x2f6a0
movq 0x10(%rsp), %rcx
movb $0x1, 0x8(%rcx)
xorl %eax, %eax
movl %eax, %esi
leaq 0x58e(%rip), %rdx       # 0x2f6f0
movq %rcx, %rdi
callq 0x46c0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rax), %rax
testb $0x1, 0x48(%rax)
je 0x3157f
leaq 0x48(%rsp), %rdi
callq 0x5500
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0xd8(%rax)
movl $0x0, 0x70(%rax)
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x50, %rdi
movq 0x40(%rax), %rsi
addq $0x80, %rsi
callq 0x32a10
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
addq $0xa8, %rdi
callq 0x32a40
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
addq $0x80, %rsi
leaq 0x20(%rsp), %rdi
movl $0x28, %edx
callq 0x4300
movq 0x10(%rsp), %rdi
movq 0x40(%rdi), %rdx
addq $0xa8, %rdx
leaq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x31730
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0xa8, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, %rcx
addq $0x50, %rcx
movq %rcx, (%rsp)
movq 0x40(%rax), %rdi
addq $0x80, %rdi
callq 0x17190
movq (%rsp), %rdi
movzbl %al, %eax
movl $0x3, %esi
subl %eax, %esi
callq 0x32ac0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32a60
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0x48(%rax)
je 0x31721
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0xd8, %rdi
addq $0x8, %rdi
addq $0xd8, %rsi
callq 0x116e0
movq 0x10(%rsp), %rsi
vaddsd 0xb8(%rsi), %xmm0, %xmm0
vmovsd %xmm0, 0xb8(%rsi)
movq %rsi, %rdi
addq $0xd8, %rdi
addq $0x10, %rdi
addq $0xd8, %rsi
addq $0x8, %rsi
callq 0x116e0
movq 0x10(%rsp), %rsi
vaddsd 0xc0(%rsi), %xmm0, %xmm0
vmovsd %xmm0, 0xc0(%rsi)
movq %rsi, %rdi
addq $0xd8, %rdi
addq $0x18, %rdi
addq $0xd8, %rsi
addq $0x10, %rsi
callq 0x116e0
movq 0x10(%rsp), %rax
vaddsd 0xc8(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0xc8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x5500
movq 0x10(%rsp), %rsi
addq $0xd8, %rsi
addq $0x18, %rsi
leaq 0x18(%rsp), %rdi
callq 0x116e0
movq 0x10(%rsp), %rax
vaddsd 0xd0(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0xd0(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movl %edx, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15fb0
movsbl %al, %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, %eax
jge 0x32927
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x33080
jmp 0x32900
movq 0x10(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x16e90
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x32b70
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
movl 0x18(%rsp), %esi
callq 0x32b00
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]pentagod/./agentmcts.h
// Function: AgentMCTS::MoveList::finishrollout(int)
void finishrollout(int won){
			exp[0].addloss();
			exp[1].addloss();
			if(won == 0){
				exp[0].addtie();
				exp[1].addtie();
			}else{
				exp[won-1].addwin();
			}
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x33260
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x33260
cmpl $0x0, 0xc(%rsp)
jne 0x32b47
movq (%rsp), %rdi
callq 0x33280
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x33280
jmp 0x32b60
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
cltq
shlq $0x4, %rax
addq %rax, %rdi
callq 0x332a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]pentagod/./agentmcts.h
// Function: AgentMCTS::Node::value(bool, float)
float value(bool knowledge, float fpurgency){
			float val = fpurgency;
			float expnum = exp.num();

			if(expnum > 0)
				val = exp.avg();

			if(knowledge && know != 0){
				if(expnum <= 1)
					val += 0.01f * know;
				else if(expnum < 1000) //knowledge is only useful with little experience
					val += 0.01f * know / sqrt(expnum);
			}

			return val;
		}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
vmovss %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
vmovss 0x18(%rsp), %xmm0
vmovss %xmm0, 0x14(%rsp)
callq 0x2e5d0
vcvtusi2ss %rax, %xmm0, %xmm0
vmovss %xmm0, 0x10(%rsp)
vmovss 0x10(%rsp), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jbe 0x32e4f
movq 0x8(%rsp), %rdi
callq 0x2e600
vmovss %xmm0, 0x14(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x32efc
movq 0x8(%rsp), %rax
movswl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x32efc
vmovss 0xd714(%rip), %xmm0     # 0x40588
vucomiss 0x10(%rsp), %xmm0
jb 0x32ea4
movq 0x8(%rsp), %rax
movswl 0x10(%rax), %eax
vcvtsi2ss %eax, %xmm0, %xmm1
vmovss 0x14(%rsp), %xmm2
vmovss 0xe181(%rip), %xmm0     # 0x41018
vfmadd213ss %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovss %xmm0, 0x14(%rsp)
jmp 0x32efa
vmovss 0xe168(%rip), %xmm0     # 0x41014
vucomiss 0x10(%rsp), %xmm0
jbe 0x32ef8
movq 0x8(%rsp), %rax
movswl 0x10(%rax), %eax
vcvtsi2ss %eax, %xmm0, %xmm1
vmovss 0xe14f(%rip), %xmm0     # 0x41018
vmulss %xmm1, %xmm0, %xmm0
vmovss %xmm0, 0x4(%rsp)
vmovss 0x10(%rsp), %xmm0
callq 0x32f10
vmovaps %xmm0, %xmm1
vmovss 0x4(%rsp), %xmm0
vdivss %xmm1, %xmm0, %xmm0
vaddss 0x14(%rsp), %xmm0, %xmm0
vmovss %xmm0, 0x14(%rsp)
jmp 0x32efa
jmp 0x32efc
vmovss 0x14(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
movw $0x0, -0xa(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
cmpl $0x20, -0x24(%rsp)
jge 0x3304c
movslq -0x24(%rsp), %rcx
leaq 0xc0c9(%rip), %rax      # 0x3f070
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
andq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x20(%rsp), %rax
andq -0x30(%rsp), %rax
movq %rax, -0x40(%rsp)
cmpq $0x0, -0x38(%rsp)
je 0x33004
cmpq $0x0, -0x40(%rsp)
jne 0x33004
movq -0x38(%rsp), %rax
popcntq %rax, %rax
movslq %eax, %rcx
leaq 0xc06e(%rip), %rax      # 0x3f060
movswl (%rax,%rcx,2), %ecx
movswl -0xa(%rsp), %eax
addl %ecx, %eax
movw %ax, -0xa(%rsp)
jmp 0x3303a
cmpq $0x0, -0x38(%rsp)
jne 0x33038
cmpq $0x0, -0x40(%rsp)
je 0x33038
movq -0x40(%rsp), %rax
popcntq %rax, %rax
movslq %eax, %rcx
leaq 0xc038(%rip), %rax      # 0x3f060
movswl (%rax,%rcx,2), %ecx
movswl -0xa(%rsp), %eax
subl %ecx, %eax
movw %ax, -0xa(%rsp)
jmp 0x3303a
jmp 0x3303c
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x32f90
movq -0x48(%rsp), %rax
movzbl 0x19(%rax), %eax
cmpl $0x1, %eax
jne 0x33069
movswl -0xa(%rsp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4c(%rsp)
jmp 0x33072
movswl -0xa(%rsp), %eax
movl %eax, -0x4c(%rsp)
movl -0x4c(%rsp), %eax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
xorq $-0x1, %rax
movabsq $0xfffffffff, %rcx      # imm = 0xFFFFFFFFF
andq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x332e0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
andq 0x28(%rsp), %rax
cmpq $0x0, %rax
jbe 0x330df
movq 0x28(%rsp), %rax
andq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x330e1
movq 0x30(%rsp), %rax
movq 0x30(%rsp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x330b1
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rdx
movzbl 0x19(%rax), %ecx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
shrq $0x24, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $0x4, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
andq $0x3, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3317f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0xd900
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0xd900
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x331bc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0xd980
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0xd980
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
orq 0x10(%rax), %rcx
movq %rcx, (%rax)
movb 0x18(%rax), %cl
addb $0x1, %cl
movb %cl, 0x18(%rax)
movzbl 0x19(%rax), %edx
movl $0x3, %ecx
subl %edx, %ecx
movb %cl, 0x19(%rax)
movb $-0x4, 0x1a(%rax)
movw $0xdead, 0x1c(%rax)     # imm = 0xDEAD
movq $0x0, 0x20(%rax)
movb $0x8, 0x1b(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]pentagod/./xorshift.h
// Function: XORShift_uint64::rand()
uint64_t rand(){
		r ^= (r >> 17);
		r ^= (r << 31);
		r ^= (r >>  8);
		return r;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
shrq $0x11, %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
shlq $0x1f, %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
shrq $0x8, %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
vmovsd %xmm0, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
callq 0x15fb0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x3390a
jmp 0x33a47
movq 0x18(%rsp), %rdi
callq 0x33a60
movq 0x18(%rsp), %rax
movb $0x0, 0x8(%rax)
vmovsd 0x98(%rsp), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x59, 0x40(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x35ae0
movq (%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35b20
vmovsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x35bd0
jmp 0x33988
leaq 0x68(%rsp), %rdi
callq 0x114c0
movq 0x18(%rsp), %rdi
addq $0xa10, %rdi            # imm = 0xA10
callq 0x2c5d0
jmp 0x339a5
movq 0x18(%rsp), %rdi
addq $0x9f0, %rdi            # imm = 0x9F0
movl $0x6, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x24(%rsp), %rdx
callq 0x35c60
jmp 0x339d2
movq 0x18(%rsp), %rax
movl 0x9f0(%rax), %eax
cmpl $0x1, %eax
jne 0x339e4
jmp 0x33a3a
leaq 0xccc6(%rip), %rdi      # 0x406b1
leaq 0xd97a(%rip), %rsi      # 0x4136c
movl $0x14, %edx
leaq 0xd97b(%rip), %rcx      # 0x41379
callq 0x4250
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x114c0
jmp 0x33a4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x2d540
jmp 0x33a4f
leaq 0x88(%rsp), %rdi
callq 0x2d540
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4660
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x9f0(%rax), %eax
cmpl $0x1, %eax
jne 0x34ff0
jmp 0x3500f
leaq 0xb6ba(%rip), %rdi      # 0x406b1
leaq 0xc36e(%rip), %rsi      # 0x4136c
movl $0x76, %edx
leaq 0xc400(%rip), %rcx      # 0x4140a
callq 0x4250
movq 0x20(%rsp), %rdi
addq $0x9f0, %rdi            # imm = 0x9F0
movl $0x1, 0x4c(%rsp)
movl $0x2, 0x48(%rsp)
leaq 0x4c(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x35c60
testb $0x1, %al
jne 0x35040
jmp 0x35042
jmp 0x35061
leaq 0xb863(%rip), %rdi      # 0x408ac
leaq 0xc31c(%rip), %rsi      # 0x4136c
movl $0x79, %edx
leaq 0xc3ae(%rip), %rcx      # 0x4140a
callq 0x4250
movq 0x20(%rsp), %rdi
addq $0xa10, %rdi            # imm = 0xA10
callq 0x2c5d0
movl $0x0, 0x44(%rsp)
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0x9f8, %rdi            # imm = 0x9F8
callq 0x36300
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x350cd
movq 0x20(%rsp), %rdi
addq $0x9f8, %rdi            # imm = 0x9F8
movl 0x44(%rsp), %eax
movl %eax, %esi
callq 0x36320
movq (%rax), %rdi
callq 0x36340
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3507a
movq 0x20(%rsp), %rdi
addq $0x9f8, %rdi            # imm = 0x9F8
callq 0x36360
movq 0x20(%rsp), %rax
movl $0x1, 0x9f0(%rax)
movq %rax, %rdi
addq $0xa10, %rdi            # imm = 0xA10
movl 0xadc(%rax), %esi
addl $0x1, %esi
callq 0x2d8c0
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0xa70, %rdi            # imm = 0xA70
movl 0xadc(%rax), %esi
callq 0x2d8c0
movl $0x0, 0x40(%rsp)
movq 0x20(%rsp), %rcx
movl 0x40(%rsp), %eax
cmpl 0xadc(%rcx), %eax
jge 0x351a9
movq 0x20(%rsp), %rax
addq $0x9f8, %rax            # imm = 0x9F8
movq %rax, 0x8(%rsp)
movl $0x48, %edi
callq 0x43b0
movq 0x20(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x363b0
jmp 0x35169
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x36380
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x35127
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x4360
jmp 0x351ae
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4660
nopl (%rax,%rax)
// File: tewalds[P]pentagod/agentpns.cpp
// Function: AgentPNS::find_child(AgentPNS::Node const*, Move const&) const
AgentPNS::Node * AgentPNS::find_child(const Node * node, const Move & move) const {
	for(Node * i = node->children.begin(); i != node->children.end(); i++)
		if(i->move == move)
			return i;

	return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x369f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x36a40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x357a2
movq 0x10(%rsp), %rdi
addq $0x14, %rdi
movq 0x18(%rsp), %rsi
callq 0x285a0
testb $0x1, %al
jne 0x35784
jmp 0x35790
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x357ab
jmp 0x35792
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
jmp 0x35746
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movl $0xfffffffc, 0x7c(%rsp) # imm = 0xFFFFFFFC
movq 0x88(%rsp), %rdi
callq 0x17190
movzbl %al, %eax
movl %eax, 0x78(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15b10
leaq 0x28(%rsp), %rdi
callq 0x15c80
xorb $-0x1, %al
testb $0x1, %al
jne 0x365c7
movl $0x2, 0x24(%rsp)
jmp 0x36682
movq 0x80(%rsp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x32d50
movq %rax, 0x8(%rsp)
jmp 0x365e6
movq 0x8(%rsp), %rdi
callq 0x15fb0
movb %al, 0x7(%rsp)
jmp 0x365f6
movb 0x7(%rsp), %al
movsbl %al, %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x78(%rsp), %eax
jne 0x3663a
movl 0x20(%rsp), %eax
movl %eax, 0x94(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x36682
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x15e30
jmp 0x366b1
cmpl $0x0, 0x20(%rsp)
jne 0x3664b
movl $0x0, 0x7c(%rsp)
jmp 0x3666d
movl 0x7c(%rsp), %eax
movl $0x3, %ecx
subl 0x78(%rsp), %ecx
cmpl %ecx, %eax
je 0x36663
cmpl $-0x4, 0x7c(%rsp)
jne 0x3666b
movl 0x20(%rsp), %eax
movl %eax, 0x7c(%rsp)
jmp 0x3666d
jmp 0x3666f
jmp 0x36671
leaq 0x28(%rsp), %rdi
callq 0x15cb0
jmp 0x3667d
jmp 0x365aa
leaq 0x28(%rsp), %rdi
callq 0x15e30
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x366a2
jmp 0x36697
movl 0x7c(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x4660
nopl (%rax,%rax)
// File: tewalds[P]pentagod/./agentpns.h
// Function: AgentPNS::Node::outcome(int, int, int, int)
Node & outcome(int outcome, int toplay, int assign, int value = 1){
			if(assign && outcome == 0)
				outcome = assign;

			if(     outcome == -3)       { phi = value; delta = value; }
			else if(outcome ==   toplay) { phi = LOSS;  delta = 0;     }
			else if(outcome == 3-toplay) { phi = 0;     delta = LOSS; }
			else /*(outcome == 0)*/      { phi = 0;     delta = DRAW; }
			return *this;
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0x36746
cmpl $0x0, -0xc(%rsp)
jne 0x36746
movl -0x14(%rsp), %eax
movl %eax, -0xc(%rsp)
cmpl $-0x3, -0xc(%rsp)
jne 0x36761
movq -0x20(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, (%rax)
movl -0x18(%rsp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x367ba
movl -0xc(%rsp), %eax
cmpl -0x10(%rsp), %eax
jne 0x3677f
movq -0x20(%rsp), %rax
movl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
movl $0x0, 0x4(%rax)
jmp 0x367b8
movl -0xc(%rsp), %eax
movl $0x3, %ecx
subl -0x10(%rsp), %ecx
cmpl %ecx, %eax
jne 0x367a4
movq -0x20(%rsp), %rax
movl $0x0, (%rax)
movl $0x3fffffff, 0x4(%rax)  # imm = 0x3FFFFFFF
jmp 0x367b6
movq -0x20(%rsp), %rax
movl $0x0, (%rax)
movl $0x3ffffffe, 0x4(%rax)  # imm = 0x3FFFFFFE
jmp 0x367b8
jmp 0x367ba
movq -0x20(%rsp), %rax
retq
// File: tewalds[P]pentagod/./agentpns.h
// Function: AgentPNS::Node::to_outcome(int) const
int to_outcome(int toplay) const {
			if(phi   == LOSS) return toplay;
			if(delta == LOSS) return 3 - toplay;
			if(delta == DRAW) return 0;
			return -3;
		}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
jne 0x36fb5
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x36ff2
movq -0x20(%rsp), %rax
cmpl $0x3fffffff, 0x4(%rax)  # imm = 0x3FFFFFFF
jne 0x36fd2
movl $0x3, %eax
subl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x36ff2
movq -0x20(%rsp), %rax
cmpl $0x3ffffffe, 0x4(%rax)  # imm = 0x3FFFFFFE
jne 0x36fea
movl $0x0, -0x4(%rsp)
jmp 0x36ff2
movl $0xfffffffd, -0x4(%rsp) # imm = 0xFFFFFFFD
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x18afe(%rip), %rax     # 0x4fbb8
movq %rax, (%rdi)
callq 0x34f30
jmp 0x370c4
movq 0x8(%rsp), %rdi
movl $0x0, 0xadc(%rdi)
callq 0x34fd0
jmp 0x370da
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0xae0, %rdi            # imm = 0xAE0
addq $0x50, %rsi
callq 0x37000
jmp 0x370f4
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
vpxor %xmm1, %xmm1, %xmm1
vmovaps %xmm1, %xmm0
callq 0x35cf0
jmp 0x3710c
movq 0x8(%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
callq 0x163b0
movq 0x8(%rsp), %rdi
addq $0xa70, %rdi            # imm = 0xA70
callq 0x16420
movq 0x8(%rsp), %rdi
addq $0xa10, %rdi            # imm = 0xA10
callq 0x16420
movq 0x8(%rsp), %rdi
addq $0x9f8, %rdi            # imm = 0x9F8
callq 0x16480
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x164e0
movq 0x8(%rsp), %rdi
callq 0x16560
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xb570
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
addq $0x10, %rdi
movl $0x28, %edx
callq 0x4300
movq 0x8(%rsp), %rdi
callq 0x16380
testb $0x1, 0x17(%rsp)
je 0x3724f
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x8(%rsp), %rdi
callq 0x34fd0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movl %edx, 0xbc(%rsp)
movq 0xc8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0xc0(%rsp), %rsi
callq 0x3aee0
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x3b3f2
movq 0xb0(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xd4(%rsp)
jmp 0x3b572
movl $0xffff8001, 0xac(%rsp) # imm = 0xFFFF8001
leaq 0xd4(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x8, %edx
callq 0x16890
movq 0xc0(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15b10
leaq 0x58(%rsp), %rdi
callq 0x15c80
movb %al, 0x2f(%rsp)
jmp 0x3b43b
movb 0x2f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b471
leaq 0x58(%rsp), %rdi
callq 0x15e30
jmp 0x3b570
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x15e30
jmp 0x3b581
leaq 0x58(%rsp), %rdi
callq 0x32d50
movq %rax, 0x20(%rsp)
jmp 0x3b482
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x3aee0
movq %rax, 0x18(%rsp)
jmp 0x3b498
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x3b4f1
movl 0xac(%rsp), %eax
movq 0x40(%rsp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x3b4ef
movq 0x40(%rsp), %rax
movswl 0x8(%rax), %eax
movl %eax, 0xac(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x32cd0
movq %rax, 0x10(%rsp)
jmp 0x3b4df
movq 0x10(%rsp), %rax
movw (%rax), %ax
movw %ax, 0xd4(%rsp)
jmp 0x3b55d
xorl %eax, %eax
cmpl $0xffff8001, 0xac(%rsp) # imm = 0xFFFF8001
movb %al, 0xf(%rsp)
jne 0x3b52e
movl $0xfffffffe, 0x3c(%rsp) # imm = 0xFFFFFFFE
leaq 0xd4(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0xd870
movb %al, 0xe(%rsp)
jmp 0x3b524
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
jmp 0x3b52e
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3b538
jmp 0x3b55b
leaq 0x38(%rsp), %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
movl $0x8, %edx
callq 0x16890
jmp 0x3b54e
movw 0x38(%rsp), %ax
movw %ax, 0xd4(%rsp)
jmp 0x3b55d
jmp 0x3b55f
leaq 0x58(%rsp), %rdi
callq 0x15cb0
jmp 0x3b56b
jmp 0x3b42b
jmp 0x3b572
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x4660
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x77(%rsp)
callq 0xcea0
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
leaq 0x48(%rsp), %rdi
movl $0x28, %edx
callq 0x4300
movl $0x14, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x44(%rsp)
cmpl $0x0, %eax
je 0x3b6fb
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x3b390
movl %eax, 0x4(%rsp)
jmp 0x3b612
movl 0x4(%rsp), %eax
movw %ax, 0x40(%rsp)
movl $0xfffffffc, 0x30(%rsp) # imm = 0xFFFFFFFC
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd870
movb %al, 0x3(%rsp)
jmp 0x3b638
movb 0x3(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x2(%rsp)
jne 0x3b670
jmp 0x3b649
movl $0xfffffffe, 0x2c(%rsp) # imm = 0xFFFFFFFE
leaq 0x40(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0xd870
movb %al, 0x1(%rsp)
jmp 0x3b666
movb 0x1(%rsp), %al
movb %al, 0x2(%rsp)
jmp 0x3b670
movb 0x2(%rsp), %al
testb $0x1, %al
jne 0x3b67a
jmp 0x3b699
jmp 0x3b6fb
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xfb50
jmp 0x3b757
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x17300
jmp 0x3b6aa
movl 0x40(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0xd040
movb %al, (%rsp)
jmp 0x3b6c5
movb (%rsp), %al
andb $0x1, %al
movb %al, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
je 0x3b6d7
jmp 0x3b6f6
leaq 0x2b5d(%rip), %rdi      # 0x3e23b
leaq 0x62bf(%rip), %rsi      # 0x419a4
movl $0xb2, %edx
leaq 0x630e(%rip), %rcx      # 0x419ff
callq 0x4250
jmp 0x3b5e5
movq 0x8(%rsp), %rdi
callq 0xd020
cmpq $0x0, %rax
jne 0x3b734
leaq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x8, %edx
callq 0x16890
jmp 0x3b721
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2de20
jmp 0x3b732
jmp 0x3b734
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x3b74a
movq 0x8(%rsp), %rdi
callq 0xfb50
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4660
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/agentab.cpp
// Function: mix_bits(unsigned long)
uint64_t mix_bits(uint64_t h){
	h ^= (h >> 17);
	h ^= (h << 31);
	h ^= (h >>  8);
	return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x11, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x1f, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]pentagod/./agentab.h
// Function: AgentAB::reset()
void reset(){
		timeout = false;
		maxdepth = 0;
		nodes_seen = 0;
		time_used = 0;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movl $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x60(%rax)
retq
nopw (%rax,%rax)
// File: tewalds[P]pentagod/./agentab.h
// Function: AgentAB::clear_mem()
void clear_mem(){
		reset();
		if(TT){
			delete[] TT;
			TT = NULL;
		}
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3b870
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x3c0fd
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3c0f0
movq (%rsp), %rdi
callq 0x44a0
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]pentagod/./xorshift.h
// Function: XORShift_uint32::rand()
uint32_t rand(){
		r ^= (r << 13);
		r ^= (r >> 17);
		r ^= (r <<  5);
		return r;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
shll $0xd, %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
shrl $0x11, %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
shll $0x5, %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
movl (%rax), %eax
retq
nopl (%rax,%rax)