LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketConnector::resolve_and_connect(boost::system::error_code const&)
void SocketConnector::resolve_and_connect(const boost::system::error_code &ec) {
        if (!running) {
            return;
        }

        if (ec) {
            assert(ec == boost::asio::error::operation_aborted);
            return;
        }

        auto self(shared_from_this());

        tcp::resolver::query query(host, port_or_service);
        resolver.async_resolve(query, [this, self](const boost::system::error_code &ec, tcp::resolver::iterator it) {
            if (!ec) {
                next_endpoint = it;
                try_next_endpoint();
            } else if (ec == boost::asio::error::operation_aborted) {
                return;
            } else {
                std::cerr << host << ":" << port_or_service << ": could not resolve address: " << ec.message() << std::endl;
                schedule_reconnect();
                return;
            }
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
testb $0x1, 0x1a0(%rax)
jne 0x5189c
jmp 0x519a8
movq -0x10(%rbp), %rdi
callq 0x262b0
testb $0x1, %al
jne 0x518ab
jmp 0x51904
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x7d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3ace0
movq -0xd8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3aee0
testb $0x1, %al
jne 0x518de
jmp 0x518e0
jmp 0x518ff
leaq 0x62aea(%rip), %rdi     # 0xb43d1
leaq 0x63686(%rip), %rsi     # 0xb4f74
movl $0x185, %edx            # imm = 0x185
leaq 0x6368a(%rip), %rcx     # 0xb4f84
callq 0x125d0
jmp 0x519a8
movq -0xd0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5ae60
movq -0xd0(%rbp), %rdx
movq %rdx, %rsi
addq $0x128, %rsi            # imm = 0x128
addq $0x148, %rdx            # imm = 0x148
leaq -0xa0(%rbp), %rdi
movl $0x20, %ecx
callq 0x487a0
jmp 0x5193f
movq -0xd0(%rbp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, -0xe0(%rbp)
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5ae90
movq -0xe0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x51a60
jmp 0x51987
leaq -0xc8(%rbp), %rdi
callq 0x51aa0
leaq -0xa0(%rbp), %rdi
callq 0x488b0
leaq -0x30(%rbp), %rdi
callq 0x5aec0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x519ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x51aa0
leaq -0xa0(%rbp), %rdi
callq 0x488b0
leaq -0x30(%rbp), %rdi
callq 0x5aec0
movq -0xa8(%rbp), %rdi
callq 0x12f70
nopw %cs:(%rax,%rax)
// File: flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketConnector::close()
void SocketConnector::close() {
        running = false;
        resolver.cancel();
        reconnect_timer.cancel();
        socket.close();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, 0x1a0(%rdi)
addq $0x20, %rdi
callq 0x5ae20
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x212e0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x4bf60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketConnector::try_next_endpoint()
void SocketConnector::try_next_endpoint() {
        if (!running) {
            return;
        }

        if (next_endpoint == tcp::resolver::iterator()) {
            // No more addresses to try
            schedule_reconnect();
            return;
        }

        tcp::endpoint endpoint = *next_endpoint++;

        auto self(shared_from_this());
        socket.async_connect(endpoint, [this, self, endpoint](const boost::system::error_code &ec) {
            if (!ec) {
                connection_established(endpoint);
            } else if (ec == boost::asio::error::operation_aborted) {
                return;
            } else {
                std::cerr << host << ":" << port_or_service << ": connection to " << endpoint << " failed: " << ec.message() << std::endl;
                socket.close();
                try_next_endpoint();
            }
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
testb $0x1, 0x1a0(%rax)
jne 0x51ae8
jmp 0x51c45
movq -0xb0(%rbp), %rax
addq $0x1a8, %rax            # imm = 0x1A8
movq %rax, -0xc8(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x48700
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x488f0
movb %al, -0xb1(%rbp)
jmp 0x51b27
leaq -0x20(%rbp), %rdi
callq 0x48730
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x51b3c
jmp 0x51b67
movq -0xb0(%rbp), %rdi
callq 0x51c90
jmp 0x51c45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x48730
jmp 0x51c86
movq -0xb0(%rbp), %rsi
addq $0x1a8, %rsi            # imm = 0x1A8
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
xorl %edx, %edx
callq 0x48920
movq -0xd8(%rbp), %rdi
callq 0x489a0
movq %rax, -0xd0(%rbp)
jmp 0x51b9c
movq -0xd0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x489c0
jmp 0x51bae
leaq -0x60(%rbp), %rdi
callq 0x48730
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x5ae60
movq -0xb0(%rbp), %rax
movq -0xf0(%rbp), %rsi
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5ae90
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x489f0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x51e30
jmp 0x51c30
leaq -0xa8(%rbp), %rdi
callq 0x51ed0
leaq -0x70(%rbp), %rdi
callq 0x5aec0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x48730
jmp 0x51c86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x51ed0
leaq -0x70(%rbp), %rdi
callq 0x5aec0
movq -0x28(%rbp), %rdi
callq 0x12f70
nop
// File: flightaware[P]beast-splitter/beast_output.cc
// Function: beast::SocketConnector::schedule_reconnect()
void SocketConnector::schedule_reconnect() {
        if (running) {
            std::cerr << host << ":" << port_or_service << ": reconnecting in " << std::chrono::duration_cast<std::chrono::seconds>(reconnect_interval).count() << " seconds" << std::endl;

            auto self(shared_from_this());
            reconnect_timer.expires_from_now(reconnect_interval);
            reconnect_timer.async_wait(std::bind(&SocketConnector::resolve_and_connect, self, std::placeholders::_1));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0x1a0(%rax)
je 0x51e19
movq -0x70(%rbp), %rsi
addq $0x128, %rsi            # imm = 0x128
movq 0xb9312(%rip), %rdi     # 0x10afd8
callq 0x12770
movq %rax, %rdi
leaq 0x61345(%rip), %rsi     # 0xb301a
callq 0x12800
movq -0x70(%rbp), %rsi
movq %rax, %rdi
addq $0x148, %rsi            # imm = 0x148
callq 0x12770
movq %rax, %rdi
leaq 0x632e1(%rip), %rsi     # 0xb4fd8
callq 0x12800
movq -0x70(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x10, %rdi
movq %rdi, -0x80(%rbp)
callq 0x5aee0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x245e0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x13020
movq %rax, %rdi
leaq 0x632b1(%rip), %rsi     # 0xb4feb
callq 0x12800
movq %rax, %rdi
movq 0xb91cf(%rip), %rsi     # 0x10af18
callq 0x128b0
movq -0x70(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5ae60
movq -0x70(%rbp), %rax
movq -0x80(%rbp), %rsi
addq $0xb8, %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x213c0
jmp 0x51d78
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21350
jmp 0x51d87
movq -0x70(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x90(%rbp)
leaq -0x52f(%rip), %rax      # 0x51870
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq 0xb91ae(%rip), %rcx     # 0x10af60
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5af40
jmp 0x51dc5
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5af10
jmp 0x51dd7
leaq -0x58(%rbp), %rdi
callq 0x5af80
leaq -0x20(%rbp), %rdi
callq 0x5aec0
jmp 0x51e19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x51e0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5af80
leaq -0x20(%rbp), %rdi
callq 0x5aec0
jmp 0x51e22
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x12f70
nopl (%rax,%rax)
// File: flightaware[P]beast-splitter/./modes_message.h
// Function: modes::Message::corrected_data() const
const std::vector<std::uint8_t> &corrected_data() const {
            if (!crc_bad()) {
                return m_data;
            }

            if (m_corrected_data.size() != 0) {
                // already corrected
                return m_corrected_data;
            }

            auto bit = crc_correctable_bit();
            if (bit < 0) {
                // not correctable
                return m_corrected_data; // empty vector
            }

            // copy the original data and do FEC
            m_corrected_data = m_data;
            m_corrected_data[bit / 8] ^= (1 << (7 - (bit & 7)));
            return m_corrected_data;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x17cc0
testb $0x1, %al
jne 0x5a5ae
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x5a64e
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x14c40
cmpq $0x0, %rax
je 0x5a5cf
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x5a64e
movq -0x20(%rbp), %rdi
callq 0x17df0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x5a5ef
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x5a64e
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x18, %rsi
addq $0x38, %rdi
callq 0x5b330
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
andl $0x7, %eax
movl $0x7, %ecx
subl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
addq $0x38, %rdi
movl -0x14(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0x144d0
movl -0x24(%rbp), %esi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl (%rcx), %edx
xorl %esi, %edx
movb %dl, (%rcx)
addq $0x38, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: flightaware[P]beast-splitter/./beast_output.h
// Function: beast::messagetype_to_byte(modes::MessageType)
inline std::uint8_t messagetype_to_byte(modes::MessageType t) {
        switch (t) {
        case modes::MessageType::MODE_AC:
            return 0x31;
        case modes::MessageType::MODE_S_SHORT:
            return 0x32;
        case modes::MessageType::MODE_S_LONG:
            return 0x33;
        case modes::MessageType::STATUS:
            return 0x34;
        default:
            return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x5a8c3
movq -0x10(%rbp), %rax
leaq 0x5a672(%rip), %rcx     # 0xb4f14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x31, -0x1(%rbp)
jmp 0x5a8c7
movb $0x32, -0x1(%rbp)
jmp 0x5a8c7
movb $0x33, -0x1(%rbp)
jmp 0x5a8c7
movb $0x34, -0x1(%rbp)
jmp 0x5a8c7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: flightaware[P]beast-splitter/status_writer.cc
// Function: splitter::StatusWriter::start()
void StatusWriter::start() {
        auto self(shared_from_this());

        modes::Filter filter;
        filter.receive_status = true;
        filter_handle = distributor.add_client(std::bind(&StatusWriter::write, self, std::placeholders::_1), filter);

        reset_timeout();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x62180
leaq -0x3f(%rbp), %rdi
callq 0x16810
jmp 0x6073e
movq -0xa8(%rbp), %rax
movb $0x1, -0x1c(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq 0xf5(%rip), %rax        # 0x60850
movq %rax, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq 0xaa7ec(%rip), %rcx     # 0x10af60
leaq -0x90(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x621b0
jmp 0x6078d
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x621f0
jmp 0x6079f
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x3f(%rbp), %rdx
callq 0x16d60
movl %eax, -0xb4(%rbp)
jmp 0x607bb
movq -0xa8(%rbp), %rax
movl -0xb4(%rbp), %ecx
movl %ecx, 0x78(%rax)
leaq -0x70(%rbp), %rdi
callq 0x17ad0
leaq -0x90(%rbp), %rdi
callq 0x62290
movq -0xa8(%rbp), %rdi
callq 0x613e0
jmp 0x607ee
leaq -0x18(%rbp), %rdi
callq 0x622b0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6083d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x60831
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x17ad0
leaq -0x90(%rbp), %rdi
callq 0x62290
leaq -0x18(%rbp), %rdi
callq 0x622b0
movq -0x48(%rbp), %rdi
callq 0x12f70
nop
// File: flightaware[P]beast-splitter/status_writer.cc
// Function: splitter::StatusWriter::status_timeout(boost::system::error_code const&)
void StatusWriter::status_timeout(const boost::system::error_code &ec) {
        if (ec == boost::asio::error::operation_aborted)
            return;

        reset_timeout();
        if (input && input->is_connected() && input->receiver() == beast::ReceiverType::RADARCAPE) {
            // we should be getting status messages, but we are not.
            write_status_file("red", "No recent GPS status message received");
        } else {
            // Not connected or it's a regular Beast, no GPS status.
            write_status_file();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x7d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3ace0
movq -0xc8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3aee0
testb $0x1, %al
jne 0x61561
jmp 0x61566
jmp 0x6173b
movq -0xd0(%rbp), %rdi
callq 0x613e0
movq -0xd0(%rbp), %rdi
addq $0x28, %rdi
callq 0x62360
testb $0x1, %al
jne 0x6158b
jmp 0x616b4
movq -0xd0(%rbp), %rdi
addq $0x28, %rdi
callq 0x62380
movq %rax, %rdi
callq 0x623a0
testb $0x1, %al
jne 0x615ac
jmp 0x616b4
movq -0xd0(%rbp), %rdi
addq $0x28, %rdi
callq 0x62380
movq %rax, %rdi
callq 0x623e0
cmpl $0x2, %eax
jne 0x616b4
leaq -0x41(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x12fa0
movq -0xd8(%rbp), %rdx
leaq 0x53bda(%rip), %rsi     # 0xb51c5
leaq -0x40(%rbp), %rdi
callq 0x22350
jmp 0x615f6
leaq -0x79(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x12fa0
movq -0xe0(%rbp), %rdx
leaq 0x53bb5(%rip), %rsi     # 0xb51c9
leaq -0x78(%rbp), %rdi
callq 0x22350
jmp 0x6161f
movq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdx
movl $0xffffd8f1, %ecx       # imm = 0xFFFFD8F1
callq 0x61750
jmp 0x6163a
leaq -0x78(%rbp), %rdi
callq 0x13198
leaq -0x79(%rbp), %rdi
callq 0x128f0
leaq -0x40(%rbp), %rdi
callq 0x13198
leaq -0x41(%rbp), %rdi
callq 0x128f0
jmp 0x6173b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x616a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x61694
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x13198
leaq -0x79(%rbp), %rdi
callq 0x128f0
leaq -0x40(%rbp), %rdi
callq 0x13198
leaq -0x41(%rbp), %rdi
callq 0x128f0
jmp 0x61744
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x12c10
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x12c10
movq -0xd0(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movl $0xffffd8f1, %ecx       # imm = 0xFFFFD8F1
callq 0x61750
jmp 0x616fb
leaq -0xc0(%rbp), %rdi
callq 0x13198
leaq -0xa0(%rbp), %rdi
callq 0x13198
jmp 0x6173b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x13198
leaq -0xa0(%rbp), %rdi
callq 0x13198
jmp 0x61744
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x12f70
nopl (%rax)
// File: flightaware[P]beast-splitter/splitter_main.cc
// Function: main
int main(int argc, char **argv) {
    try {
        return realmain(argc, argv);
    } catch (std::exception &e) {
        std::cerr << "Uncaught exception: " << e.what() << std::endl;
        return 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x65f90
movl %eax, -0x2c(%rbp)
jmp 0x65ec7
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x65f68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x65f71
movq -0x18(%rbp), %rdi
callq 0x12380
movq %rax, -0x28(%rbp)
movq 0xa50d6(%rip), %rdi     # 0x10afd8
leaq 0x4feda(%rip), %rsi     # 0xb5de3
callq 0x12800
movq %rax, -0x38(%rbp)
jmp 0x65f14
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x12800
movq %rax, -0x40(%rbp)
jmp 0x65f33
movq -0x40(%rbp), %rdi
movq 0xa4fda(%rip), %rsi     # 0x10af18
callq 0x128b0
jmp 0x65f45
movl $0x2, -0x4(%rbp)
callq 0x12e40
jmp 0x65f68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12e40
jmp 0x65f66
jmp 0x65f71
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x12f70
movq %rax, %rdi
callq 0x148f0
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::initialize_system()
void initialize_system()
{
	assert( !s_is_system_initialized );
	s_is_system_initialized = true;

	// UTF8 ワークアラウンド
	//setvbuf( stdout, nullptr, _IOFBF, 1024 );
	setvbuf( stderr, nullptr, _IOFBF, 1024 );

#if NHSP_CONFIG_MEMLEAK_DETECTION
	if ( s_memory_map_ == nullptr )
	{
		s_memory_map_ = reinterpret_cast<list_t*>( zmalloc( sizeof(list_t) ) );
		s_memory_map_->head_ = s_memory_map_->tail_ = nullptr;
	}
#endif
#if NHSP_CONFIG_VALUE_ALLOCATION_CACHE
	for( size_t i=0; i<MAX_VALUE_ALLOCATION_CACHE; ++i )
	{
		s_value_allocation_cache[i] = reinterpret_cast<value_t*>( xmalloc( sizeof(value_t) ) );
	}
	s_value_allocation_cache_idx = 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb 0x18ce2(%rip), %al      # 0x1c440
xorb $-0x1, %al
testb $0x1, %al
jne 0x3766
jmp 0x3768
jmp 0x3787
leaq 0xf2c9(%rip), %rdi      # 0x12a38
leaq 0xf2db(%rip), %rsi      # 0x12a51
movl $0x4c4, %edx            # imm = 0x4C4
leaq 0xf2e6(%rip), %rcx      # 0x12a68
callq 0x30f0
movb $0x1, 0x18cb2(%rip)     # 0x1c440
movq 0x1884b(%rip), %rax     # 0x1bfe0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x3040
movq $0x0, -0x8(%rbp)
cmpq $0x40, -0x8(%rbp)
jae 0x37e1
movl $0x18, %edi
callq 0x3800
movq %rax, %rdx
movq -0x8(%rbp), %rcx
leaq 0x18c81(%rip), %rax     # 0x1c450
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x37b0
movl $0x0, 0x18e65(%rip)     # 0x1c650
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::uninitialize_system()
void uninitialize_system()
{
	assert( s_is_system_initialized );
	s_is_system_initialized = false;

#if NHSP_CONFIG_VALUE_ALLOCATION_CACHE
	assert( s_value_allocation_cache_idx == 0 );
	for( size_t i=0; i<MAX_VALUE_ALLOCATION_CACHE; ++i )
	{
		if ( s_value_allocation_cache[i] != nullptr )
		{
			xfree( s_value_allocation_cache[i] );
			s_value_allocation_cache[i] = nullptr;
		}
	}
	s_value_allocation_cache_idx = 0;
#endif
#if NHSP_CONFIG_MEMLEAK_DETECTION
	if ( s_memory_map_ != nullptr )
	{
		printf( "====leaked memories\n" );
		auto node = s_memory_map_->head_;
		while( node != nullptr )
		{
			printf( "[%p]\n", node->value_ );
			node = node->next_;
		}
		printf( "----" );
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x18c01(%rip)     # 0x1c440
je 0x3843
jmp 0x3862
leaq 0xf1ef(%rip), %rdi      # 0x12a39
leaq 0xf200(%rip), %rsi      # 0x12a51
movl $0x4dd, %edx            # imm = 0x4DD
leaq 0xf22f(%rip), %rcx      # 0x12a8c
callq 0x30f0
movb $0x0, 0x18bd7(%rip)     # 0x1c440
cmpl $0x0, 0x18de0(%rip)     # 0x1c650
jne 0x3874
jmp 0x3893
leaq 0xf237(%rip), %rdi      # 0x12ab2
leaq 0xf1cf(%rip), %rsi      # 0x12a51
movl $0x4e1, %edx            # imm = 0x4E1
leaq 0xf1fe(%rip), %rcx      # 0x12a8c
callq 0x30f0
movq $0x0, -0x8(%rbp)
cmpq $0x40, -0x8(%rbp)
jae 0x38eb
movq -0x8(%rbp), %rcx
leaq 0x18ba3(%rip), %rax     # 0x1c450
cmpq $0x0, (%rax,%rcx,8)
je 0x38db
movq -0x8(%rbp), %rcx
leaq 0x18b91(%rip), %rax     # 0x1c450
movq (%rax,%rcx,8), %rdi
callq 0x3900
movq -0x8(%rbp), %rcx
leaq 0x18b7d(%rip), %rax     # 0x1c450
movq $0x0, (%rax,%rcx,8)
jmp 0x38dd
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x389b
movl $0x0, 0x18d5b(%rip)     # 0x1c650
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_string_buffer(unsigned long, int)
string_buffer_t* create_string_buffer( size_t initial_len, int expand_step )
{
	assert( initial_len > 0 );
	auto* const res = reinterpret_cast<string_buffer_t*>( xmalloc( sizeof( string_buffer_t ) ) );
	initialize_string_buffer( res, initial_len, expand_step );
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jbe 0x39d8
jmp 0x39f7
leaq 0xf0f5(%rip), %rdi      # 0x12ad4
leaq 0xf06b(%rip), %rsi      # 0x12a51
movl $0x52c, %edx            # imm = 0x52C
leaq 0xf0f2(%rip), %rcx      # 0x12ae4
callq 0x30f0
movl $0x18, %edi
callq 0x3800
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x3a20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::initialize_string_buffer(neteruhsp::string_buffer_t*, unsigned long, int)
void initialize_string_buffer( string_buffer_t* sb, size_t initial_len, int expand_step )
{
	sb->buffer_ = create_string( initial_len );
	sb->buffer_size_ = static_cast<int>( initial_len );
	sb->cursor_ = 0;
	sb->expand_step_ = expand_step;
	sb->buffer_[0] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::uninitialize_string_buffer(neteruhsp::string_buffer_t*)
void uninitialize_string_buffer( string_buffer_t* sb )
{
	assert( sb != nullptr );

	if ( sb->buffer_ != nullptr )
	{
		xfree( sb->buffer_ );
		sb->buffer_ = nullptr;
	}
	sb->buffer_size_ = 0;
	sb->cursor_ = 0;
	sb->expand_step_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ac5
jmp 0x3ae4
leaq 0xf056(%rip), %rdi      # 0x12b22
leaq 0xef7e(%rip), %rsi      # 0x12a51
movl $0x543, %edx            # imm = 0x543
leaq 0xf051(%rip), %rcx      # 0x12b30
callq 0x30f0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3b05
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3900
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::string_buffer_append(neteruhsp::string_buffer_t*, char const*, int)
void string_buffer_append( string_buffer_t* sb, const char* s, int len )
{
	if ( len < 0 )
	{
		len = static_cast<int>( strlen( s ) );
	}

	if ( len == 0 )
	{
		return;
	}

	const auto left = sb->buffer_size_ - sb->cursor_;
	const auto required = len + 4;
	if ( left < required )
	{
		const int nexpand = ( required - left );
		const int expand_step = ( sb->expand_step_ <= 0 ? sb->buffer_size_/* x2 */ : sb->expand_step_ );
		const int expand = ( expand_step < nexpand ? nexpand : expand_step );
		const size_t nsize = sb->buffer_size_ + expand;
		sb->buffer_ = reinterpret_cast<char*>( xrealloc( sb->buffer_, static_cast<size_t>( nsize ) ) );
		sb->buffer_size_ = static_cast<int>( nsize );
	}

	memcpy( sb->buffer_ + sb->cursor_, s, len );
	sb->cursor_ += len;
	sb->buffer_[sb->cursor_] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3b75
movq -0x10(%rbp), %rdi
callq 0x30b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3b80
jmp 0x3c67
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3c28
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jg 0x3bc5
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x3bcf
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3be5
movl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x3beb
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x28(%rbp), %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3960
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3120
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_list_node()
list_node_t* create_list_node()
{
	list_node_t* res = reinterpret_cast<list_node_t*>( xmalloc( sizeof( list_node_t ) ) );
	res->prev_ = res->next_ = nullptr;
	res->value_ = nullptr;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x3800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::unlink_list_node(neteruhsp::list_node_t*)
bool unlink_list_node( list_node_t* node )
{
	if ( node->prev_==nullptr && node->next_==nullptr )
	{ 
		return false;
	}
	if ( node->prev_ != nullptr )
	{
		node->prev_->next_ = node->next_;
	}
	if ( node->next_ != nullptr )
	{
		node->next_->prev_ = node->prev_;
	}
	node->prev_ = node->next_ = nullptr;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3d13
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3d13
movb $0x0, -0x1(%rbp)
jmp 0x3d68
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3d30
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d4d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::link_next(neteruhsp::list_node_t*, neteruhsp::list_node_t*)
void link_next( list_node_t* node, list_node_t* list )
{
	assert( node->prev_==nullptr && node->next_==nullptr );
	node->prev_ = list;
	node->next_ = list->next_;
	list->next_ = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
jne 0x3d9e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3da7
jmp 0x3da9
jmp 0x3dc8
leaq 0xedbe(%rip), %rdi      # 0x12b6e
leaq 0xec9a(%rip), %rsi      # 0x12a51
movl $0x57e, %edx            # imm = 0x57E
leaq 0xedd8(%rip), %rcx      # 0x12b9b
callq 0x30f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::link_prev(neteruhsp::list_node_t*, neteruhsp::list_node_t*)
void link_prev( list_node_t* node, list_node_t* list )
{
	assert( node->prev_==nullptr && node->next_==nullptr );
	node->prev_ = list->prev_;
	node->next_ = list;
	list->prev_ = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
jne 0x3e2e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3e37
jmp 0x3e39
jmp 0x3e58
leaq 0xed2e(%rip), %rdi      # 0x12b6e
leaq 0xec0a(%rip), %rsi      # 0x12a51
movl $0x586, %edx            # imm = 0x586
leaq 0xed80(%rip), %rcx      # 0x12bd3
callq 0x30f0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::list_prepend(neteruhsp::list_t&, neteruhsp::list_node_t*)
void list_prepend( list_t& list, list_node_t* node )
{
	if ( list.head_ == nullptr )
	{
		assert( list.tail_==nullptr );
		list.head_ = list.tail_ = node;
		return;
	}
	link_prev( node, list.head_ );
	list.head_ = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3f4b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3f17
jmp 0x3f36
leaq 0xeced(%rip), %rdi      # 0x12c0b
leaq 0xeb2c(%rip), %rsi      # 0x12a51
movl $0x5ae, %edx            # imm = 0x5AE
leaq 0xecee(%rip), %rcx      # 0x12c1f
callq 0x30f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3f66
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x3e00
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::list_append(neteruhsp::list_t&, neteruhsp::list_node_t*)
void list_append( list_t& list, list_node_t* node )
{
	if ( list.tail_ == nullptr )
	{
		assert( list.head_==nullptr );
		list.head_ = list.tail_ = node;
		return;
	}
	link_next( node, list.tail_ );
	list.tail_ = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3fcb
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3f97
jmp 0x3fb6
leaq 0xecb7(%rip), %rdi      # 0x12c55
leaq 0xeaac(%rip), %rsi      # 0x12a51
movl $0x5ba, %edx            # imm = 0x5BA
leaq 0xecb8(%rip), %rcx      # 0x12c69
callq 0x30f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3fe8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3d70
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::list_erase(neteruhsp::list_t&, neteruhsp::list_node_t*)
void list_erase( list_t& list, list_node_t* node )
{
	if ( list.head_ == node )
	{
		list.head_ = node->next_;
	}
	if ( list.tail_ == node )
	{
		list.tail_ = node->prev_;
	}
	unlink_list_node( node );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x401c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4039
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3cf0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::list_find(neteruhsp::list_t&, void*)
list_node_t* list_find( list_t& list, void* value )
{
	auto* node = list.head_;
	while( node != nullptr )
	{
		if ( node->value_ == value )
		{
			return node;
		}
		node = node->next_;
	}
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4094
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x4086
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x409c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4067
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::list_free_all(neteruhsp::list_t&)
void list_free_all( list_t& list )
{
	auto* node = list.head_;
	while( node != nullptr )
	{
		auto next = node->next_;
		list_erase( list, node );
		xfree( node );
		node = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x40fa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ff0
movq -0x10(%rbp), %rdi
callq 0x3900
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x40c7
addq $0x20, %rsp
popq %rbp
retq
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::query_keyword(char const*)
int query_keyword( const char* s )
{
	static const struct
	{
		int				tag_;
		const char*		word_;
	} table[] =
	{
		{ KEYWORD_GLOBAL,	"global", },
		{ KEYWORD_CTYPE,	"ctype", },
		{ KEYWORD_END,		"end", },
		{ KEYWORD_RETURN,	"return", },
		{ KEYWORD_GOTO,		"goto", },
		{ KEYWORD_GOSUB,	"gosub", },
		{ KEYWORD_REPEAT,	"repeat", },
		{ KEYWORD_LOOP,		"loop", },
		{ KEYWORD_CONTINUE,	"continue", },
		{ KEYWORD_BREAK,	"break", },
		{ KEYWORD_IF,		"if", },
		{ KEYWORD_ELSE,		"else", },
		{ KEYWORD_UNDEF,	nullptr },
	};

	// 全探索
	for( int i=0; table[i].tag_!=-1; ++i )
	{
		if ( string_equal_igcase( s, table[i].word_ ) )
		{
			return table[i].tag_;
		}
	}
	return KEYWORD_UNDEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x17762(%rip), %rax     # 0x1b880
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0x417a
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x17747(%rip), %rax     # 0x1b880
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4190
testb $0x1, %al
jne 0x4154
jmp 0x416d
movslq -0x14(%rbp), %rcx
leaq 0x17721(%rip), %rax     # 0x1b880
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4181
jmp 0x416f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4113
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::string_equal_igcase(char const*, char const*, int)
bool string_equal_igcase( const char* sl, const char* r, int len =-1 )
{
	const auto tol =[]( char c ) -> int
	{
		if ( c>='A' && c<='Z' )
		{ return c -'A' +'a'; }
		return c;
	};

	int iter =0;
	for( ; ; )
	{
		if ( sl[0]=='\0' || r[0]=='\0' )
		{
			if ( len < 0 )
			{
				if ( sl[0] != r[0] )
				{ return false; }
			}
			else
			{
				if ( sl[0]!='\0' || iter!=len )
				{ return false; }
			}
			break;
		}
		if ( tol( sl[0] ) != tol( r[0] ) )
		{ return false; }
		++sl, ++r; ++iter;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x41c2
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4200
cmpl $0x0, -0x1c(%rbp)
jge 0x41e2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x41e0
movb $0x0, -0x1(%rbp)
jmp 0x425c
jmp 0x41fe
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x41f6
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x41fc
movb $0x0, -0x1(%rbp)
jmp 0x425c
jmp 0x41fe
jmp 0x4258
movq -0x10(%rbp), %rax
leaq -0x1d(%rbp), %rdi
movsbl (%rax), %esi
callq 0x112b0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
leaq -0x1d(%rbp), %rdi
movsbl (%rax), %esi
callq 0x112b0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
je 0x4232
movb $0x0, -0x1(%rbp)
jmp 0x425c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41aa
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::query_token_shadow(char const*, unsigned long)
int query_token_shadow( const char* ident, size_t len )
{
	static const struct
	{
		int				type_;
		const char*		word_;
	}
	shadows[] =
	{
		{ TOKEN_OP_NEQ,		"not" },
		{ TOKEN_OP_BAND,	"and" },
		{ TOKEN_OP_BOR,		"or" },
		{ TOKEN_OP_BXOR,	"xor" },
		{ TOKEN_UNKNOWN,	nullptr },
	};

	for( int i=0; shadows[i].type_!=-1; ++i )
	{
		if ( string_equal_igcase( shadows[i].word_, ident, static_cast<int>( len ) ) )
		{
			return shadows[i].type_;
		}
	}
	return TOKEN_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x176be(%rip), %rax     # 0x1b950
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0x42ef
movslq -0x1c(%rbp), %rcx
leaq 0x176a7(%rip), %rax     # 0x1b950
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0x4190
testb $0x1, %al
jne 0x42c9
jmp 0x42e2
movslq -0x1c(%rbp), %rcx
leaq 0x1767c(%rip), %rax     # 0x1b950
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x42f6
jmp 0x42e4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4287
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::initialize_tokenize_context(neteruhsp::tokenize_context_t*, char const*)
void initialize_tokenize_context( tokenize_context_t* c, const char* script )
{
	c->script_ = script;
	c->cursor_ = 0;
	c->line_ = 0;
	c->line_head_ = script;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::uninitialize_tokenize_context(neteruhsp::tokenize_context_t*)
void uninitialize_tokenize_context( tokenize_context_t* c )
{
	c->script_ = nullptr;
	c->cursor_ = 0;
	c->line_ = 0;
	c->line_head_ = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::raise_error(char const*, ...)
void raise_error( const char* message, ... )
{
	va_list args;
	va_start( args, message );
	vfprintf( stderr, message, args );
	va_end( args );
	fflush( stderr );
	exit( -1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x4d05
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x17289(%rip), %rax     # 0x1bfe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x31e0
leaq -0x20(%rbp), %rax
movq 0x1726e(%rip), %rax     # 0x1bfe0
movq (%rax), %rdi
callq 0x3180
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x31b0
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_token_string(char const*, unsigned long)
char* create_token_string( const char* str, size_t len )
{
	char* res = create_string( len );

	size_t w =0;
	for( size_t i=0; i<len; ++i, ++w )
	{
		if ( str[i]=='\\' && (i+1)<len )
		{
			switch( str[i+1] )
			{
				case 't':	res[w] = '\t'; break;
				case 'n':	res[w] = '\n'; break;
				case '\"':	res[w] = '\"'; break;
				default:
					raise_error( "読み取れないエスケープシーケンス@@ %c%c", str[i], str[i+1] );
					break;
			}
			++i;
		}
		else
		{
			res[w] = str[i];
		}
	}
	res[w] = '\0';
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b30
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4eb1
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x4e7c
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x10(%rbp), %rax
jae 0x4e7c
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movsbl 0x1(%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
subl $0x22, %eax
je 0x4e39
jmp 0x4e09
movl -0x2c(%rbp), %eax
subl $0x6e, %eax
je 0x4e2b
jmp 0x4e13
movl -0x2c(%rbp), %eax
subl $0x74, %eax
jne 0x4e47
jmp 0x4e1d
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x9, (%rax,%rcx)
jmp 0x4e6e
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0xa, (%rax,%rcx)
jmp 0x4e6e
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x22, (%rax,%rcx)
jmp 0x4e6e
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %edx
leaq 0xdf44(%rip), %rdi      # 0x12dab
movb $0x0, %al
callq 0x4cd0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4e92
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4e94
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4dbd
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_token(neteruhsp::token_t*)
void destroy_token( token_t* t )
{
	if ( t->content_ != nullptr )
	{
		destroy_string( t->content_ );
		t->content_ = nullptr;
	}
	xfree( t );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5020
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x3900
addq $0x10, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::uninitialize_parse_context(neteruhsp::parse_context_t*)
void uninitialize_parse_context( parse_context_t* c )
{
	if ( c->token_list_ != nullptr )
	{
		list_node_t* iter =c->token_list_->head_;
		while( iter != nullptr )
		{
			const auto next =iter->next_;
			token_t* token =reinterpret_cast<token_t*>( iter->value_ );
			destroy_token( token );
			destroy_list_node( iter );
			iter = next;
		}
		destroy_list( c->token_list_ );
	}

	c->token_list_ = nullptr;
	c->token_current_ = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x513b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x512f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4ff0
movq -0x10(%rbp), %rdi
callq 0x3cc0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x50f4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::read_token(neteruhsp::parse_context_t&)
token_t* read_token( parse_context_t& c )
{
	const auto read = [&c]()
	{
		auto list = create_list_node();
		list->value_ = get_token( *c.tokenize_context_ );
		return list;
	};

	if ( c.token_current_ == nullptr )
	{
		const auto node =read();
		list_append( *c.token_list_, node );
		c.token_current_ = node;
	}
	assert( c.token_current_ != nullptr );
	const auto res = c.token_current_;
	c.token_current_ = c.token_current_->next_;
	return reinterpret_cast<token_t*>( res->value_ );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x51a8
leaq -0x10(%rbp), %rdi
callq 0x5210
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f70
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x51b5
jmp 0x51d4
leaq 0xdc27(%rip), %rdi      # 0x12de3
leaq 0xd88e(%rip), %rsi      # 0x12a51
movl $0x798, %edx            # imm = 0x798
leaq 0xdc30(%rip), %rcx      # 0x12dff
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)