LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::attack_spans(int)
bitboard Board::attack_spans(int col) {
	bitboard out = 0;
	bitboard pawns = piece_occ[piece::PAWN] & color_occ[col];

	while (pawns) {
		int p = bb::poplsb(pawns);

		out |= attacks::pawn_attackspans(col, p);
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq $0x0, -0x18(%rbp)
movq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rdx
andq 0x8(%rcx,%rdx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x86e4
leaq -0x20(%rbp), %rdi
callq 0x8f70
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x8fb0
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x86bc
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::isolated_pawns(int)
bitboard Board::isolated_pawns(int col) {
	bitboard pawns = piece_occ[piece::PAWN] & color_occ[col];
	bitboard out = 0ULL;

	while (pawns) {
		int p = bb::poplsb(pawns);

		if (!(bb::neighbor_files(p) & pawns)) {
			out |= bb::mask(p);
		}
	}
	
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rdx
andq 0x8(%rcx,%rdx,8), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8753
leaq -0x18(%rbp), %rdi
callq 0x8f70
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x9010
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
jne 0x8751
movl -0x24(%rbp), %edi
callq 0x6bd0
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x871c
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::backward_pawns(int)
bitboard Board::backward_pawns(int col) {
	bitboard pawns = piece_occ[piece::PAWN] & color_occ[col];
	bitboard stops = bb::shift(pawns, (col == piece::WHITE) ? NORTH : SOUTH);

	bitboard opp_pawns = piece_occ[piece::PAWN] & color_occ[!col];
	bitboard opp_attacks = bb::shift(opp_pawns & ~FILE_A, (col == piece::WHITE) ? NORTHWEST : SOUTHWEST);

	opp_attacks |= bb::shift(opp_pawns & ~FILE_H, (col == piece::WHITE) ? NORTHEAST : SOUTHEAST);

	stops &= ~attack_spans(col);
	stops &= opp_attacks;

	return bb::shift(stops, (col == piece::WHITE) ? SOUTH : NORTH);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rdx
andq 0x8(%rcx,%rdx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0xfffffff8, %esi       # imm = 0xFFFFFFF8
movl $0x8, %eax
cmpl $0x0, %ecx
cmovel %eax, %esi
callq 0x6ca0
movq -0x38(%rbp), %rcx
movq %rax, -0x20(%rbp)
movq 0x18(%rcx), %rax
cmpl $0x0, -0xc(%rbp)
setne %dl
xorb $-0x1, %dl
andb $0x1, %dl
movzbl %dl, %edx
andq 0x8(%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movabsq $-0x101010101010102, %rdi # imm = 0xFEFEFEFEFEFEFEFE
andq -0x28(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movl $0x7, %eax
cmpl $0x0, %ecx
cmovel %eax, %esi
callq 0x6ca0
movq %rax, -0x30(%rbp)
movabsq $0x7f7f7f7f7f7f7f7f, %rdi # imm = 0x7F7F7F7F7F7F7F7F
andq -0x28(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0xfffffff9, %esi       # imm = 0xFFFFFFF9
movl $0x9, %eax
cmpl $0x0, %ecx
cmovel %eax, %esi
callq 0x6ca0
movq -0x38(%rbp), %rdi
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x8690
xorq $-0x1, %rax
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x8, %esi
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
cmpl $0x0, %ecx
cmovel %eax, %esi
callq 0x6ca0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: codeandkey[P]neocortex/src/util.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> neocortex::util::format<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rax, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x5140
movq %rax, %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
movb $0x0, %al
callq 0x5610
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x9336
movl $0x10, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x1cb0c(%rip), %rsi     # 0x25e0a
callq 0x5120
jmp 0x9305
movq -0x68(%rbp), %rdi
movq 0x29ce0(%rip), %rsi     # 0x32ff0
movq 0x29c81(%rip), %rdx     # 0x32f98
callq 0x5680
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5300
jmp 0x9401
movslq -0x1c(%rbp), %rdi
callq 0x5030
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9430
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x5140
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
callq 0x5610
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq -0x1c(%rbp), %rcx
leaq -0x1(%rax,%rcx), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x56d0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
callq 0x9460
jmp 0x93c4
leaq -0x41(%rbp), %rdi
callq 0x5480
leaq -0x40(%rbp), %rdi
callq 0x94d0
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x5480
leaq -0x40(%rbp), %rdi
callq 0x94d0
movq -0x28(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x80000000, -0x8(%rbp) # imm = 0x80000000
jne 0x9e6c
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9eab
movl -0x8(%rbp), %edi
callq 0x9e20
testb $0x1, %al
jne 0x9e7a
jmp 0x9ea5
cmpl $0x0, -0x8(%rbp)
jge 0x9e8b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9eab
cmpl $0x0, -0x8(%rbp)
jle 0x9e9c
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9eab
movl $0x0, -0x4(%rbp)
jmp 0x9eab
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x9e20
testb $0x1, %al
jne 0x9ef4
jmp 0xa017
cmpl $0x0, -0xc(%rbp)
jle 0x9f8b
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x56d0
movq -0xb0(%rbp), %rdx
leaq 0x1c948(%rip), %rsi     # 0x26864
leaq -0x30(%rbp), %rdi
callq 0x89b0
jmp 0x9f27
movq -0xa8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x3d0900, %edx         # imm = 0x3D0900
subl %eax, %edx
leaq -0x30(%rbp), %rsi
callq 0xa2f0
jmp 0x9f43
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
jmp 0xa0ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9f7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
jmp 0xa0ca
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x56d0
movq -0xb8(%rbp), %rdx
leaq 0x1c8bf(%rip), %rsi     # 0x26868
leaq -0x68(%rbp), %rdi
callq 0x89b0
jmp 0x9fb4
movq -0xa8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x3d0900, %edx         # imm = 0x3D0900
leaq -0x68(%rbp), %rsi
callq 0xa2f0
jmp 0x9fcf
leaq -0x68(%rbp), %rdi
callq 0x5230
leaq -0x69(%rbp), %rdi
callq 0x5480
jmp 0xa0ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5230
leaq -0x69(%rbp), %rdi
callq 0x5480
jmp 0xa0ca
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x56d0
movq -0xc0(%rbp), %rdx
leaq 0x1c835(%rip), %rsi     # 0x2686d
leaq -0x90(%rbp), %rdi
callq 0x89b0
jmp 0xa046
movq -0xa8(%rbp), %rdi
cvtsi2ssl -0xc(%rbp), %xmm0
movss 0x1c806(%rip), %xmm1    # 0x26860
divss %xmm1, %xmm0
leaq -0x90(%rbp), %rsi
callq 0xa470
jmp 0xa06c
leaq -0x90(%rbp), %rdi
callq 0x5230
leaq -0x91(%rbp), %rdi
callq 0x5480
jmp 0xa0ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa0ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5230
leaq -0x91(%rbp), %rdi
callq 0x5480
jmp 0xa0ca
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x9e20
testb $0x1, %al
jne 0xa114
jmp 0xa237
cmpl $0x0, -0xc(%rbp)
jle 0xa1ab
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x56d0
movq -0xb0(%rbp), %rdx
leaq 0x1c737(%rip), %rsi     # 0x26873
leaq -0x30(%rbp), %rdi
callq 0x89b0
jmp 0xa147
movq -0xa8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x3d0900, %edx         # imm = 0x3D0900
subl %eax, %edx
leaq -0x30(%rbp), %rsi
callq 0xa2f0
jmp 0xa163
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
jmp 0xa2cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa19d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
jmp 0xa2dc
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x56d0
movq -0xb8(%rbp), %rdx
leaq 0x1c6b2(%rip), %rsi     # 0x2687b
leaq -0x68(%rbp), %rdi
callq 0x89b0
jmp 0xa1d4
movq -0xa8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x3d0900, %edx         # imm = 0x3D0900
leaq -0x68(%rbp), %rsi
callq 0xa2f0
jmp 0xa1ef
leaq -0x68(%rbp), %rdi
callq 0x5230
leaq -0x69(%rbp), %rdi
callq 0x5480
jmp 0xa2cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5230
leaq -0x69(%rbp), %rdi
callq 0x5480
jmp 0xa2dc
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x56d0
movq -0xc0(%rbp), %rdx
leaq 0x1c62c(%rip), %rsi     # 0x26884
leaq -0x90(%rbp), %rdi
callq 0x89b0
jmp 0xa266
movq -0xa8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x90(%rbp), %rsi
callq 0xa2f0
jmp 0xa27e
leaq -0x90(%rbp), %rdi
callq 0x5230
leaq -0x91(%rbp), %rdi
callq 0x5480
jmp 0xa2cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa2be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5230
leaq -0x91(%rbp), %rdi
callq 0x5480
jmp 0xa2dc
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x6d10
testb $0x1, %al
jne 0xa8cb
jmp 0xa8cd
jmp 0xa8ec
leaq 0x1c0b0(%rip), %rdi     # 0x26984
leaq 0x1c0bf(%rip), %rsi     # 0x2699a
movl $0x16, %edx
leaq 0x1c0c0(%rip), %rcx     # 0x269a7
callq 0x5290
movl -0x10(%rbp), %edi
callq 0x6d10
testb $0x1, %al
jne 0xa8fa
jmp 0xa8fc
jmp 0xa91b
leaq 0x1c0c9(%rip), %rdi     # 0x269cc
leaq 0x1c090(%rip), %rsi     # 0x2699a
movl $0x17, %edx
leaq 0x1c091(%rip), %rcx     # 0x269a7
callq 0x5290
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x52d0
cmpq $0x4, %rax
jb 0xa997
movq -0x98(%rbp), %rdi
callq 0x52d0
cmpq $0x5, %rax
jbe 0xaa78
movb $0x1, -0x45(%rbp)
movl $0x8, %edi
callq 0x51b0
movq %rax, -0xb0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x56d0
movq -0xa8(%rbp), %rdx
leaq 0x1c018(%rip), %rsi     # 0x269e2
leaq -0x30(%rbp), %rdi
callq 0x89b0
jmp 0xa9d5
movq -0x98(%rbp), %rdi
callq 0x5140
movq -0x98(%rbp), %rdi
movq %rax, -0xb8(%rbp)
callq 0x52d0
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rdx
movq %rax, %rcx
leaq -0x30(%rbp), %rsi
callq 0xafa0
jmp 0xaa10
movq -0xb0(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x285ae(%rip), %rsi     # 0x32fd0
movq 0x285bf(%rip), %rdx     # 0x32fe8
callq 0x5680
jmp 0xaba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xaa56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
testb $0x1, -0x45(%rbp)
jne 0xaa67
jmp 0xaa73
movq -0xb0(%rbp), %rdi
callq 0x5300
jmp 0xab9e
movq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x2, %ecx
callq 0x5440
movq -0xc8(%rbp), %rdi
callq 0x1bdd0
movl %eax, -0xbc(%rbp)
jmp 0xaaac
movq -0x90(%rbp), %rax
movl -0xbc(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x5230
movq -0x98(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movl $0x2, %ecx
movq %rcx, %rdx
callq 0x5440
movq -0xd8(%rbp), %rdi
callq 0x1bdd0
movl %eax, -0xcc(%rbp)
jmp 0xaafa
movq -0x90(%rbp), %rax
movl -0xcc(%rbp), %ecx
movl %ecx, 0x4(%rax)
leaq -0x88(%rbp), %rdi
callq 0x5230
movq -0x98(%rbp), %rdi
callq 0x52d0
cmpq $0x5, %rax
jne 0xab49
movq -0x98(%rbp), %rdi
movl $0x4, %esi
callq 0x5740
movsbl (%rax), %edi
callq 0xc100
movl %eax, -0xdc(%rbp)
jmp 0xab56
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0xdc(%rbp)
jmp 0xab56
movq -0x90(%rbp), %rax
movl -0xdc(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5230
jmp 0xab9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5230
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5540
movq -0x70(%rbp), %rax
movl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x1be70
jmp 0xabf0
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x54f0
jmp 0xabff
leaq -0x38(%rbp), %rdi
callq 0x5230
movq -0x70(%rbp), %rax
movl 0x4(%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1be70
jmp 0xac1a
movq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x54f0
jmp 0xac29
leaq -0x68(%rbp), %rdi
callq 0x5230
movq -0x70(%rbp), %rax
movl 0x8(%rax), %edi
callq 0xb080
movb %al, -0x81(%rbp)
jmp 0xac46
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0xac52
jmp 0xacb8
movq -0x70(%rbp), %rax
movl 0x8(%rax), %edi
callq 0xc240
movb %al, -0x82(%rbp)
jmp 0xac66
movq -0x80(%rbp), %rdi
movb -0x82(%rbp), %al
movsbl %al, %esi
callq 0x5250
jmp 0xac7a
jmp 0xacb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xacd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5230
jmp 0xacd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5230
jmp 0xacd8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xaccb
movq -0x80(%rbp), %rdi
callq 0x5230
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x5230
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5540
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0xaf6a
cmpl $0x0, -0x18(%rbp)
je 0xaf14
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x5250
jmp 0xaf04
jmp 0xaf14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xaf87
movq -0x50(%rbp), %rax
movslq -0x18(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x4(%rax,%rcx,4), %rsi
leaq -0x48(%rbp), %rdi
callq 0xabb0
jmp 0xaf30
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x54f0
jmp 0xaf3f
leaq -0x48(%rbp), %rdi
callq 0x5230
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xaee3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5230
jmp 0xaf87
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xaf7d
movq -0x60(%rbp), %rdi
callq 0x5230
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5230
movq -0x20(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xb475
movb $0x1, -0x45(%rbp)
movl $0x8, %edi
callq 0x51b0
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x56d0
movq -0xb8(%rbp), %rdx
leaq 0x1b6d9(%rip), %rsi     # 0x26ac6
leaq -0x30(%rbp), %rdi
callq 0x89b0
jmp 0xb3f8
movq -0xc0(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x30(%rbp), %rsi
callq 0xbac0
jmp 0xb40d
movq -0xc0(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x27bb1(%rip), %rsi     # 0x32fd0
movq 0x27bc2(%rip), %rdx     # 0x32fe8
callq 0x5680
jmp 0xb594
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb453
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
testb $0x1, -0x45(%rbp)
jne 0xb464
jmp 0xb470
movq -0xc0(%rbp), %rdi
callq 0x5300
jmp 0xb58b
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xbb90
movaps -0x90(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
movaps -0x70(%rbp), %xmm2
movaps -0x60(%rbp), %xmm3
movups %xmm3, 0x3181f(%rip)    # 0x3ccd0
movups %xmm2, 0x31808(%rip)    # 0x3ccc0
movups %xmm1, 0x317f1(%rip)    # 0x3ccb0
movups %xmm0, 0x317da(%rip)    # 0x3cca0
callq 0x21dc0
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb5a0
movq -0x98(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x21de0
movq -0xb0(%rbp), %rdi
movsd %xmm0, 0x317d1(%rip)    # 0x3ccd8
movaps 0x1b512(%rip), %xmm1    # 0x26a20
movq 0x3178a(%rip), %xmm0    # 0x3cca0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1b50e(%rip), %xmm1    # 0x26a30
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x3179f(%rip), %xmm1    # 0x3ccd8
divsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1b4ec(%rip), %xmm1    # 0x26a40
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x31766(%rip)     # 0x3ccd0
leaq 0x3172f(%rip), %rsi     # 0x3cca0
movl $0x40, %edx
callq 0x5360
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x55a0
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x10, %eax
ja 0xbec8
movq -0x48(%rbp), %rax
leaq 0x1ac69(%rip), %rcx     # 0x26ae0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x8(%rbp)
jmp 0xbf6c
movl $0x1, -0x8(%rbp)
jmp 0xbf6c
movl $0x2, -0x8(%rbp)
jmp 0xbf6c
movl $0x3, -0x8(%rbp)
jmp 0xbf6c
movl $0x4, -0x8(%rbp)
jmp 0xbf6c
movl $0x5, -0x8(%rbp)
jmp 0xbf6c
movb $0x1, -0x3d(%rbp)
movl $0x8, %edi
callq 0x51b0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x56d0
movq -0x50(%rbp), %rdx
leaq 0x1acb5(%rip), %rsi     # 0x26ba7
leaq -0x28(%rbp), %rdi
callq 0x89b0
jmp 0xbefd
movq -0x58(%rbp), %rdi
movsbl -0x1(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0xc2a0
jmp 0xbf10
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
movq 0x270b1(%rip), %rsi     # 0x32fd0
movq 0x270c2(%rip), %rdx     # 0x32fe8
callq 0x5680
jmp 0xbf97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xbf50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5230
leaq -0x29(%rbp), %rdi
callq 0x5480
testb $0x1, -0x3d(%rbp)
jne 0xbf61
jmp 0xbf6a
movq -0x58(%rbp), %rdi
callq 0x5300
jmp 0xbf8e
movsbl -0x1(%rbp), %ecx
movsbl -0x2(%rbp), %edx
xorl %edi, %edi
movl $0x1, %eax
cmpl %edx, %ecx
cmovel %eax, %edi
movl -0x8(%rbp), %esi
callq 0xc370
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x62, %eax
je 0xbfd2
jmp 0xbfbc
movl -0x44(%rbp), %eax
subl $0x77, %eax
jne 0xbfde
jmp 0xbfc6
movl $0x0, -0x4(%rbp)
jmp 0xc082
movl $0x1, -0x4(%rbp)
jmp 0xc082
movb $0x1, -0x3d(%rbp)
movl $0x8, %edi
callq 0x51b0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x56d0
movq -0x50(%rbp), %rdx
leaq 0x1abb5(%rip), %rsi     # 0x26bbd
leaq -0x28(%rbp), %rdi
callq 0x89b0
jmp 0xc013
movq -0x58(%rbp), %rdi
movsbl -0x5(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0xc2a0
jmp 0xc026
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
movq 0x26f9b(%rip), %rsi     # 0x32fd0
movq 0x26fac(%rip), %rdx     # 0x32fe8
callq 0x5680
jmp 0xc094
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5230
leaq -0x29(%rbp), %rdi
callq 0x5480
testb $0x1, -0x3d(%rbp)
jne 0xc077
jmp 0xc080
movq -0x58(%rbp), %rdi
callq 0x5300
jmp 0xc08b
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x10, %eax
ja 0xc17c
movq -0x48(%rbp), %rax
leaq 0x1a9f9(%rip), %rcx     # 0x26b24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xc220
movl $0x1, -0x4(%rbp)
jmp 0xc220
movl $0x2, -0x4(%rbp)
jmp 0xc220
movl $0x3, -0x4(%rbp)
jmp 0xc220
movl $0x4, -0x4(%rbp)
jmp 0xc220
movl $0x5, -0x4(%rbp)
jmp 0xc220
movb $0x1, -0x3d(%rbp)
movl $0x8, %edi
callq 0x51b0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x56d0
movq -0x50(%rbp), %rdx
leaq 0x1aa76(%rip), %rsi     # 0x26c1c
leaq -0x28(%rbp), %rdi
callq 0x89b0
jmp 0xc1b1
movq -0x58(%rbp), %rdi
movsbl -0x5(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0xc2a0
jmp 0xc1c4
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
movq 0x26dfd(%rip), %rsi     # 0x32fd0
movq 0x26e0e(%rip), %rdx     # 0x32fe8
callq 0x5680
jmp 0xc232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc204
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5230
leaq -0x29(%rbp), %rdi
callq 0x5480
testb $0x1, -0x3d(%rbp)
jne 0xc215
jmp 0xc21e
movq -0x58(%rbp), %rdi
callq 0x5300
jmp 0xc229
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x7450
movq -0x1b8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq %rdi, -0x1b0(%rbp)
callq 0x149b0
leaq -0x160(%rbp), %rdi
callq 0x7d00
jmp 0xc597
movq -0x1b8(%rbp), %rdi
leaq -0x160(%rbp), %rsi
movl $0x158, %edx            # imm = 0x158
callq 0x5360
leaq -0x1a8(%rbp), %rdi
callq 0x149d0
movq -0x1b8(%rbp), %rdi
movl $0x0, 0x174(%rdi)
movl $0xf, -0x198(%rbp)
movl $0xffffffff, -0x19c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x188(%rbp)
movl $0x0, -0x18c(%rbp)
movl $0xffffffff, -0x194(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x190(%rbp) # imm = 0xFFFFFFFF
leaq 0x30679(%rip), %rax     # 0x3cc88
movl 0x8(%rax), %ecx
movl %ecx, -0x1a0(%rbp)
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
movq $0x0, -0x178(%rbp)
callq 0x14a40
movq %rax, -0x1c0(%rbp)
jmp 0xc63b
movq -0x1c0(%rbp), %rcx
movq -0x178(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x178(%rbp)
movl -0x198(%rbp), %edi
callq 0x23d30
movq %rax, -0x1c8(%rbp)
jmp 0xc667
movq -0x1b8(%rbp), %rdi
movq -0x1c8(%rbp), %rcx
movq -0x178(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x178(%rbp)
movl $0x0, -0x184(%rbp)
movb $0x0, -0x17f(%rbp)
movb $0x0, -0x180(%rbp)
callq 0xc710
jmp 0xc6a5
movq -0x1b8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
leaq -0x1a8(%rbp), %rsi
callq 0x14a60
jmp 0xc6c1
movq -0x1b8(%rbp), %rax
movl $0x0, 0x170(%rax)
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x168(%rbp)
movl %eax, -0x16c(%rbp)
callq 0x14ad0
movq -0x168(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/position.cpp
// Function: neocortex::Position::reset_history_table()
void Position::reset_history_table() {
	for (int c = 0; c < 2; ++c) {
		for (int s1 = 0; s1 < 64; ++s1) {
			for (int s2 = 0; s2 < 64; ++s2) {
				history[c][s1][s2] = 0;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0xc797
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
jge 0xc78a
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0xc77d
movq -0x20(%rbp), %rax
addq $0x178, %rax            # imm = 0x178
movslq -0xc(%rbp), %rcx
shlq $0xe, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc741
jmp 0xc77f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc734
jmp 0xc78c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc727
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x158, %rdi            # imm = 0x158
callq 0x14c10
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x14069
movq -0x20(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x18(%rbp), %rsi
callq 0x14fb0
movq -0x20(%rbp), %rdi
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x158, %rdi            # imm = 0x158
callq 0xbce0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq 0x30(%rcx), %rax
jne 0x14059
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1405b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13ff3
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x15ff4
movl $0x1, -0xc(%rbp)
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0x184d0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jle 0x16018
movq -0x50(%rbp), %rdi
callq 0x184d0
movl %eax, -0xc(%rbp)
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
addq $0x8178, %rdi           # imm = 0x8178
callq 0x190e0
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x56d0
movq -0x60(%rbp), %rdx
leaq 0x11eed(%rip), %rsi     # 0x27f30
leaq -0x30(%rbp), %rdi
callq 0x89b0
jmp 0x1604e
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x19910
jmp 0x1605c
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x16097
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
movq -0x40(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: codeandkey[P]neocortex/src/search.cpp
// Function: neocortex::search::Search::stop()
void search::Search::stop() {
	if (control_thread.joinable()) {
		control_should_stop = true;
		control_thread.join();
		control_should_stop = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x81a0, %rdi           # imm = 0x81A0
callq 0x19690
testb $0x1, %al
jne 0x16136
jmp 0x1616d
movq -0x10(%rbp), %rdi
addq $0x81a8, %rdi           # imm = 0x81A8
movl $0x1, %esi
callq 0x19170
movq -0x10(%rbp), %rdi
addq $0x81a0, %rdi           # imm = 0x81A0
callq 0x5670
movq -0x10(%rbp), %rdi
addq $0x81a8, %rdi           # imm = 0x81A8
xorl %esi, %esi
callq 0x19170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/search.cpp
// Function: neocortex::search::Search::go(std::function<void (neocortex::search::SearchInfo)>, std::function<void (neocortex::Move)>, int, int, int, int, int, int, bool)
void search::Search::go(std::function<void(SearchInfo)> info, std::function<void(Move)> bestmove, int wtime, int btime, int winc, int binc, int depth, int movetime, bool infinite) {
	stop();

	this->wtime = wtime;
	this->btime = btime;
	this->winc = winc;
	this->binc = binc;
	this->depth = depth;
	this->movetime = movetime;
	this->infinite = infinite;

	/* Start main search thread. */
	control_should_stop = false;
	control_thread = std::thread([=] { control_worker(root, info, bestmove); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, -0xa8(%rbp)
movb 0x28(%rbp), %al
movl 0x20(%rbp), %r10d
movl 0x18(%rbp), %r10d
movl 0x10(%rbp), %r10d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x16110
movq -0xa0(%rbp), %rdi
movl -0x1c(%rbp), %esi
addq $0x81e8, %rdi           # imm = 0x81E8
callq 0x190e0
movq -0xa0(%rbp), %rdi
movl -0x20(%rbp), %esi
addq $0x81ec, %rdi           # imm = 0x81EC
callq 0x190e0
movq -0xa0(%rbp), %rdi
movl -0x24(%rbp), %esi
addq $0x81f0, %rdi           # imm = 0x81F0
callq 0x190e0
movq -0xa0(%rbp), %rdi
movl 0x10(%rbp), %esi
addq $0x81f4, %rdi           # imm = 0x81F4
callq 0x190e0
movq -0xa0(%rbp), %rdi
movl 0x18(%rbp), %esi
addq $0x81fc, %rdi           # imm = 0x81FC
callq 0x190e0
movq -0xa0(%rbp), %rdi
movl 0x20(%rbp), %esi
addq $0x81f8, %rdi           # imm = 0x81F8
callq 0x190e0
movq -0xa0(%rbp), %rdi
addq $0x8200, %rdi           # imm = 0x8200
movzbl -0x25(%rbp), %esi
andl $0x1, %esi
callq 0x19170
movq -0xa0(%rbp), %rdi
addq $0x81a8, %rdi           # imm = 0x81A8
xorl %esi, %esi
callq 0x19170
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x191a0
movq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x19250
jmp 0x162bb
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x16340
jmp 0x162ca
movq -0xa0(%rbp), %rdi
addq $0x81a0, %rdi           # imm = 0x81A0
leaq -0x30(%rbp), %rsi
callq 0x19320
leaq -0x30(%rbp), %rdi
callq 0x19020
leaq -0x78(%rbp), %rdi
callq 0x16400
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x19300
jmp 0x16331
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x16400
movq -0x80(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x650, %rsp            # imm = 0x650
movq %rdx, -0x630(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x638(%rbp)
leaq -0x624(%rbp), %rdi
callq 0xae50
movq -0x630(%rbp), %rdi
callq 0x14970
movq -0x638(%rbp), %rdi
movq -0x630(%rbp), %rsi
movl -0xc(%rbp), %edx
movq %rdi, %rax
addq $0x8198, %rax           # imm = 0x8198
movl $0xffc2f700, %ecx       # imm = 0xFFC2F700
movl $0x3d0900, %r8d         # imm = 0x3D0900
xorl %r9d, %r9d
leaq -0x624(%rbp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x16fe0
cmpq $0x0, -0x20(%rbp)
je 0x17b3c
movq -0x630(%rbp), %rdi
callq 0x14990
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x650, %rsp            # imm = 0x650
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0xc2f3(%rip), %rsi      # 0x280da
callq 0x1bf70
testb $0x1, %al
jne 0x1bdf2
jmp 0x1bdfb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1be60
movq -0x18(%rbp), %rdi
callq 0x52d0
cmpq $0x2, %rax
jne 0x1be0c
jmp 0x1be2b
leaq 0xc2c9(%rip), %rdi      # 0x280dc
leaq 0xc2d2(%rip), %rsi      # 0x280ec
movl $0x12, %edx
leaq 0xc2d5(%rip), %rcx      # 0x280fb
callq 0x5290
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5740
movq -0x18(%rbp), %rdi
movsbl (%rax), %eax
subl $0x31, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5740
movl -0x1c(%rbp), %edi
movsbl (%rax), %esi
subl $0x61, %esi
callq 0x6c20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x1bedb
leaq -0xd(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x56d0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0xc22e(%rip), %rsi      # 0x280da
callq 0x89b0
jmp 0x1beb3
leaq -0xd(%rbp), %rdi
callq 0x5480
jmp 0x1bf58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x5480
jmp 0x1bf62
movq -0x30(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0x5540
movl -0xc(%rbp), %edi
callq 0x6b80
movl %eax, -0x3c(%rbp)
jmp 0x1bef5
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %eax
addl $0x61, %eax
movsbl %al, %esi
callq 0x5250
jmp 0x1bf09
movl -0xc(%rbp), %edi
callq 0x6b30
movl %eax, -0x40(%rbp)
jmp 0x1bf16
movq -0x30(%rbp), %rdi
movl -0x40(%rbp), %eax
addl $0x31, %eax
movsbl %al, %esi
callq 0x5250
jmp 0x1bf2a
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x1bf56
jmp 0x1bf4d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5230
jmp 0x1bf62
movq -0x30(%rbp), %rdi
callq 0x5230
jmp 0x1bf58
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: codeandkey[P]neocortex/src/uci.cpp
// Function: safe_parseint(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>>>>, unsigned long)
static int safe_parseint(std::vector<std::string> parts, size_t ind) {
	if (ind >= parts.size()) {
		throw std::runtime_error("Expected argument!");
	}

	neocortex_debug("Parsing %s\n", parts[ind].c_str());

	return std::stoi(parts[ind]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x88c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jb 0x1eaf0
movl $0x10, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x99bd(%rip), %rsi      # 0x28475
callq 0x5120
jmp 0x1eabf
movq -0x60(%rbp), %rdi
movq 0x14526(%rip), %rsi     # 0x32ff0
movq 0x144c7(%rip), %rdx     # 0x32f98
callq 0x5680
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5300
jmp 0x1eb98
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x56d0
movq -0x68(%rbp), %rdx
leaq 0x9980(%rip), %rsi      # 0x28488
leaq -0x40(%rbp), %rdi
callq 0x89b0
jmp 0x1eb13
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14b30
movq %rax, %rdi
callq 0x5140
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1f9a0
jmp 0x1eb36
leaq -0x40(%rbp), %rdi
callq 0x5230
leaq -0x41(%rbp), %rdi
callq 0x5480
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14b30
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x14b50
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1eb8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5230
leaq -0x41(%rbp), %rdi
callq 0x5480
movq -0x18(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x5070
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x22ae0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x51d0
cmpq $0x0, %rax
jne 0x21cf5
movl $0x10, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x210(%rbp)
leaq 0x69c1(%rip), %rsi      # 0x28678
callq 0x5120
jmp 0x21cbe
movq -0x210(%rbp), %rdi
movq 0x11324(%rip), %rsi     # 0x32ff0
movq 0x112c5(%rip), %rdx     # 0x32f98
callq 0x5680
movq -0x210(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x5300
jmp 0x21db0
leaq -0x1e8(%rbp), %rdi
callq 0x52e0
leaq -0x1d8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq 0x6976(%rip), %rsi      # 0x2868c
leaq -0x50(%rbp), %rdi
callq 0x22e20
movq %rdx, -0x220(%rbp)
movq %rax, -0x218(%rbp)
jmp 0x21d2f
movq -0x228(%rbp), %rdi
movq -0x220(%rbp), %rax
movq -0x218(%rbp), %rcx
movq %rcx, -0x1f8(%rbp)
movq %rax, -0x1f0(%rbp)
movq -0x1f8(%rbp), %rsi
movq -0x1f0(%rbp), %rdx
callq 0x22b40
jmp 0x21d67
movq -0x208(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x5400
jmp 0x21d7c
leaq -0x1e8(%rbp), %rdi
callq 0x5310
movq -0x200(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x5310
movq -0x58(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5540
movq $0x0, -0x28(%rbp)
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x88c0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2240f
cmpq $0x0, -0x28(%rbp)
je 0x223e4
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x54f0
jmp 0x223cb
jmp 0x223e4
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5230
jmp 0x2242c
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14b30
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x54f0
jmp 0x223ff
jmp 0x22401
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x22398
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x22422
movq -0x48(%rbp), %rdi
callq 0x5230
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)