LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13aca(%rip), %eax     # 0x1d3e4
movl %eax, (%rdi)
andq $0x0, 0x4(%rdi)
andl $0x0, 0xc(%rdi)
movb $0x1, 0x5(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13aa1(%rip), %eax     # 0x1d3e4
movl %eax, (%rdi)
addq $0x4, %rdi
pushq $0xc
popq %rdx
callq 0x3200
movl %ebx, 0x10(%r14)
andl $0x0, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x997c
movq %rsi, %rdx
addq $0x10, %rdx
jmp 0x998a
movq %r14, %rdi
callq 0x31b0
movq %rax, %rdx
addq %r14, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9ce8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/protocol.cpp
// Function: CMessageHeader::IsValid() const
bool CMessageHeader::IsValid() const
{
    // Check start string
    if (memcmp(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart)) != 0)
        return false;

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

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

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl (%rdi), %eax
cmpl 0x13a2c(%rip), %eax     # 0x1d3e4
jne 0x99f2
movq %rdi, %rbx
pushq $0x4
popq %rcx
pushq $0x10
popq %rax
cmpq $0xf, %rcx
jg 0x99ff
movb (%rbx,%rcx), %dl
testb %dl, %dl
je 0x99e4
addb $-0x7f, %dl
cmpb $-0x5f, %dl
jae 0x99ed
jmp 0x99f2
cmpb $0x0, (%rbx,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x99f2
cmpq $0x10, %rcx
jne 0x99da
movq %rax, %rcx
incq %rcx
jmp 0x99c3
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bpl
cmpl $0x2000001, 0x10(%rbx)  # imm = 0x2000001
jb 0x99f4
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9962
movq (%r14), %rsi
movl 0x10(%rbx), %edx
leaq 0x8e6f(%rip), %rdi      # 0x12895
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3050
movq %r14, %rdi
callq 0x31d0
jmp 0x99f4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdi, %r15
leaq 0x4(%rdi), %r14
movq %r14, %rdi
callq 0x56e8
pushq $0x1
popq %r13
leaq 0x1321b(%rip), %rbp     # 0x1cd50
cmpq $0x3, %r13
je 0x9b73
movq (%rbp,%r13,8), %rsi
movq %r12, %rdi
callq 0x62b4
testb %al, %al
jne 0x9b51
incq %r13
jmp 0x9b35
movl %r13d, (%r15)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x8d62(%rip), %rsi      # 0x128e7
movq %rax, %rdi
callq 0x3070
movq 0x13444(%rip), %rsi     # 0x1cfd8
movq 0x1342d(%rip), %rdx     # 0x1cfc8
movq %rbx, %rdi
callq 0x3680
movq %rax, %r14
movq %rbx, %rdi
callq 0x32f0
movq %r14, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./uint256.h
// Function: uint256::operator=(unsigned long long)
uint256& operator=(uint64 b)
    {
        pn[0] = (unsigned int)b;
        pn[1] = (unsigned int)(b >> 32);
        for (int i = 2; i < WIDTH; i++)
            pn[i] = 0;
        return *this;
    }

// Assembly:
movq %rdi, %rax
movq %rsi, (%rdi)
pushq $0x2
popq %rcx
cmpq $0x8, %rcx
je 0x9c88
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x9c79
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./uint256.h
// Function: operator<(base_uint<256u> const&, base_uint<256u> const&)
inline bool operator<(const base_uint& a, const base_uint& b)
    {
        for (int i = base_uint::WIDTH-1; i >= 0; i--)
        {
            if (a.pn[i] < b.pn[i])
                return true;
            else if (a.pn[i] > b.pn[i])
                return false;
        }
        return false;
    }

// Assembly:
pushq $0x7
popq %rdx
movl %edx, %eax
testl %edx, %edx
js 0x9ce0
movl %eax, %edx
movl (%rdi,%rdx,4), %ecx
movl (%rsi,%rdx,4), %r8d
cmpl %r8d, %ecx
jb 0x9cde
leal -0x1(%rax), %edx
cmpl %r8d, %ecx
jbe 0x9cbe
xorl %ecx, %ecx
jmp 0x9ce0
movb $0x1, %cl
testl %eax, %eax
setns %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x33d0
movq %rax, %r14
movq 0x28(%rbx), %rax
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
addq %r14, %rdx
testq %rax, %rax
cmovneq %rax, %rdx
movl %r14d, %ecx
movq %r14, %rax
subq %rdx, %rax
movq %rcx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
incl 0x84(%rbx)
testl %ebp, %ebp
je 0x9dce
incl 0x88(%rbx)
movq %rcx, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
movslq %eax, %r15
movzbl %bpl, %ebp
movsd 0x8b9f(%rip), %xmm0     # 0x12980
movl %ebp, %esi
movq %r15, %rdx
callq 0xa636
leaq 0x4c(%rbx), %rdi
movsd 0x8b91(%rip), %xmm0     # 0x12988
movl %ebp, %esi
movq %r15, %rdx
callq 0xa636
leaq 0x58(%rbx), %rdi
movsd 0x8b83(%rip), %xmm0     # 0x12990
movl %ebp, %esi
movq %r15, %rdx
callq 0xa636
leaq 0x64(%rbx), %rdi
movsd 0x8b75(%rip), %xmm0     # 0x12998
movl %ebp, %esi
movq %r15, %rdx
callq 0xa636
leaq 0x70(%rbx), %rdi
movsd 0x8b67(%rip), %xmm0     # 0x129a0
movl %ebp, %esi
movq %r15, %rdx
callq 0xa636
movq %rbx, %rdi
callq 0xa6a8
testl %eax, %eax
je 0x9e6d
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
sete %dl
addl %r14d, %eax
cmpq %rax, %rcx
setl %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x9e6d
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Get_(CServiceResult&, int&)
bool CAddrDb::Get_(CServiceResult &ip, int &wait) {
  int64 now = time(NULL);
  int cont = 0;
  int tot = unkId.size() + ourId.size();
  if (tot == 0) {
    wait = 5;
    return false;
  }
  do {
    int rnd = rand() % tot;
    int ret;
    if (rnd < unkId.size()) {
      set<int>::iterator it = unkId.end(); it--;
      ret = *it;
      unkId.erase(it);
    } else {
      ret = ourId.front();
      if (time(NULL) - idToInfo[ret].ourLastTry < MIN_RETRY) return false;
      ourId.pop_front();
    }
    if (idToInfo[ret].ignoreTill && idToInfo[ret].ignoreTill < now) {
      ourId.push_back(ret);
      idToInfo[ret].ourLastTry = now;
    } else {
      ip.service = idToInfo[ret].ip;
      ip.ourLastSuccess = idToInfo[ret].ourLastSuccess;
      break;
    }
  } while(1);
  nDirty++;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33d0
movq %rax, %r15
movl 0x118(%rbx), %ebp
leaq 0xa0(%rbx), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa7a4
movq %rax, %r12
addl %ebp, %r12d
je 0x9fda
movq %r13, 0x10(%rsp)
leaq 0xf0(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rbx), %r13
leaq 0xf8(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x4(%rsp), %r14
callq 0x30d0
cltd
idivl %r12d
movslq %edx, %rax
cmpq %rax, 0x118(%rbx)
jbe 0x9f17
movq 0x18(%rsp), %rdi
callq 0x3260
movl 0x20(%rax), %ecx
movl %ecx, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xb63a
jmp 0x9f54
movq 0xb0(%rbx), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
xorl %edi, %edi
callq 0x33d0
movq %rax, %rbp
movq %r13, %rdi
movq %r14, %rsi
callq 0xa7b4
subq 0x28(%rax), %rbp
cmpq $0x3e7, %rbp            # imm = 0x3E7
jle 0x9fe1
movq 0x8(%rsp), %rdi
callq 0xa802
movq %r13, %rdi
movq %r14, %rsi
callq 0xa7b4
cmpq $0x0, 0x38(%rax)
je 0x9f98
movq %r13, %rdi
movq %r14, %rsi
callq 0xa7b4
cmpq %r15, 0x38(%rax)
jge 0x9f98
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa820
movq %r13, %rdi
movq %r14, %rsi
callq 0xa7b4
movq %r15, 0x28(%rax)
jmp 0x9ee2
leaq 0x4(%rsp), %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0xa7b4
movups (%rax), %xmm0
movq 0x10(%rsp), %r15
movups %xmm0, (%r15)
movzwl 0x10(%rax), %eax
movw %ax, 0x10(%r15)
movq %r13, %rdi
movq %r14, %rsi
callq 0xa7b4
movq 0x30(%rax), %rax
movq %rax, 0x40(%r15)
incl 0x150(%rbx)
movb $0x1, %al
jmp 0x9fe3
movl $0x5, (%r14)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9ff2
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xa0f8
leaq 0xf0(%rbx), %rdi
leaq 0x4(%rsp), %r13
movq %r13, %rsi
callq 0xb72e
leaq 0x158(%rbx), %rdi
movq %r12, %rsi
callq 0xb8ac
leaq 0x40(%rbx), %rdi
movq %r13, %rsi
callq 0xa7b4
movq %rax, %r12
movl %r15d, 0x7c(%rax)
leaq 0x90(%rax), %rdi
movq %r14, %rsi
callq 0x3220
movl %ebp, 0x80(%r12)
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x9d80
movq %r12, %rdi
callq 0xa8c2
testb %al, %al
je 0xa0de
leaq 0x120(%rbx), %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xa9f4
testq %rax, %rax
jne 0xa0de
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xb4e8
incl 0x150(%rbx)
addq $0xa0, %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xa820
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/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 0x9ff2
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xa200
leaq 0xf0(%rbx), %rdi
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0xb72e
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7b4
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x9d80
xorl %edi, %edi
callq 0x33d0
movq %rax, %r12
movq %r15, %rdi
callq 0xaa0e
cmpl %ebp, %eax
movl %ebp, %r13d
cmovgl %eax, %r13d
testl %eax, %eax
cmovel %ebp, %r13d
testl %r13d, %r13d
jle 0xa1c2
addl %r12d, %r13d
leaq 0x158(%rbx), %rdi
movq %r15, %rsi
callq 0xaaec
movq %r13, (%rax)
leaq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0xbdf6
leaq 0x120(%rbx), %rdi
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0xb72e
movq %r14, %rdi
movq %r15, %rsi
callq 0xbff2
jmp 0xa1fa
leaq 0x120(%rbx), %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xa9f4
cmpq $0x1, %rax
jne 0xa1e9
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xb72e
leaq 0xa0(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xa820
incl 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/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 0x9ff2
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0xa24e
leaq 0xf0(%rbx), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0xb72e
leaq 0xa0(%rbx), %rdi
movq %r14, %rsi
callq 0xa820
incl 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/db.cpp
// Function: CAddrDb::Add_(CAddress const&, bool)
void CAddrDb::Add_(const CAddress &addr, bool force) {
  if (!force && !addr.IsRoutable())
    return;
  CService ipp(addr);
  if (banned.count(ipp)) {
    time_t bantime = banned[ipp];
    if (force || (bantime < time(NULL) && addr.nTime > bantime))
      banned.erase(ipp);
    else
      return;
  }
  if (ipToId.count(ipp)) {
    CAddrInfo &ai = idToInfo[ipToId[ipp]];
    if (addr.nTime > ai.lastTry || ai.services != addr.nServices)
    {
      ai.lastTry = addr.nTime;
      ai.services |= addr.nServices;
      //printf("%s: updated\n", ToString(addr).c_str());
    }
    if (force) {
      ai.ignoreTill = 0;
    }
    return;
  }
  CAddrInfo ai;
  ai.ip = ipp;
  ai.services = addr.nServices;
  ai.lastTry = addr.nTime;
  ai.ourLastTry = 0;
  ai.total = 0;
  ai.success = 0;
  int id = nId++;
  idToInfo[id] = ai;
  ipToId[ipp] = id;
  //printf("%s: added\n", ToString(ipp).c_str(), ipToId[ipp]);
  unkId.insert(id);
  nDirty++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jne 0xa281
movq %r14, %rdi
callq 0x857a
testb %al, %al
je 0xa3fa
movzwl 0x10(%r14), %eax
leaq 0x10(%rsp), %rsi
movw %ax, 0x10(%rsi)
movups (%r14), %xmm0
movaps %xmm0, (%rsi)
leaq 0x158(%rbx), %r15
movq %r15, %rdi
callq 0xab52
testq %rax, %rax
je 0xa2e9
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xaaec
testb %bpl, %bpl
jne 0xa2dc
movq (%rax), %r12
xorl %edi, %edi
callq 0x33d0
cmpq %rax, %r12
jge 0xa3fa
movl 0x20(%r14), %eax
cmpq %rax, %r12
jge 0xa3fa
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xb8ac
leaq 0x70(%rbx), %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xa842
testq %rax, %rax
je 0xa336
addq $0x40, %rbx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xa85c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa7b4
movl 0x20(%r14), %ecx
cmpq %rcx, 0x20(%rax)
jge 0xa3d8
movq 0x18(%r14), %rsi
movq 0x18(%rax), %rdx
jmp 0xa3e5
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0xab6c
movzwl 0x20(%rsp), %eax
movw %ax, 0x10(%r12)
movaps 0x10(%rsp), %xmm0
movaps %xmm0, (%r12)
movq 0x18(%r14), %rax
movq %rax, 0x18(%r12)
movl 0x20(%r14), %eax
movq %rax, 0x20(%r12)
andq $0x0, 0x28(%r12)
andq $0x0, 0x84(%r12)
movl 0x38(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x38(%rbx)
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x40(%rbx), %rdi
callq 0xa7b4
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0xabba
movl 0xc(%rsp), %ebp
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xa85c
movl %ebp, (%rax)
leaq 0xf0(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0xb4e8
incl 0x150(%rbx)
leaq 0xc0(%rsp), %rdi
callq 0x31d0
jmp 0xa3fa
movq 0x18(%rax), %rdx
movq 0x18(%r14), %rsi
cmpq %rsi, %rdx
je 0xa3f0
orq %rsi, %rdx
movq %rcx, 0x20(%rax)
movq %rdx, 0x18(%rax)
testb %bpl, %bpl
je 0xa3fa
andq $0x0, 0x38(%rax)
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36b0
cvtss2sd 0x8(%rbx), %xmm2
movsd 0x8348(%rip), %xmm1     # 0x129a8
subsd %xmm0, %xmm1
movapd %xmm1, %xmm3
testl %ebp, %ebp
jne 0xa670
xorpd %xmm3, %xmm3
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
cvtsd2ss %xmm2, %xmm2
movss %xmm2, 0x8(%rbx)
cvtps2pd (%rbx), %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm2, %xmm0
shufpd $0x2, 0x837b(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa8c2
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xa7a1
movss 0x78(%rbx), %xmm0
subss 0x70(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x82d5(%rip), %xmm0     # 0x129a8
movsd 0x82d5(%rip), %xmm1     # 0x129b0
ucomisd %xmm0, %xmm1
jbe 0xa6f8
movss 0x74(%rbx), %xmm0
movl $0xd2f00, %eax          # imm = 0xD2F00
ucomiss 0x832e(%rip), %xmm0     # 0x12a20
ja 0xa7a1
movss 0x6c(%rbx), %xmm0
subss 0x64(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x829a(%rip), %xmm0     # 0x129a8
movsd 0x82a2(%rip), %xmm1     # 0x129b8
ucomisd %xmm0, %xmm1
jbe 0xa72f
movss 0x68(%rbx), %xmm0
movl $0x3f480, %eax          # imm = 0x3F480
ucomiss 0x82f3(%rip), %xmm0     # 0x12a20
ja 0xa7a1
movss 0x60(%rbx), %xmm0
subss 0x58(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x8263(%rip), %xmm0     # 0x129a8
movsd 0x8273(%rip), %xmm1     # 0x129c0
ucomisd %xmm0, %xmm1
jbe 0xa766
movss 0x5c(%rbx), %xmm0
movl $0x7080, %eax           # imm = 0x7080
ucomiss 0x82bc(%rip), %xmm0     # 0x12a20
ja 0xa7a1
movss 0x54(%rbx), %xmm0
subss 0x4c(%rbx), %xmm0
movss 0x50(%rbx), %xmm1
cvtss2sd %xmm0, %xmm0
addsd 0x8227(%rip), %xmm0     # 0x129a8
xorl %ecx, %ecx
ucomiss 0x8296(%rip), %xmm1     # 0x12a20
movl $0x1c20, %eax           # imm = 0x1C20
cmovbel %ecx, %eax
movsd 0x822e(%rip), %xmm1     # 0x129c8
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7f5a
leaq 0x12bdb(%rip), %r14     # 0x1d4b0
cmpb $0x0, (%r14)
movl $0x141b, %ecx           # imm = 0x141B
movl $0xc91a, %edx           # imm = 0xC91A
cmovnel %ecx, %edx
cmpw %dx, %ax
jne 0xa911
testb $0x1, 0x18(%rbx)
je 0xa911
movq %rbx, %rdi
callq 0x857a
testb %al, %al
je 0xa911
movl 0x7c(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl $0x11500, %eax          # imm = 0x11500
setl %al
testb %al, %cl
je 0xa91b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x80(%rbx), %ecx
testl %ecx, %ecx
je 0xa937
xorl %eax, %eax
cmpb $0x0, (%r14)
movl $0x3a98, %edx           # imm = 0x3A98
cmovnel %eax, %edx
cmpl %edx, %ecx
jl 0xa913
movl 0x84(%rbx), %ecx
cmpl $0x3, %ecx
jg 0xa950
movl 0x88(%rbx), %edx
addl %edx, %edx
movb $0x1, %al
cmpl %ecx, %edx
jge 0xa913
cvtss2sd 0x48(%rbx), %xmm0
ucomisd 0x8073(%rip), %xmm0     # 0x129d0
movb $0x1, %al
jbe 0xa96f
movss 0x44(%rbx), %xmm0
ucomiss 0x80b3(%rip), %xmm0     # 0x12a20
ja 0xa913
cvtss2sd 0x54(%rbx), %xmm0
ucomisd 0x805c(%rip), %xmm0     # 0x129d8
jbe 0xa98c
movss 0x50(%rbx), %xmm0
ucomiss 0x809a(%rip), %xmm0     # 0x12a24
ja 0xa913
cvtss2sd 0x60(%rbx), %xmm0
ucomisd 0x8047(%rip), %xmm0     # 0x129e0
jbe 0xa9ad
movss 0x5c(%rbx), %xmm0
ucomiss 0x8081(%rip), %xmm0     # 0x12a28
ja 0xa913
cvtss2sd 0x6c(%rbx), %xmm0
ucomisd 0x802e(%rip), %xmm0     # 0x129e8
jbe 0xa9ce
movss 0x68(%rbx), %xmm0
ucomiss 0x8064(%rip), %xmm0     # 0x12a2c
ja 0xa913
cvtss2sd 0x78(%rbx), %xmm0
ucomisd 0x8015(%rip), %xmm0     # 0x129f0
seta %cl
movss 0x74(%rbx), %xmm0
ucomiss 0x8046(%rip), %xmm0     # 0x12a30
seta %al
andb %cl, %al
jmp 0xa913
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa8c2
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xaae9
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 0xaae9
movss 0x78(%rbx), %xmm0
subss 0x70(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7f52(%rip), %xmm0     # 0x129a8
movsd 0x7f9a(%rip), %xmm1     # 0x129f8
ucomisd %xmm0, %xmm1
jbe 0xaa77
movss 0x74(%rbx), %xmm0
movl $0x278d00, %eax         # imm = 0x278D00
ucomiss 0x7fbb(%rip), %xmm0     # 0x12a30
ja 0xaae9
movss 0x6c(%rbx), %xmm0
subss 0x64(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x7f1b(%rip), %xmm0     # 0x129a8
movsd 0x7f6b(%rip), %xmm1     # 0x12a00
ucomisd %xmm0, %xmm1
jbe 0xaaae
movss 0x68(%rbx), %xmm0
ucomiss 0x7f85(%rip), %xmm0     # 0x12a2c
movl $0x93a80, %eax          # imm = 0x93A80
ja 0xaae9
movss 0x60(%rbx), %xmm0
subss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
cvtss2sd %xmm0, %xmm0
addsd 0x7edf(%rip), %xmm0     # 0x129a8
xorl %ecx, %ecx
ucomiss 0x7f56(%rip), %xmm1     # 0x12a28
movl $0x15180, %eax          # imm = 0x15180
cmovbel %ecx, %eax
movsd 0x7f26(%rip), %xmm1     # 0x12a08
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/main.cpp
// Function: ThreadCrawler
void* ThreadCrawler(void* data) {
  int *nThreads=(int*)data;
  do {
    std::vector<CServiceResult> ips;
    int wait = 5;
    db.GetMany(ips, 16, wait);
    int64 now = time(NULL);
    if (ips.empty()) {
      wait *= 1000;
      wait += rand() % (500 * *nThreads);
      Sleep(wait);
      continue;
    }
    vector<CAddress> addr;
    for (int i=0; i<ips.size(); i++) {
      CServiceResult &res = ips[i];
      res.nBanTime = 0;
      res.nClientV = 0;
      res.nHeight = 0;
      res.strClientV = "";
      bool getaddr = res.ourLastSuccess + 3600 < now;
      res.fGood = TestNode(res.service,res.nBanTime,res.nClientV,res.strClientV,res.nHeight,getaddr ? &addr : NULL);
    }
    db.ResultMany(ips);
    db.Add(addr);
  } while(1);
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x28(%rsp)
leaq 0x10fce(%rip), %r14     # 0x1d4b8
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movl $0x5, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
pushq $0x10
popq %rdx
leaq 0xc(%rsp), %rcx
callq 0xd5ea
xorl %edi, %edi
callq 0x33d0
movq %rax, %rbp
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rax
cmpq %rax, %r15
je 0xc602
andq $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
pushq $0x20
popq %r13
xorl %r14d, %r14d
subq %r15, %rax
cqto
pushq $0x48
popq %rcx
idivq %rcx
cmpq %r14, %rax
jbe 0xc5d4
andq $0x0, -0xc(%r15,%r13)
leaq (%r15,%r13), %r12
andl $0x0, -0x4(%r15,%r13)
movq %r12, %rdi
leaq 0x619c(%rip), %rsi      # 0x12715
callq 0x3710
leaq (%r15,%r13), %rdi
addq $-0x20, %rdi
leaq -0xc(%r15,%r13), %rsi
leaq -0x4(%r15,%r13), %rdx
leaq (%r15,%r13), %r8
addq $-0x8, %r8
movq 0x28(%r8), %rax
movl $0xe10, %ecx            # imm = 0xE10
addq %rcx, %rax
cmpq %rbp, %rax
movl $0x0, %r9d
cmovlq %rbx, %r9
movq %r12, %rcx
callq 0x46c8
movb %al, -0xe(%r15,%r13)
incq %r14
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rax
addq $0x48, %r13
jmp 0xc54f
leaq 0x10edd(%rip), %r14     # 0x1d4b8
movq %r14, %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0xd6ba
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd78c
movq %rbx, %rdi
callq 0x695a
jmp 0xc630
imull $0x3e8, 0xc(%rsp), %eax # imm = 0x3E8
movl %eax, 0xc(%rsp)
callq 0x30d0
movq 0x28(%rsp), %rcx
imull $0x1f4, (%rcx), %ecx    # imm = 0x1F4
cltd
idivl %ecx
movl %edx, %edi
addl 0xc(%rsp), %edi
movl %edi, 0xc(%rsp)
callq 0xc667
movq %r12, %rdi
callq 0xd806
jmp 0xc4f4
jmp 0xc63f
movq %rax, %rbx
jmp 0xc655
jmp 0xc648
jmp 0xc648
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x695a
leaq 0x10(%rsp), %rdi
callq 0xd806
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./util.h
// Function: Sleep(int)
void static inline Sleep(int nMilliSec) {
    struct timespec wa;
    wa.tv_sec = nMilliSec/1000;
    wa.tv_nsec = (nMilliSec % 1000) * 1000000;
    nanosleep(&wa, NULL);
}

// Assembly:
subq $0x18, %rsp
movl %edi, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x3110
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x128, %rsp            # imm = 0x128
xorl %edi, %edi
callq 0x33d0
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x3300
leaq 0x603a(%rip), %rdx      # 0x12c05
leaq 0x20(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %rax, %rcx
callq 0x3340
leaq 0x6032(%rip), %r14      # 0x12c19
leaq 0x603f(%rip), %rbx      # 0x12c2d
leaq 0x602c(%rip), %r12      # 0x12c21
leaq 0x108bc(%rip), %rdi     # 0x1d4b8
leaq 0x8(%rsp), %rsi
callq 0xdc28
movq %r14, %rdi
xorl %eax, %eax
callq 0x3050
leaq 0x6012(%rip), %rdi      # 0x12c29
xorl %eax, %eax
callq 0x3050
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %eax, %eax
movl %eax, %eax
movq 0x10a19(%rip), %rdx     # 0x1d648
movq 0x10a0a(%rip), %rcx     # 0x1d640
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0xcc55
movq (%rcx,%rax,8), %rcx
addq 0x30(%rcx), %r10
movq 0x70(%rcx), %rcx
addq %rcx, %r11
incl %eax
jmp 0xcc26
movl 0x18(%rsp), %edx
movl 0x8(%rsp), %r14d
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movl 0x14(%rsp), %r13d
movl %ecx, %ebp
subl %r8d, %ebp
subl %r13d, %ebp
subq $0x8, %rsp
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r14
pushq %rbp
pushq %r13
callq 0x3050
addq $0x30, %rsp
movl $0x3e8, %edi            # imm = 0x3E8
callq 0xc667
xorl %edi, %edi
callq 0x33d0
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x3300
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
leaq 0x5f42(%rip), %rdx      # 0x12c05
movq %rax, %rcx
callq 0x3340
movq %r12, %r14
jmp 0xcbf5
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/main.cpp
// Function: ThreadSeeder
void* ThreadSeeder(void*) {
  if (!fTestNet){
    db.Add(CService("168.235.109.113", 51482), true);
    db.Add(CService("168.235.78.242", 51482), true);
    db.Add(CService("176.56.236.202", 51482), true);
  }
  do {
    for (int i=0; seeds[i] != ""; i++) {
      vector<CNetAddr> ips;
      LookupHost(seeds[i].c_str(), ips);
      for (vector<CNetAddr>::iterator it = ips.begin(); it != ips.end(); it++) {
        db.Add(CService(*it, GetDefaultPort()), true);
      }
    }
    Sleep(1800000);
  } while(1);
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpb $0x0, 0x107c5(%rip)     # 0x1d4b0
jne 0xcde3
leaq 0x5fad(%rip), %rsi      # 0x12ca5
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
movl $0xc91a, %edx           # imm = 0xC91A
xorl %ecx, %ecx
callq 0x8c32
movzwl 0x10(%rbx), %eax
movw %ax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %r15
pushq $0x1
popq %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9a64
leaq 0x1077f(%rip), %r14     # 0x1d4b8
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xdcc4
leaq 0x5f65(%rip), %rsi      # 0x12cb5
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movl $0xc91a, %edx           # imm = 0xC91A
xorl %ecx, %ecx
callq 0x8c32
movzwl 0x10(%r15), %eax
movw %ax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9a64
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xdcc4
leaq 0x5f27(%rip), %rsi      # 0x12cc4
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movl $0xc91a, %edx           # imm = 0xC91A
xorl %ecx, %ecx
callq 0x8c32
movzwl 0x10(%r15), %eax
movw %ax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9a64
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xdcc4
xorl %r14d, %r14d
pushq $0x1
popq %rbp
leaq 0x40(%rsp), %r15
leaq 0x58(%rsp), %r12
pushq $0x1
popq %r13
leaq 0x106ba(%rip), %rbx     # 0x1d4b8
movq %r14, 0x38(%rsp)
shlq $0x5, %r14
movq 0x105da(%rip), %rdi     # 0x1d3e8
addq %r14, %rdi
leaq 0x58fd(%rip), %rsi      # 0x12715
callq 0xdd01
testb %al, %al
je 0xcea7
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x105ae(%rip), %rax     # 0x1d3e8
movq (%rax,%r14), %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x6b30
movq 0x20(%rsp), %r14
cmpq 0x28(%rsp), %r14
je 0xceb9
cmpb $0x0, 0x10651(%rip)     # 0x1d4b0
movl $0x141b, %edx           # imm = 0x141B
jne 0xce6b
movl $0xc91a, %edx           # imm = 0xC91A
movq %r15, %rdi
movq %r14, %rsi
callq 0x8aec
movzwl 0x50(%rsp), %eax
movw %ax, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x9a64
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xdcc4
addq $0x10, %r14
jmp 0xce51
movl $0x1b7740, %edi         # imm = 0x1B7740
callq 0xc667
xorl %r14d, %r14d
jmp 0xcdfe
leaq 0x20(%rsp), %rdi
callq 0x9526
movq 0x38(%rsp), %r14
incq %r14
jmp 0xcdfe
jmp 0xced2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9526
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
callq 0x35e0
testl %ebp, %ebp
jle 0xd681
leaq 0x10(%rsp), %r13
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x8ae0
movb %r15b, 0x22(%rsp)
andq $0x0, 0x24(%rsp)
andl $0x0, 0x2c(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movb %r15b, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x9e78
movl %eax, %r12d
testb %al, %al
je 0xd66d
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xe56a
decl %ebp
leaq 0x30(%rsp), %rdi
callq 0x31d0
testl %ebp, %ebp
setg %al
testb %al, %r12b
jne 0xd616
movq %rbx, %rdi
callq 0x3510
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xd6aa
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3510
movq %r14, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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 0x35e0
pushq $0x20
popq %r13
xorl %r15d, %r15d
leaq 0x8(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
pushq $0x48
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0xd753
leaq (%rsi,%r13), %r12
addq $-0x20, %r12
cmpb $0x1, 0x12(%r12)
jne 0xd73a
movl -0x4(%rsi,%r13), %ebp
addq %r13, %rsi
callq 0x3550
movq (%r14), %rax
movl -0x8(%rax,%r13), %r8d
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
leaq 0x8(%rsp), %r12
movq %r12, %rcx
callq 0xa028
movq %r12, %rdi
callq 0x31d0
jmp 0xd74a
movl -0xc(%rsi,%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa108
incq %r15
addq $0x48, %r13
jmp 0xd6da
movq %rbx, %rdi
callq 0x3510
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x31d0
jmp 0xd77c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3510
movq %r14, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./db.h
// Function: CAddrDb::GetAll()
std::vector<CAddrReport> GetAll() {
    std::vector<CAddrReport> ret;
    SHARED_CRITICAL_BLOCK(cs) {
      for (std::deque<int>::const_iterator it = ourId.begin(); it != ourId.end(); it++) {
        const CAddrInfo &info = idToInfo[*it];
        if (info.success > 0) {
          ret.push_back(info.GetReport());
        }
      }
    }
    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x33c0
movq 0xb0(%r14), %rsi
movq 0xc8(%r14), %rax
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movups 0xb8(%r14), %xmm0
movups %xmm0, 0x8(%r15)
movq %rax, 0x18(%r15)
leaq 0x40(%r14), %r13
leaq 0x70(%rsp), %r12
leaq 0x28(%rsp), %rbp
cmpq 0xd0(%r14), %rsi
je 0xdaf5
movq %r13, %rdi
callq 0xa7b4
cmpl $0x0, 0x88(%rax)
jle 0xdae1
movq %rbp, %rdi
movq %rax, %rsi
callq 0xeac4
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xeb9c
movq %r12, %rdi
callq 0x31d0
movq %rbp, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xeb7c
movq 0x8(%rsp), %rsi
jmp 0xdaa9
movq %r14, %rdi
callq 0x3510
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x31d0
jmp 0xdb24
jmp 0xdb21
movq %rax, %r15
movq %r14, %rdi
callq 0x3510
movq %rbx, %rdi
callq 0xdc06
movq %r15, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, (%rdi)
je 0xdb68
movq %rdi, %rbx
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %ecx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xff84
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x20
popq %rdi
callq 0x31e0
movq %rax, %rbx
callq 0x33b0
leaq 0x8(%rsp), %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x55c8(%rip), %rsi      # 0x13156
movq %rbx, %rdi
callq 0x3150
movq 0xf3eb(%rip), %rsi      # 0x1cf88
movq 0xf414(%rip), %rdx      # 0x1cfb8
movq %rbx, %rdi
callq 0x3680
movq %rax, %r14
movq %rbx, %rdi
callq 0x32f0
movq %r14, %rdi
callq 0x3690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x33c0
movl 0x180(%rbx), %eax
movl %eax, (%r14)
leaq 0x40(%rbx), %r15
movl 0x68(%rbx), %eax
movl %eax, 0x4(%r14)
leaq 0xa0(%rbx), %rdi
callq 0xa7a4
movl %eax, 0x8(%r14)
movl 0x148(%rbx), %eax
movl %eax, 0x10(%r14)
movl 0x118(%rbx), %eax
movl %eax, 0xc(%r14)
xorl %edi, %edi
callq 0x33d0
movq %rax, %r12
leaq 0xb0(%rbx), %rdi
xorl %esi, %esi
callq 0xee1a
movq %r15, %rdi
movq %rax, %rsi
callq 0xa7b4
subl 0x28(%rax), %r12d
movl %r12d, 0x14(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3510
movq %rax, %r14
movq %rbx, %rdi
callq 0x3510
movq %r14, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, (%rdi)
je 0xe22e
movq %rdi, %rbx
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %ecx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x10622
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x20
popq %rdi
callq 0x31e0
movq %rax, %rbx
callq 0x33b0
leaq 0x8(%rsp), %rdx
movl $0x1, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x4f75(%rip), %rsi      # 0x131c9
movq %rbx, %rdi
callq 0x3150
movq 0xed25(%rip), %rsi      # 0x1cf88
movq 0xed4e(%rip), %rdx      # 0x1cfb8
movq %rbx, %rdi
callq 0x3680
movq %rax, %r14
movq %rbx, %rdi
callq 0x32f0
movq %r14, %rdi
callq 0x3690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movl %edx, 0x38(%rdi)
leaq 0x48(%rdi), %rax
andl $0x0, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x80(%rdi), %rax
andl $0x0, 0x80(%rdi)
andq $0x0, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movq %rax, 0x98(%rdi)
andq $0x0, 0xa0(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x78(%rdi), %r15
movdqu 0x20(%rsi), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x10(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x20(%rdi)
movabsq $0x9c4000000e10, %rax   # imm = 0x9C4000000E10
movq %rax, 0x4(%rdi)
leaq -0x1c96(%rip), %rax     # 0xc697
movq %rax, 0x28(%rdi)
movl 0x4(%rsi), %eax
movl %eax, (%rdi)
andq $0x0, 0x30(%rdi)
xorl %eax, %eax
xchgq %rax, 0x70(%rdi)
movq %r14, %rdi
callq 0xf0c2
addq $0x48, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf14a
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xf40e
movq %r14, %rdi
callq 0xf422
movq %rbx, %rdi
callq 0x3690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xed8a
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movl 0x7c(%r14), %eax
movl %eax, 0x14(%rbx)
leaq 0x90(%r14), %rsi
leaq 0x48(%rbx), %r15
movq %r15, %rdi
callq 0x3220
movl 0x80(%r14), %eax
movl %eax, 0x18(%rbx)
movups 0x48(%r14), %xmm0
movss 0x54(%r14), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
cvtps2pd %xmm1, %xmm0
movups %xmm0, 0x20(%rbx)
movups 0x60(%r14), %xmm0
movss 0x6c(%r14), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
cvtps2pd %xmm1, %xmm0
movups %xmm0, 0x30(%rbx)
cvtss2sd 0x78(%r14), %xmm0
movsd %xmm0, 0x40(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x68(%rbx)
movq %r14, %rdi
callq 0xa8c2
movb %al, 0x70(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x78(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O2/tenup-coin[P]seeder/./db.h
// Function: void CAddrDb::Serialize<CAutoFile>(CAutoFile&, int, int) const
SHARED_CRITICAL_BLOCK(cs) {
      if (fWrite) {
        CAddrDb *db = const_cast<CAddrDb*>(this);
        int n = ourId.size() + unkId.size();
        READWRITE(n);
        for (std::deque<int>::const_iterator it = ourId.begin(); it != ourId.end(); it++) {
          std::map<int, CAddrInfo>::iterator ci = db->idToInfo.find(*it);
          READWRITE((*ci).second);
        }
        for (std::set<int>::const_iterator it = unkId.begin(); it != unkId.end(); it++) {
          std::map<int, CAddrInfo>::iterator ci = db->idToInfo.find(*it);
          READWRITE((*ci).second);
        }
      } else {
        CAddrDb *db = const_cast<CAddrDb*>(this);
        db->nId = 0;
        int n;
        READWRITE(n);
        for (int i=0; i<n; i++) {
          CAddrInfo info;
          READWRITE(info);
          if (!info.GetBanTime()) {
            int id = db->nId++;
            db->idToInfo[id] = info;
            db->ipToId[info.ip] = id;
            if (info.ourLastTry) {
              db->ourId.push_back(id);
              if (info.IsGood()) db->goodId.insert(id);
            } else {
              db->unkId.insert(id);
            }
          }
        }
        db->nDirty++;
      }
      READWRITE(banned);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x100c7
movq %rbx, %rdi
callq 0x33c0
leaq 0xa0(%rbx), %rdi
callq 0xa7a4
addl 0x118(%rbx), %eax
movq %r14, %rdi
movl %eax, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x100c7
movq 0xb0(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
movups 0xb8(%rbx), %xmm0
movups %xmm0, 0x8(%r12)
movq 0xc8(%rbx), %rax
movq %rax, 0x18(%r12)
leaq 0x40(%rbx), %r15
leaq 0x28(%rsp), %r13
cmpq 0xd0(%rbx), %rsi
je 0x10038
movq %r15, %rdi
callq 0x101f0
addq $0x28, %rax
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x10224
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xeb7c
movq 0x8(%rsp), %rsi
jmp 0x10000
movq 0x108(%rbx), %r12
leaq 0xf8(%rbx), %r13
cmpq %r13, %r12
je 0x10078
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x101f0
addq $0x28, %rax
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x10224
movq %r12, %rdi
callq 0x3460
movq %rax, %r12
jmp 0x10046
leaq 0x158(%rbx), %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x10588
movq %rbx, %rdi
callq 0x3510
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x100a8
jmp 0x100a8
jmp 0x100a8
movq %rax, %r14
movq %rbx, %rdi
callq 0x3510
movq %r14, %rdi
callq 0x3690