LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tewalds[P]morat/pentago/agentmcts.cpp
// Function: Morat::Pentago::AgentMCTS::get_pv() const
std::vector<Move> AgentMCTS::get_pv() const {
	vecmove pv;

	const Node * n = & root;
	Side turn = rootboard.to_play();
	while(n && !n->children.empty()){
		Move m = 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:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x67(%rsp)
callq 0xef40
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, 0x58(%rsp)
subq $-0x80, %rdi
callq 0x14b50
movb %al, 0x3c(%rsp)
jmp 0x1a851
movb 0x3c(%rsp), %al
movb %al, 0x57(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x58(%rsp)
movb %al, 0x1f(%rsp)
je 0x1a885
movq 0x58(%rsp), %rdi
addq $0x18, %rdi
callq 0x1ca70
movb %al, 0x1e(%rsp)
jmp 0x1a87b
movb 0x1e(%rsp), %al
xorb $-0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1a892
jmp 0x1a93e
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
movb 0x57(%rsp), %al
movb %al, 0x41(%rsp)
movzbl 0x41(%rsp), %edx
xorl %ecx, %ecx
callq 0x1a9a0
movw %ax, 0x1c(%rsp)
jmp 0x1a8b7
movq 0x20(%rsp), %rdi
movw 0x1c(%rsp), %ax
movw %ax, 0x42(%rsp)
leaq 0x42(%rsp), %rsi
callq 0x15990
jmp 0x1a8d2
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
leaq 0x42(%rsp), %rdx
callq 0x1ade0
movq %rax, 0x10(%rsp)
jmp 0x1a8ed
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0x57(%rsp), %al
movb %al, 0x3f(%rsp)
movzbl 0x3f(%rsp), %edi
callq 0x165d0
movb %al, 0xf(%rsp)
jmp 0x1a90f
movb 0xf(%rsp), %al
movb %al, 0x40(%rsp)
movb 0x40(%rsp), %al
movb %al, 0x57(%rsp)
jmp 0x1a859
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x10af0
jmp 0x1a992
movq 0x20(%rsp), %rdi
callq 0x15a00
cmpq $0x0, %rax
jne 0x1a972
leaq 0x3d(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x14180
jmp 0x1a95f
movq 0x20(%rsp), %rdi
leaq 0x3d(%rsp), %rsi
callq 0x15a20
jmp 0x1a970
jmp 0x1a972
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x1a988
movq 0x20(%rsp), %rdi
callq 0x10af0
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x57a0
nopl (%rax)
// File: tewalds[P]morat/pentago/move.h
// Function: Morat::Pentago::Move::Move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Move(const std::string & str){
		if(     str == "swap"    ){ l = M_SWAP;    r = 14; }
		else if(str == "resign"  ){ l = M_RESIGN;  r = 14; }
		else if(str == "none"    ){ l = M_NONE;    r = 14; }
		else if(str == "unknown" ){ l = M_UNKNOWN; r = 14; }
		else if(str.length() <= 2){ l = M_NONE;    r = 14; }
		else{
			unsigned int y = tolower(str[0]) - 'a'; //[abcdef]
			unsigned int x = str[1] - '1';          //[123456]
			l = y*6+x;

			char c = tolower(str[2]);
			if(     c >= '1' && c <= '8') r = c - '1'; //[12345678]
			else if(c >= 's' && c <= 'z') r = c - 's'; //[stuvwxyz]
			else if(c >= 'a' && c <= 'h') r = c - 'a'; //[abcdefgh]
			else r = 0; //unknown, but do something
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
leaq 0x2856c(%rip), %rsi     # 0x4429f
callq 0xa220
testb $0x1, %al
jne 0x1bd3e
jmp 0x1bd4e
movq (%rsp), %rax
movb $-0x1, (%rax)
movb $0xe, 0x1(%rax)
jmp 0x1becb
movq 0x18(%rsp), %rdi
leaq 0x2854a(%rip), %rsi     # 0x442a4
callq 0xa220
testb $0x1, %al
jne 0x1bd65
jmp 0x1bd75
movq (%rsp), %rax
movb $-0x2, (%rax)
movb $0xe, 0x1(%rax)
jmp 0x1bec9
movq 0x18(%rsp), %rdi
leaq 0x28519(%rip), %rsi     # 0x4429a
callq 0xa220
testb $0x1, %al
jne 0x1bd8c
jmp 0x1bd9c
movq (%rsp), %rax
movb $-0x3, (%rax)
movb $0xe, 0x1(%rax)
jmp 0x1bec7
movq 0x18(%rsp), %rdi
leaq 0x284ea(%rip), %rsi     # 0x44292
callq 0xa220
testb $0x1, %al
jne 0x1bdb3
jmp 0x1bdc3
movq (%rsp), %rax
movb $-0x4, (%rax)
movb $0xe, 0x1(%rax)
jmp 0x1bec5
movq 0x18(%rsp), %rdi
callq 0x5690
cmpq $0x2, %rax
ja 0x1bde3
movq (%rsp), %rax
movb $-0x3, (%rax)
movb $0xe, 0x1(%rax)
jmp 0x1bec3
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x54a0
movsbl (%rax), %edi
callq 0x5630
subl $0x61, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x54a0
movq %rax, %rcx
movq (%rsp), %rax
movsbl (%rcx), %ecx
subl $0x31, %ecx
movl %ecx, 0x10(%rsp)
imull $0x6, 0x14(%rsp), %ecx
addl 0x10(%rsp), %ecx
movb %cl, (%rax)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x54a0
movsbl (%rax), %edi
callq 0x5630
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x31, %eax
jl 0x1be6b
movsbl 0xf(%rsp), %eax
cmpl $0x38, %eax
jg 0x1be6b
movq (%rsp), %rax
movsbl 0xf(%rsp), %ecx
subl $0x31, %ecx
movb %cl, 0x1(%rax)
jmp 0x1bec1
movsbl 0xf(%rsp), %eax
cmpl $0x73, %eax
jl 0x1be90
movsbl 0xf(%rsp), %eax
cmpl $0x7a, %eax
jg 0x1be90
movq (%rsp), %rax
movsbl 0xf(%rsp), %ecx
subl $0x73, %ecx
movb %cl, 0x1(%rax)
jmp 0x1bebf
movsbl 0xf(%rsp), %eax
cmpl $0x61, %eax
jl 0x1beb5
movsbl 0xf(%rsp), %eax
cmpl $0x68, %eax
jg 0x1beb5
movq (%rsp), %rax
movsbl 0xf(%rsp), %ecx
subl $0x61, %ecx
movb %cl, 0x1(%rax)
jmp 0x1bebd
movq (%rsp), %rax
movb $0x0, 0x1(%rax)
jmp 0x1bebf
jmp 0x1bec1
jmp 0x1bec3
jmp 0x1bec5
jmp 0x1bec7
jmp 0x1bec9
jmp 0x1becb
addq $0x28, %rsp
retq
// File: tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::undo(Morat::Pentago::Move const&)
bool undo(const Move & m) {
		if(valid_move(m))
			return false;

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

		to_play_ = ~to_play_;
		num_moves_--;

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

		sides[to_play_.to_i()] &= ~xybits[m.l];

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

		outcome_ = Outcome::UNDEF;
		cached_score = default_score;
		cached_hash = 0;

		return true;
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x40(%rsp), %rsi
callq 0x16410
testb $0x1, %al
jne 0x1daf8
jmp 0x1db02
movb $0x0, 0x57(%rsp)
jmp 0x1dcbb
movq 0x40(%rsp), %rdi
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
leaq 0x3c(%rsp), %rsi
callq 0x15970
testb $0x1, %al
jne 0x1db1f
jmp 0x1db56
movq 0x30(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x10, %rsi
callq 0x16470
movq 0x30(%rsp), %rdi
movb $0x1, 0x3b(%rsp)
addq $0x19, %rdi
leaq 0x3b(%rsp), %rsi
callq 0x164b0
movb $0x1, 0x57(%rsp)
jmp 0x1dcbb
movq 0x30(%rsp), %rax
movb 0x19(%rax), %al
movb %al, 0x39(%rsp)
movzbl 0x39(%rsp), %edi
callq 0x165d0
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, 0x3a(%rsp)
movb 0x3a(%rsp), %cl
movb %cl, 0x19(%rax)
movb 0x18(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x18(%rax)
movq 0x40(%rsp), %rdi
callq 0x164d0
cmpl $0x0, %eax
jne 0x1dbf3
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x16550
movq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x16570
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x16550
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x16570
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1dc4e
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x16550
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x164f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x16550
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x164f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movsbq (%rax), %rcx
leaq 0x28bbd(%rip), %rax     # 0x46820
movq (%rax,%rcx,8), %rax
xorq $-0x1, %rax
movq %rax, 0x8(%rsp)
addq $0x19, %rdi
callq 0x16220
movq 0x8(%rsp), %rdx
movb %al, %cl
movq 0x30(%rsp), %rax
movsbq %cl, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rax), %rcx
orq 0x10(%rax), %rcx
movq %rcx, (%rax)
leaq 0x3db74(%rip), %rcx     # 0x5b817
movb (%rcx), %cl
movb %cl, 0x1a(%rax)
movw $0xdead, 0x1c(%rax)     # imm = 0xDEAD
movq $0x0, 0x20(%rax)
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/pentago/agentmctsthread.cpp
// Function: Morat::Pentago::AgentMCTS::AgentThread::iterate()
void AgentMCTS::AgentThread::iterate(){
	INCR(agent->runs);
	if(agent->profile){
		timestamps[0] = Time();
		stage = 0;
	}

	movelist.reset(&(agent->rootboard));
	agent->root.exp.addvloss();
	Board copy = agent->rootboard;
	walk_tree(copy, & agent->root, 0);
	agent->root.exp.addv(movelist.getexp(~agent->rootboard.to_play()));

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rax), %rdi
addq $0xd8, %rdi
callq 0x262a0
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0x48(%rax)
je 0x24bb4
leaq 0x58(%rsp), %rdi
callq 0x67a0
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0xe0(%rax)
movl $0x0, 0x78(%rax)
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x58, %rdi
movq 0x40(%rax), %rsi
addq $0x80, %rsi
callq 0x262c0
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rdi
addq $0xa8, %rdi
callq 0x262f0
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
addq $0x80, %rsi
leaq 0x30(%rsp), %rdi
movl $0x28, %edx
callq 0x5380
movq 0x18(%rsp), %rdi
movq 0x40(%rdi), %rdx
addq $0xa8, %rdx
leaq 0x30(%rsp), %rsi
xorl %ecx, %ecx
callq 0x24d70
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0xa8, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %rcx
addq $0x58, %rcx
movq %rcx, 0x8(%rsp)
movq 0x40(%rax), %rdi
addq $0x80, %rdi
callq 0x14b50
movb %al, 0x2e(%rsp)
movzbl 0x2e(%rsp), %edi
callq 0x165d0
movq 0x8(%rsp), %rdi
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %esi
callq 0x26370
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x26310
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0x48(%rax)
je 0x24d65
movq 0x18(%rsp), %rsi
movq %rsi, %rdi
addq $0xe0, %rdi
addq $0x8, %rdi
addq $0xe0, %rsi
callq 0x144f0
movq 0x18(%rsp), %rsi
vaddsd 0xc0(%rsi), %xmm0, %xmm0
vmovsd %xmm0, 0xc0(%rsi)
movq %rsi, %rdi
addq $0xe0, %rdi
addq $0x10, %rdi
addq $0xe0, %rsi
addq $0x8, %rsi
callq 0x144f0
movq 0x18(%rsp), %rsi
vaddsd 0xc8(%rsi), %xmm0, %xmm0
vmovsd %xmm0, 0xc8(%rsi)
movq %rsi, %rdi
addq $0xe0, %rdi
addq $0x18, %rdi
addq $0xe0, %rsi
addq $0x10, %rsi
callq 0x144f0
movq 0x18(%rsp), %rax
vaddsd 0xd0(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0xd0(%rax)
leaq 0x20(%rsp), %rdi
callq 0x67a0
movq 0x18(%rsp), %rsi
addq $0xe0, %rsi
addq $0x18, %rsi
leaq 0x20(%rsp), %rdi
callq 0x144f0
movq 0x18(%rsp), %rax
vaddsd 0xd8(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0xd8(%rax)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/pentago/agentmctsthread.cpp
// Function: Morat::Pentago::AgentMCTS::AgentThread::rollout(Morat::Pentago::Board&, Morat::Pentago::Move, int)
Outcome AgentMCTS::AgentThread::rollout(Board & board, Move move, int depth){
	Outcome won;
	while((won = board.outcome()) < Outcome::DRAW) {
		board.move_rand(rand64);
	}
	gamelen.add(board.moves_made());
	movelist.finishrollout(won);
	return won;
}

// Assembly:
subq $0x38, %rsp
movw %dx, %ax
movw %ax, 0x35(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
callq 0xeed0
movq 0x20(%rsp), %rdi
callq 0x14100
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
movb %al, 0x37(%rsp)
leaq 0x37(%rsp), %rdi
leaq 0x3568b(%rip), %rsi     # 0x5b81b
callq 0x163d0
testb $0x1, %al
jne 0x2619b
jmp 0x261b0
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x48, %rsi
callq 0x26700
jmp 0x2616e
movq 0x10(%rsp), %rax
addq $0xa0, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x16800
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x26460
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
movb 0x37(%rsp), %al
movb %al, 0x1a(%rsp)
movzbl 0x1a(%rsp), %esi
callq 0x263d0
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/pentago/agentmcts.h
// Function: Morat::Pentago::AgentMCTS::MoveList::finishrollout(Morat::Outcome)
void finishrollout(Outcome won){
			exp[0].addloss();
			exp[1].addloss();
			if(won == Outcome::DRAW){
				exp[0].addtie();
				exp[1].addtie();
			}else{
				exp[won.to_i() - 1].addwin();
			}
		}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movb %al, 0x17(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x269c0
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x269c0
leaq 0x17(%rsp), %rdi
leaq 0x35414(%rip), %rsi     # 0x5b81b
callq 0x14ae0
testb $0x1, %al
jne 0x26412
jmp 0x2642a
movq (%rsp), %rdi
callq 0x269e0
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x269e0
jmp 0x2644c
leaq 0x17(%rsp), %rdi
callq 0x15db0
movq (%rsp), %rdi
movsbl %al, %eax
subl $0x1, %eax
cltq
shlq $0x4, %rax
addq %rax, %rdi
callq 0x26a00
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tewalds[P]morat/pentago/../lib/xorshift.h
// Function: Morat::XORShift_uint64::rand()
uint64_t rand(){
		r ^= r >> 12; // a
		r ^= r << 25; // b
		r ^= r >> 27; // c
		return r * 2685821657736338717LL;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq (%rcx), %rax
shrq $0xc, %rax
xorq (%rcx), %rax
movq %rax, (%rcx)
movq (%rcx), %rax
shlq $0x19, %rax
xorq (%rcx), %rax
movq %rax, (%rcx)
movq (%rcx), %rax
shrq $0x1b, %rax
xorq (%rcx), %rax
movq %rax, (%rcx)
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq (%rcx), %rax
retq
// File: tewalds[P]morat/pentago/agentpns.cpp
// Function: Morat::Pentago::AgentPNS::create_children_simple(Morat::Pentago::Board const&, Morat::Pentago::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(MoveIterator move(board); !move.done(); ++move){
		Outcome outcome = move.board().outcome();
		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 $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xe0(%rsp), %rdi
addq $0x18, %rdi
callq 0x2a440
testb $0x1, %al
jne 0x29703
jmp 0x29705
jmp 0x29724
leaq 0x1b05d(%rip), %rdi     # 0x44769
leaq 0x1c3f9(%rip), %rsi     # 0x45b0c
movl $0x13d, %edx            # imm = 0x13D
leaq 0x1c4fa(%rip), %rcx     # 0x45c19
callq 0x52d0
movq 0xe0(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x40(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x168e0
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rdi
movl %eax, %esi
addq $0x50, %rdx
callq 0x2a530
movl $0x0, 0xdc(%rsp)
movq 0xe8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15670
leaq 0x88(%rsp), %rdi
callq 0x157e0
movb %al, 0x3f(%rsp)
jmp 0x2978f
movb 0x3f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x297c1
leaq 0x88(%rsp), %rdi
callq 0x15940
jmp 0x298f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x298e9
leaq 0x88(%rsp), %rdi
callq 0x15810
movq %rax, 0x30(%rsp)
jmp 0x297d5
movq 0x30(%rsp), %rdi
callq 0x14100
movb %al, 0x2f(%rsp)
jmp 0x297e5
movb 0x2f(%rsp), %al
movb %al, 0x7b(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x15960
movq %rax, 0x20(%rsp)
jmp 0x29801
movq 0x20(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0x1, %edx
callq 0x29ef0
jmp 0x29817
movb 0x7b(%rsp), %al
movb %al, 0x57(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x14b50
movb %al, 0x1f(%rsp)
jmp 0x29832
movq 0x48(%rsp), %rax
movb 0x1f(%rsp), %cl
movb %cl, 0x56(%rsp)
movb 0x1514(%rax), %al
movb %al, 0x55(%rsp)
movzbl 0x55(%rsp), %ecx
movzbl 0x56(%rsp), %edx
movzbl 0x57(%rsp), %esi
leaq 0x58(%rsp), %rdi
movl $0x1, %r8d
callq 0x2a7f0
movq %rax, 0x10(%rsp)
jmp 0x2986f
movq 0xe0(%rsp), %rdi
addq $0x18, %rdi
movl 0xdc(%rsp), %esi
callq 0x2a940
movq %rax, 0x8(%rsp)
jmp 0x2988e
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x2a9f0
jmp 0x2989f
leaq 0x58(%rsp), %rdi
callq 0x29f80
movl 0xdc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xdc(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x15820
jmp 0x298c9
jmp 0x2977c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x29f80
leaq 0x88(%rsp), %rdi
callq 0x15940
jmp 0x2992e
movq 0x48(%rsp), %rdi
addq $0x38, %rdi
leaq 0xdc(%rsp), %rsi
callq 0x1e4f0
movq 0xe0(%rsp), %rdi
addq $0x18, %rdi
movl 0xdc(%rsp), %esi
callq 0x2aa80
addq $0xf8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x57a0
nopl (%rax,%rax)
// File: tewalds[P]morat/pentago/agent.h
// Function: Morat::Pentago::Agent::solve1ply(Morat::Pentago::Board const&, unsigned int&)
static Outcome solve1ply(const Board & board, unsigned int & nodes) {
		Outcome outcome = Outcome::UNDEF;
		Side turn = board.to_play();
		for(MoveIterator move(board); !move.done(); ++move){
			++nodes;
			Outcome won = move.board().outcome();

			if(won == +turn)
				return won;
			if(won == Outcome::DRAW)
				outcome = Outcome::DRAW;
			else if(outcome == +~turn || outcome == Outcome::UNDEF)
				outcome = won;
		}
		return outcome;
	}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
leaq 0x31259(%rip), %rax     # 0x5b817
movb (%rax), %al
movb %al, 0x8f(%rsp)
movq 0x98(%rsp), %rdi
callq 0x14b50
movb %al, 0x8e(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15670
leaq 0x38(%rsp), %rdi
callq 0x157e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2a60f
movl $0x2, 0x34(%rsp)
jmp 0x2a7a6
movq 0x90(%rsp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x15810
movq %rax, 0x10(%rsp)
jmp 0x2a62e
movq 0x10(%rsp), %rdi
callq 0x14100
movb %al, 0xf(%rsp)
jmp 0x2a63e
movb 0xf(%rsp), %al
movb %al, 0xa7(%rsp)
movb 0x8e(%rsp), %al
movb %al, 0x22(%rsp)
movzbl 0x22(%rsp), %edi
callq 0x14b20
movb %al, 0xe(%rsp)
jmp 0x2a664
movb 0xe(%rsp), %al
movb %al, 0x23(%rsp)
leaq 0xa7(%rsp), %rdi
leaq 0x23(%rsp), %rsi
callq 0x14ae0
movb %al, 0xd(%rsp)
jmp 0x2a684
movb 0xd(%rsp), %al
testb $0x1, %al
jne 0x2a68e
jmp 0x2a6b8
movl $0x1, 0x34(%rsp)
jmp 0x2a7a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15940
jmp 0x2a7d8
leaq 0x3115c(%rip), %rsi     # 0x5b81b
leaq 0xa7(%rsp), %rdi
callq 0x14ae0
movb %al, 0xc(%rsp)
jmp 0x2a6d2
movb 0xc(%rsp), %al
testb $0x1, %al
jne 0x2a6dc
jmp 0x2a6f1
leaq 0x31138(%rip), %rax     # 0x5b81b
movb (%rax), %al
movb %al, 0x8f(%rsp)
jmp 0x2a793
movb 0x8e(%rsp), %al
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %edi
callq 0x165d0
movb %al, 0xb(%rsp)
jmp 0x2a70c
movb 0xb(%rsp), %al
movb %al, 0x20(%rsp)
movzbl 0x20(%rsp), %edi
callq 0x14b20
movb %al, 0xa(%rsp)
jmp 0x2a724
movb 0xa(%rsp), %al
movb %al, 0x21(%rsp)
leaq 0x8f(%rsp), %rdi
leaq 0x21(%rsp), %rsi
callq 0x14ae0
movb %al, 0x9(%rsp)
jmp 0x2a744
movb 0x9(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x8(%rsp)
jne 0x2a779
jmp 0x2a755
leaq 0x310bb(%rip), %rsi     # 0x5b817
leaq 0x8f(%rsp), %rdi
callq 0x14ae0
movb %al, 0x7(%rsp)
jmp 0x2a76f
movb 0x7(%rsp), %al
movb %al, 0x8(%rsp)
jmp 0x2a779
movb 0x8(%rsp), %al
testb $0x1, %al
jne 0x2a783
jmp 0x2a791
movb 0xa7(%rsp), %al
movb %al, 0x8f(%rsp)
jmp 0x2a793
jmp 0x2a795
leaq 0x38(%rsp), %rdi
callq 0x15820
jmp 0x2a7a1
jmp 0x2a5f2
leaq 0x38(%rsp), %rdi
callq 0x15940
movl 0x34(%rsp), %eax
subl $0x1, %eax
je 0x2a7c9
jmp 0x2a7bb
movb 0x8f(%rsp), %al
movb %al, 0xa7(%rsp)
movb 0xa7(%rsp), %al
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::gtp_mcts(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_mcts(vecstr args){
	delete agent;
	agent = new AgentMCTS();
	agent->set_board(*hist);
	return GTPResponse(true);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x3112d
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1590, %edi           # imm = 0x1590
callq 0x5430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x19c80
jmp 0x31149
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%rdi)
movq 0xb8(%rdi), %rax
movq %rax, (%rsp)
addq $0x68, %rdi
callq 0xefe0
movq (%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x57b0
movq 0x8(%rsp), %rdx
leaq 0x12687(%rip), %rsi     # 0x43825
leaq 0x40(%rsp), %rdi
callq 0x55d0
jmp 0x311aa
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
callq 0xc950
jmp 0x311c0
leaq 0x40(%rsp), %rdi
callq 0x5290
leaq 0x3f(%rsp), %rdi
callq 0x5480
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x53e0
jmp 0x3122d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x31223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5290
leaq 0x3f(%rsp), %rdi
callq 0x5480
movq 0x68(%rsp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::gtp_pns(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_pns(vecstr args){
	delete agent;
	agent = new AgentPNS();
	agent->set_board(*hist);
	return GTPResponse(true);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x3128d
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1540, %edi           # imm = 0x1540
callq 0x5430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x34320
jmp 0x312a9
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%rdi)
movq 0xb8(%rdi), %rax
movq %rax, (%rsp)
addq $0x68, %rdi
callq 0xefe0
movq (%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x57b0
movq 0x8(%rsp), %rdx
leaq 0x12527(%rip), %rsi     # 0x43825
leaq 0x40(%rsp), %rdi
callq 0x55d0
jmp 0x3130a
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
callq 0xc950
jmp 0x31320
leaq 0x40(%rsp), %rdi
callq 0x5290
leaq 0x3f(%rsp), %rdi
callq 0x5480
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x53e0
jmp 0x3138d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x31383
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5290
leaq 0x3f(%rsp), %rdi
callq 0x5480
movq 0x68(%rsp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::GTP::gtp_ab(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_ab(vecstr args){
	delete agent;
	agent = new AgentAB();
	agent->set_board(*hist);
	return GTPResponse(true);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x313ed
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x70, %edi
callq 0x5430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x344a0
jmp 0x31409
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%rdi)
movq 0xb8(%rdi), %rax
movq %rax, (%rsp)
addq $0x68, %rdi
callq 0xefe0
movq (%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x57b0
movq 0x8(%rsp), %rdx
leaq 0x123c7(%rip), %rsi     # 0x43825
leaq 0x40(%rsp), %rdi
callq 0x55d0
jmp 0x3146a
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
callq 0xc950
jmp 0x31480
leaq 0x40(%rsp), %rdi
callq 0x5290
leaq 0x3f(%rsp), %rdi
callq 0x5480
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x53e0
jmp 0x314ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x314e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5290
leaq 0x3f(%rsp), %rdi
callq 0x5480
movq 0x68(%rsp), %rdi
callq 0x57a0
nopw (%rax,%rax)
// File: tewalds[P]morat/pentago/gtpgeneral.cpp
// Function: Morat::Pentago::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(MoveIterator move(*hist); !move.done(); ++move)
		ret += move->to_s() + " ";
	return GTPResponse(true, ret);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x55e0
movq 0x20(%rsp), %rdi
addq $0x68, %rdi
callq 0xefe0
movq %rax, 0x28(%rsp)
jmp 0x31b1b
movq 0x28(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15670
jmp 0x31b34
jmp 0x31b36
leaq 0xa0(%rsp), %rdi
callq 0x157e0
movb %al, 0xf(%rsp)
jmp 0x31b49
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x31b97
leaq 0xa0(%rsp), %rdi
callq 0x15940
jmp 0x31c5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x31cc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x31c4c
leaq 0xa0(%rsp), %rdi
callq 0x15800
movq %rax, (%rsp)
jmp 0x31baa
movq (%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x14740
jmp 0x31bba
leaq 0x162c8(%rip), %rdx     # 0x47e89
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xaa40
jmp 0x31bd2
leaq 0xf0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5560
jmp 0x31be6
leaq 0x70(%rsp), %rdi
callq 0x5290
leaq 0x50(%rsp), %rdi
callq 0x5290
leaq 0xa0(%rsp), %rdi
callq 0x15820
jmp 0x31c09
jmp 0x31b36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x31c42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5290
leaq 0x50(%rsp), %rdi
callq 0x5290
leaq 0xa0(%rsp), %rdi
callq 0x15940
jmp 0x31cc7
leaq 0x30(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x51d0
jmp 0x31c6f
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
callq 0xc950
jmp 0x31c85
leaq 0x30(%rsp), %rdi
callq 0x5290
leaq 0xf0(%rsp), %rdi
callq 0x5290
movq 0x18(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5290
leaq 0xf0(%rsp), %rdi
callq 0x5290
movq 0x98(%rsp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/pentago/agentpns.h
// Function: Morat::Pentago::AgentPNS::AgentPNS()
AgentPNS() : pool(this) {
		ab = 1;
		df = true;
		epsilon = 0.25;
		ties = Side::NONE;
		numthreads = 1;
		pool.set_num_threads(numthreads);
		gclimit = 5;

		nodes = 0;
		reset();

		set_memlimit(1000*1024*1024);
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1ca90
movq 0x10(%rsp), %rdi
leaq 0x268fc(%rip), %rax     # 0x5ac40
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x50, %rdi
movq %rdi, 0x18(%rsp)
callq 0x352f0
jmp 0x3435b
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0x1410, %rdi           # imm = 0x1410
movq %rdi, 0x8(%rsp)
callq 0x35380
jmp 0x34376
movq 0x10(%rsp), %rdi
addq $0x1514, %rdi           # imm = 0x1514
callq 0xeeb0
jmp 0x34389
movq 0x10(%rsp), %rdi
addq $0x1520, %rdi           # imm = 0x1520
movq %rdi, (%rsp)
callq 0x29f40
jmp 0x343a0
movq 0x10(%rsp), %rax
movl $0x1, 0x1508(%rax)
movb $0x1, 0x150c(%rax)
movl $0x3e800000, 0x1510(%rax) # imm = 0x3E800000
leaq 0x2744c(%rip), %rcx     # 0x5b813
movb (%rcx), %cl
movb %cl, 0x1514(%rax)
movl $0x1, 0x1518(%rax)
movq %rax, %rdi
addq $0x1410, %rdi           # imm = 0x1410
movl 0x1518(%rax), %esi
callq 0x2bcc0
jmp 0x343f0
movq 0x10(%rsp), %rdi
movl $0x5, 0x48(%rdi)
movq $0x0, 0x38(%rdi)
callq 0x2e440
jmp 0x3440b
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
callq *%rax
jmp 0x34420
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x34480
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x34476
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x3446c
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x29f80
movq 0x8(%rsp), %rdi
callq 0x2c4e0
movq 0x18(%rsp), %rdi
callq 0x2c550
movq 0x10(%rsp), %rdi
callq 0x16d90
movq 0x28(%rsp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/pentago/agentab.h
// Function: Morat::Pentago::AgentAB::AgentAB()
AgentAB() {
		maxdepth = 0;
		nodes_seen = 0;
		time_used = 0;
		TT = NULL;
		set_memlimit(100*1024*1024);

		randomness = 2;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1ca90
movq 0x8(%rsp), %rdi
leaq 0x263e4(%rip), %rax     # 0x5a8a8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x68, %rdi
xorl %esi, %esi
callq 0x24450
jmp 0x344d8
movq 0x8(%rsp), %rdi
movl $0x0, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
movq $0x0, 0x60(%rdi)
movq $0x0, 0x38(%rdi)
movq (%rdi), %rax
movq 0x30(%rax), %rax
movl $0x6400000, %esi        # imm = 0x6400000
callq *%rax
jmp 0x3450c
movq 0x8(%rsp), %rax
movl $0x2, 0x6c(%rax)
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x16d90
movq 0x18(%rsp), %rdi
callq 0x57a0
nop
// File: tewalds[P]morat/pentago/moveiterator.cpp
// Function: Morat::Pentago::MoveIterator::test()
void MoveIterator::test() {
//	printf("MoveIterator tests\n");

	Board board;
	int i;

	i = 0;
	for(MoveIterator move(board, 0); !move.done(); ++move)
		i++;
	assert(i == 288);

	i = 0;
	for(MoveIterator move(board, 36); !move.done(); ++move)
		i++;
	assert(i == 6);

	i = 0;
	for(MoveIterator move(board); !move.done(); ++move)
		i++;
	assert(i == 6);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
leaq 0x110(%rsp), %rdi
movl $0x6, %esi
callq 0x16790
movl $0x0, 0x10c(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x110(%rsp), %rsi
xorl %edx, %edx
callq 0x15670
leaq 0xb8(%rsp), %rdi
callq 0x157e0
movb %al, 0x7(%rsp)
jmp 0x3b35e
movb 0x7(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b39d
leaq 0xb8(%rsp), %rdi
callq 0x15940
jmp 0x3b3bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x15940
jmp 0x3b55c
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x15820
jmp 0x3b3bd
jmp 0x3b34b
cmpl $0x120, 0x10c(%rsp) # imm = 0x120
jne 0x3b3ce
jmp 0x3b3ed
leaq 0xd339(%rip), %rdi      # 0x4870e
leaq 0xd33b(%rip), %rsi      # 0x48717
movl $0x17, %edx
leaq 0xd348(%rip), %rcx      # 0x48730
callq 0x52d0
movl $0x0, 0x10c(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movl $0x24, %edx
callq 0x15670
leaq 0x58(%rsp), %rdi
callq 0x157e0
movb %al, 0x6(%rsp)
jmp 0x3b41f
movb 0x6(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b458
leaq 0x58(%rsp), %rdi
callq 0x15940
jmp 0x3b477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x15940
jmp 0x3b55c
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x15820
jmp 0x3b475
jmp 0x3b40f
cmpl $0x6, 0x10c(%rsp)
jne 0x3b483
jmp 0x3b4a2
leaq 0xd2d7(%rip), %rdi      # 0x48761
leaq 0xd286(%rip), %rsi      # 0x48717
movl $0x1c, %edx
leaq 0xd293(%rip), %rcx      # 0x48730
callq 0x52d0
movl $0x0, 0x10c(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15670
leaq 0x8(%rsp), %rdi
callq 0x157e0
movb %al, 0x5(%rsp)
jmp 0x3b4d4
movb 0x5(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b50a
leaq 0x8(%rsp), %rdi
callq 0x15940
jmp 0x3b529
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x15940
jmp 0x3b55c
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x15820
jmp 0x3b527
jmp 0x3b4c4
cmpl $0x6, 0x10c(%rsp)
jne 0x3b535
jmp 0x3b554
leaq 0xd225(%rip), %rdi      # 0x48761
leaq 0xd1d4(%rip), %rsi      # 0x48717
movl $0x21, %edx
leaq 0xd1e1(%rip), %rcx      # 0x48730
callq 0x52d0
addq $0x138, %rsp            # imm = 0x138
retq
movq 0xb0(%rsp), %rdi
callq 0x57a0
nopl (%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: getdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>&)
int getdir (string dir, vector<string> &files)
{
    DIR *dp;
    struct dirent *dirp;
    if((dp  = opendir(dir.c_str())) == NULL)
    {
        cout << "Error(" << errno << ") opening " << dir << endl;
        return errno;
    }

    while ((dirp = readdir(dp)) != NULL)
    {
        files.push_back(string(dirp->d_name));
    }
    closedir(dp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x2110
movq %rax, %rdi
callq 0x23e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x350e
movq 0x5b23(%rip), %rdi      # 0x8fd8
leaq 0x2da4(%rip), %rsi      # 0x6260
callq 0x2290
movq %rax, -0x70(%rbp)
callq 0x2040
movq -0x70(%rbp), %rdi
movl (%rax), %esi
callq 0x2460
movq %rax, %rdi
leaq 0x2d88(%rip), %rsi      # 0x6267
callq 0x2290
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
movq 0x5ace(%rip), %rsi      # 0x8fc8
callq 0x22b0
callq 0x2040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x35c2
jmp 0x3510
movq -0x20(%rbp), %rdi
callq 0x23f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x35b2
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x80(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2490
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x2370
jmp 0x355e
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4cf0
jmp 0x3570
leaq -0x48(%rbp), %rdi
callq 0x2190
leaq -0x49(%rbp), %rdi
callq 0x22c0
jmp 0x3510
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x35a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2190
leaq -0x49(%rbp), %rdi
callq 0x22c0
jmp 0x35ce
movq -0x20(%rbp), %rdi
callq 0x2410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2480
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: tryFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool tryFile (string file_dir, string file_name)
{
	string path = file_dir + file_name;
	fstream filestr;
 	filestr.open(path.c_str());

	if (filestr.is_open())
	{
    		filestr.close();
		return true;
  	}
	else
	{
		cout << "Error to open file" << endl;
		Status S;
		S.errorID = 9; // A changer.
		sprintf(S.description, "File corrupted");
		string str(S.description);
		sm.newNotification(S.errorID, str);
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp            # imm = 0x360
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4d20
leaq -0x248(%rbp), %rdi
callq 0x2300
jmp 0x3610
leaq -0x38(%rbp), %rdi
callq 0x2110
movq %rax, -0x338(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x4da0
movl %eax, -0x32c(%rbp)
jmp 0x3637
movl -0x32c(%rbp), %edx
movq -0x338(%rbp), %rsi
leaq -0x248(%rbp), %rdi
callq 0x2240
jmp 0x3652
leaq -0x248(%rbp), %rdi
callq 0x2450
movb %al, -0x339(%rbp)
jmp 0x3666
movb -0x339(%rbp), %al
testb $0x1, %al
jne 0x3672
jmp 0x36c1
leaq -0x248(%rbp), %rdi
callq 0x2070
jmp 0x3680
movb $0x1, -0x1(%rbp)
movl $0x1, -0x258(%rbp)
jmp 0x3817
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x3846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x383a
movq 0x5910(%rip), %rdi      # 0x8fd8
leaq 0x2ba3(%rip), %rsi      # 0x6272
callq 0x2290
movq %rax, -0x348(%rbp)
jmp 0x36dd
movq -0x348(%rbp), %rdi
movq 0x58dd(%rip), %rsi      # 0x8fc8
callq 0x22b0
jmp 0x36f2
movl $0x9, -0x2dc(%rbp)
leaq -0x2d8(%rbp), %rdi
movq %rdi, -0x358(%rbp)
leaq 0x2b74(%rip), %rsi      # 0x6285
xorl %eax, %eax
callq 0x20a0
leaq -0x301(%rbp), %rdi
movq %rdi, -0x350(%rbp)
callq 0x2490
movq -0x358(%rbp), %rsi
movq -0x350(%rbp), %rdx
leaq -0x300(%rbp), %rdi
callq 0x2370
jmp 0x3747
leaq -0x301(%rbp), %rdi
callq 0x22c0
movl -0x2dc(%rbp), %eax
movl %eax, -0x35c(%rbp)
leaq -0x328(%rbp), %rdi
leaq -0x300(%rbp), %rsi
callq 0x2130
jmp 0x3774
movl -0x35c(%rbp), %esi
leaq 0x5b2f(%rip), %rdi      # 0x92b0
leaq -0x328(%rbp), %rdx
callq 0x3230
jmp 0x378f
leaq -0x328(%rbp), %rdi
callq 0x2190
movb $0x0, -0x1(%rbp)
movl $0x1, -0x258(%rbp)
leaq -0x300(%rbp), %rdi
callq 0x2190
jmp 0x3817
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x301(%rbp), %rdi
callq 0x22c0
jmp 0x383a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x3809
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x328(%rbp), %rdi
callq 0x2190
leaq -0x300(%rbp), %rdi
callq 0x2190
jmp 0x383a
leaq -0x248(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x2190
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x360, %rsp            # imm = 0x360
popq %rbp
retq
leaq -0x248(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x2190
movq -0x250(%rbp), %rdi
callq 0x2480
nopl (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/communication/comGroundManager.cpp
// Function: am_alive(void*)
void* am_alive(void* args)
{
	QueuingPort channelFDIR(0, 18002, s); // Client FDIR
	usleep(500000);
	channelFDIR.Display();

	char str[2]="C";
	while (1) 
	{
		if(wtc == 1)
		{
			channelFDIR.SendQueuingMsg(str, sizeof(str));
			wtc = 0;
		}
		usleep(10*1000); //10 ms
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
movq %rdi, -0x8(%rbp)
leaq -0x4d0(%rbp), %rdi
xorl %esi, %esi
movl $0x4652, %edx           # imm = 0x4652
leaq 0x5a2c(%rip), %rcx      # 0xa300
callq 0x2860
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x2390
leaq -0x4d0(%rbp), %rdi
callq 0x2cc0
movw 0x1af5(%rip), %ax       # 0x63eb
movw %ax, -0x4d2(%rbp)
cmpl $0x1, 0x5ed0(%rip)      # 0xa7d4
jne 0x4928
leaq -0x4d2(%rbp), %rsi
leaq -0x4d0(%rbp), %rdi
movl $0x2, %edx
callq 0x2ac0
movl $0x0, 0x5eac(%rip)      # 0xa7d4
movl $0x2710, %edi           # imm = 0x2710
callq 0x2390
jmp 0x48fd
nopw %cs:(%rax,%rax)
// File: thunlp[P]KB2E/TransR/Train_TransR.cpp
// Function: Train::norm(std::vector<double, std::allocator<double>>&)
void norm(vector<double> &a)
    {
        double x = vec_len(a);
        if (x>1)
        for (int ii=0; ii<a.size(); ii++)
                a[ii]/=x;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2a00
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0xdcc4(%rip), %xmm1     # 0x16020
ucomisd %xmm1, %xmm0
jbe 0x83c7
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3c60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x83c5
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x3c80
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x836a
jmp 0x83c7
addq $0x38, %rsp
retq
nopl (%rax)
// File: thunlp[P]KB2E/TransR/Train_TransR.cpp
// Function: Train::train_kb(int, int, int, int, int, int)
void train_kb(int e1_a,int e2_a,int rel_a,int e1_b,int e2_b,int rel_b)
    {
        double sum1 = calc_sum(e1_a,e2_a,rel_a,1);
        double sum2 = calc_sum(e1_b,e2_b,rel_b,1);
        if (sum1+margin>sum2)
        {
        	res+=margin+sum1-sum2;
        	gradient( e1_a, e2_a, rel_a, e1_b, e2_b, rel_b);
        }
    }

// Assembly:
subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %ecx
movl $0x1, %r8d
callq 0xe680
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
movl 0x50(%rsp), %ecx
movl $0x1, %r8d
callq 0xe680
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x50(%rax), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0xb756
movq 0x10(%rsp), %rdi
movsd 0x50(%rdi), %xmm0
addsd 0x20(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
addsd 0x40(%rdi), %xmm0
movsd %xmm0, 0x40(%rdi)
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x2c(%rsp), %r9d
movl 0x50(%rsp), %eax
movl %eax, (%rsp)
callq 0xeb40
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Neuron::calculate_potential() const
double Neuron::calculate_potential() const
{
    double total = 0;
    for (auto const& it: this->subscriptions) {
        total += it.first->potential * it.second;
    }
    return this->activation_function(total);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x19370
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x193a0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x193d0
testb $0x1, %al
jne 0x16c2e
jmp 0x16c70
leaq -0x10(%rbp), %rdi
callq 0x19400
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movsd 0xa0(%rax), %xmm0
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x19430
jmp 0x16c1b
movq -0x40(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x16cb0
movsd %xmm0, -0x48(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x16ca0
movsd -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
callq 0x16340
nopw %cs:(%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::initiate_subscriptions()
void Network::initiate_subscriptions()
{
    for (auto& neuron: this->neurons) {
        if (neuron->type != SENSORY_NEURON) {
            neuron->partially_subscribe();
            std::cout << "Initiated: " << this->initiated_neurons
                << " neuron(s)\r" << std::flush;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x148, %rax            # imm = 0x148
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19160
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x191b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x19210
testb $0x1, %al
jne 0x17ae8
jmp 0x17b64
leaq -0x10(%rbp), %rdi
callq 0x19250
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0xa8(%rax)
je 0x17b54
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x167f0
movq 0x19480(%rip), %rdi     # 0x30f98
leaq 0xf5af(%rip), %rsi      # 0x270ce
callq 0x162b0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movl 0x98(%rax), %esi
callq 0x164a0
movq %rax, %rdi
leaq 0xf59a(%rip), %rsi      # 0x270da
callq 0x162b0
movq %rax, %rdi
movq 0x19451(%rip), %rsi     # 0x30fa0
callq 0x162f0
jmp 0x17b56
leaq -0x10(%rbp), %rdi
callq 0x19350
jmp 0x17ad5
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x17b7c
addq $0x40, %rsp
popq %rbp
retq
callq 0x16340
nopw %cs:(%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::ignite()
void Network::ignite()
{
    this->freezer = false;
    this->thread1 = std::thread{Network::_ignite, this};
    this->thread1.detach();
    //this->thread1.join();
    std::cout << "Network has been ignited" << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, 0x128(%rax)
movq %rax, -0x18(%rbp)
leaq 0x7d(%rip), %rsi        # 0x17c40
leaq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x19ca0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x130, %rdi            # imm = 0x130
movq %rdi, -0x28(%rbp)
callq 0x19da0
movq -0x30(%rbp), %rdi
callq 0x198e0
movq -0x28(%rbp), %rdi
callq 0x164c0
movq 0x19393(%rip), %rdi     # 0x30f98
leaq 0xf4da(%rip), %rsi      # 0x270e6
callq 0x162b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x16380
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x17c36
addq $0x40, %rsp
popq %rbp
retq
callq 0x16340
nopl (%rax,%rax)
// File: mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::print_output() const
void Network::print_output() const
{
    std::vector<double> output = this->get_output();
    std::cout << "\r";
    std::cout << "Output: ";
    for (const auto& i: output)
        std::cout << i << ' ';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x184c0
movq 0x18bdb(%rip), %rdi     # 0x30f98
leaq 0xed20(%rip), %rsi      # 0x270e4
callq 0x162b0
jmp 0x183cb
movq 0x18bc6(%rip), %rdi     # 0x30f98
leaq 0xeed3(%rip), %rsi      # 0x272ac
callq 0x162b0
jmp 0x183e0
leaq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x19f40
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rdi
callq 0x19f90
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19ff0
testb $0x1, %al
jne 0x18415
jmp 0x18470
leaq -0x28(%rbp), %rdi
callq 0x1a030
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movsd (%rax), %xmm0
movq 0x18b67(%rip), %rdi     # 0x30f98
callq 0x16540
movq %rax, -0x60(%rbp)
jmp 0x1843c
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x16380
jmp 0x1844c
jmp 0x1844e
leaq -0x28(%rbp), %rdi
callq 0x1a050
jmp 0x18402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x19910
jmp 0x18491
leaq -0x20(%rbp), %rdi
callq 0x19910
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x184b4
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x184b4
movq -0x68(%rbp), %rdi
callq 0x164e0
callq 0x16340
nopl (%rax)