LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflDB[abi:cxx11]()
string mkflDB(void){
	string buf;
	buf+="db: clean param\n";
	buf+="param: CXXFLAGS += -g\n";
	buf+="param: $(OUT)\n\n";
	buf+="gdb: db\n";
	buf+="\tgdb $(OUT)\n\n";
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1053(%rip), %rsi      # 0x59b4
callq 0x22b0
leaq 0x1058(%rip), %rsi      # 0x59c5
movq %rbx, %rdi
callq 0x22b0
leaq 0x1060(%rip), %rsi      # 0x59dc
movq %rbx, %rdi
callq 0x22b0
leaq 0x1061(%rip), %rsi      # 0x59ec
movq %rbx, %rdi
callq 0x22b0
leaq 0x105b(%rip), %rsi      # 0x59f5
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x49c1
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflVal[abi:cxx11](bool)
string mkflVal(bool dbflag){
	string buf;

	if(!dbflag){
		buf+="db: clean param\n";
		buf+="param: CXXFLAGS += -g\n";
		buf+="param: $(OUT)\n\n";
	}
	
	buf+="vg: db\n";
	buf+="\tvalgrind $(EXECUTION_PARAMETERS) ./$(OUT)\n\n";

	buf+="vgleak: db\n";
	buf+="\tvalgrind --leak-check=full ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	buf+="vgext: db\n";
	buf+="\tvalgrind --leak-check=full --show-leak-kinds=all --leak-resolution=high --track-origins=yes --vgdb=yes ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
jne 0x4a15
leaq 0xfc5(%rip), %rsi       # 0x59b4
movq %rbx, %rdi
callq 0x22b0
leaq 0xfc7(%rip), %rsi       # 0x59c5
movq %rbx, %rdi
callq 0x22b0
leaq 0xfcf(%rip), %rsi       # 0x59dc
movq %rbx, %rdi
callq 0x22b0
leaq 0xfe7(%rip), %rsi       # 0x5a03
movq %rbx, %rdi
callq 0x22b0
leaq 0xfe0(%rip), %rsi       # 0x5a0b
movq %rbx, %rdi
callq 0x22b0
leaq 0xffe(%rip), %rsi       # 0x5a38
movq %rbx, %rdi
callq 0x22b0
leaq 0xffb(%rip), %rsi       # 0x5a44
movq %rbx, %rdi
callq 0x22b0
leaq 0x102b(%rip), %rsi      # 0x5a83
movq %rbx, %rdi
callq 0x22b0
leaq 0x1027(%rip), %rsi      # 0x5a8e
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4a8e
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/rvthak[P]Makefile-Maker/output.cpp
// Function: mkflClean[abi:cxx11]()
string mkflClean(void){
	string buf;

	buf+=".PHONY: clean\n";
	buf+="clean:\n";
	buf+="\trm -f *.o\n";
	
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1061(%rip), %rsi      # 0x5b19
callq 0x22b0
leaq 0x1064(%rip), %rsi      # 0x5b28
movq %rbx, %rdi
callq 0x22b0
leaq 0x105d(%rip), %rsi      # 0x5b30
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4afa
movq (%r15), %rsi
incq %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_07.cc
// Function: populate(std::shared_ptr<std::vector<int, std::allocator<int>>>)
shared_ptr<vector<int>> populate(shared_ptr<vector<int>> vec)
{
	int item;

	while (cin >> item) {
		vec->push_back(item);
	}

	return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2cf8(%rip), %rdi      # 0x3fe0
leaq -0x24(%rbp), %rsi
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1347
leaq -0x24(%rbp), %r15
movq 0x2cd6(%rip), %r12      # 0x3fe0
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1326
movl -0x24(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x132e
movq %r15, %rdx
callq 0x1602
movq %r12, %rdi
movq %r15, %rsi
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x130a
movq (%rbx), %rax
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]cpp-loadtxt/./src/loadtxt.hpp
// Function: loadtxt<double>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T convert(const string& s) {
        if constexpr (std::is_same_v<T, int>)
            return stoi(s);
        else if constexpr (std::is_same_v<T, long>)
            return stol(s);
        else if constexpr (std::is_same_v<T, long long>)
            return stoll(s);
        else if constexpr (std::is_same_v<T, unsigned long long>)
            return stoull(s);
        
        return stod(s);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %r14
callq 0x2030
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
cmpq %r14, (%r15)
je 0x4278
movl (%rbx), %eax
testl %eax, %eax
je 0x4268
cmpl $0x22, %eax
jne 0x426b
leaq 0x12de(%rip), %rdi      # 0x5541
callq 0x2220
movl %r12d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12c2(%rip), %rdi      # 0x5541
callq 0x2110
cmpl $0x0, (%rbx)
jne 0x428c
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: (anonymous namespace)::conv_str(Srl::String const&, std::vector<unsigned char, std::allocator<unsigned char>>&, Srl::Encoding)
MemBlock conv_str(const String& in, vector<uint8_t>& buffer, Encoding encoding)
    {
        if(in.encoding() == encoding) {
            return MemBlock(in.data(), in.size());
        }
        auto size = Tools::conv_charset(encoding, in, buffer, true);

        return MemBlock(buffer.data(), size);
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
cmpb $0x1, 0xd(%rdi)
jne 0xe561
cmpb $0x0, 0xe(%rsi)
movq %rsi, %rax
jne 0xe55c
movq (%rsi), %rax
movl 0x8(%rsi), %edx
jmp 0xe57c
movl $0x1, %edi
movq %rbx, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xbc60
movq %rax, %rdx
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_string(Srl::String const&)
pair<const String*, size_t> Environment::store_string(const String& str)
{
    if(str.size() < 1) {
        return { &Environment::EmptyString, EmptyStringHash };
    }

    auto conv = conv_str(str, this->str_buffer, Environment::Str_Encoding);
    auto hash = hash_fnc(conv);

    auto* str_ptr = this->str_table.get(conv);

    if(str_ptr) {
        return { str_ptr, hash };
    }

    String new_str(conv);

    if(!new_str.block.try_store_local()) {
        new_str.block.extern_data = Aux::copy(this->heap, conv).ptr;
    }

    str_ptr = this->str_table.insert(new_str, new_str).second;
    return { str_ptr, hash };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x8(%rsi)
je 0xe6d0
movq %rdi, %r13
leaq 0x220(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xe543
movq %rax, %r12
movq %rdx, %rbp
movq %rax, %rdi
movq %rdx, %rsi
callq 0xb580
movq %rax, %rbx
leaq 0x58(%r13), %r15
leaq 0x8(%rsp), %r14
movq %r12, (%r14)
movl %ebp, 0x8(%r14)
movw $0x10c, 0xc(%r14)       # imm = 0x10C
movb $0x0, 0xe(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0xb880
testq %rax, %rax
jne 0xe6de
movq %r12, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
movw $0x10c, 0x14(%rsp)      # imm = 0x10C
movb $0x0, 0x16(%rsp)
cmpl $0x8, %ebp
ja 0xe673
testl %ebp, %ebp
je 0xe669
xorl %eax, %eax
movb (%r12,%rax), %cl
movb %cl, 0x8(%rsp,%rax)
incq %rax
movl 0x10(%rsp), %ecx
cmpq %rcx, %rax
jb 0xe655
movb $0x1, 0x16(%rsp)
cmpl $0x9, %ebp
jb 0xe6a0
testq %rbp, %rbp
je 0xe69b
addq $0x8, %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb4f0
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xb790
movq %r13, %r12
movq %r12, 0x8(%rsp)
cmpb $0x0, 0x16(%rsp)
movq %r14, %rdi
jne 0xe6af
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xb580
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %r14, %r8
callq 0xb650
movq %rdx, %rax
jmp 0xe6de
movq 0x19869(%rip), %rax     # 0x27f40
movq 0x1a422(%rip), %rbx     # 0x28b00
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::create_node(Srl::Type, Srl::String const&)
Link<Node>* Environment::create_node(Type type, const String& name)
{
    auto strp = this->store_string(name);
    auto* link = this->heap.create<Link<Node>>(strp.second, Node(this->tree, type));
    link->field.name_ptr = strp.first;

    return link;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0xb390
movq %rax, %rbx
movq %rdx, %r15
movq (%r14), %rdi
addq $0x8, %r14
callq 0xbf80
leaq 0x18(%rsp), %rcx
movq %rax, -0x10(%rcx)
addq $0x8, %rax
movq %rax, -0x8(%rcx)
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
movq $0x0, 0x10(%rcx)
movq %rax, 0x18(%rcx)
leaq 0x38(%rsp), %r12
movq %r12, 0x8(%r12)
movq %r12, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movb %bpl, 0x20(%r12)
movb $0x1, 0x21(%r12)
movl $0x1, %esi
movq %r14, %rdi
callq 0xb7c0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0xba60
movq 0x38(%rsp), %r15
cmpq %r12, %r15
je 0xea18
movq %r15, %rsi
movq (%r15), %r15
movq 0x30(%rsp), %rdi
movl $0x30, %edx
callq 0xb3c0
jmp 0xe9fc
leaq 0x10(%rsp), %rdi
callq 0xbab0
movq %rbx, 0x50(%r14)
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc020
movq %rbx, %rdi
callq 0xbe90
movq %rax, %rdi
callq 0xf080
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_value(Srl::Node&, Srl::Value const&, Srl::String const&)
Link<Value>* Environment::store_value(Node& parent, const Value& value, const String& name)
{
    auto* link = this->create_link(parent.values, value, name);
    auto& block = link->field.block;

    if(!block.stored_local && !block.try_store_local()) {
        block.extern_data = Aux::copy(this->heap, { block.extern_data, block.size }).ptr;
    }

    return link;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsi), %r12
movq %rcx, %rsi
callq 0xb390
leaq 0x8(%rsp), %r13
movq %rax, -0x8(%r13)
movq %rdx, (%r13)
leaq 0x30(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xba10
movq 0x38(%r15), %rbx
movq -0x8(%r13), %rax
movq %rax, 0x18(%rbx)
cmpb $0x0, 0x2e(%rbx)
jne 0xeb0a
movl 0x28(%rbx), %eax
cmpl $0x8, %eax
ja 0xead6
testl %eax, %eax
je 0xeacd
movq 0x20(%rbx), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, 0x20(%rbx,%rdx)
incq %rdx
movl 0x28(%rbx), %esi
cmpq %rsi, %rdx
jb 0xeab9
movb $0x1, 0x2e(%rbx)
cmpl $0x9, %eax
jb 0xeb0a
movq 0x20(%rbx), %r15
movl 0x28(%rbx), %r12d
testq %r12, %r12
je 0xeb06
addq $0x8, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xb4f0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb790
movq %r14, %r15
movq %r15, 0x20(%rbx)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::conv_type(Srl::Value const&)
Value Environment::conv_type(const Value& value)
{
    size_t data_size = 0;
    auto& buffer = this->type_buffer;

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

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

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

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

    } else {

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x238, %r15            # imm = 0x238
movb 0x14(%rdx), %al
cmpb $0xc, %al
jne 0xecb3
cmpb $0x0, 0x16(%r14)
jne 0xecc2
movq 0x8(%r14), %rax
jmp 0xecc6
jae 0xecf9
movq %r14, %rdi
movq %r15, %rsi
callq 0xb620
jmp 0xed1a
leaq 0x8(%r14), %rax
movl 0x10(%r14), %ecx
movb 0x15(%r14), %dl
movq %rsp, %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movb $0xc, 0xc(%rsi)
movb %dl, 0xd(%rsi)
movb $0x0, 0xe(%rsi)
movl $0x1, %edi
movq %r15, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xbc60
jmp 0xed1a
cmpb $0xd, %al
jne 0xed45
cmpb $0x0, 0x16(%r14)
jne 0xed0a
movq 0x8(%r14), %rdi
jmp 0xed0e
leaq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
movq %r15, %rdx
callq 0xb780
movq (%r15), %rcx
movb 0x14(%r14), %dl
movq $0x0, (%rbx)
movq %rcx, 0x8(%rbx)
movl %eax, 0x10(%rbx)
movb %dl, 0x14(%rbx)
movw $0x0, 0x15(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10343(%rip), %rdi     # 0x1f08f
leaq 0x10372(%rip), %rsi     # 0x1f0c5
leaq 0x10383(%rip), %rcx     # 0x1f0dd
movl $0xd4, %edx
callq 0xb540
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::clear()
void Environment::clear()
{
    this->heap.clear();
    this->str_table.clear();
    this->shared_table_store.clear();
    this->shared_table_restore.clear();
}

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

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

        while(entry) {

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

            entry = entry->next;
        }

        return nullptr;
    }

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0xef1a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
cmpb $0x0, 0xe(%rsi)
movq %rsi, %rdi
jne 0xee15
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0xb580
movq %rax, %r15
movq 0x8(%r12), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
shrq $0x20, %rax
xorl %edi, %edi
testq %rdx, %rdx
cmovneq %rdi, %rax
movq 0x20(%r12), %rsi
xorq %r15, %rax
xorl %edx, %edx
divq %rcx
movq (%rsi,%rdx,8), %r14
testq %r14, %r14
je 0xef25
cmpq %r15, (%r14)
jne 0xef09
movl 0x18(%r14), %eax
movl 0x8(%rbx), %ecx
movl %eax, %edx
orl %ecx, %edx
je 0xef1e
leaq 0x10(%r14), %r13
movb 0x1d(%r14), %dl
cmpb %dl, 0xd(%rbx)
jne 0xeeab
movl %ecx, %edx
cmpl %edx, %eax
jne 0xef09
cmpb $0x0, 0xe(%rbx)
movq %rbx, %rsi
jne 0xee90
movq (%rbx), %rsi
cmpb $0x0, 0x1e(%r14)
jne 0xee9b
movq 0x10(%r14), %r13
movq %r13, %rdi
callq 0xb960
testl %eax, %eax
sete %r12b
jmp 0xef04
movzbl %dl, %esi
xorl %r12d, %r12d
movq %rsp, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xbea0
movq (%rsp), %rbp
movq 0x8(%rsp), %rdx
subq %rbp, %rdx
movl 0x18(%r14), %eax
cmpq %rax, %rdx
jne 0xeeef
cmpb $0x0, 0x1e(%r14)
jne 0xeede
movq 0x10(%r14), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb960
testl %eax, %eax
sete %r12b
testq %rbp, %rbp
je 0xef04
movq 0x10(%rsp), %rsi
subq %rbp, %rsi
movq %rbp, %rdi
callq 0xb940
testb %r12b, %r12b
jne 0xef1e
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xee53
xorl %edi, %edi
jmp 0xef25
xorl %edi, %edi
jmp 0xef33
addq $0x20, %r14
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Link<Srl::Node>* Srl::Lib::Environment::create_link<Srl::Node>(std::__cxx11::list<Srl::Lib::Link<Srl::Node>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Node>>>&, Srl::Node const&, Srl::String const&)
Link<T>* Environment::create_link(Lib::Items<T>& lst, const T& val, const String& name)
{
    auto strp = this->store_string(name);
    lst.emplace_back(strp.second, val);
    auto& link = lst.back();
    link.field.name_ptr = strp.first;

    return &link;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rsi
callq 0xb390
leaq 0x10(%rsp), %r15
movq %rax, -0x8(%r15)
movq %rdx, (%r15)
leaq 0x8(%r14), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb9e0
movq %rax, %rdi
movq %r12, %rsi
callq 0xb080
incq 0x18(%r14)
movq 0x10(%r14), %rax
movq -0x8(%r15), %rcx
movq %rcx, 0x60(%rax)
addq $0x10, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::clear()
void HTable<K, V, H>::clear()
    {
        if(this->elements < 1) {
            return;
        }

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

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

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

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

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

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

        return reinterpret_cast<T*>(mem);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
shlq $0x4, %rsi
leaq (%rsi,%rsi,2), %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xf503
movl 0x8(%rax), %eax
movq %rbx, %rcx
orq $0x7, %rcx
cmpq %rax, %rcx
jbe 0xf517
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb5c0
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rcx
movl 0x8(%rcx), %edx
movl 0xc(%rcx), %eax
addq (%rcx), %rax
subq %rdx, %rax
movl %eax, %edi
andl $0x7, %edi
movl $0x8, %esi
subq %rdi, %rsi
testq %rdi, %rdi
cmoveq %rdi, %rsi
orq %rsi, %rbx
cmpq %rdx, %rbx
ja 0xf553
addq %rsi, %rax
subl %ebx, %edx
movl %edx, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfbb9(%rip), %rdi      # 0x1f113
leaq 0xfbc2(%rip), %rsi      # 0x1f123
leaq 0xfbce(%rip), %rcx      # 0x1f136
movl $0x44, %edx
callq 0xb540
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::foreach_break(std::function<bool (unsigned long const&, std::shared_ptr<void>&)> const&) const
void HTable<K, V, H>::foreach_break(const std::function<bool(const K&, V&)>& fnc) const
    {
        if(this->elements < 1) {
            return;
        }

        auto n = 0U;

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

            auto* entry = table[i];

            while(entry) {

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

                if(abort) {
                    return;
                }

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x18(%rdi)
je 0xfcbc
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0xfcbc
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %r12
testq %r12, %r12
je 0xfca6
cmpq $0x0, 0x10(%rbx)
je 0xfcc5
leaq 0x18(%r12), %rdx
leaq 0x10(%r12), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
testb %al, %al
jne 0xfc9e
movq 0x8(%r12), %r12
incl %ebp
testb %al, %al
je 0xfc77
xorl %eax, %eax
jmp 0xfcaf
movl %ebp, %eax
cmpq %rax, 0x18(%r14)
seta %al
testb %al, %al
je 0xfcbc
incl %r15d
cmpq %r15, 0x8(%r14)
ja 0xfc6f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::Chain::get_link()
SegLink* Heap::Chain::get_link()
{
    auto* link = this->free_links.find_rm(Any());

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

    this->used_links.append(link);

    return &link->val;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xffec
movq (%rax), %rcx
movq %rcx, 0x30(%rbx)
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cmovneq %rcx, %rdx
movq %rdx, 0x38(%rbx)
movq $0x0, (%rax)
jmp 0xffee
xorl %eax, %eax
testq %rax, %rax
jne 0x1000f
movl $0x28, %edi
callq 0xb920
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq 0x28(%rbx), %rcx
leaq 0x20(%rbx), %rdx
testq %rcx, %rcx
cmovneq %rcx, %rdx
movq %rax, (%rdx)
movq %rax, 0x28(%rbx)
movq $0x0, (%rax)
addq $0x8, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
leaq 0x20(%rdi), %r13
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
xorl %ecx, %ecx
movq %r13, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x100a7
movq %rcx, %r12
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x10436
movq %r15, %rcx
testb %al, %al
je 0x10055
movq (%r13), %rax
cmpq %r15, %rax
jne 0x1007f
movq (%r15), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rax
cmpq %r15, %rax
cmoveq %r12, %rax
movq %rax, 0x28(%rbx)
testq %r12, %r12
je 0x1009e
movq (%r15), %rax
movq %rax, (%r12)
movq $0x0, (%r15)
jmp 0x100aa
xorl %r15d, %r15d
testq %r15, %r15
je 0x100cc
movq 0x18(%rbx), %rax
leaq 0x10(%rbx), %rcx
testq %rax, %rax
cmovneq %rax, %rcx
movq %r15, (%rcx)
movq %r15, 0x18(%rbx)
movq $0x0, (%r15)
leaq 0x8(%r15), %rax
testq %r15, %r15
cmoveq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1011a
movl 0x8(%rax), %edx
testq %rdx, %rdx
je 0x1011a
movl 0xc(%rax), %esi
addq (%rax), %rsi
subq %rdx, %rsi
movq %rbx, %rdi
callq 0xb3c0
cmpq $0x0, 0x20(%rbx)
je 0x1013b
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb480
movq %rax, %r12
testq %rax, %rax
jne 0x101c8
leaq 0x10(%rbx), %r15
movq (%rbx), %rax
leaq (%rax,%rax), %rcx
movl $0x40000, %edx          # imm = 0x40000
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
testq %rax, %rax
movl $0x1, %eax
cmovneq %rcx, %rax
movq %rax, (%rbx)
cmpq %rdx, %r14
setae %cl
cmpq %r14, %rax
setae %dl
orb %cl, %dl
jne 0x1017c
addq %rax, %rax
cmpq %r14, %rax
jb 0x10171
movq %rax, (%rbx)
movq (%rbx), %rax
cmpq %r14, %rax
cmovaq %rax, %r14
movq %r15, %rdi
callq 0xb250
movq %rax, %r13
leaq 0x8(%rax), %r12
movq %r14, %rdi
callq 0xb030
movq %rax, 0x8(%r13)
movl %r14d, 0x10(%r13)
movl %r14d, 0x14(%r13)
movb $0x0, 0x18(%r13)
movq 0x18(%rbx), %rax
testq %rax, %rax
cmoveq %r15, %rax
movq %r13, (%rax)
movq %r13, 0x18(%rbx)
movq $0x0, (%r13)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::clear()
void Heap::clear()
{
    this->chain.used_segs.clear();
    this->chain.free_segs.clear();

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

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

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

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

        link = next;
    }

    this->crr_seg = nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq 0x30(%rdi), %rbp
testq %rbp, %rbp
je 0x10309
leaq 0x20(%rbx), %r14
leaq 0x28(%rbx), %r12
leaq 0x40(%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movq %r12, 0x8(%rsp)
movq %r14, (%rsp)
movq (%rbp), %r13
cmpb $0x1, 0x20(%rbp)
jne 0x1026e
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rdx
cmpq %rbp, %rcx
cmoveq %r13, %rcx
movq %rcx, 0x30(%rbx)
cmpq %rbp, %rdx
cmoveq %rax, %rdx
movq %rdx, 0x38(%rbx)
testq %rax, %rax
je 0x1024b
movq %r13, (%rax)
xorl %edx, %edx
movq %rdx, (%rbp)
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
cmoveq 0x10(%rsp), %rcx
movq %rbp, (%rcx)
movq %rbp, 0x48(%rbx)
movq %rdx, (%rbp)
jmp 0x102fd
leaq 0x8(%rbp), %r15
movl 0x1c(%rbp), %edx
movl %edx, 0x18(%rbp)
movq 0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb420
movq $0x0, 0x8(%rbp)
movl 0x1c(%rbp), %eax
movq %rax, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
cmpq $0x0, (%r12)
je 0x102d5
xorl %ecx, %ecx
movq (%r14), %r14
testq %r14, %r14
je 0x102da
movq %rcx, %r12
leaq 0x8(%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0x10436
movq %r14, %rcx
testb %al, %al
je 0x102a5
movq %r14, (%r15)
testq %r12, %r12
movq (%rsp), %r14
cmoveq %r14, %r12
jmp 0x102f1
movq %r15, (%r14)
jmp 0x102f1
movq $0x0, (%r15)
movq 0x8(%rsp), %r12
movq (%r12), %rax
movq %r15, (%rax)
movq (%rsp), %r14
movq %r15, (%r12)
movq %rbp, %rax
movq 0x8(%rsp), %r12
movq %r13, %rbp
testq %r13, %r13
jne 0x1021b
movq $0x0, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::destroy()
void Heap::destroy()
{
    const auto free = [](Aux::SList<SegLink>& lst) {
        auto* link = lst.front;
        while(link) {
            auto* next = link->next;
            delete link;
            link = next;
        }
    };

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x10362
movq (%r14), %r15
leaq 0x10(%r14), %rdi
callq 0xb680
movl $0x28, %esi
movq %r14, %rdi
callq 0xb940
movq %r15, %r14
testq %r15, %r15
jne 0x10341
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x1038c
movq (%r14), %r15
leaq 0x10(%r14), %rdi
callq 0xb680
movl $0x28, %esi
movq %r14, %rdi
callq 0xb940
movq %r15, %r14
testq %r15, %r15
jne 0x1036b
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb950
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)
movq $0x0, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x48(%rdi)
movb $0x0, 0x28(%rdi)
movq 0x8(%rsp), %rax
cmpb $0x1, %cl
jne 0x104c7
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %edx
xorl %esi, %esi
jmp 0xb190
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_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::node(Srl::String const&)
Node& Node::node(const String& name_)
{
    auto hash = hash_string(name_, *this->env);
    auto hash_name = make_pair(hash, &name_);
    auto* link = find_link<Throw | Hash | Name>(hash_name, this->nodes, name_, this->name());

    return link->field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rsi
movq %rbx, %rdi
callq 0x10a06
movq %rax, %r14
movq 0x10(%r15), %r12
movq 0x48(%r15), %r13
testq %r13, %r13
jne 0x10a64
movq 0x174dc(%rip), %r13     # 0x27f40
addq $0x10, %r15
cmpq %r15, %r12
je 0x10b53
movq %r13, (%rsp)
movq %r14, 0x8(%rsp)
cmpq %r14, 0x10(%r12)
jne 0x10b42
movq 0x60(%r12), %rbp
testq %rbp, %rbp
jne 0x10a96
movq 0x174aa(%rip), %rbp     # 0x27f40
movl 0x8(%rbp), %eax
movl 0x8(%rbx), %ecx
movl %eax, %edx
orl %ecx, %edx
je 0x10b57
movb 0xd(%rbp), %dl
cmpb %dl, 0xd(%rbx)
jne 0x10ade
movl %ecx, %edx
cmpl %edx, %eax
jne 0x10b42
cmpb $0x0, 0xe(%rbx)
movq %rbx, %rsi
jne 0x10ac4
movq (%rbx), %rsi
cmpb $0x0, 0xe(%rbp)
jne 0x10ace
movq (%rbp), %rbp
movq %rbp, %rdi
callq 0xb960
testl %eax, %eax
sete %r13b
jmp 0x10b3d
movzbl %dl, %esi
xorl %r13d, %r13d
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xbea0
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rdx
subq %r14, %rdx
movl 0x8(%rbp), %eax
cmpq %rax, %rdx
jne 0x10b23
cmpb $0x0, 0xe(%rbp)
jne 0x10b12
movq (%rbp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0xb960
testl %eax, %eax
sete %r13b
testq %r14, %r14
je 0x10b38
movq 0x20(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0xb940
movq 0x8(%rsp), %r14
testb %r13b, %r13b
jne 0x10b57
movq (%r12), %r12
cmpq %r15, %r12
jne 0x10a7a
movq (%rsp), %r13
xorl %eax, %eax
jmp 0x10b62
addq $0x10, %r12
movq %r12, %rax
movq (%rsp), %r13
testq %rax, %rax
je 0x10b7a
addq $0x8, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0xb3b0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x11b92
movq 0x1744c(%rip), %rsi     # 0x27fe8
movq 0x173a5(%rip), %rdx     # 0x27f48
movq %r14, %rdi
callq 0xbe60
movq %rax, %rbx
movq %r14, %rdi
callq 0xb610
movq %rbx, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb770
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
callq 0xb320
movb $0x0, 0x10(%rbx)
callq 0xbdb0
jmp 0x110c8
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::get(Srl::String const&)
Union Node::get(const String& name_)
{
    auto* resvalue = find_link<Name>(name_, this->values, name_, this->name());

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

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

    return Union(resnode->field);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movups (%rsi), %xmm0
leaq 0x20(%rsp), %r13
movups %xmm0, (%r13)
leaq 0x30(%rdi), %rbp
xorl %r12d, %r12d
movq %rsp, %r15
movq %rbp, %rbx
movq (%rbx), %rbx
movq %rbx, (%rsp)
cmpq %rbp, %rbx
je 0x11132
movq %r15, %rdi
movq %r13, %rsi
callq 0x137a7
testb %al, %al
je 0x11110
addq $0x10, %rbx
movq %rbx, %r12
testq %r12, %r12
je 0x11143
addq $0x8, %r12
xorl %r13d, %r13d
jmp 0x11254
movq 0x10(%rsp), %rax
movups (%rax), %xmm0
movq 0x48(%r14), %rax
testq %rax, %rax
jne 0x1115b
movq 0x16de5(%rip), %rax     # 0x27f40
movq %rax, 0x18(%rsp)
movups %xmm0, (%rsp)
movq 0x10(%r14), %r13
addq $0x10, %r14
cmpq %r14, %r13
je 0x1123f
movq 0x60(%r13), %r12
testq %r12, %r12
jne 0x11185
movq 0x16dbb(%rip), %r12     # 0x27f40
movl 0x8(%r12), %eax
movl 0x8(%rsp), %ecx
movl %eax, %edx
orl %ecx, %edx
je 0x11244
movb 0xd(%r12), %dl
cmpb %dl, 0xd(%rsp)
jne 0x111d6
movl %ecx, %edx
cmpl %edx, %eax
jne 0x11236
cmpb $0x0, 0xe(%rsp)
movq %r15, %rsi
jne 0x111bb
movq (%rsp), %rsi
cmpb $0x0, 0xe(%r12)
jne 0x111c7
movq (%r12), %r12
movq %r12, %rdi
callq 0xb960
testl %eax, %eax
sete %bl
jmp 0x11232
movzbl %dl, %esi
xorl %ebx, %ebx
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xbea0
movq 0x20(%rsp), %rbp
movq 0x28(%rsp), %rdx
subq %rbp, %rdx
movl 0x8(%r12), %eax
cmpq %rax, %rdx
jne 0x1121d
cmpb $0x0, 0xe(%r12)
jne 0x1120d
movq (%r12), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0xb960
testl %eax, %eax
sete %bl
testq %rbp, %rbp
je 0x11232
movq 0x30(%rsp), %rsi
subq %rbp, %rsi
movq %rbp, %rdi
callq 0xb940
testb %bl, %bl
jne 0x11244
movq (%r13), %r13
jmp 0x1116c
xorl %r13d, %r13d
jmp 0x11248
addq $0x10, %r13
testq %r13, %r13
je 0x11269
addq $0x8, %r13
xorl %r12d, %r12d
movq %r13, %rax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0xb3b0
movq %rax, %r14
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x11b92
movq 0x16d59(%rip), %rsi     # 0x27fe8
movq 0x16cb2(%rip), %rdx     # 0x27f48
movq %r14, %rdi
callq 0xbe60
movq %rax, %rbx
movq %r14, %rdi
callq 0xb610
movq %rbx, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::get(unsigned long)
Link<T>* get_link_at_index(size_t index, Cont<T>& links)
    {
        if(index < links.size()) {
            auto itr = links.begin();
            advance(itr, index);
            auto* rslt = &*itr;
            if(enabled(Opt, Remove)) {
                links.erase(itr);
                return nullptr;
            }
            return rslt;

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

// Assembly:
cmpq %rsi, 0x20(%rdi)
jbe 0x112ee
movq 0x10(%rdi), %rax
testq %rsi, %rsi
jle 0x112f2
movq %rsi, %rcx
movq (%rax), %rax
decq %rcx
jne 0x112e4
jmp 0x11300
xorl %eax, %eax
jmp 0x11304
je 0x11300
movq %rsi, %rcx
movq 0x8(%rax), %rax
incq %rcx
jne 0x112f7
addq $0x10, %rax
testq %rax, %rax
je 0x11310
addq $0x8, %rax
xorl %edx, %edx
retq
cmpq %rsi, 0x40(%rdi)
jbe 0x11329
movq 0x30(%rdi), %rdx
testq %rsi, %rsi
jle 0x1132d
movq (%rdx), %rdx
decq %rsi
jne 0x1131f
jmp 0x11338
xorl %edx, %edx
jmp 0x1133c
je 0x11338
movq 0x8(%rdx), %rdx
incq %rsi
jne 0x1132f
addq $0x10, %rdx
addq $0x8, %rdx
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::to_source()
void Node::to_source()
{
    Value scope_start = Value(this->scope_type);

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0x50(%rdi), %al
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl $0x0, 0x10(%rsp)
movb %al, 0x14(%rsp)
movw $0x0, 0x15(%rsp)
movq (%rdi), %rdi
movq 0x48(%rbx), %rdx
testq %rdx, %rdx
jne 0x12c6c
movq 0x152d4(%rip), %rdx     # 0x27f40
movq %rsp, %rsi
callq 0xb8d0
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %r15
cmpq %r14, %r15
je 0x12ca8
movq 0x152b8(%rip), %r12     # 0x27f40
movq 0x18(%r15), %rdx
testq %rdx, %rdx
jne 0x12c94
movq %r12, %rdx
movq (%rbx), %rdi
leaq 0x18(%r15), %rsi
callq 0xb8d0
movq (%r15), %r15
cmpq %r14, %r15
jne 0x12c88
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r14, %r15
je 0x12cc3
leaq 0x18(%r15), %rdi
callq 0xb450
movq (%r15), %r15
jmp 0x12cb0
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movw $0x10, 0x14(%rsi)
movb $0x0, 0x16(%rsi)
movq (%rbx), %rdi
movq 0x48(%rbx), %rdx
callq 0xb8d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::consume_scope()
void Node::consume_scope()
{
    int depth = 0;

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

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

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

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

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

    return { inserted_new, sptr };
}

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

        fnc(link.field);

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq 0x30(%rdi), %r12
cmpq %r15, %r12
je 0x12ee6
cmpq $0x0, 0x10(%r14)
je 0x12f42
leaq 0x18(%r12), %rsi
movq %r14, %rdi
callq *0x18(%r14)
movq (%r12), %r12
jmp 0x12ec8
testb %bpl, %bpl
je 0x12f35
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r14, (%rsi)
leaq 0xa46(%rip), %rax       # 0x13948
movq %rax, 0x18(%rsi)
leaq 0xa4b(%rip), %rax       # 0x13958
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0xb1b0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12f35
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
jmp 0x12f6b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12f63
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xbe90
movq %rax, %rdi
callq 0xf080
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::find_nodes[abi:cxx11](Srl::String const&, bool)
list<Node*> Node::find_nodes(const String& name_, bool recursive)
{
    list<Node*> rslt;

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

    return rslt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x18, %edi
callq 0xb920
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x9b8(%rip), %rax       # 0x1397e
movq %rax, 0x18(%rsi)
leaq 0xab3(%rip), %rax       # 0x13a84
movq %rax, 0x10(%rsi)
movzbl %bpl, %edx
movq %r14, %rdi
callq 0xb1b0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12ff8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13024
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1302f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1302f
movq %rax, %rdi
callq 0xf080
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1304c
movq (%rdi), %r15
movl $0x18, %esi
callq 0xb940
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x13037
movq %r14, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::find_values[abi:cxx11](Srl::String const&, bool)
list<Value*> Node::find_values(const String& name_, bool recursive)
{
    list<Value*> rslt;

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

    return rslt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x18, %edi
callq 0xb920
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xa48(%rip), %rax       # 0x13aee
movq %rax, 0x18(%rsi)
leaq 0xb43(%rip), %rax       # 0x13bf4
movq %rax, 0x10(%rsi)
movzbl %bpl, %edx
movq %r14, %rdi
callq 0xbf10
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x130d8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13104
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1310f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1310f
movq %rax, %rdi
callq 0xf080
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1312c
movq (%rdi), %r15
movl $0x18, %esi
callq 0xb940
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x13117
movq %r14, %rdi
callq 0xbe90