LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::purgeCache()
void DNSResolver::purgeCache() {
    time_t now = time(NULL);
    std::map<unsigned, std::pair<std::string, uint16_t> > sortedcache;

    if (sortedcache.size() > MAX_CACHE_ENTRIES) {
        /* Cleanup cached queries */
        auto itc = cached.begin();
        while (itc != cached.end()) {
            // Halve hits to allow new domains some opportunity
            itc->second.hits >>= 4;
            if (itc->second.expire < now)
                itc = cached.erase(itc);
            else {
                sortedcache.emplace(itc->second.hits, itc->first);
                itc++;
            }
        }

        while (sortedcache.size() > MAX_CACHE_ENTRIES - CACHE_PURGE_STEP) {
            cached.erase(sortedcache.begin()->second);
            sortedcache.erase(sortedcache.begin());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3310
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9eb0
leaq -0x40(%rbp), %rdi
callq 0x9ed0
cmpq $0x10000, %rax          # imm = 0x10000
jbe 0x6860
movq -0xa8(%rbp), %rdi
addq $0xa0, %rdi
callq 0x9ef0
movq %rax, -0x48(%rbp)
movq -0xa8(%rbp), %rdi
addq $0xa0, %rdi
callq 0x9a80
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x99e0
testb $0x1, %al
jne 0x66c9
jmp 0x67bc
leaq -0x48(%rbp), %rdi
callq 0x9f20
movl 0x48(%rax), %ecx
shrl $0x4, %ecx
movl %ecx, 0x48(%rax)
leaq -0x48(%rbp), %rdi
callq 0x9f20
movq 0x40(%rax), %rax
cmpq -0x10(%rbp), %rax
jge 0x6748
movq -0xa8(%rbp), %rdi
addq $0xa0, %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x9f40
movq %rax, -0xb0(%rbp)
jmp 0x6716
movq -0xb0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x67b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa0d0
jmp 0x6872
leaq -0x48(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x9f20
movq -0xd0(%rbp), %rdi
addq $0x48, %rax
movq %rax, -0xc8(%rbp)
callq 0x9f20
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
leaq -0x40(%rbp), %rdi
callq 0x9f80
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x6791
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x9fd0
movq %rax, -0x88(%rbp)
jmp 0x669c
jmp 0x67be
leaq -0x40(%rbp), %rdi
callq 0x9ed0
cmpq $0xc000, %rax           # imm = 0xC000
jbe 0x685e
movq -0xa8(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0xd8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa040
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xa070
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xa010
jmp 0x6818
leaq -0x40(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xa040
movq -0xe8(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rsi
callq 0xa090
movq %rax, -0xe0(%rbp)
jmp 0x684b
movq -0xe0(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x67be
jmp 0x6860
leaq -0x40(%rbp), %rdi
callq 0xa0d0
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::call_user_rec(Query*, dns_error)
void DNSResolver::call_user_rec(Query *q, enum dns_error err) {
    // If this query has dependencies don't report it
    for (auto de: q->deps)
        call_user_rec(de, err);

    call_user(this, q->name, q->qtype, NULL, q->callback, q->ctx, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa2c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa2f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa320
testb $0x1, %al
jne 0x70e7
jmp 0x7112
leaq -0x28(%rbp), %rdi
callq 0xa350
movq -0x70(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x7090
leaq -0x28(%rbp), %rdi
callq 0xa410
jmp 0x70d4
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3160
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movzwl 0xc(%rax), %edx
movq 0x30(%rax), %r9
movq 0x38(%rax), %r8
movl -0x14(%rbp), %ecx
movq %rsp, %rax
movl %ecx, (%rax)
xorl %eax, %eax
movl %eax, %ecx
callq 0x7190
jmp 0x7152
leaq -0x58(%rbp), %rdi
callq 0x3200
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3200
movq -0x60(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: call_user(DNSResolver*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, cache_entry const*, void (*)(dns_cb_data*), void*, dns_error)
static void
call_user(DNSResolver *dns, std::string name, uint16_t qtype, 
          const struct cache_entry *entry, dns_callback_t cb, void *ctx, enum dns_error error)
{
    struct dns_cb_data cbd;
    cbd.context = ctx;
    cbd.query_type = (enum dns_record_type) qtype;
    cbd.error = error;
    cbd.name = name;

    if (entry)
        cbd.replies = entry->replies;

    if (cb)
        cb(&cbd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x90(%rbp)
movw %dx, %ax
movl 0x10(%rbp), %edx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb070
movq -0x90(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movzwl -0x12(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3040
jmp 0x71f0
cmpq $0x0, -0x20(%rbp)
je 0x7222
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3dd0
jmp 0x7206
jmp 0x7222
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb1a0
jmp 0x7249
cmpq $0x0, -0x28(%rbp)
je 0x7237
movq -0x28(%rbp), %rax
leaq -0x78(%rbp), %rdi
callq *%rax
jmp 0x7235
jmp 0x7237
leaq -0x78(%rbp), %rdi
callq 0xb1a0
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::createQuery(unsigned int, void*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, dns_record_type, void (*)(dns_cb_data*))
Query * DNSResolver::createQuery(unsigned niter, void *ctx, std::string name,
                    enum dns_record_type qtype, dns_callback_t callback) {

    std::transform(name.begin(), name.end(), name.begin(), ::tolower);

    time_t now = time(NULL);
    Query * query = new Query();
    query->ctx = ctx;
    query->qtype = (uint16_t) qtype;
    query->callback = callback;
    query->atimeout = now + this->atimeout;
    query->niter = niter + 1;
    query->name = name;

    return query;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rcx, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x32f0
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x31d0
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x32f0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x1d240(%rip), %rcx     # 0x25fd8
callq 0xadb0
movq %rax, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3310
movq %rax, -0x58(%rbp)
movl $0x78, %edi
callq 0x3350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0xaff0
jmp 0x8dc9
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq -0x18(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq %rdx, 0x30(%rcx)
movl -0x24(%rbp), %ecx
movw %cx, %dx
movq -0x60(%rbp), %rcx
movw %dx, 0xc(%rcx)
movq -0x30(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq %rdx, 0x38(%rcx)
movq -0x58(%rbp), %rcx
movl 0xd0(%rax), %eax
addq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0x3040
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x78, %esi
callq 0x3360
movq -0x68(%rbp), %rdi
callq 0x3530
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::getNewTid()
uint16_t DNSResolver::getNewTid() {
    while(1) {
        uint16_t n = ++tidseq;
        if (active.count(n) == 0)
            return n;
        std::cout << "Dup!" << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movw 0x10(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x10(%rdi)
movw %ax, -0xa(%rbp)
addq $0x38, %rdi
leaq -0xa(%rbp), %rsi
callq 0xb040
cmpq $0x0, %rax
jne 0x91c5
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
movq 0x1cdfc(%rip), %rdi     # 0x25fc8
leaq 0xffdf(%rip), %rsi      # 0x191b2
callq 0x3330
movq %rax, %rdi
movq 0x1cdd6(%rip), %rsi     # 0x25fb8
callq 0x3390
jmp 0x9194
nopl (%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::DNSResolver(std::__cxx11::list<sockaddr_storage, std::allocator<sockaddr_storage>>, unsigned int)
DNSResolver(std::list<struct sockaddr_storage> serverbundle, unsigned atimeout)
      : pkts_dns_servers(0), pkts_auth_servers(0), dns_servers(serverbundle), atimeout(atimeout) {
        this->sock4 = socket(PF_INET,  SOCK_DGRAM, 17);
        this->sock6 = socket(PF_INET6, SOCK_DGRAM, 17);
        /* Make it non blocking */
        nonblock(sock4);
        nonblock(sock6);
        /* Increase socket's receive buffer */
        int rcvbufsiz = 128 * 1024;
        (void) setsockopt(sock4, SOL_SOCKET, SO_RCVBUF,
            (char *) &rcvbufsiz, sizeof(rcvbufsiz));
        (void) setsockopt(sock6, SOL_SOCKET, SO_RCVBUF,
            (char *) &rcvbufsiz, sizeof(rcvbufsiz));
        tidseq = 0;
        active.rehash(MAX_CACHE_ENTRIES*2);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xb7c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x1c552(%rip), %rax     # 0x25cf8
movq %rax, (%rdi)
movl $0x0, 0x14(%rdi)
movl $0x0, 0x18(%rdi)
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x96b0
jmp 0x97c6
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x60(%rbp)
callq 0xb7e0
movq -0x40(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x58(%rbp)
callq 0xb800
movq -0x40(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x50(%rbp)
callq 0xb820
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xd0(%rax)
movl $0x2, %esi
movl %esi, -0x48(%rbp)
movl $0x11, %edx
movl %edx, -0x44(%rbp)
movl %esi, %edi
callq 0x30f0
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0xa, %edi
callq 0x30f0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movl 0x8(%rax), %edi
callq 0x180d0
jmp 0x984c
movq -0x40(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x180d0
jmp 0x985a
movq -0x40(%rbp), %rax
movl $0x20000, -0x28(%rbp)   # imm = 0x20000
movl 0x8(%rax), %edi
movl $0x1, %esi
movl %esi, -0x78(%rbp)
movl $0x8, %edx
movl %edx, -0x74(%rbp)
leaq -0x28(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movl $0x4, %r8d
movl %r8d, -0x64(%rbp)
callq 0x3550
movl -0x78(%rbp), %esi
movl -0x74(%rbp), %edx
movq -0x70(%rbp), %rcx
movl -0x64(%rbp), %r8d
movq -0x40(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3550
movq -0x40(%rbp), %rdi
movw $0x0, 0x10(%rdi)
addq $0x38, %rdi
movl $0x20000, %esi          # imm = 0x20000
callq 0xb840
jmp 0x98c3
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x990a
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb870
movq -0x58(%rbp), %rdi
callq 0xb890
movq -0x60(%rbp), %rdi
callq 0xb8b0
movq -0x30(%rbp), %rdi
callq 0x9620
movq -0x40(%rbp), %rdi
callq 0xb8d0
movq -0x20(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: Query::~Query()
~Query() {
        // Remove the entry from the parent deps list
        assert(!deps_on || deps_on->deps.count(this));
        if (deps_on)
            deps_on->deps.erase(this);

        for (auto e: deps)
            delete e;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movb $0x1, %al
cmpq $0x0, 0x70(%rcx)
movb %al, -0x39(%rbp)
je 0x9d0d
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rdi
addq $0x40, %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xcfd0
movq %rax, -0x50(%rbp)
jmp 0x9cff
movq -0x50(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x9d16
jmp 0x9d18
jmp 0x9d37
leaq 0xf581(%rip), %rdi      # 0x192a0
leaq 0xf382(%rip), %rsi      # 0x190a8
movl $0x3d, %edx
leaq 0xf594(%rip), %rcx      # 0x192c6
callq 0x3210
movq -0x48(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x9d5f
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rdi
addq $0x40, %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xd030
jmp 0x9d5d
jmp 0x9d5f
movq -0x48(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa2c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa2f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa320
testb $0x1, %al
jne 0x9d98
jmp 0x9dda
leaq -0x28(%rbp), %rdi
callq 0xa350
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x9dcd
movq -0x58(%rbp), %rdi
callq 0x9cc0
movq -0x58(%rbp), %rdi
movl $0x78, %esi
callq 0x3360
jmp 0x9dcf
leaq -0x28(%rbp), %rdi
callq 0xa410
jmp 0x9d85
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0xd060
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x3200
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::~DNSResolver()
~DNSResolver() {
        if (sock4 != -1)
            (void) closesocket(sock4);
        if (sock6 != -1)
            (void) closesocket(sock6);

        for (auto it: active)
            delete it.second;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x1a9ad(%rip), %rcx     # 0x25ce8
addq $0x10, %rcx
movq %rcx, (%rax)
cmpl $-0x1, 0x8(%rax)
je 0xb358
movq -0x38(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x35c0
jmp 0xb356
jmp 0xb358
movq -0x38(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
je 0xb372
movq -0x38(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x35c0
jmp 0xb370
jmp 0xb372
movq -0x38(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9b90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9bc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9bf0
testb $0x1, %al
jne 0xb3ab
jmp 0xb3f5
leaq -0x18(%rbp), %rdi
callq 0x9c20
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xb3e8
movq -0x40(%rbp), %rdi
callq 0x9cc0
movq -0x40(%rbp), %rdi
movl $0x78, %esi
callq 0x3360
jmp 0xb3ea
leaq -0x18(%rbp), %rdi
callq 0x9e80
jmp 0xb398
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
callq 0xb870
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
callq 0xb890
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8b0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x9620
movq -0x38(%rbp), %rdi
callq 0xb8d0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davidgfnet[P]tadns/tadns_common.cc
// Function: serializeName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char*)
unsigned serializeName(std::string dom, uint8_t *out) {
    uint8_t * oout = out;
    unsigned off = 0;
    while (off < dom.size()) {
        auto s = dom.find('.', off);
        unsigned l = (s != std::string::npos) ? s - off : dom.size() - off;
        unsigned a = (s != std::string::npos) ? l + 1 : l;

        *out++ = l;
        memcpy(out, &dom[off], l);
        out += l;
        off += a;
    }
    *out++ = 0;

    return out - oout;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x40(%rbp)
callq 0x3240
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x17b54
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movl $0x2e, %esi
callq 0x3470
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x17ac1
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
jmp 0x17ad4
movq -0x38(%rbp), %rdi
callq 0x3240
movl -0x1c(%rbp), %ecx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl %eax, -0x2c(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x17aed
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x17af3
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x35f0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x30(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x17a73
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/img2img/img2img.cpp
// Function: main
int main(int argc, char **argv)
{
  // Check arguments
  if (argc != 3) {
    RNFail("Usage: img2img inputfile outputfile\n");
    return 1;
  }

  // Read and write image file 
  R2Image image;
  if (!image.Read(argv[1])) return -1;
  if (!image.Write(argv[2])) return -1;
  return 0;
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
cmpl $0x3, 0x50(%rsp)
je 0x36b7
leaq 0x64961(%rip), %rdi     # 0x68004
movb $0x0, %al
callq 0x9cb0
movl $0x1, 0x54(%rsp)
jmp 0x3762
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x37e0
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x3780
movl %eax, 0x1c(%rsp)
jmp 0x36df
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
jne 0x3714
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x20(%rsp)
jmp 0x3758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4230
jmp 0x376b
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x30(%rsp), %rdi
callq 0x37b0
movl %eax, 0xc(%rsp)
jmp 0x372d
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x3748
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x20(%rsp)
jmp 0x3758
movl $0x0, 0x54(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4230
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
nop
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Reader::refill_next_buffer()
void
Reader::refill_next_buffer()
{
    if (m_buffer_size == 0) {
        // Current buffer is the last one. Don't fill the next one.
        return;
    }

    // Current buffer must be completely read before filling the next one
    assert(m_buffer_offset == m_buffer_size);

    m_buffer_index = (m_buffer_index + 1) % m_buffer_count;
    auto buf = m_buffers[m_buffer_index];
    // Buffer for new data must not in use
    assert(buf.use_count() == 2);

    m_buffer_size = read_stream(buf, m_buffer_capacity);
    m_buffer_offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x3cb0
jmp 0x3d97
movq -0x40(%rbp), %rcx
movq 0x40(%rcx), %rax
cmpq 0x48(%rcx), %rax
jne 0x3cc0
jmp 0x3cdf
leaq 0xa409(%rip), %rdi      # 0xe0d0
leaq 0xa377(%rip), %rsi      # 0xe045
movl $0x7f, %edx
leaq 0xa417(%rip), %rcx      # 0xe0f1
callq 0x31c0
movq -0x40(%rbp), %rcx
movq 0x38(%rcx), %rax
addq $0x1, %rax
xorl %edx, %edx
divq 0x8(%rcx)
movq -0x40(%rbp), %rax
movq %rdx, 0x38(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x38(%rax), %rsi
callq 0x4780
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x49f0
leaq -0x18(%rbp), %rdi
callq 0x4a90
cmpq $0x2, %rax
jne 0x3d26
jmp 0x3d45
leaq 0xa3f6(%rip), %rdi      # 0xe123
leaq 0xa311(%rip), %rsi      # 0xe045
movl $0x84, %edx
leaq 0xa3b1(%rip), %rcx      # 0xe0f1
callq 0x31c0
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x49f0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq 0x10(%rdi), %rdx
callq 0x4140
movq %rax, -0x48(%rbp)
jmp 0x3d6d
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
leaq -0x28(%rbp), %rdi
callq 0x47d0
movq -0x40(%rbp), %rax
movq $0x0, 0x40(%rax)
leaq -0x18(%rbp), %rdi
callq 0x47d0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x47d0
leaq -0x18(%rbp), %rdi
callq 0x47d0
movq -0x30(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Reader::read(unsigned long, char*)
size_t
Reader::read(size_t data_size, char *dest_buf)
{
    size_t retry_count{0};
    size_t offset{0};
    size_t to_read{data_size};

    while ((to_read > 0) && (retry_count < 2)) {
        const DataPart dp{readMultipart(to_read)};
        if (dp.size == 0) {
            ++retry_count;
            continue;
        }

        retry_count = 0;
        memcpy(dest_buf + offset, dp.data.get(), dp.size);
        offset += dp.size;
        to_read -= dp.size;
    }

    assert(offset <= data_size);
    return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x59(%rbp)
jbe 0x3e1b
cmpq $0x2, -0x20(%rbp)
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x3e27
jmp 0x3ec3
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3f00
cmpq $0x0, -0x48(%rbp)
jne 0x3e54
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x2, -0x4c(%rbp)
jmp 0x3ea7
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4970
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x48(%rbp), %rdx
callq 0x3240
movq -0x48(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4990
movl -0x4c(%rbp), %eax
testl %eax, %eax
je 0x3ebe
jmp 0x3eb9
jmp 0x3e04
jmp 0x3e04
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x3ecf
jmp 0x3eee
leaq 0xa15b(%rip), %rdi      # 0xe031
leaq 0xa168(%rip), %rsi      # 0xe045
movl $0x4d, %edx
leaq 0xa170(%rip), %rcx      # 0xe059
callq 0x31c0
movq -0x28(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Reader::readMultipart(unsigned long)
DataPart
Reader::readMultipart(size_t data_size)
{
    const size_t size_left{m_buffer_size - m_buffer_offset};
    if (size_left == 0) {
        refill_next_buffer();
        if (m_buffer_size == 0) {
            return DataPart{.size = 0, .data = std::shared_ptr<char[]>()};
        }
    }
    // There is at least one byte in the buffer
    const DataPart dp{read_current_buffer(data_size)};
    assert(dp.size > 0);
    return dp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x48(%rcx), %rax
subq 0x40(%rcx), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3f66
movq -0x30(%rbp), %rdi
callq 0x3c90
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x3f64
movq -0x40(%rbp), %rdi
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x49b0
jmp 0x3fbb
jmp 0x3f66
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdx
callq 0x3fd0
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x3f87
jmp 0x3fa6
leaq 0xa0ff(%rip), %rdi      # 0xe08d
leaq 0xa0b0(%rip), %rsi      # 0xe045
movl $0x5d, %edx
leaq 0xa0f8(%rip), %rcx      # 0xe099
callq 0x31c0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x3fb9
movq -0x40(%rbp), %rdi
callq 0x4990
jmp 0x3fbb
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Reader::read_current_buffer(unsigned long)
DataPart
Reader::read_current_buffer(size_t data_size)
{
    DataPart dp;

    // Set data
    if (m_buffer_offset == 0) {
        dp.data = std::shared_ptr<char[]>{m_buffers[m_buffer_index]};
    } else {
        dp.data = std::shared_ptr<char[]>{
            m_buffers[m_buffer_index],
            static_cast<char *>(m_buffers[m_buffer_index].get()) +
                m_buffer_offset};
    }

    const size_t size_left{m_buffer_size - m_buffer_offset};
    dp.size = std::min(data_size, size_left);
    m_buffer_offset += dp.size;
    return dp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x49d0
movq -0x60(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x404a
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x38(%rax), %rsi
callq 0x4780
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x49f0
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x47a0
leaq -0x30(%rbp), %rdi
callq 0x47d0
jmp 0x40b3
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x38(%rax), %rsi
callq 0x4780
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x78(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x38(%rax), %rsi
callq 0x4780
movq %rax, %rdi
callq 0x4970
movq -0x78(%rbp), %rsi
movq %rax, %rdx
movq -0x60(%rbp), %rax
addq 0x40(%rax), %rdx
leaq -0x40(%rbp), %rdi
callq 0x4a20
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0x47a0
leaq -0x40(%rbp), %rdi
callq 0x47d0
movq -0x60(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x48(%rax), %rax
subq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4a50
movq %rax, -0x80(%rbp)
jmp 0x40d9
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
movq -0x80(%rbp), %rdx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq (%rcx), %rcx
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4122
jmp 0x4119
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x4990
jmp 0x412f
movq -0x70(%rbp), %rdi
callq 0x4990
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Reader::read_stream(std::shared_ptr<char []>, unsigned long)
size_t
Reader::read_stream(std::shared_ptr<char[]> data, size_t data_size)
{
    m_istream.read(data.get(), data_size);

    if (!m_istream.good() && !m_istream.eof()) {
        throw Error("cannot read from stream");
    }

    return m_istream.gcount();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x4970
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x33b0
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3470
testb $0x1, %al
jne 0x425f
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x34d0
testb $0x1, %al
jne 0x425f
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x3180
movq %rax, -0x78(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x34a0
movq -0x70(%rbp), %rdx
leaq 0x9f4f(%rip), %rsi      # 0xe138
leaq -0x38(%rbp), %rdi
callq 0x47f0
jmp 0x41f4
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x48a0
jmp 0x4203
movq -0x78(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x108e6(%rip), %rsi     # 0x14af8
leaq 0x6c7(%rip), %rdx       # 0x48e0
callq 0x3480
jmp 0x427e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4243
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3528
leaq -0x39(%rbp), %rdi
callq 0x32f0
testb $0x1, -0x4d(%rbp)
jne 0x4254
jmp 0x425d
movq -0x78(%rbp), %rdi
callq 0x3200
jmp 0x4275
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3510
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3490
nop
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Writer::Writer(std::ostream&, unsigned long)
Writer::Writer(std::ostream &ostream, size_t buffer_capacity)
    : m_ostream(ostream), m_buffer_size(0), m_buffer_capacity(buffer_capacity)
{
    try {
        m_buffer = std::make_unique<char[]>(m_buffer_capacity);
    } catch (const std::bad_alloc &e) {
        throw Error("cannot allocate buffer for output stream data");
    }
}

// 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, -0x68(%rbp)
leaq 0x1087a(%rip), %rax     # 0x14b20
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x70(%rbp)
callq 0x4ab0
movq -0x68(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x4ae0
jmp 0x42e1
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x4b40
leaq -0x20(%rbp), %rdi
callq 0x4b70
jmp 0x43d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x43d9
movq -0x28(%rbp), %rdi
callq 0x3100
movq %rax, -0x38(%rbp)
movb $0x1, -0x5a(%rbp)
movl $0x10, %edi
callq 0x3180
movq %rax, -0x80(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x34a0
movq -0x78(%rbp), %rdx
leaq 0x9dfd(%rip), %rsi      # 0xe150
leaq -0x58(%rbp), %rdi
callq 0x47f0
jmp 0x435e
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x48a0
jmp 0x436d
movq -0x80(%rbp), %rdi
movb $0x0, -0x5a(%rbp)
leaq 0x1077c(%rip), %rsi     # 0x14af8
leaq 0x55d(%rip), %rdx       # 0x48e0
callq 0x3480
jmp 0x43f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x43ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3528
leaq -0x59(%rbp), %rdi
callq 0x32f0
testb $0x1, -0x5a(%rbp)
jne 0x43be
jmp 0x43c7
movq -0x80(%rbp), %rdi
callq 0x3200
callq 0x3460
jmp 0x43ce
jmp 0x43d9
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4b70
movq -0x28(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0x4900
nopw %cs:(%rax,%rax)
// File: jansucan[P]diff-dd/src/buffered_stream.cpp
// Function: BufferedStream::Writer::write(char const*, unsigned long)
void
Writer::write(const char *data, size_t data_size)
{
    size_t free{m_buffer_capacity - m_buffer_size};
    if (data_size <= free) {
        // There is free space in the buffer
        write_buffer(data, data_size);
    } else {
        // No free space
        flush_buffer();
        if (data_size <= m_buffer_capacity) {
            // Data fits into the buffer
            write_buffer(data, data_size);
        } else {
            // Doesn't fit
            write_stream(data, data_size);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rcx), %rax
subq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x44f5
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4540
jmp 0x4532
movq -0x28(%rbp), %rdi
callq 0x4440
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x20(%rcx), %rax
ja 0x451f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4540
jmp 0x4530
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x45a0
jmp 0x4532
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jansucan[P]diff-dd/src/./format_v2.h
// Function: FormatV2::Writer::writeDiffRecord(unsigned long, unsigned long, std::vector<FormatV2::RecordData, std::allocator<FormatV2::RecordData>>)
void writeDiffRecord(
        uint64_t offset, size_t size,
        std::vector<RecordData> data) // cppcheck-suppress passedByValue
    {
        writeOffset(offset);
        writeSize(size);
        for (auto it = data.begin(); it != data.end(); ++it) {
            writeData(*it);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rsi
callq 0x9660
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x96a0
movq -0x60(%rbp), %rdi
callq 0x96e0
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rdi
callq 0x9750
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9710
testb $0x1, %al
jne 0x8097
jmp 0x80ea
leaq -0x28(%rbp), %rdi
callq 0x97d0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x97f0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x9780
jmp 0x80bf
leaq -0x48(%rbp), %rdi
callq 0x9830
leaq -0x28(%rbp), %rdi
callq 0x9850
jmp 0x8077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9830
jmp 0x80f0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: jansucan[P]diff-dd/src/create.cpp
// Function: PagedStreamReader::getNextPage()
Page getNextPage()
    {
        const BufferedStream::DataPart dp{
            m_reader.readMultipart(m_page_size_bytes)};

        m_stream_pos_bytes += dp.size;

        return Page{dp.data, m_stream_pos_bytes - dp.size, m_stream_pos_bytes};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rax, %rsi
addq $0x8, %rsi
movq (%rax), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3f00
movq -0x60(%rbp), %rax
movq -0x28(%rbp), %rdx
movq 0x58(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x58(%rax)
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x49f0
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq 0x58(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, %rdx
subq %rax, %rdx
callq 0x9360
jmp 0x8e9b
leaq -0x38(%rbp), %rdi
callq 0x47d0
leaq -0x28(%rbp), %rdi
callq 0x4990
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x47d0
leaq -0x28(%rbp), %rdi
callq 0x4990
movq -0x40(%rbp), %rdi
callq 0x3490
nop
// File: jansucan[P]diff-dd/src/options.cpp
// Function: Options::printUsage()
void
printUsage()
{
    std::cout << "Usage: " << PROGRAM_NAME_STR << " create";
    std::cout << " [-B BUFFER_SIZE] -i INFILE -b BASEFILE -o OUTFILE"
              << std::endl;

    std::cout << "   Or: " << PROGRAM_NAME_STR << " restore";
    std::cout << " [-B BUFFER_SIZE] -d DIFFFILE -o OUTFILE" << std::endl;

    std::cout << "   Or: " << PROGRAM_NAME_STR << " version" << std::endl;

    std::cout << "   Or: " << PROGRAM_NAME_STR << " help" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa74d(%rip), %rdi      # 0x14fc8
leaq 0x3f1c(%rip), %rsi      # 0xe79e
callq 0x3290
movq %rax, %rdi
leaq 0xaaaf(%rip), %rsi      # 0x15340
callq 0x3270
movq %rax, %rdi
leaq 0x3f06(%rip), %rsi      # 0xe7a6
callq 0x3290
movq 0xa71c(%rip), %rdi      # 0x14fc8
leaq 0x3efb(%rip), %rsi      # 0xe7ae
callq 0x3290
movq %rax, %rdi
movq 0xa6d6(%rip), %rsi      # 0x14f98
callq 0x32d0
movq 0xa6fa(%rip), %rdi      # 0x14fc8
leaq 0x3f0c(%rip), %rsi      # 0xe7e1
callq 0x3290
movq %rax, %rdi
leaq 0xaa5c(%rip), %rsi      # 0x15340
callq 0x3270
movq %rax, %rdi
leaq 0x3ef6(%rip), %rsi      # 0xe7e9
callq 0x3290
movq 0xa6c9(%rip), %rdi      # 0x14fc8
leaq 0x3eec(%rip), %rsi      # 0xe7f2
callq 0x3290
movq %rax, %rdi
movq 0xa683(%rip), %rsi      # 0x14f98
callq 0x32d0
movq 0xa6a7(%rip), %rdi      # 0x14fc8
leaq 0x3eb9(%rip), %rsi      # 0xe7e1
callq 0x3290
movq %rax, %rdi
leaq 0xaa09(%rip), %rsi      # 0x15340
callq 0x3270
movq %rax, %rdi
leaq 0x4075(%rip), %rsi      # 0xe9bb
callq 0x3290
movq %rax, %rdi
movq 0xa643(%rip), %rsi      # 0x14f98
callq 0x32d0
movq 0xa667(%rip), %rdi      # 0x14fc8
leaq 0x3e79(%rip), %rsi      # 0xe7e1
callq 0x3290
movq %rax, %rdi
leaq 0xa9c9(%rip), %rsi      # 0x15340
callq 0x3270
movq %rax, %rdi
leaq 0x3e95(%rip), %rsi      # 0xe81b
callq 0x3290
movq %rax, %rdi
movq 0xa603(%rip), %rsi      # 0x14f98
callq 0x32d0
popq %rbp
retq
nopl (%rax)
// File: jansucan[P]diff-dd/src/options.cpp
// Function: Options::Parser::parseUnsigned(char const*, unsigned int*)
int
Parser::parseUnsigned(const char *const arg, uint32_t *const value)
{
    char *end;

    errno = 0;

    *value = strtoul(arg, &end, 0);

    return ((*end != '\0') || (errno != 0)) ? -1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3040
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x30d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0xb751
callq 0x3040
cmpl $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jansucan[P]diff-dd/src/./format_v2.h
// Function: FormatV2::Reader::readOffset()
uint64_t readOffset()
    {
        uint64_t raw_offset;
        const size_t r{m_reader.read(sizeof(raw_offset),
                                     reinterpret_cast<char *>(&raw_offset))};
        if (r != sizeof(raw_offset)) {
            m_eof = true;
        }
        return be64toh(raw_offset);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x8, %esi
leaq -0x10(%rbp), %rdx
callq 0x3dd0
movq %rax, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
je 0xd1f5
movq -0x20(%rbp), %rax
movb $0x1, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0xcfc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jansucan[P]diff-dd/src/./format_v2.h
// Function: FormatV2::Reader::readSize()
size_t readSize()
    {
        uint32_t raw_size;
        const size_t r{m_reader.read(sizeof(raw_size),
                                     reinterpret_cast<char *>(&raw_size))};
        if (r != sizeof(raw_size)) {
            m_eof = true;
        }
        return be32toh(raw_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x4, %esi
leaq -0xc(%rbp), %rdx
callq 0x3dd0
movq %rax, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
je 0xd265
movq -0x20(%rbp), %rax
movb $0x1, 0x50(%rax)
movl -0xc(%rbp), %edi
callq 0xd070
movl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jansucan[P]diff-dd/src/./format_v2.h
// Function: FormatV2::Reader::readRecordData(unsigned long)
RecordData readRecordData(size_t size)
    {
        const BufferedStream::DataPart dp = m_reader.readMultipart(size);
        return RecordData{
            .size = dp.size,
            .data = dp.data,
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3f00
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x49f0
leaq -0x30(%rbp), %rdi
callq 0x4990
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: tlaloc1313[P]chess-project/draw.cpp
// Function: drawMoves(Board*)
void drawMoves(Board* gameBoard){
  cout<< "Moves: \n";

  //Loops from start to current point in game.
  for (int i = 0; i < gameBoard->getMoveNumber(); i++){
    if (i%2 == 0) {
      cout << (i/2)+1 << ". ";
    }

    cout << gameBoard->getPastPiece(i) << gameBoard->getPastSquare(i) << "  ";
  }
  cout << std::endl << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq 0xbaed(%rip), %rdi      # 0xefd0
leaq 0x6dca(%rip), %rsi      # 0xa2b4
callq 0x2140
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5570
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x35d3
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x354d
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
addl $0x1, %esi
movq 0xba97(%rip), %rdi      # 0xefd0
callq 0x2260
movq %rax, %rdi
leaq 0x6ce9(%rip), %rsi      # 0xa231
callq 0x2140
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5380
movq %rax, %rsi
movq 0xba6d(%rip), %rdi      # 0xefd0
callq 0x2140
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5520
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x2120
movq %rax, -0x48(%rbp)
jmp 0x3593
movq -0x48(%rbp), %rdi
leaq 0x6d1f(%rip), %rsi      # 0xa2bd
callq 0x2140
jmp 0x35a5
leaq -0x30(%rbp), %rdi
callq 0x20e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x35fb
movq 0xb9f6(%rip), %rdi      # 0xefd0
movq 0xb9df(%rip), %rsi      # 0xefc0
callq 0x2160
movq %rax, %rdi
movq 0xb9d0(%rip), %rsi      # 0xefc0
callq 0x2160
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/setup.cpp
// Function: setup(Board*)
int setup(Board* gameBoard) {

  //Pawns
  for (int i = 1; i<64; i+=8) {
    gameBoard->addPiece('p', i, 1);
    gameBoard->addPiece('p', i+5 , 0);
  }

  //Rooks
  gameBoard->addPiece('r', 0, 1);
  gameBoard->addPiece('r', 56, 1);
  gameBoard->addPiece('r', 7, 0);
  gameBoard->addPiece('r', 63, 0);

  //Bishops
  gameBoard->addPiece('b', 16, 1);
  gameBoard->addPiece('b', 40, 1);
  gameBoard->addPiece('b', 23, 0);
  gameBoard->addPiece('b', 47, 0);

  //Knights - note 'n' as type
  gameBoard->addPiece('n', 8, 1);
  gameBoard->addPiece('n', 48, 1);
  gameBoard->addPiece('n', 15, 0);
  gameBoard->addPiece('n', 55, 0);

  //Kings - note 'k' as type
  gameBoard->addPiece('k', 32, 1);
  gameBoard->addPiece('k', 39, 0);

  //Queens
  gameBoard->addPiece('q', 24, 1);
  gameBoard->addPiece('q', 31, 0);

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x3b10
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x70, %esi
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x5, %edx
movl $0x70, %esi
xorl %ecx, %ecx
callq 0x4b00
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ad3
movq -0x8(%rbp), %rdi
movl $0x72, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x72, %esi
movl $0x38, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x72, %esi
movl $0x7, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x72, %esi
movl $0x3f, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x62, %esi
movl $0x10, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x62, %esi
movl $0x28, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x62, %esi
movl $0x17, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x62, %esi
movl $0x2f, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x6e, %esi
movl $0x8, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x6e, %esi
movl $0x30, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x6e, %esi
movl $0xf, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x6e, %esi
movl $0x37, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x6b, %esi
movl $0x20, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x6b, %esi
movl $0x27, %edx
xorl %ecx, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x71, %esi
movl $0x18, %edx
movl $0x1, %ecx
callq 0x4b00
movq -0x8(%rbp), %rdi
movl $0x71, %esi
movl $0x1f, %edx
xorl %ecx, %ecx
callq 0x4b00
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: tlaloc1313[P]chess-project/Board.cpp
// Function: Board::Board()
Board::Board(){
  for (int i=0; i<64; i++){
    activeArray[i]=0;
  }
  moveNumber = 0;
  movesSince = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0xa2e5(%rip), %rax      # 0xeb50
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x248, %rdi            # imm = 0x248
callq 0x6a50
movq -0x18(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
callq 0x6a70
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x48b6
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x208(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4895
movq -0x18(%rbp), %rax
movl $0x0, 0x278(%rax)
movl $0x0, 0x27c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)