LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/util.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> neocortex::util::format<int, unsigned long, unsigned long, unsigned long, unsigned long, double, unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, unsigned long, unsigned long, unsigned long, unsigned long, double, unsigned long)
std::string format(std::string fmt, Args ... args) {
			int length = snprintf(nullptr, 0, fmt.c_str(), args ...) + 1;

			if (length <= 0) {
				throw std::runtime_error("Error occurred formatting string.");
			}

			char* buffer = new char[length];
			std::unique_ptr<char[]> buffer_ref(buffer);

			snprintf(buffer, length, fmt.c_str(), args ...);

			return std::string(buffer, buffer + length - 1);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r10
movq %r8, %r9
movq %rcx, %r8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdx
subq $0x8, %rsp
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %ecx
movq %r8, 0x10(%rsp)
movq %r9, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movb $0x1, %al
pushq 0x70(%rsp)
pushq 0x70(%rsp)
movq %r10, 0x38(%rsp)
pushq %r10
callq 0x4440
addq $0x20, %rsp
testl %eax, %eax
js 0x81d5
movl %eax, %r12d
leaq 0x1(%r12), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, %r13
movq (%r14), %rdx
subq $0x8, %rsp
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movsd 0x20(%rsp), %xmm0
movb $0x1, %al
pushq 0x70(%rsp)
pushq 0x70(%rsp)
pushq 0x38(%rsp)
callq 0x4440
addq $0x20, %rsp
leaq (%r12,%r13), %rdx
incq %rdx
decq %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6e64
movq %r13, %rdi
callq 0x4340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4110
movq %rax, %rbx
leaq 0xfb62(%rip), %rsi      # 0x17d4b
movq %rax, %rdi
callq 0x40d0
movq 0x18df8(%rip), %rsi     # 0x20ff0
movq 0x18d89(%rip), %rdx     # 0x20f88
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
jmp 0x821f
movq %rax, %r14
movq %r13, %rdi
callq 0x4340
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/eval.cpp
// Function: neocortex::score::parent(int)
int score::parent(int value) {
	if (value == INCOMPLETE) {
		return value;
	}

	if (is_mate(value)) {
		if (value < 0) return value + 1;
		if (value > 0) return value - 1;

		return 0;
	} else {
		return value;
	}
}

// Assembly:
movl $0x80000000, %eax       # imm = 0x80000000
movl %edi, %ecx
negl %ecx
jo 0x716a
leal -0x3d08e0(%rdi), %eax
cmpl $0xff85ee40, %eax       # imm = 0xFF85EE40
ja 0x7168
testl %edi, %edi
js 0x7166
xorl %eax, %eax
subl $0x1, %edi
cmovbl %eax, %edi
jmp 0x7168
incl %edi
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/eval.cpp
// Function: neocortex::score::to_string[abi:cxx11](int)
std::string score::to_string(int value) {
	if (is_mate(value)) {
		if (value > 0) {
			return util::format("#%d", CHECKMATE - value);
		} else {
			return util::format("#-%d", value - CHECKMATED);
		}
	} else {
		return util::format("%+.2f", value / 100.0f);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leal -0x3d08e0(%r14), %eax
cmpl $0xff85ee40, %eax       # imm = 0xFF85EE40
ja 0x71d5
testl %r14d, %r14d
jle 0x7219
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x115d0(%rip), %rsi     # 0x18774
leaq 0x115cc(%rip), %rdx     # 0x18777
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x6fca
movl $0x3d0900, %edx         # imm = 0x3D0900
subl %r14d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73de
movq 0x48(%rsp), %rdi
jmp 0x7258
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x11597(%rip), %rsi     # 0x1877d
leaq 0x11595(%rip), %rdx     # 0x18782
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6fca
cvtsi2ss %r14d, %xmm0
divss 0x11569(%rip), %xmm0    # 0x18770
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74b1
movq 0x8(%rsp), %rdi
jmp 0x7258
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1154e(%rip), %rsi     # 0x18778
leaq 0x1154b(%rip), %rdx     # 0x1877c
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6fca
addl $0x3d0900, %r14d        # imm = 0x3D0900
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x73de
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7269
movq (%r12), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x7294
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x7294
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x72a5
movq (%r12), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/eval.cpp
// Function: neocortex::score::to_uci[abi:cxx11](int)
std::string score::to_uci(int value) {
	if (is_mate(value)) {
		if (value > 0) {
			return util::format("mate %d", CHECKMATE - value);
		} else {
			return util::format("mate -%d", value - CHECKMATED);
		}
	} else {
		return util::format("cp %d", value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leal -0x3d08e0(%r14), %eax
cmpl $0xff85ee40, %eax       # imm = 0xFF85EE40
ja 0x7310
testl %r14d, %r14d
jle 0x734a
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x114a1(%rip), %rsi     # 0x18783
leaq 0x114a1(%rip), %rdx     # 0x1878a
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x6fca
movl $0x3d0900, %edx         # imm = 0x3D0900
subl %r14d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73de
movq 0x48(%rsp), %rdi
jmp 0x7389
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x11473(%rip), %rsi     # 0x18794
leaq 0x11471(%rip), %rdx     # 0x18799
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6fca
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x73de
movq 0x8(%rsp), %rdi
jmp 0x7389
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x11430(%rip), %rsi     # 0x1878b
leaq 0x11431(%rip), %rdx     # 0x18793
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6fca
addl $0x3d0900, %r14d        # imm = 0x3D0900
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x73de
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x739a
movq (%r12), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x73c5
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x73c5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x73d6
movq (%r12), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/move.cpp
// Function: neocortex::Move::Move(int, int, int)
Move::Move(int src, int dst, int ptype) {
	assert(square::is_valid(src));
	assert(square::is_valid(dst));

	this->m_src = src;
	this->m_dst = dst;
	this->m_ptype = ptype;
}

// Assembly:
pushq %rax
cmpl $0x40, %esi
jae 0x766d
cmpl $0x40, %edx
jae 0x768c
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
popq %rax
retq
leaq 0x11220(%rip), %rdi     # 0x18894
leaq 0x1122f(%rip), %rsi     # 0x188aa
leaq 0x11235(%rip), %rcx     # 0x188b7
movl $0x16, %edx
callq 0x4190
leaq 0x11249(%rip), %rdi     # 0x188dc
leaq 0x11210(%rip), %rsi     # 0x188aa
leaq 0x11216(%rip), %rcx     # 0x188b7
movl $0x17, %edx
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/move.cpp
// Function: neocortex::Move::Move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Move::Move(std::string uci) {
	if (uci.size() < 4 || uci.size() > 5) {
		throw util::fmterr("Invalid UCI \"%s\": moves must be 4 or 5 characters, parsed %d", uci.c_str(), uci.size());
	}

	m_src = square::from_uci(uci.substr(0, 2));
	m_dst = square::from_uci(uci.substr(2, 2));
	m_ptype = (uci.size() == 5) ? piece::type_from_uci(uci[4]) : piece::null;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq 0x8(%rsi), %rax
addq $-0x6, %rax
cmpq $-0x3, %rax
jbe 0x7773
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movl $0x2, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x42c0
movq %r15, %rdi
callq 0x11eb0
movl %eax, (%r14)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x770b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42b0
leaq 0x8(%rsp), %r15
movl $0x2, %edx
movl $0x2, %ecx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42c0
movq %r15, %rdi
callq 0x11eb0
movl %eax, 0x4(%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x774c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x5, 0x8(%rbx)
jne 0x7764
movq (%rbx), %rax
movsbl 0x4(%rax), %edi
callq 0x852e
movl %eax, 0x8(%r14)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x4110
movq %rax, %r14
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x11162(%rip), %rsi     # 0x188f2
leaq 0x11197(%rip), %rdx     # 0x1892e
leaq 0x48(%rsp), %rdi
callq 0x6fca
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x7b25
xorl %ebp, %ebp
movq 0x19807(%rip), %rsi     # 0x20fc8
movq 0x19820(%rip), %rdx     # 0x20fe8
movq %r14, %rdi
callq 0x44c0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x77f2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x77f2
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7837
movq %r14, %rdi
callq 0x41e0
jmp 0x7837
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7837
movq 0x18(%rsp), %rsi
jmp 0x782f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7837
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/move.cpp
// Function: neocortex::Move::to_uci[abi:cxx11]()
std::string Move::to_uci() {
	std::string output;

	output += square::to_uci(m_src);
	output += square::to_uci(m_dst);

	if (piece::is_type(m_ptype)) {
		output += piece::type_to_uci(m_ptype);
	}

	return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %esi
leaq 0x8(%rsp), %rdi
callq 0x11f2e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4090
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x789e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
movl 0x4(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x11f2e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4090
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x78d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
movl 0x8(%r14), %edi
cmpl $0x5, %edi
ja 0x78ee
callq 0x861b
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4240
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7930
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x7921
jmp 0x7933
jmp 0x7930
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7933
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x7933
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x7946
movq (%r15), %rsi
incq %rsi
callq 0x42b0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/move.cpp
// Function: neocortex::PV::to_string[abi:cxx11]()
std::string PV::to_string() {
	std::string output;

	for (int i = 0; i < len; ++i) {
		if (i) output += ' ';
		output += moves[i].to_uci();
	}

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x0, (%rsi)
jle 0x7ad2
movq %rsi, %r14
leaq 0x4(%rsi), %r15
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
testq %r13, %r13
je 0x7a8f
movq %rbx, %rdi
movl $0x20, %esi
callq 0x4240
movq %r12, %rdi
movq %r15, %rsi
callq 0x7840
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4090
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7ac3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
incq %r13
movslq (%r14), %rax
addq $0xc, %r15
cmpq %rax, %r13
jl 0x7a7d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7ae6
movq %rax, %r14
jmp 0x7b05
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7b05
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x7b1d
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42b0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/perft.cpp
// Function: neocortex::perft::run(neocortex::Position&, int)
perft::results perft::run(Position& p, int depth) {
	if (depth < 0) {
		throw util::fmterr("Invalid perft depth %d", depth);
	}

	current_results = perft::results();

	util::time_point now = util::time_now();

	perft_movegen(p, depth);

	current_results.totaltime = util::time_elapsed(now);
	current_results.nps = (unsigned long) (current_results.nodes / current_results.totaltime);

	return current_results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
testl %edx, %edx
js 0x7eb2
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x22df0(%rip)    # 0x2abe0
movupd %xmm0, 0x22dd8(%rip)    # 0x2abd0
movupd %xmm0, 0x22dc0(%rip)    # 0x2abc0
movupd %xmm0, 0x22da8(%rip)    # 0x2abb0
callq 0x15d13
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x7f3e
movq %r15, %rdi
callq 0x15d18
movsd %xmm0, 0x22dbe(%rip)    # 0x2abe8
movsd 0x22d7e(%rip), %xmm1    # 0x2abb0
unpcklps 0x10af7(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x10aff(%rip), %xmm1    # 0x18940
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x10aeb(%rip), %xmm2    # 0x18950
cvttsd2si %xmm2, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x22d69(%rip)     # 0x2abe0
movups 0x22d52(%rip), %xmm0    # 0x2abd0
movups %xmm0, 0x20(%rbx)
movups 0x22d37(%rip), %xmm0    # 0x2abc0
movups %xmm0, 0x10(%rbx)
movups 0x22d1c(%rip), %xmm0    # 0x2abb0
movups %xmm0, (%rbx)
movups 0x22d42(%rip), %xmm0    # 0x2abe0
movups %xmm0, 0x30(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x4110
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x10b06(%rip), %rsi     # 0x189d6
leaq 0x10b15(%rip), %rdx     # 0x189ec
movq %rsp, %rdi
callq 0x6fca
movb $0x1, %r15b
movq %rsp, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x8227
xorl %r15d, %r15d
movq 0x190cf(%rip), %rsi     # 0x20fc8
movq 0x190e8(%rip), %rdx     # 0x20fe8
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f29
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x7f29
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x7f36
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/perft.cpp
// Function: perft_movegen(neocortex::Position&, int)
void perft_movegen(Position& p, int depth) {
	if (!depth) {
		current_results.nodes++;

		if (p.capture()) current_results.captures++;
		if (p.check()) current_results.checks++;
		if (p.castle()) current_results.castles++;
		if (p.en_passant()) current_results.en_passant++;
		if (p.promotion()) current_results.promotions++;
	
		return;
	}

	Move pl_moves[MAX_PL_MOVES];
	int num_pl_moves = p.pseudolegal_moves(pl_moves);

	for (int i = 0; i < num_pl_moves; ++i) {
		if (p.make_move(pl_moves[i])) {
			perft_movegen(p, depth - 1);
		}

		p.unmake_move(pl_moves[i]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4b8, %rsp            # imm = 0x4B8
movq %rdi, %rbx
testl %esi, %esi
je 0x7fca
movl %esi, %ebp
xorl %r14d, %r14d
leaq (%rsp,%r14), %rdi
callq 0x7648
addq $0xc, %r14
cmpq $0x4b0, %r14            # imm = 0x4B0
jne 0x7f57
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9cc2
testl %eax, %eax
jle 0x8019
decl %ebp
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r14
xorl %r15d, %r15d
movq (%rsp,%r15), %rsi
movl 0x8(%rsp,%r15), %edx
movq %rbx, %rdi
callq 0x947c
testb %al, %al
je 0x7fae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7f3e
movq (%rsp,%r15), %rsi
movl 0x8(%rsp,%r15), %edx
movq %rbx, %rdi
callq 0x9a5e
addq $0xc, %r15
cmpq %r15, %r14
jne 0x7f8f
jmp 0x8019
incq 0x22bdf(%rip)           # 0x2abb0
movq 0x160(%rbx), %rax
cmpl $-0x1, -0x24(%rax)
je 0x7fe5
incq 0x22bdb(%rip)           # 0x2abc0
cmpl $0x0, -0x14(%rax)
je 0x7ff2
incq 0x22bc6(%rip)           # 0x2abb8
cmpb $0x1, -0xf(%rax)
jne 0x7fff
incq 0x22bc9(%rip)           # 0x2abc8
cmpb $0x1, -0x10(%rax)
jne 0x800c
incq 0x22bcc(%rip)           # 0x2abd8
cmpl $0x5, -0x30(%rax)
ja 0x8019
incq 0x22bb7(%rip)           # 0x2abd0
addq $0x4b8, %rsp            # imm = 0x4B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/piece.cpp
// Function: neocortex::piece::from_uci(char)
int piece::from_uci(char uci) {
	char typechar = tolower(uci);
	int type;

	switch (typechar) {
	case 'p':
		type = PAWN;
		break;
	case 'b':
		type = BISHOP;
		break;
	case 'n':
		type = KNIGHT;
		break;
	case 'r':
		type = ROOK;
		break;
	case 'q':
		type = QUEEN;
		break;
	case 'k':
		type = KING;
		break;
	default:
		throw util::fmterr("Invalid UCI piece: %c", uci);
	}

	return make_piece((uci == typechar) ? BLACK : WHITE, type);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebp
callq 0x43e0
movsbl %al, %ecx
leal -0x6b(%rcx), %eax
cmpl $0x7, %eax
ja 0x837b
leaq 0x10685(%rip), %rdx     # 0x189f0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl $0xa, %edx
jmp 0x839e
cmpl $0x62, %ecx
jne 0x83b4
movl $0x2, %edx
jmp 0x839e
movl $0x6, %edx
jmp 0x839e
movl $0x4, %edx
jmp 0x839e
movl $0x8, %edx
jmp 0x839e
xorl %edx, %edx
xorl %eax, %eax
cmpl %ebp, %ecx
sete %al
orl %edx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x4110
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1069d(%rip), %rsi     # 0x18a6f
leaq 0x106ab(%rip), %rdx     # 0x18a84
movq %rsp, %rdi
callq 0x6fca
movb $0x1, %r15b
movsbl %bpl, %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x864d
xorl %r15d, %r15d
movq 0x18bcb(%rip), %rsi     # 0x20fc8
movq 0x18be4(%rip), %rdx     # 0x20fe8
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x842d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x842d
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x843a
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/piece.cpp
// Function: neocortex::piece::color_from_uci(char)
int piece::color_from_uci(char uci) {
	switch (uci) {
	case 'w':
		return WHITE;
	case 'b':
		return BLACK;
	default:
		throw util::fmterr("Invalid UCI color: %c", uci);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorl %eax, %eax
cmpl $0x77, %edi
je 0x8461
movl %edi, %ebp
cmpl $0x62, %edi
jne 0x846e
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x4110
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x105f9(%rip), %rsi     # 0x18a85
leaq 0x10607(%rip), %rdx     # 0x18a9a
movq %rsp, %rdi
callq 0x6fca
movb $0x1, %r15b
movsbl %bpl, %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x864d
xorl %r15d, %r15d
movq 0x18b11(%rip), %rsi     # 0x20fc8
movq 0x18b2a(%rip), %rdx     # 0x20fe8
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x84e7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x84e7
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x84f4
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/piece.cpp
// Function: neocortex::piece::type_from_uci(char)
int piece::type_from_uci(char uci) {
	switch (uci) {
	case 'p':
		return PAWN;
	case 'b':
		return BISHOP;
	case 'n':
		return KNIGHT;
	case 'r':
		return ROOK;
	case 'q':
		return QUEEN;
	case 'k':
		return KING;
	default:
		throw util::fmterr("Invalid UCI type: %c", uci);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %r14d
leal -0x6b(%r14), %eax
cmpl $0x7, %eax
ja 0x855b
leaq 0x104c5(%rip), %rcx     # 0x18a10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, %eax
jmp 0x857f
cmpl $0x62, %r14d
jne 0x858a
movl $0x1, %eax
jmp 0x857f
movl $0x3, %eax
jmp 0x857f
movl $0x2, %eax
jmp 0x857f
movl $0x4, %eax
jmp 0x857f
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x4110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1053d(%rip), %rsi     # 0x18ae4
leaq 0x1054a(%rip), %rdx     # 0x18af8
leaq 0x8(%rsp), %rdi
callq 0x6fca
movb $0x1, %bpl
movsbl %r14b, %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x864d
xorl %ebp, %ebp
movq 0x189f3(%rip), %rsi     # 0x20fc8
movq 0x18a0c(%rip), %rdx     # 0x20fe8
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8606
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x8606
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8613
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/position.cpp
// Function: neocortex::Position::Position()
Position::Position() {
	board = Board::standard();

	State first_state;

	eval_counter = 0;

	first_state.castle_rights = 0xF;
	first_state.en_passant_square = square::null;
	first_state.fullmove_number = 1;
	first_state.halfmove_clock = 0;
	first_state.captured_piece = piece::null;
	first_state.captured_square = piece::null;
	first_state.last_move = Move::null;
	first_state.key = 0;
	first_state.key ^= board.get_tt_key();
	first_state.key ^= zobrist::castle(first_state.castle_rights);
	first_state.in_check = 0;
	first_state.was_castle = false;
	first_state.was_en_passant = false;

	reset_history_table();

	ply.push_back(first_state);
	color_to_move = piece::WHITE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
callq 0x5e1c
leaq 0x158(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq $0x0, 0x168(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x63fe
leaq 0x8(%rsp), %r15
movl $0x158, %edx            # imm = 0x158
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4230
leaq 0x22336(%rip), %rax     # 0x2ab98
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movq (%rax), %rcx
movq %rcx, (%r15)
movaps 0x102ca(%rip), %xmm0    # 0x18b40
movups %xmm0, 0xc(%r15)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x1c(%r15)
xorl %ecx, %ecx
movl %ecx, 0x24(%r15)
movw $0x0, 0x28(%r15)
movq %rcx, 0x30(%r15)
movl %ecx, 0x174(%rbx)
movabsq $-0xfffffff1, %rdx      # imm = 0xFFFFFFFF0000000F
movq %rdx, 0x10(%r15)
movl $0xffffffff, 0xc(%r15)  # imm = 0xFFFFFFFF
movl $0x1, 0x20(%r15)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rdx, 0x18(%r15)
movq (%rax), %rdx
movq %rdx, (%r15)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r15)
movq %rcx, 0x30(%r15)
movq 0x150(%rbx), %rax
movq %rax, 0x30(%r15)
movl $0xf, %edi
callq 0x167b8
xorq %rax, 0x38(%rsp)
movl $0x0, 0x2c(%rsp)
movw $0x0, 0x30(%rsp)
leaq 0x178(%rbx), %rdi
movl $0x8000, %edx           # imm = 0x8000
xorl %esi, %esi
callq 0x4150
movq 0x160(%rbx), %rsi
cmpq 0x168(%rbx), %rsi
je 0x8951
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsi)
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x38, 0x160(%rbx)
jmp 0x895e
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xf8da
movl $0x0, 0x170(%rbx)
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8977
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x8991
movq 0x168(%rbx), %rsi
subq %rdi, %rsi
callq 0x42b0
movq %r15, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/position.cpp
// Function: neocortex::Position::num_repetitions()
int Position::num_repetitions() {
	int res = 0;

	for (size_t i = 0; i < ply.size(); ++i) {
		if (ply[i].key == ply.back().key) {
			++res;
		}
	}

	return res;
}

// Assembly:
movq 0x158(%rdi), %rcx
movq 0x160(%rdi), %rax
movq %rax, %rsi
subq %rcx, %rsi
je 0xee09
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rsi, %rdx
movq -0x8(%rax), %rsi
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x30, %rcx
xorl %eax, %eax
xorl %edi, %edi
cmpq %rsi, (%rcx)
sete %dil
addl %edi, %eax
addq $0x38, %rcx
decq %rdx
jne 0xedf4
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/search.cpp
// Function: neocortex::search::Search::set_threads(int)
void search::Search::set_threads(int num) {
	if (num < 1) num = 1;
	if (num > max_threads()) num = max_threads();

	num_threads = num;

	neocortex_info("Using %d search threads.\n", num);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
cmpl $0x2, %esi
movl $0x1, %ebx
cmovgel %esi, %ebx
callq 0x4370
cmpl %eax, %ebx
jle 0xfb75
callq 0x4370
movl %eax, %ebx
movl %ebx, %eax
xchgl %eax, 0x8178(%r14)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa272(%rip), %rsi      # 0x19e00
leaq 0xa284(%rip), %rdx      # 0x19e19
movq %rsp, %r14
movq %r14, %rdi
callq 0x6fca
movq %r14, %rdi
movl %ebx, %esi
callq 0x119e3
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfbc0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xfbe3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/search.cpp
// Function: neocortex::search::Search::smp_worker(int, neocortex::Position, int*)
void search::Search::smp_worker(int s_depth, Position root, int* node_count_out) {
	PV local_pv;

	root.reset_eval_counter();
	alphabeta(root, s_depth, score::CHECKMATED, score::CHECKMATE, 0, &local_pv, smp_should_stop);
	
	if (node_count_out) {
		*node_count_out = root.get_eval_counter();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x610, %rsp            # imm = 0x610
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x7a1c
movq %r14, %rdi
callq 0xf804
leaq 0x8198(%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0xffc2f700, %ecx       # imm = 0xFFC2F700
movl $0x3d0900, %r8d         # imm = 0x3D0900
xorl %r9d, %r9d
pushq %rax
pushq %r12
callq 0x10802
addq $0x10, %rsp
testq %rbx, %rbx
je 0x10f23
movq %r14, %rdi
callq 0xf810
movl %eax, (%rbx)
addq $0x610, %rsp            # imm = 0x610
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/square.cpp
// Function: neocortex::square::from_uci(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int square::from_uci(std::string uci) {
	if (uci == "-") {
		return square::null;
	} else {
		assert(uci.size() == 2);
		return at(uci[1] - '1', uci[0] - 'a');
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x80ef(%rip), %rsi      # 0x19faa
callq 0x4080
testl %eax, %eax
je 0x11ee9
cmpq $0x2, 0x8(%rbx)
jne 0x11ef0
movq (%rbx), %rcx
movsbl 0x1(%rcx), %eax
addl $-0x31, %eax
movsbl (%rcx), %ecx
addl $-0x61, %ecx
movl %ecx, %edx
orl %eax, %edx
cmpl $0x8, %edx
jae 0x11f0f
leal (%rcx,%rax,8), %eax
jmp 0x11eee
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
leaq 0x80b5(%rip), %rdi      # 0x19fac
leaq 0x80be(%rip), %rsi      # 0x19fbc
leaq 0x80c6(%rip), %rcx      # 0x19fcb
movl $0x12, %edx
callq 0x4190
leaq 0x5bb3(%rip), %rdi      # 0x17ac9
leaq 0x5b59(%rip), %rsi      # 0x17a76
leaq 0x5bd4(%rip), %rcx      # 0x17af8
movl $0x22, %edx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/square.cpp
// Function: neocortex::square::to_uci[abi:cxx11](int)
std::string square::to_uci(int sq) {
	if (sq == square::null) {
		return "-";
	}

	std::string output;

	output += 'a' + file(sq);
	output += '1' + rank(sq);

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
cmpl $-0x1, %esi
je 0x11f7d
movl %esi, %ebp
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
cmpl $0x40, %esi
jae 0x11fa1
movl %ebp, %eax
andb $0x7, %al
addb $0x61, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x4240
shrl $0x3, %ebp
addb $0x31, %bpl
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x4240
jmp 0x11f93
leaq 0x8026(%rip), %rsi      # 0x19faa
leaq 0x8020(%rip), %rdx      # 0x19fab
movq %rbx, %rdi
callq 0x6fca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ae3(%rip), %rdi      # 0x17a8b
leaq 0x5ac7(%rip), %rsi      # 0x17a76
leaq 0x5b66(%rip), %rcx      # 0x17b1c
movl $0x40, %edx
callq 0x4190
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x11fd6
movq (%r15), %rsi
incq %rsi
callq 0x42b0
movq %r14, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/tt.cpp
// Function: neocortex::tt::resize(int)
void tt::resize(int mb) {
	std::lock_guard<std::shared_mutex> lock(tt_resize_mutex);
	if (tt_buffer) delete[] tt_buffer;
	if (tt_mutex_buffer) delete[] tt_mutex_buffer;

	tt_buffer_size = mb * 1024 * 1024 / (sizeof(tt::entry) + sizeof(std::mutex));
	tt_buffer = new tt::entry[tt_buffer_size];
	tt_mutex_buffer = new std::mutex[tt_buffer_size];

	neocortex_debug("Transposition table resized to %d mb (%d entries)\n", mb, tt_buffer_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x18c67(%rip), %rdi     # 0x2ac60
callq 0x4410
cmpl $0x23, %eax
je 0x12181
movq 0x18c42(%rip), %rdi     # 0x2ac50
testq %rdi, %rdi
je 0x12018
callq 0x4340
movq 0x18c79(%rip), %rdi     # 0x2ac98
testq %rdi, %rdi
je 0x12029
callq 0x4340
movl %ebx, %eax
shll $0x14, %eax
cltq
movabsq $-0x1c71c71c71c71c71, %rcx # imm = 0xE38E38E38E38E38F
mulq %rcx
movq %rdx, %r14
shrq $0x6, %r14
movl %r14d, 0x18c0d(%rip)    # 0x2ac58
movq %r14, %r15
shlq $0x20, %r15
movslq %r14d, %r12
movq %r12, %rax
shrq $0x3b, %rax
movq %r15, %rcx
sarq $0x1b, %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x4030
testq %r15, %r15
je 0x120bb
movq %r12, %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
leaq 0x18b0c(%rip), %rdx     # 0x2ab98
movq %rax, %rsi
movq $0x0, (%rsi)
movq (%rdx), %rdi
movq %rdi, 0x8(%rsi)
movl 0x8(%rdx), %edi
movl %edi, 0x10(%rsi)
movq $0x2, 0x14(%rsi)
movl $0x0, 0x1c(%rsi)
addq $0x20, %rsi
cmpq %rcx, %rsi
jne 0x1208f
movq %rax, 0x18b8e(%rip)     # 0x2ac50
movslq %r14d, %rax
movl $0x28, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x4030
movq %rax, %r15
testl %r14d, %r14d
je 0x12118
leaq (%r12,%r12,4), %rax
leaq -0x28(,%rax,8), %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
shrq $0x5, %rdx
leaq (%rdx,%rdx,4), %rax
leaq 0x28(,%rax,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x4150
movq %r15, 0x18b79(%rip)     # 0x2ac98
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x7ec9(%rip), %rsi      # 0x19ff8
leaq 0x7ef4(%rip), %rdx      # 0x1a02a
leaq 0x8(%rsp), %rdi
callq 0x6fca
movl 0x18b12(%rip), %edx     # 0x2ac58
leaq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x1224b
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x12169
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
leaq 0x18af0(%rip), %rdi     # 0x2ac60
callq 0x4350
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x23, %edi
callq 0x41a0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x121ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x121ac
jmp 0x121a9
movq %rax, %rbx
leaq 0x18aad(%rip), %rdi     # 0x2ac60
callq 0x4350
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/util.cpp
// Function: neocortex::util::timestring[abi:cxx11]()
std::string util::timestring() {
	std::time_t t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
	std::tm tm;
	
#ifdef NEOCORTEX_WIN32
	if (localtime_s(&tm, &t)) {
		throw std::runtime_error("localtime() failed.");
	}
#else
	if (!localtime_r(&t, &tm)) {
		throw std::runtime_error("localtime() failed.");
	}
#endif

	std::stringstream ss;
	ss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");

	return ss.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
callq 0x4050
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rdx, (%rdi)
leaq 0x8(%rsp), %rsi
callq 0x4120
testq %rax, %rax
je 0x15cab
leaq 0x40(%rsp), %rdi
callq 0x41c0
leaq 0x50(%rsp), %rdi
leaq 0x48b4(%rip), %rdx      # 0x1a51c
leaq 0x8(%rsp), %rsi
callq 0x161ce
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x4430
movq 0xb2e2(%rip), %rsi      # 0x20f68
leaq 0x40(%rsp), %rdi
callq 0x41f0
leaq 0xc0(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4110
movq %rax, %r14
leaq 0x4849(%rip), %rsi      # 0x1a508
movq %rax, %rdi
callq 0x40d0
movq 0xb322(%rip), %rsi      # 0x20ff0
movq 0xb2b3(%rip), %rdx      # 0x20f88
movq %r14, %rdi
callq 0x44c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x41e0
jmp 0x15d0b
movq %rax, %rbx
movq 0xb274(%rip), %rsi      # 0x20f68
leaq 0x40(%rsp), %rdi
callq 0x41f0
leaq 0xc0(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/util.cpp
// Function: neocortex::util::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
std::vector<std::string> util::split(std::string input, char delim) {
	char* buf = new char[input.size() + 1];
	int token_ind = 0;

	std::vector<std::string> result;

	for (size_t c = 0; c < input.size(); ++c) {
		if (input[c] == delim) {
			if (token_ind > 0) {
				buf[token_ind] = '\0';
				token_ind = 0;
				result.push_back(std::string(buf));
			} else {
				continue;
			}
		} else {
			buf[token_ind++] = input[c];
		}
	}

	if (token_ind > 0) {
		buf[token_ind] = '\0';
		token_ind = 0;
		result.push_back(std::string(buf));
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rsi), %rbx
leaq 0x1(%rbx), %rdi
callq 0x4030
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq %r12, (%rsp)
movq $0x0, 0x10(%r12)
testq %rbx, %rbx
je 0x15e31
xorl %ebx, %ebx
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
xorl %eax, %eax
movq (%r15), %rcx
movb (%rcx,%rbx), %cl
cmpb %bpl, %cl
jne 0x15e1d
testl %eax, %eax
jle 0x15e26
movl %eax, %eax
movb $0x0, (%r14,%rax)
movq %r13, 0x8(%rsp)
movq %r14, %rdi
callq 0x40f0
leaq (%rax,%r14), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x6fca
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x16372
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15e19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
xorl %eax, %eax
jmp 0x15e26
movslq %eax, %rdx
incl %eax
movb %cl, (%r14,%rdx)
incq %rbx
cmpq 0x8(%r15), %rbx
jb 0x15dc4
jmp 0x15e33
xorl %eax, %eax
testl %eax, %eax
jle 0x15e87
movl %eax, %eax
movb $0x0, (%r14,%rax)
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %r14, %rdi
callq 0x40f0
movq %r14, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6fca
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x16372
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x15e87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
jne 0x15eb8
jmp 0x15eca
jmp 0x15ec7
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15eca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x15eca
movq %rax, %r14
movq (%rsp), %rdi
callq 0x6e08
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/util.cpp
// Function: neocortex::util::join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string util::join(std::vector<std::string> parts, std::string delim) {
	std::string output;

	for (size_t i = 0; i < parts.size(); ++i) {
		if (i) output += delim;
		output += parts[i];
	}

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x1619d
movq %rdx, %r14
movq %rsi, %r15
movl $0x8, %r13d
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x16172
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x4090
movq (%r15), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x4090
movq 0x8(%r15), %rax
subq (%r15), %rax
incq %rbp
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rax, %rbp
jb 0x1615e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x161c6
movq (%r12), %rsi
incq %rsi
callq 0x42b0
movq %r14, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/zobrist.cpp
// Function: neocortex::zobrist::init()
void zobrist::init() {
	assert(!zobrist_initialized);

	std::random_device rng;
	std::mt19937_64 twister(rng()); /* TODO: tune a good zobrist seed */
	std::uniform_int_distribution<zobrist::Key> dist;

	for (int sq = 0; sq < 64; ++sq) {
		for (int p = 0; p < 12; ++p) {
			piece_keys[sq][p] = dist(twister);
		}
	}

	for (int castle = 0; castle < 16; ++castle) {
		castle_keys[castle] = dist(twister);
	}

	for (int file = 0; file < 8; ++file) {
		en_passant_keys[file] = dist(twister);
	}

	black_to_move_key = dist(twister);
	zobrist_initialized = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d60, %rsp           # imm = 0x1D60
cmpb $0x1, 0x146da(%rip)     # 0x2acb1
je 0x16721
leaq 0x9d8(%rsp), %rbx
movq %rbx, %rdi
callq 0x16888
movq %rbx, %rdi
callq 0x4390
movl %eax, %esi
movq %rsi, 0x10(%rsp)
movl $0x1, %eax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
movq %rsi, %rdx
shrq $0x3e, %rdx
xorq %rsi, %rdx
imulq %rcx, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rsp,%rax,8)
incq %rax
movq %rdx, %rsi
cmpq $0x138, %rax            # imm = 0x138
jne 0x1660e
leaq 0x10(%rsp), %rbx
movq $0x138, 0x9c0(%rbx) # imm = 0x138
movq %rsp, %r14
movq $0x0, (%r14)
movq $-0x1, 0x8(%r14)
leaq 0x14668(%rip), %r15     # 0x2acc0
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16902
movq %rax, (%r15,%r13,8)
incq %r13
cmpq $0xc, %r13
jne 0x1665e
incq %r12
addq $0x60, %r15
cmpq $0x40, %r12
jne 0x1665b
xorl %r15d, %r15d
leaq 0x10(%rsp), %rbx
movq %rsp, %r14
leaq 0x15e28(%rip), %r12     # 0x2c4c0
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16902
movq %rax, (%r15,%r12)
addq $0x8, %r15
cmpq $0x80, %r15
jne 0x16698
xorl %r15d, %r15d
leaq 0x10(%rsp), %rbx
movq %rsp, %r14
leaq 0x15e77(%rip), %r12     # 0x2c540
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16902
movq %rax, (%r15,%r12)
addq $0x8, %r15
cmpq $0x40, %r15
jne 0x166c9
leaq 0x10(%rsp), %rsi
movq %rsp, %rdi
movq %rdi, %rdx
callq 0x16902
movq %rax, 0x15e84(%rip)     # 0x2c580
movb $0x1, 0x145ae(%rip)     # 0x2acb1
leaq 0x9d8(%rsp), %rdi
callq 0x4280
addq $0x1d60, %rsp           # imm = 0x1D60
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3e06(%rip), %rdi      # 0x1a52e
leaq 0x3e14(%rip), %rsi      # 0x1a543
leaq 0x3e1d(%rip), %rcx      # 0x1a553
movl $0x16, %edx
callq 0x4190
jmp 0x16762
jmp 0x1674a
jmp 0x1674a
jmp 0x1674a
jmp 0x1674a
movq %rax, %rbx
leaq 0x9d8(%rsp), %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x44f0
movq %rax, %rdi
callq 0x1190d
// File: /workspace/github_cpp_makefile_star2_O1/codeandkey[P]neocortex/src/main.cpp
// Function: main
int main(int argc, char** argv) {
#ifdef NEOCORTEX_DEBUG
	log::set_level(log::DEBUG);
#endif

	neocortex_info(NEOCORTEX_NAME " " NEOCORTEX_VERSION " " NEOCORTEX_BUILDTIME " " NEOCORTEX_DEBUG_STR "\n");

	bb::init();
	zobrist::init();
	attacks::init();
	tt::init();

	try {
		uci::start();
	}
	catch (std::exception& e) {
		neocortex_error("Unhandled exception: %s\n", e.what());
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x3, %edi
callq 0x7590
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3b3e(%rip), %rsi      # 0x1a63b
leaq 0x3b57(%rip), %rdx      # 0x1a65b
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x6fca
movq %rbx, %rdi
callq 0x16c14
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16b30
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42b0
callq 0x5918
callq 0x165c0
callq 0x4f9c
movl $0x200, %edi            # imm = 0x200
callq 0x11fe0
callq 0x124c4
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x16c0c
movq %rbx, %rdi
callq 0x40e0
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3add(%rip), %rsi      # 0x1a65c
leaq 0x3aee(%rip), %rdx      # 0x1a674
leaq 0x8(%rsp), %rdi
callq 0x6fca
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x16d77
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x16bbd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
callq 0x4470
jmp 0x16b4e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x16be3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x16be3
movq %rax, %rbx
callq 0x4470
jmp 0x16c0c
movq %rax, %rdi
callq 0x1190d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16c0c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/GenomicRangeQuery.cpp
// Function: main
int main() {
	string s = "CAGCCTA";
	vector<int> P(3), Q(3);
	P[0] = 2;
	Q[0] = 4;
	P[1] = 5;
	Q[1] = 5;
	P[2] = 0;
	Q[2] = 6;
	vector<int> res = solution(s, P, Q);
	for (int i = 0; i < res.size(); i++) {
		cout << res[i] << ',';
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xa22(%rip), %rsi       # 0x2035
leaq 0xa22(%rip), %rdx       # 0x203c
leaq -0x80(%rbp), %rdi
callq 0x1aec
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movl $0xc, %edi
callq 0x10e0
movq %rax, %rbx
movq %rax, -0x60(%rbp)
movq %rax, -0x58(%rbp)
addq $0xc, %rax
movq %rax, -0x50(%rbp)
movl $0x0, (%rbx)
xorl %r15d, %r15d
movq %r15, 0x4(%rbx)
movq %rax, -0x58(%rbp)
movq %r15, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xa0(%rbp)
movl $0xc, %edi
callq 0x10e0
movq %rax, %r14
leaq -0xa0(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rcx)
addq $0xc, %rax
movq %rax, 0x10(%rcx)
movl %r15d, (%r14)
movq $0x0, 0x4(%r14)
movq %rax, 0x8(%rcx)
movl $0x2, (%rbx)
movl $0x4, (%r14)
movl $0x5, %eax
movl %eax, 0x4(%rbx)
movl %eax, 0x4(%r14)
movl %r15d, 0x8(%rbx)
movl $0x6, 0x8(%r14)
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x12fc
movq -0x48(%rbp), %rax
cmpq %rax, -0x40(%rbp)
je 0x1728
xorl %r13d, %r13d
movq 0x28eb(%rip), %r15      # 0x3fd8
leaq -0x29(%rbp), %r12
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x1160
movb $0x2c, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
incq %r13
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x16f1
leaq -0x29(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x28a2(%rip), %rdi      # 0x3fd8
movl $0x1, %edx
callq 0x1110
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x1755
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10f0
movl $0xc, %esi
movq %r14, %rdi
callq 0x10f0
movl $0xc, %esi
movq %rbx, %rdi
callq 0x10f0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x1788
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x10f0
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17aa
movq %rax, %r15
jmp 0x17c2
movq %rax, %r15
jmp 0x17cf
movq %rax, %r15
jmp 0x17dc
movq %rax, %r15
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x17c2
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10f0
movl $0xc, %esi
movq %r14, %rdi
callq 0x10f0
movl $0xc, %esi
movq %rbx, %rdi
callq 0x10f0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x17f5
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x10f0
movq %r15, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/flightaware[P]beast-splitter/modes_message.cc
// Function: modes::operator<<(std::ostream&, modes::Message const&)
std::ostream &operator<<(std::ostream &os, const Message &message) {
        os << std::hex << std::setfill('0') << message.type() << "@" << std::setw(12) << message.timestamp() << ":";
        for (auto b : message.data()) {
            os << std::setw(2) << (int)b;
        }
        os << std::dec << std::setfill(' ');
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rdi,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rdi,%rcx)
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %r15
cmpb $0x0, 0xe1(%rdi,%rax)
jne 0x1048a
movq %r15, %rdi
movl $0x20, %esi
callq 0xf5f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl (%r14), %eax
decl %eax
cmpl $0x4, %eax
ja 0x104ed
leaq 0x3fb61(%rip), %rcx     # 0x50004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3fb69(%rip), %rsi     # 0x5001c
jmp 0x104f4
leaq 0x3fb88(%rip), %rsi     # 0x50044
movl $0x8, %edx
jmp 0x104f9
leaq 0x3fb67(%rip), %rsi     # 0x50031
movl $0xb, %edx
jmp 0x104f9
leaq 0x3fb65(%rip), %rsi     # 0x5003d
movl $0x6, %edx
jmp 0x104f9
leaq 0x3fb3e(%rip), %rsi     # 0x50024
movl $0xc, %edx
jmp 0x104f9
leaq 0x3fb59(%rip), %rsi     # 0x5004d
movl $0x7, %edx
movq %rbx, %rdi
callq 0xf730
leaq 0x3fb10(%rip), %rsi     # 0x50018
movl $0x1, %edx
movq %rbx, %rdi
callq 0xf730
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xf460
leaq 0x3fae2(%rip), %rsi     # 0x5001a
movl $0x1, %edx
movq %rax, %rdi
callq 0xf730
movq 0x18(%r14), %r15
movq 0x20(%r14), %r14
cmpq %r14, %r15
je 0x10573
movzbl (%r15), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%rbx,%rax)
movq %rbx, %rdi
callq 0xfb10
incq %r15
jmp 0x1054d
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r14
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x105b6
movq %r14, %rdi
movl $0x20, %esi
callq 0xf5f0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
movb $0x20, 0xe0(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop