LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::set_ponder(bool)
void AgentMCTS::set_ponder(bool p){
	if(ponder != p){
		ponder = p;
		pool.pause();

		if(ponder)
			pool.resume();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb %sil, 0x58(%rdi)
je 0xf165
movq %rdi, %rbx
movb %sil, 0x58(%rdi)
leaq 0x54f0(%rdi), %r14
movq %r14, %rdi
callq 0x1141a
cmpb $0x1, 0x58(%rbx)
jne 0xf165
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11586
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::set_board(Morat::Hex::Board const&, bool)
void AgentMCTS::set_board(const Board & board, bool clear){
	pool.pause();

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

	rootboard = board;

	if(ponder)
		pool.resume();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x54f0(%rdi), %rbx
movq %rbx, %rdi
callq 0x1141a
leaq 0x40e0(%r14), %r12
leaq 0x4130(%r14), %rsi
movq %r12, %rdi
callq 0x12312
movl %eax, %eax
subq %rax, 0x4110(%r14)
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %rsi
vmovups %ymm0, (%rsi)
movw $0x0, 0x20(%rsi)
leaq 0x271e9(%rip), %rax     # 0x363ae
movb (%rax), %al
movb %al, 0x22(%rsi)
movl $0xfc78fd00, 0x23(%rsi) # imm = 0xFC78FD00
movb $0x78, 0x27(%rsi)
movq $0x0, 0x28(%rsi)
movq %r12, %rdi
vzeroupper
callq 0x1282c
movq %rsp, %rdi
callq 0x122ba
movl 0xa8(%r14), %eax
incl %eax
vmovq %rax, %xmm0
addq %rax, %rax
vmovq %rax, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpaddq 0x40f0(%r14), %xmm0, %xmm0
vmovdqu %xmm0, 0x40f0(%r14)
movq (%r15), %rax
movq %rax, 0x10(%r14)
movzwl 0x8(%r15), %eax
movw %ax, 0x18(%r14)
leaq 0x20(%r14), %rdi
leaq 0x10(%r15), %rsi
callq 0x13648
vmovups 0x28(%r15), %xmm0
vmovups %xmm0, 0x38(%r14)
movq 0x38(%r15), %rax
movq %rax, 0x48(%r14)
leaq 0x50(%r14), %rdi
addq $0x40, %r15
movq %r15, %rsi
callq 0x13732
cmpb $0x1, 0x58(%r14)
jne 0xf26d
movq %rbx, %rdi
callq 0x11586
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x122ba
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::get_pv(std::vector<Morat::Move, std::allocator<Morat::Move>> const&) const
std::vector<Move> AgentMCTS::get_pv(const vecmove& moves) const {
	vecmove pv;

	const Node * n = & root;
	Side turn = rootboard.to_play();
	unsigned int i = 0;
	while(n && !n->children.empty()){
		Move m = (i < moves.size() ? moves[i++] : return_move(n, turn));
		pv.push_back(m);
		n = find_child(n, m);
		turn = ~turn;
	}

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

	return pv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x40e0(%rsi), %r13
movb 0x18(%rsi), %r12b
xorl %ebp, %ebp
movq 0x28(%r13), %rax
cmpq $0x2, %rax
jb 0xfcf8
cmpw $0x0, 0x6(%rax)
je 0xfcf8
movl %ebp, %eax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq %rdx
cmpq %rax, %rdx
jbe 0xfc52
incl %ebp
movzwl (%rcx,%rax,2), %eax
jmp 0xfc63
movzbl %r12b, %edx
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0xfd56
movw %ax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xfc7c
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0xfc89
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x15716
movq 0x28(%r13), %rsi
leaq 0x10(%rsi), %rdx
movl $0x0, %eax
movl $0x0, %ecx
cmpq $0x2, %rsi
cmovaeq %rdx, %rax
jb 0xfcb6
movzwl 0x6(%rsi), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
addq %rcx, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
je 0xfce4
movb 0x4(%rsp), %dl
movb 0x5(%rsp), %sil
movb 0x24(%rax), %dil
xorb %dl, %dil
movb 0x25(%rax), %r8b
xorb %sil, %r8b
orb %dil, %r8b
cmoveq %rax, %r13
je 0xfce7
addq $0x30, %rax
cmpq %rcx, %rax
jne 0xfcc4
xorl %r13d, %r13d
movb $0x3, %al
subb %r12b, %al
movl %eax, %r12d
testq %r13, %r13
jne 0xfc1d
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
jne 0xfd2a
movw $0x78fe, 0x6(%rsp)      # imm = 0x78FE
cmpq 0x10(%rbx), %rsi
je 0xfd1d
movzwl 0x6(%rsp), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0xfd2a
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x1584a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfd3e
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xfd4e
callq 0x52e0
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::garbage_collect(Morat::Hex::AgentMCTS::Node&, Morat::Side)
void AgentMCTS::garbage_collect(Node& node, Side to_play){
	for (auto& child : node.children) {
		if (child.children.num() == 0)
			continue;

		if ((node.outcome.solved() &&       // parent is solved
		     child.exp.num() > gcsolved &&  // keep the heavy nodes
		     (node.outcome != to_play ||    // loss or draw, keep the everything
		      child.outcome == to_play)) || // found the win, keep the proof tree
		    (!node.outcome.solved() &&      // parent isn't solved,
		     child.exp.num() > (child.outcome.solved() ?
		      gcsolved :                    // only keep the heavy proof tree
		      gclimit)) ){                  // but the light area still being worked on
			garbage_collect(child, ~to_play);
		} else {
			nodes -= child.dealloc(ctmem);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rsi), %rcx
leaq 0x10(%rcx), %rax
xorl %ebx, %ebx
movl $0x0, %r12d
cmpq $0x2, %rcx
cmovaeq %rax, %r12
jb 0x106a5
movzwl 0x6(%rcx), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
addq %rcx, %rax
movq %rax, %rbx
cmpq %rbx, %r12
je 0x10764
leaq 0x4130(%r15), %rax
movq %rax, 0x10(%rsp)
movb $0x3, %al
subb 0x8(%rsp), %al
leaq 0xac(%r15), %r13
leaq 0x4118(%r15), %rbp
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%r12), %rax
cmpq $0x2, %rax
jb 0x10757
cmpw $0x0, 0x6(%rax)
je 0x10757
movb 0x22(%r14), %cl
leaq 0x25cbf(%rip), %rax     # 0x363b1
movb (%rax), %al
cmpb %al, %cl
jl 0x1071b
movl 0xac(%r15), %edx
cmpq %rdx, 0x18(%r12)
jbe 0x10717
cmpb 0x8(%rsp), %cl
jne 0x10730
movl 0x8(%rsp), %edx
cmpb %dl, 0x22(%r12)
je 0x10730
cmpb %al, %cl
jge 0x10741
cmpb %al, 0x22(%r12)
movq %r13, %rax
cmovlq %rbp, %rax
movl (%rax), %eax
cmpq %rax, 0x18(%r12)
jbe 0x10741
movq %r15, %rdi
movq %r12, %rsi
movl 0xc(%rsp), %edx
callq 0x10662
jmp 0x10757
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x12312
movl %eax, %eax
subq %rax, 0x4110(%r15)
addq $0x30, %r12
cmpq %rbx, %r12
jne 0x106d5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::gen_sgf(Morat::SGFPrinter<Morat::Move>&, unsigned int, Morat::Hex::AgentMCTS::Node const&, Morat::Side) const
void AgentMCTS::gen_sgf(SGFPrinter<Move> & sgf, unsigned int limit, const Node & node, Side side) const {
	for(auto & child : node.children){
		if(child.exp.num() >= limit && (side != node.outcome || child.outcome == node.outcome)){
			sgf.child_start();
			sgf.move(side, child.move);
			sgf.comment(child.to_s());
			gen_sgf(sgf, limit, child, ~side);
			sgf.child_end();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x28(%rcx), %rcx
leaq 0x10(%rcx), %rax
xorl %r12d, %r12d
movl $0x0, %r13d
cmpq $0x2, %rcx
cmovaeq %rax, %r13
jb 0x107c2
movzwl 0x6(%rcx), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
addq %rcx, %rax
movq %rax, %r12
cmpq %r12, %r13
je 0x1086e
movl 0xc(%rsp), %ebp
movb $0x3, %al
subb %bl, %al
movzbl %bl, %ecx
movl %ecx, 0x14(%rsp)
movzbl %al, %eax
movl %eax, 0x10(%rsp)
cmpq %rbp, 0x18(%r13)
jb 0x10861
movq 0x20(%rsp), %rax
movb 0x22(%rax), %al
cmpb %bl, %al
jne 0x107f9
cmpb %al, 0x22(%r13)
jne 0x10861
movq %r15, %rdi
callq 0x12a32
movl 0x24(%r13), %edx
movq %r15, %rdi
movl 0x14(%rsp), %esi
callq 0x12bfa
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0xbef0
movq %r15, %rdi
movq %r14, %rsi
callq 0x12d46
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x10840
callq 0x52e0
movq 0x18(%rsp), %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
movq %r13, %rcx
movl 0x10(%rsp), %r8d
callq 0x10774
movq %r15, %rdi
callq 0x12e2a
addq $0x30, %r13
cmpq %r12, %r13
jne 0x107e1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x10894
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x28(%rdx), %rax
cmpq $0x2, %rax
jb 0x108c8
cmpw $0x0, 0x6(%rax)
jne 0x10a03
addq $0x28, %r14
movb 0x9(%r12), %al
leaq 0x25ad9(%rip), %rcx     # 0x363b1
movswl 0x2(%r12), %esi
movswl 0x4(%r12), %edx
subl %edx, %esi
xorl %r15d, %r15d
cmpb (%rcx), %al
cmovgel %r15d, %esi
leaq 0x4130(%rbx), %rdx
movq %r14, %rdi
callq 0x12fca
movq (%r14), %rax
leaq 0x10(%rax), %rcx
cmpq $0x2, %rax
cmovaeq %rcx, %r15
movq %r12, %rdi
callq 0x13010
movq %rax, (%rsp)
movl %edx, 0x8(%rsp)
shrq $0x20, %rdx
movb %dl, 0xc(%rsp)
cmpw $-0x1, 0xa(%rsp)
je 0x1099d
leaq 0x25a7a(%rip), %rbp     # 0x363ae
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movzwl 0x8(%rsp), %eax
movb (%rbp), %cl
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x10(%rsp)
movw $0x0, 0x30(%rsp)
movb %cl, 0x32(%rsp)
movb $0x0, 0x33(%rsp)
movw %ax, 0x34(%rsp)
movw $0x78fc, 0x36(%rsp)     # imm = 0x78FC
movq $0x0, 0x38(%rsp)
movq %r15, %rdi
movq %r12, %rsi
vzeroupper
callq 0x1282c
addq $0x30, %r15
movq %r12, %rdi
callq 0x122ba
movq %r13, %rdi
callq 0x13058
cmpw $-0x1, 0xa(%rsp)
jne 0x1093c
movq (%r14), %rax
cmpq $0x2, %rax
jb 0x109b8
movzwl 0x6(%rax), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
leaq 0x10(%rax,%rcx), %rcx
jmp 0x109ba
xorl %ecx, %ecx
cmpq %rcx, %r15
jne 0x109e4
cmpq $0x2, %rax
jb 0x109cb
movzwl 0x6(%rax), %eax
jmp 0x109cd
xorl %eax, %eax
lock
addq %rax, 0x4110(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21cfe(%rip), %rdi     # 0x326e9
leaq 0x21bd5(%rip), %rsi     # 0x325c7
leaq 0x21ca6(%rip), %rcx     # 0x3269f
movl $0x191, %edx            # imm = 0x191
callq 0x51d0
leaq 0x21c20(%rip), %rdi     # 0x3262a
leaq 0x21bb6(%rip), %rsi     # 0x325c7
leaq 0x21c87(%rip), %rcx     # 0x3269f
movl $0x189, %edx            # imm = 0x189
callq 0x51d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x122ba
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x214f0(%rip), %rsi     # 0x32787
movq %r14, %rdi
callq 0x50b0
testl %eax, %eax
je 0x112fe
leaq 0x214e2(%rip), %rsi     # 0x3278c
movq %r14, %rdi
callq 0x50b0
testl %eax, %eax
je 0x11305
leaq 0x214c5(%rip), %rsi     # 0x32782
movq %r14, %rdi
callq 0x50b0
testl %eax, %eax
je 0x1130c
leaq 0x214aa(%rip), %rsi     # 0x3277a
movq %r14, %rdi
callq 0x50b0
testl %eax, %eax
je 0x11313
movq (%r14), %r14
movsbl (%r14), %edi
callq 0x54a0
addb $-0x61, %al
movb %al, 0x1(%rbx)
incq %r14
movq %r14, %rdi
callq 0x5550
decb %al
movb %al, (%rbx)
jmp 0x11318
movw $0x78ff, (%rbx)         # imm = 0x78FF
jmp 0x11318
movw $0x78fe, (%rbx)         # imm = 0x78FE
jmp 0x11318
movw $0x78fd, (%rbx)         # imm = 0x78FD
jmp 0x11318
movw $0x78fc, (%rbx)         # imm = 0x78FC
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x21454(%rip), %rsi     # 0x32793
leaq 0x2144e(%rip), %rdx     # 0x32794
leaq 0x20(%rsp), %rdi
callq 0xb0e0
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2fa40
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x11373
callq 0x52e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
cmpq $0x40, %rax
jne 0x113cd
addq $0x20, %rdi
callq 0x13340
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
callq 0x133c2
vcvtss2sd %xmm0, %xmm0, %xmm0
vaddsd %xmm0, %xmm0, %xmm0
vcvtusi2sdq 0x8(%rbx), %xmm1, %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vcvttsd2usi %xmm0, %rax
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xa9ae
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x213c1(%rip), %rdi     # 0x32795
leaq 0x213cc(%rip), %rsi     # 0x327a7
leaq 0x213da(%rip), %rcx     # 0x327bc
movl $0x19, %edx
callq 0x51d0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x11412
callq 0x52e0
jmp 0x11412
movq %rax, %rbx
jmp 0x11412
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa9ae
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1146c
movq %rdi, %rbx
movl $0x6, %ecx
movl $0x3, %eax
lock
cmpxchgl %ecx, (%rdi)
movl $0x5, %ecx
movl $0x4, %eax
lock
cmpxchgl %ecx, (%rdi)
movq 0xe0(%rdi), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
leaq 0x20(%rbx), %rdi
callq 0x142a6
movl $0x1, %ecx
movl $0x6, %eax
lock
cmpxchgl %ecx, (%rbx)
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x1146e
popq %rbx
retq
leaq 0x21a73(%rip), %rdi     # 0x32ee8
leaq 0x21a8e(%rip), %rsi     # 0x32f0a
leaq 0x21a9e(%rip), %rcx     # 0x32f21
movl $0x67, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
jne 0x11548
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x1153b
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %r14
jmp 0x11527
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x11567
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21999(%rip), %rdi     # 0x32ee8
leaq 0x219b4(%rip), %rsi     # 0x32f0a
leaq 0x21a24(%rip), %rcx     # 0x32f81
movl $0x9c, %edx
callq 0x51d0
leaq 0x2197a(%rip), %rdi     # 0x32ee8
leaq 0x21995(%rip), %rsi     # 0x32f0a
leaq 0x21a05(%rip), %rcx     # 0x32f81
movl $0xa1, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
jne 0x115aa
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x142a6
movl $0x3, %ecx
movl $0x1, %eax
lock
cmpxchgl %ecx, (%rbx)
popq %rbx
retq
leaq 0x21937(%rip), %rdi     # 0x32ee8
leaq 0x21952(%rip), %rsi     # 0x32f0a
leaq 0x21a22(%rip), %rcx     # 0x32fe1
movl $0x6c, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jbe 0x1165e
vmovsd %xmm0, 0x8(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovupd %ymm0, 0x10(%rsp)
movl $0x18, %edi
vzeroupper
callq 0x5320
leaq 0x2c74(%rip), %rcx      # 0x1427c
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x2f20(%rip), %rax      # 0x14546
movq %rax, 0x18(%rsi)
leaq 0x2f31(%rip), %rax      # 0x14562
movq %rax, 0x10(%rsi)
leaq 0x4(%rsp), %rdi
vmovsd 0x8(%rsp), %xmm0
callq 0x1435c
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1165e
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x20(%rbx), %rdi
callq 0x142a6
movl $0x1, %ecx
movl $0x6, %eax
lock
cmpxchgl %ecx, (%rbx)
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x1168c
leaq 0x4(%rsp), %rdi
callq 0x14416
addq $0x30, %rsp
popq %rbx
retq
leaq 0x21855(%rip), %rdi     # 0x32ee8
leaq 0x21870(%rip), %rsi     # 0x32f0a
leaq 0x219a1(%rip), %rcx     # 0x33042
movl $0x79, %edx
callq 0x51d0
jmp 0x116cb
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x116d8
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x116d8
movq %rax, %rdi
callq 0xa7e4
jmp 0x116d5
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x14416
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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, %rax
movl 0x8(%rsi), %ecx
addl %ecx, 0x8(%rdi)
vmovdqu 0x10(%rdi), %xmm0
vpaddq 0x10(%rsi), %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rdi)
movl (%rsi), %ecx
cmpl %ecx, (%rdi)
jbe 0x1170a
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
cmpl %ecx, 0x4(%rax)
jae 0x11715
movl %ecx, 0x4(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
movl $0x1394, %edx           # imm = 0x1394
xorl %esi, %esi
callq 0x51a0
movl $0x20, %edi
callq 0x5320
movq %rax, %r14
movq $0x0, 0x18(%rax)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq %rax, %rdi
callq 0x13c8a
movq $0x1000000, 0xc(%r14)   # imm = 0x1000000
movl $0x1000000, %edi        # imm = 0x1000000
callq 0x5030
movq %rax, 0x18(%r14)
movq %r14, 0x10(%rbx)
movq %r14, 0x8(%rbx)
movq %r14, (%rbx)
movl $0x1, 0x18(%rbx)
movq $0x0, 0x13b8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/agentpool.h
// Function: Morat::AgentThreadPool<Morat::Hex::AgentMCTS>::set_num_threads(unsigned int)
void set_num_threads(unsigned int new_num_threads) { // destroys the existing threads and creates the specified number of new ones
		//start and end with thread_state = Thread_Wait_Start
		assert(thread_state == Thread_Wait_Start);

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

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

		threads.clear();

		thread_state = Thread_Wait_Start;

		num_threads = new_num_threads;

		run_barrier.reset(num_threads + 1);
		gc_barrier.reset(num_threads);

		//start new threads
		for(unsigned int i = 0; i < num_threads; i++)
			threads.push_back(new typename AgentType::AgentThread(this, agent));

		assert(thread_state == Thread_Wait_Start);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl $0x1, %eax
jne 0x121be
movq %rdi, %rbx
movl $0x2, %ecx
movl $0x1, %eax
lock
cmpxchgl %ecx, (%rdi)
jne 0x121dd
movl %esi, %ebp
leaq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x142a6
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
je 0x12127
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%rax,%r13,8), %rdi
addq $0x8, %rdi
callq 0x1493a
movq (%r14), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x1210a
movq (%rdi), %rax
callq *0x8(%rax)
movl %r12d, %r13d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %r12d
cmpq %r13, %rdx
ja 0x120eb
cmpq %rax, %rcx
je 0x12130
movq %rax, 0x10(%rbx)
movl $0x1, (%rbx)
movl %ebp, 0x4(%rbx)
incl %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x1467a
leaq 0x80(%rbx), %rdi
movl 0x4(%rbx), %esi
callq 0x1467a
cmpl $0x0, 0x4(%rbx)
je 0x121a8
xorl %ebp, %ebp
movq %rsp, %r15
movl $0x121e8, %edi          # imm = 0x121E8
callq 0x5320
movq %rax, %r12
movq 0xe0(%rbx), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x146be
movq %r12, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x12196
movq %r12, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x121a1
movq %r14, %rdi
movq %r15, %rdx
callq 0x1496e
incl %ebp
cmpl 0x4(%rbx), %ebp
jb 0x1215f
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x121fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20d23(%rip), %rdi     # 0x32ee8
leaq 0x20d3e(%rip), %rsi     # 0x32f0a
leaq 0x20eda(%rip), %rcx     # 0x330ad
movl $0x7e, %edx
callq 0x51d0
leaq 0x20f3f(%rip), %rdi     # 0x33123
leaq 0x20d1f(%rip), %rsi     # 0x32f0a
leaq 0x20ebb(%rip), %rcx     # 0x330ad
movl $0x81, %edx
callq 0x51d0
leaq 0x20ce5(%rip), %rdi     # 0x32ee8
leaq 0x20d00(%rip), %rsi     # 0x32f0a
leaq 0x20e9c(%rip), %rcx     # 0x330ad
movl $0x97, %edx
callq 0x51d0
movq %rax, %rbx
movq %r12, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x13da4
movq (%rbx), %r14
testq %r14, %r14
je 0x1229c
movq %r14, %rdi
callq 0x13c8a
movq %r14, %rdi
callq 0x52e0
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0xc(%rbx)
vmovups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xa7e4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rax
xorl %ebx, %ebx
movl $0x0, %r13d
cmpq $0x2, %rax
jb 0x12386
cmpw $0x0, 0x6(%rax)
movl $0x0, %r13d
je 0x12386
leaq 0x10(%rax), %r12
xorl %r13d, %r13d
cmpq $0x2, %rax
cmovbq %r13, %r12
movq 0x28(%r15), %rax
cmpq $0x2, %rax
jb 0x1236b
movzwl 0x6(%rax), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
leaq 0x10(%rax,%rcx), %rax
jmp 0x1236d
xorl %eax, %eax
cmpq %rax, %r12
je 0x12386
movq %r12, %rdi
movq %r14, %rsi
callq 0x12312
addl %eax, %r13d
addq $0x30, %r12
jmp 0x1234f
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x123a8
xorl %ebx, %ebx
movq %rsi, %rax
lock
cmpxchgq %rbx, 0x28(%r15)
jne 0x123a8
movzwl 0x6(%rsi), %ebx
movq %r14, %rdi
callq 0x1353a
addl %r13d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq %rsi, %rdi
je 0x12878
movq 0x28(%rdi), %rax
cmpq $0x2, %rax
jb 0x12842
cmpw $0x0, 0x6(%rax)
jne 0x1287c
vmovups (%rsi), %xmm0
vmovups %xmm0, (%rdi)
vmovups 0x10(%rsi), %xmm0
vmovups %xmm0, 0x10(%rdi)
movzwl 0x20(%rsi), %eax
movw %ax, 0x20(%rdi)
movzwl 0x24(%rsi), %eax
movw %ax, 0x24(%rdi)
movzwl 0x26(%rsi), %eax
movw %ax, 0x26(%rdi)
movb 0x22(%rsi), %al
movb %al, 0x22(%rdi)
movb 0x23(%rsi), %al
movb %al, 0x23(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x1fdac(%rip), %rdi     # 0x32630
leaq 0x1ff78(%rip), %rsi     # 0x32803
leaq 0x20158(%rip), %rcx     # 0x329ea
movl $0x38, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
xorl %ebx, %ebx
cmpq $0x2, %rax
jb 0x128b4
movzwl 0x6(%rax), %ebx
cmpq $0x2, %rax
jb 0x12902
cmpw $0x0, 0x6(%rax)
je 0x12902
leaq 0x10(%rax), %r15
xorl %ecx, %ecx
cmpq $0x2, %rax
cmovbq %rcx, %r15
movq 0x28(%r14), %rax
cmpq $0x2, %rax
jb 0x128eb
movzwl 0x6(%rax), %ecx
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
leaq 0x10(%rax,%rcx), %rax
jmp 0x128ed
xorl %eax, %eax
cmpq %rax, %r15
je 0x12902
movq %r15, %rdi
callq 0x1289c
addl %eax, %ebx
addq $0x30, %r15
jmp 0x128cf
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.h
// Function: Morat::Hex::AgentMCTS::Node::value(float, bool, float) const
float value(float ravefactor, bool knowledge, float fpurgency) const {
			float val = fpurgency;
			float expnum = exp.num();
			float ravenum = rave.num();

			if(ravefactor <= min_rave){
				if(expnum > 0)
					val = exp.avg();
			}else if(ravenum > 0 || expnum > 0){
				float alpha = ravefactor/(ravefactor + expnum);
//				float alpha = sqrt(ravefactor/(ravefactor + 3.0f*expnum));
//				float alpha = ravenum/(expnum + ravenum + expnum*ravenum*ravefactor);

				val = 0;
				if(ravenum > 0) val += alpha*rave.avg();
				if(expnum  > 0) val += (1.0f-alpha)*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:
vmovaps %xmm1, %xmm3
movq 0x18(%rdi), %rax
vcvtusi2ss %rax, %xmm2, %xmm1
vmovss 0x1f8e8(%rip), %xmm2    # 0x32208
vucomiss %xmm0, %xmm2
jae 0x12962
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
orq %rax, %rdx
je 0x129a9
vaddss %xmm0, %xmm1, %xmm2
vdivss %xmm2, %xmm0, %xmm0
testq %rcx, %rcx
je 0x1297c
vcvtusi2ssq (%rdi), %xmm4, %xmm2
vmulss 0x1f8ab(%rip), %xmm2, %xmm2 # 0x321f8
vcvtusi2ss %rcx, %xmm4, %xmm3
vdivss %xmm3, %xmm2, %xmm2
vxorps %xmm3, %xmm3, %xmm3
vfmadd231ss %xmm2, %xmm0, %xmm3 # xmm3 = (xmm0 * xmm2) + xmm3
jmp 0x12980
testq %rax, %rax
je 0x129a9
vcvtusi2ssq 0x10(%rdi), %xmm4, %xmm0
vmulss 0x1f882(%rip), %xmm0, %xmm0 # 0x321f8
vdivss %xmm1, %xmm0, %xmm3
jmp 0x129a9
vxorps %xmm3, %xmm3, %xmm3
testq %rax, %rax
je 0x129a9
vmovss 0x1f873(%rip), %xmm2    # 0x32200
vsubss %xmm0, %xmm2, %xmm0
vcvtusi2ssq 0x10(%rdi), %xmm4, %xmm2
vmulss 0x1f858(%rip), %xmm2, %xmm2 # 0x321f8
vdivss %xmm1, %xmm2, %xmm2
vfmadd231ss %xmm2, %xmm0, %xmm3 # xmm3 = (xmm0 * xmm2) + xmm3
testb %sil, %sil
je 0x12a2c
movswl 0x20(%rdi), %ecx
testl %ecx, %ecx
jle 0x12a2c
cmpq $0x1, %rax
ja 0x129cb
vcvtsi2ss %ecx, %xmm4, %xmm0
vfmadd231ss 0x1f843(%rip), %xmm0, %xmm3 # xmm3 = (xmm0 * mem) + xmm3
jmp 0x12a2c
cmpq $0x3e7, %rax            # imm = 0x3E7
ja 0x12a2c
vcvtsi2ss %ecx, %xmm4, %xmm0
vmulss 0x1f82d(%rip), %xmm0, %xmm0 # 0x3220c
vcvtss2sd %xmm0, %xmm0, %xmm2
vcvtss2sd %xmm1, %xmm1, %xmm0
vxorps %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jb 0x129f7
vsqrtsd %xmm0, %xmm0, %xmm0
jmp 0x12a1c
subq $0x18, %rsp
vmovss %xmm3, 0xc(%rsp)
vmovsd %xmm2, 0x10(%rsp)
callq 0x5250
vmovsd 0x10(%rsp), %xmm2
vmovss 0xc(%rsp), %xmm3
addq $0x18, %rsp
vdivsd %xmm0, %xmm2, %xmm0
vcvtss2sd %xmm3, %xmm3, %xmm1
vaddsd %xmm1, %xmm0, %xmm0
vcvtsd2ss %xmm0, %xmm0, %xmm3
vmovaps %xmm3, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpb $0x1, 0x8(%rdi)
je 0x12b79
movq %rdi, %rbx
movslq 0xc(%rdi), %rsi
testq %rsi, %rsi
jle 0x12b98
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movl $0x20, %edx
callq 0x53b0
leaq 0x1ee8d(%rip), %rcx     # 0x31906
movl $0x1, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5380
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x12ab2
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x12abb
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x2086e(%rip), %rsi     # 0x3334c
callq 0x56e0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x12b0b
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x12b15
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x15922
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x12b48
callq 0x52e0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x12b57
callq 0x52e0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12b66
callq 0x52e0
incl 0xc(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20760(%rip), %rdi     # 0x332e0
leaq 0x20760(%rip), %rsi     # 0x332e7
leaq 0x2076a(%rip), %rcx     # 0x332f8
movl $0x3f, %edx
callq 0x51d0
leaq 0x207a1(%rip), %rdi     # 0x33340
leaq 0x20741(%rip), %rsi     # 0x332e7
leaq 0x2074b(%rip), %rcx     # 0x332f8
movl $0x40, %edx
callq 0x51d0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x12bce
callq 0x52e0
jmp 0x12bce
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x12be2
callq 0x52e0
jmp 0x12be2
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12bf1
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpb $0x1, 0x8(%rdi)
je 0x12f4a
movq %rdi, %rbx
movslq 0xc(%rdi), %rsi
testq %rsi, %rsi
jle 0x12f69
decq %rsi
movl %esi, 0xc(%rbx)
cmpb $0x1, 0x10(%rbx)
jne 0x12efe
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x20(%rsp), %rdi
movl $0x20, %edx
callq 0x53b0
leaq 0x1ea8a(%rip), %rcx     # 0x31906
leaq 0x20(%rsp), %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5380
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x12eb6
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x12ebf
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x15922
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12eef
callq 0x52e0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x12efe
callq 0x52e0
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x20df6(%rip), %rsi     # 0x33d04
leaq 0x20df0(%rip), %rdx     # 0x33d05
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xb0e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15922
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x12f3c
callq 0x52e0
movb $0x1, 0x10(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2038f(%rip), %rdi     # 0x332e0
leaq 0x2038f(%rip), %rsi     # 0x332e7
leaq 0x204e7(%rip), %rcx     # 0x33446
movl $0x46, %edx
callq 0x51d0
leaq 0x203d0(%rip), %rdi     # 0x33340
leaq 0x20370(%rip), %rsi     # 0x332e7
leaq 0x204c8(%rip), %rcx     # 0x33446
movl $0x47, %edx
callq 0x51d0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12f9e
callq 0x52e0
jmp 0x12f9e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
jne 0x12fbc
jmp 0x12fc1
movq %rax, %rbx
jmp 0x12fc1
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x12fc1
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movb 0x9(%rdi), %r9b
movzwl 0xa(%rdi), %r8d
movb 0xc(%rdi), %dil
movb 0x8(%rax), %cl
movq (%rax), %rdx
leaq 0x23334(%rip), %rsi     # 0x363a9
movb (%rsi), %sil
incb %r9b
movb %r9b, 0x9(%rax)
incl %r8d
movw %r8w, 0xa(%rax)
cmpb %dil, %r9b
jl 0x130b9
incb %cl
movb %cl, 0x8(%rax)
movb (%rdx), %dil
cmpb %cl, %dil
jle 0x130cc
movsbl %dil, %r8d
movsbl %cl, %r9d
movb $0x0, 0x9(%rax)
movswl %r8w, %r8d
imull %r9d, %r8d
movw %r8w, 0xa(%rax)
movb %dil, 0xc(%rax)
xorl %r9d, %r9d
movswq %r8w, %r10
movq 0x10(%rdx), %r11
shlq $0x4, %r10
cmpb %sil, (%r11,%r10)
jne 0x13078
retq
movl $0xffff78fd, 0x8(%rax)  # imm = 0xFFFF78FD
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2d7a7
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x2d807
testb %al, %al
je 0x130fa
movq %rbx, %rdi
popq %rbx
jmp 0x15ae0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/sgf.h
// Function: Morat::SGFParser<Morat::Move>::move()
Move move() {
		if(_properties.count("W"))
			return Move(_properties["W"]);
		if(_properties.count("B"))
			return Move(_properties["B"]);
		return Move();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x202d7(%rip), %rsi     # 0x333f1
leaq 0x202d1(%rip), %rdx     # 0x333f2
leaq 0x10(%rsp), %rdi
callq 0xb0e0
addq $0x8, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x15c4a
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1314e
callq 0x52e0
leaq 0x10(%rsp), %rdi
testq %r14, %r14
je 0x1318a
movq %r15, (%rdi)
leaq 0x2028f(%rip), %rsi     # 0x333f1
leaq 0x20289(%rip), %rdx     # 0x333f2
callq 0xb0e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x13e58
leaq 0xe(%rsp), %rdi
movq %rax, %rsi
callq 0x11286
jmp 0x131f9
movq %r15, (%rdi)
leaq 0x2025f(%rip), %rsi     # 0x333f3
leaq 0x20259(%rip), %rdx     # 0x333f4
callq 0xb0e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x15c4a
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x131bf
callq 0x52e0
testq %r14, %r14
je 0x1320a
leaq 0x10(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x20220(%rip), %rsi     # 0x333f3
leaq 0x2021a(%rip), %rdx     # 0x333f4
callq 0xb0e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x13e58
leaq 0xe(%rsp), %rdi
movq %rax, %rsi
callq 0x11286
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x13211
callq 0x52e0
jmp 0x13211
movw $0x78fc, 0xe(%rsp)      # imm = 0x78FC
movzwl 0xe(%rsp), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1322c
jmp 0x13231
jmp 0x1322c
jmp 0x13231
jmp 0x1322c
jmp 0x13231
movq %rax, %rbx
jmp 0x13243
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x13243
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movswq 0x2(%rsi), %rax
leaq (%rax,%rax,2), %rax
movsbq %dl, %rcx
addq %rax, %rcx
leaq 0x22ba1(%rip), %rax     # 0x364d0
movq (%rax,%rcx,8), %rcx
xorq %rcx, 0x28(%rdi)
cmpw $0x5, 0x4(%rdi)
jg 0x1396e
movsbl %dl, %ecx
movsbl 0x1(%rdi), %edx
movsbl 0x1(%rsi), %r8d
movl %edx, %r9d
subl %r8d, %r9d
movsbl (%rsi), %esi
subl %esi, %edx
movsbl (%rdi), %esi
imull %edx, %esi
addl %r9d, %esi
leal (%rsi,%rsi,2), %edx
addl %ecx, %edx
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
xorq %rax, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::join_groups(int, int)
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:
movl %esi, %r8d
movq 0x10(%rdi), %rax
shlq $0x4, %r8
movzwl 0x4(%rax,%r8), %ecx
cmpl %esi, %ecx
je 0x139aa
leaq 0x4(%rax,%r8), %rsi
movl %ecx, %ecx
shlq $0x4, %rcx
movzwl 0x4(%rax,%rcx), %edi
movzwl %di, %ecx
movl %ecx, %r8d
shll $0x4, %r8d
cmpw 0x4(%rax,%r8), %di
jne 0x1398a
movw %di, (%rsi)
movl %edx, %edi
shlq $0x4, %rdi
movzwl 0x4(%rax,%rdi), %esi
cmpl %edx, %esi
je 0x139de
leaq 0x4(%rax,%rdi), %rdx
movl %esi, %esi
shlq $0x4, %rsi
movzwl 0x4(%rax,%rsi), %edi
movzwl %di, %esi
movl %esi, %r8d
shll $0x4, %r8d
cmpw 0x4(%rax,%r8), %di
jne 0x139be
movw %di, (%rdx)
cmpl %esi, %ecx
je 0x13a21
movl %ecx, %edx
shll $0x4, %edx
movzwl 0x2(%rax,%rdx), %edx
movl %esi, %edi
shll $0x4, %edi
cmpw 0x2(%rax,%rdi), %dx
movl %ecx, %edx
cmovbl %esi, %edx
movl %esi, %edi
cmovbl %ecx, %edi
shll $0x4, %edi
movw %dx, 0x4(%rax,%rdi)
movzwl 0x2(%rax,%rdi), %r8d
shll $0x4, %edx
addw %r8w, 0x2(%rax,%rdx)
movb 0x6(%rax,%rdi), %dil
orb %dil, 0x6(%rax,%rdx)
cmpl %esi, %ecx
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movw %si, 0x4(%rdi)
movw %si, 0x6(%rdi)
movq %rdx, 0x8(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x10(%rdi)
movw $0x0, 0x30(%rdi)
leaq 0x22796(%rip), %rax     # 0x363ae
movb (%rax), %cl
movb %cl, 0x32(%rdi)
movl $0xfc78fd00, 0x33(%rdi) # imm = 0xFC78FD00
movb $0x78, 0x37(%rdi)
movq $0x0, 0x38(%rdi)
movl $0xf03, %ecx            # imm = 0xF03
bextrl %ecx, %edi, %ecx
leal -0x41110000(%rcx,%rcx), %ecx
movl %ecx, (%rdi)
movzwl %si, %ecx
testl %ecx, %ecx
je 0x13c85
leaq (%rcx,%rcx,2), %rcx
shll $0x4, %ecx
leaq 0x10(%rdi,%rcx), %rcx
addq $0x10, %rdi
vmovups %ymm0, (%rdi)
movw $0x0, 0x20(%rdi)
movb (%rax), %dl
movb %dl, 0x22(%rdi)
movl $0xfc78fd00, 0x23(%rdi) # imm = 0xFC78FD00
movb $0x78, 0x27(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
cmpq %rcx, %rdi
jne 0x13c5a
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data::move(Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Data*)
void move(Data * s){
			assert(!empty()); //don't move an empty Data segment
			assert(*parent == s); //my parent points to my old location

			//update my parent with my new location
			*parent = this;

			//make sure the parent points back to the same place
			assert(parent_consistent());

			//update my children
			for(Node * i = begin(), * e = end(); i != e; ++i){
				if(i->children.data){
					i->children.data->parent = &(i->children.data);
					assert(i->children.data->parent_consistent());
				}
			}
		}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpl $0x4, %eax
jbe 0x13d46
movq 0x8(%rdi), %rcx
cmpq %rsi, (%rcx)
jne 0x13d65
movq %rdi, (%rcx)
movq 0x8(%rdi), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jne 0x13d84
movzwl 0x6(%rdi), %eax
testq %rax, %rax
je 0x13d25
shll $0x4, %eax
leaq (%rax,%rax,2), %rax
addq $0x38, %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x13d1b
movq %rdi, 0x8(%rcx)
movq (%rdi), %rcx
movl (%rcx), %edx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %edx
jne 0x13d27
addq $0x30, %rdi
addq $-0x30, %rax
jne 0x13cff
popq %rax
retq
leaq 0x1f108(%rip), %rdi     # 0x32e36
leaq 0x1eb10(%rip), %rsi     # 0x32845
leaq 0x1f07f(%rip), %rcx     # 0x32dbb
movl $0x6a, %edx
callq 0x51d0
leaq 0x1f065(%rip), %rdi     # 0x32db2
leaq 0x1eaf1(%rip), %rsi     # 0x32845
leaq 0x1f060(%rip), %rcx     # 0x32dbb
movl $0x5d, %edx
callq 0x51d0
leaq 0x1f0bd(%rip), %rdi     # 0x32e29
leaq 0x1ead2(%rip), %rsi     # 0x32845
leaq 0x1f041(%rip), %rcx     # 0x32dbb
movl $0x5e, %edx
callq 0x51d0
leaq 0x1f0bd(%rip), %rdi     # 0x32e48
leaq 0x1eab3(%rip), %rsi     # 0x32845
leaq 0x1f022(%rip), %rcx     # 0x32dbb
movl $0x64, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentMCTS::Node>::Chunk::dealloc(bool)
void dealloc(bool deallocnext = false){
			assert(capacity > 0 && mem != NULL);
			if(deallocnext && next != NULL){
				next->dealloc(deallocnext);
				delete next;
				next = NULL;
			}
			assert(next == NULL);
			capacity = 0;
			used = 0;
			delete[] (uint64_t *)mem;
			mem = NULL;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xc(%rdi)
je 0x13e1a
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x13e1a
testb %sil, %sil
je 0x13dee
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13dee
movl $0x1, %esi
callq 0x13da4
movq (%rbx), %r14
testq %r14, %r14
je 0x13de7
movq %r14, %rdi
callq 0x13c8a
movq %r14, %rdi
callq 0x52e0
movq $0x0, (%rbx)
cmpq $0x0, (%rbx)
jne 0x13e39
movq $0x0, 0xc(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x13e0a
callq 0x5440
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1f03b(%rip), %rdi     # 0x32e5c
leaq 0x1ea1d(%rip), %rsi     # 0x32845
leaq 0x1f049(%rip), %rcx     # 0x32e78
movl $0xd4, %edx
callq 0x51d0
leaq 0x1edaa(%rip), %rdi     # 0x32bea
leaq 0x1e9fe(%rip), %rsi     # 0x32845
leaq 0x1f02a(%rip), %rcx     # 0x32e78
movl $0xda, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Barrier::wait()
bool wait(){
		cond.lock();

		//wait for threads to exit
		while(counter > waitexit)
			cond.wait();

		bool flip = (++counter == numthreads);

		if(flip){
			counter--;
			if(numthreads > 1)
				counter += waitexit;
			cond.broadcast();
		}else{
			while(counter < waitexit)
				cond.wait();

			counter--;
			if(counter == waitexit){
				counter = 0;
				cond.broadcast();
			}
		}
		cond.unlock();

		return flip;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x54c0
movl 0x5c(%rbx), %eax
cmpl $0x40000001, %eax       # imm = 0x40000001
jb 0x142d8
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5510
movl 0x5c(%rbx), %eax
cmpl $0x40000000, %eax       # imm = 0x40000000
ja 0x142c3
movl 0x5c(%rbx), %ebp
incl %ebp
movl %ebp, 0x5c(%rbx)
movl 0x58(%rbx), %r15d
movl 0x5c(%rbx), %eax
cmpl %r15d, %ebp
jne 0x14303
decl %eax
movl %eax, 0x5c(%rbx)
movl 0x58(%rbx), %eax
cmpl $0x2, %eax
jb 0x14336
movl $0x40000000, %eax       # imm = 0x40000000
addl 0x5c(%rbx), %eax
jmp 0x14333
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
ja 0x14323
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5510
movl 0x5c(%rbx), %eax
cmpl $0x40000000, %eax       # imm = 0x40000000
jb 0x1430e
decl 0x5c(%rbx)
movl 0x5c(%rbx), %ecx
xorl %eax, %eax
cmpl $0x40000000, %ecx       # imm = 0x40000000
jne 0x1433f
movl %eax, 0x5c(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x50e0
cmpl %r15d, %ebp
sete %bpl
movq %rbx, %rdi
callq 0x5230
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Barrier::~Barrier()
~Barrier(){
		cond.lock();

		//wait for threads to exit
		while(counter > waitexit)
			cond.wait();

		cond.unlock();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x54c0
leaq 0x28(%rbx), %r14
movl 0x5c(%rbx), %eax
cmpl $0x40000001, %eax       # imm = 0x40000001
jb 0x14617
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5510
jmp 0x14600
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5700
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53c0
movq %rax, %rdi
callq 0xa7e4
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/thread.h
// Function: Morat::Barrier::reset(int)
void reset(int n){
		cond.lock();
		assert(counter == 0);
		numthreads = n;
		cond.unlock();
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x54c0
cmpl $0x0, 0x5c(%rbx)
jne 0x1469e
movl %ebp, 0x58(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5230
leaq 0x1eaff(%rip), %rdi     # 0x331a4
leaq 0x1eaca(%rip), %rsi     # 0x33176
leaq 0x1eafe(%rip), %rcx     # 0x331b1
movl $0xca, %edx
callq 0x51d0
nop