LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::conv_type(Srl::Value const&)
Value Environment::conv_type(const Value& value)
{
    size_t data_size = 0;
    auto& buffer = this->type_buffer;

    if(value.type() == Type::String) {

        String wrap(value.data(), value.size(), value.encoding());
        data_size = Tools::conv_charset(Encoding::UTF8, wrap, buffer, true);

    } else if(TpTools::is_scalar(value.type())) {

        data_size = Tools::type_to_str(value, buffer);

    } else {

        assert(value.type() == Type::Binary && "Value type invalid.");

        data_size = Tools::bytes_to_base64(value.data(), value.size(), buffer);
    }

    return Value( { buffer.data(), data_size }, value.type());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x238, %r15            # imm = 0x238
movb 0x14(%rdx), %al
cmpb $0xc, %al
jne 0xec91
cmpb $0x0, 0x16(%r14)
jne 0xeca0
movq 0x8(%r14), %rax
jmp 0xeca4
jae 0xecd7
movq %r14, %rdi
movq %r15, %rsi
callq 0xb620
jmp 0xecf8
leaq 0x8(%r14), %rax
movl 0x10(%r14), %ecx
movb 0x15(%r14), %dl
movq %rsp, %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movb $0xc, 0xc(%rsi)
movb %dl, 0xd(%rsi)
movb $0x0, 0xe(%rsi)
movl $0x1, %edi
movq %r15, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xbc60
jmp 0xecf8
cmpb $0xd, %al
jne 0xed23
cmpb $0x0, 0x16(%r14)
jne 0xece8
movq 0x8(%r14), %rdi
jmp 0xecec
leaq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
movq %r15, %rdx
callq 0xb780
movq (%r15), %rcx
movb 0x14(%r14), %dl
movq $0x0, (%rbx)
movq %rcx, 0x8(%rbx)
movl %eax, 0x10(%rbx)
movb %dl, 0x14(%rbx)
movw $0x0, 0x15(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf365(%rip), %rdi      # 0x1e08f
leaq 0xf394(%rip), %rsi      # 0x1e0c5
leaq 0xf3a5(%rip), %rcx      # 0x1e0dd
movl $0xd4, %edx
callq 0xb540
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::clear()
void Environment::clear()
{
    this->heap.clear();
    this->str_table.clear();
    this->shared_table_store.clear();
    this->shared_table_restore.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xb510
cmpq $0x0, 0x70(%rbx)
je 0xed80
leaq 0xa0(%rbx), %rdi
callq 0xb510
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0xed79
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
cmpq $0x0, 0x108(%rbx)
je 0xedb7
leaq 0x138(%rbx), %rdi
callq 0xb510
movq 0x118(%rbx), %rax
cmpq %rax, 0x120(%rbx)
je 0xedad
movq %rax, 0x120(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rbx)
addq $0x188, %rbx            # imm = 0x188
movq %rbx, %rdi
popq %rbx
jmp 0xc040
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::get(Srl::String const&)
V* HTable<K, V, H>::get(const K& key)
    {
        if(elements < 1) {
            return nullptr;
        }

        auto hash    = hash_fnc(key);
        auto bucket  = get_bucket(hash);
        Entry* entry = table[bucket];

        while(entry) {

            if(entry->hash == hash && entry->key == key) {
                return &entry->val;
            }

            entry = entry->next;
        }

        return nullptr;
    }

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0xeef4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
cmpb $0x0, 0xe(%rsi)
movq %rsi, %rdi
jne 0xedf3
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xb580
movq %rax, %r15
movq 0x8(%r12), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
shrq $0x20, %rax
xorl %edi, %edi
testq %rdx, %rdx
cmovneq %rdi, %rax
movq 0x20(%r12), %rsi
xorq %r15, %rax
xorl %edx, %edx
divq %rcx
movq (%rsi,%rdx,8), %r14
testq %r14, %r14
je 0xeeff
cmpq %r15, (%r14)
jne 0xeee3
movl 0x18(%r14), %edx
movl 0x8(%rbx), %eax
movl %edx, %ecx
orl %eax, %ecx
je 0xeef8
leaq 0x10(%r14), %r13
movb 0x1d(%r14), %cl
cmpb %cl, 0xd(%rbx)
jne 0xee85
cmpl %eax, %edx
jne 0xeee3
cmpb $0x0, 0xe(%rbx)
movq %rbx, %rsi
jne 0xee6c
movq (%rbx), %rsi
cmpb $0x0, 0x1e(%r14)
jne 0xee77
movq 0x10(%r14), %r13
movq %r13, %rdi
callq 0xb960
testl %eax, %eax
jne 0xeee3
jmp 0xeef8
movzbl %cl, %esi
xorl %r12d, %r12d
movq %rsp, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xbea0
movq (%rsp), %rbp
movq 0x8(%rsp), %rdx
subq %rbp, %rdx
movl 0x18(%r14), %eax
cmpq %rax, %rdx
jne 0xeec9
cmpb $0x0, 0x1e(%r14)
jne 0xeeb8
movq 0x10(%r14), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb960
testl %eax, %eax
sete %r12b
testq %rbp, %rbp
je 0xeede
movq 0x10(%rsp), %rsi
subq %rbp, %rsi
movq %rbp, %rdi
callq 0xb940
testb %r12b, %r12b
jne 0xeef8
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xee31
xorl %edi, %edi
jmp 0xeeff
xorl %edi, %edi
jmp 0xef0d
addq $0x20, %r14
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::clear()
void HTable<K, V, H>::clear()
    {
        if(this->elements < 1) {
            return;
        }

        this->destroy_all<K, V>();
        this->heap.clear();
        this->mem_cache.clear();
        this->elements = 0;
        this->limit    = 0;
    }

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0xefe9
pushq %rbx
movq %rdi, %rbx
callq 0xbfa0
leaq 0x48(%rbx), %rdi
callq 0xb510
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0xefe1
movq %rax, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/include/Srl/Heap.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::Entry* Srl::Lib::Heap::get_mem<Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::Entry>(unsigned long)
T* Heap::get_mem(size_t n_elems)
    {
        auto sz = n_elems * sizeof(T);

        if(!this->crr_seg || this->crr_seg->left < sz + alignof(T) - 1) {
            this->crr_seg = this->alloc(sz, alignof(T));
        }

        auto* mem = this->crr_seg->pointer();

        auto rem    = (size_t)mem % alignof(T);
        auto offset = rem ? alignof(T) - rem : 0;

        mem += offset;
        this->crr_seg->dec(sz + offset);

        return reinterpret_cast<T*>(mem);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
shlq $0x4, %rsi
leaq (%rsi,%rsi,2), %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xf4db
movl 0x8(%rax), %edx
movq %rbx, %rcx
orq $0x7, %rcx
cmpq %rdx, %rcx
jbe 0xf4f2
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb5c0
movq %rax, 0x8(%r14)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
addq (%rax), %rcx
subq %rdx, %rcx
movl %ecx, %edi
andl $0x7, %edi
movl $0x8, %esi
subq %rdi, %rsi
testq %rdi, %rdi
cmoveq %rdi, %rsi
orq %rsi, %rbx
cmpq %rdx, %rbx
ja 0xf52a
addq %rsi, %rcx
subl %ebx, %edx
movl %edx, 0x8(%rax)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xebe2(%rip), %rdi      # 0x1e113
leaq 0xebeb(%rip), %rsi      # 0x1e123
leaq 0xebf7(%rip), %rcx      # 0x1e136
movl $0x44, %edx
callq 0xb540
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::foreach(std::function<void (unsigned long const&, std::shared_ptr<void>&)> const&) const
void HTable<K, V, H>::foreach(const std::function<void(const K&, V&)>& fnc) const
    {
        this->foreach_break([&fnc](const K& key, V& val)
        {
            fnc(key, val);
            return false;
        });
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
movq 0x173d8(%rip), %rcx     # 0x26f90
movq %rcx, 0x18(%rax)
movq 0x17355(%rip), %rcx     # 0x26f18
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0xb440
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xfbe6
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0xfc10
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xfc08
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xbe90
movq %rax, %rdi
callq 0xf059
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::foreach_break(std::function<bool (unsigned long const&, std::shared_ptr<void>&)> const&) const
void HTable<K, V, H>::foreach_break(const std::function<bool(const K&, V&)>& fnc) const
    {
        if(this->elements < 1) {
            return;
        }

        auto n = 0U;

        for(auto i = 0U; i < this->cap; i++) {

            auto* entry = table[i];

            while(entry) {

                auto abort = fnc(entry->key, entry->val);

                if(abort) {
                    return;
                }

                entry = entry->next;
                n++;
            }

            if(n >= this->elements) {
                break;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xfc83
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0xfc83
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x20(%r14), %rcx
movq (%rcx,%r15,8), %r12
testq %r12, %r12
je 0xfc73
cmpq $0x0, 0x10(%rbx)
je 0xfc8c
leaq 0x18(%r12), %rdx
leaq 0x10(%r12), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
testb %al, %al
jne 0xfc83
incl %ebp
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xfc48
movq 0x18(%r14), %rax
movl %ebp, %ecx
cmpq %rcx, %rax
jbe 0xfc83
incl %r15d
cmpq %r15, 0x8(%r14)
ja 0xfc3b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::Chain::get_link()
SegLink* Heap::Chain::get_link()
{
    auto* link = this->free_links.find_rm(Any());

    if(!link) {
        link = new ChainLink();
    }

    this->used_links.append(link);

    return &link->val;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xffb4
movq (%rax), %rcx
movq %rcx, 0x30(%rbx)
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cmovneq %rcx, %rdx
movq %rdx, 0x38(%rbx)
movq $0x0, (%rax)
jmp 0xffd0
movl $0x28, %edi
callq 0xb920
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
leaq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rdx
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq %rax, 0x28(%rbx)
movq $0x0, (%rax)
addq $0x8, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::find_free_seg(unsigned long, unsigned long)
Heap::Segment* Heap::find_free_seg(size_t sz, size_t align)
{
    auto* link = this->chain.free_segs.find_rm(Size(sz, align));

    if(link) {
        this->chain.used_segs.append(link);
    }
    return link ? &link->val : nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rdi), %rbp
xorl %ecx, %ecx
movq %rbp, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x10084
movq %rcx, %r13
movq 0x8(%r12), %rdx
movl 0x14(%r12), %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10464
movq %r12, %rcx
testb %al, %al
je 0x10011
movq (%rbp), %rax
cmpq %r12, %rax
jne 0x10046
movq (%r12), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rax
cmpq %r12, %rax
cmoveq %r13, %rax
movq %rax, 0x28(%rbx)
testq %r13, %r13
je 0x10066
movq (%r12), %rax
movq %rax, (%r13)
leaq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %r12, (%rax)
movq %r12, 0x18(%rbx)
movq $0x0, (%r12)
leaq 0x8(%r12), %rax
testq %r12, %r12
cmoveq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::alloc(unsigned long, unsigned long)
Heap::Segment* Heap::alloc(size_t n, size_t align)
{
    Segment* seg = nullptr;

    if(this->crr_seg && crr_seg->left > 0) {
        this->put_mem(crr_seg->pointer(), this->crr_seg->left);
    }

    if(chain.free_segs.front && (seg = find_free_seg(n, align))) {
        return seg;
    }

    this->cap = cap < 1 ? 1 : cap * 2 < Max_Cap ? cap * 2 : Max_Cap;

    if(n < Max_Cap && this->cap < n) {
        while(this->cap < n && this->cap < Max_Cap) {
            this->cap *= 2;
        }
    }

    auto alloc_sz = this->cap > n ? this->cap : n;

    auto* link = this->chain.get_link();
    seg = &link->val;
    set_segment(*seg, alloc_sz);

    this->chain.used_segs.append(link);

    return seg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x10117
movl 0x8(%rax), %r12d
testq %r12, %r12
je 0x10117
movl 0xc(%rax), %r13d
addq (%rax), %r13
subq %r12, %r13
leaq 0x10(%rbx), %rdi
callq 0xb250
movq %rax, %rbp
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xb420
movq %r13, 0x8(%rbp)
movl %r12d, 0x10(%rbp)
movl %r12d, 0x14(%rbp)
movb $0x1, 0x18(%rbp)
leaq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rbp, (%rax)
movq %rbp, 0x28(%rbx)
movq $0x0, (%rbp)
cmpq $0x0, 0x20(%rbx)
je 0x10138
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb480
movq %rax, %r12
testq %rax, %rax
jne 0x101c2
leaq 0x10(%rbx), %r15
movq (%rbx), %rax
leaq (%rax,%rax), %rcx
movl $0x40000, %edx          # imm = 0x40000
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
testq %rax, %rax
movl $0x1, %eax
cmovneq %rcx, %rax
movq %rax, (%rbx)
cmpq %rdx, %r14
setae %cl
cmpq %r14, %rax
setae %dl
orb %cl, %dl
jne 0x10179
addq %rax, %rax
cmpq %r14, %rax
jb 0x1016e
movq %rax, (%rbx)
cmpq %r14, %rax
cmovaq %rax, %r14
movq %r15, %rdi
callq 0xb250
movq %rax, %r13
leaq 0x8(%rax), %r12
movq %r14, %rdi
callq 0xb030
movq %rax, 0x8(%r13)
movl %r14d, 0x10(%r13)
movl %r14d, 0x14(%r13)
movb $0x0, 0x18(%r13)
movq 0x18(%rbx), %rax
testq %rax, %rax
cmoveq %r15, %rax
movq %r13, (%rax)
movq %r13, 0x18(%rbx)
movq $0x0, (%r13)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::clear()
void Heap::clear()
{
    this->chain.used_segs.clear();
    this->chain.free_segs.clear();

    ChainLink* link = this->chain.used_links.front;
    ChainLink* prev = nullptr;

    while(link) {
        auto* next = link->next;

        if(link->val.val.sub_seg) {
            this->chain.used_links.remove(prev, link);
            this->chain.free_links.append(link);

        } else {
            prev = link;
            reset_segment(link->val);
            this->chain.free_segs.prepend(Size(link->val.val.size, 1), &link->val);
        }

        link = next;
    }

    this->crr_seg = nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, 0x20(%rdi)
movdqu %xmm0, 0x10(%rdi)
movq 0x30(%rdi), %rbp
testq %rbp, %rbp
je 0x10336
leaq 0x20(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rbx), %r14
leaq 0x40(%rbx), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
movq %rbx, 0x18(%rsp)
movq %r14, 0x10(%rsp)
movq (%rbp), %r13
cmpb $0x1, 0x20(%rbp)
jne 0x10290
movdqu 0x30(%rbx), %xmm0
movq %rbp, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
pcmpeqd %xmm0, %xmm1
pshufd $0xb1, %xmm1, %xmm2     # xmm2 = xmm1[1,0,3,2]
pand %xmm1, %xmm2
movq %rax, %xmm1
movq %r13, %xmm3
punpcklqdq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0]
pand %xmm2, %xmm3
pandn %xmm0, %xmm2
por %xmm3, %xmm2
movdqu %xmm2, 0x30(%rbx)
testq %rax, %rax
je 0x1026f
movq %r13, (%rax)
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
cmoveq 0x20(%rsp), %rcx
movq %rbp, (%rcx)
movq %rbp, 0x48(%rbx)
movq $0x0, (%rbp)
jmp 0x1032a
leaq 0x8(%rbp), %r15
movl 0x1c(%rbp), %edx
movl %edx, 0x18(%rbp)
movq 0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb420
movq $0x0, 0x8(%rbp)
cmpq $0x0, (%r14)
je 0x102fc
movl 0x1c(%rbp), %r14d
movq 0x8(%rsp), %rbx
xorl %ecx, %ecx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x10309
movq %rcx, %r12
movq 0x8(%rbx), %rdx
movl 0x14(%rbx), %ecx
movl $0x1, %esi
movq %r14, %rdi
callq 0x10464
movq %rbx, %rcx
testb %al, %al
je 0x102be
movq %rbx, (%r15)
testq %r12, %r12
cmoveq 0x8(%rsp), %r12
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
jmp 0x10323
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq %r14, %r12
jmp 0x10323
movq $0x0, (%r15)
movq 0x10(%rsp), %r14
movq (%r14), %rax
movq %r15, (%rax)
movq %r14, %r12
movq 0x18(%rsp), %rbx
movq %r15, (%r12)
movq %rbp, %rax
movq %r13, %rbp
testq %r13, %r13
jne 0x10222
movq $0x0, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::destroy()
void Heap::destroy()
{
    const auto free = [](Aux::SList<SegLink>& lst) {
        auto* link = lst.front;
        while(link) {
            auto* next = link->next;
            delete link;
            link = next;
        }
    };

    free(this->chain.used_links);
    free(this->chain.free_links);

    this->chain = Chain();
    this->crr_seg = nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x10390
movq (%r14), %r15
leaq 0x10(%r14), %rdi
callq 0xb680
movl $0x28, %esi
movq %r14, %rdi
callq 0xb940
movq %r15, %r14
testq %r15, %r15
jne 0x1036f
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x103ba
movq (%r14), %r15
leaq 0x10(%r14), %rdi
callq 0xb680
movl $0x28, %esi
movq %r14, %rdi
callq 0xb940
movq %r15, %r14
testq %r15, %r15
jne 0x10399
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::node(Srl::String const&)
Node& Node::node(const String& name_)
{
    auto hash = hash_string(name_, *this->env);
    auto hash_name = make_pair(hash, &name_);
    auto* link = find_link<Throw | Hash | Name>(hash_name, this->nodes, name_, this->name());

    return link->field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rsi
movq %rbx, %rdi
callq 0x10a18
movq %rax, %r13
movq 0x10(%r15), %r12
movq 0x48(%r15), %rax
testq %rax, %rax
jne 0x10a76
movq 0x164ca(%rip), %rax     # 0x26f40
movq %rax, (%rsp)
addq $0x10, %r15
cmpq %r15, %r12
je 0x10b63
movq %r13, 0x8(%rsp)
cmpq %r13, 0x10(%r12)
jne 0x10b56
movq 0x60(%r12), %r14
testq %r14, %r14
jne 0x10aa8
movq 0x16498(%rip), %r14     # 0x26f40
movl 0x8(%r14), %edx
movl 0x8(%rbx), %eax
movl %edx, %ecx
orl %eax, %ecx
je 0x10b95
movb 0xd(%r14), %cl
cmpb %cl, 0xd(%rbx)
jne 0x10af1
cmpl %eax, %edx
jne 0x10b56
cmpb $0x0, 0xe(%rbx)
movq %rbx, %rsi
jne 0x10ad6
movq (%rbx), %rsi
cmpb $0x0, 0xe(%r14)
jne 0x10ae0
movq (%r14), %r14
movq %r14, %rdi
callq 0xb960
testl %eax, %eax
jne 0x10b56
jmp 0x10b95
movzbl %cl, %esi
xorl %r13d, %r13d
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xbea0
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rdx
subq %rbp, %rdx
movl 0x8(%r14), %eax
cmpq %rax, %rdx
jne 0x10b37
cmpb $0x0, 0xe(%r14)
jne 0x10b26
movq (%r14), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0xb960
testl %eax, %eax
sete %r13b
testq %rbp, %rbp
je 0x10b4c
movq 0x20(%rsp), %rsi
subq %rbp, %rsi
movq %rbp, %rdi
callq 0xb940
testb %r13b, %r13b
movq 0x8(%rsp), %r13
jne 0x10b95
movq (%r12), %r12
cmpq %r15, %r12
jne 0x10a8c
movl $0x28, %edi
callq 0xb3b0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x11af4
movq 0x16462(%rip), %rsi     # 0x26fe8
movq 0x163bb(%rip), %rdx     # 0x26f48
movq %r14, %rdi
callq 0xbe60
addq $0x18, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xb610
movq %rbx, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::get(Srl::String const&)
Union Node::get(const String& name_)
{
    auto* resvalue = find_link<Name>(name_, this->values, name_, this->name());

    if(resvalue) {
        return Union(resvalue->field);
    }

    auto* resnode = find_link<Throw | Name>(name_, this->nodes, name_, this->name());

    return Union(resnode->field);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r14
movups (%rsi), %xmm0
leaq 0x20(%rsp), %r15
movups %xmm0, (%r15)
leaq 0x30(%rdi), %r12
movq %r12, %rbx
movq (%rbx), %rbx
cmpq %r12, %rbx
je 0x1112b
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x13667
testb %al, %al
je 0x11107
addq $0x18, %rbx
xorl %r12d, %r12d
jmp 0x11267
movq %r13, 0x18(%rsp)
movups (%r13), %xmm0
movq 0x48(%r14), %rax
testq %rax, %rax
jne 0x11145
movq 0x15dfb(%rip), %rax     # 0x26f40
movq %rax, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x10(%r14), %r12
addq $0x10, %r14
cmpq %r14, %r12
je 0x1122c
movq %rsp, %r13
movq 0x60(%r12), %r15
testq %r15, %r15
jne 0x11173
movq 0x15dcd(%rip), %r15     # 0x26f40
movl 0x8(%r15), %edx
movl 0x8(%rsp), %eax
movl %edx, %ecx
orl %eax, %ecx
je 0x11261
movb 0xd(%r15), %cl
cmpb %cl, 0xd(%rsp)
jne 0x111c0
cmpl %eax, %edx
jne 0x1121f
cmpb $0x0, 0xe(%rsp)
movq %r13, %rsi
jne 0x111a5
movq (%rsp), %rsi
cmpb $0x0, 0xe(%r15)
jne 0x111af
movq (%r15), %r15
movq %r15, %rdi
callq 0xb960
testl %eax, %eax
jne 0x1121f
jmp 0x11261
movzbl %cl, %esi
xorl %ebp, %ebp
leaq 0x20(%rsp), %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xbea0
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rdx
subq %rbx, %rdx
movl 0x8(%r15), %eax
cmpq %rax, %rdx
jne 0x11205
cmpb $0x0, 0xe(%r15)
jne 0x111f4
movq (%r15), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb960
testl %eax, %eax
sete %bpl
testq %rbx, %rbx
je 0x1121a
movq 0x30(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0xb940
testb %bpl, %bpl
jne 0x11261
movq (%r12), %r12
cmpq %r14, %r12
jne 0x11162
movl $0x28, %edi
callq 0xb3b0
movq %rax, %rbx
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x11af4
movq 0x15d96(%rip), %rsi     # 0x26fe8
movq 0x15cef(%rip), %rdx     # 0x26f48
movq %rbx, %rdi
callq 0xbe60
addq $0x18, %r12
xorl %ebx, %ebx
movq %r12, %rax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb610
movq %r14, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::get(unsigned long)
Link<T>* get_link_at_index(size_t index, Cont<T>& links)
    {
        if(index < links.size()) {
            auto itr = links.begin();
            advance(itr, index);
            auto* rslt = &*itr;
            if(enabled(Opt, Remove)) {
                links.erase(itr);
                return nullptr;
            }
            return rslt;

        } else {
            if(enabled(Opt, Throw)) {
                auto msg = "Cannot access <" + tp_name<T>() + "> at index <" + to_string(index) + ">, index out of bounds.";
                throw Exception(msg);
            }
            return nullptr;
        }
    }

// Assembly:
cmpq %rsi, 0x20(%rdi)
jbe 0x112c9
movq 0x10(%rdi), %rax
testq %rsi, %rsi
jle 0x112e6
movq (%rax), %rax
decq %rsi
jne 0x112bf
jmp 0x112f1
cmpq %rsi, 0x40(%rdi)
jbe 0x112e2
movq 0x30(%rdi), %rdx
testq %rsi, %rsi
jle 0x112f8
movq (%rdx), %rdx
decq %rsi
jne 0x112d8
jmp 0x11303
xorl %edx, %edx
jmp 0x11307
je 0x112f1
movq 0x8(%rax), %rax
incq %rsi
jne 0x112e8
addq $0x18, %rax
xorl %edx, %edx
retq
je 0x11303
movq 0x8(%rdx), %rdx
incq %rsi
jne 0x112fa
addq $0x10, %rdx
addq $0x8, %rdx
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::to_source()
void Node::to_source()
{
    Value scope_start = Value(this->scope_type);

    this->env->write(scope_start, this->name());

    for(auto& v : this->values) {
        this->env->write(v.field, v.field.name());
    }

    for(auto& n : this->nodes) {
        n.field.to_source();
    }

    Value scope_end = Value(Type::Scope_End);
    this->env->write(scope_end, *this->name_ptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0x50(%rdi), %al
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl $0x0, 0x10(%rsp)
movb %al, 0x14(%rsp)
movw $0x0, 0x15(%rsp)
movq (%rdi), %rdi
movq 0x48(%rbx), %rdx
testq %rdx, %rdx
jne 0x12b52
movq 0x143ee(%rip), %rdx     # 0x26f40
movq %rsp, %rsi
callq 0xb8d0
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %r15
cmpq %r14, %r15
je 0x12b8e
movq 0x143d2(%rip), %r12     # 0x26f40
movq 0x18(%r15), %rdx
testq %rdx, %rdx
jne 0x12b7a
movq %r12, %rdx
movq (%rbx), %rdi
leaq 0x18(%r15), %rsi
callq 0xb8d0
movq (%r15), %r15
cmpq %r14, %r15
jne 0x12b6e
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r14, %r15
je 0x12ba9
leaq 0x18(%r15), %rdi
callq 0xb450
movq (%r15), %r15
jmp 0x12b96
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movw $0x10, 0x14(%rsi)
movb $0x0, 0x16(%rsi)
movq (%rbx), %rdi
movq 0x48(%rbx), %rdx
callq 0xb8d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::consume_scope()
void Node::consume_scope()
{
    int depth = 0;

    auto& parser = *this->env->parser;
    auto& source = this->env->in;

    while(!this->parsed) {
        auto tp = parser.read(source).second.type();
        if(TpTools::is_scope(tp)) {
            depth++;
            continue;
        }

        if(tp == Type::Scope_End) {
            depth--;
            if(depth <= 0) {
                this->parsed = true;
            }
        }
    }
}

// Assembly:
cmpb $0x0, 0x51(%rdi)
jne 0x12c5c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x250(%r14), %r15
addq $0x260, %r14            # imm = 0x260
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq (%r15), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
movb 0x2c(%rsp), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0xe, %cl
jne 0x12c2f
incl %r13d
jmp 0x12c43
cmpb $0x10, %al
jne 0x12c43
leal -0x1(%r13), %eax
cmpl $0x1, %r13d
jg 0x12c46
movb $0x1, 0x51(%rbx)
jmp 0x12c46
movl %r13d, %eax
cmpb $0x1, 0x51(%rbx)
movl %eax, %r13d
jne 0x12c0d
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::find_shared(unsigned long, std::function<std::shared_ptr<void> ()> const&)
pair<bool, shared_ptr<void>*> Node::find_shared (uint64_t key, const function<shared_ptr<void>(void)>& create)
{
    auto& table = this->env->shared_table_restore;
    auto* sptr = table.get(key);
    bool inserted_new = false;

    if(!sptr) {
        sptr = table.insert(key, create()).second;
        inserted_new = true;
    }

    return { inserted_new, sptr };
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movl $0x188, %r14d           # imm = 0x188
addq (%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xbbc0
testq %rax, %rax
je 0x12cc6
movq %rax, %rbx
xorl %eax, %eax
jmp 0x12d05
cmpq $0x0, 0x10(%r15)
je 0x12d12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%r15)
leaq 0x8(%rsp), %rcx
movq (%rcx), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0xb150
movq %rdx, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12d03
callq 0xb760
movb $0x1, %al
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xb2d0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12d29
callq 0xb760
movq %rbx, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::foreach_node(std::function<void (Srl::Node&)> const&, bool)
void Node::foreach_node(const function<void(Node&)>& fnc, bool recursive)
{
    for(auto& link : this->nodes) {

        fnc(link.field);

        if(recursive) {
            link.field.foreach_node(fnc, recursive);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x10(%rdi), %r13
addq $0x10, %r15
cmpq %r15, %r13
je 0x12d82
movl %edx, %ebx
movq %rsi, %r14
cmpq $0x0, 0x10(%r14)
je 0x12d8c
leaq 0x18(%r13), %r12
movq %r14, %rdi
movq %r12, %rsi
callq *0x18(%r14)
testb %bl, %bl
je 0x12d79
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xb1b0
movq (%r13), %r13
cmpq %r15, %r13
jne 0x12d50
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xb2d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::foreach_value(std::function<void (Srl::Value&)> const&, bool)
void Node::foreach_value(const function<void(Value&)>& fnc, bool recursive)
{
    for(auto& link : this->values) {
        fnc(link.field);
    }

    if(recursive) {
        this->foreach_node([&fnc](Node& node) {
            node.foreach_value(fnc);
        }, true);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq 0x30(%rdi), %r12
cmpq %r15, %r12
je 0x12dcc
cmpq $0x0, 0x10(%r14)
je 0x12e26
leaq 0x18(%r12), %rsi
movq %r14, %rdi
callq *0x18(%r14)
movq (%r12), %r12
jmp 0x12dae
testb %bpl, %bpl
je 0x12e19
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
movq %r14, (%rsi)
leaq 0xa16(%rip), %rax       # 0x137fc
movq %rax, 0x18(%rsi)
leaq 0xa1b(%rip), %rax       # 0x1380c
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0xb1b0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12e19
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
jmp 0x12e4f
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12e47
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xbe90
movq %rax, %rdi
callq 0xf059
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::find_nodes[abi:cxx11](Srl::String const&, bool)
list<Node*> Node::find_nodes(const String& name_, bool recursive)
{
    list<Node*> rslt;

    this->foreach_node([&rslt, name_] (Node& node) {
        if(node.name() == name_) {
            rslt.push_back(&node);
        }
    }, recursive);

    return rslt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x10(%rsp)
movl $0x18, %edi
callq 0xb920
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x98f(%rip), %rax       # 0x13832
movq %rax, 0x18(%rsi)
leaq 0xa88(%rip), %rax       # 0x13936
movq %rax, 0x10(%rsi)
movzbl %bpl, %edx
movq %r14, %rdi
callq 0xb1b0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12ed7
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12f05
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12f10
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x12f10
movq %rax, %rdi
callq 0xf059
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x12f2d
movq (%rdi), %r15
movl $0x18, %esi
callq 0xb940
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x12f18
movq %r14, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::find_values[abi:cxx11](Srl::String const&, bool)
list<Value*> Node::find_values(const String& name_, bool recursive)
{
    list<Value*> rslt;

    this->foreach_value([&rslt, name_] (Value& value) {
        if(value.name() == name_) {
            rslt.push_back(&value);
        }
    }, recursive);

    return rslt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x10(%rsp)
movl $0x18, %edi
callq 0xb920
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xa19(%rip), %rax       # 0x1399a
movq %rax, 0x18(%rsi)
leaq 0xb10(%rip), %rax       # 0x13a9c
movq %rax, 0x10(%rsi)
movzbl %bpl, %edx
movq %r14, %rdi
callq 0xbf10
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12fb5
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12fe3
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12fee
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x12fee
movq %rax, %rdi
callq 0xf059
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1300b
movq (%rdi), %r15
movl $0x18, %esi
callq 0xb940
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x12ff6
movq %r14, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::all_nodes[abi:cxx11](bool)
list<Node*> Node::all_nodes(bool recursive)
{
    list<Node*> rslt;

    this->foreach_node([&rslt] (Node& node) {
        rslt.push_back(&node);
    }, recursive);

    return rslt;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0xabf(%rip), %rcx       # 0x13b00
movq %rcx, 0x18(%rsi)
leaq 0xae4(%rip), %rcx       # 0x13b30
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0xb1b0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x13071
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x130af
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x1309a
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xc060
movq %r14, %rdi
callq 0xbe90
movq %rax, %rdi
callq 0xf059
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::all_values[abi:cxx11](bool)
list<Value*> Node::all_values(bool recursive)
{
    list<Value*> rslt;

    this->foreach_value([&rslt] (Value& value) {
        rslt.push_back(&value);
    }, recursive);

    return rslt;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0xa71(%rip), %rcx       # 0x13b56
movq %rcx, 0x18(%rsi)
leaq 0xa96(%rip), %rcx       # 0x13b86
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0xbf10
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x13115
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x13153
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x1313e
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xc08d
movq %r14, %rdi
callq 0xbe90
movq %rax, %rdi
callq 0xf059
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::has_node(Srl::String const&)
bool Node::has_node(const String& field_name)
{
    if(this->parsed) {
        return find_link<Name>(field_name, this->nodes, field_name) != nullptr;
    }

    auto unn = this->consume_item(field_name, false);

    return unn.node() != nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x51(%rdi)
jne 0x134d6
movups (%rsi), %xmm0
leaq 0x8(%rsp), %r15
movups %xmm0, (%r15)
addq $0x10, %r14
xorl %ebx, %ebx
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x134e3
movq 0x60(%r12), %rdi
movq %r15, %rsi
callq 0x13731
testb %al, %al
je 0x134b3
addq $0x10, %r12
movq %r12, %rbx
jmp 0x134e3
movq %r14, %rdi
xorl %edx, %edx
callq 0xb130
movq %rax, %rbx
testq %rbx, %rbx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::has_value(Srl::String const&)
bool Node::has_value(const String& field_name)
{
    if(this->parsed) {
        return find_link<Name>(field_name, this->values, field_name) != nullptr;
    }

    auto unn = this->consume_item(field_name, false);

    return unn.value() != nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x51(%rdi)
jne 0x13542
movups (%rsi), %xmm0
leaq 0x8(%rsp), %r15
movups %xmm0, (%r15)
addq $0x30, %r14
xorl %ebx, %ebx
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x1354f
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x13667
testb %al, %al
je 0x1351f
addq $0x10, %r12
movq %r12, %rbx
jmp 0x1354f
movq %r14, %rdi
xorl %edx, %edx
callq 0xb130
movq %rdx, %rbx
testq %rbx, %rbx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/include/Srl/Tools.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Srl::Tools::conv_charset<char>(Srl::String const&, bool)
std::basic_string<TChar> conv_charset(const String& str_wrap, bool throw_error)
    {
        static_assert(Lib::is_char<TChar>::value, "Srl Error. Not a character-type.");

        auto target_encoding = Lib::get_encoding<TChar>();

        if(str_wrap.encoding() == target_encoding) {
            return std::basic_string<TChar>(
                reinterpret_cast<const TChar*>(str_wrap.data()),
                str_wrap.size() / sizeof(TChar)
            );
        }

        std::vector<uint8_t> converted = conv_charset(target_encoding, str_wrap, throw_error);
        auto n_chars = converted.size() / sizeof(TChar);

        return n_chars > 0
            ? std::basic_string<TChar>(reinterpret_cast<const TChar*>(converted.data()), n_chars)
            : std::basic_string<TChar>();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
cmpb $0x1, 0xd(%rsi)
jne 0x13fd5
cmpb $0x0, 0xe(%rax)
movq %rax, %rsi
jne 0x13fbe
movq (%rax), %rsi
movl 0x8(%rax), %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xb2e0
jmp 0x14033
movzbl %dl, %ecx
movq %rsp, %r14
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0xbea0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%rbx), %rax
cmpq %rsi, %rdx
je 0x1400c
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xb2e0
movq (%rsp), %rsi
jmp 0x1401b
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
testq %rsi, %rsi
je 0x14033
movq 0x10(%rsp), %rax
subq %rsi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xb940
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14057
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xb940
movq %rbx, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::flush()
void Out::flush()
{
    if(this->streaming) {
        this->write_to_stream();
        this->stream->flush();

    } else {
        this->write_to_buffer();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x80(%rdi)
jne 0x14bac
movq %rbx, %rdi
callq 0xb460
movq 0x88(%rbx), %rdi
popq %rbx
jmp 0xb590
movq %rbx, %rdi
popq %rbx
jmp 0xbaa0
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::write_to_stream()
void Out::write_to_stream()
{
    if(!this->streaming || this->state.mem_start == nullptr) {
        return;
    }

    this->stream->write((const char*)this->state.mem_start, this->state.cap - this->state.left);

    this->state.left = this->state.cap;
    this->state.crr_mem = this->state.mem_start;
    this->state.segs_flushed++;
}

// Assembly:
cmpb $0x1, 0x80(%rdi)
jne 0x14bf5
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rsi
testq %rsi, %rsi
je 0x14bf4
movq 0x60(%rbx), %rdx
movq 0x88(%rbx), %rdi
subq 0x58(%rbx), %rdx
callq 0xbb40
movq 0x60(%rbx), %rax
movq 0x78(%rbx), %rcx
movq %rax, 0x58(%rbx)
movq %rcx, 0x70(%rbx)
incq 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::write_to_buffer()
void Out::write_to_buffer()
{
    assert(this->buffer);

    this->buffer->resize(this->state.sz_total);

    auto pos = 0U;
    auto* seg = this->heap.chain.used_segs.front;

    while(seg) {
        auto fill = seg->val.size - seg->val.left;
        memcpy(buffer->data() + pos, seg->val.data, fill);
        pos += fill;
        seg = seg->next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
testq %rdi, %rdi
je 0x14c59
movq 0x50(%rbx), %rsi
callq 0xb980
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x14c4e
xorl %ebp, %ebp
movl 0x14(%r15), %r14d
subl 0x10(%r15), %r14d
movq 0x90(%rbx), %rax
movl %ebp, %edi
addq (%rax), %rdi
movq 0x8(%r15), %rsi
movq %r14, %rdx
callq 0xb790
addl %ebp, %r14d
movq (%r15), %r15
movl %r14d, %ebp
testq %r15, %r15
jne 0x14c20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ad9(%rip), %rdi      # 0x1e739
leaq 0x9adf(%rip), %rsi      # 0x1e746
leaq 0x9ae8(%rip), %rcx      # 0x1e756
movl $0x34, %edx
callq 0xb540
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::insert_spacing(Srl::Type, Srl::Lib::Out&)
void PJson::insert_spacing(Type type, Out& out)
{
    if(!this->scope_closed && type != Type::Scope_End) {
        out.write(',');
    }
    if(this->compact) {
        return;
    }

    auto depth = this->scope_stack.size();

    if(type == Type::Scope_End && depth > 0) {
        depth -= 1;
    }

    if(this->scope_stack.size() > 0) {
        out.write('\n');
    }

    out.write_times(depth, '\t');
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x10, %esi
je 0x14ed4
cmpb $0x0, 0x61(%r14)
jne 0x14ed4
leaq 0xf(%rsp), %rsi
movb $0x2c, (%rsi)
movq %rbx, %rdi
callq 0xb500
cmpb $0x0, 0x8(%r14)
jne 0x14f96
cmpb $0x10, %bpl
sete %al
movq 0x40(%r14), %rcx
movq 0x58(%r14), %rdx
movq %rdx, %rsi
subq 0x38(%r14), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rdx
adcq $-0x1, %rsi
subq 0x48(%r14), %rcx
shlq $0x9, %rsi
addq 0x30(%r14), %rcx
addq %rsi, %rcx
movq 0x20(%r14), %rdx
movq %rcx, %r14
subq %rdx, %r14
setne %sil
andb %al, %sil
movzbl %sil, %eax
subq %rax, %r14
cmpq %rdx, %rcx
je 0x14f3d
leaq 0xe(%rsp), %rsi
movb $0xa, (%rsi)
movq %rbx, %rdi
callq 0xb500
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x14f7b
cmpq %r14, 0x58(%rbx)
jae 0x14f58
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x14f69
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
subq %r14, 0x58(%rbx)
movq 0x70(%rbx), %rdi
leaq (%rdi,%r14), %rax
movq %rax, 0x70(%rbx)
jmp 0x14f89
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
movq %rax, %rdi
movl $0x9, %esi
movq %r14, %rdx
callq 0xb420
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/PJson.cpp
// Function: (anonymous namespace)::insert_in_quotes(Srl::Lib::Out&, Srl::Lib::MemBlock const&, bool)
void insert_in_quotes(Out& out, const MemBlock& txt, bool escape = false)
    {
        out.write('\"');
        if(!escape) {
            out.write(txt);
        } else {
            write_escape(txt, out);
        }
        out.write('\"');
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movb $0x22, (%rsi)
callq 0xb500
testl %ebp, %ebp
je 0x150be
movb $0x22, 0x9(%rsp)
movw $0x225c, (%rsp)         # imm = 0x225C
movb $0x5c, 0x8(%rsp)
movw $0x5c5c, 0x16(%rsp)     # imm = 0x5C5C
movb $0x2f, 0x7(%rsp)
movw $0x2f5c, 0x14(%rsp)     # imm = 0x2F5C
movb $0xa, 0x6(%rsp)
movw $0x6e5c, 0x12(%rsp)     # imm = 0x6E5C
movb $0x9, 0x5(%rsp)
movw $0x745c, 0x10(%rsp)     # imm = 0x745C
movb $0xd, 0x4(%rsp)
movw $0x725c, 0xe(%rsp)      # imm = 0x725C
movb $0x8, 0x3(%rsp)
movw $0x625c, 0xc(%rsp)      # imm = 0x625C
movb $0xc, 0x2(%rsp)
movw $0x665c, 0xa(%rsp)      # imm = 0x665C
cmpq $0x0, 0x8(%r14)
je 0x15129
movl $0x1, %r15d
xorl %eax, %eax
movq %rsp, %r12
leaq 0x8(%rsp), %r13
leaq 0x16(%rsp), %rbp
movq (%r14), %rcx
movzbl (%rcx,%rax), %esi
movq %rbx, %rdi
leaq 0x9(%rsp), %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbp, %r9
leaq 0xa(%rsp), %rax
pushq %rax
leaq 0xa(%rsp), %rax
pushq %rax
leaq 0x1c(%rsp), %rax
pushq %rax
leaq 0x1b(%rsp), %rax
pushq %rax
leaq 0x2e(%rsp), %rax
pushq %rax
leaq 0x2c(%rsp), %rax
pushq %rax
leaq 0x40(%rsp), %rax
pushq %rax
leaq 0x3d(%rsp), %rax
pushq %rax
leaq 0x52(%rsp), %rax
pushq %rax
leaq 0x4e(%rsp), %rax
pushq %rax
leaq 0x64(%rsp), %rax
pushq %rax
leaq 0x5f(%rsp), %rax
pushq %rax
callq 0xb0e0
addq $0x60, %rsp
movl %r15d, %eax
incl %r15d
cmpq %rax, 0x8(%r14)
ja 0x15047
jmp 0x15129
movq (%r14), %r15
movq 0x8(%r14), %r14
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x15103
cmpq %r14, 0x58(%rbx)
jae 0x150e0
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x150f1
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
subq %r14, 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x1510e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
cmpq $0x1, %r14
jne 0x1511b
movb (%r15), %cl
movb %cl, (%rax)
jmp 0x15129
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb790
movq %rsp, %rsi
movb $0x22, (%rsi)
movq %rbx, %rdi
callq 0xb500
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq