LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: delimiter::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void delimiter::display(string s){
    if (argc == 3){
        outfile << left << setw(30) << "Delimiter" << left << setw(30) << s << endl;        
    }else{
        cout << left << setw(30) << "Delimiter" << left << setw(30) << s << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7ed9(%rip), %rax      # 0xe234
cmpl $0x3, (%rax)
jne 0x63ef
leaq 0x7ed5(%rip), %rdi      # 0xe240
leaq -0x2f02(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x38(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x2cc1(%rip), %rsi      # 0x905f
callq 0x21d0
movq %rax, %rdi
leaq -0x2f3d(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x30(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x7bc3(%rip), %rsi      # 0xdfa8
callq 0x2220
jmp 0x6475
movq 0x7bd2(%rip), %rdi      # 0xdfc8
leaq -0x2f8d(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x2c36(%rip), %rsi      # 0x905f
callq 0x21d0
movq %rax, %rdi
leaq -0x2fc8(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x7b38(%rip), %rsi      # 0xdfa8
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: keyword::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void keyword::display(string s){
    if (argc == 3){
        outfile << left << setw(30) << "Keyword" << left << setw(30) << s << endl;
    }else {
        cout << left << setw(30) << "Keyword" << left << setw(30) << s << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7c89(%rip), %rax      # 0xe234
cmpl $0x3, (%rax)
jne 0x663f
leaq 0x7c85(%rip), %rdi      # 0xe240
leaq -0x3152(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x38(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x2a7b(%rip), %rsi      # 0x9069
callq 0x21d0
movq %rax, %rdi
leaq -0x318d(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x30(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x7973(%rip), %rsi      # 0xdfa8
callq 0x2220
jmp 0x66c5
movq 0x7982(%rip), %rdi      # 0xdfc8
leaq -0x31dd(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x29f0(%rip), %rsi      # 0x9069
callq 0x21d0
movq %rax, %rdi
leaq -0x3218(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x78e8(%rip), %rsi      # 0xdfa8
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/dns.c
// Function: write_record_ns
int static write_record_ns(unsigned char** outpos, const unsigned char *outend, char *name, int offset, dns_class cls, int ttl, const char *ns) {
  unsigned char *oldpos = *outpos;
  int ret = write_record(outpos, outend, name, offset, TYPE_NS, cls, ttl);
  if (ret) return ret;
  int error = 0;
  if (outend - *outpos < 2) { error = -5; goto error; }
  (*outpos) += 2;
  unsigned char *curpos = *outpos;
  ret = write_name(outpos, outend, ns, -1);
  if (ret) { error = ret; goto error; }
  curpos[-2] = (*outpos - curpos) >> 8;
  curpos[-1] = (*outpos - curpos) & 0xFF;
  return 0;
error:
  *outpos = oldpos;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r9d
movl -0x2c(%rbp), %eax
movl $0x2, %r8d
movl %eax, (%rsp)
callq 0x65c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x5e96
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5f4f
movl $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jge 0x5ebd
movl $0xfffffffb, -0x40(%rbp) # imm = 0xFFFFFFFB
jmp 0x5f3e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x6750
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x5efd
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x5f3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
sarq $0x8, %rax
movb %al, %cl
movq -0x48(%rbp), %rax
movb %cl, -0x2(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x48(%rbp), %rax
movb %cl, -0x1(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5f4f
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/dns.c
// Function: write_record_a
int static write_record_a(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const addr_t *ip) {
  if (ip->v != 4)
     return -6;
  unsigned char *oldpos = *outpos;
  int error = 0;
  int ret = write_record(outpos, outend, name, offset, TYPE_A, cls, ttl);
  if (ret) return ret;
  if (outend - *outpos < 6) { error = -5; goto error; }
  // rdlength
  *((*outpos)++) = 0; *((*outpos)++) = 4;
  // rdata
  for (int i=0; i<4; i++)
    *((*outpos)++) = ip->data.v4[i];
  return 0;
error:
  *outpos = oldpos;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0x6398
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x6478
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r9d
movl -0x2c(%rbp), %eax
movl $0x1, %r8d
movl %eax, (%rsp)
callq 0x65c0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x63e2
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6478
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x6, %rax
jge 0x63ff
movl $0xfffffffb, -0x3c(%rbp) # imm = 0xFFFFFFFB
jmp 0x6467
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x4, (%rax)
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x645e
movq 0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movb 0x4(%rax,%rcx), %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x642e
movl $0x0, -0x4(%rbp)
jmp 0x6478
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/dns.c
// Function: write_record_aaaa
int static write_record_aaaa(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const addr_t *ip) {
  if (ip->v != 6)
     return -6;
  unsigned char *oldpos = *outpos;
  int error = 0;
  int ret = write_record(outpos, outend, name, offset, TYPE_AAAA, cls, ttl);
  if (ret) return ret;
  if (outend - *outpos < 6) { error = -5; goto error; }
  // rdlength
  *((*outpos)++) = 0; *((*outpos)++) = 16;
  // rdata
  for (int i=0; i<16; i++)
    *((*outpos)++) = ip->data.v6[i];
  return 0;
error:
  *outpos = oldpos;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x64c8
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x65a8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r9d
movl -0x2c(%rbp), %eax
movl $0x1c, %r8d
movl %eax, (%rsp)
callq 0x65c0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x6512
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x65a8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x6, %rax
jge 0x652f
movl $0xfffffffb, -0x3c(%rbp) # imm = 0xFFFFFFFB
jmp 0x6597
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x10, (%rax)
movl $0x0, -0x44(%rbp)
cmpl $0x10, -0x44(%rbp)
jge 0x658e
movq 0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movb 0x4(%rax,%rcx), %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x655e
movl $0x0, -0x4(%rbp)
jmp 0x65a8
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/dns.c
// Function: write_record
int static write_record(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_type typ, dns_class cls, int ttl) {
  unsigned char *oldpos = *outpos;
  int error = 0;
  // name
  int ret = write_name(outpos, outend, name, offset);
  if (ret) { error = ret; goto error; }
  if (outend - *outpos < 8) { error = -4; goto error; }
  // type
  *((*outpos)++) = typ >> 8; *((*outpos)++) = typ & 0xFF;
  // class
  *((*outpos)++) = cls >> 8; *((*outpos)++) = cls & 0xFF;
  // ttl
  *((*outpos)++) = (ttl >> 24) & 0xFF; *((*outpos)++) = (ttl >> 16) & 0xFF; *((*outpos)++) = (ttl >> 8) & 0xFF; *((*outpos)++) = ttl & 0xFF;
  return 0;
error:
  *outpos = oldpos;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x6750
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x661c
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x6732
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x8, %rax
jge 0x663c
movl $0xfffffffc, -0x3c(%rbp) # imm = 0xFFFFFFFC
jmp 0x6732
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x28(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl 0x10(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl 0x10(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl 0x10(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl 0x10(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6743
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: TestNode(CService const&, int&, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&, std::vector<CAddress, std::allocator<CAddress>>*)
bool TestNode(const CService &cip, int &ban, int &clientV, std::string &clientSV, int &blocks, vector<CAddress>* vAddr) {
  try {
    CNode node(cip, vAddr);
    bool ret = node.Run();
    if (!ret) {
      ban = node.GetBan();
    } else {
      ban = 0;
    }
    clientV = node.GetClientVersion();
    clientSV = node.GetClientSubVersion();
    blocks = node.GetStartingHeight();
  //printf("%s: %s!!!\n", cip.ToString().c_str(), ret ? "GOOD" : "BAD");
    return ret;
  } catch(std::ios_base::failure& e) {
    ban = 0;
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x108(%rbp), %rdi
callq 0x6af0
jmp 0x6959
leaq -0x108(%rbp), %rdi
callq 0x6ca0
movb %al, -0x141(%rbp)
jmp 0x696d
movb -0x141(%rbp), %al
andb $0x1, %al
movb %al, -0x115(%rbp)
testb $0x1, -0x115(%rbp)
jne 0x6a1a
leaq -0x108(%rbp), %rdi
callq 0x6fb0
movl %eax, -0x148(%rbp)
jmp 0x699c
movl -0x148(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6a24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x69dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x7040
movl -0x114(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6ac1
movq -0x110(%rbp), %rdi
callq 0x41d0
movq %rax, -0x140(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, -0x1(%rbp)
callq 0x4780
jmp 0x6ab3
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
leaq -0x108(%rbp), %rdi
callq 0x6fd0
movl %eax, -0x14c(%rbp)
jmp 0x6a38
movl -0x14c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
leaq -0x138(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x6ff0
jmp 0x6a59
movq -0x28(%rbp), %rdi
leaq -0x138(%rbp), %rsi
movq %rsi, -0x158(%rbp)
callq 0x45d0
movq -0x158(%rbp), %rdi
callq 0x42f0
leaq -0x108(%rbp), %rdi
callq 0x7020
movl %eax, -0x150(%rbp)
jmp 0x6a90
movl -0x150(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movb -0x115(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x7040
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x47f0
nopl (%rax)
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::CNode(CService const&, std::vector<CAddress, std::allocator<CAddress>>*)
CNode(const CService& ip, vector<CAddress>* vAddrIn) : you(ip), nHeaderStart(-1), nMessageStart(-1), vAddr(vAddrIn), ban(0), doneAfter(0), nVersion(0) {
    vSend.SetType(SER_NETWORK);
    vSend.SetVersion(0);
    vRecv.SetType(SER_NETWORK);
    vRecv.SetVersion(0);
    if (time(NULL) > 1329696000) {
      vSend.SetVersion(209);
      vRecv.SetVersion(209);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq %rdi, -0x60(%rbp)
movl $0x1, %esi
movl %esi, -0x50(%rbp)
movl $0x11500, %edx          # imm = 0x11500
movl %edx, -0x4c(%rbp)
callq 0x7080
movq -0x58(%rbp), %rdi
movl -0x50(%rbp), %esi
movl -0x4c(%rbp), %edx
addq $0x30, %rdi
movq %rdi, -0x48(%rbp)
callq 0x7080
jmp 0x6b45
movq -0x58(%rbp), %rdi
movl $0xffffffff, 0x58(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x5c(%rdi) # imm = 0xFFFFFFFF
movl $0x0, 0x60(%rdi)
addq $0x68, %rdi
movq %rdi, -0x68(%rbp)
callq 0x46b0
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x90(%rdi)
movl $0x0, 0x98(%rdi)
movq $0x0, 0xa0(%rdi)
addq $0xa8, %rdi
movq -0x10(%rbp), %rax
movw 0x10(%rax), %cx
movw %cx, -0x30(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movw -0x30(%rbp), %cx
movq %rsp, %rax
movw %cx, 0x10(%rax)
movaps -0x40(%rbp), %xmm0
movups %xmm0, (%rax)
movl $0x1, %esi
callq 0x188f0
jmp 0x6bc7
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x70e0
jmp 0x6bdb
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x7100
jmp 0x6bec
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0x70e0
jmp 0x6c00
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x7100
jmp 0x6c11
xorl %eax, %eax
movl %eax, %edi
callq 0x44a0
cmpq $0x4f418d00, %rax       # imm = 0x4F418D00
jle 0x6c7a
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movl $0xd1, %esi
callq 0x7100
jmp 0x6c36
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movl $0xd1, %esi
callq 0x7100
jmp 0x6c4a
jmp 0x6c7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6c83
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x42f0
movq -0x48(%rbp), %rdi
callq 0x7120
jmp 0x6c83
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x7120
movq -0x20(%rbp), %rdi
callq 0x47f0
nopw %cs:(%rax,%rax)
nop
// File: tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::Init(int, int)
void Init(int nTypeIn=SER_NETWORK, int nVersionIn=PROTOCOL_VERSION)
    {
        nReadPos = 0;
        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)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x18(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x24(%rax)
movw $0x0, 0x1c(%rax)
movl $0x1, %edi
movl $0x4, %esi
callq 0x72a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movw %cx, 0x1e(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: secure_allocator<char>::deallocate(char*, unsigned long)
void deallocate(T* p, std::size_t n)
    {
        if (p != NULL)
        {
            memset(p, 0, sizeof(T) * n);
            munlock(p, sizeof(T) * n);
        }
        std::allocator<T>::deallocate(p, n);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x752d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x4270
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x4340
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x0, %rcx
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x4340
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
orq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1e, %edi
callq 0x4340
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
subq %rax, %rsi
callq 0x4870
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7550
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::PushVersion()
void PushVersion() {
    int64 nTime = time(NULL);
    uint64 nLocalNonce = BITCOIN_SEED_NONCE;
    int64 nLocalServices = 0;
    CAddress me(CService("0.0.0.0"));
    BeginMessage("version");
    int nBestHeight = GetRequireHeight();
    string ver = "/tenup-seeder:0.01/";
    vSend << PROTOCOL_VERSION << nLocalServices << nTime << you << me << nLocalNonce << ver << nBestHeight;
    EndMessage();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
xorl %eax, %eax
movl %eax, -0xb4(%rbp)
movl %eax, %edi
callq 0x44a0
movl -0xb4(%rbp), %edx
movq %rax, -0x10(%rbp)
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x2ba54(%rip), %rsi     # 0x33024
leaq -0x60(%rbp), %rdi
callq 0x14880
movw -0x50(%rbp), %cx
movq %rsp, %rax
movw %cx, 0x10(%rax)
movups -0x60(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x188f0
movq -0xb0(%rbp), %rdi
leaq 0x2ba25(%rip), %rsi     # 0x3302c
callq 0x8010
leaq 0x42f8d(%rip), %rax     # 0x4a5a0
movzbl (%rax), %edi
andl $0x1, %edi
callq 0x6ad0
movl %eax, -0x64(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4800
movq -0xa8(%rbp), %rdx
leaq 0x2b9f2(%rip), %rsi     # 0x33034
leaq -0x88(%rbp), %rdi
callq 0x4690
jmp 0x7650
leaq -0x89(%rbp), %rdi
callq 0x4520
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2bc02(%rip), %rsi     # 0x33270
callq 0x8090
movq %rax, -0xc0(%rbp)
jmp 0x767c
movq -0xc0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x80d0
movq %rax, -0xc8(%rbp)
jmp 0x7695
movq -0xc8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x80d0
movq %rax, -0xd0(%rbp)
jmp 0x76ae
movq -0xd0(%rbp), %rdi
movq -0xb0(%rbp), %rsi
addq $0xa8, %rsi
callq 0x8110
movq %rax, -0xd8(%rbp)
jmp 0x76d1
movq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8110
movq %rax, -0xe0(%rbp)
jmp 0x76ea
movq -0xe0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8150
movq %rax, -0xe8(%rbp)
jmp 0x7703
movq -0xe8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8190
movq %rax, -0xf0(%rbp)
jmp 0x771f
movq -0xf0(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x8090
jmp 0x7731
movq -0xb0(%rbp), %rdi
callq 0x81d0
jmp 0x773f
leaq -0x88(%rbp), %rdi
callq 0x42f0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x4520
jmp 0x7792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x42f0
movq -0x98(%rbp), %rdi
callq 0x47f0
nop
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::Send()
void Send() {
    if (sock == INVALID_SOCKET) return;
    if (vSend.empty()) return;
    int nBytes = send(sock, &vSend[0], vSend.size(), 0);
    if (nBytes > 0) {
      vSend.erase(vSend.begin(), vSend.begin() + nBytes);
    } else {
      close(sock);
      sock = INVALID_SOCKET;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $-0x1, (%rax)
jne 0x77be
jmp 0x7881
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xa300
testb $0x1, %al
jne 0x77d1
jmp 0x77d6
jmp 0x7881
movq -0x38(%rbp), %rdi
movl (%rdi), %eax
movl %eax, -0x44(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7940
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x78d0
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x4240
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x786c
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x8, %rdi
callq 0xa1f0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0xa1f0
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x88b0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa330
movq %rax, -0x30(%rbp)
jmp 0x7881
movq -0x38(%rbp), %rax
movl (%rax), %edi
callq 0x48c0
movq -0x38(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::GetTimeout()
int GetTimeout() {
      if (you.IsTor())
          return 120;
      else
          return 30;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
callq 0x13580
testb $0x1, %al
jne 0x78b2
jmp 0x78bb
movl $0x78, -0x4(%rbp)
jmp 0x78c2
movl $0x1e, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::BeginMessage(char const*)
void BeginMessage(const char *pszCommand) {
    if (nHeaderStart != -1) AbortMessage();
    nHeaderStart = vSend.size();
    vSend << CMessageHeader(pszCommand, 0);
    nMessageStart = vSend.size();
    //printf("%s: SEND %s\n", ToString(you).c_str(), pszCommand); 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $-0x1, 0x58(%rax)
je 0x8037
movq -0x30(%rbp), %rdi
callq 0x8300
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x78d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl %ecx, 0x58(%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x185e0
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8350
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x78d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl %ecx, 0x5c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::EndMessage()
void EndMessage() {
    if (nHeaderStart == -1) return;
    unsigned int nSize = vSend.size() - nMessageStart;
    memcpy((char*)&vSend[nHeaderStart] + offsetof(CMessageHeader, nMessageSize), &nSize, sizeof(nSize));
    if (vSend.GetVersion() >= 209) {
      uint256 hash = Hash(vSend.begin() + nMessageStart, vSend.end());
      unsigned int nChecksum = 0;
      memcpy(&nChecksum, &hash, sizeof(nChecksum));
      assert(nMessageStart - nHeaderStart >= offsetof(CMessageHeader, nChecksum) + sizeof(nChecksum));
      memcpy((char*)&vSend[nHeaderStart] + offsetof(CMessageHeader, nChecksum), &nChecksum, sizeof(nChecksum));
    }
    nHeaderStart = -1;
    nMessageStart = -1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $-0x1, 0x58(%rax)
jne 0x81ef
jmp 0x82f4
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x78d0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl 0x5c(%rax), %edx
subq %rdx, %rcx
movl %ecx, -0xc(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movl 0x58(%rax), %eax
movl %eax, %esi
callq 0x7940
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x8, %rdi
callq 0xa130
cmpl $0xd1, %eax
jl 0x82e2
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0xa1f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x40(%rbp)
movl 0x5c(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x88b0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0xa230
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x2c(%rbp), %rdi
callq 0xa150
movq -0x58(%rbp), %rcx
movl $0x0, -0x4c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl 0x5c(%rcx), %eax
subl 0x58(%rcx), %eax
movl %eax, %eax
cmpq $0x18, %rax
jb 0x82a8
jmp 0x82c7
leaq 0x2adfd(%rip), %rdi     # 0x330ac
leaq 0x2ae4e(%rip), %rsi     # 0x33104
movl $0x39, %edx
leaq 0x2ae4e(%rip), %rcx     # 0x33110
callq 0x4350
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl 0x58(%rax), %eax
movl %eax, %esi
callq 0x7940
movl -0x4c(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x58(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::AbortMessage()
void AbortMessage() {
    if (nHeaderStart == -1) return;
    vSend.resize(nHeaderStart);
    nHeaderStart = -1;
    nMessageStart = -1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $-0x1, 0x58(%rax)
jne 0x831c
jmp 0x8345
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl 0x58(%rax), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7900
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: secure_allocator<char>::allocate(unsigned long, void const*)
T* allocate(std::size_t n, const void *hint = 0)
    {
        T *p;
        p = std::allocator<T>::allocate(n, hint);
        if (p != NULL)
            mlock(p, sizeof(T) * n);
        return p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9b10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9af7
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x4340
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x0, %rcx
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x4340
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
orq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1e, %edi
callq 0x4340
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
subq %rax, %rsi
callq 0x4660
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: void WriteCompactSize<CDataStream>(CDataStream&, unsigned long long)
void WriteCompactSize(Stream& os, uint64 nSize)
{
    if (nSize < 253)
    {
        unsigned char chSize = nSize;
        WRITEDATA(os, chSize);
    }
    else if (nSize <= USHRT_MAX)
    {
        unsigned char chSize = 253;
        unsigned short xSize = nSize;
        WRITEDATA(os, chSize);
        WRITEDATA(os, xSize);
    }
    else if (nSize <= UINT_MAX)
    {
        unsigned char chSize = 254;
        unsigned int xSize = nSize;
        WRITEDATA(os, chSize);
        WRITEDATA(os, xSize);
    }
    else
    {
        unsigned char chSize = 255;
        uint64 xSize = nSize;
        WRITEDATA(os, chSize);
        WRITEDATA(os, xSize);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0xfd, -0x10(%rbp)
jae 0xa078
movq -0x10(%rbp), %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x8610
jmp 0xa124
cmpq $0xffff, -0x10(%rbp)    # imm = 0xFFFF
ja 0xa0b4
movb $-0x3, -0x12(%rbp)
movq -0x10(%rbp), %rax
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x8610
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x2, %edx
callq 0x8610
jmp 0xa122
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x10(%rbp)
ja 0xa0f0
movb $-0x2, -0x15(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x8610
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x8610
jmp 0xa120
movb $-0x1, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x8610
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x8610
jmp 0xa122
jmp 0xa124
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tenup-coin[P]seeder/./util.h
// Function: uint256 Hash<__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>)
inline uint256 Hash(const T1 pbegin, const T1 pend)
{
    static unsigned char pblank[1];
    uint256 hash1;
    SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);
    uint256 hash2;
    SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
    return hash2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa260
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa2a0
testb $0x1, %al
jne 0xa184
jmp 0xa191
leaq 0x40366(%rip), %rax     # 0x4a4f1
movq %rax, -0x48(%rbp)
jmp 0xa1a2
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2e0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x8e70
movq -0x50(%rbp), %rdi
movq %rax, %rsi
shlq $0x0, %rsi
leaq -0x30(%rbp), %rdx
callq 0x4620
movq -0x40(%rbp), %rdi
callq 0xa260
movq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x4620
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::erase(__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>)
iterator erase(iterator first, iterator last)
    {
        if (first == vch.begin() + nReadPos)
        {
            // special case for erasing from the front
            if (last == vch.end())
            {
                nReadPos = 0;
                return vch.erase(vch.begin(), vch.end());
            }
            else
            {
                nReadPos = (last - vch.begin());
                return last;
            }
        }
        else
            return vch.erase(first, last);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8880
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl 0x18(%rax), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x88b0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa2a0
testb $0x1, %al
jne 0xa387
jmp 0xa427
movq -0x78(%rbp), %rdi
callq 0x8740
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa2a0
testb $0x1, %al
jne 0xa3a7
jmp 0xa3f9
movq -0x78(%rbp), %rdi
movl $0x0, 0x18(%rdi)
callq 0x8880
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8770
movq -0x78(%rbp), %rdi
callq 0x8740
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8770
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xa470
movq %rax, -0x8(%rbp)
jmp 0xa456
movq -0x78(%rbp), %rdi
callq 0x8880
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8e70
movq %rax, %rcx
movq -0x78(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa456
leaq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8770
leaq -0x70(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8770
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0xa470
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::insert(__gnu_cxx::__normal_iterator<char*, std::vector<char, secure_allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>)
void insert(iterator it, std::vector<char>::const_iterator first, std::vector<char>::const_iterator last)
    {
        if (it == vch.begin() + nReadPos && last - first <= nReadPos)
        {
            // special case for inserting at the front when there's room
            nReadPos -= (last - first);
            memcpy(&vch[nReadPos], &first[0], last - first);
        }
        else
            vch.insert(it, first, last);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x8880
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl 0x18(%rax), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x88b0
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa2a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0xb29d
jmp 0xb2ba
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xcd10
movq -0x60(%rbp), %rcx
movl 0x18(%rcx), %ecx
cmpq %rcx, %rax
setle %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xb2c3
jmp 0xb31e
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xcd10
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl 0x18(%rdi), %eax
subq %rcx, %rax
movl %eax, 0x18(%rdi)
movl 0x18(%rdi), %eax
movl %eax, %esi
callq 0xb090
movq %rax, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcd50
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xcd10
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x4420
jmp 0xb354
leaq -0x38(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x8770
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xcd70
movq %rax, -0x50(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::ignore(int)
CDataStream& ignore(int nSize)
    {
        // Ignore from the beginning of the buffer
        assert(nSize >= 0);
        unsigned int nReadPosNext = nReadPos + nSize;
        if (nReadPosNext >= vch.size())
        {
            if (nReadPosNext > vch.size())
            {
                setstate(std::ios::failbit, "CDataStream::ignore() : end of data");
                nSize = vch.size() - nReadPos;
            }
            nReadPos = 0;
            vch.clear();
            return (*this);
        }
        nReadPos = nReadPosNext;
        return (*this);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xb4cf
jmp 0xb4ee
leaq 0x27b72(%rip), %rdi     # 0x33048
leaq 0x27b76(%rip), %rsi     # 0x33053
movl $0x42a, %edx            # imm = 0x42A
leaq 0x27cd6(%rip), %rcx     # 0x331bf
callq 0x4350
movq -0x20(%rbp), %rdi
movl 0x18(%rdi), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x9870
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0xb574
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x9870
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0xb55a
movq -0x20(%rbp), %rdi
movl $0x4, %esi
leaq 0x27ca6(%rip), %rdx     # 0x331e5
callq 0xcb40
movq -0x20(%rbp), %rdi
callq 0x9870
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl $0x0, 0x18(%rdi)
callq 0xcc00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb582
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: CDataStream::read(char*, int)
CDataStream& read(char* pch, int nSize)
    {
        // Read from the beginning of the buffer
        assert(nSize >= 0);
        unsigned int nReadPosNext = nReadPos + nSize;
        if (nReadPosNext >= vch.size())
        {
            if (nReadPosNext > vch.size())
            {
                setstate(std::ios::failbit, "CDataStream::read() : end of data");
                memset(pch, 0, nSize);
                nSize = vch.size() - nReadPos;
            }
            memcpy(pch, &vch[nReadPos], nSize);
            nReadPos = 0;
            vch.clear();
            return (*this);
        }
        memcpy(pch, &vch[nReadPos], nSize);
        nReadPos = nReadPosNext;
        return (*this);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xca23
jmp 0xca42
leaq 0x2661e(%rip), %rdi     # 0x33048
leaq 0x26622(%rip), %rsi     # 0x33053
movl $0x413, %edx            # imm = 0x413
leaq 0x26734(%rip), %rcx     # 0x33171
callq 0x4350
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x9870
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0xcb01
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x9870
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0xcac1
movq -0x28(%rbp), %rdi
movl $0x4, %esi
leaq 0x26706(%rip), %rdx     # 0x3319d
callq 0xcb40
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
xorl %esi, %esi
callq 0x4270
movq -0x28(%rbp), %rdi
callq 0x9870
movq -0x28(%rbp), %rcx
movl 0x18(%rcx), %ecx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x18(%rdi), %eax
movl %eax, %esi
callq 0xb090
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x4420
movq -0x28(%rbp), %rdi
movl $0x0, 0x18(%rdi)
callq 0xcc00
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb35
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x18(%rdi), %eax
movl %eax, %esi
callq 0xb090
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x4420
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: tenup-coin[P]seeder/bitcoin.cpp
// Function: CNode::GotVersion()
void GotVersion() {
     //printf("\n%s: version %i\n", ToString(you).c_str(), nVersion);
    if (vAddr) {
      BeginMessage("getaddr");
      EndMessage();
      doneAfter = time(NULL) + GetTimeout();
    } else {
      doneAfter = time(NULL) + 1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x90(%rax)
je 0xddb6
movq -0x10(%rbp), %rdi
leaq 0x254ba(%rip), %rsi     # 0x33233
callq 0x8010
movq -0x10(%rbp), %rdi
callq 0x81d0
xorl %eax, %eax
movl %eax, %edi
callq 0x44a0
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x7890
movq -0x18(%rbp), %rcx
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0xa0(%rax)
jmp 0xddd1
xorl %eax, %eax
movl %eax, %edi
callq 0x44a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq $0x1, %rcx
movq %rcx, 0xa0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: void Unserialize<CDataStream, char>(CDataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int)
void Unserialize(Stream& is, std::basic_string<C>& str, int, int)
{
    unsigned int nSize = ReadCompactSize(is);
    str.resize(nSize);
    if (nSize != 0)
        is.read((char*)&str[0], nSize * sizeof(str[0]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe4a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x46a0
cmpl $0x0, -0x1c(%rbp)
je 0xe490
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x48e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %eax
shlq $0x0, %rax
movl %eax, %edx
callq 0xca00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tenup-coin[P]seeder/./serialize.h
// Function: unsigned long long ReadCompactSize<CDataStream>(CDataStream&)
uint64 ReadCompactSize(Stream& is)
{
    unsigned char chSize;
    READDATA(is, chSize);
    uint64 nSizeRet = 0;
    if (chSize < 253)
    {
        nSizeRet = chSize;
    }
    else if (chSize == 253)
    {
        unsigned short xSize;
        READDATA(is, xSize);
        nSizeRet = xSize;
    }
    else if (chSize == 254)
    {
        unsigned int xSize;
        READDATA(is, xSize);
        nSizeRet = xSize;
    }
    else
    {
        uint64 xSize;
        READDATA(is, xSize);
        nSizeRet = xSize;
    }
    if (nSizeRet > (uint64)MAX_SIZE)
        throw std::ios_base::failure("ReadCompactSize() : size too large");
    return nSizeRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0xca00
movq $0x0, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0xfd, %eax
jge 0xe4db
movzbl -0x9(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0xe546
movzbl -0x9(%rbp), %eax
cmpl $0xfd, %eax
jne 0xe502
movq -0x8(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
movl $0x2, %edx
callq 0xca00
movzwl -0x1a(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0xe544
movzbl -0x9(%rbp), %eax
cmpl $0xfe, %eax
jne 0xe528
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xca00
movl -0x20(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0xe542
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0xca00
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xe544
jmp 0xe546
cmpq $0x2000000, -0x18(%rbp) # imm = 0x2000000
jbe 0xe5b8
movl $0x20, %edi
callq 0x4230
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x1, %esi
callq 0xcc20
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x24c8d(%rip), %rsi     # 0x33210
callq 0x41a0
jmp 0xe58a
movq -0x60(%rbp), %rdi
movq 0x3b9db(%rip), %rsi     # 0x49f70
movq 0x3ba14(%rip), %rdx     # 0x49fb0
callq 0x47e0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x43a0
jmp 0xe5c2
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x47f0
nopl (%rax,%rax)