LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x30, %rsi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x156b9
movl 0x8(%rdi), %eax
movq %rbx, %rcx
orq $0x7, %rcx
cmpq %rax, %rcx
jbe 0x156d1
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11960
movq %rax, %rdi
movq %rax, 0x8(%r14)
movl 0x8(%rax), %eax
movl 0xc(%rdi), %r14d
addq (%rdi), %r14
subq %rax, %r14
movl %r14d, %eax
andl $0x7, %eax
pushq $0x8
popq %rsi
subq %rax, %rsi
testq %rax, %rax
cmoveq %rax, %rsi
addq %rsi, %r14
orq %rbx, %rsi
callq 0x11410
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/String.hpp
// Function: Srl::String::operator==(Srl::String const&) const
inline bool String::operator== (const String& a) const
    {
        const auto cmp = [this](const uint8_t* mem, size_t sz) {

            return this->block.size == sz && memcmp(this->block.data(), mem, sz) == 0;
        };

        if(this->block.size == 0 && a.block.size == 0) {
            return true;
        }

        if(a.block.encoding == this->block.encoding) {
            return cmp(a.block.data(), a.block.size);

        } else {
            auto tmp = Tools::conv_charset(this->block.encoding, a, false);
            return cmp(tmp.data(), tmp.size());
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movl 0x8(%rsi), %ecx
movb $0x1, %bl
movl 0x8(%rdi), %edx
orl %ecx, %edx
je 0x15442
movq %rsi, %rax
movb 0xd(%rdi), %dl
cmpb %dl, 0xd(%rsi)
jne 0x1540f
movl %ecx, %edx
cmpb $0x0, 0xe(%rax)
jne 0x153fe
movq (%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x12bc0
movl %eax, %ebx
jmp 0x15442
movzbl %dl, %esi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x129a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x12bc0
movl %eax, %ebx
movq %r14, %rdi
callq 0x126a0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::redistribute()
void HTable<K, V, H>::redistribute()
    {
        if(this->limit == 0) {
            /* initial allocation */
            this->set_capacity(this->cap);
            this->table = this->alloc_table(this->cap);

            return;
        }

        auto old_dim = this->cap;
        this->set_capacity(this->cap * 2);

        auto* ntable = alloc_table(this->cap);

        for(auto i = 0U; i < old_dim; i++) {
            auto* entry = table[i];
            while(entry) {
                auto bucket = get_bucket(entry->hash);
                auto* slot = ntable[bucket];

                if(!slot) {
                    ntable[bucket] = entry;

                } else while(true) {
                    if(!slot->next) {
                        slot->next = entry;
                        break;
                    }
                    slot = slot->next;
                }

                auto* tmp = entry;
                entry = entry->next;
                tmp->next = nullptr;
            }
        }

        this->heap.put_mem((uint8_t*)this->table, old_dim * sizeof(nullptr));
        this->table = ntable;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
movq 0x8(%rdi), %r14
je 0x15674
leaq (%r14,%r14), %rsi
movq %rbx, %rdi
callq 0x116b0
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x11d20
movq %rax, %r15
xorl %ecx, %ecx
xorl %esi, %esi
movl %ecx, %ecx
cmpq %rcx, %r14
jbe 0x1565a
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rax
movq (%rax,%rcx,8), %r9
movq %rdi, %r8
shrq $0x20, %r8
testq %r9, %r9
je 0x15656
movq (%r9), %rdx
movq %rdx, %rax
shrq $0x20, %rax
testq %r8, %r8
cmovneq %rsi, %rax
xorq %rdx, %rax
xorl %edx, %edx
divq %rdi
movq (%r15,%rdx,8), %r10
testq %r10, %r10
je 0x15641
movq %r10, %rax
movq 0x8(%r10), %r10
testq %r10, %r10
jne 0x1562f
addq $0x8, %rax
jmp 0x15645
leaq (%r15,%rdx,8), %rax
movq %r9, (%rax)
movq 0x8(%r9), %rax
andq $0x0, 0x8(%r9)
movq %rax, %r9
jmp 0x15608
incl %ecx
jmp 0x155ee
leaq 0x48(%rbx), %rdi
movq 0x20(%rbx), %rsi
shlq $0x3, %r14
movq %r14, %rdx
callq 0x115f0
movq %r15, 0x20(%rbx)
jmp 0x1568f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x116b0
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x11d20
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rax)
movq %rsi, (%rax)
movq 0x161b7(%rip), %rcx     # 0x2bf90
movq %rcx, 0x18(%rax)
movq 0x16134(%rip), %rcx     # 0x2bf18
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x116d0
movq %rsp, %rdi
callq 0x12ce8
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x12ce8
movq %rbx, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x18(%rdi)
je 0x15e97
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movl %r15d, %r15d
cmpq %r15, 0x8(%r14)
jbe 0x15e8f
leaq (,%r15,8), %r12
addq 0x20(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x15e84
leaq 0x10(%r12), %rsi
leaq 0x18(%r12), %rdx
movq %rbx, %rdi
callq 0x11c00
testb %al, %al
jne 0x15e8f
addq $0x8, %r12
incl %ebp
jmp 0x15e5d
movl %ebp, %eax
incl %r15d
cmpq %rax, 0x18(%r14)
ja 0x15e48
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x16232
leaq 0x30(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x118a0
jmp 0x1624c
pushq $0x28
popq %rdi
callq 0x11ec0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %r14, (%rax)
movq %r14, 0x28(%rbx)
andq $0x0, (%r14)
addq $0x8, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movq %rsp, %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
xorl %ecx, %ecx
movq %r15, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x162e1
movq %rcx, %r13
leaq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x16612
movq %rbx, %rcx
testb %al, %al
je 0x1629b
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x11bc0
leaq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rbx, (%rax)
movq %rbx, 0x18(%r14)
andq $0x0, (%rbx)
leaq 0x8(%rbx), %rax
testq %rbx, %rbx
cmoveq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1632e
movl 0x8(%rax), %edx
testq %rdx, %rdx
je 0x1632e
movl 0xc(%rax), %esi
addq (%rax), %rsi
subq %rdx, %rsi
movq %rbx, %rdi
callq 0x115f0
cmpq $0x0, 0x20(%rbx)
je 0x1634f
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11720
movq %rax, %r12
testq %rax, %rax
jne 0x163d6
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
pushq $0x1
popq %rax
cmovneq %rcx, %rax
movq %rax, (%rbx)
cmpq %rdx, %r14
setae %cl
cmpq %r14, %rax
setae %dl
orb %cl, %dl
jne 0x16390
cmpq %r14, %rax
jae 0x16390
addq %rax, %rax
movq %rax, (%rbx)
jmp 0x16383
cmpq %r14, %rax
cmovaq %rax, %r14
movq %r15, %rdi
callq 0x113a0
movq %rax, %r13
leaq 0x8(%rax), %r12
movq %r14, %rdi
callq 0x11040
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)
andq $0x0, (%r13)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq 0x30(%rdi), %r15
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rdi), %rbp
xorl %r12d, %r12d
movq %r12, %r13
movq %r15, %r12
testq %r15, %r15
je 0x16514
movq (%r12), %r15
cmpb $0x1, 0x20(%r12)
jne 0x1646a
movq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x118a0
movq 0x48(%rbx), %rax
testq %rax, %rax
cmoveq %rbp, %rax
movq %r12, (%rax)
movq %r12, 0x48(%rbx)
andq $0x0, (%r12)
jmp 0x16429
leaq 0x8(%r12), %r14
movl 0x1c(%r12), %edx
movl %edx, 0x18(%r12)
movq 0x10(%r12), %rdi
xorl %esi, %esi
callq 0x116a0
andq $0x0, 0x8(%r12)
movl 0x1c(%r12), %eax
movq %rax, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x18(%rsp), %r13
cmpq $0x0, (%r13)
je 0x164e9
movq %r14, 0x10(%rsp)
movq 0x8(%rsp), %r14
xorl %ecx, %ecx
movq (%r14), %r14
testq %r14, %r14
je 0x164f6
movq %rcx, %r13
leaq 0x8(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x16612
movq %r14, %rcx
testb %al, %al
je 0x164b6
movq 0x10(%rsp), %rcx
movq %r14, (%rcx)
testq %r13, %r13
cmoveq 0x8(%rsp), %r13
jmp 0x1650b
movq 0x8(%rsp), %rax
movq %r14, (%rax)
movq %r14, %rcx
jmp 0x1650b
movq 0x10(%rsp), %rcx
andq $0x0, (%rcx)
movq 0x18(%rsp), %r13
movq (%r13), %rax
movq %rcx, (%rax)
movq %rcx, (%r13)
jmp 0x16426
andq $0x0, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::operator=(Srl::Lib::Heap&&)
Heap& Heap::operator= (Heap&& m)
{
    this->destroy();

    this->cap     = m.cap;
    this->crr_seg = m.crr_seg;
    this->chain   = m.chain;

    m.chain = Chain();
    m.crr_seg = nullptr;

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11f00
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movups 0x10(%rbx), %xmm0
movups 0x20(%rbx), %xmm1
movups 0x30(%rbx), %xmm2
movups 0x40(%rbx), %xmm3
movups %xmm3, 0x40(%r14)
movups %xmm2, 0x30(%r14)
movups %xmm1, 0x20(%r14)
movups %xmm0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
andq $0x0, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Aux::SList<Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::Link>::remove(Srl::Lib::Aux::SList<Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::Link>::Link*, Srl::Lib::Aux::SList<Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::Link>::Link*)
void Aux::SList<T>::remove(SList<T>::Link* prev, SList<T>::Link* link)
{
    this->front = link == front ? link->next : front;
    this->back  = link == back ? prev : back;
    if(prev) {
        prev->next = link->next;
    }
    link->next = nullptr;
}

// Assembly:
movq (%rdi), %rax
cmpq %rdx, %rax
jne 0x1666f
movq (%rdx), %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
cmoveq %rsi, %rax
movq %rax, 0x8(%rdi)
testq %rsi, %rsi
je 0x1668c
movq (%rdx), %rax
movq %rax, (%rsi)
andq $0x0, (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/In.cpp
// Function: Srl::Lib::In::set(Srl::Lib::In::Source)
void In::set(Source source)
{
    this->streaming = source.is_stream;
    this->anchor = nullptr;
    this->eof_reached = false;

    if(source.is_stream) {
        this->stream = source.stream;
        this->start = this->end = this->pos = nullptr;
        this->try_fetch_data(0, 1);

    } else {
        this->start = this->pos = source.block.ptr;
        this->end   = this->start + source.block.size + 1;
    }
}

// Assembly:
movb 0x18(%rsp), %cl
movb %cl, 0x18(%rdi)
andq $0x0, 0x48(%rdi)
movb $0x0, 0x28(%rdi)
movq 0x8(%rsp), %rax
cmpb $0x1, %cl
jne 0x166f3
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
pushq $0x1
popq %rdx
xorl %esi, %esi
jmp 0x11260
leaq 0x8(%rsp), %rcx
movq %rax, 0x10(%rdi)
movq %rax, (%rdi)
movq 0x8(%rcx), %rcx
addq %rcx, %rax
incq %rax
movq %rax, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::value(Srl::String const&)
Value& Node::value(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->values, name_, this->name());

    return link->field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rsi
movq %rbx, %rdi
callq 0x16b66
movq %rax, %r12
movq 0x48(%r15), %r14
testq %r14, %r14
jne 0x16ad9
movq 0x15467(%rip), %r14     # 0x2bf40
addq $0x30, %r15
movq 0x1545c(%rip), %rbp     # 0x2bf40
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x16b24
cmpq %r12, 0x10(%r13)
jne 0x16ae7
movq 0x18(%r13), %rdi
testq %rdi, %rdi
jne 0x16b02
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x114d0
testb %al, %al
je 0x16ae7
addq $0x18, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x115e0
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x17744
movq 0x154a4(%rip), %rsi     # 0x2bfe8
movq 0x153fd(%rip), %rdx     # 0x2bf48
movq %r15, %rdi
callq 0x12920
movq %rax, %rbx
movq %r15, %rdi
callq 0x119b0
movq %rbx, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rsi
movq %rbx, %rdi
callq 0x16b66
movq %rax, %r12
movq 0x48(%r15), %r14
testq %r14, %r14
jne 0x16bbd
movq 0x15383(%rip), %r14     # 0x2bf40
addq $0x10, %r15
movq 0x15378(%rip), %rbp     # 0x2bf40
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x16c08
cmpq %r12, 0x10(%r13)
jne 0x16bcb
movq 0x60(%r13), %rdi
testq %rdi, %rdi
jne 0x16be6
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x114d0
testb %al, %al
je 0x16bcb
addq $0x18, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x115e0
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x17744
movq 0x153c0(%rip), %rsi     # 0x2bfe8
movq 0x15319(%rip), %rdx     # 0x2bf48
movq %r15, %rdi
callq 0x12920
movq %rax, %rbx
movq %r15, %rdi
callq 0x119b0
movq %rbx, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::try_get(Srl::String const&)
optional<Union> Node::try_get(const String& name_)
{
    try {
        auto res = this->get(name_);
        return { res };

    } catch(...) {
        return { };
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x11bd0
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
callq 0x114c0
movb $0x0, 0x10(%rbx)
callq 0x12810
jmp 0x17004
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
leaq 0x28(%r14), %rdx
callq 0x17173
testq %rax, %rax
je 0x17051
movq %rax, %rdx
addq $0x8, %rdx
xorl %r12d, %r12d
jmp 0x170a4
movups (%rbx), %xmm0
movq 0x48(%r14), %r15
testq %r15, %r15
jne 0x17064
movq 0x14edc(%rip), %r15     # 0x2bf40
leaq 0x8(%rsp), %r13
movups %xmm0, (%r13)
addq $0x10, %r14
movq 0x14ec7(%rip), %rbp     # 0x2bf40
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x170b6
movq 0x60(%r12), %rdi
testq %rdi, %rdi
jne 0x17092
movq %rbp, %rdi
movq %r13, %rsi
callq 0x114d0
testb %al, %al
je 0x1707c
addq $0x18, %r12
xorl %edx, %edx
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x115e0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x17744
movq 0x14f12(%rip), %rsi     # 0x2bfe8
movq 0x14e6b(%rip), %rdx     # 0x2bf48
movq %r14, %rdi
callq 0x12920
movq %rax, %rbx
movq %r14, %rdi
callq 0x119b0
movq %rbx, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
cmpq %rsi, 0x20(%rdi)
jbe 0x17142
movq 0x10(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x11f90
movq (%rbx), %rax
addq $0x18, %rax
xorl %edx, %edx
jmp 0x1716d
cmpq %rsi, 0x40(%rdi)
jbe 0x17165
movq 0x30(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x12480
movq (%rbx), %rdx
addq $0x10, %rdx
jmp 0x17167
xorl %edx, %edx
addq $0x8, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Lib::Link<Srl::Value>* (anonymous namespace)::find_link<(unsigned char)64, Srl::String, Srl::Value>(Srl::String, std::__cxx11::list<Srl::Lib::Link<Srl::Value>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Value>>>&, Srl::String const&, Srl::String const&)
Link<T>* find_link(TKey key, Cont<T>& links, const String& field_name = Environment::EmptyString,
                                                 const String& node_name = Environment::EmptyString)
    {
        Itr<T> end    = links.end();
        Link<T>* rslt = nullptr;

        for(auto itr = links.begin(); itr != end; itr++) {
            if(compare<Opt, T>(itr, key)) {

                if(enabled(Opt, Throw) && rslt) {
                    auto msg = tp_name<T>() + " duplication: <" + field_name.unwrap(false) + "> in <" + node_name.unwrap(false) + ">";
                    throw Exception(msg);
                }

                rslt = &*itr;

                if(enabled(Opt, Remove)) {
                    links.erase(itr);
                    rslt = nullptr;
                    break;
                }

                if(!enabled(Opt, Check_Duplicate)) {
                    break;
                }
            }
        }

        if(enabled(Opt, Throw) && !rslt) {
            throw field_name_not_found_ex(field_name, node_name);
        }

        return rslt;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
leaq 0x10(%rsp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
addq $0x8, %rbx
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq %rbx, %r13
movq (%r13), %r13
movq %r13, 0x8(%rsp)
cmpq %rbx, %r13
je 0x171c2
movq %r12, %rdi
movq %r15, %rsi
callq 0x18913
testb %al, %al
je 0x1719e
addq $0x10, %r13
movq %r13, %r14
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andl $0x0, 0x10(%rsp)
movb %al, 0x14(%rsp)
andw $0x0, 0x15(%rsp)
movq (%rdi), %rdi
movq 0x48(%rbx), %rdx
testq %rdx, %rdx
jne 0x18264
movq 0x13cdc(%rip), %rdx     # 0x2bf40
movq %rsp, %rsi
callq 0x11e20
leaq 0x30(%rbx), %r14
movq 0x13cc9(%rip), %r15     # 0x2bf40
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x1829f
movq 0x18(%r12), %rdx
testq %rdx, %rdx
jne 0x18290
movq %r15, %rdx
movq (%rbx), %rdi
leaq 0x18(%r12), %rsi
callq 0x11e20
jmp 0x1827a
leaq 0x10(%rbx), %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x182b9
leaq 0x18(%r15), %rdi
callq 0x116e0
jmp 0x182a6
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andl $0x0, 0x10(%rsi)
movw $0x10, 0x14(%rsi)
movb $0x0, 0x16(%rsi)
movq (%rbx), %rdi
movq 0x48(%rbx), %rdx
callq 0x11e20
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
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
cmpb $0x0, 0x51(%rbx)
jne 0x18355
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
je 0x18350
cmpb $0x10, %al
jne 0x18313
leal -0x1(%r13), %eax
cmpl $0x1, %r13d
movl %eax, %r13d
jg 0x18313
movb $0x1, 0x51(%rbx)
movl %eax, %r13d
jmp 0x18313
incl %r13d
jmp 0x18313
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::insert_shared(void const*)
pair<bool, uint64_t> Node::insert_shared (const void* obj)
{
    bool exists; size_t* key;
    auto& table = this->env->shared_table_store;

    tie(exists, key) = table.insert(obj, table.num_entries());

    return { exists, *key };
}

// Assembly:
subq $0x18, %rsp
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movq (%rdi), %rdi
movq 0x108(%rdi), %rcx
addq $0xf0, %rdi
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, %rsi
callq 0x113f0
movq (%rdx), %rdx
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12420
testq %rax, %rax
je 0x183ce
movq %rax, %rbx
xorl %eax, %eax
jmp 0x183fd
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x122c0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x11570
movq %rdx, %rbx
leaq 0x18(%rsp), %rdi
callq 0x11ef0
movb $0x1, %al
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x11ef0
movq %rbx, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %r15
pushq $0x1
popq %rbp
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x18468
leaq 0x18(%r13), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x11650
testb %bl, %bl
je 0x1843d
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x11290
jmp 0x1843d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x184ab
leaq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0x12b80
jmp 0x18493
testb %bpl, %bpl
je 0x184e4
movq %rsp, %rsi
andq $0x0, 0x8(%rsi)
movq %r14, (%rsi)
leaq 0x48a(%rip), %rax       # 0x1894c
movq %rax, 0x18(%rsi)
leaq 0x48f(%rip), %rax       # 0x1895c
movq %rax, 0x10(%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x11290
movq %rsp, %rdi
callq 0x12ce8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x12ce8
movq %rbx, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x11ec0
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x431(%rip), %rax       # 0x18982
movq %rax, 0x18(%rsi)
leaq 0x464(%rip), %rax       # 0x189c0
movq %rax, 0x10(%rsi)
movzbl %bpl, %edx
movq %r14, %rdi
callq 0x11290
movq %rsp, %rdi
callq 0x12ce8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18584
movq %rax, %r14
movq %rsp, %rdi
callq 0x12ce8
movq %rbx, %rdi
callq 0x11ea0
movq %r14, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x11ec0
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x433(%rip), %rax       # 0x18a20
movq %rax, 0x18(%rsi)
leaq 0x464(%rip), %rax       # 0x18a5c
movq %rax, 0x10(%rsi)
movzbl %bpl, %edx
movq %r14, %rdi
callq 0x12a30
movq %rsp, %rdi
callq 0x12ce8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18620
movq %rax, %r14
movq %rsp, %rdi
callq 0x12ce8
movq %rbx, %rdi
callq 0x12310
movq %r14, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0x453(%rip), %rcx       # 0x18abc
movq %rcx, 0x18(%rsi)
leaq 0x45c(%rip), %rcx       # 0x18ad0
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0x11290
leaq 0x8(%rsp), %rdi
callq 0x12ce8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x12ce8
movq %rbx, %rdi
callq 0x11ea0
movq %r14, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0x417(%rip), %rcx       # 0x18af6
movq %rcx, 0x18(%rsi)
leaq 0x420(%rip), %rcx       # 0x18b0a
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0x12a30
leaq 0x8(%rsp), %rdi
callq 0x12ce8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x12ce8
movq %rbx, %rdi
callq 0x12310
movq %r14, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18fa4
cmpb $0x0, 0xe(%rax)
movq %rax, %rsi
jne 0x18f8d
movq (%rax), %rsi
movl 0x8(%rax), %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x11480
jmp 0x18fe9
movzbl %dl, %ecx
movq %rsp, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x129a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%rbx), %rax
cmpq %rsi, %rdx
je 0x18fd5
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x11480
jmp 0x18fe1
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rsp, %rdi
callq 0x126a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x126a0
movq %rbx, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::inc_cap(unsigned long)
void Out::inc_cap(size_t nbytes)
{
    this->state.cap = Stream_Buffer_Size < nbytes ? nbytes : Stream_Buffer_Size;
    this->state.mem_start = this->heap.get_mem(this->state.cap);
    this->state.left = this->state.cap;
    this->state.crr_mem = this->state.mem_start;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x401, %rsi            # imm = 0x401
movl $0x400, %eax            # imm = 0x400
cmovbq %rax, %rsi
movq %rsi, 0x60(%rdi)
callq 0x117f0
movq %rax, 0x78(%rbx)
movq 0x60(%rbx), %rcx
movq %rcx, 0x58(%rbx)
movq %rax, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19b58
movq %rbx, %rdi
callq 0x116f0
movq 0x88(%rbx), %rdi
popq %rbx
jmp 0x11920
movq %rbx, %rdi
popq %rbx
jmp 0x12170
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19ba1
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rsi
testq %rsi, %rsi
je 0x19ba0
movq 0x60(%rbx), %rdx
movq 0x88(%rbx), %rdi
subq 0x58(%rbx), %rdx
callq 0x12270
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_O2/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 0x19c02
movq 0x50(%rbx), %rsi
callq 0x11f70
leaq 0x10(%rbx), %r15
xorl %ebp, %ebp
movq (%r15), %r15
testq %r15, %r15
je 0x19bf7
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 0x11bf0
addl %ebp, %r14d
movl %r14d, %ebp
jmp 0x19bc7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7b50(%rip), %rdi      # 0x21759
leaq 0x7b56(%rip), %rsi      # 0x21766
leaq 0x7b5f(%rip), %rcx      # 0x21776
pushq $0x34
popq %rdx
callq 0x11890
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x10, %esi
je 0x19df5
cmpb $0x0, 0x61(%r14)
jne 0x19df5
leaq 0x7(%rsp), %rsi
movb $0x2c, (%rsi)
movq %rbx, %rdi
callq 0x11800
cmpb $0x0, 0x8(%r14)
jne 0x19e58
cmpb $0x10, %bpl
sete %bpl
addq $0x10, %r14
movq %r14, %rdi
callq 0x12300
movq %rax, %r15
testq %rax, %rax
setne %al
andb %bpl, %al
movzbl %al, %eax
subq %rax, %r15
movq %r14, %rdi
callq 0x12300
testq %rax, %rax
je 0x19e3f
leaq 0x6(%rsp), %rsi
movb $0xa, (%rsi)
movq %rbx, %rdi
callq 0x11800
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11a90
pushq $0x9
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x116a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12(%rsp), %rsi
movb $0x22, (%rsi)
callq 0x11800
testl %ebp, %ebp
je 0x19f63
leaq 0x1d(%rsp), %rdx
movb $0x22, (%rdx)
leaq 0x12(%rsp), %rcx
movw $0x225c, (%rcx)         # imm = 0x225C
leaq 0x1c(%rsp), %r8
movb $0x5c, (%r8)
leaq 0x26(%rsp), %r9
movw $0x5c5c, (%r9)          # imm = 0x5C5C
leaq 0x11(%rsp), %rax
movb $0x2f, (%rax)
leaq 0x16(%rsp), %rax
movw $0x2f5c, (%rax)         # imm = 0x2F5C
leaq 0x10(%rsp), %rax
movb $0xa, (%rax)
leaq 0x14(%rsp), %rax
movw $0x6e5c, (%rax)         # imm = 0x6E5C
leaq 0xf(%rsp), %rax
movb $0x9, (%rax)
leaq 0x24(%rsp), %r13
movw $0x745c, (%r13)         # imm = 0x745C
leaq 0x1b(%rsp), %rbp
movb $0xd, (%rbp)
leaq 0x22(%rsp), %rax
movw $0x725c, (%rax)         # imm = 0x725C
leaq 0x1a(%rsp), %r10
movb $0x8, (%r10)
leaq 0x20(%rsp), %r11
movw $0x625c, (%r11)         # imm = 0x625C
leaq 0x19(%rsp), %r15
movb $0xc, (%r15)
leaq 0x1e(%rsp), %r12
movw $0x665c, (%r12)         # imm = 0x665C
movq %rbx, %rdi
movq %r14, %rsi
pushq %r12
pushq %r15
pushq %r11
pushq %r10
pushq %rax
pushq %rbp
pushq %r13
leaq 0x47(%rsp), %rax
pushq %rax
leaq 0x54(%rsp), %rax
pushq %rax
leaq 0x58(%rsp), %rax
pushq %rax
leaq 0x66(%rsp), %rax
pushq %rax
leaq 0x69(%rsp), %rax
pushq %rax
callq 0x123b0
addq $0x60, %rsp
jmp 0x19f6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11cd0
leaq 0x12(%rsp), %rsi
movb $0x22, (%rsi)
movq %rbx, %rdi
callq 0x11800
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::process_quote(Srl::Lib::In&, Srl::PJson::State&)
void PJson::process_quote(In& source, State& state)
{
    if(this->scope_type == Type::Null) {
        this->throw_exception(state, "Value not in a scope.");
    }
    /* skip opening quotation-mark */
    source.move(1, error);

    auto& buffer = state.name_processed ? this->value_buffer : this->name_buffer;
    MemBlock block = read_unescape(source, buffer);

    this->process_string(block, state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
cmpb $0xb, 0x60(%rdi)
je 0x1a405
movq %rsi, %r13
movq %rdi, %r14
leaq 0x13462(%rip), %rdx     # 0x2d6e0
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x12a40
leaq 0x68(%r14), %r15
leaq 0x80(%r14), %rax
cmpb $0x0, 0x29(%rbx)
cmovneq %rax, %r15
leaq 0x19(%rsp), %r8
movb $0x22, (%r8)
leaq 0x28(%rsp), %rax
movw $0x225c, (%rax)         # imm = 0x225C
movq %rax, %r9
leaq 0x9(%rsp), %rax
movb $0x27, (%rax)
leaq 0x14(%rsp), %rax
movw $0x275c, (%rax)         # imm = 0x275C
leaq 0x8(%rsp), %rax
movb $0x5c, (%rax)
leaq 0x12(%rsp), %rax
movw $0x5c5c, (%rax)         # imm = 0x5C5C
leaq 0x7(%rsp), %rax
movb $0x2f, (%rax)
leaq 0x10(%rsp), %rax
movw $0x2f5c, (%rax)         # imm = 0x2F5C
leaq 0x6(%rsp), %rax
movb $0xa, (%rax)
leaq 0xe(%rsp), %rax
movw $0x6e5c, (%rax)         # imm = 0x6E5C
leaq 0x5(%rsp), %rax
movb $0x9, (%rax)
leaq 0xc(%rsp), %rax
movw $0x745c, (%rax)         # imm = 0x745C
leaq 0x4(%rsp), %rax
movb $0xd, (%rax)
leaq 0xa(%rsp), %rax
movw $0x725c, (%rax)         # imm = 0x725C
leaq 0x18(%rsp), %r10
movb $0x8, (%r10)
leaq 0x1e(%rsp), %r11
movw $0x625c, (%r11)         # imm = 0x625C
leaq 0x17(%rsp), %rbp
movb $0xc, (%rbp)
leaq 0x1c(%rsp), %r12
movw $0x665c, (%r12)         # imm = 0x665C
leaq 0x1a(%rsp), %rax
movw $0x755c, (%rax)         # imm = 0x755C
movq %rbx, 0x20(%rsp)
leaq 0x133a3(%rip), %rbx     # 0x2d700
pushq $0x22
popq %rdx
movq %r13, %rdi
leaq 0x13376(%rip), %rsi     # 0x2d6e0
movq %r15, %rcx
movq %r9, %r13
pushq %rax
pushq %rbx
pushq %r12
pushq %rbp
pushq %r11
pushq %r10
leaq 0x3a(%rsp), %rax
pushq %rax
leaq 0x3c(%rsp), %rax
pushq %rax
leaq 0x4c(%rsp), %rax
pushq %rax
leaq 0x4d(%rsp), %rax
pushq %rax
leaq 0x5e(%rsp), %rax
pushq %rax
leaq 0x5e(%rsp), %rax
pushq %rax
leaq 0x70(%rsp), %rax
pushq %rax
leaq 0x6f(%rsp), %rax
pushq %rax
leaq 0x82(%rsp), %rax
pushq %rax
leaq 0x80(%rsp), %rax
pushq %rax
leaq 0x94(%rsp), %rax
pushq %rax
leaq 0x91(%rsp), %rax
pushq %rax
callq 0x12690
addq $0x90, %rsp
movq (%r15), %rcx
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
movq 0x20(%rsp), %rdx
callq 0x11cc0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7444(%rip), %rdi      # 0x21850
callq 0x11c90
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
movw $0x10c, 0xc(%rcx)       # imm = 0x10C
movb $0x0, 0xe(%rcx)
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x11100
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::process_bracket(char, Srl::PJson::State&)
void PJson::process_bracket(char bracket, State& state)
{
    Type type = bracket == '{' ? Type::Object
              : bracket == '[' ? Type::Array
              : Type::Scope_End;

    if(type == Type::Scope_End) {
        if(this->scope_stack.empty()) {
            this->throw_exception(state, "Redundant scope delimiter.");
        }

        this->scope_stack.pop();
        this->scope_type = !this->scope_stack.empty()
            ? this->scope_stack.top()
            : Type::Null;

    } else {
        this->scope_stack.push(type);
        this->scope_type = type;
    }

    state.value = Value(type);
    state.complete = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x5b, %sil
sete %al
movb $0x10, %cl
subb %al, %cl
cmpb $0x7b, %sil
movzbl %cl, %eax
pushq $0xe
popq %rcx
cmovnel %eax, %ecx
movb %cl, 0xf(%rsp)
cmpb $0x10, %cl
jne 0x1a71f
movq 0x40(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x1a75e
leaq 0x10(%r14), %rdi
callq 0x123e0
movq 0x40(%r14), %rcx
movb $0x10, %al
cmpq 0x20(%r14), %rcx
je 0x1a737
cmpq 0x48(%r14), %rcx
jne 0x1a71a
movq 0x58(%r14), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
movb -0x1(%rcx), %cl
jmp 0x1a739
leaq 0x10(%r14), %rdi
leaq 0xf(%rsp), %r15
movq %r15, %rsi
callq 0x11030
movb (%r15), %cl
movl %ecx, %eax
jmp 0x1a739
movb $0xb, %cl
movb %cl, 0x60(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
movb %al, 0x24(%rbx)
andw $0x0, 0x25(%rbx)
movb $0x1, 0x28(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x70d0(%rip), %rdi      # 0x21835
callq 0x115a0
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
movw $0x10c, 0xc(%rcx)       # imm = 0x10C
movb $0x0, 0xe(%rcx)
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x11100