LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/dns.c
// Function: write_name
int static write_name(unsigned char** outpos, const unsigned char *outend, const char *name, int offset) {
  while (*name != 0) {
    char *dot = strchr(name, '.');
    const char *fin = dot;
    if (!dot) fin = name + strlen(name);
    if (fin - name > 63) return -1;
    if (fin == name) return -3;
    if (outend - *outpos < fin - name + 2) return -2;
    *((*outpos)++) = fin - name;
    memcpy(*outpos, name, fin - name);
    *outpos += fin - name;
    if (!dot) break;
    name = dot + 1;
  }
  if (offset < 0) {
    // no reference
    if (outend == *outpos) return -2;
    *((*outpos)++) = 0;
  } else {
    if (outend - *outpos < 2) return -2;
    *((*outpos)++) = (offset >> 8) | 0xC0;
    *((*outpos)++) = offset & 0xFF;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, (%r12)
je 0x4bf1
movq %r12, %rdi
movl $0x2e, %esi
callq 0x3180
movq %rax, %r13
testq %rax, %rax
jne 0x4b76
movq %r12, %rdi
callq 0x31c0
addq %r12, %rax
movq %rax, %rbp
subq %r12, %rbp
movl $0x1, %ecx
cmpq $0x3f, %rbp
jle 0x4b8f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x4be4
cmpq %r12, %rax
je 0x4bae
movq (%rbx), %rax
movq %r14, %rdx
subq %rax, %rdx
leaq 0x2(%rbp), %rsi
cmpq %rsi, %rdx
jge 0x4bb6
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
jmp 0x4be4
movl $0xfffffffd, %r15d      # imm = 0xFFFFFFFD
jmp 0x4be4
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb %bpl, (%rax)
movq (%rbx), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x3350
addq %rbp, (%rbx)
leaq 0x1(%r13), %rax
xorl %ecx, %ecx
testq %r13, %r13
sete %cl
cmovneq %rax, %r12
leal (%rcx,%rcx,2), %ecx
testl %ecx, %ecx
je 0x4b4b
cmpl $0x1, %ecx
je 0x4c3d
movq (%rbx), %rax
movl 0x4(%rsp), %edx
testl %edx, %edx
js 0x4c23
subq %rax, %r14
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpq $0x2, %r14
jl 0x4c3d
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $-0x40, (%rax)
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb %dl, (%rax)
jmp 0x4c32
cmpq %r14, %rax
je 0x4c37
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0x0, (%rax)
xorl %r15d, %r15d
jmp 0x4c3d
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/bitcoin.cpp
// Function: TestNode(CService const&, int&, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&, std::vector<CAddress, std::allocator<CAddress>>*)
bool TestNode(const CService &cip, int &ban, int &clientV, std::string &clientSV, int &blocks, vector<CAddress>* vAddr) {
  try {
    CNode node(cip, vAddr);
    bool ret = node.Run();
    if (!ret) {
      ban = node.GetBan();
    } else {
      ban = 0;
    }
    clientV = node.GetClientVersion();
    clientSV = node.GetClientSubVersion();
    blocks = node.GetStartingHeight();
  //printf("%s: %s!!!\n", cip.ToString().c_str(), ret ? "GOOD" : "BAD");
    return ret;
  } catch(std::ios_base::failure& e) {
    ban = 0;
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x20(%rsp), %rdi
movq %r9, %rdx
callq 0x4d60
leaq 0x20(%rsp), %rdi
callq 0x4e6e
movl %eax, %ebp
xorl %eax, %eax
testb %bpl, %bpl
jne 0x4c95
movl 0xb8(%rsp), %eax
movl %eax, (%rbx)
movl 0x80(%rsp), %eax
movl %eax, (%r12)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x7106
movq %rsp, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x34a0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4ce2
callq 0x33d0
leaq 0x98(%rsp), %rax
movl 0x10(%rax), %ecx
movl %ecx, (%r14)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cfe
callq 0x33d0
leaq 0x50(%rsp), %rdi
callq 0x50bc
leaq 0x28(%rsp), %rdi
callq 0x50bc
movl %ebp, %eax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d26
movq %rdx, %r15
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5084
jmp 0x4d3e
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x4d5b
callq 0x31a0
movl $0x0, (%rbx)
callq 0x3600
xorl %ebp, %ebp
jmp 0x4d12
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::CNode(CService const&, std::vector<CAddress, std::allocator<CAddress>>*)
CNode(const CService& ip, vector<CAddress>* vAddrIn) : you(ip), nHeaderStart(-1), nMessageStart(-1), vAddr(vAddrIn), ban(0), doneAfter(0), nVersion(0) {
    vSend.SetType(SER_NETWORK);
    vSend.SetVersion(0);
    vRecv.SetType(SER_NETWORK);
    vRecv.SetVersion(0);
    if (time(NULL) > 1329696000) {
      vSend.SetVersion(209);
      vRecv.SetVersion(209);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x8(%rdi)
movl $0x11500, %eax          # imm = 0x11500
movl %eax, 0x2c(%rdi)
movabsq $0x100050000, %rcx      # imm = 0x100050000
movq %rcx, 0x24(%rdi)
leaq 0x30(%rdi), %r15
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x3c(%rdi)
movl %eax, 0x54(%rdi)
movq %rcx, 0x4c(%rdi)
movq $-0x1, 0x58(%rdi)
xorl %eax, %eax
movl %eax, 0x60(%rdi)
leaq 0x78(%rdi), %r13
movq %r13, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movb $0x0, 0x78(%rdi)
movq %rdx, 0x90(%rdi)
movl %eax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
addq $0xa8, %rdi
movzwl 0x10(%rsi), %eax
movw %ax, 0x30(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, 0x20(%rsp)
movzwl 0x30(%rsp), %eax
movw %ax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %r12d
movl $0x1, %esi
callq 0xacd6
movq %r12, 0x28(%rbx)
movq %r12, 0x50(%rbx)
xorl %edi, %edi
callq 0x33c0
cmpq $0x4f418d01, %rax       # imm = 0x4F418D01
jl 0x4e36
movl $0xd1, %eax
movl %eax, 0x2c(%rbx)
movl %eax, 0x54(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq 0x68(%rbx), %rdi
cmpq %r13, %rdi
je 0x4e55
callq 0x33d0
movq %r15, %rdi
callq 0x50bc
movq %r14, %rdi
callq 0x50bc
movq %r12, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./serialize.h
// Function: secure_allocator<char>::deallocate(char*, unsigned long)
void deallocate(T* p, std::size_t n)
    {
        if (p != NULL)
        {
            memset(p, 0, sizeof(T) * n);
            munlock(p, sizeof(T) * n);
        }
        std::allocator<T>::deallocate(p, n);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5145
movq %rdx, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3220
movl $0x1e, %edi
callq 0x32a0
movq %rax, %r15
negq %r15
andq %rbx, %r15
leaq (%r14,%rbx), %r12
decq %r12
movl $0x1e, %edi
callq 0x32a0
leaq -0x1(%rax), %r14
orq %r12, %r14
movl $0x1e, %edi
callq 0x32a0
negq %rax
andq %rbx, %rax
subq %rax, %r14
incq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x36b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x33c0
movq %rax, %r15
leaq 0xde96(%rip), %rsi      # 0x13014
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x9d9c
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xacd6
leaq 0xde67(%rip), %rsi      # 0x1301c
movq %rbx, %rdi
callq 0x56e6
leaq 0x172bc(%rip), %rax     # 0x1c480
cmpb $0x0, (%rax)
movl $0x3a98, %ebp           # imm = 0x3A98
cmovnel %r12d, %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xde43(%rip), %rsi      # 0x13024
leaq 0xde4f(%rip), %rdx      # 0x13037
leaq 0x20(%rsp), %rdi
callq 0x5b6c
leaq 0x8(%rbx), %r14
leaq 0x1c(%rsp), %rcx
movl $0x11500, -0x4(%rcx)    # imm = 0x11500
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x591e
leaq 0x20(%rsp), %rcx
movq $0x0, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x591e
leaq 0x20(%rsp), %rcx
movq %r15, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x591e
leaq 0xa8(%rbx), %rdi
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r14, %rsi
callq 0x5bfc
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x5bfc
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
leaq 0x20(%rsp), %rcx
movq %rax, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x591e
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x5cd7
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x52bb
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x58de
leaq 0x1c(%rsp), %rcx
movl %ebp, -0x4(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x591e
movq %rbx, %rdi
callq 0x5752
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x52eb
callq 0x33d0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x530d
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5371
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rdx, %rcx
subq %rsi, %rcx
movl 0x20(%rbx), %eax
cmpq %rax, %rcx
je 0x5371
addq %rax, %rsi
subq %rsi, %rdx
xorl %ecx, %ecx
callq 0x31e0
testl %eax, %eax
jle 0x5364
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 0x5d76
movl (%rbx), %edi
callq 0x36e0
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5705
movq %rbx, %rdi
callq 0x5826
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 0xab86
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5860
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_O1/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 %r14
pushq %rbx
subq $0x48, %rsp
movl 0x58(%rdi), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x57fe
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 0x57f6
movl 0x20(%rbx), %eax
addq 0x8(%rbx), %rax
movl 0x5c(%rbx), %ecx
addq %rax, %rcx
movq 0x10(%rbx), %rsi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
subq %rcx, %rsi
leaq 0x16c1c(%rip), %rdi     # 0x1c3d1
cmovneq %rcx, %rdi
movq %r14, %rdx
callq 0x34d0
movq %rsp, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0x20, %esi
movq %r14, %rdi
callq 0x34d0
movl 0x58(%rbx), %eax
movl 0x5c(%rbx), %ecx
subl %eax, %ecx
cmpl $0x17, %ecx
jbe 0x5806
movl (%rsp), %ecx
movl 0x20(%rbx), %edx
addq 0x8(%rbx), %rdx
movl %ecx, 0x14(%rax,%rdx)
movq $-0x1, 0x58(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0xd8b9(%rip), %rdi      # 0x130c6
leaq 0xd90a(%rip), %rsi      # 0x1311e
leaq 0xd90f(%rip), %rcx      # 0x1312a
movl $0x39, %edx
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::AbortMessage()
void AbortMessage() {
    if (nHeaderStart == -1) return;
    vSend.resize(nHeaderStart);
    nHeaderStart = -1;
    nMessageStart = -1;
  }

// Assembly:
movl 0x58(%rdi), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x585f
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
movl 0x20(%rbx), %esi
addq %rax, %rsi
callq 0x5e12
movq $-0x1, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58ff
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movl %edx, %ecx
addq %rax, %rcx
movq %rax, %rdx
callq 0x591e
movq %rbx, %rax
popq %rbx
retq
leaq 0xd732(%rip), %rdi      # 0x13038
leaq 0xd736(%rip), %rsi      # 0x13043
leaq 0xd73d(%rip), %rcx      # 0x13051
movl $0x43e, %edx            # imm = 0x43E
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5d01
leaq 0x11(%rsp), %rcx
movb %sil, -0x1(%rcx)
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
jmp 0x5d69
cmpq $0xffff, %rsi           # imm = 0xFFFF
ja 0x5d1f
leaq 0x10(%rsp), %rcx
movb $-0x3, -0x1(%rcx)
leaq 0x12(%rsp), %r14
movw %si, -0x2(%r14)
jmp 0x5d49
movq %rsi, %rax
leaq 0x10(%rsp), %rcx
shrq $0x20, %rax
jne 0x5d3c
movb $-0x2, -0x1(%rcx)
leaq 0x14(%rsp), %r14
movl %esi, -0x4(%r14)
jmp 0x5d49
movb $-0x1, -0x1(%rcx)
leaq 0x18(%rsp), %r14
movq %rsi, -0x8(%r14)
movq 0x8(%rbx), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x591e
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x591e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movl 0x18(%rdi), %eax
addq %rbx, %rax
cmpq %rsi, %rax
je 0x5dc9
movq %rsi, %r12
movq %rsi, %rbx
cmpq %r15, %rsi
je 0x5dde
movq 0x8(%r14), %rdx
subq %r15, %rdx
je 0x5db1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35f0
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %r15, %rcx
addq %rcx, %r12
cmpq %r12, %rax
je 0x5dde
movq %r12, 0x8(%r14)
jmp 0x5dde
movq 0x8(%r14), %rax
cmpq %r15, %rax
je 0x5ded
movl %r15d, %eax
subl %ebx, %eax
movl %eax, 0x18(%r14)
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x0, 0x18(%r14)
cmpq %rax, %rbx
je 0x5dde
movq 0x8(%r14), %rdx
movq %rdx, %rcx
subq %rax, %rcx
addq %rbx, %rcx
cmpq %rcx, %rdx
je 0x5dde
movq %rcx, 0x8(%r14)
jmp 0x5dde
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6084
movq %rcx, %r8
subq %rdx, %r8
cmpq %r9, %r8
jle 0x608c
movq %rax, %rdi
jmp 0x680a
subl %r8d, %r9d
movl %r9d, 0x18(%rax)
addq %r9, %rdi
movq %rdx, %rsi
movq %r8, %rdx
jmp 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x613b
movq %rdi, %rbx
addl 0x18(%rdi), %esi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
cmpq %rsi, %rax
jbe 0x610c
movl %esi, 0x18(%rbx)
jmp 0x6136
jae 0x6122
leaq 0xd0ea(%rip), %rdx      # 0x131ff
movq %rbx, %rdi
movl $0x4, %esi
callq 0x678a
movl $0x0, 0x18(%rbx)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x6136
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xcef6(%rip), %rdi      # 0x13038
leaq 0xcefa(%rip), %rsi      # 0x13043
leaq 0xd089(%rip), %rcx      # 0x131d9
movl $0x42a, %edx            # imm = 0x42A
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x676b
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 0x6709
addq %rax, %rsi
movl %r15d, %edx
movq %r14, %rdi
callq 0x3350
movl %r12d, 0x18(%rbx)
jmp 0x675c
jae 0x6737
leaq 0xcaa5(%rip), %rdx      # 0x131b7
movq %rbx, %rdi
movl $0x4, %esi
callq 0x678a
movl %r15d, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3220
movl 0x8(%rbx), %r15d
subl (%rbx), %r15d
subl 0x18(%rbx), %r15d
movl 0x18(%rbx), %esi
addq (%rbx), %rsi
movslq %r15d, %rdx
movq %r14, %rdi
callq 0x3350
movl $0x0, 0x18(%rbx)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x675c
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xc8c6(%rip), %rdi      # 0x13038
leaq 0xc8ca(%rip), %rsi      # 0x13043
leaq 0xca0b(%rip), %rcx      # 0x1318b
movl $0x413, %edx            # imm = 0x413
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6a98
leaq 0xc7eb(%rip), %rsi      # 0x1324d
movq %rbx, %rdi
callq 0x56e6
movq %rbx, %rdi
callq 0x5752
xorl %edi, %edi
callq 0x33c0
movq %rax, %r14
leaq 0xa8(%rbx), %rdi
callq 0x93ea
leaq 0x1e(%r14), %rcx
addq $0x78, %r14
testb %al, %al
cmoveq %rcx, %r14
jmp 0x6aa5
xorl %edi, %edi
callq 0x33c0
movq %rax, %r14
incq %r14
movq %r14, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6bca
movq %rax, %r15
movl %r15d, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3110
testl %r15d, %r15d
je 0x6bc4
movq (%r14), %rsi
movq %rbx, %rdi
movl %r15d, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x66c6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %r14
movq %r14, %rsi
movl $0x1, %edx
callq 0x66c6
movzbl (%r14), %eax
cmpq $0xfc, %rax
jbe 0x6c39
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
cmpq $0xfe, %rax
je 0x6c1d
cmpl $0xfd, %eax
jne 0x6c2c
movl $0x2, %edx
callq 0x66c6
movzwl (%r14), %eax
jmp 0x6c39
movl $0x4, %edx
callq 0x66c6
movl (%r14), %eax
jmp 0x6c39
movl $0x8, %edx
callq 0x66c6
movq (%r14), %rax
cmpq $0x2000001, %rax        # imm = 0x2000001
jae 0x6c4a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x31d0
movq %rax, %rbx
callq 0x33a0
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x1, %bpl
leaq 0xc5b5(%rip), %rsi      # 0x1322a
movq %rbx, %rdi
callq 0x3160
xorl %ebp, %ebp
movq 0x15302(%rip), %rsi     # 0x1bf88
movq 0x1532b(%rip), %rdx     # 0x1bfb8
movq %rbx, %rdi
callq 0x3640
movq %rax, %r14
testb %bpl, %bpl
je 0x6ca5
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x6ccf
movq %rax, 0x8(%r14)
movq %rdi, 0x10(%rsp)
callq 0x6bca
movq %rax, %r15
testl %r15d, %r15d
je 0x6d8c
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r15, 0x8(%rsp)
movl %ebp, 0x4(%rsp)
movl %r12d, %eax
addl $0x1e848, %eax          # imm = 0x1E848
cmpl %r15d, %eax
movl %r15d, %r12d
movl %eax, (%rsp)
cmovbl %eax, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x6d9c
cmpl %r12d, %r13d
jae 0x6d82
movl %r13d, %r13d
movq %r12, 0x18(%rsp)
movl %r12d, %eax
leaq (,%r13,8), %rcx
leaq (%rcx,%rcx,4), %r12
movl %ebx, %ebp
movq %r13, 0x20(%rsp)
movq %r13, %rbx
subq %rax, %rbx
xorl %r13d, %r13d
movq %r14, %r15
movq 0x10(%rsp), %r14
movq (%r15), %rdi
addq %r12, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movl %ebp, %ecx
callq 0x6ab4
addq $0x28, %r12
decq %r13
cmpq %r13, %rbx
jne 0x6d48
movq 0x20(%rsp), %rax
subl %r13d, %eax
movq %rax, %r13
movl %ebp, %ebx
movq %r15, %r14
movq 0x8(%rsp), %r15
movq 0x18(%rsp), %r12
cmpl %r15d, (%rsp)
jb 0x6cf4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3700
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq %rax, %rcx
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq %r14, %rsi
callq 0xa79d
movq %rsp, %rdi
callq 0x3550
leaq 0xcf21(%rip), %rsi      # 0x140fb
movq %rbx, %rdi
callq 0x30e0
testl %eax, %eax
je 0x7229
leaq 0xcf18(%rip), %rsi      # 0x14105
movq %rbx, %rdi
callq 0x30e0
testl %eax, %eax
je 0x7230
leaq 0xc160(%rip), %rsi      # 0x13360
movq %rbx, %rdi
callq 0x30e0
testl %eax, %eax
je 0x7237
leaq 0xc1e3(%rip), %rsi      # 0x133f6
movq %rbx, %rdi
callq 0x30e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
shll $0x2, %eax
jmp 0x723c
movl $0x1, %eax
jmp 0x723c
movl $0x2, %eax
jmp 0x723c
movl $0x3, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3550
movq %rbx, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/netbase.cpp
// Function: SplitHostPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
    size_t colon = in.find_last_of(':');
    // if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
    bool fHaveColon = colon != in.npos;
    bool fBracketed = fHaveColon && (in[0]=='[' && in[colon-1]==']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
    bool fMultiColon = fHaveColon && (in.find_last_of(':',colon-1) != in.npos);
    if (fHaveColon && (colon==0 || fBracketed || !fMultiColon)) {
        char *endp = NULL;
        int n = strtol(in.c_str() + colon + 1, &endp, 10);
        if (endp && *endp == 0 && n >= 0) {
            in = in.substr(0, colon);
            if (n > 0 && n < 0x10000)
                portOut = n;
        }
    }
    if (in.size()>0 && in[0] == '[' && in[in.size()-1] == ']')
        hostOut = in.substr(1, in.size()-2);
    else
        hostOut = in;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x3a, %esi
movq $-0x1, %rdx
callq 0x36f0
movq %rax, %r12
cmpq $-0x1, %rax
je 0x729c
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x729c
cmpb $0x5d, -0x1(%rax,%r12)
sete %bpl
jmp 0x729e
xorl %ebp, %ebp
cmpq $-0x1, %r12
je 0x72bf
leaq -0x1(%r12), %rdx
movq %r14, %rdi
movl $0x3a, %esi
callq 0x36f0
cmpq $-0x1, %rax
sete %al
jmp 0x72c1
movb $0x1, %al
cmpq $-0x1, %r12
je 0x7356
testq %r12, %r12
sete %cl
orb %al, %bpl
orb %cl, %bpl
testb $0x1, %bpl
je 0x7356
leaq 0x20(%rsp), %rbp
movq $0x0, (%rbp)
movq (%r14), %rax
leaq (%rax,%r12), %rdi
incq %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x3540
movq %rax, %r13
movq (%rbp), %rax
testq %rax, %rax
je 0x7356
cmpb $0x0, (%rax)
jne 0x7356
testl %r13d, %r13d
js 0x7356
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x3410
movq %r14, %rdi
movq %rbp, %rsi
callq 0x34a0
movq (%rbp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7348
callq 0x33d0
leal -0x1(%r13), %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
ja 0x7356
movl %r13d, (%r15)
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x73a4
movq (%r14), %rax
cmpb $0x5b, (%rax)
jne 0x73a4
cmpb $0x5d, -0x1(%rax,%rcx)
jne 0x73a4
addq $-0x2, %rcx
movq %rsp, %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3410
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34a0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x73af
callq 0x33d0
jmp 0x73af
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x73f8
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0xff, %rcx
je 0x73fb
movb (%rdi,%rax), %dl
movb %dl, (%rsp,%rax)
leaq 0x1(%rax), %rcx
testb %dl, %dl
jne 0x73d9
addq %rsp, %rcx
jmp 0x73ff
xorl %eax, %eax
retq
leaq (%rsp,%rax), %rcx
cmpq $0xff, %rax
jne 0x740a
movb $0x0, (%rcx)
cmpb $0x5b, (%rsp)
jne 0x742f
movq %rsp, %r15
movq %r15, %rdi
callq 0x31c0
cmpb $0x5d, -0x1(%rax,%r15)
jne 0x7432
leaq 0x1(%rsp), %r15
movb $0x0, -0x1(%rsp,%rax)
jmp 0x7432
movq %rsp, %r15
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7451
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/netbase.cpp
// Function: Lookup(char const*, std::vector<CService, std::allocator<CService>>&, int, bool, unsigned int)
bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portDefault, bool fAllowLookup, unsigned int nMaxSolutions)
{
    if (pszName[0] == 0)
        return false;
    int port = portDefault;
    std::string hostname = "";
    SplitHostPort(std::string(pszName), port, hostname);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpb $0x0, (%rdi)
je 0x77d3
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, 0xc(%rsp)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc06f(%rip), %rdx      # 0x13745
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x5b6c
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rdi
callq 0x31c0
leaq (%rax,%r15), %rdx
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x5b6c
leaq 0x48(%rsp), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x7257
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x7728
callq 0x33d0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x28(%rsp), %rdi
movzbl %r14b, %ecx
movl %ebp, %edx
callq 0x7451
movl %eax, %ebp
testb %al, %al
je 0x77b3
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0xa506
movq 0x10(%rsp), %rcx
cmpq %rcx, 0x18(%rsp)
je 0x77b3
movzwl 0xc(%rsp), %eax
movl $0x1, %edx
xorl %esi, %esi
movq (%rbx), %rdi
leaq (%rsi,%rsi,8), %r8
shlq $0x4, %rsi
movups (%rcx,%rsi), %xmm0
movups %xmm0, (%rdi,%r8,2)
movw %ax, 0x10(%rdi,%r8,2)
movl %edx, %esi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdi
subq %rcx, %rdi
sarq $0x4, %rdi
incl %edx
cmpq %rsi, %rdi
ja 0x777f
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x77c2
callq 0x33d0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x77d5
callq 0x33d0
jmp 0x77d5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
jne 0x7807
jmp 0x780c
movq %rax, %rbx
jmp 0x780c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x780c
callq 0x33d0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x781b
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/netbase.cpp
// Function: Lookup(char const*, CService&, int, bool)
bool Lookup(const char *pszName, CService& addr, int portDefault, bool fAllowLookup)
{
    std::vector<CService> vService;
    bool fRet = Lookup(pszName, vService, portDefault, fAllowLookup, 1);
    if (!fRet)
        return false;
    addr = vService[0];
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl $0x1, %r8d
callq 0x769e
movl %eax, %ebp
testb %al, %al
je 0x7860
movq (%rsp), %rax
movzwl 0x10(%rax), %ecx
movw %cx, 0x10(%rbx)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x786e
callq 0x33d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7888
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
// File: /workspace/github_cpp_makefile_star2_O1/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 0x78ef
movl %esi, %ebx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
leal -0x4(%rbx), %eax
cmpl $0x2, %eax
jae 0x78c1
movq %r14, %rdi
callq 0x790e
testb %al, %al
jne 0x78c5
xorl %eax, %eax
jmp 0x78ea
testl %ebx, %ebx
jne 0x78bd
movl %ebp, %eax
leaq (%rax,%rax,2), %rax
leaq 0x14b0e(%rip), %rcx     # 0x1c3e0
movzwl 0x10(%r14), %edx
movw %dx, 0x10(%rcx,%rax,8)
movups (%r14), %xmm0
movups %xmm0, (%rcx,%rax,8)
movl %ebx, 0x14(%rcx,%rax,8)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xba6e(%rip), %rdi      # 0x13364
leaq 0xba81(%rip), %rsi      # 0x1337e
leaq 0xba86(%rip), %rcx      # 0x1338a
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
xorq (%rdi), %rax
movzbl 0x8(%rdi), %ecx
xorq $0xff, %rcx
orq %rax, %rcx
je 0x795f
pxor %xmm0, %xmm0
movdqa %xmm0, -0x18(%rsp)
movdqu (%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x795f
cmpb $0x20, (%rdi)
jne 0x7962
cmpb $0x1, 0x1(%rdi)
jne 0x7962
cmpb $0xd, 0x2(%rdi)
jne 0x7962
cmpb $-0x48, 0x3(%rdi)
jne 0x7962
xorl %eax, %eax
retq
movl 0x8(%rdi), %eax
movl $0xffff0000, %ecx       # imm = 0xFFFF0000
xorq %rax, %rcx
orq (%rdi), %rcx
je 0x7975
movb $0x1, %al
retq
movl $0xffffffff, -0x1c(%rsp) # imm = 0xFFFFFFFF
cmpl $-0x1, 0xc(%rdi)
je 0x795f
movl $0x0, -0x1c(%rsp)
cmpl $0x0, 0xc(%rdi)
jne 0x7972
jmp 0x795f
// File: /workspace/github_cpp_makefile_star2_O1/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 0x79c5
movl %edi, %eax
leaq (%rax,%rax,2), %rcx
leaq 0x14a3b(%rip), %rdx     # 0x1c3e0
movl 0x14(%rdx,%rcx,8), %eax
testl %eax, %eax
je 0x79bf
leaq (%rdx,%rcx,8), %rcx
movzwl 0x10(%rcx), %edx
movw %dx, 0x10(%rsi)
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
testl %eax, %eax
setne %al
retq
pushq %rax
leaq 0xb997(%rip), %rdi      # 0x13364
leaq 0xb9aa(%rip), %rsi      # 0x1337e
leaq 0xb9da(%rip), %rcx      # 0x133b5
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a05
cmpl $0x5, %ebx
jne 0x7a26
movq %r14, %rdi
callq 0x790e
testb %al, %al
je 0x7a26
movzwl 0x10(%r14), %eax
movw %ax, 0x14a57(%rip)      # 0x1c468
movups (%r14), %xmm0
movups %xmm0, 0x14a3c(%rip)    # 0x1c458
movl %ebx, 0x14a4a(%rip)     # 0x1c46c
movb $0x1, %al
jmp 0x7a28
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/netbase.cpp
// Function: IsProxy(CNetAddr const&)
bool IsProxy(const CNetAddr &addr) {
    for (int i=0; i<NET_MAX; i++) {
        if (proxyInfo[i].second && (addr == (CNetAddr)proxyInfo[i].first))
            return true;
    }
    return false;
}

// Assembly:
movb $0x1, %al
leaq 0x1499c(%rip), %rcx     # 0x1c3e0
xorl %edx, %edx
cmpl $0x0, 0x14(%rcx)
je 0x7a6a
movdqu (%rcx), %xmm0
movdqa %xmm0, -0x18(%rsp)
movdqu (%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x7a82
cmpq $0x4, %rdx
leaq 0x1(%rdx), %rsi
setb %al
addq $0x18, %rcx
movq %rsi, %rdx
cmpq $0x5, %rsi
jne 0x7a46
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9596
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x7f8d
movl 0x8(%rbx), %eax
movl $0xffff0000, %ecx       # imm = 0xFFFF0000
xorq %rax, %rcx
orq (%rbx), %rcx
je 0x7f81
movl $0x7ed887fd, %eax       # imm = 0x7ED887FD
xorl (%rbx), %eax
movzwl 0x4(%rbx), %ecx
xorl $0x43eb, %ecx           # imm = 0x43EB
orl %eax, %ecx
je 0x7f88
movl $0x4ddb60fd, %eax       # imm = 0x4DDB60FD
xorl (%rbx), %eax
movzwl 0x4(%rbx), %ecx
xorl $0xb5dd, %ecx           # imm = 0xB5DD
xorl %edx, %edx
orl %eax, %ecx
sete %dl
leal 0x2(,%rdx,2), %eax
jmp 0x7f8d
movl $0x1, %eax
jmp 0x7f8d
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/netbase.cpp
// Function: CNetAddr::CNetAddr(char const*, bool)
CNetAddr::CNetAddr(const char *pszIp, bool fAllowLookup)
{
    Init();
    std::vector<CNetAddr> vIP;
    if (LookupHost(pszIp, vIP, 1, fAllowLookup))
        *this = vIP[0];
}

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

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

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

// Assembly:
movzwl (%rsi), %eax
cmpl $0xa, %eax
je 0x9d83
cmpl $0x2, %eax
jne 0x9d99
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movl 0x4(%rsi), %ecx
movl $0xffff0000, 0x8(%rdi)  # imm = 0xFFFF0000
movq $0x0, (%rdi)
movl %ecx, 0xc(%rdi)
jmp 0x9d92
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movups 0x8(%rsi), %xmm0
movups %xmm0, (%rdi)
movw %ax, 0x10(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq