LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: SplitHostPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
    size_t colon = in.find_last_of(':');
    // if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
    bool fHaveColon = colon != in.npos;
    bool fBracketed = fHaveColon && (in[0]=='[' && in[colon-1]==']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
    bool fMultiColon = fHaveColon && (in.find_last_of(':',colon-1) != in.npos);
    if (fHaveColon && (colon==0 || fBracketed || !fMultiColon)) {
        char *endp = NULL;
        int n = strtol(in.c_str() + colon + 1, &endp, 10);
        if (endp && *endp == 0 && n >= 0) {
            in = in.substr(0, colon);
            if (n > 0 && n < 0x10000)
                portOut = n;
        }
    }
    if (in.size()>0 && in[0] == '[' && in[in.size()-1] == ']')
        hostOut = in.substr(1, in.size()-2);
    else
        hostOut = in;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x3a, %esi
movq $-0x1, %rdx
callq 0x36f0
cmpq $-0x1, %rax
je 0x72aa
movq %rax, %r12
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x720c
cmpb $0x5d, -0x1(%rax,%r12)
sete %bpl
jmp 0x720e
xorl %ebp, %ebp
leaq -0x1(%r12), %rdx
movq %r14, %rdi
movl $0x3a, %esi
callq 0x36f0
cmpq $0x1, %r12
jb 0x7231
testb %bpl, %bpl
jne 0x7231
cmpq $-0x1, %rax
jne 0x72aa
leaq 0x20(%rsp), %rbp
movq $0x0, (%rbp)
movq (%r14), %rax
leaq (%rax,%r12), %rdi
incq %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x3540
movq %rax, %r13
movq (%rbp), %rax
testq %rax, %rax
je 0x72aa
cmpb $0x0, (%rax)
jne 0x72aa
testl %r13d, %r13d
js 0x72aa
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x3410
movq %r14, %rdi
movq %rbp, %rsi
callq 0x34a0
movq (%rbp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x729c
callq 0x33d0
leal -0x1(%r13), %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
ja 0x72aa
movl %r13d, (%r15)
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x72f8
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x72f8
cmpb $0x5d, -0x1(%rax,%rcx)
jne 0x72f8
addq $-0x2, %rcx
movq %rsp, %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3410
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34a0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7303
callq 0x33d0
jmp 0x7303
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: LookupHost(char const*, std::vector<CNetAddr, std::allocator<CNetAddr>>&, unsigned int, bool)
bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigned int nMaxSolutions, bool fAllowLookup)
{
    if (pszName[0] == 0)
        return false;
    char psz[256];
    char *pszHost = psz;
    strlcpy(psz, pszName, sizeof(psz));
    if (psz[0] == '[' && psz[strlen(psz)-1] == ']')
    {
        pszHost = psz+1;
        psz[strlen(psz)-1] = 0;
    }

    return LookupIntern(pszHost, vIP, nMaxSolutions, fAllowLookup);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x7344
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
xorl %eax, %eax
cmpq $0xff, %rax
je 0x7347
movb (%rdi,%rax), %cl
movb %cl, (%rsp,%rax)
incq %rax
testb %cl, %cl
jne 0x732d
jmp 0x734b
xorl %eax, %eax
retq
movb $0x0, (%rsp,%rax)
cmpb $0x5b, (%rsp)
jne 0x7370
movq %rsp, %r15
movq %r15, %rdi
callq 0x31c0
cmpb $0x5d, -0x1(%rax,%r15)
jne 0x7373
leaq 0x1(%rsp), %r15
movb $0x0, -0x1(%rsp,%rax)
jmp 0x7373
movq %rsp, %r15
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7392
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: Lookup(char const*, std::vector<CService, std::allocator<CService>>&, int, bool, unsigned int)
bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions)
{
    if (pszName[0] == 0)
        return false;
    int port = portDefault;
    std::string hostname = "";
    SplitHostPort(std::string(pszName), port, hostname);

    std::vector<CNetAddr> vIP;
    bool fRet = LookupIntern(hostname.c_str(), vIP, nMaxSolutions, fAllowLookup);
    if (!fRet)
        return false;
    vAddr.resize(vIP.size());
    for (unsigned int i = 0; i < vIP.size(); i++)
        vAddr[i] = CService(vIP[i], port);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpb $0x0, (%rdi)
je 0x7717
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, 0xc(%rsp)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc129(%rip), %rdx      # 0x13745
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x5b14
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rdi
callq 0x31c0
leaq (%rax,%r15), %rdx
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x5b14
leaq 0x48(%rsp), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x71c3
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x766e
callq 0x33d0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x28(%rsp), %rdi
movzbl %r14b, %ecx
movl %ebp, %edx
callq 0x7392
movl %eax, %ebp
movq 0x10(%rsp), %rdi
testb %al, %al
je 0x76fc
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0xa396
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x76fc
movzwl 0xc(%rsp), %eax
movl $0x1, %ecx
xorl %edx, %edx
movq (%rbx), %rsi
leaq (%rdx,%rdx,8), %r8
shlq $0x4, %rdx
movups (%rdi,%rdx), %xmm0
movups %xmm0, (%rsi,%r8,2)
movw %ax, 0x10(%rsi,%r8,2)
movl %ecx, %edx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
sarq $0x4, %rsi
incl %ecx
cmpq %rdx, %rsi
ja 0x76c8
testq %rdi, %rdi
je 0x7706
callq 0x33d0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7719
callq 0x33d0
jmp 0x7719
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
jne 0x774b
jmp 0x7750
movq %rax, %rbx
jmp 0x7750
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7750
callq 0x33d0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x775f
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: Lookup(char const*, CService&, int, bool)
bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup)
{
    std::vector<CService> vService;
    bool fRet = Lookup(pszName, vService, portDefault, fAllowLookup, 1);
    if (!fRet)
        return false;
    addr = vService[0];
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl $0x1, %r8d
callq 0x75e4
movl %eax, %ebp
movq (%rsp), %rdi
testb %al, %al
je 0x77a6
movzwl 0x10(%rdi), %eax
movw %ax, 0x10(%rbx)
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
jmp 0x77ab
testq %rdi, %rdi
je 0x77b0
callq 0x33d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x77ca
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: SetProxy(Network, CService, int)
bool SetProxy(enum Network net, CService addrProxy, int nSocksVersion) {
    assert(net >= 0 && net < NET_MAX);
    if (nSocksVersion != 0 && nSocksVersion != 4 && nSocksVersion != 5)
        return false;
    if (nSocksVersion != 0 && !addrProxy.IsValid())
        return false;
    proxyInfo[net] = std::make_pair(addrProxy, nSocksVersion);
    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x5, %edi
jae 0x7831
movl %esi, %ebx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
leal -0x4(%rbx), %eax
cmpl $0x2, %eax
jae 0x7803
movq %r14, %rdi
callq 0x7850
testb %al, %al
jne 0x7807
xorl %eax, %eax
jmp 0x782c
testl %ebx, %ebx
jne 0x77ff
movl %ebp, %eax
leaq (%rax,%rax,2), %rax
leaq 0x14bcc(%rip), %rcx     # 0x1c3e0
movzwl 0x10(%r14), %edx
movw %dx, 0x10(%rcx,%rax,8)
movups (%r14), %xmm0
movups %xmm0, (%rcx,%rax,8)
movl %ebx, 0x14(%rcx,%rax,8)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbb2c(%rip), %rdi      # 0x13364
leaq 0xbb3f(%rip), %rsi      # 0x1337e
leaq 0xbb44(%rip), %rcx      # 0x1338a
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: GetProxy(Network, CService&)
bool GetProxy(enum Network net, CService &addrProxy) {
    assert(net >= 0 && net < NET_MAX);
    if (!proxyInfo[net].second)
        return false;
    addrProxy = proxyInfo[net].first;
    return true;
}

// Assembly:
cmpl $0x5, %edi
jae 0x78f9
movl %edi, %eax
leaq (%rax,%rax,2), %rcx
leaq 0x14b07(%rip), %rdx     # 0x1c3e0
movl 0x14(%rdx,%rcx,8), %eax
testl %eax, %eax
je 0x78f3
leaq (%rdx,%rcx,8), %rcx
movzwl 0x10(%rcx), %edx
movw %dx, 0x10(%rsi)
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
testl %eax, %eax
setne %al
retq
pushq %rax
leaq 0xba63(%rip), %rdi      # 0x13364
leaq 0xba76(%rip), %rsi      # 0x1337e
leaq 0xbaa6(%rip), %rcx      # 0x133b5
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: SetNameProxy(CService, int)
bool SetNameProxy(CService addrProxy, int nSocksVersion) {
    if (nSocksVersion != 0 && nSocksVersion != 5)
        return false;
    if (nSocksVersion != 0 && !addrProxy.IsValid())
        return false;
    nameproxyInfo = std::make_pair(addrProxy, nSocksVersion);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x20(%rsp), %r14
testl %edi, %edi
je 0x7939
cmpl $0x5, %ebx
jne 0x795a
movq %r14, %rdi
callq 0x7850
testb %al, %al
je 0x795a
movzwl 0x10(%r14), %eax
movw %ax, 0x14b23(%rip)      # 0x1c468
movups (%r14), %xmm0
movups %xmm0, 0x14b08(%rip)    # 0x1c458
movl %ebx, 0x14b16(%rip)     # 0x1c46c
movb $0x1, %al
jmp 0x795c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: IsProxy(CNetAddr const&)
bool IsProxy(const CNetAddr &addr) {
    for (int i=0; i<NET_MAX; i++) {
        if (proxyInfo[i].second && (addr == (CNetAddr)proxyInfo[i].first))
            return true;
    }
    return false;
}

// Assembly:
movb $0x1, %al
leaq 0x14a68(%rip), %rcx     # 0x1c3e0
xorl %edx, %edx
cmpl $0x0, 0x14(%rcx)
je 0x799e
movdqu (%rcx), %xmm0
movdqa %xmm0, -0x18(%rsp)
movdqu (%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x79b6
cmpq $0x4, %rdx
leaq 0x1(%rdx), %rsi
setb %al
addq $0x18, %rcx
movq %rsi, %rdx
cmpq $0x5, %rsi
jne 0x797a
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::GetNetwork() const
enum Network CNetAddr::GetNetwork() const
{
    if (!IsRoutable())
        return NET_UNROUTABLE;

    if (IsIPv4())
        return NET_IPV4;

    if (IsTor())
        return NET_TOR;

    if (IsI2P())
        return NET_I2P;

    return NET_IPV6;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9450
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x7e85
movl 0x8(%rbx), %eax
movl $0xffff0000, %ecx       # imm = 0xFFFF0000
xorq %rax, %rcx
orq (%rbx), %rcx
je 0x7e79
movl $0x7ed887fd, %eax       # imm = 0x7ED887FD
xorl (%rbx), %eax
movzwl 0x4(%rbx), %ecx
xorl $0x43eb, %ecx           # imm = 0x43EB
orl %eax, %ecx
je 0x7e80
movl $0x4ddb60fd, %eax       # imm = 0x4DDB60FD
xorl (%rbx), %eax
movzwl 0x4(%rbx), %ecx
xorl $0xb5dd, %ecx           # imm = 0xB5DD
xorl %edx, %edx
orl %eax, %ecx
sete %dl
leal 0x2(,%rdx,2), %eax
jmp 0x7e85
movl $0x1, %eax
jmp 0x7e85
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::CNetAddr(char const*, bool)
CNetAddr::CNetAddr(const char *pszIp, bool fAllowLookup)
{
    Init();
    std::vector<CNetAddr> vIP;
    if (LookupHost(pszIp, vIP, 1, fAllowLookup))
        *this = vIP[0];
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, %rdi
movl $0x1, %edx
callq 0x7312
movq (%rsp), %rdi
testb %al, %al
je 0x91ba
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
jmp 0x91bf
testq %rdi, %rdi
je 0x91c4
callq 0x33d0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x91db
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::CNetAddr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CNetAddr::CNetAddr(const std::string &strIp, bool fAllowLookup)
{
    Init();
    std::vector<CNetAddr> vIP;
    if (LookupHost(strIp.c_str(), vIP, 1, fAllowLookup))
        *this = vIP[0];
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x7312
movq (%rsp), %rdi
testb %al, %al
je 0x9222
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
jmp 0x9227
testq %rdi, %rdi
je 0x922c
callq 0x33d0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9243
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::GetSockAddr(sockaddr*, unsigned int*) const
bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
{
    if (IsIPv4()) {
        if (*addrlen < (socklen_t)sizeof(struct sockaddr_in))
            return false;
        *addrlen = sizeof(struct sockaddr_in);
        struct sockaddr_in *paddrin = (struct sockaddr_in*)paddr;
        memset(paddrin, 0, *addrlen);
        if (!GetInAddr(&paddrin->sin_addr))
            return false;
        paddrin->sin_family = AF_INET;
        paddrin->sin_port = htons(port);
        return true;
    }
    if (IsIPv6()) {
        if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6))
            return false;
        *addrlen = sizeof(struct sockaddr_in6);
        struct sockaddr_in6 *paddrin6 = (struct sockaddr_in6*)paddr;
        memset(paddrin6, 0, *addrlen);
        if (!GetIn6Addr(&paddrin6->sin6_addr))
            return false;
        paddrin6->sin6_family = AF_INET6;
        paddrin6->sin6_port = htons(port);
        return true;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffff0000, %eax       # imm = 0xFFFF0000
movl 0x8(%rdi), %ecx
xorq %rax, %rcx
orq (%rdi), %rcx
je 0x956d
movq %r14, %rdi
callq 0x926a
testb %al, %al
je 0x958c
cmpl $0x1c, (%r15)
jb 0x958c
movl $0x1c, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rbx)
movups %xmm0, (%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movw $0xa, %ax
jmp 0x959b
cmpl $0x10, (%r15)
jb 0x958c
movl $0x10, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl 0x8(%r14), %ecx
xorq %rax, %rcx
orq (%r14), %rcx
je 0x9590
xorl %eax, %eax
jmp 0x95ad
movl 0xc(%r14), %eax
movl %eax, 0x4(%rbx)
movw $0x2, %ax
movw %ax, (%rbx)
movzwl 0x10(%r14), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::SetSockAddr(sockaddr const*)
bool CService::SetSockAddr(const struct sockaddr *paddr)
{
    switch (paddr->sa_family) {
    case AF_INET:
        *this = CService(*(const struct sockaddr_in*)paddr);
        return true;
    case AF_INET6:
        *this = CService(*(const struct sockaddr_in6*)paddr);
        return true;
    default:
        return false;
    }
}

// Assembly:
movzwl (%rsi), %eax
cmpl $0xa, %eax
je 0x9c15
cmpl $0x2, %eax
jne 0x9c2b
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movl 0x4(%rsi), %ecx
movl $0xffff0000, 0x8(%rdi)  # imm = 0xFFFF0000
movq $0x0, (%rdi)
movl %ecx, 0xc(%rdi)
jmp 0x9c24
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movups 0x8(%rsi), %xmm0
movups %xmm0, (%rdi)
movw %ax, 0x10(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::CService(char const*, bool)
CService::CService(const char *pszIpPort, bool fAllowLookup)
{
    Init();
    CService ip;
    if (Lookup(pszIpPort, ip, 0, fAllowLookup))
        *this = ip;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edx, %edx
movw %dx, 0x10(%rdi)
movq %rsp, %rsi
movw %dx, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rax, %rdi
xorl %edx, %edx
callq 0x7767
testb %al, %al
je 0x9c6f
movzwl 0x10(%rsp), %eax
movw %ax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::CService(char const*, int, bool)
CService::CService(const char *pszIpPort, int portDefault, bool fAllowLookup)
{
    Init();
    CService ip;
    if (Lookup(pszIpPort, ip, portDefault, fAllowLookup))
        *this = ip;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edi, %edi
movw %di, 0x10(%rbx)
movq %rsp, %rsi
movw %di, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x7767
testb %al, %al
je 0x9cb3
movzwl 0x10(%rsp), %eax
movw %ax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::CService(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CService::CService(const std::string &strIpPort, bool fAllowLookup)
{
    Init();
    CService ip;
    if (Lookup(strIpPort.c_str(), ip, 0, fAllowLookup))
        *this = ip;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edx, %edx
movw %dx, 0x10(%rdi)
movq %rsp, %rax
movw %dx, 0x10(%rax)
movaps %xmm0, (%rax)
movq (%rsi), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7767
testb %al, %al
je 0x9cfb
movzwl 0x10(%rsp), %eax
movw %ax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::CService(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, bool)
CService::CService(const std::string &strIpPort, int portDefault, bool fAllowLookup)
{
    Init();
    CService ip;
    if (Lookup(strIpPort.c_str(), ip, portDefault, fAllowLookup))
        *this = ip;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edi, %edi
movw %di, 0x10(%rbx)
movq %rsp, %rax
movw %di, 0x10(%rax)
movaps %xmm0, (%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x7767
testb %al, %al
je 0x9d3f
movzwl 0x10(%rsp), %eax
movw %ax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/netbase.cpp
// Function: CService::GetKey() const
std::vector<unsigned char> CService::GetKey() const
{
     std::vector<unsigned char> vKey;
     vKey.resize(18);
     memcpy(&vKey[0], ip, 16);
     vKey[16] = port / 0x100;
     vKey[17] = port & 0x0FF;
     return vKey;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x12, %esi
callq 0xa3f2
movq (%rbx), %rax
movups (%r14), %xmm0
movups %xmm0, (%rax)
movb 0x11(%r14), %al
movq (%rbx), %rcx
movb %al, 0x10(%rcx)
movb 0x10(%r14), %al
movq (%rbx), %rcx
movb %al, 0x11(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9e83
callq 0x33d0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::GetCommand[abi:cxx11]() const
std::string CMessageHeader::GetCommand() const
{
    if (pchCommand[COMMAND_SIZE-1] == 0)
        return std::string(pchCommand, pchCommand + strlen(pchCommand));
    else
        return std::string(pchCommand, pchCommand + COMMAND_SIZE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsi), %r14
cmpb $0x0, 0xf(%rsi)
je 0xaa58
movq %rsi, %rdx
addq $0x10, %rdx
jmp 0xaa66
movq %r14, %rdi
callq 0x31c0
movq %rax, %rdx
addq %r14, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b14
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::IsValid() const
bool CMessageHeader::IsValid() const
{
    // Check start string
    if (memcmp(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart)) != 0)
        return false;

    // Check the command string for errors
    for (const char* p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++)
    {
        if (*p1 == 0)
        {
            // Must be all zeros after the first zero
            for (; p1 < pchCommand + COMMAND_SIZE; p1++)
                if (*p1 != 0)
                    return false;
        }
        else if (*p1 < ' ' || *p1 > 0x7E)
            return false;
    }

    // Message size
    if (nMessageSize > MAX_SIZE)
    {
        printf("CMessageHeader::IsValid() : (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand().c_str(), nMessageSize);
        return false;
    }

    return true;
}

// Assembly:
movl (%rdi), %eax
cmpl 0x11928(%rip), %eax     # 0x1c3b4
jne 0xab19
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x4, %eax
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0xab09
addb $-0x7f, %cl
cmpb $-0x5f, %cl
jb 0xab0f
leaq 0x1(%rax), %rcx
cmpq $0xf, %rax
movq %rcx, %rax
jb 0xaaa1
movb $0x1, %al
cmpl $0x2000001, 0x10(%rbx)  # imm = 0x2000001
jb 0xab11
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa3e
movq (%r14), %rsi
movl 0x10(%rbx), %edx
leaq 0x8de0(%rip), %rdi      # 0x138c5
xorl %eax, %eax
callq 0x3050
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xab0f
callq 0x33d0
jmp 0xab0f
incq %rax
cmpq $0x10, %rax
je 0xaabd
cmpb $0x0, (%rbx,%rax)
je 0xab00
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/protocol.cpp
// Function: CInv::CInv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, uint256 const&)
CInv::CInv(const std::string& strType, const uint256& hashIn)
{
    int i;
    for (i = 1; i < ARRAYLEN(ppszTypeName); i++)
    {
        if (strType == ppszTypeName[i])
        {
            type = i;
            break;
        }
    }
    if (i == ARRAYLEN(ppszTypeName))
        throw std::out_of_range("CInv::CInv(string, uint256) : unknown type");
    hash = hashIn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x4(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x4(%rdi)
movl $0x1, %r13d
leaq 0x11150(%rip), %rbp     # 0x1bd50
movq (%rbp,%r13,8), %rsi
movq %r15, %rdi
callq 0x30e0
testl %eax, %eax
je 0xac4c
incq %r13
cmpq $0x3, %r13
jne 0xac00
movl $0x10, %edi
callq 0x31d0
movq %rax, %rbx
leaq 0x8ce9(%rip), %rsi      # 0x13917
movq %rax, %rdi
callq 0x3070
movq 0x1139b(%rip), %rsi     # 0x1bfd8
movq 0x11384(%rip), %rdx     # 0x1bfc8
movq %rbx, %rdi
callq 0x3640
movl %r13d, (%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/db.cpp
// Function: CAddrInfo::Update(bool)
void CAddrInfo::Update(bool good) {
  uint32_t now = time(NULL);
  if (ourLastTry == 0)
    ourLastTry = now - MIN_RETRY;
  int age = now - ourLastTry;
  lastTry = now;
  ourLastTry = now;
  total++;
  if (good)
  {
    success++;
    ourLastSuccess = now;
  }
  stat2H.Update(good, age, 3600*2);
  stat8H.Update(good, age, 3600*8);
  stat1D.Update(good, age, 3600*24);
  stat1W.Update(good, age, 3600*24*7);
  stat1M.Update(good, age, 3600*24*30);
  int ign = GetIgnoreTime();
  if (ign && (ignoreTill==0 || ignoreTill < ign+now)) ignoreTill = ign+now;
 //printf("%s: got %s result: success=%i/%i; 2H:%.2f%%-%.2f%%(%.2f) 8H:%.2f%%-%.2f%%(%.2f) 1D:%.2f%%-%.2f%%(%.2f) 1W:%.2f%%-%.2f%%(%.2f) \n", ToString(ip).c_str(), good ? "good" : "bad", success, total, 
 //100.0 * stat2H.reliability, 100.0 * (stat2H.reliability + 1.0 - stat2H.weight), stat2H.count,
 //100.0 * stat8H.reliability, 100.0 * (stat8H.reliability + 1.0 - stat8H.weight), stat8H.count,
 //100.0 * stat1D.reliability, 100.0 * (stat1D.reliability + 1.0 - stat1D.weight), stat1D.count,
 //100.0 * stat1W.reliability, 100.0 * (stat1W.reliability + 1.0 - stat1W.weight), stat1W.count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33c0
movq %rax, %r14
movq 0x28(%rbx), %rax
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
addq %r14, %rdx
testq %rax, %rax
cmovneq %rax, %rdx
movl %r14d, %ecx
movq %r14, %rax
subq %rdx, %rax
movq %rcx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
incl 0x84(%rbx)
testl %ebp, %ebp
je 0xadd2
incl 0x88(%rbx)
movq %rcx, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
movslq %eax, %r15
movzbl %bpl, %ebp
movsd 0x8b9b(%rip), %xmm0     # 0x13980
movl %ebp, %esi
movq %r15, %rdx
callq 0xb8c2
leaq 0x4c(%rbx), %rdi
movsd 0x8b8d(%rip), %xmm0     # 0x13988
movl %ebp, %esi
movq %r15, %rdx
callq 0xb8c2
leaq 0x58(%rbx), %rdi
movsd 0x8b7f(%rip), %xmm0     # 0x13990
movl %ebp, %esi
movq %r15, %rdx
callq 0xb8c2
leaq 0x64(%rbx), %rdi
movsd 0x8b71(%rip), %xmm0     # 0x13998
movl %ebp, %esi
movq %r15, %rdx
callq 0xb8c2
leaq 0x70(%rbx), %rdi
movsd 0x8b63(%rip), %xmm0     # 0x139a0
movl %ebp, %esi
movq %r15, %rdx
callq 0xb8c2
movq %rbx, %rdi
callq 0xb934
testl %eax, %eax
je 0xae71
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
sete %dl
addl %r14d, %eax
cmpq %rax, %rcx
setl %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0xae71
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Get_(CServiceResult&, int&)
bool CAddrDb::Get_(CServiceResult &ip, int &wait) {
  int64 now = time(NULL);
  int cont = 0;
  int tot = unkId.size() + ourId.size();
  if (tot == 0) {
    wait = 5;
    return false;
  }
  do {
    int rnd = rand() % tot;
    int ret;
    if (rnd < unkId.size()) {
      set<int>::iterator it = unkId.end(); it--;
      ret = *it;
      unkId.erase(it);
    } else {
      ret = ourId.front();
      if (time(NULL) - idToInfo[ret].ourLastTry < MIN_RETRY) return false;
      ourId.pop_front();
    }
    if (idToInfo[ret].ignoreTill && idToInfo[ret].ignoreTill < now) {
      ourId.push_back(ret);
      idToInfo[ret].ourLastTry = now;
    } else {
      ip.service = idToInfo[ret].ip;
      ip.ourLastSuccess = idToInfo[ret].ourLastSuccess;
      break;
    }
  } while(1);
  nDirty++;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33c0
movq %rax, %r15
movq 0xe8(%rbx), %rax
movl 0xc8(%rbx), %ecx
movl %eax, %edx
subl %ecx, %edx
shrl $0x3, %edx
cmpq $0x1, %rax
adcl $-0x1, %edx
shll $0x7, %edx
movq 0xc0(%rbx), %rbp
movq 0xd0(%rbx), %rax
subq 0xd8(%rbx), %rax
shrq $0x2, %rax
subq 0xb0(%rbx), %rbp
shrq $0x2, %rbp
addl 0x118(%rbx), %eax
addl %edx, %eax
addl %eax, %ebp
je 0xb042
movq %r12, 0x10(%rsp)
leaq 0xf0(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0xa0(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rbx), %r12
leaq 0xf8(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x4(%rsp), %r13
callq 0x30c0
cltd
idivl %ebp
movslq %edx, %rax
cmpq %rax, 0x118(%rbx)
jbe 0xaf55
movq 0x18(%rsp), %rdi
callq 0x3250
movl 0x20(%rax), %ecx
movl %ecx, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xc710
jmp 0xaf92
movq 0xb0(%rbx), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
xorl %edi, %edi
callq 0x33c0
movq %rax, %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0xba30
subq 0x28(%rax), %r14
cmpq $0x3e7, %r14            # imm = 0x3E7
jle 0xb049
movq 0x8(%rsp), %rdi
callq 0xba96
movq %r12, %rdi
movq %r13, %rsi
callq 0xba30
cmpq $0x0, 0x38(%rax)
je 0xb000
movq %r12, %rdi
movq %r13, %rsi
callq 0xba30
cmpq %r15, 0x38(%rax)
jge 0xb000
movq 0xd0(%rbx), %rax
movq 0xe0(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0xafdf
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xd0(%rbx)
jmp 0xafec
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xc3d2
movq %r12, %rdi
movq %r13, %rsi
callq 0xba30
movq %r15, 0x28(%rax)
jmp 0xaf21
leaq 0x4(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0xba30
movups (%rax), %xmm0
movq 0x10(%rsp), %r15
movups %xmm0, (%r15)
movzwl 0x10(%rax), %eax
movw %ax, 0x10(%r15)
movq %r12, %rdi
movq %r14, %rsi
callq 0xba30
movq 0x30(%rax), %rax
movq %rax, 0x40(%r15)
incl 0x150(%rbx)
movb $0x1, %al
jmp 0xb04b
movl $0x5, (%r14)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Good_(CService const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void CAddrDb::Good_(const CService &addr, int clientV, std::string clientSV, int blocks) {
  int id = Lookup_(addr);
  if (id == -1) return;
  unkId.erase(id);
  banned.erase(addr);
  CAddrInfo &info = idToInfo[id];
  info.clientVersion = clientV;
  info.clientSubVersion = clientSV;
  info.blocks = blocks;
  info.Update(true);
  if (info.IsGood() && goodId.count(id)==0) {
    goodId.insert(id);
    //printf("%s: good; %i good nodes now\n", ToString(addr).c_str(), (int)goodId.size());
  }
  nDirty++;
  ourId.push_back(id);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0xb05a
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb1d1
leaq 0xf0(%rbx), %r13
leaq 0x4(%rsp), %rsi
movq %r13, %rdi
callq 0xc7ac
movq %r13, %rdi
movq %rax, %rsi
callq 0xc82a
leaq 0x158(%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xc8ca
movq %r13, %rdi
movq %rax, %rsi
callq 0xc98c
leaq 0x40(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xba30
movq %rax, %r12
movl %r15d, 0x7c(%rax)
leaq 0x90(%rax), %rdi
movq %r14, %rsi
callq 0x3210
movl %ebp, 0x80(%r12)
movq %r12, %rdi
movl $0x1, %esi
callq 0xad84
movq %r12, %rdi
callq 0xbb74
testb %al, %al
je 0xb18d
movq 0x130(%rbx), %rax
testq %rax, %rax
je 0xb17c
leaq 0x128(%rbx), %rsi
movl 0x4(%rsp), %ecx
movq %rsi, %rdx
xorl %edi, %edi
cmpl %ecx, 0x20(%rax)
setl %dil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0xb15b
cmpq %rsi, %rdx
je 0xb17c
cmpl 0x20(%rdx), %ecx
jge 0xb18d
leaq 0x120(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xc602
incl 0x150(%rbx)
movq 0xd0(%rbx), %rax
movq 0xe0(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0xb1bd
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xd0(%rbx)
jmp 0xb1d1
addq $0xa0, %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xc3d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Bad_(CService const&, int)
void CAddrDb::Bad_(const CService &addr, int ban)
{
  int id = Lookup_(addr);
  if (id == -1) return;
  unkId.erase(id);
  CAddrInfo &info = idToInfo[id];
  info.Update(false);
  uint32_t now = time(NULL);
  int ter = info.GetBanTime();
  if (ter) {
    //printf("%s: terrible\n", ToString(addr).c_str());
    if (ban < ter) ban = ter;
  }
  if (ban > 0) {
    //printf("%s: ban for %i seconds\n", ToString(addr).c_str(), ban);
    banned[info.ip] = ban + now;
    ipToId.erase(info.ip);
    goodId.erase(id);
    idToInfo.erase(id);
  } else {
    if (/*!info.IsGood() && */ goodId.count(id)==1) {
      goodId.erase(id);
      //printf("%s: not good; %i good nodes left\n", ToString(addr).c_str(), (int)goodId.size());
    }
    ourId.push_back(id);
  }
  nDirty++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0xb05a
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb36d
leaq 0xf0(%rbx), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc7ac
movq %r14, %rdi
movq %rax, %rsi
callq 0xc82a
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xba30
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0xad84
xorl %edi, %edi
callq 0x33c0
movq %rax, %r12
movq %r15, %rdi
callq 0xbcb2
cmpl %ebp, %eax
movl %ebp, %r13d
cmovgl %eax, %r13d
testl %eax, %eax
cmovel %ebp, %r13d
testl %r13d, %r13d
jle 0xb2d2
addl %r12d, %r13d
leaq 0x158(%rbx), %rdi
movq %r15, %rsi
callq 0xbd90
movq %r13, (%rax)
leaq 0x70(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xcce2
movq %r12, %rdi
movq %rax, %rsi
callq 0xcda4
leaq 0x120(%rbx), %r15
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xc7ac
movq %r15, %rdi
movq %rax, %rsi
callq 0xc82a
movq %r14, %rdi
movq %r12, %rsi
callq 0xce7a
movq %r14, %rdi
movq %rax, %rsi
callq 0xcef8
jmp 0xb367
movq 0x130(%rbx), %rax
testq %rax, %rax
je 0xb32c
leaq 0x120(%rbx), %r14
leaq 0x128(%rbx), %rsi
movl 0x4(%rsp), %ecx
movq %rsi, %rdx
xorl %edi, %edi
cmpl %ecx, 0x20(%rax)
setl %dil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0xb2f3
cmpq %rsi, %rdx
je 0xb32c
cmpl 0x20(%rdx), %ecx
jl 0xb32c
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xc7ac
movq %r14, %rdi
movq %rax, %rsi
callq 0xc82a
movq 0xd0(%rbx), %rax
movq 0xe0(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0xb356
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xd0(%rbx)
jmp 0xb367
leaq 0xa0(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xc3d2
incl 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Skipped_(CService const&)
void CAddrDb::Skipped_(const CService &addr)
{
  int id = Lookup_(addr);
  if (id == -1) return;
  unkId.erase(id);
  ourId.push_back(id);
  //printf("%s: skipped\n", ToString(addr).c_str());
  nDirty++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb05a
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb3f1
leaq 0xf0(%rbx), %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xc7ac
movq %r14, %rdi
movq %rax, %rsi
callq 0xc82a
movq 0xd0(%rbx), %rax
movq 0xe0(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0xb3da
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xd0(%rbx)
jmp 0xb3eb
leaq 0xa0(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xc3d2
incl 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/./db.h
// Function: CAddrStat::Update(bool, long long, double)
void Update(bool good, int64 age, double tau) {
    double f =  exp(-age/tau);
    reliability = reliability * f + (good ? (1.0-f) : 0);
    count = count * f + 1;
    weight = weight * f + (1.0-f);
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
negq %rdx
cvtsi2sd %rdx, %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x3670
cvtss2sd 0x8(%rbx), %xmm2
movsd 0x80bc(%rip), %xmm1     # 0x139a8
subsd %xmm0, %xmm1
movapd %xmm1, %xmm3
testl %ebp, %ebp
jne 0xb8fc
xorpd %xmm3, %xmm3
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
cvtsd2ss %xmm2, %xmm2
movss %xmm2, 0x8(%rbx)
cvtps2pd (%rbx), %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm2, %xmm0
shufpd $0x2, 0x80ef(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/./db.h
// Function: CAddrInfo::GetIgnoreTime() const
int GetIgnoreTime() const {
    if (IsGood()) return 0;
    if (stat1M.reliability - stat1M.weight + 1.0 < 0.20 && stat1M.count > 2) { return 10*86400; }
    if (stat1W.reliability - stat1W.weight + 1.0 < 0.16 && stat1W.count > 2)  { return 3*86400; }
    if (stat1D.reliability - stat1D.weight + 1.0 < 0.12 && stat1D.count > 2)  { return 8*3600; }
    if (stat8H.reliability - stat8H.weight + 1.0 < 0.08 && stat8H.count > 2)  { return 2*3600; }
    return 0;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbb74
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xba2d
movss 0x78(%rbx), %xmm0
subss 0x70(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x8049(%rip), %xmm0     # 0x139a8
movsd 0x8049(%rip), %xmm1     # 0x139b0
ucomisd %xmm0, %xmm1
jbe 0xb984
movss 0x74(%rbx), %xmm0
movl $0xd2f00, %eax          # imm = 0xD2F00
ucomiss 0x80a2(%rip), %xmm0     # 0x13a20
ja 0xba2d
movss 0x6c(%rbx), %xmm0
subss 0x64(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x800e(%rip), %xmm0     # 0x139a8
movsd 0x8016(%rip), %xmm1     # 0x139b8
ucomisd %xmm0, %xmm1
jbe 0xb9bb
movss 0x68(%rbx), %xmm0
movl $0x3f480, %eax          # imm = 0x3F480
ucomiss 0x8067(%rip), %xmm0     # 0x13a20
ja 0xba2d
movss 0x60(%rbx), %xmm0
subss 0x58(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7fd7(%rip), %xmm0     # 0x139a8
movsd 0x7fe7(%rip), %xmm1     # 0x139c0
ucomisd %xmm0, %xmm1
jbe 0xb9f2
movss 0x5c(%rbx), %xmm0
movl $0x7080, %eax           # imm = 0x7080
ucomiss 0x8030(%rip), %xmm0     # 0x13a20
ja 0xba2d
movss 0x54(%rbx), %xmm0
subss 0x4c(%rbx), %xmm0
movss 0x50(%rbx), %xmm1
cvtss2sd %xmm0, %xmm0
addsd 0x7f9b(%rip), %xmm0     # 0x139a8
xorl %ecx, %ecx
ucomiss 0x800a(%rip), %xmm1     # 0x13a20
movl $0x1c20, %eax           # imm = 0x1C20
cmovbel %ecx, %eax
movsd 0x7fa2(%rip), %xmm1     # 0x139c8
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/./db.h
// Function: CAddrInfo::IsGood() const
bool IsGood() const {
    if (ip.GetPort() != GetDefaultPort()) return false;
    if (!(services & NODE_NETWORK)) return false;
    if (!ip.IsRoutable()) return false;
    if (clientVersion && clientVersion < REQUIRE_VERSION) return false;
    if (blocks && blocks < GetRequireHeight()) return false;

    if (total <= 3 && success * 2 >= total) return true;

    if (stat2H.reliability > 0.85 && stat2H.count > 2) return true;
    if (stat8H.reliability > 0.70 && stat8H.count > 4) return true;
    if (stat1D.reliability > 0.55 && stat1D.count > 8) return true;
    if (stat1W.reliability > 0.45 && stat1W.count > 16) return true;
    if (stat1M.reliability > 0.35 && stat1M.count > 32) return true;
    
    return false;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8d42
leaq 0x108f9(%rip), %r14     # 0x1c480
cmpb $0x0, (%r14)
movl $0x141b, %ecx           # imm = 0x141B
movl $0xc91a, %edx           # imm = 0xC91A
cmovnel %ecx, %edx
cmpw %dx, %ax
jne 0xbbc3
testb $0x1, 0x18(%rbx)
je 0xbbc3
movq %rbx, %rdi
callq 0x9450
testb %al, %al
je 0xbbc3
movl 0x7c(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl $0x11500, %eax          # imm = 0x11500
setl %al
testb %al, %cl
je 0xbbcd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x80(%rbx), %ecx
testl %ecx, %ecx
je 0xbbe9
xorl %eax, %eax
cmpb $0x0, (%r14)
movl $0x3a98, %edx           # imm = 0x3A98
cmovnel %eax, %edx
cmpl %edx, %ecx
jl 0xbbc5
movl 0x84(%rbx), %ecx
cmpl $0x3, %ecx
jg 0xbc02
movl 0x88(%rbx), %edx
addl %edx, %edx
movb $0x1, %al
cmpl %ecx, %edx
jge 0xbbc5
cvtss2sd 0x48(%rbx), %xmm0
ucomisd 0x7dc1(%rip), %xmm0     # 0x139d0
movb $0x1, %al
jbe 0xbc21
movss 0x44(%rbx), %xmm0
ucomiss 0x7e01(%rip), %xmm0     # 0x13a20
ja 0xbbc5
xorps %xmm0, %xmm0
cvtss2sd 0x54(%rbx), %xmm0
ucomisd 0x7da7(%rip), %xmm0     # 0x139d8
jbe 0xbc41
movss 0x50(%rbx), %xmm0
ucomiss 0x7de5(%rip), %xmm0     # 0x13a24
ja 0xbbc5
xorps %xmm0, %xmm0
cvtss2sd 0x60(%rbx), %xmm0
ucomisd 0x7d8f(%rip), %xmm0     # 0x139e0
jbe 0xbc65
movss 0x5c(%rbx), %xmm0
ucomiss 0x7dc9(%rip), %xmm0     # 0x13a28
ja 0xbbc5
xorps %xmm0, %xmm0
cvtss2sd 0x6c(%rbx), %xmm0
ucomisd 0x7d73(%rip), %xmm0     # 0x139e8
jbe 0xbc89
movss 0x68(%rbx), %xmm0
ucomiss 0x7da9(%rip), %xmm0     # 0x13a2c
ja 0xbbc5
xorps %xmm0, %xmm0
cvtss2sd 0x78(%rbx), %xmm0
ucomisd 0x7d57(%rip), %xmm0     # 0x139f0
seta %cl
movss 0x74(%rbx), %xmm0
ucomiss 0x7d88(%rip), %xmm0     # 0x13a30
seta %al
andb %cl, %al
jmp 0xbbc5
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/./db.h
// Function: CAddrInfo::GetBanTime() const
int GetBanTime() const {
    if (IsGood()) return 0;
    if (clientVersion && clientVersion < 31900) { return 604800; }
    if (stat1M.reliability - stat1M.weight + 1.0 < 0.15 && stat1M.count > 32) { return 30*86400; }
    if (stat1W.reliability - stat1W.weight + 1.0 < 0.10 && stat1W.count > 16) { return 7*86400; }
    if (stat1D.reliability - stat1D.weight + 1.0 < 0.05 && stat1D.count > 8) { return 1*86400; }
    return 0;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbb74
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xbd8d
movl 0x7c(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl $0x7c9c, %eax           # imm = 0x7C9C
setl %dl
movl $0x93a80, %eax          # imm = 0x93A80
testb %dl, %cl
jne 0xbd8d
movss 0x78(%rbx), %xmm0
subss 0x70(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7cae(%rip), %xmm0     # 0x139a8
movsd 0x7cf6(%rip), %xmm1     # 0x139f8
ucomisd %xmm0, %xmm1
jbe 0xbd1b
movss 0x74(%rbx), %xmm0
movl $0x278d00, %eax         # imm = 0x278D00
ucomiss 0x7d17(%rip), %xmm0     # 0x13a30
ja 0xbd8d
movss 0x6c(%rbx), %xmm0
subss 0x64(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7c77(%rip), %xmm0     # 0x139a8
movsd 0x7cc7(%rip), %xmm1     # 0x13a00
ucomisd %xmm0, %xmm1
jbe 0xbd52
movss 0x68(%rbx), %xmm0
ucomiss 0x7ce1(%rip), %xmm0     # 0x13a2c
movl $0x93a80, %eax          # imm = 0x93A80
ja 0xbd8d
movss 0x60(%rbx), %xmm0
subss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
cvtss2sd %xmm0, %xmm0
addsd 0x7c3b(%rip), %xmm0     # 0x139a8
xorl %ecx, %ecx
ucomiss 0x7cb2(%rip), %xmm1     # 0x13a28
movl $0x15180, %eax          # imm = 0x15180
cmovbel %ecx, %eax
movsd 0x7c82(%rip), %xmm1     # 0x13a08
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/main.cpp
// Function: ThreadStats
void* ThreadStats(void*) {
  bool first = true;
  do {
    char c[256];
    time_t tim = time(NULL);
    struct tm *tmp = localtime(&tim);
    strftime(c, 256, "[%y-%m-%d %H:%M:%S]", tmp);
    CAddrDbStats stats;
    db.GetStats(stats);
    if (first)
    {
      first = false;
      printf("\n\n\n\x1b[3A");
    }
    else
      printf("\x1b[2K\x1b[u");
    printf("\x1b[s");
    uint64_t requests = 0;
    uint64_t queries = 0;
    for (unsigned int i=0; i<dnsThread.size(); i++) {
      requests += dnsThread[i]->dns_opt.nRequests;
      queries += dnsThread[i]->dbQueries;
    }
    printf("%s %i/%i available (%i tried in %is, %i new, %i active), %i banned; %llu DNS requests, %llu db queries", c, stats.nGood, stats.nAvail, stats.nTracked, stats.nAge, stats.nNew, stats.nAvail - stats.nTracked - stats.nNew, stats.nBanned, (unsigned long long)requests, (unsigned long long)queries);
    Sleep(1000);
  } while(1);
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
xorl %edi, %edi
callq 0x33c0
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x32f0
leaq 0x60de(%rip), %rdx      # 0x13c05
leaq 0x30(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %rax, %rcx
callq 0x3330
leaq 0x60d6(%rip), %r12      # 0x13c19
leaq 0x20(%rsp), %r14
leaq 0x60d2(%rip), %r13      # 0x13c21
leaq 0xe932(%rip), %rdi      # 0x1c488
leaq 0x8(%rsp), %rsi
callq 0xec6e
movq %r12, %rdi
xorl %eax, %eax
callq 0x3050
leaq 0x60b8(%rip), %rdi      # 0x13c29
xorl %eax, %eax
callq 0x3050
movq 0xea91(%rip), %rcx      # 0x1c610
cmpq %rcx, 0xea92(%rip)      # 0x1c618
je 0xdbc4
movl $0x1, %eax
xorl %edx, %edx
xorl %r11d, %r11d
xorl %r10d, %r10d
movq (%rcx,%rdx,8), %rcx
addq 0x30(%rcx), %r10
movq 0x70(%rcx), %rcx
addq %rcx, %r11
movl %eax, %edx
movq 0xea6b(%rip), %rsi      # 0x1c618
movq 0xea5c(%rip), %rcx      # 0x1c610
subq %rcx, %rsi
sarq $0x3, %rsi
incl %eax
cmpq %rdx, %rsi
ja 0xdb95
jmp 0xdbca
xorl %r10d, %r10d
xorl %r11d, %r11d
movl 0x18(%rsp), %edx
movl 0x8(%rsp), %r12d
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movl 0x14(%rsp), %ebp
movl %ecx, %ebx
subl %r8d, %ebx
subl %ebp, %ebx
subq $0x8, %rsp
leaq 0x6036(%rip), %rdi      # 0x13c2d
movq %r15, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r12
pushq %rbx
pushq %rbp
callq 0x3050
addq $0x30, %rsp
movq $0x1, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3100
xorl %edi, %edi
callq 0x33c0
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x32f0
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
leaq 0x5fba(%rip), %rdx      # 0x13c05
movq %rax, %rcx
callq 0x3330
movq %r13, %r12
jmp 0xdb4f
// File: /workspace/github_cpp_makefile_star2_O3/tenup-coin[P]seeder/./db.h
// Function: CAddrDb::GetMany(std::vector<CServiceResult, std::allocator<CServiceResult>>&, int, int&)
void GetMany(std::vector<CServiceResult> &ips, int max, int& wait) {
    CRITICAL_BLOCK(cs) {
      while (max > 0) {
          CServiceResult ip = {};
          if (!Get_(ip, wait))
              return;
          ips.push_back(ip);
          max--;
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
callq 0x35a0
testl %ebp, %ebp
jle 0xe5c3
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %ebx, %ebx
movq %r12, %rdi
callq 0x9b2a
movb %bl, 0x22(%rsp)
movq %rbx, 0x24(%rsp)
movl $0x0, 0x2c(%rsp)
movq %r15, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movb %bl, 0x40(%rsp)
movq %rbx, 0x50(%rsp)
movq (%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xae7c
movl %eax, %r13d
testb %al, %al
je 0xe5aa
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xf36e
decl %ebp
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0xe5b9
callq 0x33d0
testl %ebp, %ebp
setg %al
testb %al, %r13b
jne 0xe559
movq (%rsp), %rdi
callq 0x34f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe5f2
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0xe5f2
callq 0x33d0
movq (%rsp), %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3650
nop