LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r15d
movl %ecx, %r13d
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movb 0xc8(%rsp), %al
movb %al, 0xb(%rsp)
movl 0xc0(%rsp), %r14d
movl 0xb8(%rsp), %r12d
movl 0xb0(%rsp), %ebp
callq 0xd49a
xchgl %r13d, 0x81e8(%rbx)
xchgl %r15d, 0x81ec(%rbx)
movl 0xc(%rsp), %eax
xchgl %eax, 0x81f0(%rbx)
xchgl %ebp, 0x81f4(%rbx)
xchgl %r12d, 0x81fc(%rbx)
xchgl %r14d, 0x81f8(%rbx)
movb 0xb(%rsp), %al
xchgb %al, 0x8200(%rbx)
xorl %eax, %eax
xchgb %al, 0x81a8(%rbx)
leaq 0x38(%rsp), %r15
movq %rbx, -0x8(%r15)
movq %r15, %rdi
movq 0x20(%rsp), %rsi
callq 0xebe2
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq 0x28(%rsp), %rsi
callq 0xec28
andq $0x0, 0x10(%rsp)
pushq $0x50
popq %rdi
callq 0x4310
leaq 0xf6fa(%rip), %rcx      # 0x1cc88
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x48(%rsp), %rcx
testq %rcx, %rcx
je 0xd5d0
leaq 0x10(%rax), %rdx
leaq 0x48(%rsp), %rsi
movups (%r15), %xmm1
movups %xmm1, (%rdx)
movq %rcx, 0x20(%rax)
movups %xmm0, (%rsi)
movups %xmm0, 0x30(%rax)
andq $0x0, 0x40(%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x68(%rsp), %rcx
testq %rcx, %rcx
je 0xd609
movq %rax, %rdx
addq $0x30, %rdx
leaq 0x68(%rsp), %rsi
movups (%r14), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x42d0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd62d
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x81a0, %rbx           # imm = 0x81A0
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xec6e
movq %r14, %rdi
callq 0xebb2
leaq 0x30(%rsp), %rdi
callq 0xd69c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd67d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xd67d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xd69c
jmp 0xd694
movq %rax, %rbx
movq %r15, %rdi
callq 0xef5c
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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 0x700c
movq %r14, %rdi
callq 0xce34
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 0xde0e
popq %rcx
popq %rdx
testq %rbx, %rbx
je 0xe457
movq %r14, %rdi
callq 0xce3c
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_O2/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 0x6d0f(%rip), %rsi      # 0x1604a
callq 0xf402
testb %al, %al
je 0xf349
pushq $-0x1
popq %rax
popq %rbx
retq
cmpq $0x2, 0x8(%rbx)
jne 0xf366
movq (%rbx), %rax
movsbl 0x1(%rax), %edi
addl $-0x31, %edi
movsbl (%rax), %esi
addl $-0x61, %esi
popq %rbx
jmp 0x5131
leaq 0x6cdf(%rip), %rdi      # 0x1604c
leaq 0x6ce8(%rip), %rsi      # 0x1605c
leaq 0x6cf0(%rip), %rcx      # 0x1606b
pushq $0x12
popq %rdx
callq 0x41f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0xf3cf
movl %esi, %ebp
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl %esi, %edi
callq 0x50da
addb $0x61, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x42a0
movl %ebp, %edi
callq 0x50b1
addb $0x31, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x42a0
jmp 0xf3e3
leaq 0x6c74(%rip), %rsi      # 0x1604a
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6302
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4120
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebx
leaq 0x17865(%rip), %rdi     # 0x26c90
callq 0xf7aa
movq 0x17849(%rip), %rdi     # 0x26c80
testq %rdi, %rdi
je 0xf441
callq 0x4390
movq 0x17880(%rip), %rdi     # 0x26cc8
testq %rdi, %rdi
je 0xf452
callq 0x4390
movl %ebx, %eax
shll $0x14, %eax
cltq
xorl %edi, %edi
pushq $0x48
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %r14
movl %r14d, 0x1781b(%rip)    # 0x26c88
movq %rax, %r12
shlq $0x20, %r12
movslq %r14d, %r15
movq %r15, %rax
shrq $0x3b, %rax
movq %r12, %rcx
sarq $0x1b, %rcx
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x4030
testq %r12, %r12
je 0xf4d5
movq %r15, %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
leaq 0x1771c(%rip), %rdx     # 0x26bc8
movq %rax, %rsi
andq $0x0, (%rsi)
movq (%rdx), %rdi
movq %rdi, 0x8(%rsi)
movl 0x8(%rdx), %edi
movl %edi, 0x10(%rsi)
movq $0x2, 0x14(%rsi)
andl $0x0, 0x1c(%rsi)
addq $0x20, %rsi
cmpq %rcx, %rsi
jne 0xf4af
movq %rax, 0x177a4(%rip)     # 0x26c80
pushq $0x28
popq %r13
movq %r15, %rax
mulq %r13
movq %rax, %r15
pushq $-0x1
popq %rdi
cmovnoq %rax, %rdi
callq 0x4030
movq %rax, %r12
testl %r14d, %r14d
je 0xf51d
addq $-0x28, %r15
movq %r15, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %r15
addq $0x28, %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x41a0
movq %r12, 0x177a4(%rip)     # 0x26cc8
leaq 0x6b6d(%rip), %rsi      # 0x16098
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6302
movl 0x17748(%rip), %edx     # 0x26c88
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0xf610
leaq 0x10(%rsp), %rdi
callq 0x4120
leaq 0x17733(%rip), %rdi     # 0x26c90
callq 0x43b0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4120
jmp 0xf584
jmp 0xf581
movq %rax, %rbx
leaq 0x17705(%rip), %rdi     # 0x26c90
callq 0x43b0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %rsi
callq 0x4170
testq %rax, %rax
je 0x11e7a
leaq 0x40(%rsp), %rdi
callq 0x4220
leaq 0x50(%rsp), %rdi
leaq 0x4771(%rip), %rdx      # 0x165bc
leaq 0x8(%rsp), %rsi
callq 0x122ce
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x4490
leaq 0x40(%rsp), %rdi
callq 0x4250
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x4150
movq %rax, %rbx
leaq 0x471c(%rip), %rsi      # 0x165a8
movq %rax, %rdi
callq 0x40e0
movq 0xb155(%rip), %rsi      # 0x1cff0
movq 0xb0de(%rip), %rdx      # 0x1cf80
movq %rbx, %rdi
callq 0x4520
movq %rax, %r14
movq %rbx, %rdi
callq 0x4240
jmp 0x11ec4
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4250
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %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, 0x10(%rsp)
andq $0x0, 0x10(%r12)
xorl %eax, %eax
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movl %eax, %ecx
cmpq %rbx, %r13
jae 0x11fa8
movq (%r15), %rdx
movb (%rdx,%r13), %dl
cmpb %bpl, %dl
jne 0x11f9a
testl %eax, %eax
jle 0x11fa3
movb $0x0, (%r14,%rcx)
movq %r12, %rdi
movq %r14, %rsi
leaq 0xf(%rsp), %rdx
callq 0x6302
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x12436
movq %r12, %rdi
callq 0x4120
movq 0x8(%r15), %rbx
xorl %eax, %eax
jmp 0x11fa3
movslq %eax, %rcx
incl %eax
movb %dl, (%r14,%rcx)
incq %r13
jmp 0x11f51
testl %eax, %eax
jle 0x11fdc
movb $0x0, (%r14,%rcx)
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x6302
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x12436
leaq 0x18(%rsp), %rdi
callq 0x4120
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11ff4
jmp 0x12003
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4120
jmp 0x12006
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x63ce
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0x1228a
testq %r13, %r13
je 0x12276
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45c0
movq (%r15), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x45c0
incq %r13
addq $0x20, %r12
jmp 0x12250
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4120
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x14706(%rip)     # 0x26ce1
je 0x126e2
leaq 0x9d8(%rsp), %rbx
movq %rbx, %rdi
callq 0x12810
movq %rbx, %rdi
callq 0x4400
movl %eax, %esi
leaq 0x10(%rsp), %rdi
callq 0x1287e
movq %rsp, %rbx
andq $0x0, (%rbx)
orq $-0x1, 0x8(%rbx)
leaq 0x146d8(%rip), %r15     # 0x26cf0
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
cmpq $0x40, %r12
je 0x1264c
xorl %r13d, %r13d
cmpq $0xc, %r13
je 0x12643
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12866
movq %rax, (%r15,%r13,8)
incq %r13
jmp 0x12629
incq %r12
addq $0x60, %r15
jmp 0x12620
xorl %r15d, %r15d
movq %rsp, %rbx
leaq 0x10(%rsp), %r14
leaq 0x15e92(%rip), %r12     # 0x284f0
cmpq $0x80, %r15
je 0x1267c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12866
movq %rax, (%r15,%r12)
addq $0x8, %r15
jmp 0x1265e
xorl %r15d, %r15d
movq %rsp, %rbx
leaq 0x10(%rsp), %r14
leaq 0x15ee2(%rip), %r12     # 0x28570
cmpq $0x40, %r15
je 0x126a9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12866
movq %rax, (%r15,%r12)
addq $0x8, %r15
jmp 0x1268e
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x12866
movq %rax, 0x15ef3(%rip)     # 0x285b0
movb $0x1, 0x1461d(%rip)     # 0x26ce1
leaq 0x9d8(%rsp), %rdi
callq 0x1286e
addq $0x1d60, %rsp           # imm = 0x1D60
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3ee5(%rip), %rdi      # 0x165ce
leaq 0x3ef3(%rip), %rsi      # 0x165e3
leaq 0x3efc(%rip), %rcx      # 0x165f3
pushq $0x16
popq %rdx
callq 0x41f0
jmp 0x12707
jmp 0x12707
jmp 0x12707
jmp 0x12707
movq %rax, %rbx
leaq 0x9d8(%rsp), %rdi
callq 0x1286e
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
pushq $0x3
popq %rdi
callq 0x6c88
leaq 0x3c2f(%rip), %rsi      # 0x166db
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6302
leaq 0x30(%rsp), %rdi
callq 0x12b80
leaq 0x30(%rsp), %rdi
callq 0x4120
callq 0x515c
callq 0x125c4
callq 0x490c
movl $0x200, %edi            # imm = 0x200
callq 0xf410
callq 0xf8b0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x12b78
movq %rbx, %rdi
callq 0x40f0
movq %rax, %rbx
leaq 0x3bed(%rip), %rsi      # 0x166fc
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6302
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x12cdc
leaq 0x10(%rsp), %rdi
callq 0x4120
callq 0x44e0
jmp 0x12aed
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4120
jmp 0x12b57
movq %rax, %rbx
callq 0x44e0
jmp 0x12b78
movq %rax, %rdi
callq 0x653d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4120
jmp 0x12b78
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
leaq 0xaa5(%rip), %rsi       # 0x2009
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x168a
leaq -0x60(%rbp), %rdi
pushq $0x3
popq %rsi
leaq -0x48(%rbp), %rdx
callq 0x17d8
leaq -0x48(%rbp), %rdi
pushq $0x3
popq %rsi
leaq -0x30(%rbp), %rdx
callq 0x17d8
leaq -0x60(%rbp), %rdx
movq (%rdx), %rax
movl $0x2, (%rax)
leaq -0x48(%rbp), %rcx
movq (%rcx), %rsi
movl $0x4, (%rsi)
pushq $0x5
popq %rdi
movl %edi, 0x4(%rax)
movl %edi, 0x4(%rsi)
andl $0x0, 0x8(%rax)
movl $0x6, 0x8(%rsi)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x12dc
xorl %r15d, %r15d
movq 0x2a02(%rip), %rbx      # 0x3fd8
pushq $0x2c
popq %r14
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x160a
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x1170
movq %rax, %rdi
movl %r14d, %esi
callq 0x1120
incq %r15
jmp 0x15da
movq 0x29c7(%rip), %rdi      # 0x3fd8
pushq $0xa
popq %rsi
callq 0x1120
leaq -0x30(%rbp), %rdi
callq 0x1c44
leaq -0x48(%rbp), %rdi
callq 0x1c44
leaq -0x60(%rbp), %rdi
callq 0x1c44
leaq -0x80(%rbp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x165b
movq %rax, %rbx
jmp 0x1667
movq %rax, %rbx
jmp 0x1670
movq %rax, %rbx
jmp 0x1679
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1c44
leaq -0x48(%rbp), %rdi
callq 0x1c44
leaq -0x60(%rbp), %rdi
callq 0x1c44
leaq -0x80(%rbp), %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
pushq $0x30
popq %rsi
callq 0xfa50
movl (%r14), %ecx
leaq 0xc(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0x101ef
leaq 0x32ea3(%rip), %rsi     # 0x43004
movq %rax, %rdi
callq 0xf610
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0xc, 0x10(%rax,%rcx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xf480
leaq 0x32e7a(%rip), %rsi     # 0x43006
movq %rax, %rdi
callq 0xf610
movq 0x18(%r14), %r15
movq 0x20(%r14), %r14
cmpq %r14, %r15
je 0x101c2
movzbl (%r15), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%rbx,%rax)
movq %rbx, %rdi
callq 0xfb60
incq %r15
jmp 0x1019c
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0xfa50
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./crc.h
// Function: crc::message_residual(std::vector<unsigned char, std::allocator<unsigned char>>)
inline std::uint32_t message_residual(const std::vector<std::uint8_t> message) {
        std::size_t len = message.size();
        if (len <= 3) {
            return 0;
        } else {
            auto residual = crc(message.begin(), message.end() - 3);
            residual ^= (message[len - 3] << 16);
            residual ^= (message[len - 2] << 8);
            residual ^= (message[len - 1]);
            return residual;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %r14
subq %rdi, %r14
xorl %eax, %eax
cmpq $0x4, %r14
jb 0x1049a
addq $-0x3, %rsi
callq 0x1054d
movq (%rbx), %rcx
movzbl -0x3(%rcx,%r14), %edx
shll $0x10, %edx
xorl %eax, %edx
movzbl -0x2(%rcx,%r14), %esi
shll $0x8, %esi
movzbl -0x1(%rcx,%r14), %eax
xorl %esi, %eax
xorl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./crc.h
// Function: unsigned int crc::crc<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>)
std::uint32_t crc(InputIterator first, InputIterator last) {
        std::uint32_t c = 0;
        for (InputIterator i = first; i != last; ++i) {
            c = (c << 8) ^ detail::crc_table[*i ^ ((c & 0xff0000) >> 16)];
        }
        return c & 0x00FFFFFF;
    }

// Assembly:
xorl %eax, %eax
leaq 0x5d16a(%rip), %rcx     # 0x6d6c0
cmpq %rsi, %rdi
je 0x10577
movl %eax, %edx
shll $0x8, %edx
movzbl (%rdi), %r8d
shrl $0x10, %eax
movzbl %al, %eax
xorl %r8d, %eax
xorl (%rcx,%rax,4), %edx
incq %rdi
movl %edx, %eax
jmp 0x10556
andl $0xffffff, %eax         # imm = 0xFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::Filter::inplace_combine(modes::Filter const&)
void Filter::inplace_combine(const Filter &two) {
        for (std::size_t i = 0; i < receive_df.size(); ++i)
            receive_df[i] = receive_df[i] || two.receive_df[i];

        receive_modeac = receive_modeac || two.receive_modeac;
        receive_bad_crc = receive_bad_crc || two.receive_bad_crc;
        receive_fec = receive_fec || two.receive_fec;
        receive_status = receive_status || two.receive_status;
        receive_gps_timestamps = receive_gps_timestamps || two.receive_gps_timestamps;
        receive_position = receive_position || two.receive_position;
        receive_verbatim = receive_verbatim || two.receive_verbatim;
    }

// Assembly:
xorl %eax, %eax
cmpq $0x20, %rax
je 0x10917
movb $0x1, %cl
cmpb $0x0, (%rdi,%rax)
jne 0x1090f
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x108fe
movzbl 0x20(%rsi), %ecx
cmpb $0x0, 0x20(%rdi)
pushq $0x1
popq %rax
cmovnel %eax, %ecx
movb %cl, 0x20(%rdi)
movzbl 0x21(%rsi), %ecx
cmpb $0x0, 0x21(%rdi)
cmovnel %eax, %ecx
movb %cl, 0x21(%rdi)
movzbl 0x22(%rsi), %ecx
cmpb $0x0, 0x22(%rdi)
cmovnel %eax, %ecx
movb %cl, 0x22(%rdi)
movzbl 0x23(%rsi), %ecx
cmpb $0x0, 0x23(%rdi)
cmovnel %eax, %ecx
movb %cl, 0x23(%rdi)
movzbl 0x24(%rsi), %ecx
cmpb $0x0, 0x24(%rdi)
cmovnel %eax, %ecx
movb %cl, 0x24(%rdi)
movzbl 0x25(%rsi), %ecx
cmpb $0x0, 0x25(%rdi)
cmovnel %eax, %ecx
movb %cl, 0x25(%rdi)
cmpb $0x0, 0x26(%rdi)
movzbl 0x26(%rsi), %ecx
cmovnel %eax, %ecx
movb %cl, 0x26(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::operator<<(std::ostream&, modes::Filter const&)
std::ostream &operator<<(std::ostream &os, const Filter &f) {
        os << "Filter[ ";
        if (f.receive_modeac)
            os << "modeac ";
        if (f.receive_bad_crc)
            os << "badcrc ";
        if (f.receive_fec)
            os << "fec ";
        if (f.receive_status)
            os << "status ";
        if (f.receive_gps_timestamps)
            os << "gps ";
        if (f.receive_position)
            os << "position ";
        if (f.receive_verbatim)
            os << "verbatim ";
        for (std::size_t i = 0; i < f.receive_df.size(); ++i)
            if (f.receive_df[i])
                os << i << " ";
        os << "]";
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x32693(%rip), %rsi     # 0x430a0
callq 0xf610
cmpb $0x1, 0x20(%r14)
jne 0x10a28
leaq 0x32689(%rip), %rsi     # 0x430a9
movq %rbx, %rdi
callq 0xf610
cmpb $0x1, 0x21(%r14)
jne 0x10a3e
leaq 0x3267b(%rip), %rsi     # 0x430b1
movq %rbx, %rdi
callq 0xf610
cmpb $0x1, 0x22(%r14)
jne 0x10a54
leaq 0x3266d(%rip), %rsi     # 0x430b9
movq %rbx, %rdi
callq 0xf610
cmpb $0x1, 0x23(%r14)
jne 0x10a6a
leaq 0x3265c(%rip), %rsi     # 0x430be
movq %rbx, %rdi
callq 0xf610
cmpb $0x1, 0x24(%r14)
jne 0x10a80
leaq 0x3264e(%rip), %rsi     # 0x430c6
movq %rbx, %rdi
callq 0xf610
cmpb $0x1, 0x25(%r14)
jne 0x10a96
leaq 0x3263d(%rip), %rsi     # 0x430cb
movq %rbx, %rdi
callq 0xf610
cmpb $0x1, 0x26(%r14)
jne 0x10aac
leaq 0x32631(%rip), %rsi     # 0x430d5
movq %rbx, %rdi
callq 0xf610
xorl %r15d, %r15d
leaq 0x34872(%rip), %r12     # 0x45328
cmpq $0x20, %r15
je 0x10ade
cmpb $0x1, (%r14,%r15)
jne 0x10ad9
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf480
movq %rax, %rdi
movq %r12, %rsi
callq 0xf610
incq %r15
jmp 0x10ab6
leaq 0x350b9(%rip), %rsi     # 0x45b9e
movq %rbx, %rdi
callq 0xf610
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::FilterDistributor::add_client(std::function<void (modes::Message const&)>, modes::Filter const&)
FilterDistributor::handle FilterDistributor::add_client(MessageNotifier message_notifier, const Filter &initial_filter) {
        handle h = next_handle++;
        clients[h] = {message_notifier, initial_filter, false};
        update_upstream_filter();
        return h;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x10e14
movq 0x1f(%r14), %rax
movq %rax, 0x3f(%r12)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movb $0x0, 0x47(%r12)
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x10e5a
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x10ea8
movq %r14, %rdi
callq 0x11244
movq %rbx, %rdi
callq 0x10bd2
movl 0xc(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x11244
movq %rbx, %rdi
callq 0xfba0
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::FilterDistributor::update_client_filter(unsigned int, modes::Filter const&)
void FilterDistributor::update_client_filter(handle h, const Filter &new_filter) {
        auto i = clients.find(h);
        if (i == clients.end())
            return;

        client &c = i->second;
        if (c.deleted)
            return;

        if (c.filter == new_filter)
            return;

        c.filter = new_filter;
        update_upstream_filter();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x28, %rdi
movq %rax, %rsi
callq 0x115d0
movq %rax, %r15
leaq 0x30(%rbx), %rax
cmpq %rax, %r15
je 0x10ce4
cmpb $0x0, 0x6f(%r15)
jne 0x10ce4
addq $0x48, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x109a6
testb %al, %al
jne 0x10ce4
movq 0x1f(%r14), %rax
movq %rax, 0x1f(%r15)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rdi
callq 0x10bd2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::FilterDistributor::remove_client(unsigned int)
void FilterDistributor::remove_client(handle h) {
        auto i = clients.find(h);
        if (i == clients.end())
            return;

        client &c = i->second;
        if (c.deleted)
            return;

        c.deleted = true;
        update_upstream_filter();
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x28, %rdi
movq %rax, %rsi
callq 0x115d0
leaq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x10d24
cmpb $0x0, 0x6f(%rax)
jne 0x10d24
movb $0x1, 0x6f(%rax)
movq %rbx, %rdi
callq 0x10bd2
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::FilterDistributor::broadcast(modes::Message const&)
void FilterDistributor::broadcast(const Message &message) {
        for (auto i = clients.begin(); i != clients.end();) {
            client &c = i->second;
            if (!c.deleted && c.filter(message))
                c.notifier(message);

            if (c.deleted)
                clients.erase(i++);
            else
                ++i;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq 0x40(%rdi), %r13
addq $0x30, %r14
cmpq %r14, %r13
je 0x10d97
movq %r13, %r12
cmpb $0x0, 0x6f(%r13)
jne 0x10d74
leaq 0x48(%r12), %rdi
movq %rbx, %rsi
callq 0x10edc
testb %al, %al
je 0x10d74
leaq 0x28(%r12), %rdi
movq %rbx, %rsi
callq 0x10f60
movb 0x6f(%r12), %bpl
movq %r12, %rdi
callq 0xf490
movq %rax, %r13
cmpb $0x1, %bpl
jne 0x10d47
movq %r15, %rdi
movq %r12, %rsi
callq 0x11604
jmp 0x10d47
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./modes_message.h
// Function: modes::Message::crc_bad() const
bool crc_bad() const {
            switch (df()) {
            case 11:
                return (crc_residual() & 0xFFFF80) != 0;
            case 17:
            case 18:
                return crc_residual() != 0;
            default:
                return false;
            }
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x10ffc
leal -0x11(%rax), %ecx
cmpl $0x2, %ecx
jae 0x11033
movq %rbx, %rdi
callq 0x1105c
testl %eax, %eax
jmp 0x11045
cmpl $0xb, %eax
jne 0x1104a
movq %rbx, %rdi
callq 0x1105c
testl $0xffff80, %eax         # imm = 0xFFFF80
setne %al
jmp 0x1104c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./modes_message.h
// Function: modes::Message::crc_correctable_bit() const
int crc_correctable_bit() const {
            if (m_correctable_bit == -2) {
                switch (df()) {
                case 11:
                    // For DF11, don't mask off the lower 7 bits
                    // i.e. try to correct under the assumption that IID=0
                    m_correctable_bit = crc::correctable_bit_short(crc_residual());
                    break;
                case 17:
                case 18:
                    m_correctable_bit = crc::correctable_bit_long(crc_residual());
                    break;
                default:
                    m_correctable_bit = -1;
                    break;
                }
            }

            return m_correctable_bit;
        }

// Assembly:
movl 0x34(%rdi), %eax
cmpl $-0x2, %eax
jne 0x110f5
pushq %rbx
movq %rdi, %rbx
callq 0x10ffc
leal -0x11(%rax), %ecx
cmpl $0x2, %ecx
jae 0x110d8
movq %rbx, %rdi
callq 0x1105c
movl %eax, %edi
callq 0x11136
jmp 0x110f1
cmpl $0xb, %eax
jne 0x110ee
movq %rbx, %rdi
callq 0x1105c
movl %eax, %edi
callq 0x110f6
jmp 0x110f1
pushq $-0x1
popq %rax
movl %eax, 0x34(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./crc.h
// Function: crc::correctable_bit_short(unsigned int)
inline int correctable_bit_short(std::uint32_t syndrome) {
        if (detail::syndromes_short.empty())
            detail::init_syndromes();
        auto correction = detail::syndromes_short.find(syndrome);
        return (correction != detail::syndromes_short.end()) ? correction->second : -1;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, 0xc(%rsp)
leaq 0x5ca32(%rip), %rbx     # 0x6db38
cmpq $0x0, 0x28(%rbx)
jne 0x11112
callq 0x1021c
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x11176
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1112d
movl 0x24(%rax), %eax
jmp 0x11130
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./crc.h
// Function: crc::correctable_bit_long(unsigned int)
inline int correctable_bit_long(std::uint32_t syndrome) {
        if (detail::syndromes_long.empty())
            detail::init_syndromes();
        auto correction = detail::syndromes_long.find(syndrome);
        return (correction != detail::syndromes_long.end()) ? correction->second : -1;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, 0xc(%rsp)
leaq 0x5ca22(%rip), %rbx     # 0x6db68
cmpq $0x0, 0x28(%rbx)
jne 0x11152
callq 0x1021c
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x11176
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1116d
movl 0x24(%rax), %eax
jmp 0x11170
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/beast_settings.cc
// Function: beast::Settings::operator|(beast::Settings const&) const
Settings Settings::operator|(const Settings &other) const {
        Settings s = *this;
        s.binary_format |= other.binary_format;
        s.filter_11_17_18 |= other.filter_11_17_18;
        s.avrmlat |= other.avrmlat;
        s.crc_disable |= other.crc_disable;
        s.gps_timestamps |= other.gps_timestamps;
        s.rts_handshake |= other.rts_handshake;
        s.fec_disable |= other.fec_disable;
        s.modeac_enable |= other.modeac_enable;
        s.filter_0_4_5 |= other.filter_0_4_5;
        s.radarcape |= other.radarcape;
        s.verbatim |= other.verbatim;
        return s;
    }

// Assembly:
movq %rdi, %rax
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm0, (%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
cmpl $0x0, 0x4(%rdi)
jne 0x118e7
movl 0x4(%rdx), %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x118f3
movl 0x8(%rdx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0xc(%rax)
jne 0x118ff
movl 0xc(%rdx), %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x1190b
movl 0x10(%rdx), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x14(%rax)
jne 0x11917
movl 0x14(%rdx), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x18(%rax)
jne 0x11923
movl 0x18(%rdx), %ecx
movl %ecx, 0x18(%rax)
cmpl $0x0, 0x1c(%rax)
jne 0x1192f
movl 0x1c(%rdx), %ecx
movl %ecx, 0x1c(%rax)
cmpl $0x0, 0x20(%rax)
jne 0x1193b
movl 0x20(%rdx), %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x24(%rax)
jne 0x11947
movl 0x24(%rdx), %ecx
movl %ecx, 0x24(%rax)
cmpl $0x0, (%rax)
jne 0x11950
movl (%rdx), %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x2c(%rax)
je 0x11957
retq
movl 0x2c(%rdx), %ecx
movl %ecx, 0x2c(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/beast_settings.cc
// Function: beast::Settings::to_filter() const
modes::Filter Settings::to_filter() const {
        modes::Filter f;

        if (filter_11_17_18) {
            f.receive_df.fill(false);
            f.receive_df[11] = true;
            f.receive_df[17] = true;
            f.receive_df[18] = true;
        } else {
            f.receive_df.fill(true);
            if (filter_0_4_5) {
                f.receive_df[0] = false;
                f.receive_df[4] = false;
                f.receive_df[5] = false;
            }
        }

        f.receive_modeac = modeac_enable;
        f.receive_bad_crc = crc_disable;
        f.receive_fec = !fec_disable;
        f.receive_status = !radarcape.off();
        f.receive_gps_timestamps = !radarcape.off() && !gps_timestamps.off();
        f.receive_position = position_enable;
        f.receive_verbatim = verbatim;

        return f;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x108e4
cmpl $0x0, 0x8(%r14)
jle 0x11a0a
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x10da6
movb $0x1, 0xb(%rbx)
pushq $0x12
popq %rax
movb $0x1, %cl
pushq $0x11
popq %rdx
jmp 0x11a2c
leaq 0x6(%rsp), %rsi
movb $0x1, (%rsi)
movq %rbx, %rdi
callq 0x10da6
cmpl $0x0, 0x24(%r14)
jle 0x11a32
movb $0x0, (%rbx)
pushq $0x5
popq %rax
pushq $0x4
popq %rdx
xorl %ecx, %ecx
movb %cl, (%rbx,%rdx)
movb %cl, (%rbx,%rax)
cmpl $0x0, 0x20(%r14)
setg 0x20(%rbx)
cmpl $0x0, 0x10(%r14)
setg 0x21(%rbx)
cmpl $0x0, 0x1c(%r14)
setle 0x22(%rbx)
movl (%r14), %eax
testl %eax, %eax
setns 0x23(%rbx)
orl 0x14(%r14), %eax
setns 0x24(%rbx)
cmpl $0x0, 0x28(%r14)
setg 0x25(%rbx)
cmpl $0x0, 0x2c(%r14)
setg 0x26(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/beast_settings.cc
// Function: beast::Settings::to_message() const
helpers::bytebuf Settings::to_message() const {
        helpers::bytebuf msg;

        if (radarcape.dontcare())
            throw std::logic_error("need to explictly select radarcape or beast when generating settings messages");

        add_setting(msg, binary_format);
        add_setting(msg, filter_11_17_18);
        add_setting(msg, avrmlat);
        add_setting(msg, crc_disable);
        // this is a little special because of the ambiguity between radarcape and beast
        if (!radarcape && !filter_0_4_5.dontcare())
            add_setting(msg, filter_0_4_5, 'g', 'G');
        else if (radarcape && !gps_timestamps.dontcare())
            add_setting(msg, gps_timestamps, 'g', 'G');
        add_setting(msg, rts_handshake);
        add_setting(msg, fec_disable);
        add_setting(msg, modeac_enable);
        add_setting(msg, verbatim);

        return msg;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpl $0x0, (%rsi)
je 0x11ba8
movq %rsi, %r14
movl 0x4(%rsi), %esi
testl %esi, %esi
je 0x11ab5
notl %esi
shrl $0x1f, %esi
pushq $0x63
popq %rdx
pushq $0x43
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
cmpl $0x0, 0x8(%r14)
je 0x11ad0
setg %al
movzbl %al, %esi
pushq $0x64
popq %rdx
pushq $0x44
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
movl 0xc(%r14), %esi
testl %esi, %esi
je 0x11aeb
notl %esi
shrl $0x1f, %esi
pushq $0x65
popq %rdx
pushq $0x45
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
cmpl $0x0, 0x10(%r14)
je 0x11b06
setg %al
movzbl %al, %esi
pushq $0x66
popq %rdx
pushq $0x46
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
cmpl $0x0, (%r14)
jle 0x11b18
cmpl $0x0, 0x14(%r14)
je 0x11b33
setns %al
jmp 0x11b22
cmpl $0x0, 0x24(%r14)
je 0x11b33
setg %al
movzbl %al, %esi
pushq $0x67
popq %rdx
pushq $0x47
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
movl 0x18(%r14), %esi
testl %esi, %esi
je 0x11b4e
notl %esi
shrl $0x1f, %esi
pushq $0x68
popq %rdx
pushq $0x48
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
cmpl $0x0, 0x1c(%r14)
je 0x11b69
setg %al
movzbl %al, %esi
pushq $0x69
popq %rdx
pushq $0x49
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
cmpl $0x0, 0x20(%r14)
je 0x11b84
setg %al
movzbl %al, %esi
pushq $0x6a
popq %rdx
pushq $0x4a
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
cmpl $0x0, 0x2c(%r14)
je 0x11b9f
setg %al
movzbl %al, %esi
pushq $0x76
popq %rdx
pushq $0x56
popq %rcx
movq %rbx, %rdi
callq 0x11bf8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0xf320
movq %rax, %r14
leaq 0x316aa(%rip), %rsi     # 0x43264
movq %rax, %rdi
callq 0xf980
movq 0x5b3f7(%rip), %rsi     # 0x6cfc0
movq 0x5b3b0(%rip), %rdx     # 0x6cf80
movq %r14, %rdi
callq 0xfb50
movq %rax, %r15
movq %r14, %rdi
callq 0xf4c0
jmp 0x11be8
movq %rax, %r15
movq %rbx, %rdi
callq 0x105fc
movq %r15, %rdi
callq 0xfba0
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/beast_settings.cc
// Function: beast::Settings::apply_defaults() const
Settings Settings::apply_defaults() const {
        Settings s;
        s.binary_format = (bool)binary_format;
        s.filter_11_17_18 = (bool)filter_11_17_18;
        s.avrmlat = (bool)avrmlat;
        s.crc_disable = (bool)crc_disable;
        s.gps_timestamps = (bool)gps_timestamps;
        s.rts_handshake = (bool)rts_handshake;
        s.fec_disable = (bool)fec_disable;
        s.modeac_enable = (bool)modeac_enable;
        s.radarcape = (bool)radarcape;
        s.filter_0_4_5 = (bool)filter_0_4_5;
        s.verbatim = (bool)verbatim;
        return s;
    }

// Assembly:
movq %rdi, %rax
andl $0x0, 0x28(%rdi)
movups 0x10(%rsi), %xmm0
movaps 0x314f6(%rip), %xmm1    # 0x43150
movaps %xmm1, %xmm2
shufps $0x9c, %xmm0, %xmm2     # xmm2 = xmm2[0,3],xmm0[1,2]
shufps $0x9c, %xmm1, %xmm0     # xmm0 = xmm0[0,3],xmm1[1,2]
shufps $0x78, %xmm0, %xmm0     # xmm0 = xmm0[0,2,3,1]
shufps $0x78, %xmm2, %xmm2     # xmm2 = xmm2[0,2,3,1]
pcmpgtd %xmm0, %xmm2
movdqa %xmm2, %xmm0
pandn %xmm1, %xmm0
pand 0x314df(%rip), %xmm2    # 0x43160
por %xmm0, %xmm2
movdqu %xmm2, 0x10(%rdi)
movdqu (%rsi), %xmm0
movdqa 0x314da(%rip), %xmm1    # 0x43170
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
pshufd $0xe8, %xmm0, %xmm3     # xmm3 = xmm0[0,2,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm1, %xmm2     # xmm2 = xmm1[0,2,2,3]
pshufd $0xed, %xmm0, %xmm0     # xmm0 = xmm0[1,3,2,3]
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
pcmpgtd %xmm3, %xmm2
movdqa %xmm2, %xmm0
pand 0x314be(%rip), %xmm2    # 0x43180
pandn %xmm1, %xmm0
por %xmm0, %xmm2
movdqu %xmm2, (%rdi)
movq 0x20(%rsi), %xmm0
movdqa 0x31435(%rip), %xmm1    # 0x43110
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
por %xmm1, %xmm2
movq %xmm2, 0x20(%rdi)
xorl %ecx, %ecx
cmpl $0x0, 0x2c(%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x2c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/./beast_settings.h
// Function: std::ostream& beast::operator<<<false, (char)118, (char)86>(std::ostream&, beast::Settings::tristate<false, (char)118, (char)86> const&)
std::ostream &operator<<(std::ostream &os, const Settings::tristate<D, OFF, ON> &s) {
        if (s.on())
            return (os << ON);
        else if (s.off())
            return (os << OFF);
        else
            return os;
    }

// Assembly:
movb $0x56, %al
cmpl $0x0, (%rsi)
jle 0x11da4
movzbl %al, %esi
jmp 0xf770
js 0x11daa
movq %rdi, %rax
retq
movb $0x76, %al
jmp 0x11d9c
// File: /workspace/github_cpp_makefile_star2_O2/flightaware[P]beast-splitter/beast_input.cc
// Function: beast::BeastInput::connection_established()
void BeastInput::connection_established() {
    auto self(shared_from_this());

    first_message = true;
    receiving_gps_timestamps = false;
    good_sync = false;
    good_messages_count = 0;
    bad_bytes_count = 0;
    state = ParserState::READ_1A;
    current_settings = Settings();

    autodetect_timer.cancel();
    if (fixed_settings.radarcape.on())
        receiver_type = ReceiverType::RADARCAPE;
    else if (fixed_settings.radarcape.off())
        receiver_type = ReceiverType::BEAST;
    else {
        receiver_type = ReceiverType::UNKNOWN;
        autodetect_timer.expires_from_now(radarcape_detect_interval);
        autodetect_timer.async_wait([this, self](const boost::system::error_code &ec) {
            if (!ec) {
                receiver_type = ReceiverType::BEAST;
                send_settings_message();
            }
        });
    }

    send_settings_message();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1824e
movb $0x1, 0x23c(%rbx)
xorl %eax, %eax
movb %al, 0xdb(%rbx)
movb %al, 0x230(%rbx)
andq $0x0, 0x234(%rbx)
movl $0x1, 0x278(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x11654
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups 0x48(%rsp), %xmm2
movups %xmm2, 0xa4(%rbx)
movups %xmm1, 0x94(%rbx)
movups %xmm0, 0x84(%rbx)
leaq 0xe0(%rbx), %r14
movq %r14, %rdi
callq 0x13916
cmpl $0x0, 0x54(%rbx)
jle 0x121c4
movl $0x2, 0x50(%rbx)
jmp 0x122cf
js 0x122c8
andl $0x0, 0x50(%rbx)
imulq $0xf4240, 0x20(%rbx), %rax # imm = 0xF4240
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x13964
leaq 0x8(%rsp), %rdi
movq %rbx, -0x8(%rdi)
leaq 0x18(%rsp), %rsi
callq 0x14dce
movq 0xe0(%rbx), %r14
movq %rsp, %rsi
movq %rsi, 0x28(%rsp)
pushq $0x70
popq %rdi
xorl %eax, %eax
callq 0x13dbd
movq %rax, %r15
movq %rax, 0x30(%rsp)
andq $0x0, (%rax)
leaq 0xa55(%rip), %rax       # 0x12c7a
movq %rax, 0x8(%r15)
andl $0x0, 0x10(%r15)
andl $0x0, 0x18(%r15)
movb $0x0, 0x1c(%r15)
leaq 0x57f51(%rip), %rax     # 0x6a190
movq %rax, 0x20(%r15)
movaps (%rsp), %xmm0
movups %xmm0, 0x28(%r15)
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
movq %rax, 0x38(%r15)
andq $0x0, 0x8(%rsp)
leaq 0x120(%rbx), %rsi
leaq 0xe8(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x14776
movq %r15, 0x38(%rsp)
movb $0x1, 0xf0(%rbx)
movq 0x58(%r14), %rdi
addq $0x28, %r14
leaq 0xf8(%rbx), %rcx
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %r8
callq 0x13d28
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x12c6a
movq %r14, %rdi
callq 0x14e02
jmp 0x122cf
movl $0x1, 0x50(%rbx)
movq %rbx, %rdi
callq 0x12324
leaq 0x20(%rsp), %rdi
callq 0x14e02
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x12c6a
jmp 0x122ff
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x14e02
jmp 0x12312
jmp 0x1230f
jmp 0x1230f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x14e02
movq %rbx, %rdi
callq 0xfba0