LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/main.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string readFile(const std::string &fileName)
{
	std::ifstream fin(fileName.c_str(), std::ios::binary | std::ios::ate);

	if (!fin) {
		std::cerr << "error: could not open the file" << std::endl;
		return "";
	}

	std::ifstream::pos_type fileSize = fin.tellg();
	fin.seekg(0, std::ios::beg);

	std::vector<char> bytes(fileSize);
	fin.read(bytes.data(), fileSize);
	fin.close();

	return std::string(bytes.data(), fileSize);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x20(%rsp), %r14
pushq $0x6
popq %rdx
movq %r14, %rdi
callq 0x53a0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x9bfb
movq 0x2141f(%rip), %rdi     # 0x2aff0
leaq 0x1350e(%rip), %rsi     # 0x1d0e6
callq 0x51d0
movq %rax, %rdi
callq 0x5110
leaq 0x13ca2(%rip), %rsi     # 0x1d88e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x9f7c
jmp 0x9c68
leaq 0x20(%rsp), %rdi
callq 0x5370
movq %rax, %r14
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5290
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x9fb8
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x5260
leaq 0x20(%rsp), %rdi
callq 0x5080
movq 0x8(%rsp), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa2e0
leaq 0x8(%rsp), %rdi
callq 0xa3c6
leaq 0x20(%rsp), %rdi
callq 0x50a0
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
jmp 0x9c86
jmp 0x9c97
jmp 0x9c97
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa3c6
jmp 0x9c9a
jmp 0x9c97
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x50a0
movq %rbx, %rdi
callq 0x5380
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_ = from_str<int>(s);
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size();
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
callq 0x93ca
movl %eax, %ebp
testb %al, %al
je 0x93bf
movq %r14, %rdi
callq 0x93db
movq %rsp, %r14
movb %al, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1705c
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x952e
leaq 0x8(%rsp), %rdi
callq 0x9562
movsbl (%rbx), %esi
leaq 0x10(%rbx), %rdi
imull %esi, %esi
movw %si, 0x2(%rbx)
callq 0x9432
movq %rbx, %rdi
callq 0x9466
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, init_pattern(pos));
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1b6aa(%rip), %rax     # 0x24b22
movl $0x78fd0000, 0x4(%rdi)  # imm = 0x78FD0000
leaq 0x1b69a(%rip), %r12     # 0x24b20
leaq 0x4(%rsp), %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movb (%rax), %al
movb %al, 0x8(%rdi)
leaq 0x1b68a(%rip), %rax     # 0x24b26
movb (%rax), %al
movb %al, 0x9(%rdi)
andq $0x0, 0x28(%rdi)
movb (%rdi), %al
movsbl %al, %ecx
cmpl %ecx, %ebp
jge 0x951f
xorl %r15d, %r15d
movsbl %al, %ecx
cmpl %ecx, %r15d
jge 0x951b
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x977a
movl %eax, 0x4(%rsp)
movsbl (%rbx), %eax
cmpl %eax, %r15d
setl %cl
cmpl %eax, %ebp
movq %r12, %rax
setl %dl
andb %cl, %dl
testb $0x1, %dl
je 0x94ea
leaq 0x1b637(%rip), %rax     # 0x24b21
movb (%rax), %r13b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9788
movswq 0x6(%rsp), %rcx
movq 0x10(%rbx), %rdx
incl %r15d
shlq $0x4, %rcx
movb %r13b, (%rdx,%rcx)
movb $0x0, 0x1(%rdx,%rcx)
movq %rax, 0x8(%rdx,%rcx)
movb (%rbx), %al
jmp 0x94b2
incl %ebp
jmp 0x94a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/agentmcts.cpp
// Function: Morat::Gomoku::AgentMCTS::AgentMCTS(Morat::Gomoku::Board const&)
AgentMCTS::AgentMCTS(const Board & b) : Agent(b), pool(this) {
	nodes = 0;
	runs = 0;
	gclimit = 5;

	profile     = false;
	ponder      = false;
//#ifdef SINGLE_THREAD ... make sure only 1 thread
	numthreads  = 1;
	pool.set_num_threads(numthreads);
	maxmem      = 1000*1024*1024;

	msrave      = -2;
	msexplore   = 0;

	explore     = 0;
	parentexplore = false;
	ravefactor  = 500;
	decrrave    = 200;
	knowledge   = true;
	userave     = 1;
	useexplore  = 1;
	fpurgency   = 1;
	rollouts    = 1;
	dynwiden    = 0;
	logdynwiden = (dynwiden ? std::log(dynwiden) : 0);

	shortrave   = false;
	keeptree    = true;
	minimax     = 2;
	visitexpand = 1;
	gcsolved    = 100000;

	localreply  = 0;
	locality    = 0;

	weightedrandom = false;
	lastgoodreply  = false;

	for(int i = 0; i < 4096; i++)
		gammas[i] = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xd84c
leaq 0x2ceac(%rip), %rax     # 0x388e0
leaq 0x40c0(%rbx), %r14
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xd860
leaq 0x4110(%rbx), %r15
movq %r15, %rdi
callq 0xd88e
leaq 0x54d0(%rbx), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xd8ec
andq $0x0, 0x40f0(%rbx)
andq $0x0, 0x4100(%rbx)
xorl %eax, %eax
movl $0x5, 0x40f8(%rbx)
movb %al, 0x60(%rbx)
movb %al, 0x50(%rbx)
movl $0x1, 0x54(%rbx)
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0xd95a
vmovss 0x15755(%rip), %xmm0    # 0x211f8
movq $0x3e800000, 0x58(%rbx) # imm = 0x3E800000
movabsq $0x13f800000, %rax      # imm = 0x13F800000
vmovlps %xmm0, 0x64(%rbx)
vmovsd 0x1575e(%rip), %xmm0    # 0x21220
movb $0x0, 0x6c(%rbx)
vmovsd %xmm0, 0x70(%rbx)
vbroadcastss 0x15728(%rip), %xmm0 # 0x211fc
movl $0x43480000, 0x78(%rbx) # imm = 0x43480000
movb $0x1, 0x7c(%rbx)
vmovlps %xmm0, 0x80(%rbx)
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movabsq $0x100000002, %rax      # imm = 0x100000002
vxorps %xmm0, %xmm0, %xmm0
movw $0x100, 0x98(%rbx)      # imm = 0x100
movq %rax, 0x9c(%rbx)
movl $0x186a0, 0xa4(%rbx)    # imm = 0x186A0
xorl %eax, %eax
vmovups %xmm0, 0xac(%rbx)
cmpq $0x1000, %rax           # imm = 0x1000
je 0xbb40
movl $0x3f800000, 0xbc(%rbx,%rax,4) # imm = 0x3F800000
incq %rax
jmp 0xbb28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r13, %rdi
movq %rax, %r12
callq 0xdac6
jmp 0xbb5a
movq %rax, %r12
movq %r15, %rdi
callq 0xdb04
jmp 0xbb67
movq %rax, %r12
movq %r14, %rdi
callq 0xdb4c
jmp 0xbb74
movq %rax, %r12
movq %rbx, %rdi
callq 0xeaf2
movq %r12, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::move(Morat::MoveValid const&, bool, bool)
bool move(const MoveValid & pos, bool checkwin = true, bool permanent = true) {
		assert(!outcome_.solved());

		if(!valid_move(pos))
			return false;

		if(checkwin) {
			outcome_ = test_outcome(pos, to_play_);
		}

		last_move_ = pos;
		num_moves_++;

		Cell& cell = cells_[pos.xy];
		cell.piece = to_play_;
		cell.perm = permanent;

		update_hash(pos, to_play_); //depends on num_moves_
		update_pattern(pos, to_play_);

		to_play_ = ~to_play_;

		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x15d12(%rip), %r8      # 0x24b29
movb 0x9(%rdi), %al
movl %ecx, %r15d
cmpb (%r8), %al
jge 0xeeb4
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
callq 0xeed4
movl %eax, %ebp
testb %al, %al
je 0xeea9
testb %r12b, %r12b
je 0xee50
movl 0x8(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xef08
movb %al, 0x9(%rbx)
movzwl (%r14), %eax
leaq 0x15da5(%rip), %rsi     # 0x24c00
movq %rbx, %rdi
movw %ax, 0x6(%rbx)
incw 0x4(%rbx)
movswq 0x2(%r14), %rax
movq 0x10(%rbx), %rcx
movb 0x8(%rbx), %dl
shlq $0x4, %rax
movb %dl, (%rcx,%rax)
movb %r15b, 0x1(%rcx,%rax)
movswq 0x2(%r14), %rcx
movl 0x8(%rbx), %edx
leaq (%rcx,%rcx,2), %rcx
movsbq %dl, %rax
addq %rax, %rcx
movq (%rsi,%rcx,8), %rax
movq %r14, %rsi
xorq %rax, 0x28(%rbx)
callq 0xf000
movb $0x3, %al
subb 0x8(%rbx), %al
movb %al, 0x8(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x129d9(%rip), %rdi     # 0x21894
leaq 0x1196c(%rip), %rsi     # 0x2082e
leaq 0x129de(%rip), %rcx     # 0x218a7
movl $0xbb, %edx
callq 0x51f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::test_outcome(Morat::MoveValid const&, Morat::Side) const
Outcome test_outcome(const MoveValid & pos, Side turn) const {
		if (test_local(pos, turn)) {
			for (int d = 0; d < 4; d++) {
				int num = 1;
				MoveValid nb = pos;
				for (int i = 0; i < 4; i++) {
					nb = neighbors(nb)[d];
					if (nb.on_board() && get(nb) == turn)
						num++;
					else
						break;
				}
				nb = pos;
				for (int i = 0; i < 4; i++) {
					nb = neighbors(nb)[d + 4];
					if (nb.on_board() && get(nb) == turn)
						num++;
					else
						break;
				}
				if (num >= 5)
					return +turn;
			}
		}

		if(num_moves_+1 == num_cells_)
			return Outcome::DRAW;

		return Outcome::UNKNOWN;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0xf044
testb %al, %al
je 0xefd3
movzwl 0x2(%r15), %eax
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
xorl %esi, %esi
pushq $0x5
popq %rdi
pushq $0x4
popq %r8
cmpq $0x4, %rsi
je 0xefd3
leaq (%rdx,%rsi,4), %r10
movl %eax, %r11d
movl %edi, %r9d
cmpl $0x9, %r9d
je 0xef81
movswq %r11w, %r11
imulq $0x60, %r11, %r11
movl (%r10,%r11), %r11d
shrl $0x10, %r11d
cmpl $0xffff, %r11d          # imm = 0xFFFF
je 0xef81
movswq %r11w, %r15
shlq $0x4, %r15
cmpb %bl, (%rcx,%r15)
jne 0xef81
incl %r9d
jmp 0xef4f
leaq 0x10(%rdx,%rsi,4), %r11
leal -0x4(%r9), %r10d
movl %eax, %r15d
movl %r8d, %ebp
subl $0x1, %ebp
jb 0xefc4
movswq %r15w, %r15
imulq $0x60, %r15, %r15
movl (%r11,%r15), %r15d
shrl $0x10, %r15d
cmpl $0xffff, %r15d          # imm = 0xFFFF
je 0xefc1
movswq %r15w, %r12
shlq $0x4, %r12
cmpb %bl, (%rcx,%r12)
jne 0xefc1
incl %r10d
jmp 0xef90
movl %r10d, %r9d
incq %rsi
cmpl $0x5, %r9d
jb 0xef3b
jmp 0xeff5
movswl 0x4(%r14), %eax
movswl 0x2(%r14), %ecx
incl %eax
cmpl %ecx, %eax
jne 0xefec
leaq 0x15b3f(%rip), %rax     # 0x24b29
jmp 0xeff3
leaq 0x15b33(%rip), %rax     # 0x24b26
movb (%rax), %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/../lib/board_grid_oct.h
// Function: Morat::BoardGridOct<Morat::Gomoku::Board>::local(int, Morat::Side) const
int local(int i,               Side turn) const {
		Pattern p = pattern(i);
		Pattern x = ((p & 0xAAAAAAAAAAAAull) >> 1) ^ (p & 0x555555555555ull); // p1 is now when p1 or p2 but not both (ie off the board)
		p = x & (turn == Side::P1 ? p : p >> 1); // now just the selected player
		return (p & 0x00000000FFFF ? 3 : 0) |
		       (p & 0x0000FFFF0000 ? 2 : 0) |
		       (p & 0xFFFF00000000 ? 1 : 0);
	}

// Assembly:
pushq %rbx
movl %edx, %ebx
callq 0xf0b0
leaq 0x15ab7(%rip), %rdx     # 0x24b22
movq %rax, %rcx
shrq %rcx
xorq %rax, %rcx
cmpb %bl, (%rdx)
setne %dl
shrxq %rdx, %rax, %rdx
xorl %eax, %eax
andq %rcx, %rdx
testl $0x55550000, %edx       # imm = 0x55550000
setne %al
addl %eax, %eax
testw $0x5555, %dx            # imm = 0x5555
pushq $0x3
popq %rcx
movabsq $0x555500000000, %rsi   # imm = 0x555500000000
cmovel %eax, %ecx
xorl %eax, %eax
testq %rsi, %rdx
setne %al
orl %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/agentmctsthread.cpp
// Function: Morat::Gomoku::AgentMCTS::AgentThread::add_knowledge(Morat::Gomoku::Board const&, Morat::Gomoku::AgentMCTS::Node*, Morat::Gomoku::AgentMCTS::Node*)
void AgentMCTS::AgentThread::add_knowledge(const Board & board, Node * node, Node * child){
	if(agent->localreply){ //boost for moves near the previous move
		int dist = board.dist(node->move, child->move);
		if(dist < 4)
			child->know += agent->localreply * (4 - dist);
	}

	if(agent->locality) //boost for moves near previous stones
		child->know += agent->locality * board.local(child->move, board.to_play());
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
movq %rcx, %rbx
movl 0xac(%rax), %ecx
testl %ecx, %ecx
je 0x11fed
movsbl 0x25(%rdx), %edi
movsbl 0x25(%rbx), %r8d
movsbl 0x24(%rdx), %r9d
movsbl 0x24(%rbx), %edx
subl %r8d, %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
subl %edx, %r9d
movl $0xff, %edi
andl %edi, %r8d
movl %r9d, %edx
negl %edx
cmovsl %r9d, %edx
andl %edi, %edx
cmpl %edx, %r8d
cmoval %r8d, %edx
cmpl $0x3, %edx
ja 0x11fed
pushq $0x4
popq %rdi
subl %edx, %edi
imull %ecx, %edi
addw %di, 0x20(%rbx)
movl 0xb0(%rax), %ebp
testl %ebp, %ebp
je 0x12010
movl 0x8(%rsi), %edx
leaq 0x24(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1224e
imull %ebp, %eax
addw %ax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/agentmctsthread.cpp
// Function: Morat::Gomoku::AgentMCTS::AgentThread::rollout_choose_move(Morat::Gomoku::Board&, Morat::Move const&)
Move AgentMCTS::AgentThread::rollout_choose_move(Board & board, const Move & prev){
	//reuse the last good reply
	if(agent->lastgoodreply){
		Move move = last_good_reply.choose_move(board, prev);
		if(move != M_UNKNOWN)
			return move;
	}

	return random_policy.choose_move(board, prev);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x40(%rdi), %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0xb8(%rax)
je 0x12046
leaq 0x4c(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12328
cmpb $-0x4, %al
jne 0x12060
addq $0xa14, %r15            # imm = 0xA14
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x123a6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/board.cpp
// Function: Morat::Gomoku::Board::gen_neighbor_list() const
std::shared_ptr<MoveValid> Board::gen_neighbor_list() const {
	std::shared_ptr<MoveValid> list(new MoveValid[vec_size()*24]);
	MoveValid * a = list.get();
	for(int y = 0; y < size_; y++){
		for(int x = 0; x < size_; x++){
			Move pos(x,y);

			for(int i = 0; i < 24; i++){
				Move loc = pos + neighbor_offsets[i];
				*a = MoveValid(loc, (on_board(loc) ? xy(loc) : -1) );
				++a;
			}
		}
	}

	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsbl (%rsi), %ebp
movq %rdi, %rbx
movq %rsi, %r14
movl %ebp, %eax
imull %ebp, %eax
imull $0x18, %eax, %r15d
leaq (,%r15,4), %rdi
callq 0x5030
testl %ebp, %ebp
je 0x1709c
leaq (%rax,%r15,4), %rcx
movq %rax, %rdx
movl $0xffff78fc, (%rdx)     # imm = 0xFFFF78FC
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x1708d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1721a
movq (%rbx), %rax
movb (%r14), %r8b
leaq 0xc3dc(%rip), %rdx      # 0x23490
xorl %ecx, %ecx
movsbl %r8b, %esi
cmpl %esi, %ecx
jge 0x17133
xorl %esi, %esi
movsbl %r8b, %edi
cmpl %edi, %esi
jge 0x1712f
xorl %edi, %edi
cmpq $0x60, %rdi
je 0x17125
movb 0x1(%rdi,%rdx), %bpl
movb (%rdi,%rdx), %r11b
movl $0xffff0000, %r9d       # imm = 0xFFFF0000
addb %sil, %bpl
addb %cl, %r11b
movzbl %bpl, %r8d
movl %r8d, %r10d
orb %r11b, %r10b
movzbl %r11b, %r10d
js 0x17111
movb (%r14), %r15b
cmpb %r15b, %bpl
jge 0x17111
cmpb %r15b, %r11b
jae 0x17111
movzbl %r15b, %r9d
imull %r10d, %r9d
addl %r8d, %r9d
shll $0x10, %r9d
shll $0x8, %r8d
orl %r10d, %r8d
orl %r9d, %r8d
movl %r8d, (%rax,%rdi)
addq $0x4, %rdi
jmp 0x170ca
movb (%r14), %r8b
incl %esi
addq %rdi, %rax
jmp 0x170c0
incl %ecx
jmp 0x170b6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/agentpns.h
// Function: Morat::Gomoku::AgentPNS::AgentPNS(Morat::Gomoku::Board const&)
AgentPNS(const Board & b) : Agent(b), pool(this) {
		ab = 2;
		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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xd84c
leaq 0x1f8a6(%rip), %rax     # 0x38b90
leaq 0x68(%rbx), %r14
addq $0x10, %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x19ba4
leaq 0x1428(%rbx), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19c02
leaq 0xb80b(%rip), %rax      # 0x24b21
leaq 0x1538(%rbx), %r12
movb (%rax), %al
movw $0x78fc, 0x154a(%rbx)   # imm = 0x78FC
andq $0x0, 0x1550(%rbx)
movl $0x2, 0x1520(%rbx)
movb $0x1, 0x1524(%rbx)
movl $0x3e800000, 0x1528(%rbx) # imm = 0x3E800000
movb %al, 0x152c(%rbx)
movl $0x1, 0x1530(%rbx)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x1550c
movl $0x5, 0x60(%rbx)
andq $0x0, 0x50(%rbx)
andq $0x0, 0x1510(%rbx)
movb $0x0, 0x8(%rbx)
movq (%rbx), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
movq %rbx, %rdi
callq *0x30(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r13
jmp 0x193b3
movq %rax, %r13
jmp 0x193bb
movq %r12, %rdi
movq %rax, %r13
callq 0x147fa
movq %r15, %rdi
callq 0x15a2a
movq %r14, %rdi
callq 0x15a68
movq %rbx, %rdi
callq 0xeaf2
movq %r13, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/gomoku/../lib/board_grid_oct.h
// Function: Morat::BoardGridOct<Morat::Gomoku::Board>::pattern_mirror(unsigned long)
static Pattern pattern_mirror(Pattern p) {
		/*
		 *  8  16 9 17 10    10 17  9 16  8
		 * 23  0  1  2 18    18  2  1  0 23
		 * 15  7  X  3 11 => 11  3  X  7 15
		 * 22  6  5  4 19    19  4  5  6 22
		 * 14 21 13 20 12    12 20 13 21 14
		 */

		// pull out an entry
		#define e(a) (p & (3ull << (2 * a)))

		// swap two entries, a > b
		#define s(a, b) ((e(a) >> (2 * (a - b))) | e(b) << (2 * (a - b)))

		return e(9) | e(1) | e(5) | e(13) |
		       s(17, 16) | s( 2,  0) | s( 7,  3) | s( 6,  4) | s(21, 20) |
		       s(10,  8) | s(23, 18) | s(15, 11) | s(22, 19) | s(14, 12);

		#undef e
		#undef s
	}

// Assembly:
vpmovsxbq 0x984b(%rip), %ymm2 # 0x23660
vpbroadcastq %rdi, %zmm0
vpsrlvq 0x985c(%rip), %xmm0, %xmm1 # 0x23680
vpmovsxbq 0x983a(%rip), %zmm5 # 0x23668
movq %rdi, %rdx
shlq $0x4, %rdx
leaq (,%rdi,4), %rcx
movabsq $0xc00000000, %rax      # imm = 0xC00000000
movq %rdi, %rsi
shrq $0xa, %rsi
vmovq %rdx, %xmm4
movb $-0x80, %dl
andq %rcx, %rax
movl %edi, %ecx
kmovd %edx, %k1
shlq $0xa, %rdi
movb $0x8, %dl
andl $0xc0c0, %ecx           # imm = 0xC0C0
rolw $0x8, %cx
movzwl %cx, %ecx
vpsllvq %ymm2, %ymm0, %ymm3
vpsrlvq %ymm2, %ymm0, %ymm2
vpblendd $0xcc, %ymm2, %ymm3, %ymm2 # ymm2 = ymm3[0,1],ymm2[2,3],ymm3[4,5],ymm2[6,7]
vpunpcklqdq %xmm0, %xmm4, %xmm3 # xmm3 = xmm4[0],xmm0[0]
valignq $0x5, %zmm1, %zmm1, %zmm4 # zmm4 = zmm1[5,6,7,0,1,2,3,4]
vinserti32x4 $0x1, %xmm1, %zmm3, %zmm3
vpermi2q %zmm3, %zmm2, %zmm5
vmovq %rsi, %xmm2
vinserti32x4 $0x0, %xmm2, %zmm4, %zmm2
vpbroadcastq %rdi, %zmm5 {%k1}
kmovd %edx, %k1
vpsllq $0x2, %zmm0, %zmm2 {%k1}
vpmovsxbq 0x97b0(%rip), %zmm0 # 0x23670
vpermi2q %zmm2, %zmm3, %zmm0
vpandq 0x9870(%rip), %zmm5, %zmm2 # 0x23740
vmovq %rax, %xmm3
vpternlogq $0xf8, 0x98a0(%rip), %zmm0, %zmm2 # 0x23780
vextracti64x4 $0x1, %zmm2, %ymm0
vporq %zmm0, %zmm2, %zmm0
vextracti128 $0x1, %ymm0, %xmm2
vpor %xmm2, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm2     # xmm2 = xmm0[2,3,2,3]
vpor %xmm2, %xmm0, %xmm0
vpunpcklqdq %xmm3, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm3[0]
vpternlogq $0xf8, 0x9781(%rip), %xmm1, %xmm0 # 0x23690
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpor %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rax
orq %rcx, %rax
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: aes::soft::gmul(unsigned char, unsigned char)
uint8_t gmul (uint8_t a, uint8_t b) noexcept
	{
		uint8_t c = 0;

		for (int i = 0 ; i < 8 ; i ++)
		{
			if ((b & 1) != 0)
				c ^= a;
			
			uint8_t h = (uint8_t) ((signed char) a >> 7);

			a = (a << 1) ^ (0x1b & h);
			b >>= 1;
		}

		return c;
	}

// Assembly:
pushq $0x8
popq %rcx
xorl %eax, %eax
subl $0x1, %ecx
jb 0x22d5
movl %esi, %edx
andb $0x1, %dl
negb %dl
andb %dil, %dl
xorb %dl, %al
leal (%rdi,%rdi), %edx
sarb $0x7, %dil
andb $0x1b, %dil
xorb %dl, %dil
shrb %sil
jmp 0x22b1
retq
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: aes::soft::inv_mc_pre(unsigned char*)
void inv_mc_pre (uint8_t * data) noexcept
	{
		for (int i = 0 ; i < 4 ; i ++)
		{	// b=2*a, c=4*a, d=9*a
			uint8_t a [4], b [4], c [4], d [4], h;

			for (int j = 0 ; j < 4 ; j ++)
			{
				a [j] = data [4 * i + j];

				h = (uint8_t) ((signed char) a [j] >> 7);
				b [j] = (a [j] << 1) ^ (0x1b & h);

				h = (uint8_t) ((signed char) b [j] >> 7);
				c [j] = (b [j] << 1) ^ (0x1b & h);

				h = (uint8_t) ((signed char) c [j] >> 7);
				d [j] = (c [j] << 1) ^ (0x1b & h) ^ a [j];
			}
			
			data [4 * i + 0] = (d [0] ^ c [0] ^ b[0] ^ a [0]) ^ (d [1] ^ b [1]) ^ (d [2] ^ c [2]) ^ d [3];
			data [4 * i + 1] = d [0] ^ (d [1] ^ c [1] ^ b [1] ^ a [1]) ^ (d [2] ^ b [2]) ^ (d [3] ^ c [3]);
			data [4 * i + 2] = (d [0] ^ c [0]) ^ d [1] ^ (d [2] ^ c [2] ^ b [2] ^ a [2]) ^ (d [3] ^ b [3]);
			data [4 * i + 3] = (d [0] ^ b [0]) ^ (d [1] ^ c [1]) ^ d [2] ^ (d [3] ^ c [3] ^ b [3] ^ a [3]);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %eax, %eax
movq %rdi, %rcx
cmpq $0x4, %rax
je 0x2492
leaq (,%rax,4), %rdx
xorl %esi, %esi
cmpq $0x4, %rsi
je 0x23d1
movb (%rcx,%rsi), %r8b
movb %r8b, -0x4(%rsp,%rsi)
leal (%r8,%r8), %r9d
movl %r8d, %r10d
sarb $0x7, %r10b
andb $0x1b, %r10b
xorb %r9b, %r10b
movb %r10b, -0x8(%rsp,%rsi)
addb %r10b, %r10b
sarb $0x7, %r9b
andb $0x1b, %r9b
xorb %r10b, %r9b
movb %r9b, -0xc(%rsp,%rsi)
addb %r9b, %r9b
sarb $0x7, %r10b
andb $0x1b, %r10b
xorb %r9b, %r10b
xorb %r8b, %r10b
movb %r10b, -0x10(%rsp,%rsi)
incq %rsi
jmp 0x237d
movb -0x10(%rsp), %sil
movb -0xf(%rsp), %r11b
movb -0xc(%rsp), %bl
xorb %sil, %bl
movb -0x8(%rsp), %r10b
movb -0x7(%rsp), %r15b
movb -0xe(%rsp), %r8b
movb -0xa(%rsp), %bpl
xorb %r8b, %bpl
movb -0xd(%rsp), %r9b
movb -0x4(%rsp), %r14b
xorb %bl, %r14b
movl %r11d, %r12d
xorb %r10b, %r12b
xorb %r15b, %r12b
xorb %r14b, %r12b
movl %ebp, %r14d
xorb %r9b, %r14b
xorb %r12b, %r14b
movb %r14b, (%rdi,%rax,4)
movb -0xb(%rsp), %r14b
xorb %r11b, %r14b
xorb %r9b, %r11b
xorb -0x9(%rsp), %r9b
movb -0x6(%rsp), %r12b
movb -0x3(%rsp), %r13b
xorb %sil, %r13b
xorb %r8b, %r15b
xorb %r13b, %r15b
movl %r14d, %r13d
xorb %r12b, %r13b
xorb %r15b, %r13b
xorb %r9b, %r13b
movb %r13b, 0x1(%rdi,%rdx)
xorb -0x2(%rsp), %bl
movb -0x5(%rsp), %r15b
xorb %bpl, %r11b
xorb %bl, %r11b
xorb %r15b, %r12b
xorb %r11b, %r12b
movb %r12b, 0x2(%rdi,%rdx)
xorb -0x1(%rsp), %sil
xorb %r10b, %r8b
xorb %sil, %r8b
xorb %r14b, %r9b
xorb %r8b, %r9b
xorb %r15b, %r9b
movb %r9b, 0x3(%rdi,%rdx)
incq %rax
addq $0x4, %rcx
jmp 0x2369
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: aes::soft::inv_mc_gmul(unsigned char*)
void inv_mc_gmul (uint8_t * data) noexcept
	{
		for (int i = 0 ; i < 4 ; i ++)
		{
			uint8_t a [4];

			memcpy (a, data + i * 4, 4);
			
			data [i * 4 + 0] = gmul (14, a [0]) ^ gmul (11, a [1]) ^ gmul (13, a [2]) ^ gmul (9, a [3]);
			data [i * 4 + 1] = gmul (9, a [0]) ^ gmul (14, a [1]) ^ gmul (11, a [2]) ^ gmul (13, a [3]);
			data [i * 4 + 2] = gmul (13, a [0]) ^ gmul (9, a [1]) ^ gmul (14, a [2]) ^ gmul (11, a [3]);
			data [i * 4 + 3] = gmul (11, a [0]) ^ gmul (13, a [1]) ^ gmul (9, a [2]) ^ gmul (14, a [3]);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x2616
movq 0x18(%rsp), %rax
movzbl (%rax,%rbx,4), %esi
movl %esi, 0x14(%rsp)
movzbl 0x1(%rax,%rbx,4), %r14d
movzbl 0x2(%rax,%rbx,4), %r15d
movl %r15d, 0x10(%rsp)
movzbl 0x3(%rax,%rbx,4), %ebp
movl %ebp, 0xc(%rsp)
pushq $0xe
popq %rdi
callq 0x22ac
movl %eax, %r12d
pushq $0xb
popq %rdi
movl %r14d, %esi
movl %r14d, 0x24(%rsp)
callq 0x22ac
movl %eax, %r13d
xorb %r12b, %r13b
pushq $0xd
popq %rdi
movl %r15d, %esi
callq 0x22ac
movl %eax, %r12d
pushq $0x9
popq %rdi
movl %ebp, %esi
callq 0x22ac
xorb %r12b, %al
xorb %r13b, %al
movq 0x18(%rsp), %r15
movb %al, (%r15,%rbx,4)
pushq $0x9
popq %rdi
movl 0x14(%rsp), %esi
callq 0x22ac
movl %eax, %r12d
pushq $0xe
popq %rdi
movl %r14d, %esi
callq 0x22ac
movl %eax, %r13d
xorb %r12b, %r13b
pushq $0xb
popq %rdi
movl 0x10(%rsp), %r14d
movl %r14d, %esi
callq 0x22ac
movl %eax, %r12d
pushq $0xd
popq %rbp
movl %ebp, %edi
movl 0xc(%rsp), %esi
callq 0x22ac
xorb %r12b, %al
xorb %r13b, %al
movb %al, 0x1(%r15,%rbx,4)
movl %ebp, %edi
movl 0x14(%rsp), %r15d
movl %r15d, %esi
callq 0x22ac
movl %eax, %r12d
pushq $0x9
popq %rdi
movl 0x24(%rsp), %ebp
movl %ebp, %esi
callq 0x22ac
movl %eax, %r13d
xorb %r12b, %r13b
pushq $0xe
popq %rdi
movl %r14d, %esi
callq 0x22ac
movl %eax, %r12d
pushq $0xb
popq %r14
movl %r14d, %edi
movl 0xc(%rsp), %esi
callq 0x22ac
xorb %r12b, %al
xorb %r13b, %al
movq 0x18(%rsp), %r12
movb %al, 0x2(%r12,%rbx,4)
movl %r14d, %edi
movl %r15d, %esi
callq 0x22ac
movl %eax, %r15d
pushq $0xd
popq %rdi
movl %ebp, %esi
callq 0x22ac
movl %eax, %r14d
xorb %r15b, %r14b
pushq $0x9
popq %rdi
movl 0x10(%rsp), %esi
callq 0x22ac
movl %eax, %ebp
pushq $0xe
popq %rdi
movl 0xc(%rsp), %esi
callq 0x22ac
xorb %bpl, %al
xorb %r14b, %al
movb %al, 0x3(%r12,%rbx,4)
incq %rbx
jmp 0x24b2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: mixed_precalc(unsigned char*, unsigned char const*)
void mixed_precalc (uint8_t * data, const uint8_t obj [176])
{
	aes::soft::ar (data, obj, 0);

	for (int i = 1 ; i < 10; i ++)
	{
		aes::soft::inv_sb (data);
		aes::soft::inv_sr (data);
		aes::soft::inv_mc_pre (data);
		aes::soft::ar (data, obj, i);
	}
	
	aes::soft::inv_sb (data);
	aes::soft::inv_sr (data);
	aes::soft::ar (data, obj, 10);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x2625
pushq $0x1
popq %rbp
movq %r14, %rdi
callq 0x22d6
movq %r14, %rdi
callq 0x22f5
cmpl $0xa, %ebp
je 0x2684
movq %r14, %rdi
callq 0x235a
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2625
incl %ebp
jmp 0x2656
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2625
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: mixed_gmul(unsigned char*, unsigned char const*)
void mixed_gmul (uint8_t * data, const uint8_t obj [176])
{
	aes::soft::ar (data, obj, 0);

	for (int i = 1 ; i < 10; i ++)
	{
		aes::soft::inv_sb (data);
		aes::soft::inv_sr (data);
		aes::soft::inv_mc_gmul (data);
		aes::soft::ar (data, obj, i);
	}
	
	aes::soft::inv_sb (data);
	aes::soft::inv_sr (data);
	aes::soft::ar (data, obj, 10);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x2625
pushq $0x1
popq %rbp
movq %r14, %rdi
callq 0x22d6
movq %r14, %rdi
callq 0x22f5
cmpl $0xa, %ebp
je 0x26d8
movq %r14, %rdi
callq 0x249d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2625
incl %ebp
jmp 0x26aa
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2625
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: decrypt_full_aesni(unsigned char const*, unsigned char (&) [131072], unsigned char const*)
auto decrypt_full_aesni (const uint8_t obj [AES_128_KEY_OBJ_SIZE], uint8_t (& output) [VECTOR_SIZE], const uint8_t input [VECTOR_SIZE])
{
	memcpy (output, input, VECTOR_SIZE);
	
	auto start = std::chrono::high_resolution_clock::now ();
	
	for (size_t i = 0 ; i < BLOCK_COUNT ; i ++)
		full_aesni (output + BLOCK_SIZE * i, obj);
	
	auto end = std::chrono::high_resolution_clock::now ();
	
	return std::chrono::duration_cast <std::chrono::nanoseconds> (end - start).count ();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20000, %edx          # imm = 0x20000
movq %rsi, %rdi
movq %rax, %rsi
callq 0x20b0
xorl %r12d, %r12d
callq 0x2030
movq %rax, %r15
cmpq $0x20000, %r12          # imm = 0x20000
je 0x2731
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x30b9
addq $0x10, %r12
jmp 0x2716
callq 0x2030
subq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: decrypt_mixed_precalc(unsigned char const*, unsigned char (&) [131072], unsigned char const*)
auto decrypt_mixed_precalc (const uint8_t obj [AES_128_KEY_OBJ_SIZE], uint8_t (& output) [VECTOR_SIZE], const uint8_t input [VECTOR_SIZE])
{
	memcpy (output, input, VECTOR_SIZE);
	
	auto start = std::chrono::high_resolution_clock::now ();
	
	for (size_t i = 0 ; i < BLOCK_COUNT ; i ++)
		mixed_precalc (output + BLOCK_SIZE * i, obj);
	
	auto end = std::chrono::high_resolution_clock::now ();
	
	return std::chrono::duration_cast <std::chrono::nanoseconds> (end - start).count ();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20000, %edx          # imm = 0x20000
movq %rsi, %rdi
movq %rax, %rsi
callq 0x20b0
xorl %r12d, %r12d
callq 0x2030
movq %rax, %r15
cmpq $0x20000, %r12          # imm = 0x20000
je 0x278c
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x2642
addq $0x10, %r12
jmp 0x2771
callq 0x2030
subq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: decrypt_mixed_gmul(unsigned char const*, unsigned char (&) [131072], unsigned char const*)
auto decrypt_mixed_gmul (const uint8_t obj [AES_128_KEY_OBJ_SIZE], uint8_t (& output) [VECTOR_SIZE], const uint8_t input [VECTOR_SIZE])
{
	memcpy (output, input, VECTOR_SIZE);
	
	auto start = std::chrono::high_resolution_clock::now ();
	
	for (size_t i = 0 ; i < BLOCK_COUNT ; i ++)
		mixed_gmul (output + BLOCK_SIZE * i, obj);
	
	auto end = std::chrono::high_resolution_clock::now ();
	
	return std::chrono::duration_cast <std::chrono::nanoseconds> (end - start).count ();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20000, %edx          # imm = 0x20000
movq %rsi, %rdi
movq %rax, %rsi
callq 0x20b0
xorl %r12d, %r12d
callq 0x2030
movq %rax, %r15
cmpq $0x20000, %r12          # imm = 0x20000
je 0x27e7
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x2696
addq $0x10, %r12
jmp 0x27cc
callq 0x2030
subq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/zencoders[P]algoritmica/tests/littletest.hpp
// Function: littletest::test_runner::operator()()
int operator()()
        {
            std::cout << "** Runner terminated! **" << std::endl;
            std::cout << (test_counter - 1) << " tests executed" << std::endl;
            std::cout << (failures_counter + success_counter) << " checks" << std::endl;
            std::cout << "-> " << success_counter << " successes" << std::endl;
            std::cout << "-> " << failures_counter << " failures" << std::endl;
            std::cout << "Total run time: " << total_time << std::endl;
            std::cout << "Total time spent in tests: " << good_time_total << " ms" << std::endl;
            std::cout << "Average set up time: " << (total_set_up_time / test_counter) << " ms" << std::endl;
            std::cout << "Average tear down time: " << (total_tear_down_time / test_counter) << " ms" << std::endl;
            int to_ret = failures_counter;
            clear_runner();
            return to_ret;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7957(%rip), %r14      # 0x9fd8
leaq 0x3b41(%rip), %rsi      # 0x61c9
movq %r14, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl 0x24(%rbx), %esi
decl %esi
movq %r14, %rdi
callq 0x21f0
leaq 0x3b36(%rip), %rsi      # 0x61e2
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl 0x28(%rbx), %esi
addl 0x2c(%rbx), %esi
movq %r14, %rdi
callq 0x21f0
leaq 0x3b21(%rip), %rsi      # 0x61f2
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
leaq 0x3b12(%rip), %r15      # 0x61fa
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x21f0
leaq 0x3af9(%rip), %rsi      # 0x61fe
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
movl 0x2c(%rbx), %esi
movq %rax, %rdi
callq 0x21f0
leaq 0x3ad7(%rip), %rsi      # 0x6209
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
leaq 0x3aca(%rip), %rsi      # 0x6213
movq %r14, %rdi
callq 0x2140
movsd 0x48(%rbx), %xmm0
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x2090
leaq 0x3ab7(%rip), %rsi      # 0x6224
movq %r14, %rdi
callq 0x2140
movsd 0x30(%rbx), %xmm0
movq %rax, %rdi
callq 0x21a0
leaq 0x3ab7(%rip), %r15      # 0x6240
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2090
leaq 0x3aa1(%rip), %rsi      # 0x6244
movq %r14, %rdi
callq 0x2140
movsd 0x38(%rbx), %xmm0
cvtsi2sdl 0x24(%rbx), %xmm1
divsd %xmm1, %xmm0
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2090
leaq 0x3a7f(%rip), %rsi      # 0x625a
movq %r14, %rdi
callq 0x2140
movsd 0x40(%rbx), %xmm0
cvtsi2sdl 0x24(%rbx), %xmm1
divsd %xmm1, %xmm0
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl 0x2c(%rbx), %ebp
movq %rbx, %rdi
callq 0x54ee
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zencoders[P]algoritmica/./algorithms/sorting/insertsort.hpp
// Function: void algoritmica::algorithms::sorting::insertsort<int>(int*, int)
void insertsort(T1 s[], int size)
{
    for(int i = 1; i < size; i++)
    {
        int j = i;
        while((j > 0) && (s[j] < s[j-1]))
        {
            details::swap(&s[j], &s[j-1]);
            j--;
        }
    }
}

// Assembly:
pushq $0x1
popq %rax
movl %eax, %ecx
cmpl %esi, %eax
jge 0x2d97
testl %ecx, %ecx
jle 0x2d93
movl %ecx, %edx
movl -0x4(%rdi,%rdx,4), %r9d
movl (%rdi,%rdx,4), %r8d
cmpl %r9d, %r8d
jge 0x2d93
movl %r9d, (%rdi,%rdx,4)
movl %r8d, -0x4(%rdi,%rdx,4)
decl %ecx
jmp 0x2d72
incl %eax
jmp 0x2d6c
retq
// File: /workspace/github_cpp_makefile_star2_O2/zencoders[P]algoritmica/./algorithms/sorting/quicksort.hpp
// Function: void algoritmica::algorithms::sorting::quicksort<int>(int*, int, int)
void quicksort(T1 s[], int l, int h)
{
    int p;
    if(h > l)
    {
        p = details::partition(s, l, h);
        quicksort(s, l, p - 1);
        quicksort(s, p + 1, h);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl %ebx, %ebp
jge 0x3c5e
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3c69
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x3c27
incl %r15d
movl %r15d, %ebp
jmp 0x3c35
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zencoders[P]algoritmica/./algorithms/sorting/quicksort.hpp
// Function: int algoritmica::algorithms::sorting::details::partition<int>(int*, int, int)
int partition(T1 s[], int l, int h)
    {
        int pivot = h;
        int firsthigh = l;
        for(int i = l; i < pivot; ++i)
        {
            if(s[i] < s[pivot])
            {
                details::swap(&s[i], &s[firsthigh]);
                firsthigh++;
            }
        }
        details::swap(&s[firsthigh], &s[pivot]);
        return firsthigh;
    }

// Assembly:
movslq %edx, %rcx
movslq %esi, %rdx
movslq %esi, %rax
cmpq %rcx, %rdx
jge 0x3c94
movl (%rdi,%rdx,4), %r8d
cmpl (%rdi,%rcx,4), %r8d
jge 0x3c8f
movl (%rdi,%rax,4), %esi
movl %esi, (%rdi,%rdx,4)
movl %r8d, (%rdi,%rax,4)
incl %eax
movl %eax, %esi
incq %rdx
jmp 0x3c6f
movl (%rdi,%rax,4), %edx
movl (%rdi,%rcx,4), %esi
movl %esi, (%rdi,%rax,4)
movl %edx, (%rdi,%rcx,4)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zencoders[P]algoritmica/./algorithms/sorting/selectionsort.hpp
// Function: void algoritmica::algorithms::sorting::selectionsort<int>(int*, int)
void selectionsort(T1 s[], int size)
{
    for(int i = 0; i < size; i++)
    {
        int min = i;

        for(int j = i + 1; j < size; ++j)
        {
            if(s[j] < s[min])
                min = j;
        }
        details::swap(&s[i], &s[min]);
    }
}

// Assembly:
pushq %rbx
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movabsq $0x1, %rdx
cmpq %rax, %rcx
je 0x4a53
movq %rdx, %r8
movl %ecx, %r9d
movslq %r9d, %r10
cmpl %esi, %r8d
jge 0x4a3b
movl (%rdi,%r8,4), %ebx
movl %r8d, %r11d
cmpl (%rdi,%r10,4), %ebx
jl 0x4a33
movl %r9d, %r11d
incq %r8
movl %r11d, %r9d
jmp 0x4a1b
movl (%rdi,%rcx,4), %r8d
movl (%rdi,%r10,4), %r9d
movl %r9d, (%rdi,%rcx,4)
incq %rcx
movl %r8d, (%rdi,%r10,4)
incq %rdx
jmp 0x4a10
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zencoders[P]algoritmica/tests/littletest.hpp
// Function: littletest::test_runner& littletest::test_runner::run<littletest::test_base>(littletest::test_base*)
test_runner& run(test_impl* t)
        {
            std::cout << "Running test (" << 
                test_counter << "): " << 
                t->__lt_name__ << std::endl;

            t->run_test(this);

            test_counter++;
            return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4a8b(%rip), %rdi      # 0x9fd8
leaq 0xd1f(%rip), %rsi       # 0x6273
callq 0x2140
movl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x21f0
leaq 0xd17(%rip), %rsi       # 0x6282
movq %rax, %rdi
callq 0x2140
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
incl 0x24(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/Bishop.cpp
// Function: Bishop::getPossibleMoves[abi:cxx11](Board const&) const
std::list<Move> Bishop::getPossibleMoves(const Board &board) const {
  std::list<Move> moves;
  if (!isCaptured()) {
    bool leftTop = true;
    bool rightTop = true;
    bool leftBottom = true;
    bool rightBottom = true;
    int i = 1;

    while (leftTop || rightTop || leftBottom || rightBottom) {
      checkMove(board, moves, leftTop, i, -i);
      checkMove(board, moves, rightTop, i, i);
      checkMove(board, moves, leftBottom, -i, -i);
      checkMove(board, moves, rightBottom, -i, i);
      i++;
    }
  }
  return moves;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x37ae
testb %al, %al
je 0x2975
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
leaq -0x2c(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2b(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2a(%rbp), %rcx
movb %al, (%rcx)
leaq -0x29(%rbp), %rcx
movb %al, (%rcx)
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
testb $0x1, %al
jne 0x29ad
cmpb $0x0, -0x2b(%rbp)
jne 0x29ad
cmpb $0x0, -0x2a(%rbp)
jne 0x29ad
cmpb $0x1, -0x29(%rbp)
jne 0x2963
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2c(%rbp), %rcx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x2f6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2b(%rbp), %rcx
movl %r12d, %r8d
movl %r12d, %r9d
callq 0x2f6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2a(%rbp), %rcx
movl %r13d, %r8d
movl %r13d, %r9d
callq 0x2f6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x29(%rbp), %rcx
movl %r13d, %r8d
movl %r12d, %r9d
callq 0x2f6c
incl %r12d
movb -0x2c(%rbp), %al
decl %r13d
jmp 0x2997
jmp 0x2a1d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a40
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/Knight.cpp
// Function: Knight::getPossibleMoves[abi:cxx11](Board const&) const
std::list<Move> Knight::getPossibleMoves(const Board &board) const {
  std::list<Move> moves;
  if (!isCaptured()) {
    int x = this->getCurrentPosition().getX();
    int y = this->getCurrentPosition().getY();
    std::list<Position> positions = {
      Position(x + 2, y - 1), Position(x + 1, y - 2), Position(x + 2, y + 1),
      Position(x + 1, y + 2), Position(x - 2, y - 1), Position(x - 1, y - 2),
      Position(x - 2, y + 1),  Position(x - 1, y + 2)
    };

    for (Position p : positions) {
      if (p.isValid())
      { moves.push_back(Move(Position(x, y), p)); }
    }
  }
  return moves;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, -0x38(%rbp)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x37ae
testb %al, %al
jne 0x2c6b
movq %rbx, %rdi
callq 0x383a
leaq -0x90(%rbp), %rdi
movq %rax, (%rdi)
callq 0x28a6
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
callq 0x383a
leaq -0x90(%rbp), %rdi
movq %rax, (%rdi)
callq 0x28ae
movl %eax, %r15d
movq -0x30(%rbp), %rax
leal 0x2(%rax), %r13d
leal -0x1(%r15), %r14d
leaq -0x90(%rbp), %rdi
movl %r13d, %esi
movl %r14d, %edx
callq 0x286e
leaq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rax
leal 0x1(%rax), %ebx
leal -0x2(%r15), %edx
movl %ebx, %esi
movl %edx, -0x44(%rbp)
callq 0x286e
leaq -0x80(%rbp), %rdi
leal 0x1(%r15), %r12d
movl %r13d, %esi
movl %r12d, %edx
callq 0x286e
leaq -0x78(%rbp), %rdi
leal 0x2(%r15), %r13d
movl %ebx, %esi
movl %r13d, %edx
callq 0x286e
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rax
leal -0x2(%rax), %ebx
movl %ebx, %esi
movl %r14d, %edx
callq 0x286e
leaq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rax
leal -0x1(%rax), %r14d
movl %r14d, %esi
movl -0x44(%rbp), %edx
callq 0x286e
leaq -0x60(%rbp), %rdi
movl %ebx, %esi
movl %r12d, %edx
callq 0x286e
leaq -0x58(%rbp), %rdi
movl %r14d, %esi
movl %r13d, %edx
callq 0x286e
leaq -0xa8(%rbp), %rbx
leaq -0x90(%rbp), %rsi
pushq $0x8
popq %rdx
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
callq 0x2cc2
leaq -0x40(%rbp), %r13
leaq -0x90(%rbp), %r14
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x2c5f
movq 0x10(%r12), %rax
movq %rax, -0x40(%rbp)
movq %r13, %rdi
callq 0x28b8
testb %al, %al
je 0x2c0b
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %r15d, %edx
callq 0x286e
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x3ffc
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2cfa
movq %r14, %rdi
callq 0x4072
jmp 0x2c0b
leaq -0xa8(%rbp), %rdi
callq 0x2d14
movq -0x38(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c89
jmp 0x2c89
jmp 0x2c89
jmp 0x2c89
movq %rax, %rbx
jmp 0x2cb0
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x4072
jmp 0x2ca4
jmp 0x2ca1
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2d14
movq -0x38(%rbp), %rdi
callq 0x2a40
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/StraightLineMover.cpp
// Function: StraightLineMover::checkMove(Board const&, std::__cxx11::list<Move, std::allocator<Move>>&, bool&, int, int) const
void StraightLineMover::checkMove(const Board &board, std::list<Move> &moves,
                                  bool &direction, int dx, int dy) const {
  int x = this->getCurrentPosition().getX();
  int y = this->getCurrentPosition().getY();

  if (!direction) { return; }
  Position p = Position(x + dx, y + dy);
  if (!p.isValid()) {
    direction = false;
    return;
  }
  if (board.getChessman(p) != nullptr) {
    direction = false;
    if (board.getChessman(p)->getColour() != this->colour) {
      moves.push_back(Move(Position(x, y), p));
    }
  } else {
    moves.push_back(Move(Position(x, y), p));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, -0x3c(%rbp)
movl %r8d, %r15d
movq %rcx, %r14
movq %rdx, -0x48(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdi, %r13
callq 0x383a
leaq -0x80(%rbp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x28a6
movl %eax, %r12d
movq %r13, -0x58(%rbp)
movq %r13, %rdi
callq 0x383a
movq %rax, (%rbx)
leaq -0x80(%rbp), %rdi
callq 0x28ae
movq %r14, -0x50(%rbp)
cmpb $0x1, (%r14)
jne 0x30ae
movl %eax, %r13d
movl %r12d, -0x2c(%rbp)
addl %r12d, %r15d
movl -0x3c(%rbp), %edx
addl %eax, %edx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x286e
movq %rbx, %rdi
callq 0x28b8
testb %al, %al
je 0x3068
movq -0x38(%rbp), %rsi
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x4a86
testq %rax, %rax
je 0x3071
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4a86
movq %rax, %rdi
callq 0x379a
movq -0x58(%rbp), %rcx
cmpb %al, 0x8(%rcx)
movl -0x2c(%rbp), %esi
je 0x30ae
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
movl %r13d, %edx
callq 0x286e
movq -0x38(%rbp), %rdx
movq (%rbx), %rsi
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x3ffc
movq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x2cfa
jmp 0x30a5
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
jmp 0x30ae
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
movl %r13d, %edx
callq 0x286e
movq -0x38(%rbp), %rdx
movq (%rbx), %rsi
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x3ffc
movq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x2cfa
leaq -0x80(%rbp), %rdi
callq 0x4072
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30bf
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x4072
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/Rook.cpp
// Function: Rook::getPossibleMoves[abi:cxx11](Board const&) const
std::list<Move> Rook::getPossibleMoves(const Board &board) const {
  std::list<Move> moves;
  if (!isCaptured()) {
    bool top = true;
    bool right = true;
    bool bottom = true;
    bool left = true;
    int i = 1;

    while (top || right || bottom || left) {
      checkMove(board, moves, top, i, 0);
      checkMove(board, moves, right, 0, i);
      checkMove(board, moves, bottom, -i, 0);
      checkMove(board, moves, left, 0, -i);
      i++;
    }
  }
  return moves;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x37ae
testb %al, %al
je 0x36b5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
leaq -0x2c(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2b(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2a(%rbp), %rcx
movb %al, (%rcx)
leaq -0x29(%rbp), %rcx
movb %al, (%rcx)
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
testb $0x1, %al
jne 0x36ed
cmpb $0x0, -0x2b(%rbp)
jne 0x36ed
cmpb $0x0, -0x2a(%rbp)
jne 0x36ed
cmpb $0x1, -0x29(%rbp)
jne 0x36a3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2c(%rbp), %rcx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x2f6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2b(%rbp), %rcx
xorl %r8d, %r8d
movl %r12d, %r9d
callq 0x2f6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2a(%rbp), %rcx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x2f6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x29(%rbp), %rcx
xorl %r8d, %r8d
movl %r13d, %r9d
callq 0x2f6c
incl %r12d
movb -0x2c(%rbp), %al
decl %r13d
jmp 0x36d7
jmp 0x375d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a40
movq %r14, %rdi
callq 0x21d0