LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x7, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x18eb4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x18e87
movb $0x1, -0x1(%rbp)
jmp 0x18eb8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jbe 0x18ea5
movb $0x0, -0x1(%rbp)
jmp 0x18eb8
jmp 0x18ea7
jmp 0x18ea9
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18e63
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x19450
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x194ee
jmp 0x195cb
movq -0x48(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1a660
movq -0x48(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x10(%rbp), %rsi
callq 0x1a690
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1a370
movq -0x50(%rbp), %rsi
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x30(%rbp), %rdi
addq $0x90, %rdi
callq 0x4050
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x80(%rax)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x19070
movq -0x30(%rbp), %rdi
callq 0x1a6c0
testb $0x1, %al
jne 0x19573
jmp 0x195a8
movq -0x48(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x28(%rbp), %rsi
callq 0x1a8f0
cmpq $0x0, %rax
jne 0x195a8
movq -0x48(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x28(%rbp), %rsi
callq 0x1a950
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
movq -0x48(%rbp), %rdi
movl 0x150(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x150(%rdi)
addq $0xa0, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1a4c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x19450
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x19612
jmp 0x1972e
movq -0x30(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1a660
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1a370
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x19070
xorl %eax, %eax
movl %eax, %edi
callq 0x44a0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a9a0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x19674
movl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x19672
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x19674
cmpl $0x0, -0x14(%rbp)
jle 0x196d9
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
addq $0x158, %rdi            # imm = 0x158
movq -0x20(%rbp), %rsi
callq 0x1aaf0
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rcx, (%rax)
addq $0x70, %rdi
movq -0x20(%rbp), %rsi
callq 0x1abd0
movq -0x30(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x18(%rbp), %rsi
callq 0x1a660
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1ac00
jmp 0x1971b
movq -0x30(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x18(%rbp), %rsi
callq 0x1a8f0
cmpq $0x1, %rax
jne 0x19707
movq -0x30(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x18(%rbp), %rsi
callq 0x1a660
movq -0x30(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1a4c0
movq -0x30(%rbp), %rax
movl 0x150(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x150(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x19450
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1976c
jmp 0x197a7
movq -0x20(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1a660
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1a4c0
movq -0x20(%rbp), %rax
movl 0x150(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x150(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
divsd -0x20(%rbp), %xmm0
callq 0x4820
movq -0x40(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1a015
movsd 0x199af(%rip), %xmm0    # 0x339b8
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x1a01f
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x1a01f
movq -0x40(%rbp), %rax
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1995b(%rip), %xmm1    # 0x339b8
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd -0x28(%rbp), %xmm2
movsd 0x19939(%rip), %xmm1    # 0x339b8
subsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1a6c0
testb $0x1, %al
jne 0x1a0bf
jmp 0x1a0cb
movl $0x0, -0x4(%rbp)
jmp 0x1a204
movq -0x18(%rbp), %rax
movss 0x78(%rax), %xmm0
subss 0x70(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x198d3(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x198cf(%rip), %xmm0    # 0x339c0
ucomisd %xmm1, %xmm0
jbe 0x1a119
movq -0x18(%rbp), %rax
movss 0x74(%rax), %xmm0
movss 0x19918(%rip), %xmm1    # 0x33a20
ucomiss %xmm1, %xmm0
jbe 0x1a119
movl $0xd2f00, -0x4(%rbp)    # imm = 0xD2F00
jmp 0x1a204
movq -0x18(%rbp), %rax
movss 0x6c(%rax), %xmm0
subss 0x64(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x19885(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x19889(%rip), %xmm0    # 0x339c8
ucomisd %xmm1, %xmm0
jbe 0x1a167
movq -0x18(%rbp), %rax
movss 0x68(%rax), %xmm0
movss 0x198ca(%rip), %xmm1    # 0x33a20
ucomiss %xmm1, %xmm0
jbe 0x1a167
movl $0x3f480, -0x4(%rbp)    # imm = 0x3F480
jmp 0x1a204
movq -0x18(%rbp), %rax
movss 0x60(%rax), %xmm0
subss 0x58(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x19837(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x19843(%rip), %xmm0    # 0x339d0
ucomisd %xmm1, %xmm0
jbe 0x1a1b2
movq -0x18(%rbp), %rax
movss 0x5c(%rax), %xmm0
movss 0x1987c(%rip), %xmm1    # 0x33a20
ucomiss %xmm1, %xmm0
jbe 0x1a1b2
movl $0x7080, -0x4(%rbp)     # imm = 0x7080
jmp 0x1a204
movq -0x18(%rbp), %rax
movss 0x54(%rax), %xmm0
subss 0x4c(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x197ec(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x19800(%rip), %xmm0    # 0x339d8
ucomisd %xmm1, %xmm0
jbe 0x1a1fd
movq -0x18(%rbp), %rax
movss 0x50(%rax), %xmm0
movss 0x19831(%rip), %xmm1    # 0x33a20
ucomiss %xmm1, %xmm0
jbe 0x1a1fd
movl $0x1c20, -0x4(%rbp)     # imm = 0x1C20
jmp 0x1a204
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1a6c0
testb $0x1, %al
jne 0x1a9bf
jmp 0x1a9cb
movl $0x0, -0x4(%rbp)
jmp 0x1aad9
movq -0x18(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
je 0x1a9ee
movq -0x18(%rbp), %rax
cmpl $0x7c9c, 0x7c(%rax)     # imm = 0x7C9C
jge 0x1a9ee
movl $0x93a80, -0x4(%rbp)    # imm = 0x93A80
jmp 0x1aad9
movq -0x18(%rbp), %rax
movss 0x78(%rax), %xmm0
subss 0x70(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x18fb0(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x18ff4(%rip), %xmm0    # 0x33a08
ucomisd %xmm1, %xmm0
jbe 0x1aa3c
movq -0x18(%rbp), %rax
movss 0x74(%rax), %xmm0
movss 0x19005(%rip), %xmm1    # 0x33a30
ucomiss %xmm1, %xmm0
jbe 0x1aa3c
movl $0x278d00, -0x4(%rbp)   # imm = 0x278D00
jmp 0x1aad9
movq -0x18(%rbp), %rax
movss 0x6c(%rax), %xmm0
subss 0x64(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x18f62(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x18fae(%rip), %xmm0    # 0x33a10
ucomisd %xmm1, %xmm0
jbe 0x1aa87
movq -0x18(%rbp), %rax
movss 0x68(%rax), %xmm0
movss 0x18fb3(%rip), %xmm1    # 0x33a2c
ucomiss %xmm1, %xmm0
jbe 0x1aa87
movl $0x93a80, -0x4(%rbp)    # imm = 0x93A80
jmp 0x1aad9
movq -0x18(%rbp), %rax
movss 0x60(%rax), %xmm0
subss 0x58(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x18f17(%rip), %xmm0    # 0x339b8
addsd %xmm0, %xmm1
movsd 0x18f6b(%rip), %xmm0    # 0x33a18
ucomisd %xmm1, %xmm0
jbe 0x1aad2
movq -0x18(%rbp), %rax
movss 0x5c(%rax), %xmm0
movss 0x18f64(%rip), %xmm1    # 0x33a28
ucomiss %xmm1, %xmm0
jbe 0x1aad2
movl $0x15180, -0x4(%rbp)    # imm = 0x15180
jmp 0x1aad9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/main.cpp
// Function: StatCompare(CAddrReport const&, CAddrReport const&)
int StatCompare(const CAddrReport& a, const CAddrReport& b) {
  if (a.uptime[4] == b.uptime[4]) {
    if (a.uptime[3] == b.uptime[3]) {
      return a.clientVersion > b.clientVersion;
    } else {
      return a.uptime[3] > b.uptime[3];
    }
  } else {
    return a.uptime[4] > b.uptime[4];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x40(%rax), %xmm0
jne 0x23052
jp 0x23052
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x38(%rax), %xmm0
jne 0x23033
jp 0x23033
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2306f
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x38(%rax), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2306f
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x40(%rax), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x44a0
movq %rax, -0x128(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x43b0
movq %rax, -0x130(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x130(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x106e2(%rip), %rdx     # 0x33c95
callq 0x4400
leaq 0x26fe9(%rip), %rdi     # 0x4a5a8
leaq -0x148(%rbp), %rsi
callq 0x254c0
testb $0x1, -0x19(%rbp)
je 0x235e5
movb $0x0, -0x19(%rbp)
leaq 0x106cd(%rip), %rdi     # 0x33ca9
movb $0x0, %al
callq 0x4070
jmp 0x235f3
leaq 0x106c5(%rip), %rdi     # 0x33cb1
movb $0x0, %al
callq 0x4070
leaq 0x106bf(%rip), %rdi     # 0x33cb9
movb $0x0, %al
callq 0x4070
movq $0x0, -0x150(%rbp)
movq $0x0, -0x158(%rbp)
movl $0x0, -0x15c(%rbp)
movl -0x15c(%rbp), %eax
movq %rax, -0x168(%rbp)
leaq 0x270fb(%rip), %rdi     # 0x4a730
callq 0x255f0
movq %rax, %rcx
movq -0x168(%rbp), %rax
cmpq %rcx, %rax
jae 0x236b4
movl -0x15c(%rbp), %eax
movl %eax, %esi
leaq 0x270d8(%rip), %rdi     # 0x4a730
callq 0x25610
movq (%rax), %rax
movq 0x30(%rax), %rax
addq -0x150(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x15c(%rbp), %eax
movl %eax, %esi
leaq 0x270af(%rip), %rdi     # 0x4a730
callq 0x25610
movq (%rax), %rdi
addq $0x70, %rdi
callq 0x25630
addq -0x158(%rbp), %rax
movq %rax, -0x158(%rbp)
movl -0x15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x15c(%rbp)
jmp 0x23621
leaq -0x120(%rbp), %rsi
movl -0x138(%rbp), %edx
movl -0x144(%rbp), %ecx
movl -0x140(%rbp), %r8d
movl -0x134(%rbp), %r9d
movl -0x13c(%rbp), %r14d
movl -0x144(%rbp), %ebx
subl -0x140(%rbp), %ebx
subl -0x13c(%rbp), %ebx
movl -0x148(%rbp), %r11d
movq -0x150(%rbp), %r10
movq -0x158(%rbp), %rax
leaq 0x105b3(%rip), %rdi     # 0x33cbd
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x4070
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x22b60
movb $0x1, %al
testb $0x1, %al
jne 0x23576
jmp 0x2373e
xorl %eax, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
xorl %edx, %edx
callq 0x26bd0
movq -0x90(%rbp), %rdi
callq 0x26c10
movb %al, -0x85(%rbp)
jmp 0x2450b
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x2451a
jmp 0x245f2
jmp 0x2451c
cmpl $0x0, -0x14(%rbp)
jle 0x245f0
leaq -0x80(%rbp), %rdi
callq 0x14610
jmp 0x24531
movb $0x0, -0x6e(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x68(%rbp)
movl $0x0, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x46b0
movq -0x98(%rbp), %rdi
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rsi
callq 0x19200
movb %al, -0x99(%rbp)
jmp 0x24577
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x245b4
jmp 0x24583
movl $0x1, -0x84(%rbp)
jmp 0x245d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2460e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x26c90
jmp 0x2460e
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x26c20
jmp 0x245c3
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x84(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x26c90
movl -0x84(%rbp), %eax
testl %eax, %eax
jne 0x245fc
jmp 0x245eb
jmp 0x2451c
jmp 0x245f2
movl $0x0, -0x84(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x26cb0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x26cb0
movq -0x30(%rbp), %rdi
callq 0x47f0
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
xorl %edx, %edx
callq 0x26bd0
leaq -0x18(%rbp), %rdi
callq 0x26c10
testb $0x1, %al
jne 0x246e8
jmp 0x24805
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24660
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x24803
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
testb $0x1, 0x12(%rax)
je 0x247c1
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
movl 0x1c(%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x2476a
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0x64(%rbp), %edx
movl 0x18(%rax), %r8d
leaq -0x40(%rbp), %rcx
callq 0x194b0
jmp 0x24791
leaq -0x40(%rbp), %rdi
callq 0x42f0
jmp 0x247f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x24817
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x42f0
jmp 0x24817
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x27810
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl 0x14(%rax), %edx
callq 0x195e0
jmp 0x247f1
jmp 0x247f3
jmp 0x247f5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x246ef
jmp 0x24805
leaq -0x18(%rbp), %rdi
callq 0x26cb0
addq $0x80, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x26cb0
movq -0x48(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x150(%rbp)
movq %rdi, %rax
movq %rax, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x288c0
movq -0x140(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
callq 0x26bd0
jmp 0x24f5f
leaq -0x20(%rbp), %rdi
callq 0x26c10
testb $0x1, %al
jne 0x24f71
jmp 0x250a2
movq -0x140(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x70(%rbp), %rdi
callq 0x1ae00
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x288e0
movq -0x140(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x90(%rbp), %rdi
callq 0x26aa0
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x28920
testb $0x1, %al
jne 0x24fc8
jmp 0x250a0
movq -0x140(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x160(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x28950
movq -0x160(%rbp), %rdi
movq %rax, %rsi
callq 0x1a370
movq %rax, -0x158(%rbp)
jmp 0x24ffb
movq -0x158(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpl $0x0, 0x88(%rax)
jle 0x25087
movq -0x98(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x289a0
jmp 0x2502e
movq -0x150(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x28970
jmp 0x25043
leaq -0x118(%rbp), %rdi
callq 0x25400
jmp 0x25087
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x250de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x250b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x25400
jmp 0x250b7
jmp 0x25089
leaq -0x138(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x28ac0
jmp 0x24f95
jmp 0x250a2
leaq -0x20(%rbp), %rdi
callq 0x26cb0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x250ce
jmp 0x250c2
leaq -0x20(%rbp), %rdi
callq 0x26cb0
jmp 0x250de
movq -0x150(%rbp), %rdi
callq 0x25460
movq -0x148(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x150(%rbp), %rdi
callq 0x25460
movq -0x28(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: CAutoFile::CAutoFile(_IO_FILE*, int, int)
CAutoFile(FILE* filenew=NULL, int nTypeIn=SER_DISK, int nVersionIn=PROTOCOL_VERSION)
    {
        file = filenew;
        nType = nTypeIn;
        nVersion = nVersionIn;
        state = 0;
        exceptmask = std::ios::badbit | std::ios::failbit;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x10(%rax)
movw $0x0, 0x8(%rax)
movl $0x1, %edi
movl $0x4, %esi
callq 0x72a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movw %cx, 0xa(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x25296
movl $0x20, %edi
callq 0x4230
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x1, %esi
callq 0xcc20
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xefca(%rip), %rsi      # 0x3422b
callq 0x41a0
jmp 0x25268
movq -0x50(%rbp), %rdi
movq 0x24cfd(%rip), %rsi     # 0x49f70
movq 0x24d36(%rip), %rdx     # 0x49fb0
callq 0x47e0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x43a0
jmp 0x252b4
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq 0xc(%rdi), %rdx
movl 0x10(%rdi), %ecx
callq 0x2e460
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %edx
callq 0x26bd0
leaq -0x18(%rbp), %rdi
callq 0x26c10
testb $0x1, %al
jne 0x254f8
jmp 0x255d7
movq -0x30(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x295f0
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rdi
movq %rdi, -0x40(%rbp)
callq 0x29610
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0xa0, %rdi
movq %rdi, -0x58(%rbp)
callq 0x1a230
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x120, %rdi            # imm = 0x120
callq 0x1a210
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0xf0, %rdi
callq 0x1a210
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
xorl %eax, %eax
movl %eax, %edi
movq %rdi, -0x50(%rbp)
callq 0x44a0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
callq 0x29630
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1a370
movq %rax, -0x38(%rbp)
jmp 0x255a9
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
subq 0x28(%rcx), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x255d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x26cb0
jmp 0x255e6
leaq -0x18(%rbp), %rdi
callq 0x26cb0
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x47f0
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x25f96
movl $0x20, %edi
callq 0x4230
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x1, %esi
callq 0xcc20
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xe33d(%rip), %rsi      # 0x3429e
callq 0x41a0
jmp 0x25f68
movq -0x50(%rbp), %rdi
movq 0x23ffd(%rip), %rsi     # 0x49f70
movq 0x24036(%rip), %rdx     # 0x49fb0
callq 0x47e0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x43a0
jmp 0x25fb4
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq 0xc(%rdi), %rdx
movl 0x10(%rdi), %ecx
callq 0x2f7e0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, 0x38(%rdi)
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2a620
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x70, %rax
movq %rax, -0x40(%rbp)
addq $0x78, %rdi
movq %rdi, -0x30(%rbp)
callq 0x29800
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rax)
movl $0xe10, 0x4(%rax)       # imm = 0xE10
movl $0x9c40, 0x8(%rax)      # imm = 0x9C40
leaq -0x357b(%rip), %rcx     # 0x22bb0
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, (%rax)
movq $0x0, 0x30(%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x2a640
movq -0x38(%rbp), %rdi
callq 0x2a6e0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x2a700
jmp 0x26165
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2a730
movq -0x38(%rbp), %rdi
callq 0x2a750
movq -0x20(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tenup-coin[P]seeder/./util.h
// Function: CCriticalSection::Enter(bool)
void Enter(bool fShared = false) { 
      if (fShared) {
        pthread_rwlock_rdlock(&mutex);
      } else {
        pthread_rwlock_wrlock(&mutex);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x26d0d
movq -0x18(%rbp), %rdi
callq 0x4490
jmp 0x26d16
movq -0x18(%rbp), %rdi
callq 0x4730
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x29450
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movw 0x10(%rsi), %ax
movw %ax, 0x10(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movl 0x7c(%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x90, %rsi
addq $0x48, %rdi
callq 0x4050
jmp 0x289fa
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x80(%rdi), %ecx
movl %ecx, 0x18(%rax)
movss 0x48(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movss 0x54(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
movss 0x60(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movss 0x6c(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
movss 0x78(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
movq 0x30(%rdi), %rcx
movq %rcx, 0x68(%rax)
callq 0x1a6c0
movb %al, -0x41(%rbp)
jmp 0x28a63
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb -0x41(%rbp), %dl
andb $0x1, %dl
movb %dl, 0x70(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x78(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x28aa8
jmp 0x28a9f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x25400
jmp 0x28ab2
movq -0x30(%rbp), %rdi
callq 0x25400
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x47f0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x2e9f9
movl $0x20, %edi
callq 0x4230
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x1, %esi
callq 0xcc20
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x5893(%rip), %rsi      # 0x34257
callq 0x41a0
jmp 0x2e9cb
movq -0x58(%rbp), %rdi
movq 0x1b59a(%rip), %rsi     # 0x49f70
movq 0x1b5d3(%rip), %rdx     # 0x49fb0
callq 0x47e0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x43a0
jmp 0x2ea3a
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq (%rax), %rcx
movl $0x1, %esi
callq 0x48a0
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x2ea30
movq -0x40(%rbp), %rdi
movl $0x4, %esi
leaq 0x5853(%rip), %rdx      # 0x3427e
callq 0x2ea50
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x2fcc9
movl $0x20, %edi
callq 0x4230
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x1, %esi
callq 0xcc20
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x4636(%rip), %rsi      # 0x342ca
callq 0x41a0
jmp 0x2fc9b
movq -0x58(%rbp), %rdi
movq 0x1a2ca(%rip), %rsi     # 0x49f70
movq 0x1a303(%rip), %rdx     # 0x49fb0
callq 0x47e0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x43a0
jmp 0x2fd26
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq (%rax), %rcx
movl $0x1, %esi
callq 0x4720
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x2fd1c
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x4740
movq -0x40(%rbp), %rdi
movl %eax, %ecx
leaq 0x460a(%rip), %rdx      # 0x3430e
leaq 0x45e5(%rip), %rax      # 0x342f0
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl $0x4, %esi
callq 0x2ea50
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x47f0
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25fc0
movq -0x8(%rbp), %rdi
callq 0x30600
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x307e0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x307d0
leaq -0x50(%rbp), %rdi
callq 0x30810
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x50(%rbp), %rsi
callq 0x30840
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f8f0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x30890
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3076f
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc410, %rsp           # imm = 0xC410
movq %rdi, -0xc3c8(%rbp)
movq %rdi, %rax
movq %rax, -0xc3c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xc370(%rbp), %rax
movq %rax, -0xc378(%rbp)
movl $0xc350, -0xc37c(%rbp)  # imm = 0xC350
leaq -0xc3a0(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0xc378(%rbp), %rax
movq %rax, -0xc3d8(%rbp)
movslq -0xc37c(%rbp), %rax
movq %rax, -0xc3d0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41e0
movq -0xc3d8(%rbp), %rdi
movq -0xc3d0(%rbp), %rsi
movq %rax, %rdx
leaq -0xc3a0(%rbp), %rcx
callq 0x4320
movl %eax, -0xc380(%rbp)
leaq -0xc3a0(%rbp), %rax
cmpl $0x0, -0xc380(%rbp)
jl 0x313e4
movl -0xc380(%rbp), %eax
cmpl -0xc37c(%rbp), %eax
jge 0x313e4
jmp 0x3148b
movq -0xc378(%rbp), %rax
leaq -0xc370(%rbp), %rcx
cmpq %rcx, %rax
je 0x31419
movq -0xc378(%rbp), %rax
movq %rax, -0xc3e0(%rbp)
cmpq $0x0, %rax
je 0x31417
movq -0xc3e0(%rbp), %rdi
callq 0x4610
jmp 0x31419
movl -0xc37c(%rbp), %eax
shll %eax
movl %eax, -0xc37c(%rbp)
movslq -0xc37c(%rbp), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x4030
movq %rax, -0xc378(%rbp)
cmpq $0x0, -0xc378(%rbp)
jne 0x31486
movl $0x8, %edi
callq 0x4230
movq %rax, %rdi
movq %rdi, -0xc3e8(%rbp)
callq 0x31d60
movq -0xc3e8(%rbp), %rdi
movq 0x18b46(%rip), %rsi     # 0x49fc0
movq 0x18b0f(%rip), %rdx     # 0x49f90
callq 0x47e0
jmp 0x31360
movb $0x0, -0xc3a1(%rbp)
movq -0xc378(%rbp), %rax
movq %rax, -0xc400(%rbp)
movslq -0xc380(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xc3f8(%rbp)
leaq -0xc3a2(%rbp), %rdi
movq %rdi, -0xc3f0(%rbp)
callq 0x4800
movq -0xc3c8(%rbp), %rdi
movq -0xc400(%rbp), %rsi
movq -0xc3f8(%rbp), %rdx
movq -0xc3f0(%rbp), %rcx
callq 0x31da0
jmp 0x314e7
leaq -0xc3a2(%rbp), %rdi
callq 0x4520
movq -0xc378(%rbp), %rax
leaq -0xc370(%rbp), %rcx
cmpq %rcx, %rax
je 0x31548
movq -0xc378(%rbp), %rax
movq %rax, -0xc408(%rbp)
cmpq $0x0, %rax
je 0x31526
movq -0xc408(%rbp), %rdi
callq 0x4610
jmp 0x31548
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc3b0(%rbp)
movl %eax, -0xc3b4(%rbp)
leaq -0xc3a2(%rbp), %rdi
callq 0x4520
jmp 0x31574
movb $0x1, -0xc3a1(%rbp)
testb $0x1, -0xc3a1(%rbp)
jne 0x31564
movq -0xc3c8(%rbp), %rdi
callq 0x42f0
movq -0xc3c0(%rbp), %rax
addq $0xc410, %rsp           # imm = 0xC410
popq %rbp
retq
movq -0xc3b0(%rbp), %rdi
callq 0x47f0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x1224
jmp 0x11fb
movl -0x18(%rbp), %eax
subl $0x2c, %eax
je 0x1224
jmp 0x1205
movl -0x18(%rbp), %eax
subl $0x3a, %eax
je 0x12b5
jmp 0x1213
movl -0x18(%rbp), %eax
subl $0x7c, %eax
je 0x12dc
jmp 0x1304
movslq 0x2fe5(%rip), %rcx      # 0x4210
leaq 0x2e5e(%rip), %rax      # 0x4090
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x1263
movl -0x14(%rbp), %eax
movw %ax, %cx
movslq 0x2fc1(%rip), %rdx      # 0x4210
leaq 0x2e3a(%rip), %rax      # 0x4090
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x4(%rax)
jmp 0x1282
movl -0x14(%rbp), %eax
movw %ax, %cx
movslq 0x2fa0(%rip), %rdx      # 0x4210
leaq 0x2e19(%rip), %rax      # 0x4090
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x2(%rax)
movl 0x2f88(%rip), %eax      # 0x4210
addl $0x1, %eax
movl %eax, 0x2f7f(%rip)      # 0x4210
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x12b0
movl 0x2f66(%rip), %eax      # 0x4210
addq $0x20, %rsp
popq %rbp
retq
jmp 0x1339
movl -0x14(%rbp), %eax
movw %ax, %cx
movslq 0x2f4e(%rip), %rdx      # 0x4210
leaq 0x2dc7(%rip), %rax      # 0x4090
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movl $0x0, -0x14(%rbp)
jmp 0x1339
movl -0x14(%rbp), %eax
movw %ax, %cx
movslq 0x2f27(%rip), %rdx      # 0x4210
leaq 0x2da0(%rip), %rax      # 0x4090
imulq $0x6, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x2(%rax)
movl $0x0, -0x14(%rbp)
jmp 0x1339
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x131c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jge 0x1326
movl $0x1, %edi
callq 0x10b0
imull $0xa, -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11eb
nopw (%rax,%rax)
// File: exrok[P]evdoublebind/./src/evdoublebind.c
// Function: tap_mod_key
int tap_mod_key(__u16 key_code, __u16 mod_code, int fd){
    struct input_event buf[] = {{{0,0}, .type = EV_KEY, .code = mod_code, .value = 1},
                         {{0,0}, .type = EV_KEY, .code = key_code, .value = 1},
                         {{0,0}, .type = EV_KEY, .code = key_code, .value = 0},
                         {{0,0}, .type = EV_KEY, .code = mod_code, .value = 0},
                         {{0,0}, .type = EV_SYN, .code = SYN_REPORT, .value = 0}};
    return write(fd, buf, sizeof(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl %edx, -0x8(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x1040
movw $0x1, -0x70(%rbp)
movw -0x4(%rbp), %ax
movw %ax, -0x6e(%rbp)
movl $0x1, -0x6c(%rbp)
movw $0x1, -0x58(%rbp)
movw -0x2(%rbp), %ax
movw %ax, -0x56(%rbp)
movl $0x1, -0x54(%rbp)
movw $0x1, -0x40(%rbp)
movw -0x2(%rbp), %ax
movw %ax, -0x3e(%rbp)
movw $0x1, -0x28(%rbp)
movw -0x4(%rbp), %ax
movw %ax, -0x26(%rbp)
movl -0x8(%rbp), %edi
leaq -0x80(%rbp), %rsi
movl $0x78, %edx
callq 0x1030
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrok[P]evdoublebind/./src/evdoublebind.c
// Function: tap_key
int tap_key(__u16 key_code, int fd){
    struct input_event buf[] = {{{0,0}, .type = EV_KEY, .code = key_code, .value = 1},
                         {{0,0}, .type = EV_KEY, .code = key_code, .value = 0},
                         {{0,0}, .type = EV_SYN, .code = SYN_REPORT, .value = 0}};
    return write(fd, buf, sizeof(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x1040
movw $0x1, -0x40(%rbp)
movw -0x2(%rbp), %ax
movw %ax, -0x3e(%rbp)
movl $0x1, -0x3c(%rbp)
movw $0x1, -0x28(%rbp)
movw -0x2(%rbp), %ax
movw %ax, -0x26(%rbp)
movl -0x8(%rbp), %edi
leaq -0x50(%rbp), %rsi
movl $0x48, %edx
callq 0x1030
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrok[P]evdoublebind/./src/evdoublebind.c
// Function: open_input
int open_input(char * path) {
    int fd = open(path, O_RDWR);
    if (fd < 0) {
        perror("Error: Opening Keyboard");
        exit(1);
    }
    unsigned int key_repeat[2] = {2048,2048};
    ioctl(fd, EVIOCSREP, &key_repeat);
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x1090
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x154b
leaq 0xac8(%rip), %rdi       # 0x2004
callq 0x1350
movl $0x1, %edi
callq 0x10b0
movq 0xb4a(%rip), %rax       # 0x209c
movq %rax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl $0x40084503, %esi       # imm = 0x40084503
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)