LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x1a47c(%rip), %rsi     # 0x2d2d4
movq %rdi, %rbx
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12eac
leaq 0x1a46b(%rip), %rsi     # 0x2d2d9
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12eb1
leaq 0x1a44e(%rip), %rsi     # 0x2d2cf
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12ea7
leaq 0x1a433(%rip), %rsi     # 0x2d2c7
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12eb6
cmpq $0x2, 0x8(%r14)
ja 0x12ec6
movb $-0x3, (%rbx)
jmp 0x12eb9
movb $-0x1, (%rbx)
jmp 0x12eb9
movb $-0x2, (%rbx)
jmp 0x12eb9
movb $-0x4, (%rbx)
movb $0xe, %al
movb %al, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %r14
movsbl (%r14), %edi
callq 0x54f0
addl %eax, %eax
leal (%rax,%rax,2), %eax
addb 0x1(%r14), %al
addb $-0x77, %al
movb %al, (%rbx)
movsbl 0x2(%r14), %edi
callq 0x54f0
movsbl %al, %ecx
leal -0x31(%rcx), %edx
cmpl $0x7, %edx
ja 0x12ef9
addl $-0x31, %eax
jmp 0x12ebb
leal -0x73(%rcx), %edx
cmpl $0x7, %edx
ja 0x12f06
addl $-0x73, %eax
jmp 0x12ebb
addl $-0x61, %ecx
cmpl $0x7, %ecx
ja 0x12f13
addl $-0x61, %eax
jmp 0x12ebb
xorl %eax, %eax
jmp 0x12ebb
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x40(%rdi), %rax
movq %rdi, %rbx
lock
incq 0xd8(%rax)
movq 0x40(%rdi), %rax
cmpb $0x1, 0x48(%rax)
jne 0x16dbd
leaq 0x10(%rsp), %r14
xorl %esi, %esi
movq %r14, %rdi
callq 0x5600
vcvtsi2sdq (%r14), %xmm0, %xmm0
vcvtsi2sdq 0x8(%r14), %xmm1, %xmm1
vdivsd 0x15262(%rip), %xmm1, %xmm1 # 0x2c008
vaddsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, 0xe0(%rbx)
movl $0x0, 0x78(%rbx)
movq 0x40(%rbx), %rax
vxorpd %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
vmovupd %ymm0, 0x58(%rbx)
lock
incq 0xb0(%rax)
movq 0x40(%rbx), %rdx
movq 0xa0(%rdx), %rax
movq %rax, 0x20(%rsi)
vmovupd 0x80(%rdx), %ymm0
addq $0xa8, %rdx
vmovupd %ymm0, (%rsi)
vzeroupper
callq 0x16ed6
movq 0x40(%rbx), %rax
movb $0x3, %cl
subb 0x99(%rax), %cl
movsbq %cl, %rcx
shlq $0x4, %rcx
leaq 0x48(%rcx,%rbx), %rcx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x16e2b
lock
addq %rdx, 0xa8(%rax)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x16e3c
lock
addq %rcx, 0xb0(%rax)
movq 0x40(%rbx), %rax
cmpb $0x1, 0x48(%rax)
jne 0x16ece
vmovupd 0xe0(%rbx), %xmm0
vmovupd 0xe8(%rbx), %xmm1
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
vunpcklpd %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vsubpd %xmm0, %xmm1, %xmm0
vaddpd 0xc0(%rbx), %xmm0, %xmm0
vmovupd %xmm0, 0xc0(%rbx)
vmovsd 0xf8(%rbx), %xmm0
vsubsd 0xf0(%rbx), %xmm0, %xmm0
vaddsd 0xd0(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0xd0(%rbx)
callq 0x5600
vcvtsi2sdq (%r14), %xmm2, %xmm0
vcvtsi2sdq 0x8(%r14), %xmm2, %xmm1
vdivsd 0x15156(%rip), %xmm1, %xmm1 # 0x2c008
vaddsd %xmm0, %xmm1, %xmm0
vsubsd 0xf8(%rbx), %xmm0, %xmm0
vaddsd 0xd8(%rbx), %xmm0, %xmm0
vmovsd %xmm0, 0xd8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1a335(%rip), %r12     # 0x31da5
leaq 0x1a332(%rip), %r13     # 0x31da9
leaq 0x48(%rdi), %r15
movq %rsi, %r14
movq %rdi, %rbx
movb 0x1a(%r14), %bpl
cmpb (%r12), %bpl
jne 0x17a99
movq %r14, %rdi
callq 0xe2a8
movl %eax, %ebp
movb %al, 0x1a(%r14)
cmpb (%r13), %bpl
jge 0x17aac
movq %r14, %rdi
movq %r15, %rsi
callq 0x17c4a
jmp 0x17a81
movzbl 0x18(%r14), %esi
leaq 0xa0(%rbx), %rdi
callq 0x17b9e
addq $0x58, %rbx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x17b66
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/board.h
// Function: Morat::Pentago::Board::move_rand(Morat::XORShift_uint64&)
bool move_rand(XORShift_uint64 & rand){
		//find an empty space, this should take log2(bits set) to converge, assuming a good and fast RNG
		uint64_t move = (~sides[0]) & 0xFFFFFFFFFULL; // bits set for all empty positions
		uint64_t mask;
		do {
			mask = rand();
			if((move & mask) > 0) // don't let it drop to no bits set
				move &= mask;
		} while(move & (move-1));
//		} while(bitcount(move) > 1); // if there's only one bit left, that's our move

		sides[to_play_.to_i()] |= move;

		uint64_t rotation = (mask >> 36); //mask is already a random number, so just re-use the unused high bits
		uint64_t direction = rotation & 0x4;
		uint64_t quadrant = rotation & 0x3;

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

		num_moves_++;
		to_play_ = ~to_play_;
		outcome_ = Outcome::UNDEF;
		cached_score = default_score;
		cached_hash = 0;

		return true;
	}

// Assembly:
movq (%rdi), %rax
movb $0x24, %cl
notq %rax
bzhiq %rcx, %rax, %r8
movq (%rsi), %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
movq %rcx, %rdx
shrq $0xc, %rdx
movq %r8, %r9
xorq %rcx, %rdx
movq %rdx, %r8
shlq $0x19, %r8
xorq %rdx, %r8
movq %r8, %rcx
shrq $0x1b, %rcx
xorq %r8, %rcx
movq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %r8
andq %r9, %r8
cmoveq %r9, %r8
blsrq %r8, %r9
jne 0x17c64
movq %rcx, (%rsi)
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rdx, %rsi
shrq $0x24, %rsi
movsbq 0x19(%rdi), %rax
andq %rdx, %rcx
orq %r8, (%rdi,%rax,8)
movq %rcx, %rax
shrq $0x26, %rax
testq %rcx, %rcx
sete %cl
andb $0x3, %sil
movq 0x8(%rdi), %r11
movq 0x10(%rdi), %r8
shlb $0x2, %al
movzbl %sil, %edx
movl $0xff, %esi
shlb $0x2, %cl
orb $0x2, %al
leal (%rdx,%rdx,8), %edx
orb $0x2, %cl
shlxq %rdx, %rsi, %rdx
andnq %r11, %rdx, %r9
andq %rdx, %r11
shrxq %rcx, %r11, %r10
shlxq %rax, %r11, %rsi
orq %r10, %rsi
andnq %r8, %rdx, %r10
andq %rdx, %r8
shrxq %rcx, %r8, %rcx
shlxq %rax, %r8, %rax
andq %rdx, %rsi
orq %rcx, %rax
orq %r9, %rsi
andq %rdx, %rax
movq %rsi, 0x8(%rdi)
orq %r10, %rax
movq %rax, 0x10(%rdi)
orq %rsi, %rax
movq %rax, (%rdi)
incb 0x18(%rdi)
movb $0x3, %al
subb 0x19(%rdi), %al
movb %al, 0x19(%rdi)
leaq 0x1a05d(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x1a(%rdi)
movb $0x1, %al
movw $0xdead, 0x1c(%rdi)     # imm = 0xDEAD
movq $0x0, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/agentmcts.h
// Function: Morat::Pentago::AgentMCTS::AgentThread::reset()
void reset(){
			treelen.reset();
			gamelen.reset();
			use_explore = false;
			for(int a = 0; a < 4; a++)
				times[a] = 0;
		}

// Assembly:
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
vxorps %xmm0, %xmm0, %xmm0
xorl %eax, %eax
movl %eax, 0x88(%rdi)
movq %rcx, 0x80(%rdi)
vmovups %xmm0, 0x90(%rdi)
vxorps %xmm0, %xmm0, %xmm0
movl %eax, 0xa8(%rdi)
movq %rcx, 0xa0(%rdi)
movb $0x0, 0x54(%rdi)
vmovups %ymm0, 0xb0(%rdi)
vmovups %ymm0, 0xc0(%rdi)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x18(%rdx), %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r14
cmpq $0x2, %rax
jb 0x1a49b
cmpw $0x0, 0x6(%rax)
jne 0x1a5ee
movq (%rsp), %r15
addq $0x18, %rbx
movq %r15, %rdi
callq 0xe682
leal (,%rax,8), %esi
leaq 0x50(%r14), %rdx
movq %rbx, %rdi
callq 0x1ac70
leaq 0x28(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0xe03e
leaq 0x178cf(%rip), %r12     # 0x31da6
leaq 0x8(%rsp), %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpb $0x24, 0x58(%rsp)
jge 0x1a5bf
movb 0x4a(%rsp), %al
leaq 0x178ae(%rip), %rcx     # 0x31da5
cmpb (%rcx), %al
jne 0x1a509
leaq 0x30(%rsp), %rdi
callq 0xe2a8
movb %al, 0x4a(%rsp)
movzwl 0x58(%rsp), %ecx
movq %r15, 0x10(%rsp)
movw $0x0, 0x18(%rsp)
leaq 0x17888(%rip), %rdi     # 0x31da9
movw %cx, 0x1a(%rsp)
movq %r15, 0x20(%rsp)
movzbl %al, %ecx
movl 0x1514(%r14), %edx
movl %edx, %esi
cmpb %al, (%rdi)
je 0x1a53d
movl %ecx, %esi
leaq 0x1785d(%rip), %rax     # 0x31da1
cmpb %dl, (%rax)
cmovnel %esi, %ecx
cmpb (%r12), %cl
jne 0x1a55e
movl $0x1, 0x8(%rsp)
movl $0x1, %eax
jmp 0x1a58d
movq (%rsp), %rax
movb 0x19(%rax), %al
cmpb %al, %cl
jne 0x1a575
movl $0x3fffffff, 0x8(%rsp)  # imm = 0x3FFFFFFF
xorl %eax, %eax
jmp 0x1a58d
movb $0x3, %dl
movl $0x0, 0x8(%rsp)
subb %al, %dl
xorl %eax, %eax
cmpb %dl, %cl
sete %al
orl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1ad98
movq %rax, %rdi
movq %r13, %rsi
callq 0x1adf6
movq %r13, %rdi
callq 0x1aa3e
incl %ebp
leaq 0x28(%rsp), %rdi
callq 0xe122
jmp 0x1a4e1
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a5ce
callq 0x5490
movl %ebp, %eax
lock
addq %rax, 0x38(%r14)
movl %ebp, %esi
movq (%rbx), %rdi
callq 0x1d0de
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13228(%rip), %rdi     # 0x2d81d
leaq 0x14710(%rip), %rsi     # 0x2ed0c
leaq 0x14816(%rip), %rcx     # 0x2ee19
movl $0x13d, %edx            # imm = 0x13D
callq 0x5200
jmp 0x1a61e
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x1aa3e
jmp 0x1a621
movq %rax, %rbx
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a630
callq 0x5490
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x170da(%rip), %r13     # 0x31da5
movb 0x19(%rdi), %r12b
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movb (%r13), %bl
callq 0xe03e
movb $0x3, %r15b
subb %r12b, %r15b
cmpb $0x23, 0x38(%rsp)
jg 0x1ad48
incl (%r14)
movb 0x2a(%rsp), %bpl
cmpb (%r13), %bpl
jne 0x1ad13
leaq 0x10(%rsp), %rdi
callq 0xe2a8
movl %eax, %ebp
movb %al, 0x2a(%rsp)
cmpb %r12b, %bpl
je 0x1ad5c
leaq 0x1708a(%rip), %rax     # 0x31da9
cmpb (%rax), %bpl
je 0x1ad3a
cmpb (%r13), %bl
movzbl %bpl, %eax
movzbl %bl, %ecx
movl %ecx, %ebp
cmovel %eax, %ebp
cmpb %r15b, %cl
cmovel %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xe122
movl %ebp, %ebx
jmp 0x1acee
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad57
callq 0x5490
movl %ebx, %r12d
jmp 0x1ad6b
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad6b
callq 0x5490
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x50(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x1ad8f
callq 0x5490
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
movq %rsi, %r14
testq %rdi, %rdi
je 0x1e569
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1590, %edi           # imm = 0x1590
callq 0x5350
movq %rax, %r15
movq %rax, %rdi
callq 0x111b6
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movl $0x1, %edx
movq %r15, %rdi
movq (%r15), %rax
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x10(%rsp), %r15
leaq 0xe29d(%rip), %rdx      # 0x2c843
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %r15, -0x10(%r15)
callq 0xb026
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9eba
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e5d6
callq 0x5310
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
jne 0x1e5f7
jmp 0x1e5fc
movq %rax, %rbx
movq %r15, %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
movq %rsi, %r14
testq %rdi, %rdi
je 0x1e625
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1540, %edi           # imm = 0x1540
callq 0x5350
movq %rax, %r15
movq %rax, %rdi
callq 0x20af8
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movl $0x1, %edx
movq %r15, %rdi
movq (%r15), %rax
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x10(%rsp), %r15
leaq 0xe1e1(%rip), %rdx      # 0x2c843
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %r15, -0x10(%r15)
callq 0xb026
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9eba
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e692
callq 0x5310
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
jne 0x1e6b3
jmp 0x1e6b8
movq %rax, %rbx
movq %r15, %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
movq %rsi, %r14
testq %rdi, %rdi
je 0x1e6e1
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x70, %edi
callq 0x5350
movq %rax, %r15
movq %rax, %rdi
callq 0x20c1e
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movl $0x1, %edx
movq %r15, %rdi
movq (%r15), %rax
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x10(%rsp), %r15
leaq 0xe125(%rip), %rdx      # 0x2c843
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %r15, -0x10(%r15)
callq 0xb026
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9eba
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e74e
callq 0x5310
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
jne 0x1e76f
jmp 0x1e774
movq %rax, %rbx
movq %r15, %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0x38(%rsp), %rax
movq %rdi, (%rsp)
subq $-0x80, %rsi
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x88(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xe03e
leaq 0xb8(%rsp), %r14
leaq 0x18(%rsp), %rbx
leaq 0x68(%rsp), %r15
leaq 0x1243b(%rip), %r12     # 0x31039
leaq 0x28(%rsp), %r13
leaq 0x88(%rsp), %rbp
cmpb $0x24, 0xb8(%rsp)
jge 0x1ecb4
movq %r15, %rdi
movq %r14, %rsi
callq 0xd3c2
movq %r15, %rdi
movq %r12, %rsi
callq 0x5720
movq %rbx, 0x8(%rsp)
movq %rax, %rcx
addq $0x10, %rcx
movq (%rax), %rdx
cmpq %rcx, %rdx
je 0x1ec52
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1ec5a
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x50e0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1ec93
callq 0x5310
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x1eca7
callq 0x5310
movq %rbp, %rdi
callq 0xe122
jmp 0x1ec0b
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x1ecc6
callq 0x5490
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x58(%rsp), %rbx
movq %rbx, -0x10(%rbx)
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x9f30
movq (%rsp), %rdi
leaq 0x48(%rsp), %rdx
movl $0x1, %esi
callq 0x9eba
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1ed08
callq 0x5310
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1ed1c
callq 0x5310
movq (%rsp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rsp), %rdi
movq %rax, %r14
cmpq %rbx, %rdi
je 0x1ed91
callq 0x5310
jmp 0x1ed91
jmp 0x1ed48
movq %rax, %r14
jmp 0x1ed91
jmp 0x1ed7c
movq %rax, %r14
jmp 0x1ed66
movq 0x8(%rsp), %rdi
movq %rax, %r14
cmpq %rbx, %rdi
je 0x1ed66
callq 0x5310
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x1ed7f
callq 0x5310
jmp 0x1ed7f
movq %rax, %r14
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x1ed91
callq 0x5490
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1eda5
callq 0x5310
movq %r14, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1129b(%rip), %rax     # 0x31da2
vxorps %xmm0, %xmm0, %xmm0
leaq 0x1c11e(%rip), %rcx     # 0x3cc30
leaq 0x50(%rdi), %rbx
movq %rdi, %r14
vmovups %xmm0, 0x19(%rdi)
vmovups %xmm0, 0x10(%rdi)
movb (%rax), %al
addq $0x10, %rcx
movb %al, 0x29(%rdi)
leaq 0x11272(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x2a(%rdi)
movw $0xdead, 0x2c(%rdi)     # imm = 0xDEAD
movq $0x0, 0x30(%rdi)
movq %rcx, (%rdi)
movq %rbx, %rdi
callq 0x21466
leaq 0x1410(%r14), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x214f8
leaq 0x11237(%rip), %rax     # 0x31da1
leaq 0x1520(%r14), %r12
movl $0x1, %ecx
movb (%rax), %al
movw $0xefc, 0x1532(%r14)    # imm = 0xEFC
movq $0x0, 0x1538(%r14)
movl %ecx, 0x1508(%r14)
movb $0x1, 0x150c(%r14)
movl $0x3e800000, 0x1510(%r14) # imm = 0x3E800000
movb %al, 0x1514(%r14)
movl %ecx, 0x1518(%r14)
movl $0x1, %esi
movq %r15, %rdi
callq 0x1ba7c
movl $0x5, 0x48(%r14)
xorl %eax, %eax
movq %rax, 0x38(%r14)
movq %rax, 0x14f8(%r14)
movb $0x0, 0x8(%r14)
movq (%r14), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
movq %r14, %rdi
callq *0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x20c0e
movq %r12, %rdi
movq %rax, %r14
callq 0x1aa3e
movq %r15, %rdi
callq 0x1c082
movq %rbx, %rdi
callq 0x1c0c4
movq %r14, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x11179(%rip), %rax     # 0x31da2
vxorps %xmm0, %xmm0, %xmm0
leaq 0x1bce4(%rip), %rcx     # 0x3c918
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
vmovups %xmm0, 0x19(%rdi)
vmovups %xmm0, 0x10(%rdi)
movb (%rax), %al
addq $0x10, %rcx
movb %al, 0x29(%rdi)
leaq 0x1114f(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x2a(%rdi)
movw $0xdead, 0x2c(%rdi)     # imm = 0xDEAD
movq %r14, 0x30(%rdi)
movq %rcx, (%rdi)
addq $0x68, %rdi
callq 0x1690c
vxorps %xmm0, %xmm0, %xmm0
movl $0x0, 0x50(%rbx)
movq %r14, 0x38(%rbx)
movl $0x6400000, %esi        # imm = 0x6400000
movq %rbx, %rdi
vmovups %xmm0, 0x58(%rbx)
movq (%rbx), %rax
callq *0x30(%rax)
movl $0x2, 0x6c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/pentago/moveiterator.h
// Function: Morat::Pentago::RandomMoveIterator<Morat::XORShift_uint64>::choose_rand()
void choose_rand(){
		// incremental fisher-yates shuffle. Choose a random element that hasn't yet been chosen.
		int j = rand() % (cur+1);
		Move tmp = moves[j];
		moves[j] = moves[cur];
		moves[cur] = tmp;
//		logerr(moves[cur].to_s() + " ");
	}

// Assembly:
movq 0x30(%rdi), %rax
movq (%rax), %rcx
movq %rcx, %rdx
shrq $0xc, %rdx
xorq %rcx, %rdx
movq %rdx, %rcx
shlq $0x19, %rcx
xorq %rdx, %rcx
movq %rcx, %rdx
shrq $0x1b, %rdx
xorq %rcx, %rdx
movq %rdx, (%rax)
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
movslq 0x40(%rdi), %rcx
imulq %rdx, %rax
xorl %edx, %edx
leaq 0x1(%rcx), %rsi
divq %rsi
movq 0x38(%rdi), %rax
movslq %edx, %rdx
movzwl (%rax,%rcx,2), %ecx
movzwl (%rax,%rdx,2), %esi
movw %cx, (%rax,%rdx,2)
movq 0x38(%rdi), %rax
movslq 0x40(%rdi), %rcx
movw %si, (%rax,%rcx,2)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x23c0
testq %rax, %rax
je 0x343e
movq %rax, %r14
movq %rax, %rdi
callq 0x23d0
testq %rax, %rax
je 0x3432
movq %rax, %r12
leaq -0x40(%rbp), %rbx
leaq -0x50(%rbp), %r15
leaq 0x13(%r12), %r13
movq %rbx, -0x50(%rbp)
movq %r13, %rdi
callq 0x2130
leaq (%r12,%rax), %rdx
addq $0x13, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3304
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x473c
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3422
callq 0x2280
movq %r14, %rdi
callq 0x23d0
movq %rax, %r12
testq %rax, %rax
jne 0x33e4
movq %r14, %rdi
callq 0x2400
xorl %eax, %eax
jmp 0x34bd
movq 0x4b93(%rip), %r14      # 0x7fd8
leaq 0x1e44(%rip), %rsi      # 0x5290
movl $0x6, %edx
movq %r14, %rdi
callq 0x2300
callq 0x2040
movq %rax, %rbx
movl (%rax), %esi
movq %r14, %rdi
callq 0x2450
movq %rax, %r14
leaq 0x1e22(%rip), %rsi      # 0x5297
movl $0xa, %edx
movq %rax, %rdi
callq 0x2300
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2300
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movl (%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x34dd
callq 0x2280
movq %r14, %rdi
callq 0x2470
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x80(%rbp), %rdi
callq 0x45e7
leaq -0x318(%rbp), %rdi
callq 0x2310
movq -0x80(%rbp), %rsi
leaq -0x318(%rbp), %rdi
movl $0x18, %edx
callq 0x2250
leaq -0x298(%rbp), %rdi
callq 0x20c0
movl %eax, %ebx
testb %al, %al
je 0x354a
leaq -0x318(%rbp), %rdi
callq 0x2070
jmp 0x3634
movq 0x4a87(%rip), %r14      # 0x7fd8
leaq 0x1d4a(%rip), %rsi      # 0x52a2
movl $0x12, %edx
movq %r14, %rdi
callq 0x2300
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x22a0
movsbl %al, %esi
movq 0x4a55(%rip), %rdi      # 0x7fd8
callq 0x2030
movq %rax, %rdi
callq 0x21a0
leaq -0x100(%rbp), %r14
movl $0x9, -0x4(%r14)
movabsq $0x726f6320656c6946, %rax # imm = 0x726F6320656C6946
movq %rax, (%r14)
movabsq $0x64657470757272, %rax # imm = 0x64657470757272
movq %rax, 0x7(%r14)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x2130
leaq (%rax,%rbp), %rdx
addq $-0x100, %rdx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3304
movl -0x104(%rbp), %r14d
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x469e
leaq 0x4c94(%rip), %rdi      # 0x82a0
leaq -0x60(%rbp), %rdx
movl %r14d, %esi
callq 0x3128
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3626
callq 0x2280
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3634
callq 0x2280
leaq -0x318(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3652
callq 0x2280
movl %ebx, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x367a
callq 0x2280
jmp 0x367a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3694
callq 0x2280
jmp 0x3694
jmp 0x3691
movq %rax, %rbx
jmp 0x36a0
movq %rax, %rbx
leaq -0x318(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36b2
callq 0x2280
movq %rbx, %rdi
callq 0x2470
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
leaq 0x5075(%rip), %rcx      # 0x92f0
leaq -0x4e0(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4652, %edx           # imm = 0x4652
callq 0x2866
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x2370
movq %rbx, %rdi
callq 0x2d88
leaq -0x12(%rbp), %r14
movw $0x43, (%r14)
cmpl $0x1, 0x5510(%rip)      # 0x97c4
jne 0x42d0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x2b26
movl $0x0, 0x54f4(%rip)      # 0x97c4
movl $0x2710, %edi           # imm = 0x2710
callq 0x2370
jmp 0x42ad
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0x463d
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x4628
ucomisd %xmm1, %xmm0
jb 0x4649
sqrtsd %xmm0, %xmm0
jmp 0x464e
callq 0x2150
ucomisd 0x39ca(%rip), %xmm0     # 0x8020
jbe 0x4688
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x4688
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x4672
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r15
movl 0x50(%rsp), %r12d
movl %ecx, 0x4(%rsp)
movl $0x1, %r8d
callq 0x5e76
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movl %r14d, 0x8(%rsp)
movl %r14d, %esi
movl %ebp, 0xc(%rsp)
movl %ebp, %edx
movl %r12d, %ecx
movl $0x1, %r8d
callq 0x5e76
movsd 0x10(%rsp), %xmm1
addsd 0x50(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x57c9
subsd %xmm0, %xmm1
addsd 0x40(%r15), %xmm1
movsd %xmm1, 0x40(%r15)
movq %r15, %rdi
movl %ebx, %esi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x1, %r9d
callq 0x60d4
movq %r15, %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movl %r12d, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x60d4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thunlp[P]KB2E/TransR/Train_TransR.cpp
// Function: Train::norm(std::vector<double, std::allocator<double>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void norm(vector<double> &a, vector<vector<double> > &A)
    {
    	while (true)
    	{
		    double x=0;
		    for (int ii=0; ii<m; ii++)
		    {
		        double tmp = 0;
		        for (int jj=0; jj<n; jj++)
		            tmp+=A[jj][ii]*a[jj];
		        x+=sqr(tmp);
		    }
		    if (x>1)
		    {
		        double lambda=1;
		        for (int ii=0; ii<m; ii++)
		        {
		            double tmp = 0;
		            for (int jj=0; jj<n; jj++)
		                tmp+=A[jj][ii]*a[jj];
		            tmp*=2;
		            for (int jj=0; jj<n; jj++)
		            {
		                A[jj][ii]-=rate*lambda*tmp*a[jj];
		                a[jj]-=rate*lambda*tmp*A[jj][ii];
		            }
		        }
		    }
		    else
		    	break;
		}
    }

// Assembly:
movslq 0x34(%rdi), %rax
testq %rax, %rax
jle 0x58f6
pushq %r14
pushq %rbx
movl 0x30(%rdi), %ecx
movsd 0x282d(%rip), %xmm0     # 0x8020
movq (%rdx), %r8
movq (%rsi), %r9
xorpd %xmm1, %xmm1
xorl %r10d, %r10d
xorpd %xmm2, %xmm2
testl %ecx, %ecx
jle 0x582c
movq %r8, %r11
xorl %ebx, %ebx
movq (%r11), %r14
movsd (%r14,%r10,8), %xmm3
mulsd (%r9,%rbx,8), %xmm3
addsd %xmm3, %xmm2
incq %rbx
addq $0x18, %r11
cmpq %rbx, %rcx
jne 0x580d
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
incq %r10
cmpq %rax, %r10
jne 0x5800
ucomisd %xmm0, %xmm1
jbe 0x58f3
testl %eax, %eax
jle 0x58f3
movq (%rdx), %r8
movq (%rsi), %r9
xorl %r10d, %r10d
testl %ecx, %ecx
jle 0x58df
xorpd %xmm1, %xmm1
movq %r8, %r11
xorl %ebx, %ebx
movq (%r11), %r14
movsd (%r14,%r10,8), %xmm2
mulsd (%r9,%rbx,8), %xmm2
addsd %xmm2, %xmm1
incq %rbx
addq $0x18, %r11
cmpq %rbx, %rcx
jne 0x5868
testl %ecx, %ecx
jle 0x58df
addsd %xmm1, %xmm1
movq %r8, %r11
xorl %ebx, %ebx
movq (%r11), %r14
movsd 0x48(%rdi), %xmm2
mulsd %xmm1, %xmm2
mulsd (%r9,%rbx,8), %xmm2
movsd (%r14,%r10,8), %xmm3
subsd %xmm2, %xmm3
movsd %xmm3, (%r14,%r10,8)
movsd (%r9,%rbx,8), %xmm2
movsd 0x48(%rdi), %xmm4
mulsd %xmm1, %xmm4
mulsd %xmm3, %xmm4
subsd %xmm4, %xmm2
movsd %xmm2, (%r9,%rbx,8)
incq %rbx
addq $0x18, %r11
cmpq %rbx, %rcx
jne 0x5894
incq %r10
cmpq %rax, %r10
jne 0x5857
testl %eax, %eax
jg 0x57f3
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq 0x40(%rdi), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x6980
movq 0x8(%rax), %rcx
movsd 0xa0(%rcx), %xmm1
mulsd 0x10(%rax), %xmm1
movq (%rax), %rcx
addsd %xmm1, %xmm0
movq %rcx, %rax
testq %rcx, %rcx
jne 0x6960
xorpd 0x56a8(%rip), %xmm0     # 0xc030
callq 0x6450
movsd 0x5673(%rip), %xmm1     # 0xc008
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Neuron::fire()
bool Neuron::fire()
{
    if (this->type != SENSORY_NEURON) {

        this->potential = this->calculate_potential();
        this->network->fire_counter++;
        this->fire_counter++;

        if (! std::isnan(this->desired_potential)) {

            this->loss = this->calculate_loss();
            int alteration_sign;
            if (this->loss > 0) {
                alteration_sign = -1;
            } else if (this->loss < 0) {
                alteration_sign = 1;
            } else {
                this->desired_potential = std::nan("None");
                return true;
            }

            double alteration_value = pow(this->loss, 2);
            alteration_value = alteration_value * pow(
                this->network->decay_factor,
                (this->network->fire_counter/1000)
            );

            for (auto& it: this->subscriptions) {
                it.first->desired_potential = it.first->potential
                    + alteration_sign
                    * this->derivative(it.first->potential);
                this->subscriptions[it.first] = it.second
                    + (alteration_value * alteration_sign)
                    * this->derivative(it.first->potential);
            }
        }
    }
    return false;
}

// Assembly:
cmpl $0x1, 0xa8(%rdi)
jne 0x69f4
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x6952
movsd %xmm0, 0xa0(%rbx)
movq 0x28(%rbx), %rcx
movq 0x180(%rcx), %rax
incq %rax
movq %rax, 0x180(%rcx)
incl 0x10(%rbx)
movsd (%rbx), %xmm1
ucomisd %xmm1, %xmm1
jp 0x6b20
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6a53
movsd %xmm0, (%rsp)
movsd 0x55af(%rip), %xmm0     # 0xc000
jmp 0x6a6a
ucomisd %xmm0, %xmm1
jbe 0x6b24
movsd %xmm0, (%rsp)
movsd 0x559e(%rip), %xmm0     # 0xc008
movsd %xmm0, 0x8(%rsp)
movsd 0x90(%rcx), %xmm0
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
shrq $0x4, %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
callq 0x6410
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x6b20
addq $0x30, %rbx
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x8(%rsp), %xmm2
movsd %xmm2, (%rsp)
leaq 0x8(%r14), %rsi
movq 0x8(%r14), %rax
movsd 0xa0(%rax), %xmm0
movsd 0x5531(%rip), %xmm3     # 0xc008
subsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
movsd 0x8(%rsp), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax)
mulsd %xmm2, %xmm3
addsd 0x10(%r14), %xmm3
movsd %xmm3, 0x10(%rsp)
movq %rbx, %rdi
callq 0x9dfc
movsd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r14), %r14
testq %r14, %r14
jne 0x6abf
xorl %eax, %eax
jmp 0x6b36
leaq 0x5581(%rip), %rdi      # 0xc0ac
callq 0x6050
movsd %xmm0, (%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x128(%rdi)
movq %rsp, %rdx
movq %rdi, (%rdx)
leaq 0x80(%rip), %rsi        # 0x754a
leaq 0x8(%rsp), %rdi
callq 0x82de
cmpq $0x0, 0x130(%rbx)
jne 0x753f
addq $0x130, %rbx            # imm = 0x130
leaq 0x8(%rsp), %r14
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x6420
movq 0x8aa1(%rip), %rbx      # 0xffa0
leaq 0x4c40(%rip), %rsi      # 0xc146
movl $0x18, %edx
movq %rbx, %rdi
callq 0x62d0
movb $0xa, (%r14)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62d0
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x7544
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x6070
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq %rsp, %rdi
callq 0x7b3a
movq 0x8541(%rip), %rdi      # 0xffa0
leaq 0x46de(%rip), %rsi      # 0xc144
movl $0x1, %edx
callq 0x62d0
movq 0x8529(%rip), %rdi      # 0xffa0
leaq 0x488e(%rip), %rsi      # 0xc30c
movl $0x8, %edx
callq 0x62d0
movq (%rsp), %rbx
movq 0x8(%rsp), %r12
cmpq %r12, %rbx
je 0x7ad0
movq 0x8503(%rip), %r14      # 0xffa0
leaq 0x1f(%rsp), %r15
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x63a0
movb $0x20, 0x1f(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62d0
addq $0x8, %rbx
cmpq %r12, %rbx
jne 0x7aa2
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x7ae5
movq 0x10(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x7b34
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7b03
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7b1c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x7b34
movq %rbx, %rdi
callq 0x6440
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mertyildiran[P]Plexus/plexus/plexus.cpp
// Function: Network::get_output() const
std::vector<double> Network::get_output() const
{
    std::vector<double> output;
    for (auto& neuron: this->motor_neurons) {
        int decimals = pow(10, this->precision);
        output.push_back(roundf(neuron->potential * decimals) / decimals);
    }
    return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r13
cmpq %r13, %r12
je 0x7bf0
movq %rsi, %r14
leaq 0x10(%rsp), %r15
xorps %xmm1, %xmm1
cvtsi2sdl (%r14), %xmm1
movsd 0x4485(%rip), %xmm0     # 0xc010
callq 0x6410
movq (%r12), %rax
cvttpd2dq %xmm0, %xmm0
movapd %xmm0, (%rsp)
cvtdq2pd %xmm0, %xmm0
mulsd 0xa0(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x6290
cvtdq2ps (%rsp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7bdc
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7be7
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa286
addq $0x8, %r12
cmpq %r13, %r12
jne 0x7b7b
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x7c40
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7c28
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x7c40
movq %r14, %rdi
callq 0x6440
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mertyildiran[P]Plexus/plexus/network.hpp
// Function: std::vector<Neuron*, std::allocator<Neuron*>> random_sample<std::vector<Neuron*, std::allocator<Neuron*>>>(std::vector<Neuron*, std::allocator<Neuron*>>, unsigned int)
RandomSampling random_sample(
    RandomSampling neurons,
    unsigned int sample_length
)
{
    RandomSampling sample;
    std::sample(neurons.begin(), neurons.end(), std::back_inserter(sample),
        sample_length, std::mt19937{std::random_device{}()});
    return sample;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2720, %rsp           # imm = 0x2720
movl %edx, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x2718(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x8d46
movq %r12, %rdi
callq 0x6320
movl %eax, %eax
movq %rax, 0x1390(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x1390(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x800f
leaq 0x1390(%rsp), %r8
movq $0x270, 0x1380(%r8) # imm = 0x270
movl %ebp, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x982d
leaq 0x8(%rsp), %rdi
callq 0x6260
movq %fs:0x28, %rax
cmpq 0x2718(%rsp), %rax
jne 0x80c5
movq %rbx, %rax
addq $0x2720, %rsp           # imm = 0x2720
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x80ca
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6260
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x80aa
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x2718(%rsp), %rax
jne 0x80c5
movq %r14, %rdi
callq 0x6440
callq 0x62a0
movq %rax, %rdi
callq 0x8390
// File: /workspace/github_cpp_makefile_star2_O3/mertyildiran[P]Plexus/plexus/wrapper.cpp
// Function: parse_iterable(std::vector<double, std::allocator<double>>&, _object*)
void parse_iterable(std::vector<double> &arr, PyObject *iter)
{
    while (true) {
        PyObject *next = PyIter_Next(iter);
        if (!next) {
            // nothing left in the iterator
            Py_XDECREF(next);
            break;
        }

        if (!PyFloat_Check(next)) {
            throw
                "One of the arguments contains an illegal "
                "value (other than float)"
            ;
        }

        double val = PyFloat_AsDouble(next);
        Py_XDECREF(next);
        arr.push_back(val);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rdi
callq 0x6430
testq %rax, %rax
je 0xa44f
movq %rax, %r13
movq 0x5bec(%rip), %r15      # 0xffd0
movq %rsp, %r12
movq 0x8(%r13), %rdi
cmpq %r15, %rdi
je 0xa3fc
movq %r15, %rsi
callq 0x6090
testl %eax, %eax
je 0xa46d
movq %r13, %rdi
callq 0x61c0
movsd %xmm0, (%rsp)
decq (%r13)
jne 0xa417
movq %r13, %rdi
callq 0x61d0
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xa434
movsd (%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0xa43f
movq %r14, %rdi
movq %r12, %rdx
callq 0xba2e
movq %rbx, %rdi
callq 0x6430
movq %rax, %r13
testq %rax, %rax
jne 0xa3e7
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0xa4a2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x6100
leaq 0x2073(%rip), %rcx      # 0xc4f1
movq %rcx, (%rax)
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %rcx
jne 0xa4a2
movq 0x5ae0(%rip), %rsi      # 0xff78
movq %rax, %rdi
xorl %edx, %edx
callq 0x63f0
callq 0x62a0