LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: night-shift[P]Srl/src/lib/Heap.cpp
// Function: (anonymous namespace)::set_subsegment(Srl::Lib::Heap::Segment&, unsigned char*, unsigned long)
void set_subsegment(Heap::Segment& seg, uint8_t* data, size_t sz)
    {
        memset(data, 0, sz);
        seg.data = data;
        seg.left = sz;
        seg.size = sz;
        seg.sub_seg = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x343e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x43670
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x435e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x435b2
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0x38af0
cmpq $0x0, -0x20(%rbp)
je 0x435c7
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
jmp 0x435cf
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x435cf
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::Link* Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::find_rm<(anonymous namespace)::Size>((anonymous namespace)::Size const&)
typename Aux::SList<T>::Link*
Aux::SList<T>::find_rm(const Predicate& pred)
{
    Link* link = this->front;
    Link* prev = nullptr;

    while(link) {
        if(pred(link->val)) {
            remove(prev, link);
            return link;
        }

        prev = link;
        link = link->next;
    }

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x43655
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x43d80
testb $0x1, %al
jne 0x43625
jmp 0x43640
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x352e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4365d
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x43607
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x4378b
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x8(%rax)
jbe 0x4378b
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x37a90
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq 0x8(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x341a0
movq -0x40(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x437be
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x344f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x437be
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x438d6
movq -0x40(%rbp), %rax
cmpq $0x1, (%rax)
jae 0x437d3
movl $0x1, %eax
movq %rax, -0x48(%rbp)
jmp 0x43808
movq -0x40(%rbp), %rax
movq (%rax), %rax
shlq %rax
cmpq $0x40000, %rax          # imm = 0x40000
jae 0x437f5
movq -0x40(%rbp), %rax
movq (%rax), %rax
shlq %rax
movq %rax, -0x50(%rbp)
jmp 0x43800
movl $0x40000, %eax          # imm = 0x40000
movq %rax, -0x50(%rbp)
jmp 0x43800
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x40000, -0x18(%rbp)   # imm = 0x40000
jae 0x43869
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x43869
jmp 0x4382c
movq -0x40(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x4384f
movq -0x40(%rbp), %rax
cmpq $0x40000, (%rax)        # imm = 0x40000
setb %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x43858
jmp 0x43867
movq -0x40(%rbp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
jmp 0x4382c
jmp 0x43869
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x43883
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x4388b
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x33a60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x438e0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq -0x38(%rbp), %rsi
callq 0x38af0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: night-shift[P]Srl/src/lib/Heap.cpp
// Function: (anonymous namespace)::set_segment(Srl::Lib::Heap::Segment&, unsigned long)
void set_segment(Heap::Segment& seg, size_t sz)
    {
        seg.data = new uint8_t[sz];
        seg.left = sz;
        seg.size = sz;
        seg.sub_seg = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33040
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
callq 0x362c0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
addq $0x10, %rdi
callq 0x362c0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43a20
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x439c2
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x349f0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x38340
jmp 0x43a13
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x43a40
movq -0x38(%rbp), %rax
addq $0x10, %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
callq 0x43670
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq -0x30(%rbp), %rsi
callq 0x43a90
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x43972
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Heap.cpp
// Function: void Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::prepend<(anonymous namespace)::Size>((anonymous namespace)::Size const&, Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::Link*)
void Aux::SList<T>::prepend(const Pred& pred, SList<T>::Link* link)
{
    if(!this->back) {
        this->front = link;
        this->back  = link;

    } else {

        Link* curr = this->front;
        Link* prev = nullptr;

        while(curr) {
            if(pred(curr->val)) {
                link->next = curr;
                if(prev) {
                    prev->next = link;
                } else {
                    front = link;
                }
                return;
            }
            prev = curr;
            curr = curr->next;
        }

        link->next = nullptr;
        this->back->next = link;
        this->back = link;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x43acb
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x43b5f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x43b3d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x43d80
testb $0x1, %al
jne 0x43afc
jmp 0x43b28
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x43b1b
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x43b26
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x43b5f
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x43ade
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rcx)
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
addq $0x10, %rsi
addq $0x20, %rsi
leaq -0x9(%rbp), %rdi
callq 0x43c20
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
addq $0x30, %rsi
leaq -0x9(%rbp), %rdi
callq 0x43c20
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x343e0
leaq -0x50(%rbp), %rdi
callq 0x36650
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
leaq -0x50(%rbp), %rsi
movl $0x40, %edx
callq 0x35360
movq -0x58(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x35de0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
movl $0x40, %edx
callq 0x35360
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x343e0
leaq -0x50(%rbp), %rdi
callq 0x36650
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq -0x50(%rbp), %rsi
movl $0x40, %edx
callq 0x35360
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x8(%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::append(Srl::Lib::Aux::SList<Srl::Lib::Heap::Segment>::Link*)
void Aux::SList<T>::append(SList<T>::Link* link)
{
    if(!this->back) {
        this->front = link;
        this->back  = link;

    } else {
        this->back->next = link;
        this->back = link;
    }

    link->next = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x43e80
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x43e97
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jne 0x43f8e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x43f99
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, (%rcx)
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x43fb8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x43fc4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x43fe5
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movb 0x10(%rax), %dl
andb $0x1, %dl
movb %dl, 0x18(%rcx)
movq $0x0, 0x48(%rcx)
movb $0x0, 0x28(%rcx)
testb $0x1, 0x10(%rax)
je 0x4423d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x33710
jmp 0x4425e
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, (%rax)
movq (%rax), %rcx
addq 0x8(%rdx), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::insert_value(Srl::Value const&, Srl::String const&)
void Node::insert_value(const Value& new_value, const String& name_)
{
    if(this->env->parsing) {
        this->env->write(new_value, name_);

    } else {
        this->env->store_value(*this, new_value, name_);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
testb $0x1, 0x258(%rax)
je 0x44f5e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x35a70
jmp 0x44f72
movq -0x20(%rbp), %rsi
movq (%rsi), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x387c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
callq 0x45100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x384b0
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x362a0
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq %rax, %r8
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x45160
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
callq 0x45100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x384b0
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x362a0
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq %rax, %r8
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x45560
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Lib::Link<Srl::Value>* (anonymous namespace)::get_link_at_index<(unsigned char)16, Srl::Value>(unsigned long, std::__cxx11::list<Srl::Lib::Link<Srl::Value>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Value>>>&)
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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37c30
movq %rax, %rcx
movq -0xd8(%rbp), %rax
cmpq %rcx, %rax
jae 0x4596a
movq -0x10(%rbp), %rdi
callq 0x34cb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x38bd0
leaq -0x18(%rbp), %rdi
callq 0x37930
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
callq 0x492e0
movq %rax, %rdx
leaq 0x23c59(%rip), %rsi     # 0x695d2
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x356d0
movq -0xe0(%rbp), %rsi
leaq 0x23c48(%rip), %rdx     # 0x695e2
leaq -0x80(%rbp), %rdi
callq 0x336d0
jmp 0x459a5
movq -0x8(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x33c20
jmp 0x459b7
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x354a0
jmp 0x459cd
leaq 0x23c1b(%rip), %rdx     # 0x695ef
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x336d0
jmp 0x459e3
leaq -0x60(%rbp), %rdi
callq 0x38ce0
leaq -0xd0(%rbp), %rdi
callq 0x38ce0
leaq -0x80(%rbp), %rdi
callq 0x38ce0
leaq -0xa0(%rbp), %rdi
callq 0x38ce0
movl $0x28, %edi
callq 0x34160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x33910
jmp 0x45a2f
movq -0xe8(%rbp), %rdi
movq 0x3d5ab(%rip), %rsi     # 0x82fe8
movq 0x3d4f4(%rip), %rdx     # 0x82f38
callq 0x37fc0
jmp 0x45b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x45aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x45ab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x45aa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x38ce0
leaq -0xd0(%rbp), %rdi
callq 0x38ce0
leaq -0x80(%rbp), %rdi
callq 0x38ce0
leaq -0xa0(%rbp), %rdi
callq 0x38ce0
jmp 0x45b03
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
callq 0x34ce0
jmp 0x45afa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x38ce0
movq -0xa8(%rbp), %rdi
callq 0x38210
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35300
movq %rdx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x45d8f
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x36de0
jmp 0x45dd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x33df0
movq -0x50(%rbp), %rdi
callq 0x36af0
callq 0x37ac0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x362a0
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq %rax, %r8
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x45fd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x45e5c
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x368f0
jmp 0x45eb8
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x362a0
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq %rax, %r8
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x46060
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x33a40
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::try_get(unsigned long)
optional<Union> Node::try_get(size_t index)
{
    try {
        auto res = this->get(index);
        return { res };

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x346e0
movq %rdx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x45eff
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x36de0
jmp 0x45f41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x33df0
movq -0x50(%rbp), %rdi
callq 0x36af0
callq 0x37ac0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::get(unsigned long)
Union Node::get(size_t index)
{
    auto* resnode = get_link_at_index<None>(index, this->nodes);

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

    auto* resvalue = get_link_at_index<None>(index, this->values);

    return Union(resvalue->field);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rsi
callq 0x463c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x45f93
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x33a40
jmp 0x45fb9
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x28, %rsi
callq 0x46430
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x368f0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: night-shift[P]Srl/src/lib/Node.cpp
// Function: std::__cxx11::list<Srl::Lib::Link<Srl::Node>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Node>>>::iterator (anonymous namespace)::find_link_iterator<Srl::Node>(Srl::String const&, std::__cxx11::list<Srl::Lib::Link<Srl::Node>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Node>>>&, Srl::Lib::Environment&)
Itr<T> find_link_iterator(const String& name, Cont<T>& links, Environment& env)
    {
        auto hash = hash_string(name, env);

        for(auto itr = links.begin(), end = links.end(); itr != end; itr++) {

            if(compare<Hash, T>(itr, hash) && compare<Name, T>(itr, name)) {
                return itr;

            }
        }

        return links.end();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x45100
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34010
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq %rax, -0x30(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x357a0
testb $0x1, %al
jne 0x472e2
jmp 0x4731d
movq -0x28(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x49560
testb $0x1, %al
jne 0x472f5
jmp 0x4730a
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x49520
testb $0x1, %al
jne 0x47308
jmp 0x4730a
jmp 0x4732a
jmp 0x4730c
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x34a30
movq %rax, -0x38(%rbp)
jmp 0x472cf
movq -0x18(%rbp), %rdi
callq 0x36ee0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
movzbl 0x50(%rax), %esi
callq 0x33ff0
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x88(%rbp)
callq 0x362a0
movq -0x88(%rbp), %rdi
movq %rax, %rdx
leaq -0x20(%rbp), %rsi
callq 0x35a70
movq -0x80(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x34cb0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x344b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x337f0
testb $0x1, %al
jne 0x48093
jmp 0x480ee
leaq -0x30(%rbp), %rdi
callq 0x37930
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x35770
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0x35a70
leaq -0x30(%rbp), %rdi
callq 0x38360
jmp 0x48080
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x34010
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x36ee0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x357a0
testb $0x1, %al
jne 0x48127
jmp 0x4814c
leaq -0x50(%rbp), %rdi
callq 0x36960
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x34450
leaq -0x50(%rbp), %rdi
callq 0x38400
jmp 0x48114
leaq -0x78(%rbp), %rdi
movl $0x10, %esi
callq 0x33ff0
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movq 0x48(%rax), %rdx
leaq -0x78(%rbp), %rsi
callq 0x35a70
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0xc(%rbp)
movq (%rax), %rcx
movq 0x250(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
addq $0x260, %rax            # imm = 0x260
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rax
movb 0x51(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x481c5
jmp 0x48222
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rsi), %rax
leaq -0x50(%rbp), %rdi
callq *0x10(%rax)
leaq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x35b80
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %edi
callq 0x35db0
testb $0x1, %al
jne 0x481f6
jmp 0x48201
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x481b6
cmpb $0x10, -0x21(%rbp)
jne 0x48220
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x4821e
movq -0x58(%rbp), %rax
movb $0x1, 0x51(%rax)
jmp 0x48220
jmp 0x481b6
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x36e90
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x48389
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x36a70
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x34090
movq %rdx, -0x78(%rbp)
movb %al, -0x6d(%rbp)
jmp 0x4834d
movq -0x78(%rbp), %rax
movb -0x6d(%rbp), %cl
movb %cl, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x374b0
movb $0x1, -0x39(%rbp)
jmp 0x48389
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x374b0
jmp 0x483aa
leaq -0x10(%rbp), %rdi
leaq -0x39(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x362f0
movb -0x10(%rbp), %al
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34010
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x36ee0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x357a0
testb $0x1, %al
jne 0x48410
jmp 0x4845a
leaq -0x28(%rbp), %rdi
callq 0x36960
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x34250
testb $0x1, -0x11(%rbp)
je 0x4844d
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x337a0
jmp 0x4844f
leaq -0x28(%rbp), %rdi
callq 0x38400
jmp 0x483fd
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34cb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x344b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x337f0
testb $0x1, %al
jne 0x484b7
jmp 0x484e0
leaq -0x28(%rbp), %rdi
callq 0x37930
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x38900
leaq -0x28(%rbp), %rdi
callq 0x38360
jmp 0x484a4
testb $0x1, -0x11(%rbp)
je 0x48535
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x48550
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl $0x1, %edx
callq 0x337a0
jmp 0x48513
leaq -0x58(%rbp), %rdi
callq 0x35890
jmp 0x48535
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35890
jmp 0x4853e
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x38210
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x37d00
movq -0x70(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x486c0
jmp 0x4863c
movq -0x78(%rbp), %rdi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
leaq -0x40(%rbp), %rsi
callq 0x337a0
jmp 0x48652
leaq -0x40(%rbp), %rdi
callq 0x35890
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x48695
jmp 0x4868c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x486a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35890
jmp 0x486a2
movq -0x70(%rbp), %rdi
callq 0x36870
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x36870
movq -0x60(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x35640
movq -0x70(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x48840
jmp 0x487bc
movq -0x78(%rbp), %rdi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
leaq -0x40(%rbp), %rsi
callq 0x384a0
jmp 0x487d2
leaq -0x40(%rbp), %rdi
callq 0x37b00
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x48815
jmp 0x4880c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x48822
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x37b00
jmp 0x48822
movq -0x70(%rbp), %rdi
callq 0x38b90
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x38b90
movq -0x60(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x37d00
movq -0x68(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x489a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
callq 0x337a0
jmp 0x48942
leaq -0x38(%rbp), %rdi
callq 0x35890
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x48980
jmp 0x48977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35890
movq -0x68(%rbp), %rdi
callq 0x36870
jmp 0x4898a
movq -0x68(%rbp), %rdi
callq 0x36870
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x35640
movq -0x68(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x48af0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
callq 0x384a0
jmp 0x48a92
leaq -0x38(%rbp), %rdi
callq 0x37b00
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x48ad0
jmp 0x48ac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x37b00
movq -0x68(%rbp), %rdi
callq 0x38b90
jmp 0x48ada
movq -0x68(%rbp), %rdi
callq 0x38b90
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x51(%rax)
je 0x4919f
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x39da4(%rip), %r8      # 0x82f30
callq 0x46c10
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x491cb
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x33550
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35810
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x51(%rax)
je 0x4923f
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x39d04(%rip), %r8      # 0x82f30
callq 0x45fd0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4926b
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x33550
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x36820
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0x33720
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x342c0
cmpb -0x12(%rbp), %al
jne 0x4bc21
movq -0x10(%rbp), %rdi
callq 0x33490
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37f50
movq %rax, -0x70(%rbp)
leaq -0x13(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x38240
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x36220
jmp 0x4bbf9
leaq -0x13(%rbp), %rdi
callq 0x35f90
jmp 0x4bcf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x13(%rbp), %rdi
callq 0x35f90
jmp 0x4bd00
movb -0x12(%rbp), %cl
movq -0x10(%rbp), %rdx
movb -0x11(%rbp), %al
leaq -0x40(%rbp), %rdi
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %ecx
callq 0x38220
leaq -0x40(%rbp), %rdi
callq 0x37840
shrq $0x0, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, -0x4a(%rbp)
cmpq $0x0, %rax
jbe 0x4bca6
leaq -0x40(%rbp), %rdi
callq 0x36f40
movq %rax, -0x90(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x38240
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
movb $0x1, -0x4a(%rbp)
callq 0x36220
jmp 0x4bca4
jmp 0x4bcaf
movq -0x60(%rbp), %rdi
callq 0x36d50
testb $0x1, -0x4a(%rbp)
jne 0x4bcb7
jmp 0x4bcc0
leaq -0x49(%rbp), %rdi
callq 0x35f90
leaq -0x40(%rbp), %rdi
callq 0x33980
jmp 0x4bcf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
testb $0x1, -0x4a(%rbp)
jne 0x4bcdf
jmp 0x4bce8
leaq -0x49(%rbp), %rdi
callq 0x35f90
leaq -0x40(%rbp), %rdi
callq 0x33980
jmp 0x4bd00
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x38210
nopl (%rax)