LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::create_children_simple(Morat::Hex::Board const&, Morat::Hex::AgentMCTS::Node*)
void AgentMCTS::create_children_simple(const Board & board, Node * node){
	assert(node->children.empty());

	node->children.alloc(board.moves_avail(), ctmem);

	Node * child = node->children.begin();
	for (auto move : board) {
		*child++ = Node(move);
	}
	assert(child == node->children.end());
	PLUS(nodes, node->children.num());
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xd0(%rsp), %rdi
addq $0x28, %rdi
callq 0x1b500
testb $0x1, %al
jne 0x199c3
jmp 0x199c5
jmp 0x199e4
leaq 0x33a7e(%rip), %rdi     # 0x4d44a
leaq 0x33a14(%rip), %rsi     # 0x4d3e7
movl $0x189, %edx            # imm = 0x189
leaq 0x33ae0(%rip), %rcx     # 0x4d4bf
callq 0x52a0
movq 0xd0(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x1d310
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rdi
movl %eax, %esi
addq $0x4130, %rdx           # imm = 0x4130
callq 0x1d2a0
movq 0xd0(%rsp), %rdi
addq $0x28, %rdi
callq 0x1c340
movq %rax, 0xc8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x1d370
movq %rdx, 0xa8(%rsp)
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq 0xa5(%rsp), %rcx
movq %rcx, 0xb5(%rsp)
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x1d3a0
movq %rdx, 0x88(%rsp)
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x90(%rsp)
movl 0x88(%rsp), %eax
movl %eax, 0x98(%rsp)
movb 0x8c(%rsp), %al
movb %al, 0x9c(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1d3f0
testb $0x1, %al
jne 0x19ae7
jmp 0x19b7c
leaq 0xb0(%rsp), %rdi
callq 0x1d420
movl (%rax), %eax
movl %eax, 0x7c(%rsp)
leaq 0x539bf(%rip), %rax     # 0x6d4c0
movb (%rax), %al
movb %al, 0x47(%rsp)
movzbl 0x47(%rsp), %edx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x7c(%rsp), %rsi
callq 0x1d430
movq 0x18(%rsp), %rsi
movq 0xc8(%rsp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0xc8(%rsp)
callq 0x1c1d0
jmp 0x19b43
leaq 0x48(%rsp), %rdi
callq 0x1bab0
leaq 0xb0(%rsp), %rdi
callq 0x1d4b0
jmp 0x19ac9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1bab0
jmp 0x19c04
movq 0xc8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
addq $0x28, %rdi
callq 0x1c390
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x19ba9
jmp 0x19bc8
leaq 0x33959(%rip), %rdi     # 0x4d509
leaq 0x33830(%rip), %rsi     # 0x4d3e7
movl $0x191, %edx            # imm = 0x191
leaq 0x338fc(%rip), %rcx     # 0x4d4bf
callq 0x52a0
movq 0x28(%rsp), %rax
addq $0x4110, %rax           # imm = 0x4110
movq %rax, 0x8(%rsp)
movq 0xd0(%rsp), %rdi
addq $0x28, %rdi
callq 0x1a560
movq 0x8(%rsp), %rdi
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x1d5c0
addq $0xe8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x5760
nop
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::load_sgf(Morat::SGFParser<Morat::Move>&, Morat::Hex::Board const&, Morat::Hex::AgentMCTS::Node&)
void AgentMCTS::load_sgf(SGFParser<Move> & sgf, const Board & board, Node & node) {
	assert(sgf.has_children());
	create_children_simple(board, & node);

	while(sgf.next_child()){
		Move m = sgf.move();
		Node & child = *find_child(&node, m);
		child.from_s(sgf.comment());
		if(sgf.done_child()){
			continue;
		}else{
			// has children!
			Board b = board;
			b.move(m);
			load_sgf(sgf, b, child);
			assert(sgf.done_child());
		}
	}
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x1d5f0
testb $0x1, %al
jne 0x19c57
jmp 0x19c59
jmp 0x19c78
leaq 0x338c7(%rip), %rdi     # 0x4d527
leaq 0x33780(%rip), %rsi     # 0x4d3e7
movl $0x196, %edx            # imm = 0x196
leaq 0x338c7(%rip), %rcx     # 0x4d53a
callq 0x52a0
movq 0x28(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x19980
movq 0xc8(%rsp), %rdi
callq 0x1d630
testb $0x1, %al
jne 0x19ca8
jmp 0x19e1c
movq 0xc8(%rsp), %rdi
callq 0x1d690
movq 0x28(%rsp), %rdi
movw %ax, 0xb6(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0xb6(%rsp), %rdx
callq 0x190a0
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1d9f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x155f0
jmp 0x19d17
leaq 0x88(%rsp), %rdi
callq 0x5260
movq 0xc8(%rsp), %rdi
callq 0x1dad0
testb $0x1, %al
jne 0x19d37
jmp 0x19d5f
jmp 0x19c92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x5260
jmp 0x19e24
movq 0xc0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x118b0
movq 0x10(%rsp), %rdi
leaq 0xb6(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x1c500
jmp 0x19d91
movq 0x28(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xa8(%rsp), %rcx
leaq 0x30(%rsp), %rdx
callq 0x19c10
jmp 0x19db2
movq 0xc8(%rsp), %rdi
callq 0x1dad0
movb %al, 0xf(%rsp)
jmp 0x19dc5
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x19dcf
jmp 0x19dd1
jmp 0x19e0d
leaq 0x337b1(%rip), %rdi     # 0x4d589
leaq 0x33608(%rip), %rsi     # 0x4d3e7
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x3374f(%rip), %rcx     # 0x4d53a
callq 0x52a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xc040
jmp 0x19e24
leaq 0x30(%rsp), %rdi
callq 0xc040
jmp 0x19c92
addq $0xd8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/move.h
// Function: Morat::Move::to_s[abi:cxx11]() const
std::string to_s() const {
		if(y == M_UNKNOWN) return "unknown";
		if(y == M_NONE)    return "none";
		if(y == M_SWAP)    return "swap";
		if(y == M_RESIGN)  return "resign";

		return std::string() + char(x + 'a') + to_str(y + 1);
	}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
movsbl (%rax), %eax
cmpl $-0x4, %eax
jne 0x1a01b
leaq 0xb7(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5770
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x335be(%rip), %rsi     # 0x4d59a
callq 0x5590
jmp 0x19fe3
leaq 0xb7(%rsp), %rdi
callq 0x5450
jmp 0x1a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb7(%rsp), %rdi
callq 0x5450
jmp 0x1a25a
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $-0x3, %eax
jne 0x1a08a
leaq 0xa3(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5770
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x33557(%rip), %rsi     # 0x4d5a2
callq 0x5590
jmp 0x1a052
leaq 0xa3(%rsp), %rdi
callq 0x5450
jmp 0x1a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xa3(%rsp), %rdi
callq 0x5450
jmp 0x1a25a
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x1a0f9
leaq 0xa2(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5770
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x334ed(%rip), %rsi     # 0x4d5a7
callq 0x5590
jmp 0x1a0c1
leaq 0xa2(%rsp), %rdi
callq 0x5450
jmp 0x1a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xa2(%rsp), %rdi
callq 0x5450
jmp 0x1a25a
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $-0x2, %eax
jne 0x1a168
leaq 0xa1(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5770
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x33483(%rip), %rsi     # 0x4d5ac
callq 0x5590
jmp 0x1a130
leaq 0xa1(%rsp), %rdi
callq 0x5450
jmp 0x1a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xa1(%rsp), %rdi
callq 0x5450
jmp 0x1a25a
leaq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x55a0
movq 0x38(%rsp), %rax
movq (%rsp), %rsi
movzbl 0x1(%rax), %eax
addl $0x61, %eax
movsbl %al, %edx
leaq 0x80(%rsp), %rdi
callq 0x14cf0
jmp 0x1a198
movq 0x38(%rsp), %rax
movsbl (%rax), %esi
incl %esi
leaq 0x40(%rsp), %rdi
callq 0x1a430
jmp 0x1a1ae
movq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x19e40
jmp 0x1a1c7
leaq 0x40(%rsp), %rdi
callq 0x5260
leaq 0x80(%rsp), %rdi
callq 0x5260
leaq 0x60(%rsp), %rdi
callq 0x5260
jmp 0x1a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x1a241
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x1a234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5260
leaq 0x80(%rsp), %rdi
callq 0x5260
leaq 0x60(%rsp), %rdi
callq 0x5260
jmp 0x1a25a
movq 0x30(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0x5760
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/move.h
// Function: Morat::Move::Move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Move(const std::string & str){
		if(     str == "swap"   ){ y = M_SWAP;    x = 120; }
		else if(str == "resign" ){ y = M_RESIGN;  x = 120; }
		else if(str == "none"   ){ y = M_NONE;    x = 120; }
		else if(str == "unknown"){ y = M_UNKNOWN; x = 120; }
		else{
			x = tolower(str[0]) - 'a';
			y = atoi(str.c_str() + 1) - 1;
		}
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x32fa4(%rip), %rsi     # 0x4d5a7
callq 0xb0f0
testb $0x1, %al
jne 0x1a60e
jmp 0x1a61e
movq (%rsp), %rax
movb $-0x1, (%rax)
movb $0x78, 0x1(%rax)
jmp 0x1a6d6
movq 0x8(%rsp), %rdi
leaq 0x32f82(%rip), %rsi     # 0x4d5ac
callq 0xb0f0
testb $0x1, %al
jne 0x1a635
jmp 0x1a645
movq (%rsp), %rax
movb $-0x2, (%rax)
movb $0x78, 0x1(%rax)
jmp 0x1a6d4
movq 0x8(%rsp), %rdi
leaq 0x32f51(%rip), %rsi     # 0x4d5a2
callq 0xb0f0
testb $0x1, %al
jne 0x1a65c
jmp 0x1a669
movq (%rsp), %rax
movb $-0x3, (%rax)
movb $0x78, 0x1(%rax)
jmp 0x1a6d2
movq 0x8(%rsp), %rdi
leaq 0x32f25(%rip), %rsi     # 0x4d59a
callq 0xb0f0
testb $0x1, %al
jne 0x1a680
jmp 0x1a68d
movq (%rsp), %rax
movb $-0x4, (%rax)
movb $0x78, 0x1(%rax)
jmp 0x1a6d0
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5470
movsbl (%rax), %edi
callq 0x55f0
movl %eax, %ecx
movq (%rsp), %rax
subl $0x61, %ecx
movb %cl, 0x1(%rax)
movq 0x8(%rsp), %rdi
callq 0x51a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x5680
movl %eax, %ecx
movq (%rsp), %rax
subl $0x1, %ecx
movb %cl, (%rax)
jmp 0x1a6d2
jmp 0x1a6d4
jmp 0x1a6d6
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/exppair.h
// Function: Morat::ExpPair::ExpPair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ExpPair(std::string str) {
		auto parts = explode(str, "/");
		assert(parts.size() == 2);
		n = from_str<uword>(parts[1]);
		s = 2.0*from_str<float>(parts[0])*n;
	}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5770
movq 0x20(%rsp), %rdx
leaq 0x32e92(%rip), %rsi     # 0x4d5b3
leaq 0x40(%rsp), %rdi
callq 0x5590
jmp 0x1a72d
movq 0x10(%rsp), %rsi
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
callq 0x48aa0
jmp 0x1a745
leaq 0x40(%rsp), %rdi
callq 0x5260
leaq 0x3f(%rsp), %rdi
callq 0x5450
leaq 0x60(%rsp), %rdi
callq 0x13c80
cmpq $0x2, %rax
jne 0x1a76b
jmp 0x1a7c1
leaq 0x32e43(%rip), %rdi     # 0x4d5b5
leaq 0x32e4e(%rip), %rsi     # 0x4d5c7
movl $0x19, %edx
leaq 0x32e57(%rip), %rcx     # 0x4d5dc
callq 0x52a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1a7b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5260
leaq 0x3f(%rsp), %rdi
callq 0x5450
jmp 0x1a85c
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0x13ca0
movq %rax, %rdi
callq 0x1dc80
movq %rax, 0x8(%rsp)
jmp 0x1a7df
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, %esi
leaq 0x60(%rsp), %rdi
callq 0x13ca0
movq %rax, %rdi
callq 0x1dd00
vmovss %xmm0, 0x4(%rsp)
jmp 0x1a80b
movq 0x18(%rsp), %rax
vmovss 0x4(%rsp), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vaddsd %xmm0, %xmm0, %xmm0
vcvtusi2sdq 0x8(%rax), %xmm1, %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vcvttsd2usi %xmm0, %rcx
movq %rcx, (%rax)
leaq 0x60(%rsp), %rdi
callq 0xe140
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xe140
movq 0x30(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/../lib/agentpool.h
// Function: Morat::AgentThreadPool<Morat::Hex::AgentMCTS>::pause()
void pause() { // pause the threads so they're waiting to be resumed
		if(thread_state != Thread_Wait_Start){
			timed_out();
			run_barrier.wait();
			CAS(thread_state, Thread_Wait_End, Thread_Wait_Start);
			assert(thread_state == Thread_Wait_Start);
		}
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl (%rax), %eax
cmpl $0x1, %eax
je 0x1a9a0
movq (%rsp), %rdi
callq 0x21ad0
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x21b40
movq (%rsp), %rdi
movl $0x6, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x21c20
movq (%rsp), %rax
movl (%rax), %eax
cmpl $0x1, %eax
jne 0x1a97f
jmp 0x1a99e
leaq 0x33385(%rip), %rdi     # 0x4dd0b
leaq 0x333a0(%rip), %rsi     # 0x4dd2d
movl $0x67, %edx
leaq 0x333ab(%rip), %rcx     # 0x4dd44
callq 0x52a0
jmp 0x1a9a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/agentpool.h
// Function: Morat::AgentThreadPool<Morat::Hex::AgentMCTS>::reset()
void reset() { // call the reset method on each thread
		//start and end with thread_state = Thread_Wait_Start
		assert(thread_state == Thread_Wait_Start);

		for(auto & t : threads)
			t->reset();

		assert(thread_state == Thread_Wait_Start);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
cmpl $0x1, %eax
jne 0x1aa9c
jmp 0x1aabb
leaq 0x33268(%rip), %rdi     # 0x4dd0b
leaq 0x33283(%rip), %rsi     # 0x4dd2d
movl $0x9c, %edx
leaq 0x332ee(%rip), %rcx     # 0x4dda4
callq 0x52a0
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21cb0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21ce0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x21d10
testb $0x1, %al
jne 0x1aafc
jmp 0x1ab25
leaq 0x20(%rsp), %rdi
callq 0x21d50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x20(%rsp), %rdi
callq 0x21d60
jmp 0x1aae7
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ab33
jmp 0x1ab52
leaq 0x331d1(%rip), %rdi     # 0x4dd0b
leaq 0x331ec(%rip), %rsi     # 0x4dd2d
movl $0xa1, %edx
leaq 0x33257(%rip), %rcx     # 0x4dda4
callq 0x52a0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/agentpool.h
// Function: Morat::AgentThreadPool<Morat::Hex::AgentMCTS>::resume()
void resume() { // let the threads run
		assert(thread_state == Thread_Wait_Start);
		run_barrier.wait();
		CAS(thread_state, Thread_Wait_Start, Thread_Running);
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ab7b
jmp 0x1ab9a
leaq 0x33189(%rip), %rdi     # 0x4dd0b
leaq 0x331a4(%rip), %rsi     # 0x4dd2d
movl $0x6c, %edx
leaq 0x3326f(%rip), %rcx     # 0x4de04
callq 0x52a0
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x21b40
movq (%rsp), %rdi
movl $0x1, 0xc(%rsp)
movl $0x3, 0x8(%rsp)
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x21c20
addq $0x18, %rsp
retq
nop
// File: tewalds[P]morat/hex/../lib/agentpool.h
// Function: Morat::AgentThreadPool<Morat::Hex::AgentMCTS>::wait_pause(double)
void wait_pause(double time) { // wait until they run out of time or otherwise finish
		Alarm timer;
		if(time > 0)
			timer(time, std::bind(&AgentThreadPool::timed_out, this));

		//wait for the timer to stop them or for them to hit the other stop conditions
		run_barrier.wait();
		CAS(thread_state, Thread_Wait_End, Thread_Wait_Start);
		assert(thread_state == Thread_Wait_Start);
	}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
vmovsd %xmm0, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x84(%rsp), %rdi
callq 0x21db0
vmovsd 0x88(%rsp), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jbe 0x1acc1
movq 0x10(%rsp), %rax
vmovsd 0x88(%rsp), %xmm0
vmovsd %xmm0, 0x8(%rsp)
leaq 0x6e9c(%rip), %rcx      # 0x21ad0
movq %rcx, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x21e80
jmp 0x1ac5d
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x21ec0
jmp 0x1ac6e
vmovsd 0x8(%rsp), %xmm0
leaq 0x84(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x21dd0
jmp 0x1ac88
leaq 0x60(%rsp), %rdi
callq 0x21f70
jmp 0x1acc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1ad37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x21f70
jmp 0x1ad37
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x21b40
jmp 0x1acd1
movq 0x10(%rsp), %rdi
movl $0x6, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
leaq 0x20(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0x21c20
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ad03
jmp 0x1ad22
leaq 0x33001(%rip), %rdi     # 0x4dd0b
leaq 0x3301c(%rip), %rsi     # 0x4dd2d
movl $0x79, %edx
leaq 0x33148(%rip), %rcx     # 0x4de65
callq 0x52a0
leaq 0x84(%rsp), %rdi
callq 0x21f80
addq $0x98, %rsp
retq
leaq 0x84(%rsp), %rdi
callq 0x21f80
movq 0x28(%rsp), %rdi
callq 0x5760
nop
// File: tewalds[P]morat/hex/../lib/depthstats.h
// Function: Morat::DepthStats::operator+=(Morat::DepthStats const&)
DepthStats & operator += (const DepthStats & o){
		num += o.num;
		sumdepth += o.sumdepth;
		sumdepthsq += o.sumdepthsq;
		if(mindepth > o.mindepth) mindepth = o.mindepth;
		if(maxdepth < o.maxdepth) maxdepth = o.maxdepth;
		return *this;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl (%rax), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x1ae8d
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x1aeaf
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::CompactTree()
CompactTree() {
		//allocate the first chunk
		head = current = last = new Chunk(CHUNK_SIZE);
		numchunks = 1;
		memused = 0;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x22c90
movl $0x20, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x1000000, %esi        # imm = 0x1000000
callq 0x20440
jmp 0x1b65c
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
movl $0x1, 0x18(%rax)
movq $0x0, 0x13b8(%rax)
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x53a0
movq 0x18(%rsp), %rdi
callq 0x5760
nopl (%rax)
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::~CompactTree()
~CompactTree(){
		head->dealloc(true);
		delete head;
		head = current = last = NULL;
		numchunks = 0;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x20810
jmp 0x1ba52
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1ba76
movq (%rsp), %rdi
callq 0x20940
movq (%rsp), %rdi
callq 0x53a0
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movl $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xd890
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.h
// Function: Morat::Hex::AgentMCTS::Node::dealloc(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>&)
unsigned int dealloc(CompactTree<Node> & ct){
			unsigned int num = 0;

			if(children.num())
				for(Node * i = children.begin(); i != children.end(); i++)
					num += i->dealloc(ct);
			num += children.dealloc(ct);

			return num;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
addq $0x28, %rdi
callq 0x1a560
cmpl $0x0, %eax
je 0x1bbaf
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x1c340
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
callq 0x1c390
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x1bbad
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1bb20
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
jmp 0x1bb61
jmp 0x1bbaf
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq 0x28(%rsp), %rsi
callq 0x1e450
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]morat/hex/agentmcts.h
// Function: Morat::Hex::AgentMCTS::Node::operator=(Morat::Hex::AgentMCTS::Node const&)
Node & operator = (const Node & n){
			if(this != & n){ //don't copy to self
				//don't copy to a node that already has children
				assert(children.empty());

				rave = n.rave;
				exp  = n.exp;
				know = n.know;
				move = n.move;
				bestmove = n.bestmove;
				outcome = n.outcome;
				proofdepth = n.proofdepth;
				//children = n.children; ignore the children, they need to be swap_tree'd in
			}
			return *this;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x1c28f
movq (%rsp), %rdi
addq $0x28, %rdi
callq 0x1b500
testb $0x1, %al
jne 0x1c205
jmp 0x1c207
jmp 0x1c226
leaq 0x31242(%rip), %rdi     # 0x4d450
leaq 0x31411(%rip), %rsi     # 0x4d626
movl $0x38, %edx
leaq 0x315ec(%rip), %rcx     # 0x4d80d
callq 0x52a0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movw 0x20(%rcx), %cx
movw %cx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movw 0x24(%rcx), %cx
movw %cx, 0x24(%rax)
movq 0x8(%rsp), %rcx
movw 0x26(%rcx), %cx
movw %cx, 0x26(%rax)
movq 0x8(%rsp), %rcx
movb 0x22(%rcx), %cl
movb %cl, 0x22(%rax)
movq 0x8(%rsp), %rcx
movb 0x23(%rcx), %cl
movb %cl, 0x23(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.h
// Function: Morat::Hex::AgentMCTS::Node::size() const
unsigned int size() const {
			unsigned int num = children.num();

			if(children.num())
				for(Node * i = children.begin(); i != children.end(); i++)
					num += i->size();

			return num;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x28, %rdi
callq 0x1a560
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
addq $0x28, %rdi
callq 0x1a560
cmpl $0x0, %eax
je 0x1c4ed
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x1c340
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x28, %rdi
callq 0x1c390
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x1c4eb
movq 0x10(%rsp), %rdi
callq 0x1c460
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
jmp 0x1c4a6
jmp 0x1c4ed
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFPrinter<Morat::Move>::child_start()
void child_start() {
		assert(!_root);
		assert(_depth >= 1);
		print("\n" + std::string(_depth, ' ') + "(");
		_depth++;
		_indent = false;
	}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1cbf7
jmp 0x1cbf9
jmp 0x1cc18
leaq 0x31503(%rip), %rdi     # 0x4e103
leaq 0x31503(%rip), %rsi     # 0x4e10a
movl $0x3f, %edx
leaq 0x31508(%rip), %rcx     # 0x4e11b
callq 0x52a0
movq 0x10(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jl 0x1cc25
jmp 0x1cc44
leaq 0x31537(%rip), %rdi     # 0x4e163
leaq 0x314d7(%rip), %rsi     # 0x4e10a
movl $0x40, %edx
leaq 0x314dc(%rip), %rcx     # 0x4e11b
callq 0x52a0
movq 0x10(%rsp), %rax
movslq 0xc(%rax), %rax
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5770
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movl $0x20, %edx
callq 0x52b0
jmp 0x1cc7a
leaq 0x2fc67(%rip), %rsi     # 0x4c8e8
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x19f30
jmp 0x1cc92
leaq 0x314d6(%rip), %rdx     # 0x4e16f
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb910
jmp 0x1ccaa
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x25e10
jmp 0x1ccbb
leaq 0x70(%rsp), %rdi
callq 0x5260
leaq 0x50(%rsp), %rdi
callq 0x5260
leaq 0x30(%rsp), %rdi
callq 0x5260
leaq 0x2f(%rsp), %rdi
callq 0x5450
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movb $0x0, 0x10(%rax)
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1cd59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1cd4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1cd45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5260
leaq 0x50(%rsp), %rdi
callq 0x5260
leaq 0x30(%rsp), %rdi
callq 0x5260
leaq 0x2f(%rsp), %rdi
callq 0x5450
movq 0x20(%rsp), %rdi
callq 0x5760
nopl (%rax)
// File: tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFPrinter<Morat::Move>::child_end()
void child_end() {
		assert(!_root);
		assert(_depth >= 1);
		_depth--;
		if(_indent)
			print("\n" + std::string(_depth, ' '));
		print(")");
		_indent = true;
	}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d0b7
jmp 0x1d0b9
jmp 0x1d0d8
leaq 0x31043(%rip), %rdi     # 0x4e103
leaq 0x31043(%rip), %rsi     # 0x4e10a
movl $0x46, %edx
leaq 0x31196(%rip), %rcx     # 0x4e269
callq 0x52a0
movq 0x18(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jl 0x1d0e5
jmp 0x1d104
leaq 0x31077(%rip), %rdi     # 0x4e163
leaq 0x31017(%rip), %rsi     # 0x4e10a
movl $0x47, %edx
leaq 0x3116a(%rip), %rcx     # 0x4e269
callq 0x52a0
movq 0x18(%rsp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
testb $0x1, 0x10(%rax)
je 0x1d1fa
movq 0x18(%rsp), %rax
movslq 0xc(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5770
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x60(%rsp), %rdi
movl $0x20, %edx
callq 0x52b0
jmp 0x1d154
leaq 0x2f78d(%rip), %rsi     # 0x4c8e8
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x19f30
jmp 0x1d16f
movq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x25e10
jmp 0x1d183
leaq 0x80(%rsp), %rdi
callq 0x5260
leaq 0x60(%rsp), %rdi
callq 0x5260
leaq 0x5f(%rsp), %rdi
callq 0x5450
jmp 0x1d1fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1d1eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1d1e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5260
leaq 0x60(%rsp), %rdi
callq 0x5260
leaq 0x5f(%rsp), %rdi
callq 0x5450
jmp 0x1d287
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5770
movq (%rsp), %rdx
leaq 0x317e1(%rip), %rsi     # 0x4e9f4
leaq 0x28(%rsp), %rdi
callq 0x5590
jmp 0x1d21f
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x25e10
jmp 0x1d230
leaq 0x28(%rsp), %rdi
callq 0x5260
leaq 0x27(%rsp), %rdi
callq 0x5450
movq 0x18(%rsp), %rax
movb $0x1, 0x10(%rax)
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1d27d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5260
leaq 0x27(%rsp), %rdi
callq 0x5450
movq 0x50(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/move_iterator.h
// Function: Morat::MoveIterator<Morat::Hex::Board>::operator++()
MoveIterator & operator ++ () {  //prefix form
		do {
			move_.x++;
			move_.xy++;

			if (move_.x >= line_end_) {
				move_.y++;
				if (move_.y >= board_.lines()) {  // done
					move_ = M_NONE;
					return *this;
				}
				move_.x = board_.line_start(move_.y);
				move_.xy = board_.xy(move_.x, move_.y);
				line_end_ = board_.line_end(move_.y);
			}
		} while (!board_.valid_move_fast(move_));

		return *this;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movb 0x9(%rcx), %al
addb $0x1, %al
movb %al, 0x9(%rcx)
movw 0xa(%rcx), %ax
addw $0x1, %ax
movw %ax, 0xa(%rcx)
movsbl 0x9(%rcx), %eax
movsbl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jl 0x1d582
movq 0x8(%rsp), %rax
movb 0x8(%rax), %cl
addb $0x1, %cl
movb %cl, 0x8(%rax)
movsbl 0x8(%rax), %ecx
movl %ecx, 0x4(%rsp)
movq (%rax), %rdi
callq 0x1fe80
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jl 0x1d536
leaq 0x14(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x1fdf0
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq %rax, 0x20(%rsp)
jmp 0x1d5a9
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movsbl 0x8(%rax), %esi
callq 0x1fea0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq (%rax), %rdi
movsbl 0x9(%rax), %esi
movsbl 0x8(%rax), %edx
callq 0x1fc80
movl %eax, %ecx
movq 0x8(%rsp), %rax
movw %cx, 0xa(%rax)
movq (%rax), %rdi
movsbl 0x8(%rax), %esi
callq 0x1feb0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movb %cl, 0xc(%rax)
jmp 0x1d584
movq 0x8(%rsp), %rsi
movq (%rsi), %rdi
addq $0x8, %rsi
callq 0x1fbd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d4c3
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFParser<Morat::Move>::next_child()
bool next_child() {
		eat_whitespace(_is);
		if(eat_char(_is, '('))
			return next_node();
		return false;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rdi
callq 0x46050
movq (%rsp), %rax
movq (%rax), %rdi
movl $0x28, %esi
callq 0x46110
testb $0x1, %al
jne 0x1d661
jmp 0x1d672
movq (%rsp), %rdi
callq 0x26020
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x1d677
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]morat/hex/../lib/depthstats.h
// Function: Morat::DepthStats::reset()
void reset(){
		num = 0;
		mindepth = 1000000000;
		maxdepth = 0;
		sumdepth = 0;
		sumdepthsq = 0;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x3b9aca00, (%rax)     # imm = 0x3B9ACA00
movl $0x0, 0x4(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
retq
nop
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Children::dealloc(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>&)
unsigned int dealloc(CompactTree & ct){
			Data * t = data;
			int n = 0;
			if(t && CAS(data, t, (Data*)NULL)){
				n = t->used;
				ct.dealloc(t);
			}
			return n;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rsp)
movb %al, 0xf(%rsp)
je 0x1e4a5
movq (%rsp), %rdi
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1e4e0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1e4af
jmp 0x1e4cb
movq 0x20(%rsp), %rax
movzwl 0x6(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1e520
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::dealloc(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data*)
void dealloc(Data * d){
		assert(!d->empty() && d->capacity > 0 && d->capacity < MAX_NUM);

		unsigned int size = d->mem_size();
		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 0x1e600
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x1e577
movq 0x18(%rsp), %rax
movzwl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jle 0x1e577
movq 0x18(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x272, %eax            # imm = 0x272
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1e581
jmp 0x1e583
jmp 0x1e5a2
leaq 0x2f163(%rip), %rdi     # 0x4d6ed
leaq 0x2f0d7(%rip), %rsi     # 0x4d668
movl $0x167, %edx            # imm = 0x167
leaq 0x2f188(%rip), %rcx     # 0x4d725
callq 0x52a0
movq 0x18(%rsp), %rdi
callq 0x1e620
movq (%rsp), %rdi
movl %eax, 0x14(%rsp)
addq $0x13b8, %rdi           # imm = 0x13B8
xorl %eax, %eax
subl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1d5c0
movq 0x18(%rsp), %rdi
callq 0x1e640
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movw $0x0, 0x6(%rax)
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x1e700
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Freelist::push(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data*)
void push(Data * d){
			assert(d->empty());
			lock.lock();
			push_nolock(d);
			lock.unlock();
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x1e600
testb $0x1, %al
jne 0x1e727
jmp 0x1e729
jmp 0x1e748
leaq 0x2f060(%rip), %rdi     # 0x4d790
leaq 0x2ef31(%rip), %rsi     # 0x4d668
movl $0xf9, %edx
leaq 0x2f058(%rip), %rcx     # 0x4d79b
callq 0x52a0
movq (%rsp), %rdi
addq $0x1390, %rdi           # imm = 0x1390
callq 0x1e7b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1e7e0
movq (%rsp), %rdi
addq $0x1390, %rdi           # imm = 0x1390
callq 0x1e820
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Children::swap(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Children&)
void swap(Children & other){
			//swap data pointer
			Data * temp;
			temp = data;
			data = other.data;
			other.data = temp;
			temp = NULL;

			//update parent pointer
			if(data > (Data*)LOCK)
				data->parent = &data;
			if(other.data > (Data*)LOCK)
				other.data->parent = &(other.data);
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq (%rax), %rcx
movq %rcx, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rsp), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq $0x0, -0x18(%rsp)
movl $0x1, %ecx
cmpq %rcx, (%rax)
jbe 0x1f3e3
movq -0x20(%rsp), %rcx
movq (%rcx), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movl $0x1, %ecx
cmpq %rcx, (%rax)
jbe 0x1f403
movq -0x10(%rsp), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::update_hash(Morat::MoveValid const&, Morat::Side)
void update_hash(const MoveValid & pos, Side side) {
		int turn = side.to_i();
		hash.update(0, 3 * pos.xy + turn);
		if(num_moves_ <= unique_depth) {
			hash.update(1, 3 * xy(sizem1_ - pos.x, sizem1_ - pos.y) + turn);
		}
	}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movb %al, 0x37(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x1fc40
movq 0x10(%rsp), %rdi
movsbl %al, %eax
movl %eax, 0x1c(%rsp)
addq $0x28, %rdi
movq 0x20(%rsp), %rax
movswl 0x2(%rax), %eax
imull $0x3, %eax, %edx
addl 0x1c(%rsp), %edx
xorl %esi, %esi
callq 0x1fc50
movq 0x10(%rsp), %rax
movswl 0x4(%rax), %eax
cmpl $0x5, %eax
jg 0x1f7e6
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
movsbl 0x1(%rdi), %esi
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
subl %eax, %esi
movsbl 0x1(%rdi), %edx
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
subl %eax, %edx
callq 0x1fc80
movq 0x8(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x1c(%rsp), %edx
movl $0x1, %esi
callq 0x1fc50
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/board_base.h
// Function: Morat::BoardBase<Morat::Hex::Board>::update_pattern(Morat::MoveValid const&, Morat::Side)
void update_pattern(const MoveValid& pos, Side turn) {
		Pattern p = turn.to_i();
		for (auto m : self()->neighbors_large(pos)) {
			if(m.on_board()){
				self()->cells_[m.xy].pattern |= p;
			}
			p <<= 2;
		}
	}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movb %al, 0x67(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x1fc40
movq 0x10(%rsp), %rdi
movsbq %al, %rax
movq %rax, 0x48(%rsp)
callq 0x116c0
movq %rax, %rdi
movq 0x50(%rsp), %rsi
callq 0x116d0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11710
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11720
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x1f8e2
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0x11730
testb $0x1, %al
jne 0x1f891
jmp 0x1f8c4
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x116c0
movq %rax, %rdi
addq $0x10, %rdi
movswq 0x1e(%rsp), %rsi
callq 0x11590
movq 0x8(%rsp), %rcx
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x48(%rsp), %rax
shlq $0x2, %rax
movq %rax, 0x48(%rsp)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
jmp 0x1f86a
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::join_groups(int, int)
bool join_groups(int i, int j){
		i = find_group(i);
		j = find_group(j);

		if(i == j)
			return true;

		if(cells_[i].size < cells_[j].size) //force i's subtree to be bigger
			std::swap(i, j);

		cells_[j].parent = i;
		cells_[i].size   += cells_[j].size;
		cells_[i].edge   |= cells_[j].edge;

		return false;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x24(%rsp), %esi
callq 0x1faf0
movq 0x18(%rsp), %rdi
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %esi
callq 0x1faf0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jne 0x1f9ee
movb $0x1, 0x37(%rsp)
jmp 0x1fadb
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movslq 0x24(%rsp), %rsi
callq 0x11590
movq 0x18(%rsp), %rdi
movzwl 0x2(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
movslq 0x20(%rsp), %rsi
callq 0x11590
movq %rax, %rcx
movl 0x14(%rsp), %eax
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1fa3a
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1fd10
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movw %ax, 0xa(%rsp)
addq $0x10, %rdi
movslq 0x20(%rsp), %rsi
callq 0x11590
movw 0xa(%rsp), %cx
movq 0x18(%rsp), %rdi
movw %cx, 0x4(%rax)
addq $0x10, %rdi
movslq 0x20(%rsp), %rsi
callq 0x11590
movq 0x18(%rsp), %rdi
movzwl 0x2(%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x10, %rdi
movslq 0x24(%rsp), %rsi
callq 0x11590
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rdi
movzwl 0x2(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x2(%rax)
addq $0x10, %rdi
movslq 0x20(%rsp), %rsi
callq 0x11590
movq 0x18(%rsp), %rdi
movzbl 0x6(%rax), %eax
movl %eax, 0x10(%rsp)
addq $0x10, %rdi
movslq 0x24(%rsp), %rsi
callq 0x11590
movl 0x10(%rsp), %edx
movzbl 0x6(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x6(%rax)
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::find_group(unsigned int) const
int find_group(unsigned int i) const {
		unsigned int p = cells_[i].parent;
		if(p != i){
			do{
				p = cells_[p].parent;
			}while(p != cells_[p].parent);
			cells_[i].parent = p; //do path compression, but only the current one, not all, to avoid recursion
		}
		return p;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x1fcf0
movzwl 0x4(%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x1fb97
jmp 0x1fb2a
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x1fcf0
movzwl 0x4(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x10, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x1fcf0
movq %rax, %rcx
movl 0xc(%rsp), %eax
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1fb2a
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movw %ax, 0xa(%rsp)
addq $0x10, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x1fcf0
movw 0xa(%rsp), %cx
movw %cx, 0x4(%rax)
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
// File: tewalds[P]morat/hex/../lib/move_iterator.h
// Function: Morat::MoveIterator<Morat::Hex::Board>::MoveIterator(Morat::Hex::Board const&)
MoveIterator(const Board& b) : board_(b), move_(M_SWAP), line_end_(0) {
		if(board_.outcome() >= Outcome::DRAW){
			move_ = M_NONE;
		} else {
			++(*this); //find the first valid move
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1fdf0
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
movq (%rax), %rdi
callq 0x1a900
movb %al, 0x17(%rsp)
leaq 0x17(%rsp), %rdi
leaq 0x4d714(%rip), %rsi     # 0x6d4c3
callq 0x1a8c0
testb $0x1, %al
jne 0x1fdba
jmp 0x1fdd7
leaq 0x12(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x1fdf0
movq 0x8(%rsp), %rax
movl 0x12(%rsp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x1fde1
movq 0x8(%rsp), %rdi
callq 0x1d4b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Freelist::pop(unsigned int)
Data * pop(unsigned int num){
			lock.lock();
			Data * t = pop_nolock(num);
			lock.unlock();
			return t;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x1390, %rdi           # imm = 0x1390
callq 0x1e7b0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x204b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x1390, %rdi           # imm = 0x1390
callq 0x1e820
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data::Data(unsigned int, Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data**)
Data(unsigned int n, Data ** p) : capacity(n), used(n), parent(p) {
			header = (((unsigned long)this >> 2) & 0xFFFF) | (0xBEEF << 16);
			if(empty()) header += 0xABCD;

			for(Node * i = begin(), * e = end(); i != e; ++i)
				new(i) Node(); //call the constructors
		}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x7c(%rsp), %ecx
movw %cx, 0x4(%rax)
movl 0x7c(%rsp), %ecx
movw %cx, 0x6(%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1b5a0
jmp 0x20289
movq 0x40(%rsp), %rcx
movq 0x28(%rsp), %rax
addq $0x30, %rax
cmpq %rcx, %rax
movq %rax, 0x48(%rsp)
jne 0x20278
movq 0x30(%rsp), %rdi
movq %rdi, %rax
shrq $0x2, %rax
andq $0xffff, %rax           # imm = 0xFFFF
orq $-0x41110000, %rax      # imm = 0xBEEF0000
movl %eax, (%rdi)
callq 0x1e600
testb $0x1, %al
jne 0x202c6
jmp 0x20323
movq 0x30(%rsp), %rax
movl (%rax), %ecx
addl $0xabcd, %ecx           # imm = 0xABCD
movl %ecx, (%rax)
jmp 0x20323
movq 0x38(%rsp), %rcx
movq %rax, %rsi
movq 0x28(%rsp), %rax
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
cmpq %rax, %rcx
movq %rax, 0x20(%rsp)
je 0x2031e
movq 0x20(%rsp), %rdi
addq $-0x30, %rdi
movq %rdi, 0x18(%rsp)
callq 0x1bab0
movq 0x38(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0x202f7
jmp 0x203bb
movq 0x30(%rsp), %rdi
callq 0x1e780
movq 0x30(%rsp), %rdi
movq %rax, 0x58(%rsp)
callq 0x1e790
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x2038a
movq 0x58(%rsp), %rdi
callq 0x1b5a0
jmp 0x20359
jmp 0x2035b
movq 0x58(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x58(%rsp)
jmp 0x20341
movq %rdx, %rcx
movq %rax, %rdx
movq 0x38(%rsp), %rax
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
addq $0x30, %rax
movq %rax, 0x10(%rsp)
jmp 0x20392
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
addq $-0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1bab0
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x20392
jmp 0x203bb
movq 0x68(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Freelist::pop_nolock(unsigned int)
Data * pop_nolock(unsigned int num){
			Data * t = list[num];
			if(t)
				list[num] = t->nextfree;
			return t;
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x204ee
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rdx
movl -0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Chunk::alloc(unsigned int)
void alloc(unsigned int c){
			assert_empty();
			capacity = c;
			used = 0;
			mem = (char*) new uint64_t[capacity / sizeof(uint64_t)]; //use uint64_t instead of char to guarantee alignment
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x20570
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl 0xc(%rax), %eax
shrq $0x3, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop