LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b39
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x10b2e
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_O1/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 0x3f409(%rip), %rsi     # 0x5006c
movl $0x8, %edx
callq 0xf730
cmpb $0x1, 0x20(%r14)
jne 0x10c88
leaq 0x3f3fa(%rip), %rsi     # 0x50075
movl $0x7, %edx
movq %rbx, %rdi
callq 0xf730
cmpb $0x1, 0x21(%r14)
jne 0x10ca3
leaq 0x3f3e7(%rip), %rsi     # 0x5007d
movl $0x7, %edx
movq %rbx, %rdi
callq 0xf730
cmpb $0x1, 0x22(%r14)
jne 0x10cbe
leaq 0x3f3d4(%rip), %rsi     # 0x50085
movl $0x4, %edx
movq %rbx, %rdi
callq 0xf730
cmpb $0x1, 0x23(%r14)
jne 0x10cd9
leaq 0x3f3be(%rip), %rsi     # 0x5008a
movl $0x7, %edx
movq %rbx, %rdi
callq 0xf730
cmpb $0x1, 0x24(%r14)
jne 0x10cf4
leaq 0x3f3ab(%rip), %rsi     # 0x50092
movl $0x4, %edx
movq %rbx, %rdi
callq 0xf730
cmpb $0x1, 0x25(%r14)
jne 0x10d0f
leaq 0x3f395(%rip), %rsi     # 0x50097
movl $0x9, %edx
movq %rbx, %rdi
callq 0xf730
cmpb $0x0, 0x26(%r14)
je 0x10d2a
leaq 0x3f384(%rip), %rsi     # 0x500a1
movl $0x9, %edx
movq %rbx, %rdi
callq 0xf730
xorl %r15d, %r15d
leaq 0x41504(%rip), %r12     # 0x52238
cmpb $0x1, (%r14,%r15)
jne 0x10d56
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf460
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xf730
incq %r15
cmpq $0x20, %r15
jne 0x10d34
leaq 0x41d48(%rip), %rsi     # 0x52aae
movl $0x1, %edx
movq %rbx, %rdi
callq 0xf730
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11166
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 0x111cc
movq %rax, %r14
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x112c8
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 0x10e5f
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x10ea6
movl 0xc(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x10e9d
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x10e95
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xfb40
movq %rax, %rdi
callq 0x10886
nop
// File: /workspace/github_cpp_makefile_star2_O1/flightaware[P]beast-splitter/modes_filter.cc
// Function: modes::FilterDistributor::update_client_filter(unsigned int, modes::Filter const&)
void FilterDistributor::update_client_filter(handle h, const Filter &new_filter) {
        auto i = clients.find(h);
        if (i == clients.end())
            return;

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

        if (c.filter == new_filter)
            return;

        c.filter = new_filter;
        update_upstream_filter();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rdx
leaq 0x30(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x10fbf
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x10fa8
movq %rax, %r15
cmpq %rax, %rcx
je 0x10fd1
cmpl %esi, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %r15
cmpq %rax, %r15
je 0x10ff0
cmpb $0x0, 0x6f(%r15)
jne 0x10ff0
addq $0x48, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10bd6
testb %al, %al
je 0x10ff6
popq %rbx
popq %r14
popq %r15
retq
movq 0x1f(%r14), %rax
movq %rax, 0x1f(%r15)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10ea6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
andl $-0x2, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jne 0x11373
movq 0x18(%rdi), %rax
movzbl (%rax), %eax
shrl $0x3, %eax
pushq %rax
leal -0x11(%rax), %ecx
cmpl $0x2, %ecx
jae 0x11385
callq 0x1139e
testl %eax, %eax
jmp 0x11394
cmpl $0xb, %eax
jne 0x11399
callq 0x1139e
testl $0xffff80, %eax         # imm = 0xFFFF80
setne %al
jmp 0x1139b
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
cmpl $-0x2, 0x34(%rdi)
jne 0x115cd
movl (%rbx), %ecx
andl $-0x2, %ecx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jne 0x1150b
movq 0x18(%rbx), %rax
movzbl (%rax), %eax
shrl $0x3, %eax
leal -0x11(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1155d
movq %rbx, %rdi
callq 0x1139e
movl %eax, %ebp
leaq 0x625f4(%rip), %r15     # 0x73b18
cmpq $0x0, 0x28(%r15)
jne 0x11530
callq 0x105c8
movq 0x10(%r15), %rdx
leaq 0x8(%r15), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x115aa
leaq 0x8(%r15), %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x11544
jmp 0x115aa
cmpl $0xb, %eax
jne 0x115c9
movq %rbx, %rdi
callq 0x1139e
movl %eax, %ebp
leaq 0x62575(%rip), %r15     # 0x73ae8
cmpq $0x0, 0x28(%r15)
jne 0x1157f
callq 0x105c8
movq 0x10(%r15), %rdx
leaq 0x8(%r15), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x115aa
leaq 0x8(%r15), %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x11593
movq %rax, %rdx
cmpq %rax, %rcx
je 0x115c0
addq $0x8, %r15
cmpl %ebp, 0x20(%rcx)
cmovbeq %rcx, %r15
movq %r15, %rdx
cmpq %rax, %rdx
je 0x115c9
movl 0x24(%rdx), %r14d
movl %r14d, 0x34(%rbx)
movl 0x34(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11b9d
movl 0x4(%rdx), %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x11ba9
movl 0x8(%rdx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0xc(%rax)
jne 0x11bb5
movl 0xc(%rdx), %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x11bc1
movl 0x10(%rdx), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x14(%rax)
jne 0x11bcd
movl 0x14(%rdx), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x18(%rax)
jne 0x11bd9
movl 0x18(%rdx), %ecx
movl %ecx, 0x18(%rax)
cmpl $0x0, 0x1c(%rax)
jne 0x11be5
movl 0x1c(%rdx), %ecx
movl %ecx, 0x1c(%rax)
cmpl $0x0, 0x20(%rax)
jne 0x11bf1
movl 0x20(%rdx), %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x24(%rax)
jne 0x11bfd
movl 0x24(%rdx), %ecx
movl %ecx, 0x24(%rax)
cmpl $0x0, (%rax)
jne 0x11c06
movl (%rdx), %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x2c(%rax)
je 0x11c0d
retq
movl 0x2c(%rdx), %ecx
movl %ecx, 0x2c(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b18
cmpl $0x0, 0x8(%r14)
jle 0x11caa
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x1, 0xb(%rbx)
movl $0x12, %eax
movb $0x1, %cl
movl $0x11, %edx
jmp 0x11cce
movaps 0x3e40f(%rip), %xmm0    # 0x500c0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0x0, 0x24(%r14)
jle 0x11cd4
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_O1/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 0x11e76
movq %rsi, %r14
movl 0x4(%rsi), %esi
testl %esi, %esi
je 0x11d5e
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
movl $0x63, %edx
movl $0x43, %ecx
callq 0x11ed4
cmpl $0x0, 0x8(%r14)
je 0x11d7d
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x64, %edx
movl $0x44, %ecx
callq 0x11ed4
movl 0xc(%r14), %esi
testl %esi, %esi
je 0x11d9c
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
movl $0x65, %edx
movl $0x45, %ecx
callq 0x11ed4
cmpl $0x0, 0x10(%r14)
je 0x11dbb
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x66, %edx
movl $0x46, %ecx
callq 0x11ed4
movl (%r14), %eax
testl %eax, %eax
jle 0x11dd2
testl %eax, %eax
jle 0x11df1
cmpl $0x0, 0x14(%r14)
je 0x11df1
setns %al
jmp 0x11ddc
cmpl $0x0, 0x24(%r14)
je 0x11dc2
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x67, %edx
movl $0x47, %ecx
callq 0x11ed4
movl 0x18(%r14), %esi
testl %esi, %esi
je 0x11e10
notl %esi
shrl $0x1f, %esi
movq %rbx, %rdi
movl $0x68, %edx
movl $0x48, %ecx
callq 0x11ed4
cmpl $0x0, 0x1c(%r14)
je 0x11e2f
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x69, %edx
movl $0x49, %ecx
callq 0x11ed4
cmpl $0x0, 0x20(%r14)
je 0x11e4e
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x6a, %edx
movl $0x4a, %ecx
callq 0x11ed4
cmpl $0x0, 0x2c(%r14)
je 0x11e6d
setg %al
movzbl %al, %esi
movq %rbx, %rdi
movl $0x76, %edx
movl $0x56, %ecx
callq 0x11ed4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0xf300
movq %rax, %r15
leaq 0x3e31a(%rip), %rsi     # 0x501a4
movq %rax, %rdi
callq 0xf960
movq 0x61127(%rip), %rsi     # 0x72fc0
movq 0x610d8(%rip), %rdx     # 0x72f78
movq %r15, %rdi
callq 0xfb00
movq %rax, %r14
movq %r15, %rdi
callq 0xf4b0
jmp 0x11eb8
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x11ecc
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xf650
movq %r14, %rdi
callq 0xfb40
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x4(%rsi), %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
movl %ecx, 0x4(%rdi)
xorl %ecx, %ecx
cmpl $0x0, 0x8(%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
movl %ecx, 0xc(%rdi)
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x10(%rdi)
movl 0x14(%rsi), %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
movl %ecx, 0x14(%rdi)
movl 0x18(%rsi), %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
movl %ecx, 0x18(%rdi)
xorl %ecx, %ecx
cmpl $0x0, 0x1c(%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x1c(%rdi)
xorl %ecx, %ecx
cmpl $0x0, 0x20(%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x20(%rdi)
xorl %ecx, %ecx
cmpl $0x0, (%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, (%rdi)
xorl %ecx, %ecx
cmpl $0x0, 0x24(%rsi)
setg %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x24(%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_O1/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 0x120a1
leaq 0x6(%rsp), %rsi
movb $0x56, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xf730
jmp 0x120a3
js 0x120a5
popq %rcx
retq
leaq 0x7(%rsp), %rsi
movb $0x76, (%rsi)
jmp 0x12092
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12a15
movq 0xe0(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0xf8(%rbx), %rdx
movq $-0x1, %rcx
callq 0x15926
movb $0x0, 0xf0(%rbx)
leaq 0x8(%rbx), %rsi
leaq 0x38(%rsp), %rdi
callq 0x19994
leaq 0x150(%rbx), %rdi
imulq $0xf4240, 0x18(%rbx), %rax # imm = 0xF4240
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
callq 0x14326
movq %rbx, 0x8(%rsp)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x12a72
movq 0x6051c(%rip), %rcx     # 0x72f80
cmpb $0x0, (%rcx)
je 0x12a6e
incl 0x8(%rax)
jmp 0x12a72
lock
incl 0x8(%rax)
movq 0x150(%rbx), %r14
leaq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %fs:-0x8, %rax
testq %rax, %rax
je 0x12a97
movq 0x8(%rax), %rdi
jmp 0x12a99
xorl %edi, %edi
movl $0x70, %esi
callq 0x148a2
movq %rax, %r15
leaq 0x158(%rbx), %r12
leaq 0x190(%rbx), %rsi
movq %rax, 0x28(%rsp)
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movq %rax, (%r15)
leaq 0xd6a(%rip), %rcx       # 0x13834
movq %rcx, 0x8(%r15)
movl %eax, 0x10(%r15)
movl %eax, 0x18(%r15)
movb $0x0, 0x1c(%r15)
leaq 0x5d72e(%rip), %rcx     # 0x70210
movq %rcx, 0x20(%r15)
movq 0x8(%rsp), %rcx
movq %rcx, 0x28(%r15)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%r15)
movq %rax, 0x38(%r15)
movq 0x18(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x38(%r15)
movq %rax, 0x10(%rsp)
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15310
movq %r15, 0x30(%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 0x1472c
leaq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x13ab0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12b6b
callq 0x1581a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x12b7a
callq 0x1581a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x12b97
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x13ab0
jmp 0x12ba2
movq %rax, %rdi
callq 0x10886
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12bb6
callq 0x1581a
jmp 0x12bb6
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x12bc5
callq 0x1581a
movq %rbx, %rdi
callq 0xfb40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a6b6
movq 0x8(%r14), %rax
movabsq $-0x70502de1da3a1f65, %rcx # imm = 0x8FAFD21E25C5E09B
cmpq %rcx, 0x8(%rax)
je 0x1a84c
movq (%rbx), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x58903(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r15
leaq 0x36987(%rip), %rsi     # 0x5106b
movl $0xd, %edx
movq %rax, %rdi
callq 0xf730
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 0xf730
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a757
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a772
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0x129ce
cmpb $0x1, 0x360(%rbx)
jne 0x1a7ac
movq 0x350(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x368(%rbx), %rdx
movq $-0x1, %rcx
callq 0x15926
movb $0x0, 0x360(%rbx)
cmpb $0x1, 0x3d0(%rbx)
jne 0x1a7de
movq 0x3c0(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x3d8(%rbx), %rdx
movq $-0x1, %rcx
callq 0x15926
movb $0x0, 0x3d0(%rbx)
cmpl $-0x1, 0x2d8(%rbx)
je 0x1a818
leaq 0x2d8(%rbx), %rsi
leaq 0x20(%rsp), %rdx
movl $0x0, (%rdx)
movb $0x0, 0x4(%rdx)
leaq 0x55a0c(%rip), %rax     # 0x70210
movq %rax, 0x8(%rdx)
movq 0x2d0(%rbx), %rdi
addq $0x28, %rdi
callq 0x1ef9a
movq 0x320(%rbx), %rax
cmpq 0x328(%rbx), %rax
je 0x1a84c
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 0x1a858
movq %rax, %rbx
jmp 0x1a87b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a87b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a896
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ae28
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x19994
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %ecx, %ecx
subq %rdx, %rax
cmovneq %rdx, %rcx
movq %rbx, (%rsp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
je 0x1ad53
movq 0x5823b(%rip), %rsi     # 0x72f80
cmpb $0x0, (%rsi)
je 0x1ad4f
incl 0x8(%rdx)
jmp 0x1ad53
lock
incl 0x8(%rdx)
addq $0x2d0, %rbx            # imm = 0x2D0
movq (%r14), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%r14), %rdx
movq %rdx, 0x20(%rsp)
testq %rdx, %rdx
je 0x1ad85
movq 0x58209(%rip), %rsi     # 0x72f80
cmpb $0x0, (%rsi)
je 0x1ad81
incl 0x8(%rdx)
jmp 0x1ad85
lock
incl 0x8(%rdx)
leaq 0x48(%rsp), %rdi
movq %rbx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movl %eax, 0x20(%rdi)
movq (%rsp), %rcx
movq %rcx, 0x28(%rdi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x30(%rdi)
xorps %xmm0, %xmm0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movups %xmm0, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rsi
movl %eax, (%rsi)
movb $0x0, 0x4(%rsi)
leaq 0x5542b(%rip), %rax     # 0x70210
movq %rax, 0x8(%rsi)
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1b6f8
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x1ae07
callq 0x1581a
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1ae19
callq 0x1581a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1ae28
callq 0x1581a
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 0x1b934
movq %rsp, %rdi
callq 0x1ae68
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1ae60
callq 0x1581a
movq %rbx, %rdi
callq 0xfb40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1af84
movq %rdi, %rbx
movq 0x338(%rdi), %rax
addq $0x4, %rax
movq %rax, 0x338(%rdi)
cmpq 0x328(%rdi), %rax
jne 0x1af6c
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x580f7(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r14
leaq 0x36189(%rip), %rsi     # 0x51079
movl $0x42, %edx
movq %rax, %rdi
callq 0xf730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1af3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movq 0x348(%rbx), %rax
addq %rax, %rax
movq 0x290(%rbx), %rcx
movq 0x320(%rbx), %rdx
cmpq %rcx, %rax
cmovgeq %rcx, %rax
movq %rax, 0x348(%rbx)
movq %rdx, 0x338(%rbx)
movq 0x338(%rbx), %rax
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 0x1afaa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b143
movq %rdi, %rbx
cmpb $0x0, 0x230(%rdi)
jne 0x1b143
movl 0x238(%rbx), %eax
cmpl 0x29c(%rbx), %eax
jbe 0x1b143
movq 0x320(%rbx), %rax
cmpq 0x328(%rbx), %rax
je 0x1b08d
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x57fbd(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r14
leaq 0x36092(%rip), %rsi     # 0x510bc
movl $0x36, %edx
movq %rax, %rdi
callq 0xf730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b079
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movb $0x1, 0x318(%rbx)
movq %rbx, %rdi
callq 0x1ae8c
jmp 0x1b143
cmpb $0x0, 0x440(%rbx)
jne 0x1b143
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x57f1f(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r14
leaq 0x3602b(%rip), %rsi     # 0x510f3
movl $0x2e, %edx
movq %rax, %rdi
callq 0xf730
movl 0x340(%rbx), %esi
movq %r14, %rdi
callq 0xf460
movq %rax, %r14
leaq 0x36035(%rip), %rsi     # 0x51122
movl $0xe, %edx
movq %rax, %rdi
callq 0xf730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b13c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movb $0x1, 0x440(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1b14d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b16b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x133f8
cmpb $0x1, 0x318(%rbx)
jne 0x1b2a1
movl 0x234(%rbx), %eax
cmpl 0x298(%rbx), %eax
jb 0x1b2a1
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x57df3(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r14
leaq 0x35fc9(%rip), %rsi     # 0x511bd
movl $0x14, %edx
movq %rax, %rdi
callq 0xf730
movl 0x340(%rbx), %esi
movq %r14, %rdi
callq 0xf460
movq %rax, %r14
leaq 0x35fb9(%rip), %rsi     # 0x511d2
movl $0x4, %edx
movq %rax, %rdi
callq 0xf730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b268
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movb $0x0, 0x318(%rbx)
cmpb $0x1, 0x360(%rbx)
jne 0x1b2a1
movq 0x350(%rbx), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x368(%rbx), %rdx
movq $-0x1, %rcx
callq 0x15926
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 0x1b2c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52dae(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r15
leaq 0x31298(%rip), %rsi     # 0x514d1
movl $0xf, %edx
movq %rax, %rdi
callq 0xf730
movq %r15, %rdi
movq %r14, %rsi
callq 0x22d53
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20296
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0x12516
xorl %eax, %eax
movb %al, 0x3f8(%rbx)
movq %rsp, %rsi
movl $0x0, (%rsi)
movb %al, 0x4(%rsi)
leaq 0x4ff57(%rip), %rax     # 0x70210
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x202f6
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 0x202ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x208ae
movq 0x8(%r14), %rax
movabsq $-0x70502de1da3a1f65, %rcx # imm = 0x8FAFD21E25C5E09B
cmpq %rcx, 0x8(%rax)
je 0x209af
movq (%rbx), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x5270b(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r15
leaq 0x3078f(%rip), %rsi     # 0x5106b
movl $0xd, %edx
movq %rax, %rdi
callq 0xf730
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 0xf730
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2094f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2096a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0x129ce
cmpl $-0x1, 0x318(%rbx)
je 0x209af
leaq 0x20(%rsp), %rdx
movl $0x0, (%rdx)
movb $0x0, 0x4(%rdx)
leaq 0x4f87f(%rip), %rax     # 0x70210
movq %rax, 0x8(%rdx)
movq 0x310(%rbx), %rdi
addq $0x318, %rbx            # imm = 0x318
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x24200
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x209bb
movq %rax, %rbx
jmp 0x209de
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x209de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x209f9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20ab7
movq %rdi, %rbx
cmpl $0x15, 0x238(%rdi)
jb 0x20ab7
cmpb $0x0, 0x3f8(%rbx)
jne 0x20ab7
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x52586(%rip), %rdi     # 0x72fd8
callq 0xf730
movq %rax, %r14
leaq 0x30a80(%rip), %rsi     # 0x514e1
movl $0x3d, %edx
movq %rax, %rdi
callq 0xf730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20ab0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
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 0x20add
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25eb4
leaq 0x2bd33(%rip), %rcx     # 0x51b20
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 0x25ed0
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 0x25e9c
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_O1/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 0x267b8
movq 0x100(%rbx), %rdi
leaq 0x7(%rsp), %rsi
movb $0x2a, (%rsi)
callq 0x1227c
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x26779
leaq 0x2b75f(%rip), %r14     # 0x51e90
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 0x1227c
andl $0xf, %r15d
movb (%r15,%r14), %al
movb %al, 0x3(%rsp)
movq %r12, %rdi
leaq 0x3(%rsp), %rsi
callq 0x1227c
incq %r13
cmpq %rbp, %r13
jne 0x26731
movq 0x100(%rbx), %rdi
leaq 0x6(%rsp), %rsi
movb $0x3b, (%rsi)
callq 0x1227c
movq 0x100(%rbx), %rdi
leaq 0x5(%rsp), %rsi
movb $0xa, (%rsi)
callq 0x1227c
movq %rbx, %rdi
callq 0x2682c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketOutput::handle_error(boost::system::error_code const&)
void SocketOutput::handle_error(const boost::system::error_code &ec) {
        if (ec == boost::asio::error::eof) {
            std::cerr << peer << ": connection closed" << std::endl;
        } else if (ec != boost::asio::error::operation_aborted) {
            std::cerr << peer << ": connection error: " << ec.message() << std::endl;
        }

        close();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4cfa8(%rip), %rax     # 0x73a80
movabsq $-0x70502de1da3a1f65, %r15 # imm = 0x8FAFD21E25C5E09B
cmpq %r15, %rax
je 0x26b0c
movabsq $-0x4d54ee85da8120f3, %rcx # imm = 0xB2AB117A257EDF0D
cmpq %rcx, %rax
je 0x26b0c
movq 0x4cf7b(%rip), %rax     # 0x73a78
leaq 0x4cf74(%rip), %rdi     # 0x73a78
movl $0x2, %esi
callq *0x30(%rax)
movl (%r14), %eax
cmpl $0x7d, %eax
je 0x26baa
cmpl $0x2, %eax
jne 0x26bb8
movq 0x8(%r14), %rcx
movq 0x4cf54(%rip), %rdx     # 0x73a80
leaq 0x4cf45(%rip), %rsi     # 0x73a78
xorl %edi, %edi
cmpq %rsi, %rcx
sete %dil
xorl %esi, %esi
cmpq %rdx, 0x8(%rcx)
sete %sil
testq %rdx, %rdx
cmovel %edi, %esi
cmpb $0x1, %sil
jne 0x26ba5
leaq 0x70(%rbx), %rsi
movq 0x4c47b(%rip), %rdi     # 0x72fd8
callq 0x22d53
movq %rax, %r14
leaq 0x2b26b(%rip), %rsi     # 0x51dd7
movl $0x13, %edx
movq %rax, %rdi
callq 0xf730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
jmp 0x26c46
cmpl $0x7d, %eax
jne 0x26bb8
movq 0x8(%r14), %rax
cmpq %r15, 0x8(%rax)
je 0x26c46
leaq 0x70(%rbx), %rsi
movq 0x4c415(%rip), %rdi     # 0x72fd8
callq 0x22d53
movq %rax, %r15
leaq 0x2b219(%rip), %rsi     # 0x51deb
movl $0x14, %edx
movq %rax, %rdi
callq 0xf730
movq 0x8(%r14), %rsi
movl (%r14), %edx
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x20(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xf730
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf5f0
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26c46
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
leaq 0x20(%rbx), %rdi
callq 0x2415e
cmpq $0x0, 0xf0(%rbx)
je 0x26c66
leaq 0xe0(%rbx), %rdi
callq *0xf8(%rbx)
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 0x26c8e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf650
movq %rbx, %rdi
callq 0xfb40
// File: /workspace/github_cpp_makefile_star2_O1/flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketListener::start()
void SocketListener::start() {
        acceptor.open(endpoint.protocol());
        acceptor.set_option(asio::socket_base::reuse_address(true));
        acceptor.set_option(tcp::acceptor::reuse_address(true));

        // We are v6 aware and bind separately to v4 and v6 addresses
        if (endpoint.protocol() == tcp::v6())
            acceptor.set_option(asio::ip::v6_only(true));

        acceptor.bind(endpoint);
        acceptor.listen();
        accept_connection();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x68(%rdi), %r15
xorl %eax, %eax
cmpw $0x2, 0x68(%rdi)
setne %al
leal 0x2(,%rax,8), %eax
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b280
movl $0x1, %ebp
movl %ebp, (%r12)
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b320
movl %ebp, (%r12)
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x2b320
cmpw $0x2, 0x68(%rbx)
je 0x26e08
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
movq %r14, %rdi
callq 0x2b3c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b460
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2b500
movq %rbx, %rdi
callq 0x26e36
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop