LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tenup-coin[P]seeder/./serialize.h
// Function: void Unserialize_impl<CDataStream, CAddress, std::allocator<CAddress>>(CDataStream&, std::vector<CAddress, std::allocator<CAddress>>&, int, int, boost::integral_constant<bool, false> const&)
void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&)
{
    //unsigned int nSize = ReadCompactSize(is);
    //v.resize(nSize);
    //for (std::vector<T, A>::iterator vi = v.begin(); vi != v.end(); ++vi)
    //    Unserialize(is, (*vi), nType, nVersion);

    v.clear();
    unsigned int nSize = ReadCompactSize(is);
    unsigned int i = 0;
    unsigned int nMid = 0;
    while (nMid < nSize)
    {
        nMid += 5000000 / sizeof(T);
        if (nMid > nSize)
            nMid = nSize;
        v.resize(nMid);
        for (; i < nMid; i++)
            Unserialize(is, v[i], nType, nVersion);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe780
movq -0x8(%rbp), %rdi
callq 0xe4a0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xe76b
movl -0x2c(%rbp), %eax
addq $0x1e848, %rax          # imm = 0x1E848
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0xe71f
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xe7a0
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0xe769
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0xe830
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
movl -0x18(%rbp), %ecx
callq 0xe0d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe72d
jmp 0xe6fd
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/netbase.cpp
// Function: ParseNetwork(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
enum Network ParseNetwork(std::string net) {
    boost::to_lower(net);
    if (net == "ipv4") return NET_IPV4;
    if (net == "ipv6") return NET_IPV6;
    if (net == "tor")  return NET_TOR;
    if (net == "i2p")  return NET_I2P;
    return NET_UNROUTABLE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x48f0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x151a0
jmp 0xf5bc
leaq -0x18(%rbp), %rdi
callq 0x46d0
movq -0x38(%rbp), %rdi
leaq 0x24c10(%rip), %rsi     # 0x341e0
callq 0xdba0
testb $0x1, %al
jne 0xf5db
jmp 0xf5fb
movl $0x1, -0x4(%rbp)
jmp 0xf65f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x46d0
jmp 0xf668
movq -0x38(%rbp), %rdi
leaq 0x24be4(%rip), %rsi     # 0x341ea
callq 0xdba0
testb $0x1, %al
jne 0xf611
jmp 0xf61a
movl $0x2, -0x4(%rbp)
jmp 0xf65f
movq -0x38(%rbp), %rdi
leaq 0x23d1b(%rip), %rsi     # 0x33340
callq 0xdba0
testb $0x1, %al
jne 0xf630
jmp 0xf639
movl $0x3, -0x4(%rbp)
jmp 0xf65f
movq -0x38(%rbp), %rdi
leaq 0x23d92(%rip), %rsi     # 0x333d6
callq 0xdba0
testb $0x1, %al
jne 0xf64f
jmp 0xf658
movl $0x4, -0x4(%rbp)
jmp 0xf65f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xf8f2
movb $0x0, -0x1(%rbp)
jmp 0xf988
leaq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x151f0
movsbl -0x120(%rbp), %eax
cmpl $0x5b, %eax
jne 0xf968
leaq -0x120(%rbp), %rdi
callq 0x4210
subq $0x1, %rax
movsbl -0x120(%rbp,%rax), %eax
cmpl $0x5d, %eax
jne 0xf968
leaq -0x120(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x4210
subq $0x1, %rax
movb $0x0, -0x120(%rbp,%rax)
movq -0x128(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xf9a0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x15420
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movzbl -0x1d(%rbp), %ecx
andl $0x1, %ecx
movl $0x1, %r8d
callq 0xfce0
movb %al, -0x51(%rbp)
jmp 0xffd9
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x1000b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x10040
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15440
jmp 0x10054
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x153a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movw 0x10(%rcx), %cx
movw %cx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15440
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x25(%rbp)
jl 0x100bb
cmpl $0x5, -0x8(%rbp)
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x100c4
jmp 0x100c6
jmp 0x100e5
leaq 0x23277(%rip), %rdi     # 0x33344
leaq 0x2328a(%rip), %rsi     # 0x3335e
movl $0x1a2, %edx            # imm = 0x1A2
leaq 0x2328a(%rip), %rcx     # 0x3336a
callq 0x4350
cmpl $0x0, -0xc(%rbp)
je 0x100fd
cmpl $0x4, -0xc(%rbp)
je 0x100fd
cmpl $0x5, -0xc(%rbp)
je 0x100fd
movb $0x0, -0x1(%rbp)
jmp 0x10145
cmpl $0x0, -0xc(%rbp)
je 0x10116
movq -0x30(%rbp), %rdi
callq 0x10150
testb $0x1, %al
jne 0x10116
movb $0x0, -0x1(%rbp)
jmp 0x10145
movq -0x30(%rbp), %rsi
leaq -0x24(%rbp), %rdi
leaq -0xc(%rbp), %rdx
callq 0x154a0
movl -0x8(%rbp), %eax
leaq 0x3a3cf(%rip), %rdi     # 0x4a500
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x24(%rbp), %rsi
callq 0x154d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::IsValid() const
bool CNetAddr::IsValid() const
{
    // Cleanup 3-byte shifted addresses caused by garbage in size field
    // of addr messages from versions before 0.2.9 checksum.
    // Two consecutive addr messages look like this:
    // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 addr26 addr26...
    // so if the first length field is garbled, it reads the second batch
    // of addr misaligned by 3 bytes.
    if (memcmp(ip, pchIPv4+3, sizeof(pchIPv4)-3) == 0)
        return false;

    // unspecified IPv6 address (::/128)
    unsigned char ipNone[16] = {};
    if (memcmp(ip, ipNone, 16) == 0)
        return false;

    // documentation IPv6 address
    if (IsRFC3849())
        return false;

    if (IsIPv4())
    {
        // INADDR_NONE
        uint32_t ipNone = INADDR_NONE;
        if (memcmp(ip+12, &ipNone, 4) == 0)
            return false;

        // 0
        ipNone = 0;
        if (memcmp(ip+12, &ipNone, 4) == 0)
            return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x23172(%rip), %rsi     # 0x332dd
movl $0x9, %edx
callq 0x4220
cmpl $0x0, %eax
jne 0x10183
movb $0x0, -0x1(%rbp)
jmp 0x10237
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4270
movq -0x30(%rbp), %rax
leaq -0x20(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x101bf
movb $0x0, -0x1(%rbp)
jmp 0x10237
movq -0x30(%rbp), %rdi
callq 0x13790
testb $0x1, %al
jne 0x101ce
jmp 0x101d4
movb $0x0, -0x1(%rbp)
jmp 0x10237
movq -0x30(%rbp), %rdi
callq 0x134f0
testb $0x1, %al
jne 0x101e3
jmp 0x10233
movq -0x30(%rbp), %rax
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
addq $0xc, %rax
movl (%rax), %eax
movl -0x24(%rbp), %ecx
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1020a
movb $0x0, -0x1(%rbp)
jmp 0x10237
movq -0x30(%rbp), %rax
movl $0x0, -0x24(%rbp)
addq $0xc, %rax
movl (%rax), %eax
movl -0x24(%rbp), %ecx
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x10231
movb $0x0, -0x1(%rbp)
jmp 0x10237
jmp 0x10233
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jl 0x10274
cmpl $0x5, -0x8(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1027d
jmp 0x1027f
jmp 0x1029e
leaq 0x230be(%rip), %rdi     # 0x33344
leaq 0x230d1(%rip), %rsi     # 0x3335e
movl $0x1ac, %edx            # imm = 0x1AC
leaq 0x230fc(%rip), %rcx     # 0x33395
callq 0x4350
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x3a256(%rip), %rax     # 0x4a500
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x14(%rax)
jne 0x102bd
movb $0x0, -0x1(%rbp)
jmp 0x102ec
movl -0x8(%rbp), %eax
leaq 0x3a239(%rip), %rcx     # 0x4a500
imulq $0x18, %rax, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movw 0x10(%rcx), %cx
movw %cx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x10325
cmpl $0x5, -0x8(%rbp)
je 0x10325
movb $0x0, -0x1(%rbp)
jmp 0x10363
cmpl $0x0, -0x8(%rbp)
je 0x1033e
movq -0x28(%rbp), %rdi
callq 0x10150
testb $0x1, %al
jne 0x1033e
movb $0x0, -0x1(%rbp)
jmp 0x10363
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rdx
callq 0x154a0
leaq 0x3a222(%rip), %rdi     # 0x4a578
leaq -0x20(%rbp), %rsi
callq 0x154d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x10413
movslq -0x14(%rbp), %rax
leaq 0x3a14c(%rip), %rcx     # 0x4a500
imulq $0x18, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x0, 0x14(%rcx)
movb %al, -0x25(%rbp)
je 0x103f7
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x3a12b(%rip), %rax     # 0x4a500
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x24(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x1c(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x10430
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x10400
jmp 0x10406
movb $0x1, -0x1(%rbp)
jmp 0x10417
jmp 0x10408
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x103a3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/netbase.cpp
// Function: ConnectSocket(CService const&, unsigned int&, int)
bool ConnectSocket(const CService &addrDest, SOCKET& hSocketRet, int nTimeout)
{
    const proxyType &proxy = proxyInfo[addrDest.GetNetwork()];

    // no proxy needed
    if (!proxy.second)
        return ConnectSocketDirectly(addrDest, hSocketRet, nTimeout);

    SOCKET hSocket = INVALID_SOCKET;

    // first connect to proxy server
    if (!ConnectSocketDirectly(proxy.first, hSocket, nTimeout))
        return false;

    // do socks negotiation
    switch (proxy.second) {
    case 4:
        if (!Socks4(addrDest, hSocket))
            return false;
        break;
    case 5:
        if (!Socks5(addrDest.ToStringIP(), addrDest.GetPort(), hSocket))
            return false;
        break;
    default:
        return false;
    }

    hSocketRet = hSocket;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x105c0
movl %eax, %eax
movl %eax, %ecx
leaq 0x3a069(%rip), %rax     # 0x4a500
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x104c6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x10640
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x105a5
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x2c(%rbp), %rsi
callq 0x10640
testb $0x1, %al
jne 0x104ea
movb $0x0, -0x1(%rbp)
jmp 0x105a5
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x60(%rbp)
subl $0x4, %eax
je 0x10508
jmp 0x104fb
movl -0x60(%rbp), %eax
subl $0x5, %eax
je 0x10524
jmp 0x10592
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x10d80
testb $0x1, %al
jne 0x10522
movb $0x0, -0x1(%rbp)
jmp 0x105a5
jmp 0x10598
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x12500
movq -0x10(%rbp), %rdi
callq 0x12ad0
movw %ax, -0x62(%rbp)
jmp 0x10540
movw -0x62(%rbp), %ax
movzwl %ax, %esi
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x113b0
movb %al, -0x63(%rbp)
jmp 0x10559
movb -0x63(%rbp), %al
xorb $-0x1, %al
movb %al, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x42f0
movb -0x64(%rbp), %al
testb $0x1, %al
jne 0x10573
jmp 0x10590
movb $0x0, -0x1(%rbp)
jmp 0x105a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x42f0
jmp 0x105b0
jmp 0x10598
movb $0x0, -0x1(%rbp)
jmp 0x105a5
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x13b40
testb $0x1, %al
jne 0x105e6
movl $0x0, -0x4(%rbp)
jmp 0x10635
movq -0x18(%rbp), %rdi
callq 0x134f0
testb $0x1, %al
jne 0x105f5
jmp 0x105fe
movl $0x1, -0x4(%rbp)
jmp 0x10635
movq -0x18(%rbp), %rdi
callq 0x13580
testb $0x1, %al
jne 0x1060d
jmp 0x10616
movl $0x3, -0x4(%rbp)
jmp 0x10635
movq -0x18(%rbp), %rdi
callq 0x135b0
testb $0x1, %al
jne 0x10625
jmp 0x1062e
movl $0x4, -0x4(%rbp)
jmp 0x10635
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x12e30
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x152b0
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %ecx
andl $0x1, %ecx
movl $0x1, %edx
callq 0xf8c0
movb %al, -0x3d(%rbp)
jmp 0x133af
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x133b8
jmp 0x133f3
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15380
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x133f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x153c0
jmp 0x13402
leaq -0x30(%rbp), %rdi
callq 0x153c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x47f0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x12e30
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x152b0
movq -0x10(%rbp), %rdi
callq 0x41e0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
movzbl -0x11(%rbp), %ecx
andl $0x1, %ecx
movl $0x1, %edx
callq 0xf8c0
movb %al, -0x3d(%rbp)
jmp 0x13467
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x13470
jmp 0x134ab
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15380
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x134ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x153c0
jmp 0x134ba
leaq -0x30(%rbp), %rdi
callq 0x153c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::IsRFC1918() const
bool CNetAddr::IsRFC1918() const
{
    return IsIPv4() && (
        GetByte(3) == 10 ||
        (GetByte(3) == 192 && GetByte(2) == 168) ||
        (GetByte(3) == 172 && (GetByte(2) >= 16 && GetByte(2) <= 31)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x134f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x1360a
jmp 0x136ba
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x134d0
movl %eax, %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x19(%rbp)
je 0x136b4
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x134d0
cmpl $0xc0, %eax
jne 0x1365a
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x134d0
movl %eax, %ecx
movb $0x1, %al
cmpl $0xa8, %ecx
movb %al, -0x19(%rbp)
je 0x136b4
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x134d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0xac, %ecx
movb %al, -0x1a(%rbp)
jne 0x136ae
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x134d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x10, %ecx
movb %al, -0x1b(%rbp)
jb 0x136a8
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x134d0
cmpl $0x1f, %eax
setbe %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::IsLocal() const
bool CNetAddr::IsLocal() const
{
    // IPv4 loopback
   if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0))
       return true;

   // IPv6 loopback (::1/128)
   static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
   if (memcmp(ip, pchLocal, 16) == 0)
       return true;

   return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x134f0
testb $0x1, %al
jne 0x13a5f
jmp 0x13a8b
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x134d0
cmpl $0x7f, %eax
je 0x13a85
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x134d0
cmpl $0x0, %eax
jne 0x13a8b
movb $0x1, -0x1(%rbp)
jmp 0x13abb
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movaps 0x1f897(%rip), %xmm1    # 0x33330
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x13ab7
movb $0x1, -0x1(%rbp)
jmp 0x13abb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x134f0
testb $0x1, %al
jne 0x13c57
jmp 0x13cd6
movq -0x20(%rbp), %rax
cmpl $0x10, (%rax)
jae 0x13c69
movb $0x0, -0x1(%rbp)
jmp 0x13d5f
movq -0x20(%rbp), %rax
movl $0x10, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x4270
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
callq 0x13ee0
testb $0x1, %al
jne 0x13cac
movb $0x0, -0x1(%rbp)
jmp 0x13d5f
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movw $0x2, (%rcx)
movzwl 0x10(%rax), %edi
callq 0x4080
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x2(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13d5f
movq -0x38(%rbp), %rdi
callq 0x13520
testb $0x1, %al
jne 0x13ce5
jmp 0x13d5b
movq -0x20(%rbp), %rax
cmpl $0x1c, (%rax)
jae 0x13cf4
movb $0x0, -0x1(%rbp)
jmp 0x13d5f
movq -0x20(%rbp), %rax
movl $0x1c, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x4270
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x13f30
testb $0x1, %al
jne 0x13d34
movb $0x0, -0x1(%rbp)
jmp 0x13d5f
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movw $0xa, (%rcx)
movzwl 0x10(%rax), %edi
callq 0x4080
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x2(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13d5f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tenup-coin[P]seeder/./util.h
// Function: strprintf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ...)
std::string static inline strprintf(const std::string &format, ...) {
    va_list arg_ptr;
    va_start(arg_ptr, format);
    std::string ret = vstrprintf(format, arg_ptr);
    va_end(arg_ptr);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x100(%rbp)
movq %rdi, %r10
movq %r10, -0xf8(%rbp)
testb %al, %al
je 0x13dbc
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movb $0x0, -0x31(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x31320
leaq -0x30(%rbp), %rax
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x13e2f
movq -0x100(%rbp), %rdi
callq 0x42f0
movq -0xf8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::GetInAddr(in_addr*) const
bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const
{
    if (!IsIPv4())
        return false;
    memcpy(pipv4Addr, ip+12, 4);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x134f0
testb $0x1, %al
jne 0x13f07
movb $0x0, -0x1(%rbp)
jmp 0x13f18
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0xc(%rcx), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/netbase.cpp
// Function: GetExtNetwork(CNetAddr const*)
int static GetExtNetwork(const CNetAddr *addr)
{
    if (addr == NULL)
        return NET_UNKNOWN;
    if (addr->IsRFC4380())
        return NET_TEREDO;
    return addr->GetNetwork();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x145bc
movl $0x5, -0x4(%rbp)
jmp 0x145e0
movq -0x10(%rbp), %rdi
callq 0x138a0
testb $0x1, %al
jne 0x145cb
jmp 0x145d4
movl $0x6, -0x4(%rbp)
jmp 0x145e0
movq -0x10(%rbp), %rdi
callq 0x105c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x40(%rbp)
subl $0x2, %eax
je 0x14813
jmp 0x14809
movl -0x40(%rbp), %eax
subl $0xa, %eax
je 0x14841
jmp 0x1486f
movq -0x18(%rbp), %rsi
leaq -0x2a(%rbp), %rdi
callq 0x14700
movq -0x48(%rbp), %rax
movq -0x2a(%rbp), %rcx
movq %rcx, (%rax)
movq -0x22(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw -0x1a(%rbp), %cx
movw %cx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x14873
movq -0x18(%rbp), %rsi
leaq -0x3c(%rbp), %rdi
callq 0x14770
movq -0x48(%rbp), %rax
movq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
movq -0x34(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw -0x2c(%rbp), %cx
movw %cx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x14873
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x132e0
movq -0x30(%rbp), %rdi
callq 0x145f0
leaq -0x24(%rbp), %rdi
callq 0x14610
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
leaq -0x24(%rbp), %rsi
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0xff90
testb $0x1, %al
jne 0x148d3
jmp 0x148ee
movq -0x30(%rbp), %rax
movq -0x24(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1c(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw -0x14(%rbp), %cx
movw %cx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x132e0
movq -0x30(%rbp), %rdi
callq 0x145f0
leaq -0x28(%rbp), %rdi
callq 0x14610
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movb -0x15(%rbp), %al
leaq -0x28(%rbp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0xff90
testb $0x1, %al
jne 0x14957
jmp 0x14972
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw -0x18(%rbp), %cx
movw %cx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x132e0
movq -0x30(%rbp), %rdi
callq 0x145f0
leaq -0x24(%rbp), %rdi
callq 0x14610
movq -0x10(%rbp), %rdi
callq 0x41e0
movq %rax, %rdi
movb -0x11(%rbp), %al
leaq -0x24(%rbp), %rsi
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0xff90
testb $0x1, %al
jne 0x149db
jmp 0x149f6
movq -0x30(%rbp), %rax
movq -0x24(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1c(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw -0x14(%rbp), %cx
movw %cx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x132e0
movq -0x30(%rbp), %rdi
callq 0x145f0
leaq -0x28(%rbp), %rdi
callq 0x14610
movq -0x10(%rbp), %rdi
callq 0x41e0
movq %rax, %rdi
movl -0x14(%rbp), %edx
movb -0x15(%rbp), %al
leaq -0x28(%rbp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0xff90
testb $0x1, %al
jne 0x14a5f
jmp 0x14a7a
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movw -0x18(%rbp), %cx
movw %cx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x15600
movq -0x30(%rbp), %rdi
movl $0x12, %esi
callq 0x156e0
jmp 0x14c7c
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15530
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movzwl 0x10(%rax), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movb %al, -0x42(%rbp)
movl $0x10, %esi
callq 0x15530
movb -0x42(%rbp), %dl
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movb %dl, (%rcx)
movzwl 0x10(%rax), %eax
andl $0xff, %eax
movb %al, -0x41(%rbp)
movl $0x11, %esi
callq 0x15530
movb -0x41(%rbp), %cl
movb %cl, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x14d12
jmp 0x14d09
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x15550
jmp 0x14d1c
movq -0x30(%rbp), %rdi
callq 0x15550
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/netbase.cpp
// Function: CService::ToStringIPPort[abi:cxx11]() const
std::string CService::ToStringIPPort() const
{
    if (IsIPv4() || IsTor() || IsI2P()) {
        return ToStringIP() + ":" + ToStringPort();
    } else {
        return "[" + ToStringIP() + "]:" + ToStringPort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x134f0
testb $0x1, %al
jne 0x14e3d
movq -0x108(%rbp), %rdi
callq 0x13580
testb $0x1, %al
jne 0x14e3d
movq -0x108(%rbp), %rdi
callq 0x135b0
testb $0x1, %al
jne 0x14e3d
jmp 0x14efd
movq -0x108(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x12500
movq -0x120(%rbp), %rsi
leaq 0x1e644(%rip), %rdx     # 0x334a6
leaq -0x30(%rbp), %rdi
callq 0x155b0
jmp 0x14e6d
movq -0x108(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x14d30
jmp 0x14e7f
movq -0x118(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x15770
jmp 0x14e95
leaq -0x80(%rbp), %rdi
callq 0x42f0
leaq -0x30(%rbp), %rdi
callq 0x42f0
leaq -0x50(%rbp), %rdi
callq 0x42f0
jmp 0x1501a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x14eef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x14ee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x42f0
leaq -0x30(%rbp), %rdi
callq 0x42f0
leaq -0x50(%rbp), %rdi
callq 0x42f0
jmp 0x1502a
movq -0x108(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x12500
movq -0x128(%rbp), %rdx
leaq 0x1e57e(%rip), %rsi     # 0x334a3
leaq -0xc0(%rbp), %rdi
callq 0x15840
jmp 0x14f33
leaq 0x1e56b(%rip), %rdx     # 0x334a5
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x155b0
jmp 0x14f4f
movq -0x108(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x14d30
jmp 0x14f64
movq -0x118(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x15770
jmp 0x14f80
leaq -0x100(%rbp), %rdi
callq 0x42f0
leaq -0xa0(%rbp), %rdi
callq 0x42f0
leaq -0xc0(%rbp), %rdi
callq 0x42f0
leaq -0xe0(%rbp), %rdi
callq 0x42f0
jmp 0x1501a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1500c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x15000
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x14ff4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x42f0
leaq -0xa0(%rbp), %rdi
callq 0x42f0
leaq -0xc0(%rbp), %rdi
callq 0x42f0
leaq -0xe0(%rbp), %rdi
callq 0x42f0
jmp 0x1502a
movq -0x110(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/./strlcpy.h
// Function: strlcpy(char*, char const*, unsigned long)
inline size_t strlcpy(char *dst, const char *src, size_t siz)
{
    char *d = dst;
    const char *s = src;
    size_t n = siz;

    /* Copy as many bytes as will fit */
    if (n != 0)
    {
        while (--n != 0)
        {
            if ((*d++ = *s++) == '\0')
                break;
        }
    }

    /* Not enough room in dst, add NUL and traverse rest of src */
    if (n == 0)
    {
        if (siz != 0)
            *d = '\0';  /* NUL-terminate dst */
        while (*s++)
            ;
    }

    return(s - src - 1); /* count does not include NUL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x15263
jmp 0x15221
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x15261
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x1525f
jmp 0x15261
jmp 0x15221
jmp 0x15263
cmpq $0x0, -0x30(%rbp)
jne 0x15292
cmpq $0x0, -0x18(%rbp)
je 0x15278
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x1527a
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpb $0x0, (%rax)
je 0x15290
jmp 0x1527a
jmp 0x15292
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tenup-coin[P]seeder/./compat.h
// Function: myclosesocket(unsigned int&)
inline int myclosesocket(SOCKET& hSocket)
{
    if (hSocket == INVALID_SOCKET)
        return WSAENOTSOCK;
#ifdef WIN32
    int ret = closesocket(hSocket);
#else
    int ret = close(hSocket);
#endif
    hSocket = INVALID_SOCKET;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x1662e
movl $0x9, -0x4(%rbp)
jmp 0x1664c
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x48c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::CMessageHeader()
CMessageHeader::CMessageHeader()
{
    memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
    memset(pchCommand, 0, sizeof(pchCommand));
    pchCommand[1] = 1;
    nMessageSize = -1;
    nChecksum = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl 0x31f06(%rip), %eax     # 0x4a4b0
movl %eax, (%rdi)
addq $0x4, %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x4270
movq -0x10(%rbp), %rax
movb $0x1, 0x5(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::CMessageHeader(char const*, unsigned int)
CMessageHeader::CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn)
{
    memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
    strncpy(pchCommand, pszCommand, COMMAND_SIZE);
    nMessageSize = nMessageSizeIn;
    nChecksum = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x31eaf(%rip), %eax     # 0x4a4b0
movl %eax, (%rdi)
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movl $0xc, %edx
callq 0x4250
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsbl 0xf(%rax), %eax
cmpl $0x0, %eax
jne 0x186c3
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq %rdi, -0x58(%rbp)
callq 0x4210
movq %rax, %rcx
movq -0x30(%rbp), %rax
leaq 0x4(%rax,%rcx), %rax
movq %rax, -0x50(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4800
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x18d10
jmp 0x186a1
leaq -0x11(%rbp), %rdi
callq 0x4520
jmp 0x18720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4520
jmp 0x1872a
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x70(%rbp)
addq $0x10, %rax
movq %rax, -0x68(%rbp)
leaq -0x25(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4800
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x18d10
jmp 0x186fe
leaq -0x25(%rbp), %rdi
callq 0x4520
jmp 0x18720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4520
jmp 0x1872a
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movl 0x31d54(%rip), %ecx     # 0x4a4b0
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x18772
movb $0x0, -0x1(%rbp)
jmp 0x18882
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x4, %rcx
addq $0xc, %rcx
cmpq %rcx, %rax
jae 0x18817
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x187e1
jmp 0x187a5
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x4, %rcx
addq $0xc, %rcx
cmpq %rcx, %rax
jae 0x187df
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x187cf
movb $0x0, -0x1(%rbp)
jmp 0x18882
jmp 0x187d1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x187a5
jmp 0x18804
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x187f9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jle 0x18802
movb $0x0, -0x1(%rbp)
jmp 0x18882
jmp 0x18804
jmp 0x18806
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1877e
movq -0x50(%rbp), %rax
cmpl $0x2000000, 0x10(%rax)  # imm = 0x2000000
jbe 0x1887e
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x18630
movq -0x58(%rbp), %rdi
callq 0x41e0
movq %rax, %rsi
movq -0x50(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x1b05a(%rip), %rdi     # 0x338a9
xorl %eax, %eax
callq 0x4070
jmp 0x18858
leaq -0x38(%rbp), %rdi
callq 0x42f0
movb $0x0, -0x1(%rbp)
jmp 0x18882
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x42f0
jmp 0x1888d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x4, %rdi
callq 0xa260
movl $0x1, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x3, %rax
jae 0x18abc
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x31a2b(%rip), %rax     # 0x4a4c0
movq (%rax,%rcx,8), %rsi
callq 0xdba0
testb $0x1, %al
jne 0x18aa4
jmp 0x18aaf
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x18abc
jmp 0x18ab1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18a7c
movslq -0x1c(%rbp), %rax
cmpq $0x3, %rax
jne 0x18b16
movl $0x10, %edi
callq 0x4230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x1ae1a(%rip), %rsi     # 0x338fb
callq 0x40a0
jmp 0x18ae8
movq -0x40(%rbp), %rdi
movq 0x314ed(%rip), %rsi     # 0x49fe0
movq 0x314d6(%rip), %rdx     # 0x49fd0
callq 0x47e0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x43a0
jmp 0x18b43
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x4(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0xc(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x14(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x1c(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: tenup-coin[P]seeder/./uint256.h
// Function: uint256::operator=(unsigned long long)
uint256& operator=(uint64 b)
    {
        pn[0] = (unsigned int)b;
        pn[1] = (unsigned int)(b >> 32);
        for (int i = 2; i < WIDTH; i++)
            pn[i] = 0;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
movl %ecx, 0x4(%rax)
movl $0x2, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x18dcc
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18dac
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)