LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::test()
void AgentPNS::test() {
	Node n(Move("a1"));
	auto s = n.to_s();
	Node k;
	assert(k.from_s(s));
}

// Assembly:
subq $0xd8, %rsp
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5770
movq 0x10(%rsp), %rdx
leaq 0x21594(%rip), %rsi     # 0x4e849
leaq 0x90(%rsp), %rdi
callq 0x5590
jmp 0x2d2c4
leaq 0xb6(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1a5e0
jmp 0x2d2db
leaq 0xb8(%rsp), %rdi
leaq 0xb6(%rsp), %rsi
movl $0x1, %edx
callq 0x30070
jmp 0x2d2f7
leaq 0x90(%rsp), %rdi
callq 0x5260
leaq 0x8f(%rsp), %rdi
callq 0x5450
leaq 0x58(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x2c960
jmp 0x2d325
leaq 0x38(%rsp), %rdi
callq 0x300c0
jmp 0x2d331
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x51b0
jmp 0x2d342
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2cda0
movb %al, 0xf(%rsp)
jmp 0x2d357
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2d361
jmp 0x2d366
jmp 0x2d421
leaq 0x214df(%rip), %rdi     # 0x4e84c
leaq 0x214e4(%rip), %rsi     # 0x4e858
movl $0x27, %edx
leaq 0x214e9(%rip), %rcx     # 0x4e869
callq 0x52a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x2d3b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5260
leaq 0x8f(%rsp), %rdi
callq 0x5450
jmp 0x2d475
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x2d468
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x2d45e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x2d454
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5260
jmp 0x2d454
leaq 0x18(%rsp), %rdi
callq 0x5260
leaq 0x38(%rsp), %rdi
callq 0x30100
leaq 0x58(%rsp), %rdi
callq 0x5260
leaq 0xb8(%rsp), %rdi
callq 0x30100
addq $0xd8, %rsp
retq
leaq 0x38(%rsp), %rdi
callq 0x30100
leaq 0x58(%rsp), %rdi
callq 0x5260
leaq 0xb8(%rsp), %rdi
callq 0x30100
movq 0x80(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::AgentThread::updatePDnum(Morat::Hex::AgentPNS::Node*)
bool AgentPNS::AgentThread::updatePDnum(Node * node){
	Node * i = node->children.begin();
	Node * end = node->children.end();

	uint32_t min = i->delta;
	uint64_t sum = 0;

	bool win = false;
	for( ; i != end; i++){
		win |= (i->phi == LOSS);
		sum += i->phi;
		if( min > i->delta)
			min = i->delta;
	}

	if(win)
		sum = LOSS;
	else if(sum >= INF32)
		sum = INF32;

	if(min == node->phi && sum == node->delta){
		return false;
	}else{
		if(sum == 0 && min == DRAW){
			node->phi = 0;
			node->delta = DRAW;
		}else{
			node->phi = min;
			node->delta = sum;
		}
		return true;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x30e90
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x30ee0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x2ece1
movq 0x28(%rsp), %rax
cmpl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jbe 0x2eccf
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x2ecd1
movq 0x28(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x28(%rsp)
jmp 0x2ec6e
testb $0x1, 0xf(%rsp)
je 0x2ecf3
movq $0x3fffffff, 0x10(%rsp) # imm = 0x3FFFFFFF
jmp 0x2ed09
cmpq $0x3ffffffd, 0x10(%rsp) # imm = 0x3FFFFFFD
jb 0x2ed07
movq $0x3ffffffd, 0x10(%rsp) # imm = 0x3FFFFFFD
jmp 0x2ed09
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x2ed2f
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jne 0x2ed2f
movb $0x0, 0x47(%rsp)
jmp 0x2ed79
cmpq $0x0, 0x10(%rsp)
jne 0x2ed5a
cmpl $0x3ffffffe, 0x1c(%rsp) # imm = 0x3FFFFFFE
jne 0x2ed5a
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movq 0x30(%rsp), %rax
movl $0x3ffffffe, 0x4(%rax)  # imm = 0x3FFFFFFE
jmp 0x2ed74
movl 0x1c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::find_child(Morat::Hex::AgentPNS::Node const*, Morat::Move const&) const
AgentPNS::Node * AgentPNS::find_child(const Node * node, const Move & move) const {
	for(auto & n : node->children)
		if(n.move == move)
			return &n;

	return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30e90
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30ee0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2f2dc
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x12, %rdi
movq 0x28(%rsp), %rsi
callq 0x1c3e0
testb $0x1, %al
jne 0x2f2be
jmp 0x2f2ca
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2f2e5
jmp 0x2f2cc
movq 0x18(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f28f
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::garbage_collect(Morat::Hex::AgentPNS::Node*)
void AgentPNS::garbage_collect(Node * node){
	Node * child = node->children.begin();
	Node * end = node->children.end();

	for( ; child != end; child++){
		if(child->terminal() || child->work < gclimit){ //solved or low work, ignore solvedness since it's trivial to re-solve
			nodes -= child->dealloc(ctmem);
		}else if(child->children.num() > 0){
			garbage_collect(child);
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x30e90
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x30ee0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x2f7c1
movq 0x10(%rsp), %rdi
callq 0x305e0
testb $0x1, %al
jne 0x2f760
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x68(%rcx), %ecx
cmpq %rcx, %rax
jae 0x2f789
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x70, %rsi
callq 0x30ff0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x58(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x58(%rax)
jmp 0x2f7ac
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x2ffb0
cmpl $0x0, %eax
jbe 0x2f7aa
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f6f0
jmp 0x2f7ac
jmp 0x2f7ae
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f72d
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentpns.cpp
// Function: Morat::Hex::AgentPNS::create_children_simple(Morat::Hex::Board const&, Morat::Hex::AgentPNS::Node*)
void AgentPNS::create_children_simple(const Board & board, Node * node){
	assert(node->children.empty());
	node->children.alloc(board.moves_avail(), ctmem);
	unsigned int i = 0;
	for (auto move : board) {
		Outcome outcome = board.test_outcome(move);
		node->children[i] = Node(move).outcome(outcome, board.to_play(), ties, 1);
		i++;
	}
	PLUS(nodes, i);
	node->children.shrink(i); //if symmetry, there may be extra moves to ignore
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xc0(%rsp), %rdi
addq $0x18, %rdi
callq 0x305c0
testb $0x1, %al
jne 0x2f813
jmp 0x2f815
jmp 0x2f834
leaq 0x1dc2e(%rip), %rdi     # 0x4d44a
leaq 0x1f035(%rip), %rsi     # 0x4e858
movl $0x142, %edx            # imm = 0x142
leaq 0x1f130(%rip), %rcx     # 0x4e95f
callq 0x52a0
movq 0xc0(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x20(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x1d310
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rdi
movl %eax, %esi
addq $0x70, %rdx
callq 0x306b0
movl $0x0, 0xbc(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x1d370
movq %rdx, 0x98(%rsp)
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq 0x95(%rsp), %rcx
movq %rcx, 0xa5(%rsp)
movq %rax, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x1d3a0
movq %rdx, 0x78(%rsp)
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x88(%rsp)
movb 0x7c(%rsp), %al
movb %al, 0x8c(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1d3f0
testb $0x1, %al
jne 0x2f917
jmp 0x2fa26
leaq 0xa0(%rsp), %rdi
callq 0x1d420
movl (%rax), %eax
movl %eax, 0x6c(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x29410
movq 0x10(%rsp), %rsi
movb %al, 0x6b(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x30070
movb 0x6b(%rsp), %al
movb %al, 0x47(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x1a8a0
movb %al, 0x1f(%rsp)
jmp 0x2f974
movq 0x28(%rsp), %rax
movb 0x1f(%rsp), %cl
movb %cl, 0x46(%rsp)
movb 0x1534(%rax), %al
movb %al, 0x33(%rsp)
movzbl 0x33(%rsp), %ecx
movzbl 0x46(%rsp), %edx
movzbl 0x47(%rsp), %esi
leaq 0x48(%rsp), %rdi
movl $0x1, %r8d
callq 0x30ad0
movq %rax, 0x8(%rsp)
jmp 0x2f9b1
movq 0xc0(%rsp), %rdi
addq $0x18, %rdi
movl 0xbc(%rsp), %esi
callq 0x30c20
movq %rax, (%rsp)
jmp 0x2f9cf
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x30cd0
jmp 0x2f9df
leaq 0x48(%rsp), %rdi
callq 0x30100
movl 0xbc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xbc(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1d4b0
jmp 0x2f8f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x30100
jmp 0x2fa5c
movq 0x28(%rsp), %rdi
addq $0x58, %rdi
leaq 0xbc(%rsp), %rsi
callq 0x1d5c0
movq 0xc0(%rsp), %rdi
addq $0x18, %rdi
movl 0xbc(%rsp), %esi
callq 0x30d60
addq $0xd8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::Node::to_outcome(Morat::Side) const
Outcome to_outcome(Side to_play) const {
			if(phi   == LOSS) return +to_play;
			if(delta == LOSS) return +~to_play;
			if(delta == DRAW) return Outcome::DRAW;
			return Outcome::UNKNOWN;
		}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movb %al, 0x26(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
jne 0x3054a
movb 0x26(%rsp), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %edi
callq 0x1fba0
movb %al, 0x27(%rsp)
jmp 0x305a8
movq 0x8(%rsp), %rax
cmpl $0x3fffffff, 0x4(%rax)  # imm = 0x3FFFFFFF
jne 0x3057e
movb 0x26(%rsp), %al
movb %al, 0x15(%rsp)
movzbl 0x15(%rsp), %edi
callq 0x1c680
movb %al, 0x16(%rsp)
movzbl 0x16(%rsp), %edi
callq 0x1fba0
movb %al, 0x27(%rsp)
jmp 0x305a8
movq 0x8(%rsp), %rax
cmpl $0x3ffffffe, 0x4(%rax)  # imm = 0x3FFFFFFE
jne 0x3059b
leaq 0x3cf30(%rip), %rax     # 0x6d4c3
movb (%rax), %al
movb %al, 0x27(%rsp)
jmp 0x305a8
leaq 0x3cf1e(%rip), %rax     # 0x6d4c0
movb (%rax), %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/agent.h
// Function: Morat::Hex::Agent::solve1ply(Morat::Hex::Board const&, unsigned int&)
static Outcome solve1ply(const Board & board, unsigned int & nodes) {
		Outcome outcome = Outcome::UNKNOWN;
		Side turn = board.to_play();
		for (auto move : board) {
			++nodes;
			Outcome won = board.test_outcome(move, turn);

			if(won == +turn)
				return won;
			if(won == Outcome::DRAW)
				outcome = Outcome::DRAW;
		}
		return outcome;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
leaq 0x3cd8b(%rip), %rax     # 0x6d4c0
movb (%rax), %al
movb %al, 0x5f(%rsp)
movq 0x68(%rsp), %rdi
callq 0x1a8a0
movb %al, 0x5e(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1d370
movq %rdx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x35(%rsp), %rcx
movq %rcx, 0x45(%rsp)
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1d3a0
movq %rdx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x28(%rsp)
movb 0x1c(%rsp), %al
movb %al, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1d3f0
testb $0x1, %al
jne 0x307c1
jmp 0x3085f
leaq 0x40(%rsp), %rdi
callq 0x1d420
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x68(%rsp), %rdi
movb 0x5e(%rsp), %al
movb %al, 0xb(%rsp)
leaq 0xc(%rsp), %rsi
movzbl 0xb(%rsp), %edx
callq 0x29460
movb %al, 0x77(%rsp)
movb 0x5e(%rsp), %al
movb %al, 0x9(%rsp)
movzbl 0x9(%rsp), %edi
callq 0x1fba0
movb %al, 0xa(%rsp)
leaq 0x77(%rsp), %rdi
leaq 0xa(%rsp), %rsi
callq 0x1c810
testb $0x1, %al
jne 0x30828
jmp 0x3082a
jmp 0x30867
leaq 0x77(%rsp), %rdi
leaq 0x3cc8d(%rip), %rsi     # 0x6d4c3
callq 0x1c810
testb $0x1, %al
jne 0x30841
jmp 0x3084e
leaq 0x3cc7b(%rip), %rax     # 0x6d4c3
movb (%rax), %al
movb %al, 0x5f(%rsp)
jmp 0x30850
leaq 0x40(%rsp), %rdi
callq 0x1d4b0
jmp 0x307a9
movb 0x5f(%rsp), %al
movb %al, 0x77(%rsp)
movb 0x77(%rsp), %al
addq $0x78, %rsp
retq
// File: tewalds[P]morat/hex/agent.h
// Function: Morat::Hex::Agent::solve2ply(Morat::Hex::Board const&, unsigned int&)
static Outcome solve2ply(const Board & board, unsigned int & nodes) {
		int losses = 0;
		Outcome outcome = Outcome::UNKNOWN;
		Side turn = board.to_play();
		Side op = ~turn;
		for (auto move : board) {
			++nodes;
			Outcome won = board.test_outcome(move, turn);

			if(won == +turn)
				return won;
			if(won == Outcome::DRAW)
				outcome = Outcome::DRAW;

			if(board.test_outcome(move, op) == +op)
				losses++;
		}
		if(losses >= 2)
			return (Outcome)op;
		return outcome;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
leaq 0x3cc33(%rip), %rax     # 0x6d4c0
movb (%rax), %al
movb %al, 0x5b(%rsp)
movq 0x68(%rsp), %rdi
callq 0x1a8a0
movb %al, 0x5a(%rsp)
movb 0x5a(%rsp), %al
movb %al, 0x58(%rsp)
movzbl 0x58(%rsp), %edi
callq 0x1c680
movb %al, 0x59(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1d370
movq %rdx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x35(%rsp), %rcx
movq %rcx, 0x45(%rsp)
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1d3a0
movq %rdx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x28(%rsp)
movb 0x1c(%rsp), %al
movb %al, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1d3f0
testb $0x1, %al
jne 0x3092f
jmp 0x30a26
leaq 0x40(%rsp), %rdi
callq 0x1d420
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x68(%rsp), %rdi
movb 0x5a(%rsp), %al
movb %al, 0xb(%rsp)
leaq 0xc(%rsp), %rsi
movzbl 0xb(%rsp), %edx
callq 0x29460
movb %al, 0x77(%rsp)
movb 0x5a(%rsp), %al
movb %al, 0x9(%rsp)
movzbl 0x9(%rsp), %edi
callq 0x1fba0
movb %al, 0xa(%rsp)
leaq 0x77(%rsp), %rdi
leaq 0xa(%rsp), %rsi
callq 0x1c810
testb $0x1, %al
jne 0x30996
jmp 0x3099b
jmp 0x30a46
leaq 0x77(%rsp), %rdi
leaq 0x3cb1c(%rip), %rsi     # 0x6d4c3
callq 0x1c810
testb $0x1, %al
jne 0x309b2
jmp 0x309bf
leaq 0x3cb0a(%rip), %rax     # 0x6d4c3
movb (%rax), %al
movb %al, 0x5b(%rsp)
movq 0x68(%rsp), %rdi
movb 0x59(%rsp), %al
movb %al, 0x7(%rsp)
leaq 0xc(%rsp), %rsi
movzbl 0x7(%rsp), %edx
callq 0x29460
movb %al, 0x8(%rsp)
movb 0x59(%rsp), %al
movb %al, 0x5(%rsp)
movzbl 0x5(%rsp), %edi
callq 0x1fba0
movb %al, 0x6(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rsi
callq 0x1c810
testb $0x1, %al
jne 0x30a0a
jmp 0x30a15
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x30a17
leaq 0x40(%rsp), %rdi
callq 0x1d4b0
jmp 0x30917
cmpl $0x2, 0x5c(%rsp)
jl 0x30a3e
leaq 0x77(%rsp), %rdi
leaq 0x59(%rsp), %rsi
callq 0x31a90
jmp 0x30a46
movb 0x5b(%rsp), %al
movb %al, 0x77(%rsp)
movb 0x77(%rsp), %al
addq $0x78, %rsp
retq
nop
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::Node::outcome(Morat::Outcome, Morat::Side, Morat::Side, int)
Node & outcome(Outcome outcome, Side to_play, Side assign, int value = 1){
			if(assign != Side::NONE && outcome == Outcome::DRAW)
				outcome = +assign;

			if(     outcome == Outcome::UNKNOWN) { phi = value; delta = value; }
			else if(outcome == +to_play)          { phi = LOSS;  delta = 0;     }
			else if(outcome == +~to_play)         { phi = 0;     delta = LOSS; }
			else /*(outcome == Outcome::DRAW)*/  { phi = 0;     delta = DRAW; }
			return *this;
		}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dl, 0x27(%rsp)
movb %cl, 0x26(%rsp)
movb %al, 0x25(%rsp)
movq %rdi, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x25(%rsp), %rdi
leaq 0x3c9b5(%rip), %rsi     # 0x6d4bb
callq 0x29c60
testb $0x1, %al
jne 0x30b11
jmp 0x30b46
leaq 0x27(%rsp), %rdi
leaq 0x3c9a6(%rip), %rsi     # 0x6d4c3
callq 0x1c810
testb $0x1, %al
jne 0x30b28
jmp 0x30b46
movb 0x25(%rsp), %al
movb %al, 0x12(%rsp)
movzbl 0x12(%rsp), %edi
callq 0x1fba0
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
movb %al, 0x27(%rsp)
leaq 0x27(%rsp), %rdi
leaq 0x3c96e(%rip), %rsi     # 0x6d4c0
callq 0x1c810
testb $0x1, %al
jne 0x30b5d
jmp 0x30b73
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x30c12
movb 0x26(%rsp), %al
movb %al, 0x10(%rsp)
movzbl 0x10(%rsp), %edi
callq 0x1fba0
movb %al, 0x11(%rsp)
leaq 0x27(%rsp), %rdi
leaq 0x11(%rsp), %rsi
callq 0x1c810
testb $0x1, %al
jne 0x30b9e
jmp 0x30bb1
movq (%rsp), %rax
movl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
movl $0x0, 0x4(%rax)
jmp 0x30c10
movb 0x26(%rsp), %al
movb %al, 0xd(%rsp)
movzbl 0xd(%rsp), %edi
callq 0x1c680
movb %al, 0xe(%rsp)
movzbl 0xe(%rsp), %edi
callq 0x1fba0
movb %al, 0xf(%rsp)
leaq 0x27(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x1c810
testb $0x1, %al
jne 0x30bea
jmp 0x30bfd
movq (%rsp), %rax
movl $0x0, (%rax)
movl $0x3fffffff, 0x4(%rax)  # imm = 0x3FFFFFFF
jmp 0x30c0e
movq (%rsp), %rax
movl $0x0, (%rax)
movl $0x3ffffffe, 0x4(%rax)  # imm = 0x3FFFFFFE
jmp 0x30c10
jmp 0x30c12
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::Node::operator=(Morat::Hex::AgentPNS::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());

				phi = n.phi;
				delta = n.delta;
				work = n.work;
				move = n.move;
				//don't copy the children
			}
			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 0x30d54
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x305c0
testb $0x1, %al
jne 0x30d01
jmp 0x30d03
jmp 0x30d22
leaq 0x1c746(%rip), %rdi     # 0x4d450
leaq 0x1dce5(%rip), %rsi     # 0x4e9f6
movl $0x2d, %edx
leaq 0x1dd0c(%rip), %rcx     # 0x4ea29
callq 0x52a0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movw 0x12(%rcx), %cx
movw %cx, 0x12(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::~AgentPNS()
~AgentPNS(){
		pool.pause();
		pool.set_num_threads(0);

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x3b9fe(%rip), %rax     # 0x6cb18
movq %rax, (%rdi)
addq $0x1430, %rdi           # imm = 0x1430
callq 0x31ee0
jmp 0x3112b
movq 0x8(%rsp), %rdi
addq $0x1430, %rdi           # imm = 0x1430
xorl %esi, %esi
callq 0x31f70
jmp 0x31140
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x1540, %rdi           # imm = 0x1540
addq $0x70, %rsi
callq 0x30ff0
jmp 0x3115a
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
vpxor %xmm1, %xmm1, %xmm1
vmovaps %xmm1, %xmm0
callq 0x321a0
jmp 0x31172
movq 0x8(%rsp), %rdi
addq $0x1540, %rdi           # imm = 0x1540
callq 0x30100
movq 0x8(%rsp), %rdi
addq $0x1430, %rdi           # imm = 0x1430
callq 0x32790
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0x32800
movq 0x8(%rsp), %rdi
callq 0x1e390
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xd890
nopl (%rax)
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::set_board(Morat::Hex::Board const&, bool)
void set_board(const Board & board, bool clear = true){
		rootboard = board;
		reset();
		if(clear)
			clear_mem();
	}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
addq $0x10, %rdi
callq 0x1c2d0
movq 0x8(%rsp), %rdi
callq 0x34700
testb $0x1, 0x17(%rsp)
je 0x3129a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
addq $0x28, %rsp
retq
nop
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::clear_mem()
void clear_mem(){
		reset();
		root.dealloc(ctmem);
		ctmem.compact();
		root = Node(0, 0, 1);
		nodes = 0;
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x34700
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x1540, %rdi           # imm = 0x1540
movq %rdi, 0x10(%rsp)
addq $0x70, %rsi
movq %rsi, 0x8(%rsp)
callq 0x30ff0
movq 0x8(%rsp), %rdi
vpxor %xmm1, %xmm1, %xmm1
vmovaps %xmm1, %xmm0
callq 0x321a0
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %edx, %edx
movl $0x1, %ecx
movl %edx, %esi
callq 0x347e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x30cd0
jmp 0x318e3
leaq 0x30(%rsp), %rdi
callq 0x30100
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x30100
movq 0x28(%rsp), %rdi
callq 0x5760
// File: tewalds[P]morat/hex/agentpns.h
// Function: Morat::Hex::AgentPNS::gen_sgf(Morat::SGFPrinter<Morat::Move>&, int) const
void gen_sgf(SGFPrinter<Move> & sgf, int limit) const {
		if(limit < 0){
			limit = 0;
			//TODO: Set the root.work properly
			for(auto & child : root.children)
				limit += child.work;
			limit /= 1000;
		}
		gen_sgf(sgf, limit, root, rootboard.to_play());
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x54(%rsp)
jge 0x319cc
movq 0x20(%rsp), %rax
movl $0x0, 0x54(%rsp)
addq $0x1540, %rax           # imm = 0x1540
addq $0x18, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x30e90
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x30ee0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x319bc
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x54(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x54(%rsp)
movq 0x40(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x40(%rsp)
jmp 0x31981
movl 0x54(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, 0x54(%rsp)
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x14(%rsp)
movq %rdi, %rax
addq $0x1540, %rax           # imm = 0x1540
movq %rax, 0x18(%rsp)
addq $0x10, %rdi
callq 0x1a8a0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %r8d
callq 0x2fa70
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/compacttree.h
// Function: Morat::CompactTree<Morat::Hex::AgentPNS::Node>::Data::shrink(int)
int shrink(int n){
			assert(n > 0 && n <= capacity && n <= used);
			for(Node * i = children + n, * e = children + used; i != e; ++i)
				i->~Node();
			int diff = used - n;
			used = n;
			return diff;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x2c(%rsp)
movb %al, 0x13(%rsp)
jle 0x356e1
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %ecx
movzwl 0x4(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0x13(%rsp)
jg 0x356e1
movq 0x8(%rsp), %rcx
movl 0x2c(%rsp), %eax
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
setle %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x356eb
jmp 0x356ed
jmp 0x3570c
leaq 0x19a83(%rip), %rdi     # 0x4f177
leaq 0x17f6d(%rip), %rsi     # 0x4d668
movl $0x4e, %edx
leaq 0x19a94(%rip), %rcx     # 0x4f19b
callq 0x52a0
movq 0x8(%rsp), %rcx
movq %rcx, %rax
addq $0x10, %rax
movslq 0x2c(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rax, 0x20(%rsp)
movq %rcx, %rax
addq $0x10, %rax
movzwl 0x6(%rcx), %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x35769
movq 0x20(%rsp), %rdi
callq 0x30100
movq 0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
jmp 0x35743
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %ecx
subl 0x2c(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movl 0x2c(%rsp), %ecx
movw %cx, 0x6(%rax)
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/board.cpp
// Function: Morat::Hex::Board::edges(int, int) const
int Board::edges(int x, int y) const {
	return (y == 0       ? 1 : 0) |
	       (y == sizem1_ ? 2 : 0) |
	       (x == 0       ? 4 : 0) |
	       (x == sizem1_ ? 8 : 0);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rcx
movl -0x10(%rsp), %esi
xorl %eax, %eax
movl $0x1, %edx
cmpl $0x0, %esi
cmovel %edx, %eax
movl -0x10(%rsp), %edi
movsbl 0x1(%rcx), %r8d
xorl %edx, %edx
movl $0x2, %esi
cmpl %r8d, %edi
cmovel %esi, %edx
orl %edx, %eax
movl -0xc(%rsp), %edi
xorl %edx, %edx
movl $0x4, %esi
cmpl $0x0, %edi
cmovel %esi, %edx
orl %edx, %eax
movl -0xc(%rsp), %esi
movsbl 0x1(%rcx), %edi
xorl %ecx, %ecx
movl $0x8, %edx
cmpl %edi, %esi
cmovel %edx, %ecx
orl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/gtpagent.cpp
// Function: Morat::Hex::GTP::gtp_move_stats(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_move_stats(vecstr args){
	vector<Move> moves;
	for(auto s : args)
		moves.push_back(Move(s));
	return GTPResponse(true, agent->move_stats(moves));
}

// Assembly:
subq $0xb8, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x118a0
movq 0x18(%rsp), %rdx
movq %rdx, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x13d30
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x141f0
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x141b0
testb $0x1, %al
jne 0x37cf3
jmp 0x37d74
leaq 0x78(%rsp), %rdi
callq 0x3ea60
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x51b0
jmp 0x37d0c
leaq 0x42(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1a5e0
jmp 0x37d1d
leaq 0x88(%rsp), %rdi
leaq 0x42(%rsp), %rsi
callq 0x1c6c0
jmp 0x37d31
leaq 0x50(%rsp), %rdi
callq 0x5260
leaq 0x78(%rsp), %rdi
callq 0x3ea70
jmp 0x37cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x37de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5260
jmp 0x37de9
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rsi
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq *%rax
jmp 0x37d98
movq (%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
callq 0xd9a0
jmp 0x37dad
leaq 0x20(%rsp), %rdi
callq 0x5260
leaq 0x88(%rsp), %rdi
callq 0x11920
movq 0x8(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5260
leaq 0x88(%rsp), %rdi
callq 0x11920
movq 0x48(%rsp), %rdi
callq 0x5760
// File: tewalds[P]morat/hex/gtpagent.cpp
// Function: Morat::Hex::GTP::gtp_params(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_params(vecstr args){
//	if(dynamic_cast<AgentAB   *>(agent)) return gtp_ab_params(args);
	if(dynamic_cast<AgentMCTS *>(agent)) return gtp_mcts_params(args);
	if(dynamic_cast<AgentPNS  *>(agent)) return gtp_pns_params(args);

	return GTPResponse(false, "Unknown Agent type");
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xd8(%rax), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x38fe3
movq 0x50(%rsp), %rdi
leaq 0x33914(%rip), %rsi     # 0x6c8e0
leaq 0x338f5(%rip), %rdx     # 0x6c8c8
xorl %eax, %eax
movl %eax, %ecx
callq 0x5480
movq %rax, 0x28(%rsp)
jmp 0x38fec
xorl %eax, %eax
movq %rax, 0x28(%rsp)
jmp 0x38fec
movq 0x28(%rsp), %rax
cmpq $0x0, %rax
je 0x3905c
movq 0x30(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x13f30
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x391c0
jmp 0x39024
leaq 0xa8(%rsp), %rdi
callq 0xe140
jmp 0x3919d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xe140
jmp 0x391aa
movq 0x48(%rsp), %rax
movq 0xd8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x39096
movq 0x18(%rsp), %rdi
leaq 0x33861(%rip), %rsi     # 0x6c8e0
leaq 0x33b02(%rip), %rdx     # 0x6cb88
xorl %eax, %eax
movl %eax, %ecx
callq 0x5480
movq %rax, 0x10(%rsp)
jmp 0x3909f
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x3909f
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
je 0x3910f
movq 0x30(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13f30
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3dad0
jmp 0x390d7
leaq 0x80(%rsp), %rdi
callq 0xe140
jmp 0x3919d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xe140
jmp 0x391aa
leaq 0x5f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5770
movq (%rsp), %rdx
leaq 0x165f8(%rip), %rsi     # 0x4f720
leaq 0x60(%rsp), %rdi
callq 0x5590
jmp 0x39134
movq 0x38(%rsp), %rdi
xorl %esi, %esi
leaq 0x60(%rsp), %rdx
callq 0xd9a0
jmp 0x39147
leaq 0x60(%rsp), %rdi
callq 0x5260
leaq 0x5f(%rsp), %rdi
callq 0x5450
jmp 0x3919d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x39191
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5260
leaq 0x5f(%rsp), %rdi
callq 0x5450
jmp 0x391aa
movq 0x40(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x5760
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/timecontrol.h
// Function: Morat::TimeControl::get_time(int, int, int) const
double get_time(int moves_made, int moves_remain_max, int moves_remain_estimate) const {
		double ret = 0;

		switch(method){
			case PERCENT:
				ret += param * remain / 100.0;
				break;
			case STATS:
				if(moves_remain_estimate > 0){
					// 2* because there are 2 players
					ret += 2 * param * remain / moves_remain_estimate;
					break;
				}  //fall back to even
			case EVEN:
				// 2* because there are 2 players
				ret += 2 * param * remain / moves_remain_max;
				break;
			// TODO: add a method that takes into account the number of moves made so
			// far. This should gives shorter time for the early moves, preferring to
			// spend it in the mid-game.
		}

		return std::min(ret, remain) + move;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl (%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x3eb7d
jmp 0x3eb64
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x3ebde
jmp 0x3eb6f
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0x3eba6
jmp 0x3ec0b
movq 0x8(%rsp), %rax
vmovsd 0x8(%rax), %xmm0
vmulsd 0x30(%rax), %xmm0, %xmm0
vmovsd 0xe644(%rip), %xmm1     # 0x4d1d8
vdivsd %xmm1, %xmm0, %xmm0
vaddsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
jmp 0x3ec0b
cmpl $0x0, 0x24(%rsp)
jle 0x3ebdc
movq 0x8(%rsp), %rax
vmovsd 0xd45e(%rip), %xmm0     # 0x4c018
vmulsd 0x8(%rax), %xmm0, %xmm0
vmulsd 0x30(%rax), %xmm0, %xmm0
vcvtsi2sdl 0x24(%rsp), %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vaddsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
jmp 0x3ec0b
jmp 0x3ebde
movq 0x8(%rsp), %rax
vmovsd 0xd42d(%rip), %xmm0     # 0x4c018
vmulsd 0x8(%rax), %xmm0, %xmm0
vmulsd 0x30(%rax), %xmm0, %xmm0
vcvtsi2sdl 0x28(%rsp), %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vaddsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
leaq 0x18(%rsp), %rdi
callq 0x3f010
movq %rax, %rcx
movq 0x8(%rsp), %rax
vmovsd (%rcx), %xmm0
vaddsd 0x18(%rax), %xmm0, %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/timecontrol.h
// Function: Morat::TimeControl::use(double)
void use(double used){
		if(flexible)
			remain += move - used;
		else
			remain += std::min(0.0, move - used);

		if(remain < 0)
			remain = 0;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
vmovsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x20(%rax)
je 0x3ed19
movq (%rsp), %rax
vmovsd 0x18(%rax), %xmm0
vsubsd 0x18(%rsp), %xmm0, %xmm0
vaddsd 0x30(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rax)
jmp 0x3ed5c
movq (%rsp), %rax
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
vmovsd 0x18(%rax), %xmm0
vsubsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3f010
movq %rax, %rcx
movq (%rsp), %rax
vmovsd (%rcx), %xmm0
vaddsd 0x30(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rax)
movq (%rsp), %rax
vpxor %xmm0, %xmm0, %xmm0
vucomisd 0x30(%rax), %xmm0
jbe 0x3ed78
movq (%rsp), %rax
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/hex/../lib/history.h
// Function: Morat::History<Morat::Hex::Board>::move(Morat::Move const&)
bool move(const Move & m) {
		if(board.valid_move(m)){
			board.move(m);
			hist.push_back(m);
			return true;
		}
		return false;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movq 0x10(%rsp), %rsi
callq 0x3f0c0
testb $0x1, %al
jne 0x3f07c
jmp 0x3f0ac
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x1c500
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1c610
movb $0x1, 0x27(%rsp)
jmp 0x3f0b1
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_print(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_print(vecstr args){
	Board board = *hist;
	for(auto arg : args)
		if (!board.move(arg))
			break;
	return GTPResponse(true, "\n" + board.to_s(colorboard));
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdx, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x108(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x68, %rdi
callq 0xc070
movq %rax, %rsi
leaq 0xb8(%rsp), %rdi
callq 0x118b0
movq 0x20(%rsp), %rdx
movq %rdx, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x13d30
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x141f0
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x141b0
testb $0x1, %al
jne 0x3f48c
jmp 0x3f55c
leaq 0xa8(%rsp), %rdi
callq 0x3ea60
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x51b0
jmp 0x3f4ab
leaq 0x72(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1a5e0
jmp 0x3f4bf
leaq 0xb8(%rsp), %rdi
leaq 0x72(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x1c500
movb %al, 0x7(%rsp)
jmp 0x3f4de
movb 0x7(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f4ea
jmp 0x3f527
movl $0x2, 0x6c(%rsp)
jmp 0x3f52f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x3f615
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5260
jmp 0x3f615
movl $0x0, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5260
movl 0x6c(%rsp), %eax
testl %eax, %eax
je 0x3f548
jmp 0x3f546
jmp 0x3f55c
jmp 0x3f54a
leaq 0xa8(%rsp), %rdi
callq 0x3ea70
jmp 0x3f46e
movq 0x18(%rsp), %rax
movzbl 0xcd(%rax), %edx
andl $0x1, %edx
leaq 0x28(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x35f30
jmp 0x3f57f
leaq 0xd362(%rip), %rsi      # 0x4c8e8
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x19f30
jmp 0x3f597
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
callq 0xd9a0
jmp 0x3f5ad
leaq 0x48(%rsp), %rdi
callq 0x5260
leaq 0x28(%rsp), %rdi
callq 0x5260
movl $0x1, 0x6c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xc040
movq 0x10(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x3f60b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5260
leaq 0x28(%rsp), %rdi
callq 0x5260
leaq 0xb8(%rsp), %rdi
callq 0xc040
movq 0x78(%rsp), %rdi
callq 0x5760
nopl (%rax)
// File: tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_clearboard(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_clearboard(vecstr args){
	hist.clear();
	set_board();
	time_control.new_game();

	return GTPResponse(true);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x68, %rdi
callq 0x436c0
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xc080
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x436a0
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5770
movq 0x20(%rsp), %rdx
leaq 0xcebe(%rip), %rsi      # 0x4c8e9
leaq 0x40(%rsp), %rdi
callq 0x5590
jmp 0x3fa37
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
callq 0xd9a0
jmp 0x3fa4d
leaq 0x40(%rsp), %rdi
callq 0x5260
leaq 0x3f(%rsp), %rdi
callq 0x5450
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x3fa93
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
movq 0x30(%rsp), %rdi
callq 0x5760
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_undo(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_undo(vecstr args){
	int num = (args.size() >= 1 ? from_str<int>(args[0]) : 1);

	while(num--){
		hist.undo();
	}
	set_board(false);
	if(verbose >= 2)
		logerr(hist->to_s(colorboard) + "\n");
	return GTPResponse(true);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdi, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x13c80
cmpq $0x1, %rax
jb 0x3fb1d
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13ca0
movq %rax, %rdi
callq 0x10220
movl %eax, 0x1c(%rsp)
jmp 0x3fb28
movl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3fb28
movl 0x1c(%rsp), %eax
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0xbc(%rsp)
cmpl $0x0, %eax
je 0x3fb5b
movq 0x38(%rsp), %rdi
addq $0x68, %rdi
callq 0x436f0
jmp 0x3fb33
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xc080
movq 0x38(%rsp), %rax
cmpl $0x2, 0xc8(%rax)
jl 0x3fc25
movq 0x38(%rsp), %rdi
addq $0x68, %rdi
callq 0x3ea90
movq %rax, %rsi
movq 0x38(%rsp), %rax
movzbl 0xcd(%rax), %edx
andl $0x1, %edx
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35f30
movq 0x10(%rsp), %rsi
leaq 0xcd34(%rip), %rdx      # 0x4c8e8
leaq 0x98(%rsp), %rdi
callq 0xb910
jmp 0x3fbc3
leaq 0x98(%rsp), %rdi
callq 0x1a9b0
jmp 0x3fbd2
leaq 0x98(%rsp), %rdi
callq 0x5260
leaq 0x78(%rsp), %rdi
callq 0x5260
jmp 0x3fc25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3fc16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5260
leaq 0x78(%rsp), %rdi
callq 0x5260
jmp 0x3fcb5
leaq 0x47(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5770
movq 0x8(%rsp), %rdx
leaq 0xcca9(%rip), %rsi      # 0x4c8e9
leaq 0x48(%rsp), %rdi
callq 0x5590
jmp 0x3fc4c
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
callq 0xd9a0
jmp 0x3fc62
leaq 0x48(%rsp), %rdi
callq 0x5260
leaq 0x47(%rsp), %rdi
callq 0x5450
movq 0x30(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3fcab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5260
leaq 0x47(%rsp), %rdi
callq 0x5450
movq 0x70(%rsp), %rdi
callq 0x5760
nop
// File: tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_all_legal(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_all_legal(vecstr args){
	std::string ret;
	for (auto move : *hist)
		ret += move.to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x55a0
movq 0x40(%rsp), %rdi
addq $0x68, %rdi
callq 0xc070
movq %rax, 0x48(%rsp)
jmp 0x4015b
movq 0x48(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rdi
callq 0x1d370
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0x40181
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0xd8(%rsp)
movq %rax, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xdd(%rsp), %rcx
movq %rcx, 0xed(%rsp)
movq %rax, 0xe8(%rsp)
movq 0x108(%rsp), %rdi
callq 0x1d3a0
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x401d4
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0xb8(%rsp)
movq %rax, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0xc0(%rsp), %eax
movl %eax, 0xd0(%rsp)
movb 0xc4(%rsp), %al
movb %al, 0xd4(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1d3f0
movb %al, 0xf(%rsp)
jmp 0x40235
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x40242
jmp 0x4032f
leaq 0xe8(%rsp), %rdi
callq 0x1d420
movq %rax, (%rsp)
jmp 0x40255
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, 0xb4(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xb4(%rsp), %rsi
callq 0x19f80
jmp 0x40276
leaq 0x1065a(%rip), %rdx     # 0x508d7
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xb910
jmp 0x40291
leaq 0x110(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x5520
jmp 0x402a8
leaq 0x90(%rsp), %rdi
callq 0x5260
leaq 0x70(%rsp), %rdi
callq 0x5260
leaq 0xe8(%rsp), %rdi
callq 0x1d4b0
jmp 0x402ce
jmp 0x4021a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x4039b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x40323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5260
leaq 0x70(%rsp), %rdi
callq 0x5260
jmp 0x4039b
leaq 0x50(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x51b0
jmp 0x40343
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x50(%rsp), %rdx
callq 0xd9a0
jmp 0x40359
leaq 0x50(%rsp), %rdi
callq 0x5260
leaq 0x110(%rsp), %rdi
callq 0x5260
movq 0x38(%rsp), %rax
addq $0x148, %rsp            # imm = 0x148
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5260
leaq 0x110(%rsp), %rdi
callq 0x5260
movq 0x100(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/gtpgeneral.cpp
// Function: Morat::Hex::GTP::gtp_history(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
GTPResponse GTP::gtp_history(vecstr args){
	std::string ret;
	for(auto m : hist)
		ret += m.to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x55a0
movq 0x20(%rsp), %rax
addq $0x68, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x439e0
movq %rax, 0x28(%rsp)
jmp 0x4042b
movq 0x28(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x43a10
movq %rax, 0x8(%rsp)
jmp 0x4044c
movq 0x8(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1c750
testb $0x1, %al
jne 0x40477
jmp 0x4054e
leaq 0xb0(%rsp), %rdi
callq 0x1c790
movw (%rax), %ax
movw %ax, 0x96(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x96(%rsp), %rsi
callq 0x19f80
jmp 0x404a3
leaq 0x1042d(%rip), %rdx     # 0x508d7
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb910
jmp 0x404bb
leaq 0xc0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5520
jmp 0x404cf
leaq 0x70(%rsp), %rdi
callq 0x5260
leaq 0x50(%rsp), %rdi
callq 0x5260
leaq 0xb0(%rsp), %rdi
callq 0x1c7a0
jmp 0x40459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x405ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x40542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5260
leaq 0x50(%rsp), %rdi
callq 0x5260
jmp 0x405ba
leaq 0x30(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x51b0
jmp 0x40562
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
callq 0xd9a0
jmp 0x40578
leaq 0x30(%rsp), %rdi
callq 0x5260
leaq 0xc0(%rsp), %rdi
callq 0x5260
movq 0x18(%rsp), %rax
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5260
leaq 0xc0(%rsp), %rdi
callq 0x5260
movq 0xa8(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)