LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: walker-xian[P]teisye/heapperf/heapperf.cpp
// Function: local_alloc(unsigned long)
inline void* local_alloc(size_t size) noexcept
{
    auto start = benchmark_start();
    void* p = _active_allocator(size);
    auto end = benchmark_end();
    _active_statistic->_allocations_cost += end - start;
    _active_statistic->_num_of_allocations++;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7040
movq %rax, -0x10(%rbp)
movq %fs:-0x1b8, %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
jmp 0x5a8a
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x7080
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
subq -0x10(%rbp), %rcx
movq %fs:0x0, %rax
leaq -0x1a8(%rax), %rax
movq (%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq %fs:0x0, %rax
leaq -0x1a8(%rax), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7030
nopw (%rax,%rax)
// File: walker-xian[P]teisye/heapperf/heapperf.cpp
// Function: local_dealloc(void*)
inline void local_dealloc(void* p) noexcept
{
    auto start = benchmark_start();
    _active_deallocator(p);
    auto end = benchmark_end();
    _active_statistic->_deallocations_cost += end - start;
    _active_statistic->_num_of_deallocations++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7040
movq %rax, -0x10(%rbp)
movq %fs:-0x1b0, %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x5b16
callq 0x7080
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
movq %fs:0x0, %rax
leaq -0x1a8(%rax), %rax
movq (%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq %fs:0x0, %rax
leaq -0x1a8(%rax), %rax
movq (%rax), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7030
nopl (%rax)
// File: walker-xian[P]teisye/heapperf/heapperf.cpp
// Function: statistic::operator+=(statistic const&)
statistic operator+=(const statistic& rhs) noexcept
    {
        _allocations_cost += rhs._allocations_cost;
        _deallocations_cost += rhs._deallocations_cost;
        _num_of_allocations += rhs._num_of_allocations;
        _num_of_deallocations += rhs._num_of_deallocations;

        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
addq (%rcx), %rdx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
addq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rcx)
movq -0x10(%rbp), %rdx
movl 0x10(%rdx), %edx
addl 0x10(%rcx), %edx
movl %edx, 0x10(%rcx)
movq -0x10(%rbp), %rdx
movl 0x14(%rdx), %edx
addl 0x14(%rcx), %edx
movl %edx, 0x14(%rcx)
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: walker-xian[P]teisye/heapperf/heapperf.cpp
// Function: application::test_wc()
void test_wc()
    {
        map<string, int> words;

        typedef regex_token_iterator<const char*> regex_it;
        regex_it::regex_type rx(R"([\s+[:punct:]+])"); // spaces and punctuations
        regex_it token(_wc_text, _wc_text + sizeof(_wc_text)/sizeof(_wc_text[0]), rx, -1);
        regex_it end;

        for (; token != end; token++)
        {
            string word{ *token };
            auto it = words.find(word);
            if (it == words.end()) words[word] = 0;
            ++words[word];
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x98c0
leaq 0x311db(%rip), %rsi     # 0x3a39a
leaq -0x58(%rbp), %rdi
movl $0x10, %edx
callq 0x98e0
jmp 0x91cf
leaq 0x31c0a(%rip), %rsi     # 0x3ade0
leaq 0x31f55(%rip), %rdx     # 0x3b132
leaq -0xf0(%rbp), %rdi
leaq -0x58(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x9980
jmp 0x91f8
leaq -0x178(%rbp), %rdi
callq 0x9a70
jmp 0x9206
jmp 0x9208
leaq -0xf0(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x9af0
movb %al, -0x231(%rbp)
jmp 0x9223
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x9232
jmp 0x9393
leaq -0xf0(%rbp), %rdi
callq 0x9b20
movq %rax, -0x240(%rbp)
jmp 0x9247
movq -0x240(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x9b40
jmp 0x925c
leaq -0x38(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9b70
movq %rax, -0x248(%rbp)
jmp 0x9275
movq -0x248(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9bd0
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x9ba0
testb $0x1, %al
jne 0x92af
jmp 0x9338
leaq -0x38(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9c00
movq %rax, -0x250(%rbp)
jmp 0x92c8
movq -0x250(%rbp), %rax
movl $0x0, (%rax)
jmp 0x9338
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x93e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x93de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x93d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x93c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x5290
jmp 0x93c6
leaq -0x38(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9c00
movq %rax, -0x258(%rbp)
jmp 0x9351
movq -0x258(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x198(%rbp), %rdi
callq 0x5290
leaq -0x230(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
xorl %edx, %edx
callq 0x9ce0
jmp 0x9382
leaq -0x230(%rbp), %rdi
callq 0x9d60
jmp 0x9208
leaq -0x178(%rbp), %rdi
callq 0x9d60
leaq -0xf0(%rbp), %rdi
callq 0x9d60
leaq -0x58(%rbp), %rdi
callq 0x9d90
leaq -0x38(%rbp), %rdi
callq 0x9dc0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x178(%rbp), %rdi
callq 0x9d60
leaq -0xf0(%rbp), %rdi
callq 0x9d60
leaq -0x58(%rbp), %rdi
callq 0x9d90
leaq -0x38(%rbp), %rdi
callq 0x9dc0
movq -0x60(%rbp), %rdi
callq 0x5680
nopl (%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: tssize
size_t tssize(const void* ptr)
{
    using namespace teisye;
    if (!ptr) return static_cast<size_t>(-1);
    auto unit = reinterpret_cast<memory_unit*>(reinterpret_cast<size_t>(ptr) - sizeof(memory_unit::header));
    if (!_heap.validate(unit)) return static_cast<size_t>(-1);
    return unit->_header._size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36c7d
movq $-0x1, -0x8(%rbp)
jmp 0x36cb2
movq -0x10(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x2103c(%rip), %rdi     # 0x57cd0
callq 0x372d0
testb $0x1, %al
jne 0x36ca7
movq $-0x1, -0x8(%rbp)
jmp 0x36cb2
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::heap::free(void*)
inline void free(void* ptr) noexcept
    {
        if (!ptr) return;

        auto unit = reinterpret_cast<memory_unit*>(reinterpret_cast<size_t>(ptr) - sizeof(memory_unit::header));
        if (!validate(unit)) return;

        if (unit->_header._idle) return;
        unit->_header._idle = true;

        auto key = unit->_header._key;
        if (key <= _book.key_max_small())
        {
            _thread_cache.free(unit);
        }
        else if (key <= _book.key_max_medium())
        {
            _shared_cache.free(unit);
        }
        else if (key <= _book.key_max_large())
        {
            _large.free(unit);
        }
        else
        {
            auto hu = reinterpret_cast<huge_unit*>(reinterpret_cast<size_t>(unit) - sizeof(huge_unit::_raw_ptr));
            ::free(hu->_raw_ptr);
        }
    }

// 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)
cmpq $0x0, -0x10(%rbp)
jne 0x370c4
jmp 0x371b8
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x372d0
testb $0x1, %al
jne 0x370e6
jmp 0x371b8
movq -0x18(%rbp), %rax
cmpb $0x0, 0x3(%rax)
je 0x370f5
jmp 0x371b8
movq -0x18(%rbp), %rax
movb $0x1, 0x3(%rax)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq 0x20703(%rip), %rdi     # 0x57818
callq 0x37770
movb %al, %cl
movl -0x34(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jg 0x37139
callq 0x37790
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x39b60
jmp 0x371b8
movsbl -0x19(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq 0x206d1(%rip), %rdi     # 0x57818
callq 0x37810
movb %al, %cl
movl -0x38(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jg 0x3716a
movq -0x18(%rbp), %rsi
leaq 0x2084d(%rip), %rdi     # 0x579b0
callq 0x39bd0
jmp 0x371b6
movsbl -0x19(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq 0x206a0(%rip), %rdi     # 0x57818
callq 0x379b0
movb %al, %cl
movl -0x3c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jg 0x3719c
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x39c10
jmp 0x371b4
movq -0x18(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x5728
jmp 0x371b6
jmp 0x371b8
addq $0x40, %rsp
popq %rbp
retq
nop
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::heap::realloc(void*, unsigned long)
inline void* realloc(void *ptr, size_t size) noexcept
    {
        if (!ptr) return alloc(size);

        auto unit = reinterpret_cast<memory_unit*>(reinterpret_cast<size_t>(ptr) - sizeof(memory_unit::header));
        if (!validate(unit)) return nullptr;

        auto key = _book.key(size + sizeof(memory_unit::header));
        if (key == unit->_header._key)
        {
            unit->_header._size = static_cast<uint32_t>(size);
            return ptr;
        }

        void *new_ptr = alloc(size);
        if (new_ptr)
        {
            memcpy(new_ptr, ptr, min(static_cast<size_t>(unit->_header._size), size));
            free(ptr);
        }

        return new_ptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x371f9
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36d70
movq %rax, -0x8(%rbp)
jmp 0x372c6
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x372d0
testb $0x1, %al
jne 0x37223
movq $0x0, -0x8(%rbp)
jmp 0x372c6
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq 0x205e6(%rip), %rdi     # 0x57818
callq 0x37340
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
movq -0x28(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x37261
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x372c6
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x36d70
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x372be
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8560
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq (%rax), %rdx
callq 0x5360
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x370a0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::heap::shared_cache::merge(signed char, teisye::memory_unit*)
inline void merge(key_t key, memory_unit* head) noexcept
        {
            if (!head) return;
            auto tail = head;
            while (tail->_next) tail = tail->_next;
            _hashmap[key].push(head, tail);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x375c7
jmp 0x37605
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x375e8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x375cf
movq -0x28(%rbp), %rdi
movsbq -0x9(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x37630
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::stack_sl<teisye::memory_unit*>::push(teisye::memory_unit*, teisye::memory_unit*)
inline void push(node_t head, node_t tail) noexcept
    {
        while (_spin_lock.test_and_set());
        tail->_next = _head;
        _head = head;
        _spin_lock.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl $0x5, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x4, %eax
ja 0x3768b
movq -0x48(%rbp), %rax
leaq 0x407e(%rip), %rcx      # 0x3b700
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x50(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x51(%rbp)
jmp 0x376ca
movq -0x50(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x51(%rbp)
jmp 0x376ca
movq -0x50(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x51(%rbp)
jmp 0x376ca
movq -0x50(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x51(%rbp)
jmp 0x376ca
movq -0x50(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
cmpb $0x0, %al
je 0x376d6
jmp 0x3764c
movq -0x40(%rbp), %rax
movq (%rax), %rdx
movq -0x38(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x37750
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x58(%rbp)
subl $0x3, %eax
je 0x37733
jmp 0x37720
movl -0x58(%rbp), %eax
subl $0x5, %eax
je 0x3773c
jmp 0x3772a
movq -0x60(%rbp), %rax
movb $0x0, (%rax)
jmp 0x37744
movq -0x60(%rbp), %rax
movb $0x0, (%rax)
jmp 0x37744
movq -0x60(%rbp), %rcx
xorl %eax, %eax
xchgb %al, (%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::slabs<teisye::heap::slab, teisye::memory_unit>::alloc(unsigned long)
inline unit_t* alloc(size_t size)  noexcept
    {
        unit_t *unit{};
        for (auto s = _slabs.top(); s; s = s->_next)
        {
            unit = s->alloc(size);
            if (unit) return unit;
        }

        // need a new slab
        auto s = new slab_t;
        if (s)
        {
            unit = s->alloc(size);
            _slabs.push(s);
        }

        return unit;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x37c50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x37902
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37c70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x378f2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3794d
jmp 0x378f4
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x378c9
movl $0x20, %edi
callq 0x37d30
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x37d50
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x37945
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37c70
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rsi
callq 0x37da0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::heap_large::alloc(unsigned long)
inline memory_unit* alloc(size_t size) noexcept
    {
        large_unit* chunk = _slabs.alloc(size);
        if (chunk)
        {
            return reinterpret_cast<memory_unit*>(&chunk->_unit);
        }

        return nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38cf0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x37a06
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x37a0e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::stack_sl<teisye::memory_unit*>::pop()
inline node_t pop() noexcept
    {
        while (_spin_lock.test_and_set());
        node_t node = _head;
        if (node) _head = node->_next;
        _spin_lock.clear();
        return node;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl $0x5, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x4, %eax
ja 0x37b73
movq -0x40(%rbp), %rax
leaq 0x3baa(%rip), %rcx      # 0x3b714
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x37bb2
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x37bb2
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x37bb2
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x37bb2
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
cmpb $0x0, %al
je 0x37bbe
jmp 0x37b34
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x37bdf
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x37750
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
subl $0x3, %eax
je 0x37c2a
jmp 0x37c17
movl -0x50(%rbp), %eax
subl $0x5, %eax
je 0x37c33
jmp 0x37c21
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
jmp 0x37c3b
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
jmp 0x37c3b
movq -0x58(%rbp), %rcx
xorl %eax, %eax
xchgb %al, (%rcx)
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::heap::slab::alloc(unsigned long)
inline unit_t* alloc(size_t size) noexcept
        {
            assert(is_aligned(size));

            unit_t *ptr = _current;
            unit_t *next;
            do
            {
                next = reinterpret_cast<unit_t*>(reinterpret_cast<size_t>(ptr) + size);
                if (next >= _last) return nullptr;
            }
            while (!_current.compare_exchange_weak(ptr, next));

            return ptr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37e90
testb $0x1, %al
jne 0x37c97
jmp 0x37c99
jmp 0x37cb8
leaq 0x3e31(%rip), %rdi      # 0x3bad1
leaq 0x3cb0(%rip), %rsi      # 0x3b957
movl $0x242, %edx            # imm = 0x242
leaq 0x3e2f(%rip), %rcx      # 0x3bae2
callq 0x52e0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x37eb0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jb 0x37ced
movq $0x0, -0x8(%rbp)
jmp 0x37d17
jmp 0x37cef
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rsi
movl $0x5, %ecx
callq 0x37ed0
xorb $-0x1, %al
testb $0x1, %al
jne 0x37cc9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::heap_large::large_slab::large_slab()
inline large_slab() noexcept
        {
            _first = reinterpret_cast<unit_t*>(align<char*>(this, sizeof(*this)) + _alignment - sizeof(memory_unit::header));
            _first->_owner = nullptr;
            _first->_right = _last;

            _free_size = pointer_diff(_last, _first);
            _busy.clear();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x394d0
movq -0x40(%rbp), %rdi
movq $0x0, 0x10(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movl $0x28, %esi
callq 0x385f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq $0x8, %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq $0x0, 0x8(%rcx)
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0x394b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x394f0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x37750
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
je 0x39327
jmp 0x39314
movl -0x1c(%rbp), %eax
subl $0x5, %eax
je 0x39330
jmp 0x3931e
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0x39338
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0x39338
movq -0x28(%rbp), %rcx
xorl %eax, %eax
xchgb %al, (%rcx)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: walker-xian[P]teisye/src/teisye.cpp
// Function: teisye::stack_sl<teisye::memory_unit*>::push(teisye::memory_unit*)
inline void push(node_t node) noexcept
    {
        while (_spin_lock.test_and_set());
        node->_next = _head;
        _head = node;
        _spin_lock.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl $0x5, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x4, %eax
ja 0x39d17
movq -0x40(%rbp), %rax
leaq 0x1a7e(%rip), %rcx      # 0x3b78c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x39d56
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x39d56
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x39d56
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
jmp 0x39d56
movq -0x48(%rbp), %rcx
movb $0x1, %al
xchgb %al, (%rcx)
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
cmpb $0x0, %al
je 0x39d62
jmp 0x39cd8
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x37750
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
subl $0x3, %eax
je 0x39dbf
jmp 0x39dac
movl -0x50(%rbp), %eax
subl $0x5, %eax
je 0x39dc8
jmp 0x39db6
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
jmp 0x39dd0
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
jmp 0x39dd0
movq -0x58(%rbp), %rcx
xorl %eax, %eax
xchgb %al, (%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_13.cc
// Function: main
int main(int argc, char const *argv[])
{
	{
		auto sp = std::make_shared<int>();
		auto p = sp.get();
		delete p;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1210
leaq -0x20(%rbp), %rdi
callq 0x1280
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x11f8
movq -0x30(%rbp), %rdi
movl $0x4, %esi
callq 0x1080
leaq -0x20(%rbp), %rdi
callq 0x12a0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_16.cc
// Function: main
int main(int argc, char const *argv[])
{
	unique_ptr<string> p1 (new string("Henry"));

	/* error: call to deleted constructor of 'unique_ptr<string>' */
	// unique_ptr<string> p2(p1); // copy

	/**
	 * error: overload resolution selected deleted operator '='
	 * note: candidate function has been explicitly deleted
     * unique_ptr& operator=(const unique_ptr&) = delete;
     */
	// unique_ptr<string> p3;
	// p3 = p1; //assign

	cout << *p1 << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1080
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x10f0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0xd7c(%rip), %rsi       # 0x2004
callq 0x10c0
jmp 0x128f
movq -0x48(%rbp), %rsi
movb $0x0, -0x2d(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1350
leaq -0x19(%rbp), %rdi
callq 0x10b0
movq -0x58(%rbp), %rdi
callq 0x1380
movq %rax, -0x50(%rbp)
jmp 0x12bc
movq -0x50(%rbp), %rsi
movq 0x2d11(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, -0x60(%rbp)
jmp 0x12d2
movq -0x60(%rbp), %rdi
movq 0x2ceb(%rip), %rsi      # 0x3fc8
callq 0x10a0
jmp 0x12e4
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13b0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x10b0
testb $0x1, -0x2d(%rbp)
jne 0x131a
jmp 0x1328
movq -0x48(%rbp), %rdi
movl $0x20, %esi
callq 0x1090
jmp 0x133f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13b0
movq -0x28(%rbp), %rdi
callq 0x10e0
nopl (%rax,%rax)
// File: MatthewNielsen27[P]Routh/main.cpp
// Function: void print_matrix<double>(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
void print_matrix(const vector<vector<T>>& mat) {
    for (const auto& row : mat) {
        for (const auto& value : row) {
            cout << value << "\t";
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3bf0
testb $0x1, %al
jne 0x21e4
jmp 0x2282
leaq -0x18(%rbp), %rdi
callq 0x3c30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3c50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3c80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3cb0
testb $0x1, %al
jne 0x2226
jmp 0x2261
leaq -0x38(%rbp), %rdi
callq 0x3cf0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsd (%rax), %xmm0
movq 0x4d96(%rip), %rdi      # 0x6fd8
callq 0x1140
movq %rax, %rdi
leaq 0x1dd1(%rip), %rsi      # 0x4022
callq 0x10a0
leaq -0x38(%rbp), %rdi
callq 0x3d10
jmp 0x2213
movq 0x4d70(%rip), %rdi      # 0x6fd8
movq 0x4d59(%rip), %rsi      # 0x6fc8
callq 0x10d0
leaq -0x18(%rbp), %rdi
callq 0x3d30
jmp 0x21ce
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: olahol[P]cpp-csp/examples/primes.cpp
// Function: main
int main() {
  csp::Scheduler scheduler;

  auto ch = new csp::Channel<int>;

  scheduler.spawn(generate, ch);

  for (int i = 0; i < PRIMES; i++) {
    int prime = ch->get();
    std::cout << prime << std::endl;
    auto ch1 = new csp::Channel<int>;
    scheduler.spawn(filter, ch, ch1, prime);
    ch = ch1;
  }

  scheduler.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2570
movl $0xb0, %edi
callq 0x20f0
movq %rax, -0x50(%rbp)
jmp 0x2328
movq -0x50(%rbp), %rdi
callq 0x2590
jmp 0x2333
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
leaq 0x12a(%rip), %rsi       # 0x2470
leaq -0x20(%rbp), %rdi
callq 0x25e0
jmp 0x2351
movl $0x0, -0x38(%rbp)
cmpl $0x64, -0x38(%rbp)
jge 0x243a
movq -0x28(%rbp), %rdi
callq 0x2670
movl %eax, -0x54(%rbp)
jmp 0x2370
movl -0x54(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
movq 0x7c58(%rip), %rdi      # 0x9fd8
callq 0x21a0
movq %rax, -0x60(%rbp)
jmp 0x238b
movq -0x60(%rbp), %rdi
movq 0x7c2a(%rip), %rsi      # 0x9fc0
callq 0x2110
jmp 0x239d
movl $0xb0, %edi
callq 0x20f0
movq %rax, -0x68(%rbp)
jmp 0x23ad
movq -0x68(%rbp), %rdi
callq 0x2590
jmp 0x23b8
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %r8d
leaq 0xcd(%rip), %rsi        # 0x24a0
leaq -0x20(%rbp), %rdi
callq 0x2730
jmp 0x23de
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2358
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2457
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xb0, %esi
callq 0x2100
jmp 0x2457
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xb0, %esi
callq 0x2100
jmp 0x2457
leaq -0x20(%rbp), %rdi
callq 0x27d0
jmp 0x2445
leaq -0x20(%rbp), %rdi
callq 0x2850
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x2850
movq -0x30(%rbp), %rdi
callq 0x21b0
nopl (%rax)
// File: olahol[P]cpp-csp/examples/primes.cpp
// Function: generate(csp::Channel<int>*)
void generate(csp::Channel<int>* chan) {
  int i = 2;
  for (;;) {
    chan->put(i);
    i++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x28f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2483
nopw (%rax,%rax)
// File: olahol[P]cpp-csp/examples/primes.cpp
// Function: filter(csp::Channel<int>*, csp::Channel<int>*, int)
void filter(csp::Channel<int>* in, csp::Channel<int>* out, int prime) {
  for (;;) {
    int i = in->get();
    if (i % prime != 0) {
      out->put(i);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2670
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cltd
idivl -0x14(%rbp)
cmpl $0x0, %edx
je 0x24d7
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x28f0
jmp 0x24b3
nopl (%rax)
// File: NichtJens[P]lmf2txt/./conio.h
// Function: fopen_s(_IO_FILE**, char const*, char const*)
int fopen_s(FILE **f, const char *name, const char *mode) {
    int ret = 0;
    assert(f);
    *f = fopen(name, mode);
    if (! *f)
        ret = errno;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c284
jmp 0x1c2a3
leaq 0x126d(%rip), %rdi      # 0x1d4f8
leaq 0x1166(%rip), %rsi      # 0x1d3f8
movl $0xb, %edx
leaq 0x1164(%rip), %rcx      # 0x1d402
callq 0x1100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c2ce
callq 0x1050
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kerolloz[P]os/shell.cc
// Function: main
int main() {
  hello();
  string user_input;
  while (1) {
    printf("\n[shell@user]$ ");

    getline(cin, user_input);
    if (cin.eof() || user_input == "exit") {
      // if pressed CTRL + D "EOF" or entered "exit"
      break;
    }
    pid_t process_id = fork();
    if (process_id < 0) {
      printf("Failed to fork");
      exit(-1);
    }
    if (isChildProcess(process_id)) {
      command cmd(user_input);
      // (execute) replaces the child process image with the command to execute
      cmd.execute();
      // the following lines will execute, IFF command failed to execute
      printf("ERROR executing: %s\n", user_input.c_str());
      exit(0); // stop the child process, if failed
    }
    wait(NULL); // wait for the child to finish execution
  }
  bye();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
callq 0x2450
leaq -0x28(%rbp), %rdi
callq 0x2270
jmp 0x24d2
leaq 0x2c2b(%rip), %rdi      # 0x5104
xorl %eax, %eax
callq 0x2030
jmp 0x24e2
movq 0x5af7(%rip), %rdi      # 0x7fe0
leaq -0x28(%rbp), %rsi
callq 0x2060
jmp 0x24f4
movq 0x5ae5(%rip), %rdi      # 0x7fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22f0
movb %al, -0x91(%rbp)
jmp 0x2512
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2542
jmp 0x251e
leaq 0x2bef(%rip), %rsi      # 0x5114
leaq -0x28(%rbp), %rdi
callq 0x2670
movb %al, -0x92(%rbp)
jmp 0x2536
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x2542
jmp 0x2558
jmp 0x2630
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2653
callq 0x2070
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x2580
leaq 0x2bac(%rip), %rdi      # 0x5119
xorl %eax, %eax
callq 0x2030
jmp 0x2576
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2230
movl -0x38(%rbp), %edi
callq 0x2490
testb $0x1, %al
jne 0x2591
jmp 0x2620
leaq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20d0
jmp 0x25a3
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x26a0
jmp 0x25b5
leaq -0x90(%rbp), %rdi
callq 0x2120
leaq -0x70(%rbp), %rdi
callq 0x27b0
jmp 0x25cc
leaq -0x28(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x2b49(%rip), %rdi      # 0x5128
xorl %eax, %eax
callq 0x2030
jmp 0x25e8
xorl %edi, %edi
callq 0x2230
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2120
jmp 0x2653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x27f0
jmp 0x2653
xorl %eax, %eax
movl %eax, %edi
callq 0x2250
jmp 0x262b
jmp 0x24d0
callq 0x2470
jmp 0x2637
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x2120
movq -0x30(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nop
// File: kerolloz[P]os/shell.cc
// Function: command::command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
command(string s) : command_string(s) {
    vector<string> args;
    split(args);
    for (const string &arg : args) {
      char *str = const_cast<char *>(arg.c_str());
      argschar.push_back(str);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x20d0
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x78(%rbp)
callq 0x2820
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2840
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2860
jmp 0x26f4
leaq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x29c0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x29f0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2a20
testb $0x1, %al
jne 0x2729
jmp 0x278c
leaq -0x48(%rbp), %rdi
callq 0x2a60
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x20c0
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x20, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2a80
jmp 0x2756
jmp 0x2758
leaq -0x48(%rbp), %rdi
callq 0x2af0
jmp 0x2716
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2b10
movq -0x78(%rbp), %rdi
callq 0x2b70
movq -0x70(%rbp), %rdi
callq 0x2120
jmp 0x279e
leaq -0x28(%rbp), %rdi
callq 0x2b10
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: kerolloz[P]os/shell.cc
// Function: command::split(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void split(vector<string> &commands) {
    // just like python split
    // intput(string): "ls -la --color"
    // output(array of strings): ["ls", "-la", "--color"]
    string tmp_str = "";
    for (char c : command_string) {
      if (isspace(c)) {
        if (tmp_str.size())
          commands.push_back(tmp_str);
        tmp_str = "";
      } else
        tmp_str += c;
    }
    if (tmp_str.size())
      commands.push_back(tmp_str);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22d0
movq -0x70(%rbp), %rdx
leaq 0x280f(%rip), %rsi      # 0x50a2
leaq -0x30(%rbp), %rdi
callq 0x2d30
jmp 0x289e
leaq -0x31(%rbp), %rdi
callq 0x2200
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x21b0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2100
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2de0
testb $0x1, %al
jne 0x28df
jmp 0x297e
leaq -0x58(%rbp), %rdi
callq 0x2e20
movb (%rax), %al
movb %al, -0x61(%rbp)
movsbl -0x61(%rbp), %edi
callq 0x2040
cmpl $0x0, %eax
je 0x295d
leaq -0x30(%rbp), %rdi
callq 0x2150
cmpq $0x0, %rax
je 0x2949
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e40
jmp 0x2919
jmp 0x2949
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2200
jmp 0x29b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x29b0
leaq 0x2752(%rip), %rsi      # 0x50a2
leaq -0x30(%rbp), %rdi
callq 0x2260
jmp 0x295b
jmp 0x296e
movsbl -0x61(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x296c
jmp 0x296e
jmp 0x2970
leaq -0x58(%rbp), %rdi
callq 0x2eb0
jmp 0x28c9
leaq -0x30(%rbp), %rdi
callq 0x2150
cmpq $0x0, %rax
je 0x299e
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e40
jmp 0x299c
jmp 0x299e
leaq -0x30(%rbp), %rdi
callq 0x2120
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: WinChua[P]MLDemo/DecisionTree.cpp
// Function: TreeNode::TreeNode(File&)
TreeNode::TreeNode(File & file):data(file), feature_sets(file.featureset), lchild(nullptr), rchild(nullptr)
{
    for(int i=0; i < data.records.size(); ++i)
    {
        record_index.push_back(i);
    }
    set_label();
    divide_node();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3a80
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22e0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x3aa0
jmp 0x25e8
movq -0x30(%rbp), %rax
movq $0x0, 0x80(%rax)
movq $0x0, 0x88(%rax)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x3ad0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2672
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3b00
jmp 0x2640
jmp 0x2642
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2609
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x268e
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3b70
jmp 0x268e
movq -0x30(%rbp), %rdi
callq 0x26b0
jmp 0x267d
movq -0x30(%rbp), %rdi
callq 0x2780
jmp 0x2688
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
callq 0x3b90
movq -0x18(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: WinChua[P]MLDemo/DecisionTree.cpp
// Function: TreeNode::set_label()
void TreeNode::set_label()
{
    int  pos=0, neg=0;
    for(auto index : record_index)
    {
        if(data.records[index].label == 1) pos += 1;
        else neg += 1;
    }
    label = pos > neg ? 1 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3d80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3db0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3de0
testb $0x1, %al
jne 0x2707
jmp 0x2752
leaq -0x20(%rbp), %rdi
callq 0x3e20
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x2c(%rbp)
movq (%rax), %rdi
addq $0x20, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3e40
cmpl $0x1, (%rax)
jne 0x273c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2745
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2747
leaq -0x20(%rbp), %rdi
callq 0x3e60
jmp 0x26f4
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %edx
cmpl %edi, %esi
cmovgl %edx, %ecx
movl %ecx, 0x78(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WinChua[P]MLDemo/DecisionTree.cpp
// Function: TreeNode::test(Record&)
int TreeNode::test(Record &record)
{
    TreeNode * node = this;
    std::string feature = node->attr;
    while(feature != "no divided")
    {
        if(record.data.find(feature) == record.data.end())
        {
            node = node->rchild;
        }
        else node = node->lchild;
        feature = node->attr;
    }
    return node->label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
callq 0x20f0
leaq 0x904c(%rip), %rsi      # 0xc01c
leaq -0x38(%rbp), %rdi
callq 0x3ce0
movb %al, -0x59(%rbp)
jmp 0x2fde
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x2fea
jmp 0x307c
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x3eb0
movq %rax, -0x68(%rbp)
jmp 0x3001
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3ee0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3e80
testb $0x1, %al
jne 0x302d
jmp 0x3055
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3064
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x3098
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
callq 0x2040
jmp 0x3077
jmp 0x2fc9
movq -0x18(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2140
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: WinChua[P]MLDemo/DecisionTree.cpp
// Function: get_entropy(double, double)
double get_entropy(double pos, double neg)
{
    if(pos == 0 || neg == 0) return 0.0;
    pos = pos/(pos+neg);
    neg = 1 - pos;
    return -pos*std::log2(pos)-neg*std::log2(neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3894
jp 0x3894
jmp 0x38a4
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x38b1
jp 0x38b1
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3959
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
addsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x873f(%rip), %xmm0     # 0xc010
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x2370
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2370
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x20(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WinChua[P]MLDemo/DecisionTree.cpp
// Function: TreeNode::_entropy(std::vector<int, std::allocator<int>>&)
double TreeNode::_entropy(std::vector<int> &index)
{
    double entropy=0.0;
    double pos=0.0, neg=0.0;
    for(auto it=index.begin(); it != index.end(); ++it)
    {
        if(data.records[*it].label == 1)
        {
            pos += 1;
        }
        else
        {
            neg += 1;
        }
    }
    entropy = get_entropy(pos, neg);
    return entropy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d80
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3de0
testb $0x1, %al
jne 0x39fd
jmp 0x3a59
movq -0x40(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3e20
movq -0x48(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3e40
cmpl $0x1, (%rax)
jne 0x3a3a
movsd 0x85e2(%rip), %xmm0     # 0xc010
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x3a4c
movsd 0x85ce(%rip), %xmm0     # 0xc010
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x3a4e
leaq -0x30(%rbp), %rdi
callq 0x3e60
jmp 0x39dd
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x3870
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: WinChua[P]MLDemo/data.cpp
// Function: File::show_features() const
void File::show_features() const
{
    for(auto it=featureset.begin(); it != featureset.end(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x38, %rdi
callq 0x4420
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x4450
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4480
testb $0x1, %al
jne 0x8945
jmp 0x8977
leaq -0x10(%rbp), %rdi
callq 0x44b0
movq %rax, %rsi
movq 0xa680(%rip), %rdi      # 0x12fd8
callq 0x21e0
movq %rax, %rdi
leaq 0x379c(%rip), %rsi      # 0xc103
callq 0x21f0
leaq -0x10(%rbp), %rdi
callq 0x4520
jmp 0x8921
movq 0xa65a(%rip), %rdi      # 0x12fd8
movq 0xa643(%rip), %rsi      # 0x12fc8
callq 0x2240
addq $0x20, %rsp
popq %rbp
retq