LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x1a32b(%rip), %rsi     # 0x2d2d4
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12ffa
leaq 0x1a31d(%rip), %rsi     # 0x2d2d9
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12fff
leaq 0x1a300(%rip), %rsi     # 0x2d2cf
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x12ff5
leaq 0x1a2e5(%rip), %rsi     # 0x2d2c7
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x13004
cmpq $0x2, 0x8(%r14)
ja 0x13014
movb $-0x3, (%rbx)
jmp 0x13007
movb $-0x1, (%rbx)
jmp 0x13007
movb $-0x2, (%rbx)
jmp 0x13007
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 0x13047
addl $-0x31, %eax
jmp 0x13009
leal -0x73(%rcx), %edx
cmpl $0x7, %edx
ja 0x13054
addl $-0x73, %eax
jmp 0x13009
addl $-0x61, %ecx
cmpl $0x7, %ecx
ja 0x13061
addl $-0x61, %eax
jmp 0x13009
xorl %eax, %eax
jmp 0x13009
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq 0x40(%rdi), %rax
lock
incq 0xd8(%rax)
movq 0x40(%rdi), %rax
cmpb $0x1, 0x48(%rax)
jne 0x16f81
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5600
vcvtsi2sdq (%r14), %xmm0, %xmm0
vcvtsi2sdq 0x8(%r14), %xmm1, %xmm1
vdivsd 0x1509a(%rip), %xmm1, %xmm1 # 0x2c008
vaddsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, 0xe0(%rbx)
movl $0x0, 0x78(%rbx)
movq 0x40(%rbx), %rax
vxorpd %xmm0, %xmm0, %xmm0
vmovupd %ymm0, 0x58(%rbx)
lock
incq 0xb0(%rax)
movq 0x40(%rbx), %rdx
movq 0xa0(%rdx), %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x20(%rsi)
vmovupd 0x80(%rdx), %ymm0
vmovupd %ymm0, (%rsi)
addq $0xa8, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
vzeroupper
callq 0x1709e
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 0x16ff3
lock
addq %rdx, 0xa8(%rax)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x17004
lock
addq %rcx, 0xb0(%rax)
movq 0x40(%rbx), %rax
cmpb $0x1, 0x48(%rax)
jne 0x17096
vmovupd 0xe0(%rbx), %xmm0
vmovupd 0xe8(%rbx), %xmm1
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)
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5600
vcvtsi2sdq (%r14), %xmm2, %xmm0
vcvtsi2sdq 0x8(%r14), %xmm2, %xmm1
vdivsd 0x14f8e(%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_O1/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
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rdi), %r15
leaq 0x1a133(%rip), %r12     # 0x31da5
leaq 0x1a130(%rip), %r13     # 0x31da9
movb 0x1a(%r14), %al
cmpb (%r12), %al
jne 0x17c8f
movq %r14, %rdi
callq 0xe358
movb %al, 0x1a(%r14)
movb 0x1a(%r14), %bpl
cmpb (%r13), %bpl
jge 0x17ca6
movq %r14, %rdi
movq %r15, %rsi
callq 0x17e76
jmp 0x17c79
leaq 0xa0(%rbx), %rdi
movzbl 0x18(%r14), %esi
callq 0x17d98
addq $0x58, %rbx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x17d60
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_O1/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
notq %rax
movb $0x24, %cl
bzhiq %rcx, %rax, %r8
movq (%rsi), %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
movq %r8, %r9
movq %rcx, %rdx
shrq $0xc, %rdx
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 0x17e90
movq %rcx, (%rsi)
movsbq 0x19(%rdi), %rax
orq %r8, (%rdi,%rax,8)
movq %rdx, %rax
shrq $0x24, %rax
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
andq %rdx, %rcx
movq %rcx, %rdx
shrq $0x26, %rdx
xorl %esi, %esi
testq %rcx, %rcx
sete %sil
andb $0x3, %al
movzbl %al, %eax
leal (%rax,%rax,8), %eax
movl $0xff, %ecx
leaq 0x2(,%rsi,4), %rsi
leaq 0x2(,%rdx,4), %rdx
shlxq %rax, %rcx, %rax
vmovdqu 0x8(%rdi), %xmm0
vpbroadcastq %rax, %xmm1
vpand %xmm1, %xmm0, %xmm2
vpbroadcastq %rsi, %xmm3
vpsrlq %xmm3, %xmm2, %xmm3
vpbroadcastq %rdx, %xmm4
vpsllq %xmm4, %xmm2, %xmm2
vpor %xmm2, %xmm3, %xmm2
vpternlogq $0xe2, %xmm0, %xmm1, %xmm2
vmovdqu %xmm2, 0x8(%rdi)
movq 0x10(%rdi), %rax
orq 0x8(%rdi), %rax
movq %rax, (%rdi)
incb 0x18(%rdi)
movb $0x3, %al
subb 0x19(%rdi), %al
movb %al, 0x19(%rdi)
leaq 0x19e3a(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x1a(%rdi)
movw $0xdead, 0x1c(%rdi)     # imm = 0xDEAD
movq $0x0, 0x20(%rdi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movl %eax, 0x88(%rdi)
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
movq %rcx, 0x80(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x90(%rdi)
movl %eax, 0xa8(%rdi)
movq %rcx, 0xa0(%rdi)
movb $0x0, 0x54(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0xb0(%rdi)
vmovups %ymm0, 0xc0(%rdi)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r14
movq 0x18(%rdx), %rax
cmpq $0x2, %rax
jb 0x1a6f7
cmpw $0x0, 0x6(%rax)
jne 0x1a861
addq $0x18, %rbx
movq (%rsp), %r15
movq %r15, %rdi
callq 0xe726
leal (,%rax,8), %esi
leaq 0x50(%r14), %rdx
movq %rbx, %rdi
callq 0x1af0a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xe0ba
xorl %r15d, %r15d
leaq 0x17670(%rip), %r12     # 0x31da6
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
cmpb $0x24, 0x58(%rsp)
jge 0x1a832
movb 0x4a(%rsp), %al
leaq 0x17652(%rip), %rcx     # 0x31da5
cmpb (%rcx), %al
jne 0x1a765
leaq 0x30(%rsp), %rdi
callq 0xe358
movb %al, 0x4a(%rsp)
movb 0x4a(%rsp), %sil
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movw $0x0, 0x18(%rsp)
movzwl 0x58(%rsp), %eax
movw %ax, 0x1a(%rsp)
movq %r15, 0x20(%rsp)
movl 0x1514(%r14), %ecx
movzbl %sil, %eax
movl %ecx, %edx
leaq 0x17601(%rip), %rdi     # 0x31da9
cmpb %sil, (%rdi)
je 0x1a7af
movl %eax, %edx
leaq 0x175eb(%rip), %rsi     # 0x31da1
cmpb %cl, (%rsi)
cmovnel %edx, %eax
cmpb (%r12), %al
jne 0x1a7d0
movl $0x1, 0x8(%rsp)
movl $0x1, %ecx
jmp 0x1a800
movq (%rsp), %rcx
movb 0x19(%rcx), %cl
cmpb %cl, %al
jne 0x1a7e7
movl $0x3fffffff, 0x8(%rsp)  # imm = 0x3FFFFFFF
xorl %ecx, %ecx
jmp 0x1a800
movb $0x3, %dl
subb %cl, %dl
xorl %ecx, %ecx
cmpb %dl, %al
sete %cl
movl $0x0, 0x8(%rsp)
orl $0x3ffffffe, %ecx       # imm = 0x3FFFFFFE
movl %ecx, 0xc(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b03e
movq %rax, %rdi
movq %r13, %rsi
callq 0x1b09c
movq %r13, %rdi
callq 0x1acd8
incl %ebp
leaq 0x28(%rsp), %rdi
callq 0xe1b8
jmp 0x1a73d
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a841
callq 0x5490
movl %ebp, %eax
lock
addq %rax, 0x38(%r14)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x1d3e6
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12fb5(%rip), %rdi     # 0x2d81d
leaq 0x1449d(%rip), %rsi     # 0x2ed0c
leaq 0x145a3(%rip), %rcx     # 0x2ee19
movl $0x13d, %edx            # imm = 0x13D
callq 0x5200
jmp 0x1a891
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1acd8
jmp 0x1a894
movq %rax, %rbx
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x1a8a3
callq 0x5490
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x16e3a(%rip), %r12     # 0x31da5
movb (%r12), %r15b
movb 0x19(%rdi), %r13b
leaq 0x8(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xe0ba
movb $0x3, %al
subb %r13b, %al
movb %al, 0x7(%rsp)
cmpb $0x23, 0x38(%rsp)
jg 0x1afef
incl (%rbx)
movb 0x2a(%rsp), %al
cmpb (%r12), %al
jne 0x1afac
leaq 0x10(%rsp), %rdi
callq 0xe358
movb %al, 0x2a(%rsp)
movb 0x2a(%rsp), %bpl
cmpb %r13b, %bpl
je 0x1b003
leaq 0x16dec(%rip), %rax     # 0x31da9
movb (%rax), %r14b
cmpb %r14b, %bpl
je 0x1afe0
cmpb (%r12), %r15b
movzbl %bpl, %eax
movzbl %r15b, %ecx
movl %ecx, %r14d
cmovel %eax, %r14d
cmpb 0x7(%rsp), %cl
cmovel %eax, %r14d
leaq 0x8(%rsp), %rdi
callq 0xe1b8
movl %r14d, %r15d
jmp 0x1af8b
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1affe
callq 0x5490
movl %r15d, %ebp
jmp 0x1b012
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1b012
callq 0x5490
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1b035
callq 0x5490
movq %rbx, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
testq %rdi, %rdi
je 0x1e8fd
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1590, %edi           # imm = 0x1590
callq 0x5350
movq %rax, %r15
movq %rax, %rdi
callq 0x11292
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq *0x20(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xdf05(%rip), %rdx      # 0x2c843
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xaffc
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x9e82
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e96a
callq 0x5310
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x1e98b
jmp 0x1e990
movq %rax, %rbx
movq %r15, %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
testq %rdi, %rdi
je 0x1e9b9
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1540, %edi           # imm = 0x1540
callq 0x5350
movq %rax, %r15
movq %rax, %rdi
callq 0x20ea2
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq *0x20(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xde49(%rip), %rdx      # 0x2c843
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xaffc
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x9e82
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1ea26
callq 0x5310
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x1ea47
jmp 0x1ea4c
movq %rax, %rbx
movq %r15, %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rsi), %rdi
testq %rdi, %rdi
je 0x1ea75
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x70, %edi
callq 0x5350
movq %rax, %r15
movq %rax, %rdi
callq 0x20fe8
movq %r15, 0xb8(%r14)
subq $-0x80, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq *0x20(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xdd8d(%rip), %rdx      # 0x2c843
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xaffc
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x9e82
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1eae2
callq 0x5310
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x1eb03
jmp 0x1eb08
movq %rax, %rbx
movq %r15, %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x56c0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, (%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
subq $-0x80, %rsi
leaq 0x88(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xe0ba
leaq 0xb8(%rsp), %r14
leaq 0x18(%rsp), %rbx
leaq 0x68(%rsp), %r15
leaq 0x120a7(%rip), %r12     # 0x31039
leaq 0x28(%rsp), %r13
leaq 0x88(%rsp), %rbp
cmpb $0x24, 0xb8(%rsp)
jge 0x1f048
movq %r15, %rdi
movq %r14, %rsi
callq 0xd416
movq %r15, %rdi
movq %r12, %rsi
callq 0x5720
movq %rbx, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1efe6
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1efee
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 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x50e0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1f027
callq 0x5310
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x1f03b
callq 0x5310
movq %rbp, %rdi
callq 0xe1b8
jmp 0x1ef9f
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x1f05a
callq 0x5490
leaq 0x58(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x9ef8
leaq 0x48(%rsp), %rdx
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x9e82
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1f09c
callq 0x5310
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1f0b0
callq 0x5310
movq (%rsp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1f131
callq 0x5310
jmp 0x1f131
jmp 0x1f0dc
movq %rax, %r14
jmp 0x1f131
jmp 0x1f110
movq %rax, %r14
jmp 0x1f0fa
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1f0fa
callq 0x5310
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x1f113
callq 0x5310
jmp 0x1f113
movq %rax, %r14
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x1f125
callq 0x5490
movq $0x0, 0xd0(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1f145
callq 0x5310
movq %r14, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %r14
leaq 0x1bb74(%rip), %rax     # 0x3ca28
movq %rax, (%rdi)
leaq 0x10ee3(%rip), %r12     # 0x31da1
movb (%r12), %al
movb %al, 0x29(%rdi)
leaq 0x10eda(%rip), %rax     # 0x31da6
movb (%rax), %al
movb %al, 0x2a(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
vmovups %xmm0, 0x19(%rdi)
leaq 0x10ebc(%rip), %rax     # 0x31da2
movb (%rax), %al
movb %al, 0x29(%rdi)
leaq 0x10eb3(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x2a(%rdi)
movw $0xdead, 0x2c(%rdi)     # imm = 0xDEAD
movq $0x0, 0x30(%rdi)
leaq 0x1bd24(%rip), %rax     # 0x3cc30
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x21852
leaq 0x1410(%r14), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x218e4
movb (%r12), %al
movb %al, 0x1514(%r14)
leaq 0x1520(%r14), %r12
movw $0xefc, 0x1532(%r14)    # imm = 0xEFC
movq $0x0, 0x1538(%r14)
movl $0x1, %eax
movl %eax, 0x1508(%r14)
movb $0x1, 0x150c(%r14)
movl $0x3e800000, 0x1510(%r14) # imm = 0x3E800000
movl %eax, 0x1518(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x1bd36
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 0x20fd7
movq %rax, %r14
movq %r12, %rdi
callq 0x1acd8
movq %r15, %rdi
callq 0x1c364
movq %rbx, %rdi
callq 0x1c3a6
movq %r14, %rdi
callq 0x56c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x1ba32(%rip), %rax     # 0x3ca28
movq %rax, (%rdi)
leaq 0x10da1(%rip), %rax     # 0x31da1
movb (%rax), %al
movb %al, 0x29(%rdi)
leaq 0x10d9a(%rip), %rax     # 0x31da6
movb (%rax), %al
movb %al, 0x2a(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
vmovups %xmm0, 0x19(%rdi)
leaq 0x10d7c(%rip), %rax     # 0x31da2
movb (%rax), %al
movb %al, 0x29(%rdi)
leaq 0x10d73(%rip), %rax     # 0x31da5
movb (%rax), %al
movb %al, 0x2a(%rdi)
movw $0xdead, 0x2c(%rdi)     # imm = 0xDEAD
xorl %r14d, %r14d
movq %r14, 0x30(%rdi)
leaq 0x1b84d(%rip), %rax     # 0x3c898
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x68, %rdi
xorl %esi, %esi
callq 0x16ad6
movl $0x0, 0x50(%rbx)
movq %r14, 0x38(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x58(%rbx)
movq (%rbx), %rax
movl $0x6400000, %esi        # imm = 0x6400000
movq %rbx, %rdi
callq *0x30(%rax)
movl $0x2, 0x6c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
imulq %rdx, %rax
movslq 0x40(%rdi), %rcx
leaq 0x1(%rcx), %rsi
xorl %edx, %edx
divq %rsi
movq 0x38(%rdi), %rax
movslq %edx, %rdx
movzwl (%rax,%rdx,2), %esi
movzwl (%rax,%rcx,2), %ecx
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_O1/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 0x34ce
movq %rax, %r14
movq %rax, %rdi
callq 0x23d0
testq %rax, %rax
je 0x34c2
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 0x3398
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x47bc
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x34b2
callq 0x2280
movq %r14, %rdi
callq 0x23d0
movq %rax, %r12
testq %rax, %rax
jne 0x3474
movq %r14, %rdi
callq 0x2400
xorl %eax, %eax
jmp 0x354d
movq 0x4b03(%rip), %r14      # 0x7fd8
leaq 0x1db4(%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 0x1d92(%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 0x356d
callq 0x2280
movq %r14, %rdi
callq 0x2470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4675
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 0x35da
leaq -0x318(%rbp), %rdi
callq 0x2070
jmp 0x36c4
movq 0x49f7(%rip), %r14      # 0x7fd8
leaq 0x1cba(%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 0x49c5(%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 0x3398
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 0x4722
leaq 0x4c04(%rip), %rdi      # 0x82a0
leaq -0x60(%rbp), %rdx
movl %r14d, %esi
callq 0x31bc
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x36b6
callq 0x2280
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x36c4
callq 0x2280
leaq -0x318(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36e2
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 0x370a
callq 0x2280
jmp 0x370a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3724
callq 0x2280
jmp 0x3724
jmp 0x3721
movq %rax, %rbx
jmp 0x3730
movq %rax, %rbx
leaq -0x318(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3742
callq 0x2280
movq %rbx, %rdi
callq 0x2470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4fe8(%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 0x2da8
leaq -0x12(%rbp), %r14
movw $0x43, (%r14)
cmpl $0x1, 0x5483(%rip)      # 0x97c4
jne 0x435d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x2b26
movl $0x0, 0x5467(%rip)      # 0x97c4
movl $0x2710, %edi           # imm = 0x2710
callq 0x2370
jmp 0x433a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4649
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 0x4634
ucomisd %xmm1, %xmm0
jb 0x4655
sqrtsd %xmm0, %xmm0
jmp 0x465a
callq 0x2150
ucomisd 0x39be(%rip), %xmm0     # 0x8020
jbe 0x4694
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x4694
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 0x467e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5dba
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 0x5dba
movsd 0x10(%rsp), %xmm1
addsd 0x50(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5713
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 0x601a
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 0x601a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movl 0x30(%rdi), %eax
movl 0x34(%rdi), %ecx
movsd 0x28eb(%rip), %xmm0     # 0x8020
testl %ecx, %ecx
jle 0x578c
movq (%rdx), %r8
movq (%rsi), %r9
xorpd %xmm1, %xmm1
xorl %r10d, %r10d
xorpd %xmm2, %xmm2
testl %eax, %eax
jle 0x5772
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, %rax
jne 0x5753
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
incq %r10
cmpq %rcx, %r10
jne 0x5746
ucomisd %xmm0, %xmm1
seta %r8b
jmp 0x578f
xorl %r8d, %r8d
testb %r8b, %r8b
je 0x5844
testl %ecx, %ecx
jle 0x583b
movq (%rdx), %r9
movq (%rsi), %r10
xorl %r11d, %r11d
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x57da
movq %r9, %rbx
xorl %r14d, %r14d
movq (%rbx), %r15
movsd (%r15,%r11,8), %xmm2
mulsd (%r10,%r14,8), %xmm2
addsd %xmm2, %xmm1
incq %r14
addq $0x18, %rbx
cmpq %r14, %rax
jne 0x57b7
addsd %xmm1, %xmm1
testl %eax, %eax
jle 0x582f
movq %r9, %rbx
xorl %r14d, %r14d
movq (%rbx), %r15
movsd 0x48(%rdi), %xmm2
mulsd %xmm1, %xmm2
mulsd (%r10,%r14,8), %xmm2
movsd (%r15,%r11,8), %xmm3
subsd %xmm2, %xmm3
movsd %xmm3, (%r15,%r11,8)
movsd (%r10,%r14,8), %xmm2
movsd 0x48(%rdi), %xmm4
mulsd %xmm1, %xmm4
mulsd %xmm3, %xmm4
subsd %xmm4, %xmm2
movsd %xmm2, (%r10,%r14,8)
incq %r14
addq $0x18, %rbx
cmpq %r14, %rax
jne 0x57e4
incq %r11
cmpq %rcx, %r11
jne 0x57a9
testb %r8b, %r8b
jne 0x5735
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x698e
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 0x696e
xorpd 0x569a(%rip), %xmm0     # 0xc030
callq 0x6450
movsd 0x5665(%rip), %xmm1     # 0xc008
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6a02
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x6960
movsd %xmm0, 0xa0(%rbx)
movq 0x28(%rbx), %rax
incq 0x180(%rax)
incl 0x10(%rbx)
movsd (%rbx), %xmm1
ucomisd %xmm1, %xmm1
jp 0x6b2f
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6a57
movsd %xmm0, (%rsp)
movsd 0x55ab(%rip), %xmm0     # 0xc000
jmp 0x6a6e
ucomisd %xmm0, %xmm1
jbe 0x6b33
movsd %xmm0, (%rsp)
movsd 0x559a(%rip), %xmm0     # 0xc008
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rbx), %rax
movsd 0x90(%rax), %xmm0
movq 0x180(%rax), %rax
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 0x6b2f
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 0x5522(%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 0x9dea
movsd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r14), %r14
testq %r14, %r14
jne 0x6ace
xorl %eax, %eax
jmp 0x6b45
leaq 0x5532(%rip), %rdi      # 0xc06c
callq 0x6050
movsd %xmm0, (%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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        # 0x756a
leaq 0x8(%rsp), %rdi
callq 0x8280
cmpq $0x0, 0x130(%rbx)
jne 0x755f
addq $0x130, %rbx            # imm = 0x130
leaq 0x8(%rsp), %r14
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x6420
movq 0x8a81(%rip), %rbx      # 0xffa0
leaq 0x4be0(%rip), %rsi      # 0xc106
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 0x7564
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x6070
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7af0
movq 0x8589(%rip), %rdi      # 0xffa0
leaq 0x46e6(%rip), %rsi      # 0xc104
movl $0x1, %edx
callq 0x62d0
movq 0x8571(%rip), %rdi      # 0xffa0
leaq 0x4896(%rip), %rsi      # 0xc2cc
movl $0x8, %edx
callq 0x62d0
movq (%rsp), %r15
movq 0x8(%rsp), %r12
cmpq %r12, %r15
je 0x7a85
movq 0x854b(%rip), %rbx      # 0xffa0
leaq 0x1f(%rsp), %r14
movsd (%r15), %xmm0
movq %rbx, %rdi
callq 0x63a0
movb $0x20, 0x1f(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x62d0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x7a5a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7a9b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x7aea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7ab9
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7ad2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x7aea
movq %rbx, %rdi
callq 0x6440
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ba6
movq %rsi, %r14
leaq 0x10(%rsp), %r15
xorps %xmm1, %xmm1
cvtsi2sdl (%r14), %xmm1
movsd 0x44cf(%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 0x7b92
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7b9d
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa288
addq $0x8, %r12
cmpq %r13, %r12
jne 0x7b31
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x7bf6
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 0x7bde
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x7bf6
movq %r14, %rdi
callq 0x6440
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x2718, %rsp           # imm = 0x2718
movl %edx, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x2710(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
movq %rsp, %rdi
callq 0x8cc6
movq %rsp, %rdi
callq 0x6320
movl %eax, %eax
movq %rax, 0x1388(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x1388(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x7fbe
leaq 0x1388(%rsp), %r8
movq $0x270, 0x1380(%r8) # imm = 0x270
movl %ebp, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x979d
movq %rsp, %rdi
callq 0x6260
movq %fs:0x28, %rax
cmpq 0x2710(%rsp), %rax
jne 0x8073
movq %rbx, %rax
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8078
movq %rax, %r14
jmp 0x8044
movq %rax, %r14
movq %rsp, %rdi
callq 0x6260
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8058
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6280
movq %fs:0x28, %rax
cmpq 0x2710(%rsp), %rax
jne 0x8073
movq %r14, %rdi
callq 0x6440
callq 0x62a0
movq %rax, %rdi
callq 0x8342
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5bfc(%rip), %r15      # 0xffd0
movq %rsp, %r12
movq %rbx, %rdi
callq 0x6430
testq %rax, %rax
je 0xa444
movq %rax, %r13
movq 0x8(%rax), %rdi
cmpq %r15, %rdi
je 0xa3fc
movq %r15, %rsi
callq 0x6090
testl %eax, %eax
je 0xa462
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 0xba32
testq %r13, %r13
jne 0xa3d7
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0xa497
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x6100
leaq 0x203e(%rip), %rcx      # 0xc4b1
movq %rcx, (%rax)
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %rcx
jne 0xa497
movq 0x5aeb(%rip), %rsi      # 0xff78
movq %rax, %rdi
xorl %edx, %edx
callq 0x63f0
callq 0x62a0