LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %ecx, %r15d
movb 0x9(%rdi), %al
leaq 0x1f8f5(%rip), %rcx     # 0x32ec9
cmpb (%rcx), %al
jge 0x136b8
movq %rsi, %r14
movq %rdi, %rbx
movswq 0x2(%rsi), %rax
cmpq $-0x1, %rax
je 0x13607
movq 0x10(%rbx), %rcx
shlq $0x4, %rax
movb (%rcx,%rax), %al
leaq 0x1f8c2(%rip), %rcx     # 0x32ec1
cmpb (%rcx), %al
sete %bpl
jmp 0x13609
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x136ab
testb %dl, %dl
je 0x13627
movl 0x8(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x136d8
movb %al, 0x9(%rbx)
movzwl (%r14), %eax
movw %ax, 0x6(%rbx)
incw 0x4(%rbx)
movswq 0x2(%r14), %rax
movq 0x10(%rbx), %rcx
shlq $0x4, %rax
movb 0x8(%rbx), %dl
movb %dl, (%rcx,%rax)
movb %r15b, 0x1(%rcx,%rax)
movsbq 0x8(%rbx), %rax
movswq 0x2(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rcx,%rax), %rdx
leaq 0x1f98c(%rip), %rsi     # 0x32ff0
movq (%rsi,%rdx,8), %rdx
xorq %rdx, 0x28(%rbx)
shlq $0x5, %rcx
addq 0x30(%rbx), %rcx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
movzwl 0x2(%rcx,%rsi), %edi
cmpq $0xffff, %rdi           # imm = 0xFFFF
je 0x13695
movswq %di, %rdi
shlq $0x4, %rdi
orq %rax, 0x8(%rdx,%rdi)
shlq $0x2, %rax
addq $0x4, %rsi
cmpq $0x60, %rsi
jne 0x1367a
movb $0x3, %al
subb 0x8(%rbx), %al
movb %al, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c376(%rip), %rdi     # 0x2fa35
leaq 0x1b192(%rip), %rsi     # 0x2e858
leaq 0x1c37b(%rip), %rcx     # 0x2fa48
movl $0xbb, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movswl 0x2(%rsi), %esi
callq 0x13812
cmpl $0x3, %eax
jne 0x137e3
movzwl 0x2(%r14), %ecx
movq 0x10(%rbx), %rdx
movq %rbx, (%rsp)
movq 0x30(%rbx), %rsi
xorl %r8d, %r8d
movzbl %bpl, %edi
xorl %r9d, %r9d
leaq (%rsi,%r8,4), %r11
movl $0x1, %r10d
movl %ecx, %r14d
movswq %r14w, %r14
leaq (%r14,%r14,2), %r14
shlq $0x5, %r14
movl (%r11,%r14), %r14d
shrl $0x10, %r14d
cmpl $0xffff, %r14d          # imm = 0xFFFF
je 0x1375f
movswq %r14w, %r15
shlq $0x4, %r15
cmpb %bpl, (%rdx,%r15)
jne 0x1375f
incl %r10d
cmpl $0x5, %r10d
jne 0x13725
movl $0x5, %r10d
leaq 0x10(%rsi,%r8,4), %r14
leal 0x4(%r10), %r15d
xorl %r12d, %r12d
movl %r10d, %r11d
movl %ecx, %r13d
movswq %r13w, %r13
leaq (%r13,%r13,2), %r13
shlq $0x5, %r13
movl (%r14,%r13), %r13d
shrl $0x10, %r13d
cmpl $0xffff, %r13d          # imm = 0xFFFF
je 0x137ae
movswq %r13w, %rbx
shlq $0x4, %rbx
cmpb %bpl, (%rdx,%rbx)
jne 0x137b4
incl %r11d
incl %r12d
cmpl $0x4, %r12d
jne 0x13771
movl %r15d, %r11d
jmp 0x137b4
addl %r12d, %r10d
movl %r10d, %r11d
movzbl %al, %eax
cmpl $0x5, %r11d
cmovael %edi, %eax
jae 0x137d9
cmpq $0x3, %r8
leaq 0x1(%r8), %r10
setae %r9b
movq %r10, %r8
cmpq $0x4, %r10
jne 0x13718
testb $0x1, %r9b
movq (%rsp), %rbx
je 0x13803
movswl 0x4(%rbx), %eax
incl %eax
movswl 0x2(%rbx), %ecx
cmpl %ecx, %eax
jne 0x137fa
leaq 0x1f6d1(%rip), %rax     # 0x32ec9
jmp 0x13801
leaq 0x1f6c5(%rip), %rax     # 0x32ec6
movb (%rax), %al
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/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 %rcx, %rbx
movq 0x40(%rdi), %rax
movl 0xac(%rax), %ecx
testl %ecx, %ecx
je 0x170d1
movsbl 0x25(%rdx), %edi
movsbl 0x25(%rbx), %r8d
subl %r8d, %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl $0xff, %edi
andl %edi, %r8d
movsbl 0x24(%rdx), %r9d
movsbl 0x24(%rbx), %edx
subl %edx, %r9d
movl %r9d, %edx
negl %edx
cmovsl %r9d, %edx
andl %edi, %edx
cmpl %edx, %r8d
cmoval %r8d, %edx
cmpl $0x3, %edx
ja 0x170d1
movl $0x4, %edi
subl %edx, %edi
imull %ecx, %edi
addw %di, 0x20(%rbx)
movl 0xb0(%rax), %ebp
testl %ebp, %ebp
je 0x170ff
movsbl 0x24(%rbx), %eax
movsbl (%rsi), %ecx
imull %eax, %ecx
movsbl 0x25(%rbx), %eax
addl %ecx, %eax
movl 0x8(%rsi), %edx
movq %rsi, %rdi
movl %eax, %esi
callq 0x13812
imull %ebp, %eax
addw %ax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rdi), %rax
cmpl $0x0, 0xb8(%rax)
je 0x17134
leaq 0x4c(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17526
cmpb $-0x4, %al
jne 0x1714e
addq $0xa14, %r15            # imm = 0xA14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x175a4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/gomoku/agentpns.cpp
// Function: Morat::Gomoku::AgentPNS::return_move(Morat::Gomoku::AgentPNS::Node const*, Morat::Side, int) const
bool AgentPNS::AgentThread::updatePDnum(Node * node){
	Node * i = node->children.begin();
	Node * end = node->children.end();

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rsi), %r8
leaq 0x10(%r8), %rdi
xorl %esi, %esi
movl $0x0, %eax
cmpq $0x2, %r8
cmovaeq %rdi, %rax
jb 0x1a238
movzwl 0x6(%r8), %esi
shll $0x5, %esi
addq %rsi, %rdi
movq %rdi, %rsi
cmpq %rsi, %rax
je 0x1a2f4
leaq 0x18c81(%rip), %rdi     # 0x32ec9
movb (%rdi), %dil
movb $0x3, %r8b
subb %dl, %r8b
leaq 0x18c6e(%rip), %r9      # 0x32ec6
movb (%r9), %r9b
vmovsd 0x14fa5(%rip), %xmm0    # 0x2f208
xorl %ebx, %ebx
vmovsd 0x14fb3(%rip), %xmm1    # 0x2f220
vmovsd 0x14fa3(%rip), %xmm2    # 0x2f218
vmovsd 0x14f93(%rip), %xmm3    # 0x2f210
cmpl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
movl %edx, %r10d
je 0x1a2a7
movl 0x4(%rax), %r11d
movl %r8d, %r10d
cmpl $0x3fffffff, %r11d      # imm = 0x3FFFFFFF
je 0x1a2a7
movl %edi, %r10d
cmpl $0x3ffffffe, %r11d      # imm = 0x3FFFFFFE
je 0x1a2a7
movl %r9d, %r10d
cmpb %dil, %r10b
jge 0x1a2b5
vcvtusi2sdq 0x8(%rax), %xmm5, %xmm4
jmp 0x1a2dd
cmpb %dl, %r10b
jne 0x1a2c7
vcvtusi2sdq 0x8(%rax), %xmm5, %xmm4
vsubsd %xmm4, %xmm1, %xmm4
jmp 0x1a2dd
vcvtusi2sdq 0x8(%rax), %xmm5, %xmm4
cmpb %dil, %r10b
jne 0x1a2d9
vaddsd %xmm2, %xmm4, %xmm4
jmp 0x1a2dd
vaddsd %xmm3, %xmm4, %xmm4
vucomisd %xmm0, %xmm4
cmovaq %rax, %rbx
vmaxsd %xmm0, %xmm4, %xmm0
addq $0x20, %rax
cmpq %rsi, %rax
jne 0x1a27d
jmp 0x1a2f6
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x1a33e
testl %ecx, %ecx
jne 0x1a30b
movzwl 0x12(%rbx), %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17ebc
leaq 0x145b3(%rip), %rsi     # 0x2e8d5
movq %r14, %rdi
callq 0x56e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x59e1
jmp 0x1a2ff
leaq 0x1532c(%rip), %rdi     # 0x2f671
leaq 0x16760(%rip), %rsi     # 0x30aac
leaq 0x16823(%rip), %rcx     # 0x30b76
movl $0x11d, %edx            # imm = 0x11D
callq 0x51d0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a373
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rsi), %ebp
movl %ebp, %eax
imull %eax, %eax
shll $0x3, %eax
leal (%rax,%rax,2), %r15d
leaq (,%r15,4), %rdi
callq 0x5030
testl %ebp, %ebp
je 0x1e4ed
leaq (%rax,%r15,4), %rcx
movq %rax, %rdx
movl $0xffff78fc, (%rdx)     # imm = 0xFFFF78FC
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x1e4de
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x1e66e
cmpb $0x0, (%r14)
jle 0x1e59b
movq (%rbx), %r8
xorl %eax, %eax
leaq 0x131ce(%rip), %rcx     # 0x316e0
cmpb $0x0, (%r14)
jle 0x1e58d
xorl %edx, %edx
movq %r8, %rsi
xorl %edi, %edi
movb 0x1(%rdi,%rcx), %r11b
addb %dl, %r11b
movb (%rdi,%rcx), %bpl
addb %al, %bpl
movzbl %r11b, %r8d
movl $0xffff0000, %r9d       # imm = 0xFFFF0000
movl %r11d, %r10d
orb %bpl, %r10b
movzbl %bpl, %r10d
js 0x1e560
movb (%r14), %r15b
cmpb %r15b, %r11b
jge 0x1e560
cmpb %r15b, %bpl
jge 0x1e560
movsbl (%r14), %r9d
imull %r10d, %r9d
addl %r8d, %r9d
shll $0x10, %r9d
shll $0x8, %r8d
orl %r10d, %r8d
orl %r9d, %r8d
movl %r8d, (%rsi,%rdi)
addq $0x4, %rdi
cmpq $0x60, %rdi
jne 0x1e51f
incl %edx
movsbl (%r14), %r9d
leaq (%rsi,%rdi), %r8
cmpl %r9d, %edx
jl 0x1e51a
addq %rdi, %rsi
movq %rsi, %r8
incl %eax
movsbl (%r14), %edx
cmpl %edx, %eax
jl 0x1e512
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11d56
leaq 0x24146(%rip), %rax     # 0x45b40
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x68(%rbx), %r14
movq %r14, %rdi
callq 0x22466
leaq 0x1428(%rbx), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x224f8
leaq 0x1149b(%rip), %rax     # 0x32ec1
movb (%rax), %al
movb %al, 0x152c(%rbx)
leaq 0x1538(%rbx), %r12
movw $0x78fc, 0x154a(%rbx)   # imm = 0x78FC
movq $0x0, 0x1550(%rbx)
movl $0x2, 0x1520(%rbx)
movb $0x1, 0x1524(%rbx)
movl $0x3e800000, 0x1528(%rbx) # imm = 0x3E800000
movl $0x1, 0x1530(%rbx)
movq %r15, %rdi
movl $0x1, %esi
callq 0x1bf30
movl $0x5, 0x60(%rbx)
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movq %rax, 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 0x21ac8
movq %rax, %r13
jmp 0x21ad0
movq %rax, %r13
movq %r12, %rdi
callq 0x1adaa
movq %r15, %rdi
callq 0x1c55e
movq %r14, %rdi
callq 0x1c5a0
movq %rbx, %rdi
callq 0x13354
movq %r13, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/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:
vpbroadcastq %rdi, %zmm0
leaq (,%rdi,4), %rcx
vpsrlvq 0xf295(%rip), %xmm0, %xmm1 # 0x318b0
movabsq $0xc00000000, %rax      # imm = 0xC00000000
andq %rcx, %rax
movq %rdi, %rdx
shlq $0x4, %rdx
movl %edi, %ecx
andl $0xc0c0, %ecx           # imm = 0xC0C0
rolw $0x8, %cx
movzwl %cx, %ecx
movq %rdi, %rsi
shrq $0xa, %rsi
shlq $0xa, %rdi
vpmovsxbq 0xf28e(%rip), %ymm2 # 0x318e0
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]
vmovq %rdx, %xmm3
vpunpcklqdq %xmm0, %xmm3, %xmm3 # xmm3 = xmm3[0],xmm0[0]
valignq $0x5, %zmm1, %zmm1, %zmm4 # zmm4 = zmm1[5,6,7,0,1,2,3,4]
vinserti32x4 $0x1, %xmm1, %zmm3, %zmm3
vpmovsxbq 0xf24d(%rip), %zmm5 # 0x318d0
vpermi2q %zmm3, %zmm2, %zmm5
movb $-0x80, %dl
kmovd %edx, %k1
vpbroadcastq %rdi, %zmm5 {%k1}
vmovq %rsi, %xmm2
vinserti32x4 $0x0, %xmm2, %zmm4, %zmm2
movb $0x8, %dl
kmovd %edx, %k1
vpsllq $0x2, %zmm0, %zmm2 {%k1}
vpmovsxbq 0xf220(%rip), %zmm0 # 0x318d8
vpermi2q %zmm2, %zmm3, %zmm0
vpandq 0xf2f8(%rip), %zmm5, %zmm2 # 0x319c0
vpternlogq $0xf8, 0xf32d(%rip), %zmm0, %zmm2 # 0x31a00
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
vmovq %rax, %xmm2
vpunpcklqdq %xmm2, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm2[0]
vpternlogq $0xf8, 0xf1b9(%rip), %xmm1, %xmm0 # 0x318c0
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_O1/bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: aes::soft::inv_sr(unsigned char*)
void inv_sr (uint8_t * data) noexcept
	{
		uint8_t temp [16];
		
		memcpy (temp, data, 16);
		
		data [ 0] = temp [ 0], data [ 1] = temp [13], data [ 2] = temp [10], data [ 3] = temp [ 7];
		data [ 4] = temp [ 4], data [ 5] = temp [ 1], data [ 6] = temp [14], data [ 7] = temp [11];
		data [ 8] = temp [ 8], data [ 9] = temp [ 5], data [10] = temp [ 2], data [11] = temp [15];
		data [12] = temp [12], data [13] = temp [ 9], data [14] = temp [ 6], data [15] = temp [ 3];
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movb 0x1(%rdi), %al
movb 0x2(%rdi), %cl
movb 0x3(%rdi), %dl
movb 0x5(%rdi), %sil
movb 0x6(%rdi), %r8b
movb 0x7(%rdi), %r9b
movb 0x9(%rdi), %r10b
movb 0xa(%rdi), %r11b
movb 0xb(%rdi), %bl
movb 0xd(%rdi), %bpl
movb 0xe(%rdi), %r14b
movb 0xf(%rdi), %r15b
movb %bpl, 0x1(%rdi)
movb %r11b, 0x2(%rdi)
movb %r9b, 0x3(%rdi)
movb %al, 0x5(%rdi)
movb %r14b, 0x6(%rdi)
movb %bl, 0x7(%rdi)
movb %sil, 0x9(%rdi)
movb %cl, 0xa(%rdi)
movb %r15b, 0xb(%rdi)
movb %r10b, 0xd(%rdi)
movb %r8b, 0xe(%rdi)
movb %dl, 0xf(%rdi)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
xorl %eax, %eax
movdqa 0x1c99(%rip), %xmm0     # 0x3010
movd (%rdi,%rax,4), %xmm2
movdqa %xmm2, %xmm3
paddb %xmm2, %xmm3
pxor %xmm1, %xmm1
pcmpgtb %xmm2, %xmm1
pand %xmm0, %xmm1
pxor %xmm3, %xmm1
movdqa %xmm1, %xmm4
paddb %xmm1, %xmm4
pxor %xmm5, %xmm5
pcmpgtb %xmm3, %xmm5
pand %xmm0, %xmm5
pxor %xmm4, %xmm5
movdqa %xmm5, -0x18(%rsp)
paddb %xmm5, %xmm5
pxor %xmm3, %xmm3
pcmpgtb %xmm4, %xmm3
pand %xmm0, %xmm3
pxor %xmm5, %xmm3
pxor %xmm2, %xmm3
movd %xmm3, %ecx
movb -0x18(%rsp), %sil
xorb %cl, %sil
movdqa %xmm1, -0x28(%rsp)
movl %ecx, %r10d
shrl $0x8, %r10d
movb -0x28(%rsp), %r9b
movb -0x27(%rsp), %bl
movl %ecx, %edx
shrl $0x10, %edx
movb -0x16(%rsp), %r11b
xorb %dl, %r11b
movl %ecx, %r8d
shrl $0x18, %r8d
movb (%rdi,%rax,4), %bpl
xorb %sil, %bpl
movl %r10d, %r14d
xorb %r9b, %r14b
xorb %bl, %r14b
xorb %bpl, %r14b
movl %r11d, %ebp
xorb %r8b, %bpl
xorb %r14b, %bpl
movb %bpl, (%rdi,%rax,4)
movb -0x17(%rsp), %bpl
xorb %r10b, %bpl
movb -0x26(%rsp), %r14b
xorb %r8b, %r10b
xorb -0x15(%rsp), %r8b
movb 0x1(%rdi,%rax,4), %r15b
xorb %cl, %r15b
xorb %dl, %bl
xorb %r15b, %bl
xorb %bpl, %bl
xorb %r14b, %r11b
xorb %r8b, %r14b
xorb %bl, %r14b
movb %r14b, 0x1(%rdi,%rax,4)
movb -0x25(%rsp), %bl
xorb 0x2(%rdi,%rax,4), %sil
xorb %r10b, %sil
xorb %r11b, %sil
xorb %bl, %sil
movb %sil, 0x2(%rdi,%rax,4)
movb 0x3(%rdi,%rax,4), %sil
xorb %cl, %sil
xorb %r9b, %dl
xorb %sil, %dl
xorb %bpl, %dl
xorb %bl, %r8b
xorb %dl, %r8b
movb %r8b, 0x3(%rdi,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x1377
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movb (%rbx,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x185c
leaq 0x10(%rbx), %r12
movl $0x1, %r13d
leaq 0x17e3(%rip), %r15      # 0x3060
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
movb (%rcx,%r15), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x187f
movq %r14, %rdi
callq 0x1302
movq %r14, %rdi
callq 0x1367
xorl %eax, %eax
movb (%r12,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x18a7
incq %r13
addq $0x10, %r12
cmpq $0xa, %r13
jne 0x187d
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
movb (%rcx,%r15), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x18c7
movq %r14, %rdi
callq 0x1302
xorl %eax, %eax
movb 0xa0(%rbx,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x18e7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movb (%rbx,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x1916
leaq 0x10(%rbx), %r12
movl $0x1, %r13d
leaq 0x1729(%rip), %r15      # 0x3060
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
movb (%rcx,%r15), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x1939
movq %r14, %rdi
callq 0x1302
movq %r14, %rdi
callq 0x149a
xorl %eax, %eax
movb (%r12,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x1961
incq %r13
addq $0x10, %r12
cmpq $0xa, %r13
jne 0x1937
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
movb (%rcx,%r15), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x1981
movq %r14, %rdi
callq 0x1302
xorl %eax, %eax
movb 0xa0(%rbx,%rax), %cl
xorb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x19a1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b0
xorl %r12d, %r12d
callq 0x1040
movq %rax, %r15
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x2499
addq $0x10, %r12
cmpq $0x20000, %r12          # imm = 0x20000
jne 0x19eb
callq 0x1040
subq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b0
xorl %r12d, %r12d
callq 0x1040
movq %rax, %r15
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x184b
addq $0x10, %r12
cmpq $0x20000, %r12          # imm = 0x20000
jne 0x1a44
callq 0x1040
subq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b0
xorl %r12d, %r12d
callq 0x1040
movq %rax, %r15
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x1905
addq $0x10, %r12
cmpq $0x20000, %r12          # imm = 0x20000
jne 0x1a9d
callq 0x1040
subq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %ebp, %ebx
jle 0x411e
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x4129
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x40e7
incl %r15d
movl %r15d, %ebp
jmp 0x40f5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl %edx, %esi
jge 0x4153
movslq %esi, %rax
movl (%rdi,%rax,4), %edx
cmpl (%rdi,%rcx,4), %edx
jge 0x414b
movslq %esi, %rsi
movl (%rdi,%rsi,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %edx, (%rdi,%rsi,4)
incl %esi
incq %rax
cmpq %rax, %rcx
jne 0x4133
movslq %esi, %rax
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_O1/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:
testl %esi, %esi
jle 0x5292
pushq %rbx
movl %esi, %eax
movl $0x1, %ecx
xorl %edx, %edx
leaq 0x1(%rdx), %rsi
movl %edx, %r9d
cmpq %rax, %rsi
jae 0x5273
movq %rcx, %r8
movl %edx, %r10d
movl (%rdi,%r8,4), %r11d
movslq %r10d, %rbx
movl %r8d, %r9d
cmpl (%rdi,%rbx,4), %r11d
jl 0x5268
movl %r10d, %r9d
incq %r8
movl %r9d, %r10d
cmpq %r8, %rax
jne 0x5255
movslq %r9d, %r8
movl (%rdi,%rdx,4), %r9d
movl (%rdi,%r8,4), %r10d
movl %r10d, (%rdi,%rdx,4)
movl %r9d, (%rdi,%r8,4)
incq %rcx
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x5243
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3ec3(%rip), %r15      # 0x9fd8
leaq 0x1157(%rip), %rsi      # 0x7273
movl $0xe, %edx
movq %r15, %rdi
callq 0x2180
movl 0x24(%rbx), %esi
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
leaq 0x1144(%rip), %rsi      # 0x7282
movl $0x3, %edx
movq %rax, %rdi
callq 0x2180
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x616c
movq %r12, %rdi
callq 0x2080
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x6186
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x2200
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
incl 0x24(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x37c6
testb %al, %al
je 0x2a34
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)
movl $0x1, %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmpb $0x0, -0x2c(%rbp)
jne 0x2a72
cmpb $0x0, -0x2b(%rbp)
jne 0x2a72
cmpb $0x0, -0x2a(%rbp)
jne 0x2a72
cmpb $0x1, -0x29(%rbp)
jne 0x2a22
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2c(%rbp), %rcx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2b(%rbp), %rcx
movl %r12d, %r8d
movl %r12d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2a(%rbp), %rcx
movl %r13d, %r8d
movl %r13d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x29(%rbp), %rcx
movl %r13d, %r8d
movl %r12d, %r9d
callq 0x2ed8
incl %r12d
decl %r13d
jmp 0x2a5a
jmp 0x2adc
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b00
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3852
leaq -0x80(%rbp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2956
movl %eax, %r12d
movq %r13, -0x58(%rbp)
movq %r13, %rdi
callq 0x3852
movq %rax, (%rbx)
leaq -0x80(%rbp), %rdi
callq 0x295e
movq %r14, -0x50(%rbp)
cmpb $0x1, (%r14)
jne 0x3033
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 0x291e
movq %rbx, %rdi
callq 0x2968
testb %al, %al
je 0x2fdb
movq -0x38(%rbp), %rsi
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x4c3c
testq %rax, %rax
je 0x2fe4
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4c3c
movq %rax, %rdi
callq 0x37b2
movq -0x58(%rbp), %rcx
cmpb %al, 0x8(%rcx)
movl -0x2c(%rbp), %esi
je 0x3033
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
movl %r13d, %edx
callq 0x291e
movq -0x38(%rbp), %rdx
movq (%rbx), %rsi
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x4058
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e78
jmp 0x301b
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3033
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movl -0x2c(%rbp), %esi
movl %r13d, %edx
callq 0x291e
movq -0x38(%rbp), %rdx
movq (%rbx), %rsi
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x4058
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e78
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
incq 0x10(%r14)
leaq -0x80(%rbp), %rdi
callq 0x40d8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3044
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x40d8
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x37c6
testb %al, %al
je 0x36cc
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)
movl $0x1, %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmpb $0x0, -0x2c(%rbp)
jne 0x370a
cmpb $0x0, -0x2b(%rbp)
jne 0x370a
cmpb $0x0, -0x2a(%rbp)
jne 0x370a
cmpb $0x1, -0x29(%rbp)
jne 0x36ba
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2c(%rbp), %rcx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2b(%rbp), %rcx
xorl %r8d, %r8d
movl %r12d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2a(%rbp), %rcx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x29(%rbp), %rcx
xorl %r8d, %r8d
movl %r13d, %r9d
callq 0x2ed8
incl %r12d
decl %r13d
jmp 0x36f2
jmp 0x3774
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b00
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/Chessman.cpp
// Function: Chessman::isMoveValid(Board const&, Move const&) const
bool Chessman::isMoveValid(const Board &board, const Move &move) const {
  std::list<Move> moves = this->getPossibleMoves(board);
  for (std::list<Move>::iterator it = moves.begin(); it != moves.end(); it++) {
    if (*it == move)
    { return true; }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
movq (%rdi), %rax
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq *0x18(%rax)
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x3818
leaq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x4138
testb %al, %al
je 0x3800
leaq -0x30(%rbp), %rdi
cmpq %rdi, %r15
setne %bl
callq 0x2b00
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2b00
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/Queen.cpp
// Function: Queen::getPossibleMoves[abi:cxx11](Board const&) const
std::list<Move> Queen::getPossibleMoves(const Board &board) const {
  std::list<Move> moves;
  if (!isCaptured()) {
    bool top = true;
    bool right = true;
    bool bottom = true;
    bool left = true;
    bool leftTop = true;
    bool rightTop = true;
    bool leftBottom = true;
    bool rightBottom = true;
    int i = 1;

    while (top || right || bottom || left || 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);
      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)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x37c6
testb %al, %al
je 0x3f00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
leaq -0x30(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2f(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2e(%rbp), %rcx
movb %al, (%rcx)
leaq -0x2d(%rbp), %rcx
movb %al, (%rcx)
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)
movl $0x1, %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmpb $0x0, -0x30(%rbp)
jne 0x3f6e
cmpb $0x0, -0x2f(%rbp)
jne 0x3f6e
cmpb $0x0, -0x2e(%rbp)
jne 0x3f6e
cmpb $0x0, -0x2d(%rbp)
jne 0x3f6e
cmpb $0x0, -0x2c(%rbp)
jne 0x3f6e
cmpb $0x0, -0x2b(%rbp)
jne 0x3f6e
cmpb $0x0, -0x2a(%rbp)
jne 0x3f6e
cmpb $0x1, -0x29(%rbp)
jne 0x3eee
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2c(%rbp), %rcx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2b(%rbp), %rcx
movl %r12d, %r8d
movl %r12d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2a(%rbp), %rcx
movl %r13d, %r8d
movl %r13d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x29(%rbp), %rcx
movl %r13d, %r8d
movl %r12d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x30(%rbp), %rcx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2f(%rbp), %rcx
xorl %r8d, %r8d
movl %r12d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2e(%rbp), %rcx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq -0x2d(%rbp), %rcx
xorl %r8d, %r8d
movl %r13d, %r9d
callq 0x2ed8
incl %r12d
decl %r13d
jmp 0x3f3e
jmp 0x403b
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b00
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/IncredibleHannes[P]QMUL-ChessGame/src/Model/Move.cpp
// Function: Move::Move(Move const&)
Move::Move(const Move &move)
  : origin(move.origin), target(move.target), type(move.type), capturedChessman(){
    if(move.getCapturedChessman() == nullptr) {
      this->capturedChessman = nullptr;
    } else {
      this->capturedChessman = move.getCapturedChessman()->clone();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x40c1
movq (%rdi), %rax
callq *(%rax)
jmp 0x40c3
xorl %eax, %eax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/IncredibleHannes[P]QMUL-ChessGame/src/Model/Board.cpp
// Function: Board::Board(std::__cxx11::list<Move*, std::allocator<Move*>>)
Board::Board(std::list<Move *> moves)
  : currentColour(Chessman::Colour::White) {
  this->board = createStartBoard();
  while (moves.size() != 0) {
    applyMove(moves.front());
    delete moves.front();
    moves.pop_front();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x8(%rdi)
leaq 0x10(%rdi), %r12
movq %r12, 0x18(%rdi)
movq %r12, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, 0x30(%rdi)
movq %r13, 0x28(%rdi)
movq %rax, 0x38(%rdi)
callq 0x420c
movq %rax, (%r14)
cmpq $0x0, 0x10(%rbx)
je 0x46ff
movq (%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x474e
movq (%rbx), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x46e6
movq %r15, %rdi
callq 0x40d8
movq %r15, %rdi
callq 0x2100
movq (%rbx), %r15
decq 0x10(%rbx)
movq %r15, %rdi
callq 0x21b0
movq %r15, %rdi
callq 0x2100
jmp 0x46b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4710
movq %rax, %rbx
movq (%r13), %rdi
cmpq %r13, %rdi
je 0x472c
movq (%rdi), %r14
callq 0x2100
movq %r14, %rdi
cmpq %r13, %r14
jne 0x471c
movq (%r12), %rdi
cmpq %r12, %rdi
je 0x4745
movq (%rdi), %r14
callq 0x2100
movq %r14, %rdi
cmpq %r12, %r14
jne 0x4735
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IncredibleHannes[P]QMUL-ChessGame/src/Model/Board.cpp
// Function: Board::Board(Board const&)
Board::Board(const Board &b) {
  this->board = new Chessman**[8];

  for (int x = 0; x < 8; x++) {
    this->board[x] = new Chessman*[8];
    for (int y = 0; y < 8; y++) {
      if (b.getChessman(Position(x,y)) != nullptr) {
        this->board[x][y] = b.getChessman(Position(x,y))->clone();
      }
    }
  }
  for(Chessman* c : b.capturedChessmen) {
    this->capturedChessmen.push_back(c->clone());
  }
  for(Move* m : b.previousMoves) {
    this->previousMoves.push_back(new Move(*m));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, -0x40(%rbp)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, 0x30(%rdi)
movq %r14, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movl $0x40, %edi
callq 0x2030
movq %rax, (%rbx)
xorl %r13d, %r13d
leaq -0x48(%rbp), %r12
movq %rbx, -0x38(%rbp)
movl $0x40, %edi
callq 0x2030
movq (%rbx), %rcx
movq %rax, (%rcx,%r13,8)
xorl %r15d, %r15d
leaq -0x58(%rbp), %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x291e
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movq %r12, %rdi
callq 0x2956
cltq
movq (%rbx,%rax,8), %rbx
movq %r12, %rdi
callq 0x295e
cltq
cmpq $0x0, (%rbx,%rax,8)
je 0x4b1f
leaq -0x50(%rbp), %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x291e
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movq %r12, %rdi
callq 0x2956
cltq
movq (%rbx,%rax,8), %rbx
movq %r12, %rdi
callq 0x295e
cltq
movq (%rbx,%rax,8), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq $0x8, %r15
jne 0x4a94
incq %r13
cmpq $0x8, %r13
movq -0x38(%rbp), %rbx
jne 0x4a80
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %r12
movq 0x10(%rax), %r13
cmpq %r12, %r13
je 0x4b7e
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r15
movl $0x18, %edi
callq 0x2120
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x2050
incq 0x20(%rbx)
movq (%r13), %r13
jmp 0x4b49
movq -0x30(%rbp), %rax
movq 0x28(%rax), %r13
addq $0x28, %rax
cmpq %rax, %r13
je 0x4bd8
movq %rax, %rbx
movq 0x10(%r13), %r15
movl $0x20, %edi
callq 0x2120
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x408c
movl $0x18, %edi
callq 0x2120
movq %r12, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movq -0x38(%rbp), %rax
incq 0x38(%rax)
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x4b92
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4bfc
movq %rax, %r15
movq %r12, %rdi
callq 0x2100
jmp 0x4bff
jmp 0x4bfc
jmp 0x4bfc
jmp 0x4bfc
movq %rax, %r15
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x4c17
movq (%rdi), %rbx
callq 0x2100
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x4c07
movq -0x40(%rbp), %r14
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x4c33
movq (%rdi), %rbx
callq 0x2100
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x4c23
movq %r15, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IncredibleHannes[P]QMUL-ChessGame/src/Model/Board.cpp
// Function: Board::~Board()
Board::~Board() {
  for (int x = 0; x < 8; x++) {
    for (int y = 0; y < 8; y++) {
      if (this->board[x][y] != nullptr) {
        delete this->board[x][y];
      }
    }
  }
  for (int i = 0; i < 8; i++) {
    delete[] this->board[i];
  }
  delete[] this->board;
  for(Chessman* c : this->capturedChessmen) {
    delete c;
  }
  for(Move* m : this->previousMoves) {
    delete m;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x4ca0
movq (%rdi), %rax
callq *0x10(%rax)
incq %r15
cmpq $0x8, %r15
jne 0x4c8a
incq %r14
cmpq $0x8, %r14
jne 0x4c87
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4cc6
callq 0x2170
incq %r14
cmpq $0x8, %r14
jne 0x4cb5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4cdc
callq 0x2170
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %r14
cmpq %r15, %r14
je 0x4cfd
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x4cf8
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %r14
jmp 0x4ce4
movq 0x28(%rbx), %r12
addq $0x28, %rbx
cmpq %rbx, %r12
je 0x4d2a
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x4d24
movq %r14, %rdi
callq 0x40d8
movq %r14, %rdi
callq 0x2100
movq (%r12), %r12
jmp 0x4d05
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x4d42
movq (%rdi), %r14
callq 0x2100
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x4d32
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x4d5a
movq (%rdi), %rbx
callq 0x2100
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x4d4a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop