LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/connectionbase.cpp
// Function: ConnectionBase::OnOutgoingConnected(event_type<bufferevent>&&, CConnection)
void ConnectionBase::OnOutgoingConnected(event_type<bufferevent>&& bev, CConnection resolved)
{
    m_bev = std::move(bev);
    DEBUG_PRINT(LOGINFO, "id:", m_id, "outgoing connection: initial:", m_connection.GetHost(), "resolved:", resolved.GetHost());
    InitConnection();

    m_handler.OnOutgoingConnected(m_id, m_connection, std::move(resolved));
    // Don't do anything after OnOutgoingConnected. It may delete *this.
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x1a8(%rdi), %rdi
testq %rdi, %rdi
je 0xeae3
callq 0x10eee
xorl %eax, %eax
movq %rax, 0x1a8(%r14)
movq (%r15), %rcx
movq %rcx, 0x1a8(%r14)
movq %rax, (%r15)
leaq 0x18(%r14), %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x61e6
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x61e6
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeb28
callq 0x4340
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeb3b
callq 0x4340
movq %r14, %rdi
callq 0xe276
movq 0x8(%r14), %rdi
movq 0x190(%r14), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x9894
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xab84
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeb81
callq 0x4340
movq %rbx, %rdi
callq 0x4640
nop
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/connectionbase.cpp
// Function: ConnectionBase::OnIncomingConnected(event_type<bufferevent>&&, sockaddr*, int)
void ConnectionBase::OnIncomingConnected(event_type<bufferevent>&& bev, sockaddr* addr, int addrsize)
{
    m_bev = std::move(bev);
    CConnection resolved(m_connection.GetOptions(), m_connection.GetNetConfig(), addr, addrsize);
    DEBUG_PRINT(LOGINFO, "id:", m_id, "incoming connection. bound to:", m_connection.GetHost(), "incoming:", resolved.GetHost());
    InitConnection();

    m_handler.OnIncomingConnected(m_id, m_connection, std::move(resolved));
    // Don't do anything after OnIncomingConnected. It may delete *this.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1a8(%rdi), %rdi
testq %rdi, %rdi
je 0xebb7
callq 0x10eee
xorl %eax, %eax
movq %rax, 0x1a8(%rbx)
movq (%r14), %rcx
movq %rcx, 0x1a8(%rbx)
movq %rax, (%r14)
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x701a
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x1c(%rax), %xmm2
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movups %xmm2, 0x4c(%rsp)
movq %r14, %rdi
callq 0x7022
movq %rax, %r12
movups (%rax), %xmm0
leaq 0x90(%rsp), %r13
movaps %xmm0, -0x10(%r13)
leaq 0x10(%rax), %rsi
movq %r13, %rdi
callq 0x4ff4
movups 0x28(%r12), %xmm0
movups %xmm0, 0x18(%r13)
movups 0x4c(%rsp), %xmm0
movups %xmm0, 0x1c(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xe0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x68a8
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0xec6e
callq 0x4340
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x61e6
leaq 0xc0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x61e6
leaq 0xd0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeca6
callq 0x4340
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xecb9
callq 0x4340
movq %rbx, %rdi
callq 0xe276
movq 0x8(%rbx), %rdi
movq 0x190(%rbx), %rsi
leaq 0xe0(%rsp), %rcx
movq %r14, %rdx
callq 0x96dc
leaq 0xe0(%rsp), %rdi
callq 0x4e4e
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xab84
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xed37
callq 0x4340
jmp 0xed37
jmp 0xed34
movq %rax, %rbx
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0xed44
callq 0x4340
jmp 0xed44
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x4e4e
movq %rbx, %rdi
callq 0x4640
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/connectionbase.cpp
// Function: ConnectionBase::Write(unsigned char const*, unsigned long)
bool ConnectionBase::Write(const unsigned char* data, size_t size)
{
    bool ret = bufferevent_write(m_bev, data, size) == 0;
    if (ret)
        m_check_write_buffer_func.active();
    return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1a8(%rdi), %rdi
testq %rdi, %rdi
je 0xed84
callq 0x41f0
movl %eax, %ebp
testl %eax, %eax
jne 0xed78
addq $0x230, %rbx            # imm = 0x230
movq %rbx, %rdi
callq 0x11d50
testl %ebp, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x41c8(%rip), %rdi      # 0x12f53
leaq 0x41d2(%rip), %rsi      # 0x12f64
leaq 0x4b7c(%rip), %rcx      # 0x13915
movl $0x4b, %edx
callq 0x4260
nop
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/connectionbase.cpp
// Function: ConnectionBase::write_cb(bufferevent*, void*)
void ConnectionBase::write_cb(bufferevent* bev, void* ctx)
{
    assert(ctx);
    ConnectionBase* base = static_cast<ConnectionBase*>(ctx);
    evbuffer* output = bufferevent_get_output(bev);
    size_t buflen = evbuffer_get_length(output);
    bufferevent_setcb(bev, base->read_cb_ptr, nullptr, event_cb, ctx);
    base->m_handler.OnWriteBufferReady(base->m_id, buflen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xedf7
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4130
movq %rax, %rdi
callq 0x43a0
movq %rax, %r15
movq 0x2a8(%rbx), %rsi
leaq -0xc52(%rip), %rcx      # 0xe180
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0x4360
movq 0x8(%rbx), %rdi
movq 0x190(%rbx), %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x9074
leaq 0x4cba(%rip), %rdi      # 0x13ab8
leaq 0x4b8f(%rip), %rsi      # 0x13994
leaq 0x4e55(%rip), %rcx      # 0x13c61
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x4260
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/proxyconn.cpp
// Function: CProxyConn::Connect()
void CProxyConn::Connect()
{
    assert(m_connection.IsSet());

    const CConnectionOptions& opts = m_connection.GetOptions();

    timeval connTimeout;
    connTimeout.tv_sec = opts.nConnTimeout;
    connTimeout.tv_usec = 0;

    const CConnectionBase& proxy = m_connection.GetProxy();
    assert(proxy.IsSet());

    sockaddr_storage addr_storage;
    int addrlen = sizeof(addr_storage);
    memset(&addr_storage, 0, sizeof(addr_storage));
    sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
    proxy.GetSockAddr(addr, &addrlen);

    if (m_connection.CanConnectProxy())
        BareConnect(m_event_base, m_handler.GetBevOpts(), BAD_SOCKET, addr, addrlen, connTimeout);
    else
        OnConnectionFailure(ConnectionFailureType::PROXY, 0, m_connection, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x63d2
testb %al, %al
je 0xf519
movq %r14, %rdi
callq 0x701a
movslq 0xc(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r14, %rdi
callq 0x7014
movq %rax, %r15
movq %rax, %rdi
callq 0x63d2
testb %al, %al
je 0xf538
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movq %r15, %rdi
callq 0x618e
movq %r14, %rdi
callq 0x7146
testb %al, %al
je 0xf4d7
leaq 0x2b0(%rbx), %r14
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rbx
callq 0x9f56
movl 0xc(%rsp), %r9d
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
leaq 0x20(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xd336
jmp 0xf50c
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x75d0
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe0d6
leaq 0xa8(%rsp), %rdi
callq 0x4e4e
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4088(%rip), %rdi      # 0x135a8
leaq 0x4988(%rip), %rsi      # 0x13eaf
leaq 0x4993(%rip), %rcx      # 0x13ec1
movl $0x1b, %edx
callq 0x4260
leaq 0x49a5(%rip), %rdi      # 0x13ee4
leaq 0x4969(%rip), %rsi      # 0x13eaf
leaq 0x4974(%rip), %rcx      # 0x13ec1
movl $0x24, %edx
callq 0x4260
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x4e4e
movq %rbx, %rdi
callq 0x4640
nop
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/bareproxy.cpp
// Function: CBareProxy::receive_init(bufferevent*, void*)
void CBareProxy::receive_init(bufferevent* bev, void* ctx)
{
    CBareProxy* data = static_cast<CBareProxy*>(ctx);
    const CConnection& conn(data->m_proxy_connection);
    const CProxyAuth& auth(conn.GetProxy().GetAuth());
    char pchRet1[2];
    if (bufferevent_read(bev, pchRet1, sizeof(pchRet1)) != sizeof(pchRet1)) {
        data->ProxyFailure(0);
        return;
    }
    if (pchRet1[0] != 0x05) {
        data->ProxyFailure(0);
        return;
    }

    bool useAuth = pchRet1[1] == 0x02;
    if (useAuth) {
        bufferevent_setcb(bev, check_auth_response, nullptr, event_cb, ctx);
        if (!write_auth(bev, auth)) {
            data->ProxyFailure(0);
            return;
        }
    } else {
        bufferevent_setcb(bev, read_final, nullptr, event_cb, ctx);
        if (!writeproto(bev, conn))
            data->ProxyFailure(0);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
movq %r15, %rdi
callq 0x7014
movq %rax, %rdi
callq 0x6178
movq %rax, %r12
leaq 0x6(%rsp), %rsi
movl $0x2, %edx
movq %r14, %rdi
callq 0x46f0
cmpq $0x2, %rax
jne 0xf965
cmpb $0x5, 0x6(%rsp)
jne 0xf965
cmpb $0x2, 0x7(%rsp)
jne 0xf93b
leaq 0x111c(%rip), %rsi      # 0x10a36
leaq 0x71(%rip), %rcx        # 0xf992
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0x4360
movq %r14, %rdi
movq %r12, %rsi
callq 0xfece
jmp 0xf961
leaq 0x6f8(%rip), %rsi       # 0x1003a
leaq 0x49(%rip), %rcx        # 0xf992
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0x4360
movq %r14, %rdi
movq %r15, %rsi
callq 0xf9f6
testb %al, %al
jne 0xf986
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf973
callq 0x10eee
movq $0x0, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/bareproxy.cpp
// Function: CBareProxy::write_auth(bufferevent*, CProxyAuth const&)
bool CBareProxy::write_auth(bufferevent* bev, const CProxyAuth& auth)
{
    const std::string& username = auth.GetUsername();
    const std::string& password = auth.GetPassword();
    // Perform username/password authentication (as described in RFC1929)
    std::vector<uint8_t> vAuth;
    vAuth.push_back(0x01);
    if (username.size() > 255 || password.size() > 255)
        return false;
    vAuth.push_back(username.size());
    vAuth.insert(vAuth.end(), username.begin(), username.end());
    vAuth.push_back(password.size());
    vAuth.insert(vAuth.end(), password.begin(), password.end());
    bufferevent_setwatermark(bev, EV_READ, 2, 0);
    bufferevent_write(bev, &vAuth[0], vAuth.size());
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5988
movq %rax, %r15
movq %r14, %rdi
callq 0x598c
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x1, 0xf(%rsp)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xff1e
movb $0x1, (%rsi)
incq 0x18(%rsp)
jmp 0xff2d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7f08
movq 0x8(%r15), %rax
cmpq $0xff, %rax
ja 0xff43
cmpq $0xff, 0x8(%r14)
jbe 0xff4a
xorl %ebp, %ebp
jmp 0xfffa
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0xff63
movb %al, (%rsi)
incq 0x18(%rsp)
jmp 0xff72
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7f08
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%r15), %rdx
movq 0x8(%r15), %rcx
addq %rdx, %rcx
callq 0x10ac2
movb 0x8(%r14), %al
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0xffa7
movb %al, (%rsi)
incq 0x18(%rsp)
jmp 0xffb6
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7f08
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
addq %rdx, %rcx
callq 0x10ac2
movl $0x2, %edx
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x40c0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x41f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x10009
callq 0x4340
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10020
jmp 0x10020
jmp 0x10020
jmp 0x10020
jmp 0x10020
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x10032
callq 0x4340
movq %rbx, %rdi
callq 0x4640
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/bareproxy.cpp
// Function: CBareProxy::check_auth_response(bufferevent*, void*)
void CBareProxy::check_auth_response(bufferevent* bev, void* ctx)
{
    CBareProxy* data = static_cast<CBareProxy*>(ctx);
    const CConnection& conn(data->m_proxy_connection);
    char pchRetA[2];

    if (bufferevent_read(bev, pchRetA, sizeof(pchRetA)) != sizeof(pchRetA)) {
        data->ProxyFailure(0);
        return;
    }

    if (pchRetA[0] != 0x01 && pchRetA[1] != 0x00) {
        data->ProxyFailure(0);
        return;
    }

    bufferevent_setcb(bev, read_final, nullptr, event_cb, ctx);

    if (!writeproto(bev, conn)) {
        data->ProxyFailure(0);
        return;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
leaq 0xe(%rsp), %rsi
movl $0x2, %edx
callq 0x46f0
cmpq $0x2, %rax
jne 0x10a96
cmpb $0x1, 0xe(%rsp)
je 0x10a6c
cmpb $0x0, 0xf(%rsp)
jne 0x10a96
leaq -0xa39(%rip), %rsi      # 0x1003a
leaq -0x10e8(%rip), %rcx     # 0xf992
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0x4360
movq %r15, %rdi
movq %r14, %rsi
callq 0xf9f6
testb %al, %al
jne 0x10ab7
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x10aa4
callq 0x10eee
movq $0x0, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/listener.cpp
// Function: CConnListener::listen_error_cb(evconnlistener*, void*)
void CConnListener::listen_error_cb(evconnlistener* /*unused*/, void* ctx)
{
    assert(ctx != nullptr);
    CConnListener* bind = static_cast<CConnListener*>(ctx);
    bind->m_listener.free();
    bind->m_handler.OnListenFailure(bind->m_id, bind->m_connection);
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x111bf
movq %rsi, %rbx
movq 0x190(%rsi), %rdi
testq %rdi, %rdi
je 0x111a0
callq 0x10f0a
movq $0x0, 0x190(%rbx)
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
addq $0x18, %rbx
movq %rbx, %rdx
popq %rbx
jmp 0x9450
leaq 0x233c(%rip), %rdi      # 0x13502
leaq 0x2f01(%rip), %rsi      # 0x140ce
leaq 0x2f79(%rip), %rcx      # 0x1414d
movl $0x44, %edx
callq 0x4260
// File: /workspace/github_cpp_makefile_star2_O1/theuni[P]libbtcnet/src/resolveonly.cpp
// Function: CResolveOnly::OnResolveSuccess(CDNSResponse&&)
void CResolveOnly::OnResolveSuccess(CDNSResponse&& response)
{
    m_request.reset(nullptr);
    std::list<CConnection> connections;
    for (auto it = response.begin(); it != response.end(); ++it)
        connections.emplace_back(m_connection.GetOptions(), m_connection.GetNetConfig(), it->ai_addr, it->ai_addrlen);
    m_retries = m_connection.GetOptions().nRetries;
    m_handler.OnResolveComplete(m_id, m_connection, std::move(connections));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x190(%rdi)
movq %rsp, %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
movq %rax, 0x10(%rcx)
movq %rsi, %rdi
callq 0xba06
leaq 0x40(%rsp), %r13
movq %rax, (%r13)
movq %rbx, 0x30(%rsp)
addq $0x10, %rbx
movq %r12, %rdi
callq 0xba0a
movq %rax, 0x38(%rsp)
movq %r13, %rdi
leaq 0x38(%rsp), %rsi
callq 0xb9b4
testb %al, %al
je 0x1169e
movq %rbx, %rdi
callq 0x701a
movq %rax, %r14
movq %rbx, %rdi
callq 0x7022
movq %rax, %rbp
movq %r13, %rdi
callq 0xb980
movq %rax, %r15
movq %r13, %rdi
callq 0xb980
addq $0x18, %r15
addq $0x10, %rax
movq %rsp, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x11830
movq %rax, %rdi
movq %rsp, %rsi
callq 0x4070
incq 0x10(%rsp)
movq %r13, %rdi
callq 0xb91c
jmp 0x11621
movq %rbx, %rdi
callq 0x701a
movl 0x8(%rax), %eax
movq 0x30(%rsp), %rcx
movl %eax, 0x188(%rcx)
movq 0x8(%rcx), %rsi
movq 0x198(%rcx), %rdi
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdx
movq %rdx, 0x28(%rsp)
movq %rsp, %rdx
cmpq %rdx, %rcx
je 0x11707
leaq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq (%rcx), %rax
movq %rcx, 0x8(%rax)
movq %rdx, 0x8(%rsp)
movq %rdx, (%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x11713
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
leaq 0x18(%rsp), %rcx
movq %rbx, %rdx
callq 0x8e4c
leaq 0x18(%rsp), %rdi
callq 0x4e1c
movq %rsp, %rdi
callq 0x4e1c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4e1c
jmp 0x11759
jmp 0x11756
jmp 0x11756
jmp 0x11756
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4e1c
movq %rbx, %rdi
callq 0x4640
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/ostreamIter2.cc
// Function: main
int main() {
	vector<int> vec;
	istream_iterator<int> in_iter(cin);  // read ints from cin
	istream_iterator<int> eof;           // istream ``end'' iterator
	
	while (in_iter != eof)
		vec.push_back(*in_iter++);
	ostream_iterator<int> out_iter(cout, " ");
	
	for (auto e : vec)
		out_iter = e;  // the assignment writes this element to cout
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x2d3d(%rip), %rax      # 0x3fe0
leaq -0x68(%rbp), %rdi
movq %rax, (%rdi)
movb $0x1, 0xc(%rdi)
callq 0x1410
movb -0x5c(%rbp), %al
testb %al, %al
je 0x130a
leaq -0x48(%rbp), %rbx
leaq -0x68(%rbp), %r14
leaq -0x40(%rbp), %r15
movq -0x68(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl -0x60(%rbp), %ecx
movl %ecx, -0x48(%rbp)
movb %al, -0x44(%rbp)
movq %r14, %rdi
callq 0x1410
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x12f8
movl -0x48(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x1303
movq %r15, %rdi
movq %rbx, %rdx
callq 0x144a
movb -0x5c(%rbp), %al
testb %al, %al
jne 0x12c6
movq 0x2cbf(%rip), %rbx      # 0x3fd0
movq %rbx, -0x50(%rbp)
leaq 0xce8(%rip), %rax       # 0x2004
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
cmpq %r13, %r12
je 0x1350
leaq -0x50(%rbp), %r14
leaq -0x54(%rbp), %r15
movl (%r12), %eax
movl %eax, -0x54(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x13c8
addq $0x4, %r12
cmpq %r13, %r12
jne 0x1335
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq 0x2c62(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1390
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10d0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a7
jmp 0x13a7
jmp 0x13a7
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x13bf
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O1/Couragewang[P]50_clss/TcpClient.cc
// Function: main
int main(int argc, char *argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        exit(1);
    }
    std::string ip = argv[1];
    int port = atoi(argv[2]);
    TcpClient *cli = new TcpClient(ip, port);
    cli->InitClient();
    cli->Start();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x404811
movq 0x8(%rbx), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4048aa
movq 0x10(%rbx), %rdi
callq 0x4c0d60
movl %eax, %r14d
movl $0x30, %edi
callq 0x4058e0
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x404aa0
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
callq 0x404aa0
movl %r14d, 0x28(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x4047db
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x404be0
movq %rbx, %rdi
callq 0x4048e8
movq %rbx, %rdi
callq 0x404934
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x404804
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x404be0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x4048aa
leaq -0x80(%rbp), %rdi
callq 0x4046c8
leaq -0x80(%rbp), %rdi
callq 0x474990
movl $0x1, %edi
callq 0x4c18e0
movq %rax, %r14
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4048a2
movq -0x70(%rbp), %rsi
jmp 0x40489a
jmp 0x404881
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x404872
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x404be0
jmp 0x404872
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x404be0
jmp 0x404889
movq %rax, %r14
jmp 0x4048a2
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4048a2
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x404be0
movq %r14, %rdi
callq 0x4a6010
// File: /workspace/github_cpp_makefile_star2_O1/Couragewang[P]50_clss/./TcpClient.hpp
// Function: TcpClient::InitClient()
void InitClient()
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if(sock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x52e860
movl %eax, (%rbx)
testl %eax, %eax
js 0x40490f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $0x5e4320, %rdi         # imm = 0x5E4320
leaq 0x172706(%rip), %rsi    # 0x577023
callq 0x46e5c0
movq %rax, %rdi
callq 0x46dea0
movl $0x2, %edi
callq 0x4c18e0
// File: /workspace/github_cpp_makefile_star2_O1/Couragewang[P]50_clss/./TcpClient.hpp
// Function: TcpClient::Start()
void Start()
        {
            struct sockaddr_in peer;
            bzero(&peer, sizeof(peer));
            peer.sin_family = AF_INET;
            peer.sin_port = htons(port);
            peer.sin_addr.s_addr = inet_addr(ip.c_str());

            if(connect(sock, (struct sockaddr*)&peer, sizeof(peer)) < 0){
                std::cerr << "connect error" << std::endl;
                exit(3);
            }
            char buf[1024];
            std::string in;
            while(1){
                std::cout << "Please Enter# ";
                std::cin >> in;
                write(sock, in.c_str(), in.size());
                ssize_t s = read(sock, buf, sizeof(buf)-1);
                if(s > 0){
                    buf[s] = 0;
                    std::cout << "Server Echo# " << buf << std::endl;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r14
movaps %xmm0, (%r14)
movw $0x2, (%r14)
movzwl 0x28(%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movq 0x8(%rdi), %rdi
callq 0x52f450
movl %eax, 0x4(%r14)
movl (%rbx), %edi
movq %r14, %rsi
movl $0x10, %edx
callq 0x52e7c0
testl %eax, %eax
jns 0x4049ae
movq $0x5e4320, %rdi         # imm = 0x5E4320
leaq 0x172699(%rip), %rsi    # 0x577030
callq 0x46e5c0
movq %rax, %rdi
callq 0x46dea0
movl $0x3, %edi
callq 0x4c18e0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq $0x5e4440, %r14         # imm = 0x5E4440
movq $0x5e4560, %r12         # imm = 0x5E4560
leaq -0x48(%rbp), %r13
leaq -0x460(%rbp), %r15
movl $0xe, %edx
movq %r14, %rdi
leaq 0x172655(%rip), %rsi    # 0x57703e
callq 0x46e090
movq %r12, %rdi
movq %r13, %rsi
callq 0x406590
movl (%rbx), %edi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x52b990
movl (%rbx), %edi
movl $0x3ff, %edx            # imm = 0x3FF
movq %r15, %rsi
callq 0x52b8f0
testq %rax, %rax
jle 0x4049da
movb $0x0, -0x460(%rbp,%rax)
movl $0xd, %edx
movq %r14, %rdi
leaq 0x17261a(%rip), %rsi    # 0x57704d
callq 0x46e090
movq %r15, %rdi
callq 0x401110
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x46e090
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x44f1e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x46db90
movq %rax, %rdi
callq 0x46d160
jmp 0x4049da
jmp 0x404a7c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x404a98
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x404be0
movq %rbx, %rdi
callq 0x4a6010
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Sigma(gaps::R3Mesh*)
RNScalar
Sigma(R3Mesh *mesh)
{
  // Compute smallest sigma
  static RNScalar sigma = 0;
  static R3Mesh *last_mesh = NULL;
  if (mesh != last_mesh) {
    sigma = 0.005 * sqrt(mesh->Area());
    last_mesh = mesh;
  }

  // Return sigma
  return sigma;
}

// Assembly:
cmpq %rdi, 0xffd9d(%rip)     # 0x112d30
je 0x12fcb
pushq %rbx
movq %rdi, %rbx
callq 0x1ffe0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x12fae
sqrtsd %xmm0, %xmm0
jmp 0x12fb3
callq 0x10420
mulsd 0xb104d(%rip), %xmm0    # 0xc4008
movsd %xmm0, 0xffd65(%rip)    # 0x112d28
movq %rbx, 0xffd66(%rip)     # 0x112d30
popq %rbx
movsd 0xffd55(%rip), %xmm0    # 0x112d28
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: InsertProperty(gaps::R3MeshPropertySet*, gaps::R3MeshProperty*, int)
int 
InsertProperty(R3MeshPropertySet *properties, R3MeshProperty *property, int num_blurs = 0)
{
  // Insert property
  properties->Insert(property);

  // Insert coies of property with increasing blur
  if (num_blurs > 0) {
    char buffer[4096];
    RNScalar sigma = Sigma(properties->Mesh());
    R3MeshProperty *p = property;
    for (int i = 1; i < num_blurs; i++) {
      p = new R3MeshProperty(*p);
      sprintf(buffer, "%s%d", property->Name(), i);
      p->SetName(buffer);
      p->Blur(sigma);
      properties->Insert(p);
      sigma *= 2;
    }
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
callq 0x1a4e8
testl %ebp, %ebp
jle 0x130dc
movq (%r12), %r15
cmpq %r15, 0xffd2b(%rip)     # 0x112d30
je 0x1303b
movq %r15, %rdi
callq 0x1ffe0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1301f
sqrtsd %xmm0, %xmm0
jmp 0x13024
callq 0x10420
mulsd 0xb0fdc(%rip), %xmm0    # 0xc4008
movsd %xmm0, 0xffcf4(%rip)    # 0x112d28
movq %r15, 0xffcf5(%rip)     # 0x112d30
cmpl $0x1, %ebp
je 0x130dc
movsd 0xffcdc(%rip), %xmm0    # 0x112d28
movsd %xmm0, (%rsp)
cmpl $0x3, %ebp
movl $0x2, %r14d
cmovgel %ebp, %r14d
leaq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %ebp
leaq 0x10(%rsp), %r13
movq %rbx, %r15
movl $0x448, %edi            # imm = 0x448
callq 0x10550
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1bf8c
movq %r13, %rdi
leaq 0xb10aa(%rip), %rsi     # 0xc4140
movq 0x8(%rsp), %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10100
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1da58
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x1e076
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1a4e8
movsd (%rsp), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, (%rsp)
incl %ebp
cmpl %ebp, %r14d
jne 0x13071
movl $0x1, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x448, %esi            # imm = 0x448
movq %rbx, %rdi
callq 0x10560
movq %r14, %rdi
callq 0x109f0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Percentile(double*, int, double)
static RNScalar
Percentile(RNScalar *values, int nvalues, RNScalar percentile)
{
  // Return value at given percentile (0-100)
  if (nvalues == 0) return 0;
  RNScalar *copy = new RNScalar [ nvalues ];
  for (int i = 0; i < nvalues; i++) copy[i] = values[i];
  qsort(copy, nvalues, sizeof(RNScalar), RNCompareScalars);
  int index = (int) (percentile * nvalues / 100.0);
  if (index >= nvalues) index = nvalues-1;
  RNScalar result = copy[index];
  delete [] copy;
  return result;
}

// Assembly:
testl %esi, %esi
je 0x18d91
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r12
movsd %xmm0, (%rsp)
movslq %esi, %r15
leaq (,%r15,8), %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x10040
movq %rax, %r14
testl %ebx, %ebx
jle 0x18d33
movl %ebx, %edx
shlq $0x3, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x10460
leaq 0x6743f(%rip), %rcx     # 0x80179
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10ac0
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd (%rsp), %xmm0
divsd 0xab35a(%rip), %xmm0    # 0xc40b8
cvttsd2si %xmm0, %eax
leal -0x1(%rbx), %ecx
cmpl %ebx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
movsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x10730
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/marknelson[P]LZW/./lzw-d.h
// Function: lzw::output_code_stream<std::ostream>::operator<<(unsigned int const&)
void operator<<( const unsigned int &i )
    {
        m_pending_output |= i << m_pending_bits;
        m_pending_bits += m_code_size;
        flush( 8 );
        if ( m_current_code < m_max_code ) {
            m_current_code++;
            if ( m_current_code == m_next_bump ) {
                m_next_bump *= 2;
                m_code_size++;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
movl 0x10(%rdi), %ecx
shll %cl, %eax
orl %eax, 0x14(%rdi)
addl (%rdi), %ecx
movl %ecx, 0x10(%rdi)
movl $0x8, %esi
callq 0x3472
movl 0x18(%rbx), %eax
cmpl 0x20(%rbx), %eax
jae 0x2cc1
incl %eax
movl %eax, 0x18(%rbx)
movl 0x1c(%rbx), %ecx
cmpl %ecx, %eax
jne 0x2cc1
addl %ecx, %ecx
movl %ecx, 0x1c(%rbx)
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marknelson[P]LZW/./lzw-d.h
// Function: lzw::output_code_stream<std::ostream>::flush(int)
void flush( const int val )
    {
        while ( m_pending_bits >= val ) {
            m_output.put( m_pending_output & 0xff );
            m_pending_output >>= 8;
            m_pending_bits -= 8;
        }
    }

// Assembly:
cmpl %esi, 0x10(%rdi)
jl 0x34a9
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%r14), %rdi
movsbl 0x14(%r14), %esi
callq 0x2030
shrl $0x8, 0x14(%r14)
movl 0x10(%r14), %eax
addl $-0x8, %eax
movl %eax, 0x10(%r14)
cmpl %ebx, %eax
jge 0x3483
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marknelson[P]LZW/./lzw-d.h
// Function: lzw::input_code_stream<std::istream>::operator>>(unsigned int&)
bool operator>>( unsigned int &i )
    {
        while ( m_available_bits < m_code_size )
        {
            char c;
            if ( !m_input.get(c) )
                return false;
            m_pending_input |= (c & 0xff) << m_available_bits;
            m_available_bits += 8;
        }
        i = m_pending_input & ~(~0 << m_code_size);
        m_pending_input >>= m_code_size;
        m_available_bits -= m_code_size;
        if ( m_current_code < m_max_code ) {
            m_current_code++;
            if ( m_current_code == m_next_bump ) {
                m_next_bump *= 2;
                m_code_size++;
            }
        }
        if ( i == EOF_CODE )
            return false;
        else
            return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
cmpl %ecx, 0x10(%rdi)
jge 0x3525
leaq -0x19(%rbp), %r15
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x21b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x356d
movzbl -0x19(%rbp), %edx
movl 0x10(%r14), %eax
movl %eax, %ecx
shll %cl, %edx
orl %edx, 0x14(%r14)
addl $0x8, %eax
movl %eax, 0x10(%r14)
movl (%r14), %ecx
cmpl %ecx, %eax
jl 0x34ed
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0x14(%r14), %eax
movl %eax, (%rbx)
movl (%r14), %ecx
movl 0x18(%r14), %eax
shrl %cl, 0x14(%r14)
subl %ecx, 0x10(%r14)
cmpl 0x20(%r14), %eax
jae 0x3562
incl %eax
movl %eax, 0x18(%r14)
movl 0x1c(%r14), %edx
cmpl %edx, %eax
jne 0x3562
addl %edx, %edx
movl %edx, 0x1c(%r14)
incl %ecx
movl %ecx, (%r14)
cmpl $0x100, (%rbx)          # imm = 0x100
setne %al
jmp 0x356f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::DiskSpaceWorker(uv_work_s*)
void DiskSpaceWorker(uv_work_t *request) {
        reqData_t *requestData = reinterpret_cast<reqData_t *>(request->data);

        // Call the Inner Function
        requestData->error = GetDiskSpace(
            requestData->diskPath,
            &(requestData->available),
            &(requestData->total),
            &(requestData->free)
         );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rsi
leaq 0x28(%rbx), %rdx
leaq 0x20(%rbx), %rcx
callq 0x21e0
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::checkArgs(v8::FunctionCallbackInfo<v8::Value> const&)
bool checkArgs(const FunctionCallbackInfo<Value> &args) {
        Isolate *isolate = args.GetIsolate();

        // Check the args
        if (args.Length() != 2) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "diskPath and callback are required", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        } else if (!args[0]->IsString()) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "diskPath should be a string", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        } else if (!args[1]->IsFunction()) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "diskPath should be a function", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rbx
cmpl $0x2, 0x10(%rdi)
jne 0x2630
movq 0x8(%rdi), %rax
movq (%rax), %rax
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x1, %ecx
jne 0x2639
movq -0x1(%rax), %rax
cmpw $0x40, 0xb(%rax)
jae 0x2639
movq 0x8(%rdi), %rdi
addq $-0x8, %rdi
callq 0x2050
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x266c
leaq 0xa5d(%rip), %rsi       # 0x308b
jmp 0x2640
leaq 0xa15(%rip), %rsi       # 0x304c
jmp 0x2640
leaq 0xa2f(%rip), %rsi       # 0x306f
movq %rbx, %rdi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2290
movq %rax, %r14
testq %rax, %rax
je 0x2671
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2120
jmp 0x2657
// File: /workspace/github_cpp_makefile_star2_O1/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::DiskSpace(v8::FunctionCallbackInfo<v8::Value> const&)
void DiskSpace(const FunctionCallbackInfo<Value> &args) {
        Isolate *isolate = args.GetIsolate();

        // Check the input args
        bool shouldRun = checkArgs(args);
        if (!shouldRun) {
            return;
        }

        // Get the Args
        String::Utf8Value diskPath(isolate, args[0]);
        Local<Function> callback = Local<Function>::Cast(args[1]);

        // Copy the string into a C String (+1 or the null char)
        char *diskPathC = (char *) calloc(diskPath.length() + 1, sizeof(char));
        strcpy(diskPathC, *diskPath);

        // Store the args in a request
        reqData_t *requestData = new reqData_t();
        requestData->callback.Reset(isolate, callback);
        requestData->diskPath = diskPathC;

        // Run the worker
        uv_work_t *request = new uv_work_t();
        request->data = requestData;

        uv_queue_work(uv_default_loop(), request, &DiskSpaceWorker, &AfterDiskSpaceWorker);

        // Return to the parent early
        args.GetReturnValue().Set(Undefined(isolate));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rbx
callq 0x2160
testb %al, %al
je 0x279d
cmpl $0x0, 0x10(%r14)
jle 0x26ad
movq 0x8(%r14), %rdx
jmp 0x26b8
movq (%r14), %rax
movq 0x8(%rax), %rdx
addq $0x58, %rdx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x20b0
cmpl $0x1, 0x10(%r14)
jle 0x26d5
movq 0x8(%r14), %r15
addq $-0x8, %r15
jmp 0x26e0
movq (%r14), %rax
movq 0x8(%rax), %r15
addq $0x58, %r15
movslq -0x30(%rbp), %rdi
incq %rdi
movl $0x1, %esi
callq 0x21d0
movq %rax, %r13
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
movl $0x30, %edi
callq 0x2080
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
testq %r15, %r15
je 0x272f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
movq %rax, (%r12)
movq %r13, 0x8(%r12)
movl $0x80, %edi
callq 0x2080
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x70(%rax)
movq %r12, (%rax)
callq 0x2230
movq 0x2856(%rip), %rdx      # 0x4fc8
movq 0x286f(%rip), %rcx      # 0x4fe8
movq %rax, %rdi
movq %r15, %rsi
callq 0x20f0
movq (%r14), %rax
addq $0x58, %rbx
je 0x27ac
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
leaq -0x38(%rbp), %rdi
callq 0x21c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rax), %rbx
jmp 0x278d
// File: /workspace/github_cpp_makefile_star2_O1/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::checkErrorcodeArgs(v8::FunctionCallbackInfo<v8::Value> const&)
bool checkErrorcodeArgs(const FunctionCallbackInfo<Value> &args) {
        Isolate *isolate = args.GetIsolate();

        // Check the args
        if (args.Length() != 1) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "errno is required", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        } else if (!args[0]->IsNumber()) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "errno should be a Number", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rbx
cmpl $0x1, 0x10(%rdi)
jne 0x27e0
movq 0x8(%rdi), %rdi
callq 0x2170
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2813
leaq 0x8dd(%rip), %rsi       # 0x30bb
jmp 0x27e7
leaq 0x8c2(%rip), %rsi       # 0x30a9
movq %rbx, %rdi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2290
movq %rax, %r14
testq %rax, %rax
je 0x2818
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2120
jmp 0x27fe
// File: /workspace/github_cpp_makefile_star2_O1/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::checkErr(v8::FunctionCallbackInfo<v8::Value> const&, bool (*)(unsigned long))
void checkErr(const FunctionCallbackInfo<Value> &args, diskErrFunc_t errChecker) {
        Isolate *isolate = args.GetIsolate();
        Local<Context> context = isolate->GetCurrentContext();

        // Check the input args
        bool shouldRun = checkErrorcodeArgs(args);
        if (!shouldRun) {
            return;
        }

        // Get the args
        double error;
        if (args[0]->IsUndefined()) {
            error = 0;
        } else {
            error = args[0]->NumberValue(context).FromMaybe(0);
        }

        // Convert to proper type
        args.GetReturnValue().Set(
            static_cast<double>(errChecker(static_cast<uint64_t>(error)))
        );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x2130
movq %rax, %r15
movq %r14, %rdi
callq 0x2110
testb %al, %al
je 0x28f1
movl 0x10(%r14), %eax
testl %eax, %eax
jle 0x285c
movq 0x8(%r14), %rcx
jmp 0x2867
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
addq $0x58, %rcx
movq (%rcx), %rcx
movl %ecx, %edx
andl $0x3, %edx
cmpl $0x1, %edx
jne 0x2889
movq -0x1(%rcx), %rdx
cmpw $0x43, 0xb(%rdx)
jne 0x2889
cmpl $0x5, 0x2b(%rcx)
jne 0x2889
xorl %edi, %edi
jmp 0x28cd
testl %eax, %eax
jle 0x2893
movq 0x8(%r14), %rdi
jmp 0x289e
movq (%r14), %rax
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movq %r15, %rsi
callq 0x2100
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x76e(%rip), %xmm0      # 0x3028
cvttsd2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
xorl %edi, %edi
testb $0x1, %al
cmovneq %rsi, %rdi
movq (%r14), %r14
callq *%rbx
movzbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x8(%r14), %rdi
callq 0x2200
testq %rax, %rax
je 0x28fc
movq (%rax), %rax
movq %rax, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%r14), %rax
jmp 0x28ea
// File: /workspace/github_cpp_makefile_star2_O1/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::init(v8::Local<v8::Object>)
void init(Local<Object> exports) {
        NODE_SET_METHOD(exports, "check", DiskSpace);
        NODE_SET_METHOD(exports, "isErrDenied", nodeIsErrDenied);
        NODE_SET_METHOD(exports, "isErrBadPath", nodeIsErrBadPath);
        NODE_SET_METHOD(exports, "isErrIO", nodeIsErrIO);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x78f(%rip), %rsi       # 0x30d4
movq 0x2674(%rip), %rdx      # 0x4fc0
callq 0x22a0
leaq 0x782(%rip), %rsi       # 0x30da
movq 0x2659(%rip), %rdx      # 0x4fb8
movq %rbx, %rdi
callq 0x22a0
leaq 0x778(%rip), %rsi       # 0x30e6
movq 0x2683(%rip), %rdx      # 0x4ff8
movq %rbx, %rdi
callq 0x22a0
leaq 0x76f(%rip), %rsi       # 0x30f3
movq 0x260d(%rip), %rdx      # 0x4f98
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/fiveseven-lambda[P]michaelis-menten/a.cpp
// Function: in_polygon(Vector<short> const&, std::vector<XPoint, std::allocator<XPoint>> const&)
bool in_polygon(const Vector<short> &p, const std::vector<XPoint> &v){
	bool ret = false;
	for(std::size_t i = 0; i < v.size(); ++i){
		std::size_t j = i + 1;
		if(j == v.size()) j = 0;
		bool tmp = (p.x - v[i].x) * (v[j].y - v[i].y) < (p.y - v[i].y) * (v[j].x - v[i].x);
		if(v[i].y <= p.y && v[j].y > p.y){
			ret ^= tmp;
		}else if(v[i].y > p.y && v[j].y <= p.y){
			ret ^= !tmp;
		}
	}
	return ret;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
je 0x2818
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
sarq $0x2, %rdx
movswl (%rdi), %esi
movswl 0x2(%rdi), %edi
xorl %eax, %eax
cmpq $0x1, %rdx
movl $0x0, %r8d
sbbq %rdx, %r8
movl $0x1, %r9d
cmpq %r9, %rdx
movl $0x0, %r14d
cmovneq %r9, %r14
movswl -0x4(%rcx,%r9,4), %r15d
movl %esi, %r12d
subl %r15d, %r12d
movswl 0x2(%rcx,%r14,4), %r11d
movswl -0x2(%rcx,%r9,4), %ebx
movl %r11d, %r10d
subl %ebx, %r10d
imull %r12d, %r10d
movl %edi, %r12d
subl %ebx, %r12d
movswl (%rcx,%r14,4), %r14d
subl %r15d, %r14d
imull %r12d, %r14d
cmpw %di, %bx
jg 0x27db
cmpw %di, %r11w
jle 0x27db
cmpl %r14d, %r10d
setl %r10b
xorb %al, %r10b
jmp 0x27f3
cmpw %di, %bx
jle 0x27fa
cmpw %di, %r11w
jg 0x27fa
cmpl %r14d, %r10d
setl %r10b
xorb %al, %r10b
notb %r10b
andb $0x1, %r10b
movl %r10d, %eax
leaq (%r8,%r9), %r10
incq %r10
incq %r9
cmpq $0x1, %r10
jne 0x2783
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x281a
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/sbingner[P]kerneldec/lzfse/src/lzfse_encode.c
// Function: lzfse_encode_buffer
size_t lzfse_encode_buffer(uint8_t *__restrict dst_buffer, size_t dst_size,
                           const uint8_t *__restrict src_buffer,
                           size_t src_size, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_encode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL)
    return 0;
  ret = lzfse_encode_buffer_with_scratch(dst_buffer, 
                        dst_size, src_buffer, 
                        src_size, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %r8, %rbp
testq %r8, %r8
jne 0x38ed
callq 0x73f8
cmpq $0xa7161, %rax          # imm = 0xA7161
movl $0xa7160, %edi          # imm = 0xA7160
cmovaeq %rax, %rdi
incq %rdi
callq 0x30d0
movq %rax, %rbp
testq %rbp, %rbp
je 0x3918
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r8
callq 0x369b
movq %rax, %r14
testq %rbx, %rbx
jne 0x391b
movq %rbp, %rdi
callq 0x3030
jmp 0x391b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_buffer_with_scratch
size_t lzfse_decode_buffer_with_scratch(uint8_t *__restrict dst_buffer, 
                         size_t dst_size, const uint8_t *__restrict src_buffer,
                         size_t src_size, void *__restrict scratch_buffer) {
  lzfse_decoder_state *s = (lzfse_decoder_state *)scratch_buffer;
  memset(s, 0x00, sizeof(*s));

  // Initialize state
  s->src = src_buffer;
  s->src_begin = src_buffer;
  s->src_end = s->src + src_size;
  s->dst = dst_buffer;
  s->dst_begin = dst_buffer;
  s->dst_end = dst_buffer + dst_size;

  // Decode
  int status = lzfse_decode(s);
  if (status == LZFSE_STATUS_DST_FULL)
    return dst_size;
  if (status != LZFSE_STATUS_OK)
    return 0;                           // failed
  return (size_t)(s->dst - dst_buffer); // bytes written
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movl $0xb920, %edx           # imm = 0xB920
movq %r8, %rdi
xorl %esi, %esi
callq 0x3080
movq %r13, (%r14)
movq %r13, 0x8(%r14)
addq %r13, %r12
movq %r12, 0x10(%r14)
movq %r15, 0x18(%r14)
movq %r15, 0x20(%r14)
leaq (%r15,%rbx), %rax
movq %rax, 0x28(%r14)
movq %r14, %rdi
callq 0x53dc
cmpl $-0x2, %eax
je 0x3997
testl %eax, %eax
jne 0x3995
movq 0x18(%r14), %rbx
subq %r15, %rbx
jmp 0x3997
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq