LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1db0, %rsp           # imm = 0x1DB0
movb 0x19320(%rip), %al      # 0x3cda1
xorb $-0x1, %al
testb $0x1, %al
jne 0x23a89
jmp 0x23a8b
jmp 0x23aaa
leaq 0x4c0c(%rip), %rdi      # 0x2869e
leaq 0x4c1a(%rip), %rsi      # 0x286b3
movl $0x16, %edx
leaq 0x4c1e(%rip), %rcx      # 0x286c3
callq 0x5290
leaq -0x1388(%rbp), %rdi
movq %rdi, -0x1d90(%rbp)
callq 0x23e30
movq -0x1d90(%rbp), %rdi
callq 0x23ed0
movl %eax, -0x1d84(%rbp)
jmp 0x23ad1
movl -0x1d84(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x1d50(%rbp), %rdi
callq 0x23ef0
jmp 0x23ae9
leaq -0x1d70(%rbp), %rdi
callq 0x23f20
jmp 0x23af7
movl $0x0, -0x1d74(%rbp)
cmpl $0x40, -0x1d74(%rbp)
jge 0x23bae
movl $0x0, -0x1d78(%rbp)
cmpl $0xc, -0x1d78(%rbp)
jge 0x23b98
leaq -0x1d70(%rbp), %rdi
leaq -0x1d50(%rbp), %rsi
callq 0x23f50
movq %rax, -0x1d98(%rbp)
jmp 0x23b3d
movq -0x1d98(%rbp), %rdx
movslq -0x1d74(%rbp), %rcx
leaq 0x1925e(%rip), %rax     # 0x3cdb0
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movslq -0x1d78(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1d78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d78(%rbp)
jmp 0x23b18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d58(%rbp)
movl %eax, -0x1d5c(%rbp)
leaq -0x1388(%rbp), %rdi
callq 0x23f80
jmp 0x23ca6
jmp 0x23b9a
movl -0x1d74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d74(%rbp)
jmp 0x23b01
movl $0x0, -0x1d7c(%rbp)
cmpl $0x10, -0x1d7c(%rbp)
jge 0x23c07
leaq -0x1d70(%rbp), %rdi
leaq -0x1d50(%rbp), %rsi
callq 0x23f50
movq %rax, -0x1da0(%rbp)
jmp 0x23bdd
movq -0x1da0(%rbp), %rdx
movslq -0x1d7c(%rbp), %rcx
leaq 0x1a9be(%rip), %rax     # 0x3e5b0
movq %rdx, (%rax,%rcx,8)
movl -0x1d7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d7c(%rbp)
jmp 0x23bb8
movl $0x0, -0x1d80(%rbp)
cmpl $0x8, -0x1d80(%rbp)
jge 0x23c60
leaq -0x1d70(%rbp), %rdi
leaq -0x1d50(%rbp), %rsi
callq 0x23f50
movq %rax, -0x1da8(%rbp)
jmp 0x23c36
movq -0x1da8(%rbp), %rdx
movslq -0x1d80(%rbp), %rcx
leaq 0x1a9e5(%rip), %rax     # 0x3e630
movq %rdx, (%rax,%rcx,8)
movl -0x1d80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d80(%rbp)
jmp 0x23c11
leaq -0x1d70(%rbp), %rdi
leaq -0x1d50(%rbp), %rsi
callq 0x23f50
movq %rax, -0x1db0(%rbp)
jmp 0x23c7c
movq -0x1db0(%rbp), %rax
movq %rax, 0x1a9e6(%rip)     # 0x3e670
movb $0x1, 0x19110(%rip)     # 0x3cda1
leaq -0x1388(%rbp), %rdi
callq 0x23f80
addq $0x1db0, %rsp           # imm = 0x1DB0
popq %rbp
retq
movq -0x1d58(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, %edi
callq 0xa5f0
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x56d0
movq -0x80(%rbp), %rdx
leaq 0x4130(%rip), %rsi      # 0x287ab
leaq -0x30(%rbp), %rdi
callq 0x89b0
jmp 0x24686
leaq -0x30(%rbp), %rdi
callq 0x248a0
jmp 0x24691
leaq -0x30(%rbp), %rdi
callq 0x5230
leaq -0x31(%rbp), %rdi
callq 0x5480
callq 0x6d40
callq 0x23a70
callq 0x5bf0
movl $0x200, %edi            # imm = 0x200
callq 0x1bfa0
callq 0x1ca10
jmp 0x246c3
jmp 0x2477d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x246eb
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 0x247bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x247bd
movq -0x40(%rbp), %rdi
callq 0x5130
movq %rax, -0x50(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x56d0
movq -0x88(%rbp), %rdx
leaq 0x408c(%rip), %rsi      # 0x287cc
leaq -0x70(%rbp), %rdi
callq 0x89b0
jmp 0x2474b
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x24ab0
jmp 0x24766
leaq -0x70(%rbp), %rdi
callq 0x5230
leaq -0x71(%rbp), %rdi
callq 0x5480
callq 0x5640
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x247ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5230
leaq -0x71(%rbp), %rdi
callq 0x5480
callq 0x5640
jmp 0x247bb
jmp 0x247bd
movq -0x40(%rbp), %rdi
callq 0x56c0
movq %rax, %rdi
callq 0x90c0
nop
// File: 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
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2220
movq -0xa8(%rbp), %rdx
leaq 0x35d9(%rip), %rsi      # 0x6009
leaq -0x28(%rbp), %rdi
callq 0x2ce0
jmp 0x2a3b
leaq -0x29(%rbp), %rdi
callq 0x2160
leaq -0x59(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2e90
movq -0xb0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x3100
jmp 0x2a6b
leaq -0x59(%rbp), %rdi
callq 0x3050
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2e90
movq -0xb8(%rbp), %rdx
leaq -0x78(%rbp), %rdi
movl $0x3, %esi
callq 0x3100
jmp 0x2a9b
leaq -0x79(%rbp), %rdi
callq 0x3050
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xe0(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x30c0
movq -0xe0(%rbp), %rsi
movl $0x2, (%rax)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x30c0
movq -0xc8(%rbp), %rdi
movl $0x4, (%rax)
movl $0x1, %esi
movq %rsi, -0xd8(%rbp)
callq 0x30c0
movq -0xd8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
movl $0x5, (%rax)
callq 0x30c0
movq -0xc8(%rbp), %rdi
movl $0x5, (%rax)
movl $0x2, %esi
movq %rsi, -0xd0(%rbp)
callq 0x30c0
movq -0xd0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
movl $0x0, (%rax)
callq 0x30c0
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movl $0x6, (%rax)
leaq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23a0
jmp 0x2b70
movl $0x0, -0x9c(%rbp)
movslq -0x9c(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x30e0
movq %rax, %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
jae 0x2c6a
movslq -0x9c(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x30c0
movl (%rax), %esi
movq 0x7415(%rip), %rdi      # 0x9fd8
callq 0x2200
movq %rax, -0xf0(%rbp)
jmp 0x2bd1
movq -0xf0(%rbp), %rdi
movl $0x2c, %esi
callq 0x2190
jmp 0x2be4
jmp 0x2be6
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x2b7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2160
jmp 0x2ccb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x3050
jmp 0x2cc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x3050
jmp 0x2cb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2cb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2ff0
jmp 0x2cb0
movq 0x7367(%rip), %rdi      # 0x9fd8
movl $0xa, %esi
callq 0x2190
jmp 0x2c7d
leaq -0x98(%rbp), %rdi
callq 0x2ff0
leaq -0x78(%rbp), %rdi
callq 0x2ff0
leaq -0x58(%rbp), %rdi
callq 0x2ff0
leaq -0x28(%rbp), %rdi
callq 0x20a0
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x2ff0
leaq -0x58(%rbp), %rdi
callq 0x2ff0
leaq -0x28(%rbp), %rdi
callq 0x20a0
movq -0x38(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x222(%rip), %rsi       # 0x13d70
callq 0x122d0
movq %rax, -0x68(%rbp)
movl $0x30, %edi
callq 0x13da0
movq -0x68(%rbp), %rdi
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
callq 0x12da0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13dc0
movq -0x60(%rbp), %rdi
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x13ca0
movq %rax, %rdi
leaq 0x9f480(%rip), %rsi     # 0xb3018
callq 0x12800
movq %rax, -0x58(%rbp)
movl $0xc, %edi
callq 0x13dd0
movq -0x58(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x129c0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13df0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x121b0
movq %rax, %rdi
leaq 0x9f43d(%rip), %rsi     # 0xb301a
callq 0x12800
movq -0x10(%rbp), %rdi
callq 0x13e10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13e30
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13e60
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13e90
testb $0x1, %al
jne 0x13c1c
jmp 0x13c62
leaq -0x30(%rbp), %rdi
callq 0x13ed0
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x2, %edi
callq 0x13dd0
movq -0x70(%rbp), %rdi
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %esi
callq 0x129c0
movq %rax, %rdi
movzbl -0x39(%rbp), %esi
callq 0x12f20
leaq -0x30(%rbp), %rdi
callq 0x13ef0
jmp 0x13c09
movq -0x8(%rbp), %rdi
leaq 0x2a3(%rip), %rsi       # 0x13f10
callq 0x122d0
movq %rax, -0x78(%rbp)
movl $0x20, %edi
callq 0x13da0
movq -0x78(%rbp), %rdi
movb %al, -0x41(%rbp)
movzbl -0x41(%rbp), %esi
callq 0x12da0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: flightaware[P]beast-splitter/./modes_message.h
// Function: modes::operator<<(std::ostream&, modes::MessageType const&)
inline std::ostream &operator<<(std::ostream &os, const MessageType &t) {
        switch (t) {
        case MessageType::MODE_AC:
            return (os << "MODE_AC");
        case MessageType::MODE_S_SHORT:
            return (os << "MODE_S_SHORT");
        case MessageType::MODE_S_LONG:
            return (os << "MODE_S_LONG");
        case MessageType::STATUS:
            return (os << "STATUS");
        case MessageType::POSITION:
            return (os << "POSITION");
        default:
            return (os << "INVALID");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x13d49
movq -0x20(%rbp), %rax
leaq 0x9f332(%rip), %rcx     # 0xb3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x9f336(%rip), %rsi     # 0xb301c
callq 0x12800
movq %rax, -0x8(%rbp)
jmp 0x13d5d
movq -0x10(%rbp), %rdi
leaq 0x9f328(%rip), %rsi     # 0xb3024
callq 0x12800
movq %rax, -0x8(%rbp)
jmp 0x13d5d
movq -0x10(%rbp), %rdi
leaq 0x9f31f(%rip), %rsi     # 0xb3031
callq 0x12800
movq %rax, -0x8(%rbp)
jmp 0x13d5d
movq -0x10(%rbp), %rdi
leaq 0x9f315(%rip), %rsi     # 0xb303d
callq 0x12800
movq %rax, -0x8(%rbp)
jmp 0x13d5d
movq -0x10(%rbp), %rdi
leaq 0x9f306(%rip), %rsi     # 0xb3044
callq 0x12800
movq %rax, -0x8(%rbp)
jmp 0x13d5d
movq -0x10(%rbp), %rdi
leaq 0x9f2f9(%rip), %rsi     # 0xb304d
callq 0x12800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x14c40
movq %rax, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
ja 0x145fc
movl $0x0, -0x4(%rbp)
jmp 0x14692
movq -0x40(%rbp), %rdi
callq 0x13e30
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x13e60
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x3, %esi
callq 0x14cf0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14c60
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
subq $0x3, %rsi
callq 0x14d30
movq -0x40(%rbp), %rdi
movzbl (%rax), %eax
shll $0x10, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
subq $0x2, %rsi
callq 0x14d30
movq -0x40(%rbp), %rdi
movzbl (%rax), %eax
shll $0x8, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x14d30
movzbl (%rax), %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x13e90
testb $0x1, %al
jne 0x14c92
jmp 0x14cd7
movl -0x14(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x13ed0
movq %rax, %rcx
movl -0x24(%rbp), %eax
movzbl (%rcx), %ecx
movl -0x14(%rbp), %edx
andl $0xff0000, %edx         # imm = 0xFF0000
shrl $0x10, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0xf6c1a(%rip), %rcx     # 0x10b8e0
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x13ef0
jmp 0x14c7f
movl -0x14(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x171a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x168e2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x171b0
movq %rax, %rcx
movb $0x1, %al
testb $0x1, (%rcx)
movb %al, -0x29(%rbp)
jne 0x168b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x171e0
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rdi
movb -0x29(%rbp), %al
movb %al, -0x2a(%rbp)
movq -0x18(%rbp), %rsi
callq 0x171b0
movb -0x2a(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16870
movq -0x20(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x20(%rcx)
movb %al, -0x2b(%rbp)
jne 0x168fb
movq -0x10(%rbp), %rax
movb 0x20(%rax), %al
movb %al, -0x2b(%rbp)
movq -0x20(%rbp), %rcx
movb -0x2b(%rbp), %al
andb $0x1, %al
movb %al, 0x20(%rcx)
movb $0x1, %al
testb $0x1, 0x21(%rcx)
movb %al, -0x2c(%rbp)
jne 0x1691c
movq -0x10(%rbp), %rax
movb 0x21(%rax), %al
movb %al, -0x2c(%rbp)
movq -0x20(%rbp), %rcx
movb -0x2c(%rbp), %al
andb $0x1, %al
movb %al, 0x21(%rcx)
movb $0x1, %al
testb $0x1, 0x22(%rcx)
movb %al, -0x2d(%rbp)
jne 0x1693d
movq -0x10(%rbp), %rax
movb 0x22(%rax), %al
movb %al, -0x2d(%rbp)
movq -0x20(%rbp), %rcx
movb -0x2d(%rbp), %al
andb $0x1, %al
movb %al, 0x22(%rcx)
movb $0x1, %al
testb $0x1, 0x23(%rcx)
movb %al, -0x2e(%rbp)
jne 0x1695e
movq -0x10(%rbp), %rax
movb 0x23(%rax), %al
movb %al, -0x2e(%rbp)
movq -0x20(%rbp), %rcx
movb -0x2e(%rbp), %al
andb $0x1, %al
movb %al, 0x23(%rcx)
movb $0x1, %al
testb $0x1, 0x24(%rcx)
movb %al, -0x2f(%rbp)
jne 0x1697f
movq -0x10(%rbp), %rax
movb 0x24(%rax), %al
movb %al, -0x2f(%rbp)
movq -0x20(%rbp), %rcx
movb -0x2f(%rbp), %al
andb $0x1, %al
movb %al, 0x24(%rcx)
movb $0x1, %al
testb $0x1, 0x25(%rcx)
movb %al, -0x30(%rbp)
jne 0x169a0
movq -0x10(%rbp), %rax
movb 0x25(%rax), %al
movb %al, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movb -0x30(%rbp), %al
andb $0x1, %al
movb %al, 0x25(%rcx)
movb $0x1, %al
testb $0x1, 0x26(%rcx)
movb %al, -0x31(%rbp)
jne 0x169c1
movq -0x10(%rbp), %rax
movb 0x26(%rax), %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x26(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9c4f1(%rip), %rsi     # 0xb309c
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x16bca
movq -0x8(%rbp), %rdi
leaq 0x9c4e0(%rip), %rsi     # 0xb30a5
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x21(%rax)
je 0x16be4
movq -0x8(%rbp), %rdi
leaq 0x9c4ce(%rip), %rsi     # 0xb30ad
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x16bfe
movq -0x8(%rbp), %rdi
leaq 0x9c4bc(%rip), %rsi     # 0xb30b5
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x23(%rax)
je 0x16c18
movq -0x8(%rbp), %rdi
leaq 0x9c4a7(%rip), %rsi     # 0xb30ba
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0x16c32
movq -0x8(%rbp), %rdi
leaq 0x9c495(%rip), %rsi     # 0xb30c2
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x25(%rax)
je 0x16c4c
movq -0x8(%rbp), %rdi
leaq 0x9c480(%rip), %rsi     # 0xb30c7
callq 0x12800
movq -0x10(%rbp), %rax
testb $0x1, 0x26(%rax)
je 0x16c66
movq -0x8(%rbp), %rdi
leaq 0x9c470(%rip), %rsi     # 0xb30d1
callq 0x12800
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x171a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x16cc9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x171e0
testb $0x1, (%rax)
je 0x16cb9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x121b0
movq %rax, %rdi
leaq 0x9e6f8(%rip), %rsi     # 0xb53ac
callq 0x12800
jmp 0x16cbb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16c6e
movq -0x8(%rbp), %rdi
leaq 0x9f37a(%rip), %rsi     # 0xb604e
callq 0x12800
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movl (%rcx), %eax
movl %eax, %edx
incl %edx
movl %edx, (%rcx)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x17310
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x1f(%rax), %rcx
movq %rcx, -0x29(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, -0x38(%rbp)
movups %xmm0, -0x48(%rbp)
movb $0x0, -0x21(%rbp)
addq $0x28, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x173c0
movq %rax, -0x80(%rbp)
jmp 0x16dcf
movq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x174a0
leaq -0x68(%rbp), %rdi
callq 0x174f0
movq -0x88(%rbp), %rdi
callq 0x16e20
movl -0x1c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x174f0
movq -0x70(%rbp), %rdi
callq 0x12f70
nopl (%rax,%rax)
// File: flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::FilterDistributor::update_upstream_filter()
void FilterDistributor::update_upstream_filter() {
        if (!filter_notifier)
            return;

        Filter f;
        for (auto i : clients) {
            client &c = i.second;
            if (c.deleted)
                continue;
            f.inplace_combine(c.filter);
        }

        filter_notifier(f);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x8, %rdi
callq 0x17800
testb $0x1, %al
jne 0x16e4c
jmp 0x16f33
leaq -0x2f(%rbp), %rdi
callq 0x16810
movq -0xb0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x175c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17570
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x175f0
testb $0x1, %al
jne 0x16e94
jmp 0x16f1f
leaq -0x40(%rbp), %rdi
callq 0x17820
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x17840
leaq -0x98(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
testb $0x1, 0x47(%rax)
je 0x16ed7
movl $0x3, -0xa4(%rbp)
jmp 0x16ef5
movq -0xa0(%rbp), %rsi
addq $0x20, %rsi
leaq -0x2f(%rbp), %rdi
callq 0x16850
movl $0x0, -0xa4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x17880
movl -0xa4(%rbp), %eax
testl %eax, %eax
je 0x16f0f
jmp 0x16f0d
jmp 0x16f11
jmp 0x16f11
leaq -0x40(%rbp), %rdi
callq 0x177d0
jmp 0x16e7e
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
leaq -0x2f(%rbp), %rsi
callq 0x178a0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x28, %rdi
leaq -0xc(%rbp), %rsi
callq 0x17510
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x17570
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17540
testb $0x1, %al
jne 0x16f90
jmp 0x16f92
jmp 0x16fe7
leaq -0x20(%rbp), %rdi
callq 0x175a0
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x47(%rax)
je 0x16faf
jmp 0x16fe7
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x16a20
testb $0x1, %al
jne 0x16fc6
jmp 0x16fc8
jmp 0x16fe7
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movl $0x27, %edx
callq 0x12700
movq -0x38(%rbp), %rdi
callq 0x16e20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
leaq -0xc(%rbp), %rsi
callq 0x17510
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x17570
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17540
testb $0x1, %al
jne 0x1703c
jmp 0x1703e
jmp 0x1706c
leaq -0x18(%rbp), %rdi
callq 0x175a0
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x47(%rax)
je 0x1705b
jmp 0x1706c
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movb $0x1, 0x47(%rax)
callq 0x16e20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x28, %rdi
callq 0x175c0
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x17570
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x175f0
testb $0x1, %al
jne 0x170cc
jmp 0x17151
leaq -0x18(%rbp), %rdi
callq 0x175a0
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x47(%rax)
jne 0x1710b
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x17620
testb $0x1, %al
jne 0x170fe
jmp 0x1710b
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17710
movq -0x28(%rbp), %rax
testb $0x1, 0x47(%rax)
je 0x17143
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17790
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x17750
movq %rax, -0x38(%rbp)
jmp 0x1714c
leaq -0x18(%rbp), %rdi
callq 0x177d0
jmp 0x170a5
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: flightaware[P]beast-splitter/./modes_filter.h
// Function: modes::Filter::operator()(modes::Message const&) const
bool operator()(const Message &message) const {
            switch (message.type()) {
            case MessageType::MODE_AC:
                return receive_modeac;
            case MessageType::STATUS:
                return receive_status;
            case MessageType::MODE_S_SHORT:
            case MessageType::MODE_S_LONG:
                if (!receive_df[message.df()])
                    return false;
                if (!receive_bad_crc && !receive_verbatim && message.crc_bad()) {
                    if (!receive_fec || !message.crc_correctable())
                        return false;
                }
                return true;
            case MessageType::POSITION:
                return receive_position;

            default:
                // what is this?
                return false;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13dc0
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x176fb
movq -0x20(%rbp), %rax
leaq 0x9ba2b(%rip), %rcx     # 0xb3088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x176ff
movq -0x28(%rbp), %rax
movb 0x23(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x176ff
movq -0x18(%rbp), %rdi
callq 0x17c70
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0x171e0
testb $0x1, (%rax)
jne 0x176a5
movb $0x0, -0x1(%rbp)
jmp 0x176ff
movq -0x28(%rbp), %rax
testb $0x1, 0x21(%rax)
jne 0x176e7
movq -0x28(%rbp), %rax
testb $0x1, 0x26(%rax)
jne 0x176e7
movq -0x18(%rbp), %rdi
callq 0x17cc0
testb $0x1, %al
jne 0x176c8
jmp 0x176e7
movq -0x28(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x176df
movq -0x18(%rbp), %rdi
callq 0x17d40
testb $0x1, %al
jne 0x176e5
movb $0x0, -0x1(%rbp)
jmp 0x176ff
jmp 0x176e7
movb $0x1, -0x1(%rbp)
jmp 0x176ff
movq -0x28(%rbp), %rax
movb 0x25(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x176ff
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: flightaware[P]beast-splitter/./modes_message.h
// Function: modes::Message::df() const
int df() const {
            switch (m_type) {
            case MessageType::MODE_S_SHORT:
            case MessageType::MODE_S_LONG:
                return (m_data[0] >> 3) & 31;
            default:
                return -1;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0x17caf
jmp 0x17c90
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14d30
movzbl (%rax), %eax
sarl $0x3, %eax
andl $0x1f, %eax
movl %eax, -0x4(%rbp)
jmp 0x17cb6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x17c70
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $0xb, %eax
je 0x17cf2
jmp 0x17ce5
movl -0x14(%rbp), %eax
addl $-0x11, %eax
subl $0x2, %eax
jb 0x17d0d
jmp 0x17d23
movq -0x20(%rbp), %rdi
callq 0x17d70
andl $0xffff80, %eax         # imm = 0xFFFF80
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x17d27
movq -0x20(%rbp), %rdi
callq 0x17d70
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x17d27
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $-0x2, 0x34(%rax)
jne 0x17e6f
movq -0x10(%rbp), %rdi
callq 0x17c70
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $0xb, %eax
je 0x17e2c
jmp 0x17e1f
movl -0x14(%rbp), %eax
addl $-0x11, %eax
subl $0x2, %eax
jb 0x17e47
jmp 0x17e62
movq -0x10(%rbp), %rdi
callq 0x17d70
movl %eax, %edi
callq 0x17e80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
jmp 0x17e6d
movq -0x10(%rbp), %rdi
callq 0x17d70
movl %eax, %edi
callq 0x17f00
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
jmp 0x17e6d
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
jmp 0x17e6f
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xf3ece(%rip), %rdi     # 0x10bd60
callq 0x17f80
testb $0x1, %al
jne 0x17e9d
jmp 0x17ea2
callq 0x14080
leaq 0xf3eb7(%rip), %rdi     # 0x10bd60
leaq -0x4(%rbp), %rsi
callq 0x17fa0
movq %rax, -0x10(%rbp)
leaq 0xf3ea3(%rip), %rdi     # 0x10bd60
callq 0x158c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17fd0
testb $0x1, %al
jne 0x17ed9
jmp 0x17eea
leaq -0x10(%rbp), %rdi
callq 0x18000
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x17ef4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x17ef4
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xf3e7e(%rip), %rdi     # 0x10bd90
callq 0x17f80
testb $0x1, %al
jne 0x17f1d
jmp 0x17f22
callq 0x14080
leaq 0xf3e67(%rip), %rdi     # 0x10bd90
leaq -0x4(%rbp), %rsi
callq 0x17fa0
movq %rax, -0x10(%rbp)
leaq 0xf3e53(%rip), %rdi     # 0x10bd90
callq 0x158c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17fd0
testb $0x1, %al
jne 0x17f59
jmp 0x17f6a
leaq -0x10(%rbp), %rdi
callq 0x18000
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x17f74
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x17f74
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: flightaware[P]beast-splitter/beast_settings.cc
// Function: beast::Settings::Settings(modes::Filter const&)
Settings::Settings(const modes::Filter &filter) : filter_11_17_18(true), crc_disable(filter.receive_bad_crc), gps_timestamps(filter.receive_gps_timestamps), fec_disable(!filter.receive_fec), modeac_enable(filter.receive_modeac), filter_0_4_5(!filter.receive_df[0] && !filter.receive_df[4] && filter.receive_df[5]) {
        for (auto i = 0; i < 32; ++i) {
            if (filter.receive_df[i] && i != 11 && i != 17 && i != 18) {
                filter_11_17_18 = false;
                break;
            }
        }

        // only enable verbatim if someone downstream requested it; otherwise
        // leave it as DONTCARE to avoid generating 'v'-setting messages if we
        // can avoid it
        if (filter.receive_verbatim)
            verbatim = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1ad10
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
callq 0x1ad30
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x1aef0
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
callq 0x1ad70
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movb 0x21(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1af50
movq -0x28(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1af80
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x1add0
movq -0x28(%rbp), %rdi
addq $0x1c, %rdi
movq -0x10(%rbp), %rax
movb 0x22(%rax), %al
xorb $-0x1, %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x1afe0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1b010
movq -0x28(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x171e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0x15(%rbp)
jne 0x19b81
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x171e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0x15(%rbp)
jne 0x19b81
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x171e0
movb (%rax), %al
movb %al, -0x15(%rbp)
movq -0x20(%rbp), %rdi
movb -0x15(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b040
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x1ae50
movq -0x28(%rbp), %rdi
addq $0x2c, %rdi
callq 0x1ae70
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x19bfc
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x171e0
testb $0x1, (%rax)
je 0x19bef
cmpl $0xb, -0x14(%rbp)
je 0x19bef
cmpl $0x11, -0x14(%rbp)
je 0x19bef
cmpl $0x12, -0x14(%rbp)
je 0x19bef
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x1b070
jmp 0x19bfc
jmp 0x19bf1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19bb4
movq -0x10(%rbp), %rax
testb $0x1, 0x26(%rax)
je 0x19c18
movq -0x28(%rbp), %rdi
addq $0x2c, %rdi
movl $0x1, %esi
callq 0x1b0a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movl $0x30, %edx
callq 0x12700
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
addq $0x4, %rdi
callq 0x1b380
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x1b3b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0xc, %rdi
callq 0x1b3e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x1b410
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x14, %rsi
addq $0x14, %rdi
callq 0x1b440
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x1b470
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c, %rsi
addq $0x1c, %rdi
callq 0x1b4a0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x1b4d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x24, %rsi
addq $0x24, %rdi
callq 0x1b500
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b530
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2c, %rsi
addq $0x2c, %rdi
callq 0x1b560
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x16810
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1b610
testb $0x1, %al
jne 0x1a227
jmp 0x1a26d
movq -0x28(%rbp), %rdi
movb $0x0, -0x9(%rbp)
leaq -0x9(%rbp), %rsi
callq 0x17160
movq -0x28(%rbp), %rdi
movl $0xb, %esi
callq 0x171b0
movq -0x28(%rbp), %rdi
movb $0x1, (%rax)
movl $0x11, %esi
callq 0x171b0
movq -0x28(%rbp), %rdi
movb $0x1, (%rax)
movl $0x12, %esi
callq 0x171b0
movb $0x1, (%rax)
jmp 0x1a2c5
movq -0x28(%rbp), %rdi
movb $0x1, -0xa(%rbp)
leaq -0xa(%rbp), %rsi
callq 0x17160
movq -0x18(%rbp), %rdi
addq $0x24, %rdi
callq 0x1b7d0
testb $0x1, %al
jne 0x1a291
jmp 0x1a2c3
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x171b0
movq -0x28(%rbp), %rdi
movb $0x0, (%rax)
movl $0x4, %esi
callq 0x171b0
movq -0x28(%rbp), %rdi
movb $0x0, (%rax)
movl $0x5, %esi
callq 0x171b0
movb $0x0, (%rax)
jmp 0x1a2c5
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b790
movq -0x18(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
addq $0x10, %rdi
callq 0x1b690
movq -0x18(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x21(%rax)
addq $0x1c, %rdi
callq 0x1b810
movq -0x18(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x22(%rax)
callq 0x1b300
movq -0x18(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x23(%rax)
callq 0x1b300
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1a34f
movq -0x18(%rbp), %rdi
addq $0x14, %rdi
callq 0x1b850
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movb -0x29(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x24(%rax)
addq $0x28, %rdi
callq 0x1b870
movq -0x18(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x25(%rax)
addq $0x2c, %rdi
callq 0x1b8b0
movq -0x28(%rbp), %rcx
movb %al, %dl
movq -0x20(%rbp), %rax
andb $0x1, %dl
movb %dl, 0x26(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x19860
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0x1b5d0
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b160
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1b610
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b070
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
callq 0x1b650
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b190
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b690
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b1c0
movq -0x20(%rbp), %rdi
addq $0x14, %rdi
callq 0x1b6d0
movq -0x18(%rbp), %rdi
addq $0x14, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b1f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1b710
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b220
movq -0x20(%rbp), %rdi
addq $0x1c, %rdi
callq 0x1b750
movq -0x18(%rbp), %rdi
addq $0x1c, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b250
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b790
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b280
movq -0x20(%rbp), %rdi
callq 0x1b930
movq -0x18(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b130
movq -0x20(%rbp), %rdi
addq $0x24, %rdi
callq 0x1b7d0
movq -0x18(%rbp), %rdi
addq $0x24, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b2b0
movq -0x20(%rbp), %rdi
addq $0x2c, %rdi
callq 0x1b8b0
movq -0x18(%rbp), %rdi
addq $0x2c, %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1b0a0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c8f0
testb $0x1, %al
jne 0x1bb0f
jmp 0x1bb23
movq -0x10(%rbp), %rdi
movl $0x56, %esi
callq 0x12a00
movq %rax, -0x8(%rbp)
jmp 0x1bb4e
movq -0x18(%rbp), %rdi
callq 0x1ca10
testb $0x1, %al
jne 0x1bb32
jmp 0x1bb46
movq -0x10(%rbp), %rdi
movl $0x76, %esi
callq 0x12a00
movq %rax, -0x8(%rbp)
jmp 0x1bb4e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)