LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/codeandkey[P]neocortex/src/main.cpp
// Function: main
int main(int argc, char** argv) {
#ifdef NEOCORTEX_DEBUG
	log::set_level(log::DEBUG);
#endif

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

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

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

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x3, %edi
callq 0x76a0
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4968(%rip), %rsi      # 0x1b75d
leaq 0x4981(%rip), %rdx      # 0x1b77d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x70d8
movq %rbx, %rdi
callq 0x16f0c
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16e28
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42b0
callq 0x585c
callq 0x16890
callq 0x4f9c
movl $0x200, %edi            # imm = 0x200
callq 0x12274
callq 0x12758
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x16f04
movq %rbx, %rdi
callq 0x40e0
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4907(%rip), %rsi      # 0x1b77e
leaq 0x4918(%rip), %rdx      # 0x1b796
leaq 0x8(%rsp), %rdi
callq 0x70d8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1706f
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x16eb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
callq 0x4470
jmp 0x16e46
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x16edb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42b0
jmp 0x16edb
movq %rax, %rbx
callq 0x4470
jmp 0x16f04
movq %rax, %rdi
callq 0x11bad
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16f04
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42b0
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O3/zengfenfei[P]codility/src/GenomicRangeQuery.cpp
// Function: main
int main() {
	string s = "CAGCCTA";
	vector<int> P(3), Q(3);
	P[0] = 2;
	Q[0] = 4;
	P[1] = 5;
	Q[1] = 5;
	P[2] = 0;
	Q[2] = 6;
	vector<int> res = solution(s, P, Q);
	for (int i = 0; i < res.size(); i++) {
		cout << res[i] << ',';
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x9ed(%rip), %rsi       # 0x2009
leaq 0x9ed(%rip), %rdx       # 0x2010
leaq -0x68(%rbp), %rdi
callq 0x1ac8
movl $0xc, %edi
callq 0x10e0
movq %rax, %rbx
movq %rax, -0x80(%rbp)
addq $0xc, %rax
movq %rax, -0x70(%rbp)
movl $0x0, (%rbx)
movq $0x0, 0x4(%rbx)
movq %rax, -0x78(%rbp)
movl $0xc, %edi
callq 0x10e0
movq %rax, %r14
leaq -0x98(%rbp), %rcx
movq %rax, (%rcx)
addq $0xc, %rax
movq %rax, 0x10(%rcx)
movabsq $0x600000005, %rdx      # imm = 0x600000005
movq %rdx, 0x4(%r14)
movq %rax, 0x8(%rcx)
movl $0x2, (%rbx)
movl $0x4, (%r14)
movq $0x5, 0x4(%rbx)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x12fc
movq -0x48(%rbp), %rax
cmpq %rax, -0x40(%rbp)
je 0x16fd
xorl %r13d, %r13d
movq 0x2916(%rip), %r15      # 0x3fd8
leaq -0x29(%rbp), %r12
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x1160
movb $0x2c, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
incq %r13
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x16c6
leaq -0x29(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x28cd(%rip), %rdi      # 0x3fd8
movl $0x1, %edx
callq 0x1110
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x172a
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10f0
movl $0xc, %esi
movq %r14, %rdi
callq 0x10f0
movl $0xc, %esi
movq %rbx, %rdi
callq 0x10f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x175d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x10f0
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x177f
movq %rax, %r15
jmp 0x1797
movq %rax, %r15
jmp 0x17a4
movq %rax, %r15
jmp 0x17b1
movq %rax, %r15
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x1797
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10f0
movl $0xc, %esi
movq %r14, %rdi
callq 0x10f0
movl $0xc, %esi
movq %rbx, %rdi
callq 0x10f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x17ca
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x10f0
movq %r15, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/modes_message.cc
// Function: modes::operator<<(std::ostream&, modes::Message const&)
std::ostream &operator<<(std::ostream &os, const Message &message) {
        os << std::hex << std::setfill('0') << message.type() << "@" << std::setw(12) << message.timestamp() << ":";
        for (auto b : message.data()) {
            os << std::setw(2) << (int)b;
        }
        os << std::dec << std::setfill(' ');
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rdi,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rdi,%rcx)
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %r15
cmpb $0x0, 0xe1(%rdi,%rax)
jne 0xf3d3
movq %r15, %rdi
movl $0x20, %esi
callq 0xe5f0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl (%r14), %eax
decl %eax
cmpl $0x4, %eax
ja 0xf436
leaq 0x3ec18(%rip), %rcx     # 0x4e004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3ec20(%rip), %rsi     # 0x4e01c
jmp 0xf43d
leaq 0x3ec3f(%rip), %rsi     # 0x4e044
movl $0x8, %edx
jmp 0xf442
leaq 0x3ec1e(%rip), %rsi     # 0x4e031
movl $0xb, %edx
jmp 0xf442
leaq 0x3ec1c(%rip), %rsi     # 0x4e03d
movl $0x6, %edx
jmp 0xf442
leaq 0x3ebf5(%rip), %rsi     # 0x4e024
movl $0xc, %edx
jmp 0xf442
leaq 0x3ec10(%rip), %rsi     # 0x4e04d
movl $0x7, %edx
movq %rbx, %rdi
callq 0xe730
leaq 0x3ebc7(%rip), %rsi     # 0x4e018
movl $0x1, %edx
movq %rbx, %rdi
callq 0xe730
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xe460
leaq 0x3eb99(%rip), %rsi     # 0x4e01a
movl $0x1, %edx
movq %rax, %rdi
callq 0xe730
movq 0x18(%r14), %r15
movq 0x20(%r14), %r14
cmpq %r14, %r15
je 0xf4bc
movzbl (%r15), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%rbx,%rax)
movq %rbx, %rdi
callq 0xeb10
incq %r15
jmp 0xf496
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r14
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0xf4f8
movq %r14, %rdi
movl $0x20, %esi
callq 0xe5f0
movb $0x1, 0xe1(%r14)
movb $0x20, 0xe0(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
movb $0x1, %cl
cmpb $0x0, (%rdi,%rax)
jne 0xfa79
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
cmpq $0x20, %rax
jne 0xfa6e
movzbl 0x20(%rsi), %ecx
cmpb $0x0, 0x20(%rdi)
movl $0x1, %eax
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_O3/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 0x3e4c9(%rip), %rsi     # 0x4e06c
movl $0x8, %edx
callq 0xe730
cmpb $0x1, 0x20(%r14)
jne 0xfbc8
leaq 0x3e4ba(%rip), %rsi     # 0x4e075
movl $0x7, %edx
movq %rbx, %rdi
callq 0xe730
cmpb $0x1, 0x21(%r14)
jne 0xfbe3
leaq 0x3e4a7(%rip), %rsi     # 0x4e07d
movl $0x7, %edx
movq %rbx, %rdi
callq 0xe730
cmpb $0x1, 0x22(%r14)
jne 0xfbfe
leaq 0x3e494(%rip), %rsi     # 0x4e085
movl $0x4, %edx
movq %rbx, %rdi
callq 0xe730
cmpb $0x1, 0x23(%r14)
jne 0xfc19
leaq 0x3e47e(%rip), %rsi     # 0x4e08a
movl $0x7, %edx
movq %rbx, %rdi
callq 0xe730
cmpb $0x1, 0x24(%r14)
jne 0xfc34
leaq 0x3e46b(%rip), %rsi     # 0x4e092
movl $0x4, %edx
movq %rbx, %rdi
callq 0xe730
cmpb $0x1, 0x25(%r14)
jne 0xfc4f
leaq 0x3e455(%rip), %rsi     # 0x4e097
movl $0x9, %edx
movq %rbx, %rdi
callq 0xe730
cmpb $0x0, 0x26(%r14)
je 0xfc6a
leaq 0x3e444(%rip), %rsi     # 0x4e0a1
movl $0x9, %edx
movq %rbx, %rdi
callq 0xe730
xorl %r15d, %r15d
leaq 0x40614(%rip), %r12     # 0x50288
cmpb $0x1, (%r14,%r15)
jne 0xfc96
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe460
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xe730
incq %r15
cmpq $0x20, %r15
jne 0xfc74
leaq 0x40e28(%rip), %rsi     # 0x50ace
movl $0x1, %edx
movq %rbx, %rdi
callq 0xe730
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1007e
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 0x100dc
movq %rax, %r14
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x101c6
movq 0x20(%r12), %rax
movq %rax, 0x40(%r14)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xfd9f
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xfde6
movl 0xc(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xfddd
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xfdd5
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xeb40
movq %rax, %rdi
callq 0xf7cb
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/./modes_message.h
// Function: modes::Message::crc_bad() 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:
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x10270
pushq %rax
movq 0x18(%rdi), %rax
movzbl (%rax), %eax
shrl $0x3, %eax
leal -0x11(%rax), %ecx
cmpl $0x2, %ecx
jae 0x10273
callq 0x1028e
testl %eax, %eax
jmp 0x10282
xorl %eax, %eax
retq
cmpl $0xb, %eax
jne 0x10287
callq 0x1028e
testl $0xffff80, %eax         # imm = 0xFFFF80
setne %al
jmp 0x10289
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x34(%rdi), %ebp
cmpl $-0x2, %ebp
jne 0x104a7
movq %rdi, %rbx
movl (%rdi), %eax
andl $-0x2, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x2, %eax
jne 0x104a4
movq 0x18(%rbx), %rax
movzbl (%rax), %eax
shrl $0x3, %eax
leal -0x11(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1044b
movq %rbx, %rdi
callq 0x1028e
movl %eax, %r14d
leaq 0x616ff(%rip), %r15     # 0x71b18
cmpq $0x0, 0x28(%r15)
jne 0x10425
callq 0xf50c
movq 0x10(%r15), %rcx
testq %rcx, %rcx
je 0x104a4
leaq 0x8(%r15), %rax
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x10432
jmp 0x10492
cmpl $0xb, %eax
jne 0x104a4
movq %rbx, %rdi
callq 0x1028e
movl %eax, %r14d
leaq 0x61686(%rip), %r15     # 0x71ae8
cmpq $0x0, 0x28(%r15)
jne 0x1046e
callq 0xf50c
movq 0x10(%r15), %rcx
testq %rcx, %rcx
je 0x104a4
leaq 0x8(%r15), %rax
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x1047b
addq $0x8, %r15
cmpq %r15, %rax
je 0x104a4
cmpl %r14d, 0x20(%rax)
ja 0x104a4
movl 0x24(%rax), %ebp
movl %ebp, 0x34(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10a6b
movl 0x4(%rdx), %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x10a77
movl 0x8(%rdx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0xc(%rax)
jne 0x10a83
movl 0xc(%rdx), %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x10a8f
movl 0x10(%rdx), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x14(%rax)
jne 0x10a9b
movl 0x14(%rdx), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x18(%rax)
jne 0x10aa7
movl 0x18(%rdx), %ecx
movl %ecx, 0x18(%rax)
cmpl $0x0, 0x1c(%rax)
jne 0x10ab3
movl 0x1c(%rdx), %ecx
movl %ecx, 0x1c(%rax)
cmpl $0x0, 0x20(%rax)
jne 0x10abf
movl 0x20(%rdx), %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x24(%rax)
jne 0x10acb
movl 0x24(%rdx), %ecx
movl %ecx, 0x24(%rax)
cmpl $0x0, (%rax)
jne 0x10ad4
movl (%rdx), %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x2c(%rax)
je 0x10adb
retq
movl 0x2c(%rdx), %ecx
movl %ecx, 0x2c(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfa58
cmpl $0x0, 0x8(%r14)
jle 0x10b8c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x1, 0xb(%rbx)
movl $0x12, %eax
movb $0x1, %cl
movl $0x11, %edx
jmp 0x10bb0
movaps 0x3d58d(%rip), %xmm0    # 0x4e120
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0x0, 0x24(%r14)
jle 0x10bb6
movb $0x0, (%rbx)
movl $0x5, %eax
movl $0x4, %edx
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_O3/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x0, (%rsi)
je 0x10d53
movq %rsi, %r14
movl 0x4(%rsi), %esi
testl %esi, %esi
je 0x10c40
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
movl $0x63, %edx
movl $0x43, %ecx
callq 0x10db1
cmpl $0x0, 0x8(%r14)
je 0x10c5f
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x64, %edx
movl $0x44, %ecx
callq 0x10db1
movl 0xc(%r14), %esi
testl %esi, %esi
je 0x10c7e
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
movl $0x65, %edx
movl $0x45, %ecx
callq 0x10db1
cmpl $0x0, 0x10(%r14)
je 0x10c9d
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x66, %edx
movl $0x46, %ecx
callq 0x10db1
cmpl $0x0, (%r14)
jle 0x10caf
cmpl $0x0, 0x14(%r14)
je 0x10cce
setns %al
jmp 0x10cb9
cmpl $0x0, 0x24(%r14)
je 0x10cce
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x67, %edx
movl $0x47, %ecx
callq 0x10db1
movl 0x18(%r14), %esi
testl %esi, %esi
je 0x10ced
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
movl $0x68, %edx
movl $0x48, %ecx
callq 0x10db1
cmpl $0x0, 0x1c(%r14)
je 0x10d0c
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x69, %edx
movl $0x49, %ecx
callq 0x10db1
cmpl $0x0, 0x20(%r14)
je 0x10d2b
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x6a, %edx
movl $0x4a, %ecx
callq 0x10db1
cmpl $0x0, 0x2c(%r14)
je 0x10d4a
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x76, %edx
movl $0x56, %ecx
callq 0x10db1
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0xe300
movq %rax, %r15
leaq 0x3d4dd(%rip), %rsi     # 0x4e244
movq %rax, %rdi
callq 0xe960
movq 0x6024a(%rip), %rsi     # 0x70fc0
movq 0x601fb(%rip), %rdx     # 0x70f78
movq %r15, %rdi
callq 0xeb00
movq %rax, %r14
movq %r15, %rdi
callq 0xe4b0
jmp 0x10da9
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10da9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xe650
movq %r14, %rdi
callq 0xeb40
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x28(%rdi)
movups 0x10(%rsi), %xmm0
movaps 0x3d31b(%rip), %xmm1    # 0x4e130
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 0x3d304(%rip), %xmm2    # 0x4e140
por %xmm0, %xmm2
movdqu %xmm2, 0x10(%rdi)
movdqu (%rsi), %xmm0
movdqa 0x3d2ff(%rip), %xmm1    # 0x4e150
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 0x3d2e3(%rip), %xmm2    # 0x4e160
pandn %xmm1, %xmm0
por %xmm0, %xmm2
movdqu %xmm2, (%rdi)
movq 0x20(%rsi), %xmm0
movdqa 0x3d24a(%rip), %xmm1    # 0x4e0e0
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq %rdi, %rax
cmpl $0x0, (%rsi)
jle 0x10f73
leaq 0x6(%rsp), %rsi
movb $0x56, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xe730
jmp 0x10f75
js 0x10f77
popq %rcx
retq
leaq 0x7(%rsp), %rsi
movb $0x76, (%rsi)
jmp 0x10f64
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input.cc
// Function: beast::BeastInput::connection_failed()
void BeastInput::connection_failed() {
    good_sync = false;
    autodetect_timer.cancel();

    // schedule reconnect.
    auto self(shared_from_this());
    reconnect_timer.expires_from_now(reconnect_interval);
    reconnect_timer.async_wait([this, self](const boost::system::error_code &ec) {
        if (!ec) {
            try_to_connect();
        }
    });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movb $0x0, 0x230(%rdi)
cmpb $0x1, 0xf0(%rdi)
jne 0x118d7
movq 0xe0(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0xf8(%rbx), %rdx
movq $-0x1, %rcx
callq 0x1464a
movb $0x0, 0xf0(%rbx)
leaq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x185ac
leaq 0x150(%rbx), %rdi
imulq $0xf4240, 0x18(%rbx), %rax # imm = 0xF4240
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
callq 0x13140
movq %rbx, (%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x11933
movq 0x5f65b(%rip), %rcx     # 0x70f80
cmpb $0x0, (%rcx)
je 0x1192f
incl 0x8(%rax)
jmp 0x11933
lock
incl 0x8(%rax)
movq 0x150(%rbx), %r14
movq %rsp, %rax
movq %rax, 0x30(%rsp)
movq %fs:-0x8, %rax
testq %rax, %rax
je 0x11956
movq 0x8(%rax), %rdi
jmp 0x11958
xorl %edi, %edi
movl $0x70, %esi
callq 0x136c4
movq %rax, %r15
leaq 0x158(%rbx), %r12
leaq 0x190(%rbx), %rsi
movq %rax, 0x38(%rsp)
xorl %eax, %eax
movq %rax, (%r15)
leaq 0xcf4(%rip), %rcx       # 0x12678
movq %rcx, 0x8(%r15)
movl %eax, 0x10(%r15)
movl %eax, 0x18(%r15)
movb $0x0, 0x1c(%r15)
leaq 0x5c994(%rip), %rcx     # 0x6e330
movq %rcx, 0x20(%r15)
movaps (%rsp), %xmm0
movups %xmm0, 0x28(%r15)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x38(%r15)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
addq $0x40, %rdi
callq 0x140a4
movq %r15, 0x40(%rsp)
movb $0x1, 0x160(%rbx)
movq 0x58(%r14), %rdi
addq $0x28, %r14
addq $0x168, %rbx            # imm = 0x168
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x13542
leaq 0x38(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x30(%rsp), %rdi
callq 0x128ee
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x11a18
callq 0x14590
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x11a27
callq 0x14590
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x11a44
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x128ee
jmp 0x11a4f
movq %rax, %rdi
callq 0xf7cb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x11a63
callq 0x14590
jmp 0x11a63
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x11a72
callq 0x14590
movq %rbx, %rdi
callq 0xeb40
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_serial.cc
// Function: beast::SerialInput::handle_error(boost::system::error_code const&)
void SerialInput::handle_error(const boost::system::error_code &ec) {
    if (ec == boost::asio::error::operation_aborted)
        return;

    std::cerr << what() << ": i/o error: " << ec.message() << std::endl;
    connection_failed();

    autobaud_timer.cancel();
    read_timer.cancel();
    if (port.is_open()) {
        boost::system::error_code ignored;
        port.close(ignored);
    }

    // reset autobaud state
    if (!autobaud_rates.empty()) {
        autobauding = true;
        autobaud_interval = autobaud_base_interval;
        autobaud_rate = autobaud_rates.begin();
        baud_rate = *autobaud_rate;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x7d, (%rsi)
jne 0x192fc
movq 0x8(%r14), %rax
movabsq $-0x70502de1da3a1f65, %rcx # imm = 0x8FAFD21E25C5E09B
cmpq %rcx, 0x8(%rax)
je 0x19492
movq (%rbx), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x57cbd(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r15
leaq 0x35dd1(%rip), %rsi     # 0x4f0fb
movl $0xd, %edx
movq %rax, %rdi
callq 0xe730
movq 0x8(%r14), %rsi
movl (%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0xe730
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1939d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x193b8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0x11890
cmpb $0x1, 0x360(%rbx)
jne 0x193f2
movq 0x350(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x368(%rbx), %rdx
movq $-0x1, %rcx
callq 0x1464a
movb $0x0, 0x360(%rbx)
cmpb $0x1, 0x3d0(%rbx)
jne 0x19424
movq 0x3c0(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x3d8(%rbx), %rdx
movq $-0x1, %rcx
callq 0x1464a
movb $0x0, 0x3d0(%rbx)
cmpl $-0x1, 0x2d8(%rbx)
je 0x1945e
leaq 0x2d8(%rbx), %rsi
leaq 0x20(%rsp), %rdx
movl $0x0, (%rdx)
movb $0x0, 0x4(%rdx)
leaq 0x54ee6(%rip), %rax     # 0x6e330
movq %rax, 0x8(%rdx)
movq 0x2d0(%rbx), %rdi
addq $0x28, %rdi
callq 0x1d8e0
movq 0x320(%rbx), %rax
cmpq 0x328(%rbx), %rax
je 0x19492
movb $0x1, 0x318(%rbx)
movq 0x288(%rbx), %rcx
movq %rcx, 0x348(%rbx)
movq %rax, 0x338(%rbx)
movl (%rax), %eax
movl %eax, 0x340(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1949e
movq %rax, %rbx
jmp 0x194c1
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x194c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x194dc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_serial.cc
// Function: beast::SerialInput::low_level_write(std::shared_ptr<std::vector<unsigned char, std::allocator<unsigned char>>>)
bool SerialInput::low_level_write(std::shared_ptr<helpers::bytebuf> message) {
    if (!port.is_open())
        return false;

    auto self(shared_from_this());
    boost::asio::async_write(port, boost::asio::buffer(*message), [this, self, message](boost::system::error_code ec, std::size_t len) {
        if (ec)
            handle_error(ec);
    });
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl 0x2d8(%rdi), %ebp
cmpl $-0x1, %ebp
je 0x19a80
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x185ac
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
xorl %edx, %edx
subq %rsi, %rcx
cmovneq %rsi, %rdx
movq %rbx, (%rsp)
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x199a8
movq 0x575e9(%rip), %rdi     # 0x70f80
cmpb $0x0, (%rdi)
je 0x199a1
incl 0x8(%rsi)
jmp 0x199a8
lock
incl 0x8(%rsi)
movq (%r14), %rax
addq $0x2d0, %rbx            # imm = 0x2D0
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rsi
movq %rsi, 0x20(%rsp)
xorl %r8d, %r8d
testq %rsi, %rsi
je 0x199d6
movq 0x575b4(%rip), %rdi     # 0x70f80
cmpb $0x0, (%rdi)
je 0x199da
incl 0x8(%rsi)
jmp 0x199e8
xorl %esi, %esi
jmp 0x199e8
lock
incl 0x8(%rsi)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rbx, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl %r8d, 0x20(%rdi)
movaps (%rsp), %xmm0
movups %xmm0, 0x28(%rdi)
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq %rax, 0x40(%rdi)
movq %rsi, 0x48(%rdi)
movups %xmm0, 0x18(%rsp)
leaq 0x38(%rsp), %rsi
movl %r8d, (%rsi)
movb $0x0, 0x4(%rsi)
leaq 0x548f3(%rip), %rax     # 0x6e330
movq %rax, 0x8(%rsi)
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1a33a
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x19a5f
callq 0x14590
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x19a71
callq 0x14590
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x19a80
callq 0x14590
cmpl $-0x1, %ebp
setne %al
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1a56a
movq %rsp, %rdi
callq 0x19ac0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x19ab8
callq 0x14590
movq %rbx, %rdi
callq 0xeb40
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_serial.cc
// Function: beast::SerialInput::advance_autobaud()
void SerialInput::advance_autobaud(void) {
    if (!autobauding)
        return;

    if (++autobaud_rate == autobaud_rates.end()) {
        // Ran out of rates to try. Increase the interval and start again
        std::cerr << what() << ": autobaud failed, trying again (consider specifying --fixed-baud)" << std::endl;
        autobaud_interval = std::min(autobaud_max_interval, autobaud_interval * 2);
        autobaud_rate = autobaud_rates.begin();
    }

    baud_rate = *autobaud_rate;
    try_to_connect();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x318(%rdi)
jne 0x19bd5
movq %rdi, %rbx
movq 0x338(%rdi), %rax
addq $0x4, %rax
movq %rax, 0x338(%rdi)
cmpq 0x328(%rdi), %rax
jne 0x19bc4
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5749f(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r14
leaq 0x355c1(%rip), %rsi     # 0x4f109
movl $0x42, %edx
movq %rax, %rdi
callq 0xe730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b97
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movq 0x348(%rbx), %rcx
addq %rcx, %rcx
movq 0x290(%rbx), %rdx
movq 0x320(%rbx), %rax
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, 0x348(%rbx)
movq %rax, 0x338(%rbx)
movl (%rax), %eax
movl %eax, 0x340(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19bfb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_serial.cc
// Function: beast::SerialInput::check_framing_errors()
void SerialInput::check_framing_errors(void) {
    if (!autobauding && !have_good_sync() && bad_bytes() > autobaud_restart_bytes) {
        if (!autobaud_rates.empty()) {
            // We did autobaud and picked a rate, but it's not really working, let's
            // restart autobauding.
            std::cerr << what() << ": too many framing errors seen, restarting autobauding" << std::endl;
            autobauding = true;
            advance_autobaud();
        } else {
            if (!warned_about_rate) {
                std::cerr << what() << ": many framing errors seen, is the baud rate (" << baud_rate << " bps) correct?" << std::endl;
                warned_about_rate = true;
            }
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x318(%rdi)
jne 0x19d95
movq %rdi, %rbx
cmpb $0x0, 0x230(%rdi)
jne 0x19d95
movl 0x238(%rbx), %eax
cmpl 0x29c(%rbx), %eax
jbe 0x19d95
movq 0x320(%rbx), %rax
cmpq 0x328(%rbx), %rax
je 0x19cdf
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5736b(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r14
leaq 0x354d0(%rip), %rsi     # 0x4f14c
movl $0x36, %edx
movq %rax, %rdi
callq 0xe730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19ccb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movb $0x1, 0x318(%rbx)
movq %rbx, %rdi
callq 0x19ae4
jmp 0x19d95
cmpb $0x0, 0x440(%rbx)
jne 0x19d95
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x572cd(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r14
leaq 0x35469(%rip), %rsi     # 0x4f183
movl $0x2e, %edx
movq %rax, %rdi
callq 0xe730
movl 0x340(%rbx), %esi
movq %r14, %rdi
callq 0xe460
movq %rax, %r14
leaq 0x35473(%rip), %rsi     # 0x4f1b2
movl $0xe, %edx
movq %rax, %rdi
callq 0xe730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19d8e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movb $0x1, 0x440(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x19d9f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19dbd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_serial.cc
// Function: beast::SerialInput::saw_good_message()
void SerialInput::saw_good_message() {
    BeastInput::saw_good_message();

    if (autobauding && good_messages() >= autobaud_good_messages) {
        // Accept this rate
        std::cerr << what() << ": autobaud selected " << baud_rate << " bps" << std::endl;
        autobauding = false;
        autobaud_timer.cancel();
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1224a
cmpb $0x1, 0x318(%rbx)
jne 0x19ef3
movl 0x234(%rbx), %eax
cmpl 0x298(%rbx), %eax
jb 0x19ef3
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x571a1(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r14
leaq 0x35407(%rip), %rsi     # 0x4f24d
movl $0x14, %edx
movq %rax, %rdi
callq 0xe730
movl 0x340(%rbx), %esi
movq %r14, %rdi
callq 0xe460
movq %rax, %r14
leaq 0x353f7(%rip), %rsi     # 0x4f262
movl $0x4, %edx
movq %rax, %rdi
callq 0xe730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19eba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movb $0x0, 0x318(%rbx)
cmpb $0x1, 0x360(%rbx)
jne 0x19ef3
movq 0x350(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x368(%rbx), %rdx
movq $-0x1, %rcx
callq 0x1464a
movb $0x0, 0x360(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19f19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_net.cc
// Function: beast::NetInput::connection_established(boost::asio::ip::basic_endpoint<boost::asio::ip::tcp> const&)
void NetInput::connection_established(const tcp::endpoint &endpoint) {
    std::cerr << what() << ": connected to " << endpoint << std::endl;

    BeastInput::connection_established();
    warned_about_framing = false;
    start_reading();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x524b2(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r15
leaq 0x30a2c(%rip), %rsi     # 0x4f561
movl $0xf, %edx
movq %rax, %rdi
callq 0xe730
movq %r15, %rdi
movq %r14, %rsi
callq 0x21543
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eb92
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0x113ee
xorl %eax, %eax
movb %al, 0x3f8(%rbx)
movq %rsp, %rsi
movl $0x0, (%rsi)
movb %al, 0x4(%rsi)
leaq 0x4f77b(%rip), %rax     # 0x6e330
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1ebf2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ebe9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_net.cc
// Function: beast::NetInput::handle_error(boost::system::error_code const&)
void NetInput::handle_error(const boost::system::error_code &ec) {
    if (ec == boost::asio::error::operation_aborted)
        return;

    std::cerr << what() << ": i/o error: " << ec.message() << std::endl;
    connection_failed();

    if (socket.is_open()) {
        boost::system::error_code ignored;
        socket.close(ignored);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x7d, (%rsi)
jne 0x1f19e
movq 0x8(%r14), %rax
movabsq $-0x70502de1da3a1f65, %rcx # imm = 0x8FAFD21E25C5E09B
cmpq %rcx, 0x8(%rax)
je 0x1f29f
movq (%rbx), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x51e1b(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r15
leaq 0x2ff2f(%rip), %rsi     # 0x4f0fb
movl $0xd, %edx
movq %rax, %rdi
callq 0xe730
movq 0x8(%r14), %rsi
movl (%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0xe730
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f23f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f25a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0x11890
cmpl $-0x1, 0x318(%rbx)
je 0x1f29f
leaq 0x20(%rsp), %rdx
movl $0x0, (%rdx)
movb $0x0, 0x4(%rdx)
leaq 0x4f0af(%rip), %rax     # 0x6e330
movq %rax, 0x8(%rdx)
movq 0x310(%rbx), %rdi
addq $0x318, %rbx            # imm = 0x318
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x2299e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1f2ab
movq %rax, %rbx
jmp 0x1f2ce
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f2ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xe650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f2e9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_input_net.cc
// Function: beast::NetInput::check_framing_errors()
void NetInput::check_framing_errors(void) {
    if (!have_good_sync() && bad_bytes() > 20) {
        if (!warned_about_framing) {
            std::cerr << what() << ": framing errors seen, is the peer sending Beast binary data?" << std::endl;
            warned_about_framing = true;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x230(%rdi)
jne 0x1f3a7
movq %rdi, %rbx
cmpl $0x15, 0x238(%rdi)
jb 0x1f3a7
cmpb $0x0, 0x3f8(%rbx)
jne 0x1f3a7
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x51c96(%rip), %rdi     # 0x70fd8
callq 0xe730
movq %rax, %r14
leaq 0x30220(%rip), %rsi     # 0x4f571
movl $0x3d, %edx
movq %rax, %rdi
callq 0xe730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xe5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xe040
movq %rax, %rdi
callq 0xe470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f3a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movb $0x1, 0x3f8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f3cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe650
movq %rbx, %rdi
callq 0xeb40
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketOutput::process_option_command(unsigned char)
void SocketOutput::process_option_command(uint8_t option) {
        char ch = (char)option;
        switch (ch) {
        case 'c':
        case 'C':
            settings.binary_format = (ch == 'C');
            break;
        case 'd':
        case 'D':
            settings.filter_11_17_18 = (ch == 'D');
            break;
        case 'e':
        case 'E':
            settings.avrmlat = (ch == 'E');
            break;
        case 'f':
        case 'F':
            settings.crc_disable = (ch == 'F');
            break;
        case 'g':
        case 'G':
            if (settings.radarcape)
                settings.gps_timestamps = (ch == 'G');
            else
                settings.filter_0_4_5 = (ch == 'G');
            break;
        case 'h':
        case 'H':
            settings.rts_handshake = (ch == 'H');
            break;
        case 'i':
        case 'I':
            settings.fec_disable = (ch == 'I');
            break;
        case 'j':
        case 'J':
            settings.modeac_enable = (ch == 'J');
            break;
        case 'v':
        case 'V':
            settings.verbatim = (ch == 'V');
            break;
        default:
            // unrecognized
            return;
        }
    }

// Assembly:
leal -0x43(%rsi), %eax
cmpl $0x27, %eax
ja 0x243ec
leaq 0x2b88b(%rip), %rcx     # 0x4fbb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
cmpb $0x43, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0x94(%rdi)
retq
xorl %eax, %eax
cmpb $0x49, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0xac(%rdi)
retq
xorl %eax, %eax
cmpb $0x48, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0xa8(%rdi)
retq
xorl %eax, %eax
cmpb $0x46, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0xa0(%rdi)
retq
xorl %eax, %eax
cmpb $0x47, %sil
sete %al
cmpl $0x0, 0x90(%rdi)
leal -0x1(%rax,%rax), %eax
jle 0x24408
movl %eax, 0xa4(%rdi)
retq
xorl %eax, %eax
cmpb $0x44, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0x98(%rdi)
retq
xorl %eax, %eax
cmpb $0x4a, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0xb0(%rdi)
retq
xorl %eax, %eax
cmpb $0x45, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0x9c(%rdi)
retq
cmpl $0x76, %esi
jne 0x243d4
xorl %eax, %eax
cmpb $0x56, %sil
sete %al
leal -0x1(,%rax,2), %eax
movl %eax, 0xbc(%rdi)
retq
movl %eax, 0xb4(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketOutput::write_avr(std::vector<unsigned char, std::allocator<unsigned char>> const&)
void SocketOutput::write_avr(const helpers::bytebuf &data) {
        prepare_write();

        outbuf->push_back((std::uint8_t)'*');
        for (auto b : data)
            push_back_hex(*outbuf, b);
        outbuf->push_back((std::uint8_t)';');
        outbuf->push_back((std::uint8_t)'\n');

        complete_write();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x24ce4
movq 0x100(%rbx), %rdi
leaq 0x7(%rsp), %rsi
movb $0x2a, (%rsi)
callq 0x1114e
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x24ca5
leaq 0x2b283(%rip), %r14     # 0x4fee0
movzbl (%r13), %r15d
movq 0x100(%rbx), %r12
movl %r15d, %eax
shrl $0x4, %eax
movb (%rax,%r14), %al
movb %al, 0x4(%rsp)
movq %r12, %rdi
leaq 0x4(%rsp), %rsi
callq 0x1114e
andl $0xf, %r15d
movb (%r15,%r14), %al
movb %al, 0x3(%rsp)
movq %r12, %rdi
leaq 0x3(%rsp), %rsi
callq 0x1114e
incq %r13
cmpq %rbp, %r13
jne 0x24c5d
movq 0x100(%rbx), %rdi
leaq 0x6(%rsp), %rsi
movb $0x3b, (%rsi)
callq 0x1114e
movq 0x100(%rbx), %rdi
leaq 0x5(%rsp), %rsi
movb $0xa, (%rsi)
callq 0x1114e
movq %rbx, %rdi
callq 0x24d5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq