LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/netbase.cpp
// Function: CService::CService(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CService::CService(const std::string &strIpPort, bool fAllowLookup)
{
    Init();
    CService ip;
    if (Lookup(strIpPort.c_str(), ip, 0, fAllowLookup))
        *this = ip;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edx, %edx
movw %dx, 0x10(%rdi)
movq %rsp, %rax
movw %dx, 0x10(%rax)
movaps %xmm0, (%rax)
movq (%rsi), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7823
testb %al, %al
je 0x9e69
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_O1/tenup-coin[P]seeder/netbase.cpp
// Function: CService::CService(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, bool)
CService::CService(const std::string &strIpPort, int portDefault, bool fAllowLookup)
{
    Init();
    CService ip;
    if (Lookup(strIpPort.c_str(), ip, portDefault, fAllowLookup))
        *this = ip;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edi, %edi
movw %di, 0x10(%rbx)
movq %rsp, %rax
movw %di, 0x10(%rax)
movaps %xmm0, (%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x7823
testb %al, %al
je 0x9ead
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_O1/tenup-coin[P]seeder/netbase.cpp
// Function: CService::GetKey() const
std::vector<unsigned char> CService::GetKey() const
{
     std::vector<unsigned char> vKey;
     vKey.resize(18);
     memcpy(&vKey[0], ip, 16);
     vKey[16] = port / 0x100;
     vKey[17] = port & 0x0FF;
     return vKey;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x12, %esi
callq 0xa562
movq (%rbx), %rax
movups (%r14), %xmm0
movups %xmm0, (%rax)
movb 0x11(%r14), %al
movq (%rbx), %rcx
movb %al, 0x10(%rcx)
movb 0x10(%r14), %al
movq (%rbx), %rcx
movb %al, 0x11(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9ff1
callq 0x33d0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::CMessageHeader()
CMessageHeader::CMessageHeader()
{
    memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
    memset(pchCommand, 0, sizeof(pchCommand));
    pchCommand[1] = 1;
    nMessageSize = -1;
    nChecksum = 0;
}

// Assembly:
movl 0x1184e(%rip), %eax     # 0x1c3b4
movl %eax, (%rdi)
movq $0x0, 0x4(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x5(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::CMessageHeader(char const*, unsigned int)
CMessageHeader::CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn)
{
    memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
    strncpy(pchCommand, pszCommand, COMMAND_SIZE);
    nMessageSize = nMessageSizeIn;
    nChecksum = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl 0x1181f(%rip), %eax     # 0x1c3b4
movl %eax, (%rdi)
addq $0x4, %rdi
movl $0xc, %edx
callq 0x31f0
movl %ebx, 0x10(%r14)
movl $0x0, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::GetCommand[abi:cxx11]() const
std::string CMessageHeader::GetCommand() const
{
    if (pchCommand[COMMAND_SIZE-1] == 0)
        return std::string(pchCommand, pchCommand + strlen(pchCommand));
    else
        return std::string(pchCommand, pchCommand + COMMAND_SIZE);
}

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

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

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

    return true;
}

// Assembly:
movl (%rdi), %eax
cmpl 0x117ac(%rip), %eax     # 0x1c3b4
jne 0xac58
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x4, %eax
xorl %ecx, %ecx
movb (%rbx,%rax), %dl
testb %dl, %dl
je 0xac2c
addb $-0x7f, %dl
cmpb $-0x5f, %dl
jae 0xac46
jmp 0xac5b
cmpq $0xf, %rax
jg 0xac46
cmpb $0x0, (%rbx,%rax)
jne 0xac5b
incq %rax
cmpq $0x10, %rax
jne 0xac32
movl $0x10, %eax
leaq 0x1(%rax), %rdx
cmpq $0xf, %rax
setge %cl
movq %rdx, %rax
jl 0xac1b
jmp 0xac60
xorl %eax, %eax
retq
testb $0x1, %cl
je 0xaca1
movb $0x1, %al
cmpl $0x2000001, 0x10(%rbx)  # imm = 0x2000001
jb 0xaca3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xabba
movq (%r14), %rsi
movl 0x10(%rbx), %edx
leaq 0x8c3d(%rip), %rdi      # 0x138c5
xorl %eax, %eax
callq 0x3050
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xaca1
callq 0x33d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/protocol.cpp
// Function: CInv::CInv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, uint256 const&)
CInv::CInv(const std::string& strType, const uint256& hashIn)
{
    int i;
    for (i = 1; i < ARRAYLEN(ppszTypeName); i++)
    {
        if (strType == ppszTypeName[i])
        {
            type = i;
            break;
        }
    }
    if (i == ARRAYLEN(ppszTypeName))
        throw std::out_of_range("CInv::CInv(string, uint256) : unknown type");
    hash = hashIn;
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0xb218
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb3a3
leaq 0xf0(%rbx), %r13
leaq 0x4(%rsp), %rsi
movq %r13, %rdi
callq 0xc9b2
movq %r13, %rdi
movq %rax, %rsi
callq 0xca2a
leaq 0x158(%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xcaca
movq %r13, %rdi
movq %rax, %rsi
callq 0xcb86
leaq 0x40(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xbc36
movq %rax, %r12
movl %r15d, 0x7c(%rax)
leaq 0x90(%rax), %rdi
movq %r14, %rsi
callq 0x3210
movl %ebp, 0x80(%r12)
movq %r12, %rdi
movl $0x1, %esi
callq 0xaf2c
movq %r12, %rdi
callq 0xbd76
testb %al, %al
je 0xb35f
movq 0x130(%rbx), %rdx
leaq 0x128(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0xb333
movl 0x4(%rsp), %esi
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0xb31c
movq %rax, %rdx
cmpq %rax, %rcx
je 0xb349
movl 0x4(%rsp), %edx
cmpl 0x20(%rcx), %edx
cmovlq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
jne 0xb35f
leaq 0x120(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xc802
incl 0x150(%rbx)
movq 0xd0(%rbx), %rax
movq 0xe0(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0xb38f
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xd0(%rbx)
jmp 0xb3a3
addq $0xa0, %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xc5d2
addq $0x8, %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/db.cpp
// Function: CAddrDb::Bad_(CService const&, int)
void CAddrDb::Bad_(const CService &addr, int ban)
{
  int id = Lookup_(addr);
  if (id == -1) return;
  unkId.erase(id);
  CAddrInfo &info = idToInfo[id];
  info.Update(false);
  uint32_t now = time(NULL);
  int ter = info.GetBanTime();
  if (ter) {
    //printf("%s: terrible\n", ToString(addr).c_str());
    if (ban < ter) ban = ter;
  }
  if (ban > 0) {
    //printf("%s: ban for %i seconds\n", ToString(addr).c_str(), ban);
    banned[info.ip] = ban + now;
    ipToId.erase(info.ip);
    goodId.erase(id);
    idToInfo.erase(id);
  } else {
    if (/*!info.IsGood() && */ goodId.count(id)==1) {
      goodId.erase(id);
      //printf("%s: not good; %i good nodes left\n", ToString(addr).c_str(), (int)goodId.size());
    }
    ourId.push_back(id);
  }
  nDirty++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0xb218
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xb553
leaq 0xf0(%rbx), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc9b2
movq %r14, %rdi
movq %rax, %rsi
callq 0xca2a
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xbc36
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0xaf2c
xorl %edi, %edi
callq 0x33c0
movq %rax, %r12
movq %r15, %rdi
callq 0xbeb4
cmpl %ebp, %eax
movl %ebp, %r13d
cmovgl %eax, %r13d
testl %eax, %eax
cmovel %ebp, %r13d
testl %r13d, %r13d
jle 0xb4a4
addl %r12d, %r13d
leaq 0x158(%rbx), %rdi
movq %r15, %rsi
callq 0xbf92
movq %r13, (%rax)
leaq 0x70(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xceda
movq %r12, %rdi
movq %rax, %rsi
callq 0xcf96
leaq 0x120(%rbx), %r15
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xc9b2
movq %r15, %rdi
movq %rax, %rsi
callq 0xca2a
movq %r14, %rdi
movq %r12, %rsi
callq 0xd06c
movq %r14, %rdi
movq %rax, %rsi
callq 0xd0e4
jmp 0xb54d
movq 0x130(%rbx), %rdx
leaq 0x128(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0xb4d8
movl 0x4(%rsp), %esi
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0xb4c1
movq %rax, %rdx
cmpq %rax, %rcx
je 0xb4ee
movl 0x4(%rsp), %edx
cmpl 0x20(%rcx), %edx
cmovlq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0xb512
leaq 0x120(%rbx), %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xc9b2
movq %r14, %rdi
movq %rax, %rsi
callq 0xca2a
movq 0xd0(%rbx), %rax
movq 0xe0(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0xb53c
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xd0(%rbx)
jmp 0xb54d
leaq 0xa0(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xc5d2
incl 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Skipped_(CService const&)
void CAddrDb::Skipped_(const CService &addr)
{
  int id = Lookup_(addr);
  if (id == -1) return;
  unkId.erase(id);
  ourId.push_back(id);
  //printf("%s: skipped\n", ToString(addr).c_str());
  nDirty++;
}

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbd76
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xbc33
movss 0x78(%rbx), %xmm0
subss 0x70(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7e43(%rip), %xmm0     # 0x139a8
movsd 0x7e43(%rip), %xmm1     # 0x139b0
ucomisd %xmm0, %xmm1
jbe 0xbb8a
movss 0x74(%rbx), %xmm0
movl $0xd2f00, %eax          # imm = 0xD2F00
ucomiss 0x7e8c(%rip), %xmm0     # 0x13a10
ja 0xbc33
movss 0x6c(%rbx), %xmm0
subss 0x64(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7e08(%rip), %xmm0     # 0x139a8
movsd 0x7e10(%rip), %xmm1     # 0x139b8
ucomisd %xmm0, %xmm1
jbe 0xbbc1
movss 0x68(%rbx), %xmm0
movl $0x3f480, %eax          # imm = 0x3F480
ucomiss 0x7e51(%rip), %xmm0     # 0x13a10
ja 0xbc33
movss 0x60(%rbx), %xmm0
subss 0x58(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7dd1(%rip), %xmm0     # 0x139a8
movsd 0x7de1(%rip), %xmm1     # 0x139c0
ucomisd %xmm0, %xmm1
jbe 0xbbf8
movss 0x5c(%rbx), %xmm0
movl $0x7080, %eax           # imm = 0x7080
ucomiss 0x7e1a(%rip), %xmm0     # 0x13a10
ja 0xbc33
movss 0x54(%rbx), %xmm0
subss 0x4c(%rbx), %xmm0
movss 0x50(%rbx), %xmm1
cvtss2sd %xmm0, %xmm0
addsd 0x7d95(%rip), %xmm0     # 0x139a8
xorl %ecx, %ecx
ucomiss 0x7df4(%rip), %xmm1     # 0x13a10
movl $0x1c20, %eax           # imm = 0x1C20
cmovbel %ecx, %eax
movsd 0x7d9c(%rip), %xmm1     # 0x139c8
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./db.h
// Function: CAddrInfo::IsGood() const
bool IsGood() const {
    if (ip.GetPort() != GetDefaultPort()) return false;
    if (!(services & NODE_NETWORK)) return false;
    if (!ip.IsRoutable()) return false;
    if (clientVersion && clientVersion < REQUIRE_VERSION) return false;
    if (blocks && blocks < GetRequireHeight()) return false;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8e40
leaq 0x106f7(%rip), %r14     # 0x1c480
cmpb $0x0, (%r14)
movl $0x141b, %ecx           # imm = 0x141B
movl $0xc91a, %edx           # imm = 0xC91A
cmovnel %ecx, %edx
cmpw %dx, %ax
jne 0xbdc5
testb $0x1, 0x18(%rbx)
je 0xbdc5
movq %rbx, %rdi
callq 0x9596
testb %al, %al
je 0xbdc5
movl 0x7c(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl $0x11500, %eax          # imm = 0x11500
setl %al
testb %al, %cl
je 0xbdcf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x80(%rbx), %ecx
testl %ecx, %ecx
je 0xbdeb
xorl %eax, %eax
cmpb $0x0, (%r14)
movl $0x3a98, %edx           # imm = 0x3A98
cmovnel %eax, %edx
cmpl %edx, %ecx
jl 0xbdc7
movl 0x84(%rbx), %ecx
cmpl $0x3, %ecx
jg 0xbe04
movl 0x88(%rbx), %edx
addl %edx, %edx
movb $0x1, %al
cmpl %ecx, %edx
jge 0xbdc7
cvtss2sd 0x48(%rbx), %xmm0
ucomisd 0x7bbf(%rip), %xmm0     # 0x139d0
movb $0x1, %al
jbe 0xbe23
movss 0x44(%rbx), %xmm0
ucomiss 0x7bef(%rip), %xmm0     # 0x13a10
ja 0xbdc7
xorps %xmm0, %xmm0
cvtss2sd 0x54(%rbx), %xmm0
ucomisd 0x7ba5(%rip), %xmm0     # 0x139d8
jbe 0xbe43
movss 0x50(%rbx), %xmm0
ucomiss 0x7bd3(%rip), %xmm0     # 0x13a14
ja 0xbdc7
xorps %xmm0, %xmm0
cvtss2sd 0x60(%rbx), %xmm0
ucomisd 0x7b8d(%rip), %xmm0     # 0x139e0
jbe 0xbe67
movss 0x5c(%rbx), %xmm0
ucomiss 0x7bb7(%rip), %xmm0     # 0x13a18
ja 0xbdc7
xorps %xmm0, %xmm0
cvtss2sd 0x6c(%rbx), %xmm0
ucomisd 0x7b71(%rip), %xmm0     # 0x139e8
jbe 0xbe8b
movss 0x68(%rbx), %xmm0
ucomiss 0x7b97(%rip), %xmm0     # 0x13a1c
ja 0xbdc7
xorps %xmm0, %xmm0
cvtss2sd 0x78(%rbx), %xmm0
ucomisd 0x7b55(%rip), %xmm0     # 0x139f0
seta %cl
movss 0x74(%rbx), %xmm0
ucomiss 0x7b76(%rip), %xmm0     # 0x13a20
seta %al
andb %cl, %al
jmp 0xbdc7
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./db.h
// Function: CAddrInfo::GetBanTime() const
int GetBanTime() const {
    if (IsGood()) return 0;
    if (clientVersion && clientVersion < 31900) { return 604800; }
    if (stat1M.reliability - stat1M.weight + 1.0 < 0.15 && stat1M.count > 32) { return 30*86400; }
    if (stat1W.reliability - stat1W.weight + 1.0 < 0.10 && stat1W.count > 16) { return 7*86400; }
    if (stat1D.reliability - stat1D.weight + 1.0 < 0.05 && stat1D.count > 8) { return 1*86400; }
    return 0;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movb $0x1, %r12b
leaq 0x30(%rsp), %r15
leaq 0x20(%rsp), %r14
xorl %edi, %edi
callq 0x33c0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x32f0
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
leaq 0x5eb0(%rip), %rdx      # 0x13bf5
movq %rax, %rcx
callq 0x3330
leaq 0xe734(%rip), %rdi      # 0x1c488
movq %rsp, %rsi
callq 0xee6a
testb $0x1, %r12b
leaq 0x5eaa(%rip), %rdi      # 0x13c11
leaq 0x5e9b(%rip), %rax      # 0x13c09
cmovneq %rax, %rdi
movzbl %r12b, %r12d
movl $0x0, %eax
cmovnel %eax, %r12d
xorl %eax, %eax
callq 0x3050
leaq 0x5e8c(%rip), %rdi      # 0x13c19
xorl %eax, %eax
callq 0x3050
movq 0xe875(%rip), %rcx      # 0x1c610
movl $0x0, %r10d
movl $0x0, %r11d
cmpq %rcx, 0xe86a(%rip)      # 0x1c618
je 0xddea
movl $0x1, %eax
xorl %edx, %edx
xorl %r11d, %r11d
xorl %r10d, %r10d
movq (%rcx,%rdx,8), %rcx
addq 0x30(%rcx), %r10
movq 0x70(%rcx), %rcx
addq %rcx, %r11
movl %eax, %edx
movq 0xe843(%rip), %rsi      # 0x1c618
movq 0xe834(%rip), %rcx      # 0x1c610
subq %rcx, %rsi
sarq $0x3, %rsi
incl %eax
cmpq %rdx, %rsi
ja 0xddbd
movl 0x10(%rsp), %edx
movl (%rsp), %r13d
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0x14(%rsp), %r9d
movl 0xc(%rsp), %ebp
movl %ecx, %ebx
subl %r8d, %ebx
subl %ebp, %ebx
subq $0x8, %rsp
leaq 0x5e07(%rip), %rdi      # 0x13c1d
movq %r15, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r13
pushq %rbx
pushq %rbp
callq 0x3050
addq $0x30, %rsp
movq $0x1, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3100
jmp 0xdd20
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./db.h
// Function: CAddrDb::GetMany(std::vector<CServiceResult, std::allocator<CServiceResult>>&, int, int&)
void GetMany(std::vector<CServiceResult> &ips, int max, int& wait) {
    CRITICAL_BLOCK(cs) {
      while (max > 0) {
          CServiceResult ip = {};
          if (!Get_(ip, wait))
              return;
          ips.push_back(ip);
          max--;
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
callq 0x35a0
testl %ebp, %ebp
jle 0xe7bb
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %ebx, %ebx
movq %r12, %rdi
callq 0x9c98
movb %bl, 0x22(%rsp)
movq %rbx, 0x24(%rsp)
movl $0x0, 0x2c(%rsp)
movq %r15, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movb %bl, 0x40(%rsp)
movq %rbx, 0x50(%rsp)
movq (%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xb024
movl %eax, %r13d
testb %al, %al
je 0xe7a2
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xf582
decl %ebp
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0xe7b1
callq 0x33d0
testl %ebp, %ebp
setg %al
testb %al, %r13b
jne 0xe751
movq (%rsp), %rdi
callq 0x34f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe7ea
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0xe7ea
callq 0x33d0
movq (%rsp), %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./db.h
// Function: CAddrDb::ResultMany(std::vector<CServiceResult, std::allocator<CServiceResult>> const&)
void ResultMany(const std::vector<CServiceResult> &ips) {
    CRITICAL_BLOCK(cs) {
      for (int i=0; i<ips.size(); i++) {
        if (ips[i].fGood) {
          Good_(ips[i].service, ips[i].nClientV, ips[i].strClientV, ips[i].nHeight);
        } else {
          Bad_(ips[i].service, ips[i].nBanTime);
        }
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x35a0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0xe8c6
xorl %r13d, %r13d
xorl %r15d, %r15d
leaq (%rax,%r13), %r12
cmpb $0x1, 0x12(%rax,%r13)
jne 0xe88a
movl 0x1c(%rax,%r13), %ebp
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x20(%rax,%r13), %rsi
movq 0x28(%rax,%r13), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7106
movq (%r14), %rax
movl 0x18(%rax,%r13), %r8d
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
leaq 0x8(%rsp), %rcx
callq 0xb252
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe89a
callq 0x33d0
jmp 0xe89a
movl 0x14(%rax,%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb3b2
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rcx
addq $0x48, %r13
cmpq %r15, %rcx
ja 0xe828
movq %rbx, %rdi
callq 0x34f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe8f9
callq 0x33d0
jmp 0xe8f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./serialize.h
// Function: CAutoFile& CAutoFile::operator<<<CAddrDb>(CAddrDb const&)
CAutoFile& operator<<(const T& obj)
    {
        // Serialize to this stream
        if (!file)
            throw std::ios_base::failure("CAutoFile::operator<< : file handle is NULL");
        ::Serialize(*this, obj, nType, nVersion);
        return (*this);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rdi)
je 0xedb6
movq %rdi, %rbx
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %ecx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x116e8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x31d0
movq %rax, %rbx
callq 0x33a0
movq %rsp, %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x1, %bpl
leaq 0x5367(%rip), %rsi      # 0x14146
movq %rbx, %rdi
callq 0x3160
xorl %ebp, %ebp
movq 0xd198(%rip), %rsi      # 0x1bf88
movq 0xd1c1(%rip), %rdx      # 0x1bfb8
movq %rbx, %rdi
callq 0x3640
movq %rax, %r14
testb %bpl, %bpl
je 0xee0f
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./db.h
// Function: CAddrDb::GetStats(CAddrDbStats&)
void GetStats(CAddrDbStats &stats) {
    SHARED_CRITICAL_BLOCK(cs) {
      stats.nBanned = banned.size();
      stats.nAvail = idToInfo.size();
      stats.nTracked = ourId.size();
      stats.nGood = goodId.size();
      stats.nNew = unkId.size();
      stats.nAge = time(NULL) - idToInfo[ourId[0]].ourLastTry;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x33b0
movl 0x180(%rbx), %eax
movl %eax, (%r14)
leaq 0x40(%rbx), %r15
movl 0x68(%rbx), %eax
movl %eax, 0x4(%r14)
movq 0xe8(%rbx), %rax
movl 0xc8(%rbx), %ecx
movl %eax, %edx
subl %ecx, %edx
shrl $0x3, %edx
cmpq $0x1, %rax
adcl $-0x1, %edx
shll $0x7, %edx
movq 0xd0(%rbx), %rax
subq 0xd8(%rbx), %rax
movq 0xc0(%rbx), %rcx
shrq $0x2, %rax
subq 0xb0(%rbx), %rcx
shrq $0x2, %rcx
addl %eax, %ecx
addl %edx, %ecx
movl %ecx, 0x8(%r14)
movl 0x148(%rbx), %eax
movl %eax, 0x10(%r14)
movl 0x118(%rbx), %eax
movl %eax, 0xc(%r14)
xorl %edi, %edi
callq 0x33c0
movq %rax, %r12
movq 0xb0(%rbx), %rsi
movq %rsi, %rax
subq 0xb8(%rbx), %rax
sarq $0x2, %rax
cmpq $0x80, %rax
jb 0xef4d
movq %rax, %rcx
shrq $0x7, %rcx
movabsq $-0x200000000000000, %rdx # imm = 0xFE00000000000000
orq %rcx, %rdx
testq %rax, %rax
cmovgq %rcx, %rdx
movq 0xc8(%rbx), %rcx
movq %rdx, %rsi
shlq $0x7, %rsi
subq %rsi, %rax
shlq $0x2, %rax
addq (%rcx,%rdx,8), %rax
movq %rax, %rsi
movq %r15, %rdi
callq 0xbc36
subl 0x28(%rax), %r12d
movl %r12d, 0x14(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x34f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x34f0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./serialize.h
// Function: CAutoFile& CAutoFile::operator>><CAddrDb>(CAddrDb&)
CAutoFile& operator>>(T& obj)
    {
        // Unserialize from this stream
        if (!file)
            throw std::ios_base::failure("CAutoFile::operator>> : file handle is NULL");
        ::Unserialize(*this, obj, nType, nVersion);
        return (*this);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rdi)
je 0xf288
movq %rdi, %rbx
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %ecx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x11e0e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x31d0
movq %rax, %rbx
callq 0x33a0
movq %rsp, %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x1, %bpl
leaq 0x4f08(%rip), %rsi      # 0x141b9
movq %rbx, %rdi
callq 0x3160
xorl %ebp, %ebp
movq 0xccc6(%rip), %rsi      # 0x1bf88
movq 0xccef(%rip), %rdx      # 0x1bfb8
movq %rbx, %rdi
callq 0x3640
movq %rax, %r14
testb %bpl, %bpl
je 0xf2e1
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/main.cpp
// Function: CDnsThread::CDnsThread(CDnsSeedOpts*, int)
CDnsThread(CDnsSeedOpts* opts, int idIn) : id(idIn) {
    dns_opt.host = opts->host;
    dns_opt.ns = opts->ns;
    dns_opt.mbox = opts->mbox;
    dns_opt.datattl = 3600;
    dns_opt.nsttl = 40000;
    dns_opt.cb = GetIPList;
    dns_opt.port = opts->nPort;
    dns_opt.nRequests = 0;
    dbQueries = 0;
    perflag.clear();
    filterWhitelist = opts->filter_whitelist;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edx, 0x38(%rdi)
leaq 0x40(%rdi), %rbx
leaq 0x48(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
leaq 0x78(%rdi), %r15
leaq 0x80(%rdi), %rax
movl %ecx, 0x80(%rdi)
movq %rcx, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movq %rax, 0x98(%rdi)
movq %rcx, 0xa0(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x18(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x20(%rdi)
movabsq $0x9c4000000e10, %rax   # imm = 0x9C4000000E10
movq %rax, 0x4(%rdi)
leaq -0x1ca7(%rip), %rax     # 0xd6c5
movq %rax, 0x28(%rdi)
movl 0x4(%rsi), %eax
movl %eax, (%rdi)
movq %rcx, 0x30(%rdi)
xchgq %rcx, 0x70(%rdi)
movq %rbx, %rdi
callq 0x100e8
addq $0x48, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x10176
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x10436
movq %rbx, %rdi
callq 0x1044a
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./db.h
// Function: CAddrInfo::GetReport() const
CAddrReport GetReport() const {
    CAddrReport ret;
    ret.ip = ip;
    ret.clientVersion = clientVersion;
    ret.clientSubVersion = clientSubVersion;
    ret.blocks = blocks;
    ret.uptime[0] = stat2H.reliability;
    ret.uptime[1] = stat8H.reliability;
    ret.uptime[2] = stat1D.reliability;
    ret.uptime[3] = stat1W.reliability;
    ret.uptime[4] = stat1M.reliability;
    ret.lastSuccess = ourLastSuccess;
    ret.fGood = IsGood();
    ret.services = services;
    return ret;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9c98
leaq 0x48(%rbx), %r15
leaq 0x58(%rbx), %r12
movq %r12, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rbx)
movl 0x7c(%r14), %eax
movl %eax, 0x14(%rbx)
leaq 0x90(%r14), %rsi
movq %r15, %rdi
callq 0x3210
movl 0x80(%r14), %eax
movl %eax, 0x18(%rbx)
xorps %xmm0, %xmm0
cvtss2sd 0x48(%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
xorps %xmm0, %xmm0
cvtss2sd 0x54(%r14), %xmm0
movsd %xmm0, 0x28(%rbx)
xorps %xmm0, %xmm0
cvtss2sd 0x60(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
xorps %xmm0, %xmm0
cvtss2sd 0x6c(%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
xorps %xmm0, %xmm0
cvtss2sd 0x78(%r14), %xmm0
movsd %xmm0, 0x40(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x68(%rbx)
movq %r14, %rdi
callq 0xbd76
movb %al, 0x70(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x78(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xfbcb
callq 0x33d0
movq %rbx, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./serialize.h
// Function: CAutoFile::write(char const*, int)
CAutoFile& write(const char* pch, int nSize)
    {
        if (!file)
            throw std::ios_base::failure("CAutoFile::write : file handle is NULL");
        if (fwrite(pch, 1, nSize, file) != nSize)
            setstate(std::ios::failbit, "CAutoFile::write : write failed");
        return (*this);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x11924
movq %rsi, %rax
movq %rdi, %rbx
movslq %edx, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x36d0
cmpq %r14, %rax
je 0x11918
leaq 0x288e(%rip), %rdx      # 0x14199
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11986
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x31d0
movq %rax, %rbx
callq 0x33a0
movq %rsp, %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x1, %bpl
leaq 0x2825(%rip), %rsi      # 0x14172
movq %rbx, %rdi
callq 0x3160
xorl %ebp, %ebp
movq 0xa62a(%rip), %rsi      # 0x1bf88
movq 0xa653(%rip), %rdx      # 0x1bfb8
movq %rbx, %rdi
callq 0x3640
movq %rax, %r14
testb %bpl, %bpl
je 0x1197d
movq %rbx, %rdi
callq 0x32e0
movq %r14, %rdi
callq 0x3650
nop
// File: /workspace/github_cpp_makefile_star2_O1/tenup-coin[P]seeder/./serialize.h
// Function: CAutoFile::read(char*, int)
CAutoFile& read(char* pch, int nSize)
    {
        if (!file)
            throw std::ios_base::failure("CAutoFile::read : file handle is NULL");
        if (fread(pch, 1, nSize, file) != nSize)
            setstate(std::ios::failbit, feof(file) ? "CAutoFile::read : end of file" : "CAutoFile::read : fread failed");
        return (*this);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x120f5
movq %rsi, %rax
movq %rdi, %rbx
movslq %edx, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x3590
cmpq %r14, %rax
je 0x120e9
movq (%rbx), %rdi
callq 0x35d0
testl %eax, %eax
leaq 0x2158(%rip), %rax      # 0x14229
leaq 0x2133(%rip), %rdx      # 0x1420b
cmoveq %rax, %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11986
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x31d0
movq %rax, %rbx
callq 0x33a0
movq %rsp, %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x1, %bpl
leaq 0x20c7(%rip), %rsi      # 0x141e5
movq %rbx, %rdi
callq 0x3160
xorl %ebp, %ebp
movq 0x9e59(%rip), %rsi      # 0x1bf88
movq 0x9e82(%rip), %rdx      # 0x1bfb8
movq %rbx, %rdi
callq 0x3640
movq %rax, %r14
testb %bpl, %bpl
je 0x1214e
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<CAutoFile, CService, long, std::less<CService>, std::allocator<std::pair<CService const, long>>>(CAutoFile&, std::map<CService, long, std::less<CService>, std::allocator<std::pair<CService const, long>>>&, int, int)
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion)
{
    m.clear();
    unsigned int nSize = ReadCompactSize(is);
    typename std::map<K, T, Pred, A>::iterator mi = m.begin();
    for (unsigned int i = 0; i < nSize; i++)
    {
        std::pair<K, T> item;
        Unserialize(is, item, nType, nVersion);
        mi = m.insert(mi, item);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xcbf8
movq %r15, %rdi
callq 0x123e4
movq %rax, %r12
testl %r12d, %r12d
je 0x1254c
movq 0x18(%r14), %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x9c98
movq $0x0, 0x20(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl 0x4(%rsp), %ecx
callq 0x12308
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x12092
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1255c
movq %rax, %rbx
decl %r12d
jne 0x12502
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/util.cpp
// Function: vstrprintf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, __va_list_tag*)
string vstrprintf(const std::string &format, va_list ap)
{
    char buffer[50000];
    char* p = buffer;
    int limit = sizeof(buffer);
    int ret;
    loop
    {
        va_list arg_ptr;
        va_copy(arg_ptr, ap);
        ret = vsnprintf(p, limit, format.c_str(), arg_ptr);
        va_end(arg_ptr);
        if (ret >= 0 && ret < limit)
            break;
        if (p != buffer)
            delete[] p;
        limit *= 2;
        p = new char[limit];
        if (p == NULL)
            throw std::bad_alloc();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc388, %rsp           # imm = 0xC388
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, (%rsp)
leaq 0x30(%rsp), %r14
movl $0xc350, %r13d          # imm = 0xC350
movq %rsi, 0x8(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movslq %r13d, %rbx
movq (%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x10(%rsp), %rcx
callq 0x3280
movl %eax, %ebp
testl %eax, %eax
sets %al
cmpl %ebx, %ebp
setge %bl
orb %al, %bl
cmpb $0x1, %bl
jne 0x127e3
leaq 0x30(%rsp), %rax
cmpq %rax, %r14
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x127bc
movq %r14, %rdi
callq 0x34c0
leal (,%r13,2), %r12d
testl %r13d, %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r12d, %eax
movslq %eax, %rdi
callq 0x3030
movq %rax, %r14
movl %r12d, %r13d
movq 0x8(%rsp), %r12
testb %bl, %bl
jne 0x12763
movl %ebp, %edx
addq %r14, %rdx
movq (%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7106
leaq 0x30(%rsp), %rax
cmpq %rax, %r14
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x12823
movq %r14, %rdi
callq 0x34c0
movq %rbx, %rax
addq $0xc388, %rsp           # imm = 0xC388
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrok[P]evdoublebind/./src/evdoublebind.c
// Function: parse_keymap
int parse_keymap(const char * mapstr) {
    const char *c = mapstr;
    int val = 0;
    while (1) {
        switch (*c) {
            case '\0': //fallthrough
            case ',': //fallthrough
                if (KEYMAP[KEYMAP_LEN].tap_key != 0)
                    KEYMAP[KEYMAP_LEN].tap_modifier = val;
                else
                    KEYMAP[KEYMAP_LEN].tap_key = val;
                ++KEYMAP_LEN;
                val = 0;
                if (*c == '\0') {
                    return KEYMAP_LEN;
                }
                break;
            case ':': //fallthrough
                KEYMAP[KEYMAP_LEN].key = val;
                val = 0;
                break;
            case '|': //fallthrough
                KEYMAP[KEYMAP_LEN].tap_key = val;
                val = 0;
                break;
            default:
                if (*c > '9' || *c < '0') {
                    exit(1);
                }
                val = val*10 + (*c - '0');
        }
        c++;
    }
}

// Assembly:
pushq %rax
xorl %edx, %edx
movl 0x303b(%rip), %eax      # 0x4200
leaq 0x2eb4(%rip), %rcx      # 0x4080
movb (%rdi), %sil
movzbl %sil, %r8d
cmpl $0x39, %r8d
jg 0x1212
testl %r8d, %r8d
je 0x11e4
cmpl $0x2c, %r8d
jne 0x122c
movslq %eax, %rsi
leaq (%rsi,%rsi,2), %rsi
leaq (%rcx,%rsi,2), %rsi
xorl %r8d, %r8d
cmpw $0x0, 0x2(%rsi)
setne %r8b
movw %dx, 0x2(%rsi,%r8,2)
incl %eax
movl %eax, 0x2ff7(%rip)      # 0x4200
xorl %edx, %edx
cmpb $0x0, (%rdi)
jne 0x1253
jmp 0x125b
cmpl $0x3a, %r8d
je 0x1246
cmpl $0x7c, %r8d
jne 0x122c
movslq %eax, %rsi
leaq (%rsi,%rsi,2), %rsi
movw %dx, 0x2(%rcx,%rsi,2)
jmp 0x1251
leal -0x3a(%rsi), %r8d
cmpb $-0xb, %r8b
jbe 0x125d
leal (%rdx,%rdx,4), %edx
addb $-0x30, %sil
movzbl %sil, %esi
leal (%rsi,%rdx,2), %edx
jmp 0x1253
movslq %eax, %rsi
leaq (%rsi,%rsi,2), %rsi
movw %dx, (%rcx,%rsi,2)
xorl %edx, %edx
incq %rdi
jmp 0x11cc
popq %rcx
retq
movl $0x1, %edi
callq 0x10a0