LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::PushVersion()
void PushVersion() {
    int64 nTime = time(NULL);
    uint64 nLocalNonce = BITCOIN_SEED_NONCE;
    int64 nLocalServices = 0;
    CAddress me(CService("0.0.0.0"));
    BeginMessage("version");
    int nBestHeight = GetRequireHeight();
    string ver = "/tenup-seeder:0.01/";
    vSend << PROTOCOL_VERSION << nLocalServices << nTime << you << me << nLocalNonce << ver << nBestHeight;
    EndMessage();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x33d0
movq %rax, 0x38(%rsp)
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
movq %rax, 0x30(%rsp)
andq $0x0, 0x28(%rsp)
leaq 0xd4bc(%rip), %rsi      # 0x12004
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x8bea
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x78(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x9a64
leaq 0xd48f(%rip), %rsi      # 0x1200c
movq %rbx, %rdi
callq 0x4fa8
leaq 0x18924(%rip), %rax     # 0x1d4b0
cmpb $0x0, (%rax)
movl $0x3a98, %eax           # imm = 0x3A98
cmovnel %r15d, %eax
movl %eax, 0x24(%rsp)
leaq 0xd471(%rip), %rsi      # 0x12014
leaq 0x40(%rsp), %rdi
leaq 0x23(%rsp), %rdx
callq 0x3180
leaq 0x8(%rbx), %rdi
leaq 0xd693(%rip), %rsi      # 0x12250
callq 0x500e
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x5024
leaq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x5024
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0x503c
leaq 0x78(%rsp), %rsi
movq %rax, %rdi
callq 0x503c
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x5056
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x506e
leaq 0x24(%rsp), %rsi
movq %rax, %rdi
callq 0x500e
movq %rbx, %rdi
callq 0x5082
leaq 0x40(%rsp), %rdi
callq 0x31d0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3690
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::Send()
void Send() {
    if (sock == INVALID_SOCKET) return;
    if (vSend.empty()) return;
    int nBytes = send(sock, &vSend[0], vSend.size(), 0);
    if (nBytes > 0) {
      vSend.erase(vSend.begin(), vSend.begin() + nBytes);
    } else {
      close(sock);
      sock = INVALID_SOCKET;
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $-0x1, %edi
je 0x4cac
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rdx, %rcx
subq %rsi, %rcx
movl 0x20(%rbx), %eax
cmpq %rax, %rcx
je 0x4cac
addq %rax, %rsi
subq %rsi, %rdx
xorl %ecx, %ecx
callq 0x31f0
testl %eax, %eax
jle 0x4ca2
leaq 0x8(%rbx), %rdi
movl 0x20(%rbx), %esi
addq 0x8(%rbx), %rsi
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rsi, %rax
movq %rax, %rdx
popq %rbx
jmp 0x56fa
movl (%rbx), %edi
callq 0x3740
orl $-0x1, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::BeginMessage(char const*)
void BeginMessage(const char *pszCommand) {
    if (nHeaderStart != -1) AbortMessage();
    nHeaderStart = vSend.size();
    vSend << CMessageHeader(pszCommand, 0);
    nMessageStart = vSend.size();
    //printf("%s: SEND %s\n", ToString(you).c_str(), pszCommand); 
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x58(%rdi)
je 0x4fc7
movq %rbx, %rdi
callq 0x5110
leaq 0x8(%rbx), %r15
movl 0x8(%rbx), %eax
movl 0x10(%rbx), %ecx
addl 0x20(%rbx), %eax
subl %eax, %ecx
movl %ecx, 0x58(%rbx)
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9934
movq %r15, %rdi
movq %r12, %rsi
callq 0x5134
movl 0x8(%rbx), %eax
movl 0x10(%rbx), %ecx
addl 0x20(%rbx), %eax
subl %eax, %ecx
movl %ecx, 0x5c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::EndMessage()
void EndMessage() {
    if (nHeaderStart == -1) return;
    unsigned int nSize = vSend.size() - nMessageStart;
    memcpy((char*)&vSend[nHeaderStart] + offsetof(CMessageHeader, nMessageSize), &nSize, sizeof(nSize));
    if (vSend.GetVersion() >= 209) {
      uint256 hash = Hash(vSend.begin() + nMessageStart, vSend.end());
      unsigned int nChecksum = 0;
      memcpy(&nChecksum, &hash, sizeof(nChecksum));
      assert(nMessageStart - nHeaderStart >= offsetof(CMessageHeader, nChecksum) + sizeof(nChecksum));
      memcpy((char*)&vSend[nHeaderStart] + offsetof(CMessageHeader, nChecksum), &nChecksum, sizeof(nChecksum));
    }
    nHeaderStart = -1;
    nMessageStart = -1;
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl 0x58(%rdi), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x50ec
movq %rdi, %rbx
movl 0x20(%rdi), %ecx
addq 0x8(%rdi), %rcx
movl 0x10(%rdi), %edx
subl %ecx, %edx
subl 0x5c(%rdi), %edx
movl %edx, 0x10(%rax,%rcx)
cmpl $0xd1, 0x2c(%rdi)
jl 0x50e7
movl 0x20(%rbx), %eax
addq 0x8(%rbx), %rax
movl 0x5c(%rbx), %esi
addq %rax, %rsi
movq 0x10(%rbx), %rdx
movq %rsp, %rdi
callq 0x5688
movl 0x58(%rbx), %eax
movl 0x5c(%rbx), %ecx
subl %eax, %ecx
cmpl $0x17, %ecx
jbe 0x50f2
movl (%rsp), %ecx
movl 0x20(%rbx), %edx
addq 0x8(%rbx), %rdx
movl %ecx, 0x14(%rax,%rdx)
orq $-0x1, 0x58(%rbx)
addq $0x20, %rsp
popq %rbx
retq
leaq 0xcf93(%rip), %rdi      # 0x1208c
leaq 0xcfe4(%rip), %rsi      # 0x120e4
leaq 0xcfe9(%rip), %rcx      # 0x120f0
pushq $0x39
popq %rdx
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::write(char const*, int)
CDataStream& write(const char* pch, int nSize)
    {
        // Write to the end of the buffer
        assert(nSize >= 0);
        vch.insert(vch.end(), pch, pch + nSize);
        return (*this);
    }

// Assembly:
pushq %rbx
testl %edx, %edx
js 0x51fb
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movl %edx, %ecx
addq %rax, %rcx
movq %rax, %rdx
callq 0x521a
movq %rbx, %rax
popq %rbx
retq
leaq 0xce26(%rip), %rdi      # 0x12028
leaq 0xce2a(%rip), %rsi      # 0x12033
leaq 0xce31(%rip), %rcx      # 0x12041
movl $0x43e, %edx            # imm = 0x43E
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: secure_allocator<char>::allocate(unsigned long, void const*)
T* allocate(std::size_t n, const void *hint = 0)
    {
        T *p;
        p = std::allocator<T>::allocate(n, hint);
        if (p != NULL)
            mlock(p, sizeof(T) * n);
        return p;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
callq 0x5462
movq %rax, %rbx
testq %rax, %rax
je 0x5456
pushq $0x1e
popq %rbp
movl %ebp, %edi
callq 0x32b0
movq %rax, %r15
negq %r15
andq %rbx, %r15
leaq (%r14,%rbx), %r12
decq %r12
movl %ebp, %edi
callq 0x32b0
leaq -0x1(%rax), %r14
orq %r12, %r14
movl %ebp, %edi
callq 0x32b0
negq %rax
andq %rbx, %rax
subq %rax, %r14
incq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x3530
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: void WriteCompactSize<CDataStream>(CDataStream&, unsigned long long)
void WriteCompactSize(Stream& os, uint64 nSize)
{
    if (nSize < 253)
    {
        unsigned char chSize = nSize;
        WRITEDATA(os, chSize);
    }
    else if (nSize <= USHRT_MAX)
    {
        unsigned char chSize = 253;
        unsigned short xSize = nSize;
        WRITEDATA(os, chSize);
        WRITEDATA(os, xSize);
    }
    else if (nSize <= UINT_MAX)
    {
        unsigned char chSize = 254;
        unsigned int xSize = nSize;
        WRITEDATA(os, chSize);
        WRITEDATA(os, xSize);
    }
    else
    {
        unsigned char chSize = 255;
        uint64 xSize = nSize;
        WRITEDATA(os, chSize);
        WRITEDATA(os, xSize);
    }
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0xfc, %rsi
ja 0x55fd
leaq 0x10(%rsp), %rax
movb %sil, (%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x567b
cmpq $0xffff, %rsi           # imm = 0xFFFF
ja 0x5629
leaq 0xf(%rsp), %rax
movb $-0x3, (%rax)
leaq 0x10(%rsp), %r14
movw %si, (%r14)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x51da
pushq $0x2
jmp 0x5674
movq %rsi, %rax
shrq $0x20, %rax
jne 0x5654
leaq 0xf(%rsp), %rax
movb $-0x2, (%rax)
leaq 0x10(%rsp), %r14
movl %esi, (%r14)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x51da
pushq $0x4
jmp 0x5674
leaq 0xf(%rsp), %rax
movb $-0x1, (%rax)
leaq 0x10(%rsp), %r14
movq %rsi, (%r14)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x51da
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51da
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./util.h
// Function: uint256 Hash<__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>)
inline uint256 Hash(const T1 pbegin, const T1 pend)
{
    static unsigned char pblank[1];
    uint256 hash1;
    SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);
    uint256 hash2;
    SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
    return hash2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x56e8
subq %r14, %rbx
leaq 0x17d4e(%rip), %rdi     # 0x1d401
cmovneq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x34f0
movq %r15, %rdi
callq 0x56e8
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x34f0
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::erase(__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>)
iterator erase(iterator first, iterator last)
    {
        if (first == vch.begin() + nReadPos)
        {
            // special case for erasing from the front
            if (last == vch.end())
            {
                nReadPos = 0;
                return vch.erase(vch.begin(), vch.end());
            }
            else
            {
                nReadPos = (last - vch.begin());
                return last;
            }
        }
        else
            return vch.erase(first, last);
    }

// Assembly:
movq %rsi, %rax
movq (%rdi), %rsi
movl 0x18(%rdi), %ecx
addq %rsi, %rcx
cmpq %rax, %rcx
je 0x5713
movq %rax, %rsi
jmp 0x5734
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
je 0x5727
movl %edx, %eax
subl %esi, %eax
movl %eax, 0x18(%rdi)
movq %rdx, %rax
retq
andl $0x0, 0x18(%rdi)
movq %rax, %rdx
jmp 0x5734
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::insert(__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>)
void insert(iterator it, std::vector<char>::const_iterator first, std::vector<char>::const_iterator last)
    {
        if (it == vch.begin() + nReadPos && last - first <= nReadPos)
        {
            // special case for inserting at the front when there's room
            nReadPos -= (last - first);
            memcpy(&vch[nReadPos], &first[0], last - first);
        }
        else
            vch.insert(it, first, last);
    }

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x18(%rax), %r9d
leaq (%rdi,%r9), %r8
cmpq %rsi, %r8
jne 0x5998
movq %rcx, %r8
subq %rdx, %r8
cmpq %r9, %r8
jle 0x59a0
movq %rax, %rdi
jmp 0x6088
subl %r8d, %r9d
movl %r9d, 0x18(%rax)
addq %r9, %rdi
movq %rdx, %rsi
movq %r8, %rdx
jmp 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::ignore(int)
CDataStream& ignore(int nSize)
    {
        // Ignore from the beginning of the buffer
        assert(nSize >= 0);
        unsigned int nReadPosNext = nReadPos + nSize;
        if (nReadPosNext >= vch.size())
        {
            if (nReadPosNext > vch.size())
            {
                setstate(std::ios::failbit, "CDataStream::ignore() : end of data");
                nSize = vch.size() - nReadPos;
            }
            nReadPos = 0;
            vch.clear();
            return (*this);
        }
        nReadPos = nReadPosNext;
        return (*this);
    }

// Assembly:
pushq %rbx
testl %esi, %esi
js 0x5a3f
movq %rdi, %rbx
addl 0x18(%rdi), %esi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x5a12
movl %esi, 0x18(%rbx)
jmp 0x5a3a
jae 0x5a2d
leaq 0xc7aa(%rip), %rdx      # 0x121c5
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x6014
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
andl $0x0, 0x18(%rbx)
cmpq %rax, %rcx
je 0x5a3a
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xc5e2(%rip), %rdi      # 0x12028
leaq 0xc5e6(%rip), %rsi      # 0x12033
leaq 0xc74b(%rip), %rcx      # 0x1219f
movl $0x42a, %edx            # imm = 0x42A
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::read(char*, int)
CDataStream& read(char* pch, int nSize)
    {
        // Read from the beginning of the buffer
        assert(nSize >= 0);
        unsigned int nReadPosNext = nReadPos + nSize;
        if (nReadPosNext >= vch.size())
        {
            if (nReadPosNext > vch.size())
            {
                setstate(std::ios::failbit, "CDataStream::read() : end of data");
                memset(pch, 0, nSize);
                nSize = vch.size() - nReadPos;
            }
            memcpy(pch, &vch[nReadPos], nSize);
            nReadPos = 0;
            vch.clear();
            return (*this);
        }
        memcpy(pch, &vch[nReadPos], nSize);
        nReadPos = nReadPosNext;
        return (*this);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x5ff5
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %eax
leal (%rax,%r15), %r12d
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
subq %rsi, %rcx
cmpq %r12, %rcx
jbe 0x5f91
addq %rax, %rsi
movl %r15d, %edx
movq %r14, %rdi
callq 0x3360
movl %r12d, 0x18(%rbx)
jmp 0x5fe6
jae 0x5fc2
leaq 0xc1e3(%rip), %rdx      # 0x1217d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x6014
movl %r15d, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3230
movl 0x8(%rbx), %r15d
movq (%rbx), %rsi
subl %esi, %r15d
movl 0x18(%rbx), %eax
subl %eax, %r15d
movl %eax, %eax
addq %rsi, %rax
movslq %r15d, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3360
andl $0x0, 0x18(%rbx)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x5fe6
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xc02c(%rip), %rdi      # 0x12028
leaq 0xc030(%rip), %rsi      # 0x12033
leaq 0xc147(%rip), %rcx      # 0x12151
movl $0x413, %edx            # imm = 0x413
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::GotVersion()
void GotVersion() {
     //printf("\n%s: version %i\n", ToString(you).c_str(), nVersion);
    if (vAddr) {
      BeginMessage("getaddr");
      EndMessage();
      doneAfter = time(NULL) + GetTimeout();
    } else {
      doneAfter = time(NULL) + 1;
    }
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x90(%rdi)
je 0x6367
leaq 0xbed5(%rip), %rsi      # 0x12213
movq %rbx, %rdi
callq 0x4fa8
movq %rbx, %rdi
callq 0x5082
xorl %edi, %edi
callq 0x33d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4cae
cltq
addq %r14, %rax
jmp 0x6371
xorl %edi, %edi
callq 0x33d0
incq %rax
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: void Unserialize<CDataStream, char>(CDataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int)
void Unserialize(Stream& is, std::basic_string<C>& str, int, int)
{
    unsigned int nSize = ReadCompactSize(is);
    str.resize(nSize);
    if (nSize != 0)
        is.read((char*)&str[0], nSize * sizeof(str[0]));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x64d2
movq %rax, %r15
movl %r15d, %esi
movq %r14, %rdi
callq 0x3560
testl %r15d, %r15d
je 0x64cc
movq (%r14), %rsi
movq %rbx, %rdi
movl %r15d, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x5f4e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./serialize.h
// Function: unsigned long long ReadCompactSize<CDataStream>(CDataStream&)
uint64 ReadCompactSize(Stream& is)
{
    unsigned char chSize;
    READDATA(is, chSize);
    uint64 nSizeRet = 0;
    if (chSize < 253)
    {
        nSizeRet = chSize;
    }
    else if (chSize == 253)
    {
        unsigned short xSize;
        READDATA(is, xSize);
        nSizeRet = xSize;
    }
    else if (chSize == 254)
    {
        unsigned int xSize;
        READDATA(is, xSize);
        nSizeRet = xSize;
    }
    else
    {
        uint64 xSize;
        READDATA(is, xSize);
        nSizeRet = xSize;
    }
    if (nSizeRet > (uint64)MAX_SIZE)
        throw std::ios_base::failure("ReadCompactSize() : size too large");
    return nSizeRet;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x5f4e
movzbl (%r14), %eax
cmpq $0xfc, %rax
jbe 0x654c
leaq 0x8(%rsp), %r14
cmpq $0xfe, %rax
je 0x6520
cmpl $0xfd, %eax
jne 0x6533
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f4e
movzwl (%r14), %eax
jmp 0x654c
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f4e
movl (%r14), %eax
jmp 0x6544
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f4e
movq (%r14), %rax
cmpq $0x2000001, %rax        # imm = 0x2000001
jae 0x6554
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x20
popq %rdi
callq 0x31e0
movq %rax, %rbx
callq 0x33b0
leaq 0x8(%rsp), %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0xbc76(%rip), %rsi      # 0x121f0
movq %rbx, %rdi
callq 0x3150
movq 0x169ff(%rip), %rsi     # 0x1cf88
movq 0x16a28(%rip), %rdx     # 0x1cfb8
movq %rbx, %rdi
callq 0x3680
movq %rax, %r14
movq %rbx, %rdi
callq 0x32f0
movq %r14, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x65df
movq %rax, 0x8(%r14)
movq %r15, %rdi
callq 0x64d2
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rax, 0x10(%rsp)
cmpl %eax, %r13d
jae 0x6640
addl $0x1e848, %r13d         # imm = 0x1E848
cmpl %eax, %r13d
cmovael %eax, %r13d
movq %r14, %rdi
movq %r13, %rsi
callq 0x6650
movl %r12d, %r12d
imulq $0x28, %r12, %rbx
cmpq %r13, %r12
jae 0x6639
movq (%r14), %rdi
addq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl 0xc(%rsp), %ecx
callq 0x63c2
incq %r12
addq $0x28, %rbx
jmp 0x6617
movq 0x10(%rsp), %rax
jmp 0x65f2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3760
movq %rbx, %rdi
movq %r14, %rsi
callq 0x908f
movq %rsp, %rdi
callq 0x3590
leaq 0xc777(%rip), %rsi      # 0x1310b
movq %rbx, %rdi
callq 0x62b4
testb %al, %al
je 0x69a4
pushq $0x1
jmp 0x69d0
leaq 0xc76a(%rip), %rsi      # 0x13115
movq %rbx, %rdi
callq 0x62b4
testb %al, %al
je 0x69bb
pushq $0x2
jmp 0x69d0
leaq 0xb96e(%rip), %rsi      # 0x12330
movq %rbx, %rdi
callq 0x62b4
testb %al, %al
je 0x69d9
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb9e6(%rip), %rsi      # 0x123c6
movq %rbx, %rdi
callq 0x62b4
movzbl %al, %eax
shll $0x2, %eax
jmp 0x69d1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3590
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x3a
popq %rsi
pushq $-0x1
popq %rdx
callq 0x3750
cmpq $-0x1, %rax
je 0x6ad2
movq %rax, %r12
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x6a46
cmpb $0x5d, -0x1(%rax,%r12)
sete %bpl
jmp 0x6a48
xorl %ebp, %ebp
leaq -0x1(%r12), %rdx
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x3750
cmpq $0x1, %r12
jb 0x6a69
testb %bpl, %bpl
jne 0x6a69
cmpq $-0x1, %rax
jne 0x6ad2
movq %rsp, %rbp
andq $0x0, (%rbp)
movq (%r14), %rax
leaq (%rax,%r12), %rdi
incq %rdi
pushq $0xa
popq %rdx
movq %rbp, %rsi
callq 0x3580
movq %rax, %r13
movq (%rbp), %rax
testq %rax, %rax
je 0x6ad2
cmpb $0x0, (%rax)
jne 0x6ad2
testl %r13d, %r13d
js 0x6ad2
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x3430
movq %r14, %rdi
movq %rbp, %rsi
callq 0x34b0
movq %rbp, %rdi
callq 0x31d0
leal -0x1(%r13), %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
ja 0x6ad2
movl %r13d, (%r15)
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x6b16
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x6b16
cmpb $0x5d, -0x1(%rax,%rcx)
jne 0x6b16
addq $-0x2, %rcx
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3430
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34b0
movq %r15, %rdi
callq 0x31d0
jmp 0x6b21
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b9e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
callq 0x90b3
cmpb $0x5b, (%r15)
jne 0x6b7f
movq %rsp, %r15
movq %r15, %rdi
callq 0x31b0
cmpb $0x5d, -0x1(%rax,%r15)
jne 0x6b7f
leaq 0x1(%rsp), %r15
movb $0x0, -0x1(%rsp,%rax)
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x6ba1
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
cmpb $0x0, (%rdi)
je 0x6e60
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, 0xc(%rsp)
leaq 0xb985(%rip), %rsi      # 0x12715
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3180
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0x3180
leaq 0x48(%rsp), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x6a03
leaq 0x48(%rsp), %rdi
callq 0x31d0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq 0x28(%rsp), %rdi
movzbl %r14b, %ecx
movl %ebp, %edx
callq 0x6ba1
movl %eax, %ebp
testb %al, %al
je 0x6e4a
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x90fa
movzwl 0xc(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %ecx
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
subq %rdx, %rsi
sarq $0x4, %rsi
cmpq %rcx, %rsi
jbe 0x6e4a
movq (%rbx), %rsi
imulq $0x12, %rcx, %rdi
movq %rcx, %r8
shlq $0x4, %r8
movups (%rdx,%r8), %xmm0
movups %xmm0, (%rsi,%rdi)
movw %ax, 0x10(%rsi,%rdi)
incl %ecx
jmp 0x6e12
leaq 0x10(%rsp), %rdi
callq 0x9526
leaq 0x28(%rsp), %rdi
callq 0x31d0
jmp 0x6e62
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x31d0
jmp 0x6e90
movq %rax, %rbx
jmp 0x6e90
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9526
leaq 0x28(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rsi)
pushq $0x1
popq %r8
callq 0x6d66
movl %eax, %ebp
testb %al, %al
je 0x6eda
movq (%rsp), %rax
movzwl 0x10(%rax), %ecx
movw %cx, 0x10(%rbx)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq %rsp, %rdi
callq 0x96ea
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x96ea
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6f5d
movl %esi, %ebx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
leal -0x4(%rbx), %eax
cmpl $0x2, %eax
jae 0x6f2f
movq %r14, %rdi
callq 0x6f7c
testb %al, %al
jne 0x6f33
xorl %eax, %eax
jmp 0x6f58
testl %ebx, %ebx
jne 0x6f2b
movl %ebp, %eax
imulq $0x18, %rax, %rax
leaq 0x164d0(%rip), %rcx     # 0x1d410
movzwl 0x10(%r14), %edx
movw %dx, 0x10(%rax,%rcx)
movups (%r14), %xmm0
movups %xmm0, (%rax,%rcx)
movl %ebx, 0x14(%rax,%rcx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb3d0(%rip), %rdi      # 0x12334
leaq 0xb3e3(%rip), %rsi      # 0x1234e
leaq 0xb3e8(%rip), %rcx      # 0x1235a
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xb316(%rip), %rsi      # 0x122a1
pushq $0x9
popq %rdx
callq 0x3420
testl %eax, %eax
je 0x6fc0
pxor %xmm0, %xmm0
movdqa %xmm0, 0x10(%rsp)
movdqu (%rbx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x6fc0
movq %rbx, %rdi
callq 0x8476
testb %al, %al
je 0x6fc8
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x8392
testb %al, %al
je 0x6fed
orl $-0x1, 0xc(%rsp)
cmpl $-0x1, 0xc(%rbx)
je 0x6fc0
andl $0x0, 0xc(%rsp)
addq $0xc, %rbx
cmpl $0x0, (%rbx)
je 0x6fc0
movb $0x1, %al
jmp 0x6fc2
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7022
movl %edi, %eax
imulq $0x18, %rax, %rdx
leaq 0x1640d(%rip), %rcx     # 0x1d410
movl 0x14(%rdx,%rcx), %eax
testl %eax, %eax
je 0x701c
addq %rdx, %rcx
movzwl 0x10(%rcx), %edx
movw %dx, 0x10(%rsi)
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
testl %eax, %eax
setne %al
retq
pushq %rax
leaq 0xb30a(%rip), %rdi      # 0x12334
leaq 0xb31d(%rip), %rsi      # 0x1234e
leaq 0xb34d(%rip), %rcx      # 0x12385
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7062
cmpl $0x5, %ebx
jne 0x7083
movq %r14, %rdi
callq 0x6f7c
testb %al, %al
je 0x7083
movzwl 0x10(%r14), %eax
movw %ax, 0x1642a(%rip)      # 0x1d498
movups (%r14), %xmm0
movups %xmm0, 0x1640f(%rip)    # 0x1d488
movl %ebx, 0x1641d(%rip)     # 0x1d49c
movb $0x1, %al
jmp 0x7085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x16363(%rip), %r12     # 0x1d410
xorl %r15d, %r15d
movq %rsp, %r14
cmpq $0x5, %r15
je 0x70e2
cmpl $0x0, 0x14(%r12)
je 0x70d9
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x70f5
testb %al, %al
jne 0x70e2
incq %r15
addq $0x18, %r12
jmp 0x70b3
cmpq $0x5, %r15
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x857a
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x745a
movq %rbx, %rdi
callq 0x8392
testb %al, %al
je 0x7437
pushq $0x1
jmp 0x7445
movq %rbx, %rdi
callq 0x83d4
testb %al, %al
je 0x7448
pushq $0x3
popq %rax
jmp 0x745a
movq %rbx, %rdi
callq 0x83ec
movzbl %al, %eax
leal 0x2(,%rax,2), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/netbase.cpp
// Function: ConnectSocketByName(CService&, unsigned int&, char const*, int, int)
bool ConnectSocketByName(CService &addr, SOCKET& hSocketRet, const char *pszDest, int portDefault, int nTimeout)
{
    string strDest;
    int port = portDefault;
    SplitHostPort(string(pszDest), port, strDest);

    SOCKET hSocket = INVALID_SOCKET;
    CService addrResolved(CNetAddr(strDest, fNameLookup && !nameproxyInfo.second), port);
    if (addrResolved.IsValid()) {
        addr = addrResolved;
        return ConnectSocket(addr, hSocketRet, nTimeout);
    }
    addr = CService("0.0.0.0:0");
    if (!nameproxyInfo.second)
        return false;
    if (!ConnectSocketDirectly(nameproxyInfo.first, hSocket, nTimeout))
        return false;

    switch(nameproxyInfo.second)
    {
        default:
        case 4: return false;
        case 5:
            if (!Socks5(strDest, port, hSocket))
                return false;
            break;
    }

    hSocketRet = hSocket;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebp
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rax)
movl %ecx, 0x8(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3180
leaq 0x78(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x6a03
leaq 0x78(%rsp), %rdi
callq 0x31d0
orl $-0x1, 0x4(%rsp)
cmpl $0x0, 0x154d3(%rip)     # 0x1d49c
sete %al
andb 0x154ce(%rip), %al      # 0x1d4a0
movzbl %al, %edx
leaq 0xe(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x832e
movl 0x8(%rsp), %r15d
movups 0xe(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movw %r15w, 0x10(%rdi)
callq 0x6f7c
testb %al, %al
je 0x802b
movzwl 0x30(%rsp), %eax
movw %ax, 0x10(%r14)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x710e
movl %eax, %ebx
jmp 0x80bb
leaq 0xa37b(%rip), %rsi      # 0x123ad
leaq 0xe(%rsp), %rdi
xorl %edx, %edx
callq 0x8bea
movzwl 0x1e(%rsp), %eax
movw %ax, 0x10(%r14)
movups 0xe(%rsp), %xmm0
movups %xmm0, (%r14)
cmpl $0x0, 0x15444(%rip)     # 0x1d49c
je 0x80b9
leaq 0x15427(%rip), %rdi     # 0x1d488
leaq 0x4(%rsp), %rsi
movl %ebp, %edx
callq 0x745c
cmpl $0x5, 0x15428(%rip)     # 0x1d49c
sete %cl
andb %cl, %al
cmpb $0x1, %al
jne 0x80b9
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3550
leaq 0x58(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movl %r15d, %esi
callq 0x7721
movl %eax, %ebp
leaq 0x58(%rsp), %rdi
callq 0x31d0
testb %bpl, %bpl
je 0x80b9
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
movb $0x1, %bl
jmp 0x80bb
xorl %ebx, %ebx
leaq 0x38(%rsp), %rdi
callq 0x31d0
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x80ed
jmp 0x80f4
jmp 0x80f4
jmp 0x80f4
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x31d0
jmp 0x80f7
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rsi)
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x6b30
testb %al, %al
je 0x830d
movq (%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq %rsp, %rdi
callq 0x9526
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9526
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rax)
movq (%rsi), %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x6b30
testb %al, %al
je 0x8365
movq (%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq %rsp, %rdi
callq 0x9526
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9526
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x8392
testb %al, %al
je 0x842e
movzbl 0xc(%rbx), %eax
cmpl $0xa, %eax
je 0x843e
cmpl $0xac, %eax
je 0x8432
cmpl $0xc0, %eax
jne 0x842e
cmpb $-0x58, 0xd(%rbx)
jmp 0x8439
xorl %eax, %eax
jmp 0x8440
movb 0xd(%rbx), %al
andb $-0x10, %al
cmpb $0x10, %al
sete %al
jmp 0x8440
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x8392
testb %al, %al
je 0x853e
movzbl 0xc(%rbx), %ecx
movb $0x1, %al
testl %ecx, %ecx
je 0x8556
cmpl $0x7f, %ecx
je 0x8556
movdqu (%rbx), %xmm0
pcmpeqb 0x9dd6(%rip), %xmm0     # 0x12320
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x8392
testb %al, %al
je 0x8634
cmpl $0x10, (%r15)
jb 0x8646
movl $0x10, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x4(%rbx), %rsi
movq %r14, %rdi
callq 0x8744
movw $0x2, %cx
testb %al, %al
je 0x8646
jmp 0x8667
movq %r14, %rdi
callq 0x83aa
testb %al, %al
je 0x8646
cmpl $0x1c, (%r15)
jae 0x864a
xorl %eax, %eax
jmp 0x8679
movl $0x1c, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rbx)
movups %xmm0, (%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movw $0xa, %cx
movw %cx, (%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_O2/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)
andw $0x0, 0x10(%rdi)
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andw $0x0, 0x10(%rsi)
movq %rax, %rdi
xorl %edx, %edx
callq 0x6ea2
testb %al, %al
je 0x8c2b
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_O2/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)
andw $0x0, 0x10(%rdi)
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andw $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0x6ea2
testb %al, %al
je 0x8c6f
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_O2/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
andw $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %rax
movaps %xmm0, (%rax)
andw $0x0, 0x10(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x6ea2
testb %al, %al
je 0x8cb7
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_O2/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
andw $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %rax
movaps %xmm0, (%rax)
andw $0x0, 0x10(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x6ea2
testb %al, %al
je 0x8cfb
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_O2/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)
andq $0x0, 0x10(%rdi)
pushq $0x12
popq %rsi
callq 0x91b0
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
callq 0x96f8
movq %r14, %rdi
callq 0x3690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8392
testb %al, %al
jne 0x8ed6
movq %r14, %rdi
callq 0x83d4
testb %al, %al
jne 0x8ed6
movq %r14, %rdi
callq 0x83ec
testb %al, %al
je 0x8f41
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d1a
leaq 0x95a9(%rip), %rdx      # 0x12496
movq %rsp, %rdi
movq %r15, %rsi
callq 0x9132
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x8e3a
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x91dc
leaq 0x20(%rsp), %rdi
callq 0x31d0
movq %rsp, %rdi
callq 0x31d0
leaq 0x40(%rsp), %rdi
callq 0x31d0
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d1a
leaq 0x953b(%rip), %rsi      # 0x12493
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x9243
leaq 0x9529(%rip), %rdx      # 0x12495
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x9132
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x8e3a
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x91dc
leaq 0x60(%rsp), %rdi
callq 0x31d0
movq %rsp, %rdi
callq 0x31d0
leaq 0x40(%rsp), %rdi
callq 0x31d0
leaq 0x20(%rsp), %rdi
jmp 0x8f2c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x31d0
jmp 0x8fce
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31d0
jmp 0x8fdb
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x31d0
jmp 0x8fea
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x9015
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x31d0
jmp 0x9003
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31d0
jmp 0x9010
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3690