LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Node.cpp
// Function: Srl::Node::all_nodes[abi:cxx11](bool)
list<Node*> Node::all_nodes(bool recursive)
{
    list<Node*> rslt;

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

    return rslt;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rdi, (%rsi)
leaq 0xaf7(%rip), %rcx       # 0x13c5e
movq %rcx, 0x18(%rsi)
leaq 0xb1c(%rip), %rcx       # 0x13c8e
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0xb1b0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x13195
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x131cf
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x131bc
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xc060
movq %r14, %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::all_values[abi:cxx11](bool)
list<Value*> Node::all_values(bool recursive)
{
    list<Value*> rslt;

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

    return rslt;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rdi, (%rsi)
leaq 0xaa9(%rip), %rcx       # 0x13cb4
movq %rcx, 0x18(%rsi)
leaq 0xace(%rip), %rcx       # 0x13ce4
movq %rcx, 0x10(%rsi)
movq %rax, %rdi
callq 0xbf10
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x13239
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x13273
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x13260
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xc08d
movq %r14, %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::has_node(Srl::String const&)
bool Node::has_node(const String& field_name)
{
    if(this->parsed) {
        return find_link<Name>(field_name, this->nodes, field_name) != nullptr;
    }

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

    return unn.node() != nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
cmpb $0x1, 0x51(%rdi)
jne 0x13608
movups (%rsi), %xmm0
leaq 0x10(%rsp), %r15
movups %xmm0, (%r15)
addq $0x10, %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
movq %r14, %r13
movq (%r13), %r13
movq %r13, 0x8(%rsp)
cmpq %r14, %r13
je 0x13615
movq %r12, %rdi
movq %r15, %rsi
callq 0x13877
testb %al, %al
je 0x135e2
addq $0x10, %r13
movq %r13, %rbx
jmp 0x13615
movq %r14, %rdi
xorl %edx, %edx
callq 0xb130
movq %rax, %rbx
testq %rbx, %rbx
setne %al
addq $0x20, %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::has_value(Srl::String const&)
bool Node::has_value(const String& field_name)
{
    if(this->parsed) {
        return find_link<Name>(field_name, this->values, field_name) != nullptr;
    }

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

    return unn.value() != nullptr;
}

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
cmpb $0x1, 0xd(%rsi)
jne 0x14133
cmpb $0x0, 0xe(%rax)
movq %rax, %rsi
jne 0x1411c
movq (%rax), %rsi
movl 0x8(%rax), %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xb2e0
jmp 0x1418b
movzbl %dl, %ecx
movq %rsp, %r14
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0xbea0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%rbx), %rax
cmpq %rsi, %rdx
je 0x14166
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xb2e0
jmp 0x14175
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1418b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xb940
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x141af
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xb940
movq %rbx, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::set(Srl::Lib::Out::Source)
void Out::set(Source source)
{
    this->heap.clear();
    this->state = State();

    this->streaming = source.is_stream;
    this->stream = source.is_stream ? source.stream : nullptr;
    this->buffer = !source.is_stream ? source.buffer : nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0xb510
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r15)
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x50(%r15)
xorl %eax, %eax
andb $0x1, %bl
movb %bl, 0x80(%r15)
movl $0x0, %ecx
cmovneq %r14, %rcx
movq %rcx, 0x88(%r15)
cmovneq %rax, %r14
movq %r14, 0x90(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::inc_cap(unsigned long)
void Out::inc_cap(size_t nbytes)
{
    this->state.cap = Stream_Buffer_Size < nbytes ? nbytes : Stream_Buffer_Size;
    this->state.mem_start = this->heap.get_mem(this->state.cap);
    this->state.left = this->state.cap;
    this->state.crr_mem = this->state.mem_start;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x401, %rsi            # imm = 0x401
movl $0x400, %eax            # imm = 0x400
cmovbq %rax, %rsi
movq %rsi, 0x60(%rdi)
callq 0xb4f0
movq %rax, 0x78(%rbx)
movq 0x60(%rbx), %rcx
movq %rcx, 0x58(%rbx)
movq %rax, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::flush()
void Out::flush()
{
    if(this->streaming) {
        this->write_to_stream();
        this->stream->flush();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movb $0x22, (%rsi)
callq 0xb500
testl %ebp, %ebp
je 0x15222
movb $0x22, 0x9(%rsp)
movw $0x225c, (%rsp)         # imm = 0x225C
movb $0x5c, 0x8(%rsp)
movw $0x5c5c, 0x16(%rsp)     # imm = 0x5C5C
movb $0x2f, 0x7(%rsp)
movw $0x2f5c, 0x14(%rsp)     # imm = 0x2F5C
movb $0xa, 0x6(%rsp)
movw $0x6e5c, 0x12(%rsp)     # imm = 0x6E5C
movb $0x9, 0x5(%rsp)
movw $0x745c, 0x10(%rsp)     # imm = 0x745C
movb $0xd, 0x4(%rsp)
movw $0x725c, 0xe(%rsp)      # imm = 0x725C
movb $0x8, 0x3(%rsp)
movw $0x625c, 0xc(%rsp)      # imm = 0x625C
movb $0xc, 0x2(%rsp)
movw $0x665c, 0xa(%rsp)      # imm = 0x665C
cmpq $0x0, 0x8(%r14)
je 0x1528d
movl $0x1, %r15d
xorl %eax, %eax
movq %rsp, %r12
leaq 0x8(%rsp), %r13
leaq 0x16(%rsp), %rbp
movq (%r14), %rcx
movzbl (%rcx,%rax), %esi
movq %rbx, %rdi
leaq 0x9(%rsp), %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbp, %r9
leaq 0xa(%rsp), %rax
pushq %rax
leaq 0xa(%rsp), %rax
pushq %rax
leaq 0x1c(%rsp), %rax
pushq %rax
leaq 0x1b(%rsp), %rax
pushq %rax
leaq 0x2e(%rsp), %rax
pushq %rax
leaq 0x2c(%rsp), %rax
pushq %rax
leaq 0x40(%rsp), %rax
pushq %rax
leaq 0x3d(%rsp), %rax
pushq %rax
leaq 0x52(%rsp), %rax
pushq %rax
leaq 0x4e(%rsp), %rax
pushq %rax
leaq 0x64(%rsp), %rax
pushq %rax
leaq 0x5f(%rsp), %rax
pushq %rax
callq 0xb0e0
addq $0x60, %rsp
movl %r15d, %eax
incl %r15d
cmpq %rax, 0x8(%r14)
ja 0x151ab
jmp 0x1528d
movq (%r14), %r15
movq 0x8(%r14), %r14
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x15267
cmpq %r14, 0x58(%rbx)
jae 0x15244
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x15255
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
subq %r14, 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x15272
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
cmpq $0x1, %r14
jne 0x1527f
movb (%r15), %cl
movb %cl, (%rax)
jmp 0x1528d
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb790
movq %rsp, %rsi
movb $0x22, (%rsi)
movq %rbx, %rdi
callq 0xb500
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::process_quote(Srl::Lib::In&, Srl::PJson::State&)
void PJson::process_quote(In& source, State& state)
{
    if(this->scope_type == Type::Null) {
        this->throw_exception(state, "Value not in a scope.");
    }
    /* skip opening quotation-mark */
    source.move(1, error);

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

    this->process_string(block, state);
}

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x5b, %sil
sete %al
movb $0x10, %cl
subb %al, %cl
cmpb $0x7b, %sil
movzbl %cl, %ecx
movl $0xe, %eax
cmovnel %ecx, %eax
movb %al, 0x7(%rsp)
cmpb $0x10, %al
jne 0x15cf2
movq 0x40(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x15d4e
leaq 0x10(%r14), %rdi
callq 0xbbb0
movq 0x40(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x15d21
cmpq 0x48(%r14), %rax
jne 0x15ced
movq 0x58(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movb -0x1(%rax), %al
jmp 0x15d23
movq 0x40(%r14), %rcx
movq 0x50(%r14), %rdx
decq %rdx
cmpq %rdx, %rcx
je 0x15d0d
movb %al, (%rcx)
incq %rcx
movq %rcx, 0x40(%r14)
jmp 0x15d1b
leaq 0x10(%r14), %rdi
leaq 0x7(%rsp), %rsi
callq 0xbe50
movb 0x7(%rsp), %al
jmp 0x15d23
movb $0xb, %al
movb %al, 0x60(%r14)
movb 0x7(%rsp), %al
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movb %al, 0x24(%rbx)
movw $0x0, 0x25(%rbx)
movb $0x1, 0x28(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x9ac0(%rip), %rax      # 0x1f815
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1a, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb $0x0, 0xe(%rdx)
movq %rbx, %rsi
callq 0xb0b0
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::process_char(Srl::Lib::In&, Srl::PJson::State&, bool&)
void PJson::process_char(In& source, State& state, bool& out_move)
{
    bool is_literal = this->lookup.table[*source.pointer()];

    if(is_literal) {

        bool likely_fp = false;
        In::Notify dec ('.', likely_fp);

        auto block = source.read_block_until(error, ',', ' ', '}', ']', dec);

        this->process_literal(block, state, likely_fp ? Type::FP64 : Type::Null);

        if(*source.pointer() == '}' || *source.pointer() == ']') {
            /* The bracket has a double meaning here, first it delimits the literal,
             * and second it closes the scope. So make sure it will be processed. */
            out_move = false;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq 0x10(%rsi), %rax
movzbl (%rax), %ecx
cmpb $0x0, 0x98(%rdi,%rcx)
je 0x15e2b
movq %rdx, %r15
movq %rsi, %r14
leaq 0x17(%rsp), %r12
movb $0x0, (%r12)
leaq 0x28(%rsp), %rsi
movb $0x2e, (%rsi)
movq %r12, 0x8(%rsi)
leaq 0x16(%rsp), %rdx
movb $0x2c, (%rdx)
leaq 0x15(%rsp), %rcx
movb $0x20, (%rcx)
leaq 0x14(%rsp), %r8
movb $0x7d, (%r8)
leaq 0x13(%rsp), %r9
movb $0x5d, (%r9)
movq %rax, 0x48(%r14)
movq %rsi, (%rsp)
leaq 0x132ba(%rip), %rsi     # 0x290a0
movq %r14, %rdi
callq 0xb200
movq $0x0, 0x48(%r14)
movq 0x10(%r14), %rcx
subq %rax, %rcx
leaq 0x18(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movzbl (%r12), %ecx
xorl $0xb, %ecx
movq %r15, %rdx
callq 0xb090
movq 0x10(%r14), %rax
movzbl (%rax), %eax
orl $0x20, %eax
cmpl $0x7d, %eax
jne 0x15e2b
movb $0x0, (%rbx)
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/PJson.cpp
// Function: Srl::PJson::process_string(Srl::Lib::MemBlock const&, Srl::PJson::State&)
void PJson::process_string(const MemBlock& content, State& state)
{
    /* container elements don't have a name */
    if(state.reading_value || this->scope_type == Type::Array) {
        state.value = Value(content, Encoding::UTF8);
        state.complete = true;

    } else {
        if(state.name_processed) {
            this->throw_exception(state, "Misssing \':\'.");
        }
        state.name = content;
        state.name_processed = true;
    }
}

// Assembly:
cmpb $0x0, 0x2a(%rdx)
jne 0x15e55
cmpb $0xf, 0x60(%rdi)
je 0x15e55
cmpb $0x1, 0x29(%rdx)
je 0x15e79
movups (%rsi), %xmm0
movups %xmm0, (%rdx)
movb $0x1, 0x29(%rdx)
retq
movq (%rsi), %rax
movl 0x8(%rsi), %ecx
movq $0x0, 0x10(%rdx)
movq %rax, 0x18(%rdx)
movl %ecx, 0x20(%rdx)
movw $0x10c, 0x24(%rdx)      # imm = 0x10C
movb $0x0, 0x26(%rdx)
movb $0x1, 0x28(%rdx)
retq
subq $0x18, %rsp
leaq 0x99c2(%rip), %rcx      # 0x1f846
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0xd, 0x8(%rax)
movw $0x10c, 0xc(%rax)       # imm = 0x10C
movb $0x0, 0xe(%rax)
movq %rdx, %rsi
movq %rax, %rdx
callq 0xb0b0
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::process_literal(Srl::Lib::MemBlock const&, Srl::PJson::State&, Srl::Type)
void PJson::process_literal(const MemBlock& str, State& state, Type hint)
{
    bool success;

    tie(success, state.value) = Tools::str_to_type(str.ptr, str.size, hint);

    if(!success) {
        throw_exception(state, String("Failed to convert string "
                        + String(str).unwrap(false) + " to literal."));
    }

    state.complete = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xb270
cmpb $0x0, (%r15)
movq 0x18(%r15), %rax
movq %rax, 0x20(%rbx)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x10(%rbx)
je 0x15efa
movb $0x1, 0x28(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rax
movl 0x8(%r14), %ecx
movq %rax, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
movw $0x10c, 0x14(%rsp)      # imm = 0x10C
movb $0x0, 0x16(%rsp)
leaq 0x48(%rsp), %r14
testl %ecx, %ecx
jne 0x15f34
movq %r14, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movb $0x0, 0x48(%rsp)
jmp 0x15f45
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xb9a0
leaq 0x9908(%rip), %rcx      # 0x1f854
leaq 0x38(%rsp), %rdi
movl $0x19, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xba00
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x15f81
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x15f8e
movq %rdx, 0x58(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x68(%rsp)
movq 0x8(%rax), %rdx
leaq 0x58(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x98bd(%rip), %rsi      # 0x1f86e
callq 0xc000
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x15fd9
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x15fe6
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
movq 0x18(%rsp), %rax
movl 0x20(%rsp), %esi
leaq 0x78(%rsp), %rdx
movq %rax, (%rdx)
movl %esi, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb %cl, 0xe(%rdx)
movq %rbx, %rsi
callq 0xb0b0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x16043
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb940
jmp 0x16043
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x1605f
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb940
jmp 0x1605f
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x16076
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb940
movq %rbx, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/include/Srl/Out.hpp
// Function: void Srl::Lib::Out::substitute_token<char, std::array<char const, 2ul>>(unsigned char, char const&, std::array<char const, 2ul> const&)
void Out::substitute_token(uint8_t src, const Token& token, const Sub& sub, const Tokens&... tail)
    {
        if(src != token) {
            this->substitute_token(src, tail...);

        } else {
            auto* dest = this->alloc(std::tuple_size<Sub>::value);
            this->write_substitute<std::tuple_size<Sub>::value>(dest, sub.data());
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movsbl (%rdx), %eax
cmpl %eax, %esi
jne 0x16914
movq %rcx, %rbx
addq $0x2, 0x50(%r14)
cmpb $0x0, 0x80(%r14)
je 0x16929
cmpq $0x1, 0x58(%r14)
ja 0x168ed
movq %r14, %rdi
callq 0xb460
cmpq $0x1, 0x60(%r14)
ja 0x16901
movl $0x2, %esi
movq %r14, %rdi
callq 0xbc90
addq $-0x2, 0x58(%r14)
movq 0x70(%r14), %rax
leaq 0x2(%rax), %rcx
movq %rcx, 0x70(%r14)
jmp 0x16936
leaq 0x7(%rsp), %rax
movb %sil, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0xb8f0
jmp 0x16940
movl $0x2, %esi
movq %r14, %rdi
callq 0xb4f0
movb (%rbx), %cl
movb %cl, (%rax)
movb 0x1(%rbx), %cl
movb %cl, 0x1(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/include/Srl/In.hpp
// Function: unsigned long Srl::Lib::In::move_until<false, char, char, char, char, Srl::Lib::In::Notify>(std::function<void ()> const&, char const&, char const&, char const&, char const&, Srl::Lib::In::Notify const&)
size_t In::move_until(const Error& error, const Tokens&... tokens)
    {
        if(!this->pos) {
            error();
        }
        auto steps = 0U;

        while(Not == this->is_at_token(tokens...)) {
            this->move(1, error);
            steps++;
        }

        return steps;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %rbp
cmpq $0x0, 0x10(%rdi)
movq %rsi, 0x8(%rsp)
jne 0x17603
cmpq $0x0, 0x10(%rdx)
je 0x176be
movq %rdx, %rdi
movq 0x8(%rsp), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movsbl (%r13), %esi
movq 0x10(%rbp), %rax
movzbl (%rax), %ecx
xorl %r15d, %r15d
cmpl %esi, %ecx
je 0x176ac
movq 0x50(%rsp), %r8
movq %r13, 0x10(%rsp)
movsbl (%r12), %esi
cmpl %esi, %ecx
je 0x176a9
movsbl (%r14), %esi
cmpl %esi, %ecx
je 0x176a9
movsbl (%rbx), %edi
cmpl %edi, %ecx
je 0x1764d
movsbl (%r8), %esi
cmpl %esi, %ecx
jne 0x1764d
movq 0x8(%r8), %rcx
movb $0x1, (%rcx)
jmp 0x17651
cmpl %edi, %ecx
je 0x176a9
incq %rax
cmpq 0x8(%rbp), %rax
jb 0x17689
movl $0x1, %esi
movq %rbp, %rdi
movq %r12, %r13
movq %r14, %r12
movq %rbx, %r14
movq %r8, %rbx
callq 0xb210
movq %rbx, %r8
movq %r14, %rbx
movq %r12, %r14
movq %r13, %r12
movq 0x10(%rsp), %r13
movq 0x8(%rsp), %rdx
movq 0x10(%rbp), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x10(%rbp)
incl %r15d
movsbl (%r13), %esi
movzbl 0x1(%rcx), %ecx
cmpl %esi, %ecx
jne 0x17624
movl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/include/Srl/In.hpp
// Function: unsigned long Srl::Lib::In::substitute_token<std::function<unsigned long (Srl::Lib::In&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)>, std::array<char const, 2ul>>(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long, unsigned long, std::function<unsigned long (Srl::Lib::In&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)> const&, std::array<char const, 2ul> const&)
size_t In::substitute_token(std::vector<uint8_t>& buf, size_t idx, size_t left,
                                const Sub& sub, const Token& token, const Tail&... tail)
    {
        const auto N = std::tuple_size<Token>::value;

        return left >= N && Aux::comp<N>(this->pos, token.data())
                ? this->replace<Sub, N>(sub, buf, idx)
                : this->substitute_token(buf, idx, left, tail...);
    }

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rdi, %rsi
cmpq $0x2, %rcx
jb 0x1710a
movq 0x10(%rsi), %rcx
movzbl (%rcx), %edi
movsbl (%r9), %r10d
cmpl %r10d, %edi
jne 0x1710a
movzbl 0x1(%rcx), %ecx
movsbl 0x1(%r9), %edi
cmpl %edi, %ecx
jne 0x1710a
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%r8)
je 0x17125
movq %rsp, %rcx
movq %r8, %rdi
movq %rax, %rdx
callq *0x18(%r8)
jmp 0x17123
movq 0x10(%rsi), %rcx
leaq 0x1(%rcx), %rdi
movq %rdi, 0x10(%rsi)
movb (%rcx), %cl
movq (%rax), %rax
movb %cl, (%rax,%rdx)
movl $0x1, %eax
popq %rcx
retq
callq 0xb2d0
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: Srl::PMsgPack::write_scope(Srl::Type, Srl::Lib::Out&)
void PMsgPack::write_scope(Type type, Out& out)
{
    uint8_t prefix = type == Type::Object ? 0xDF : 0xDD;

   out.write(prefix);
   auto ticket = out.reserve(4);
   this->scope_stack.emplace(type, 0, ticket);
   this->scope = &this->scope_stack.top();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb %sil, 0xa(%rsp)
cmpl $0xe, %esi
sete %al
addb %al, %al
orb $-0x23, %al
leaq 0xb(%rsp), %rsi
movb %al, (%rsi)
movq %rdx, %rdi
callq 0xb8f0
movq 0x50(%r14), %r15
leaq 0x4(%r15), %rax
movq %rax, 0x50(%r14)
cmpb $0x0, 0x80(%r14)
je 0x183d9
cmpq $0x3, 0x58(%r14)
ja 0x183b2
movq %r14, %rdi
callq 0xb460
cmpq $0x3, 0x60(%r14)
ja 0x183c6
movl $0x4, %esi
movq %r14, %rdi
callq 0xbc90
addq $-0x4, 0x58(%r14)
movq 0x70(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x70(%r14)
jmp 0x183e6
movl $0x4, %esi
movq %r14, %rdi
callq 0xb4f0
xorl %esi, %esi
movl %esi, (%rax)
movq 0x68(%r14), %rdx
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq $0x4, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %rdx, 0x18(%rcx)
leaq 0x20(%rbx), %rdi
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
leaq 0xa(%rsp), %rsi
callq 0xbc40
movq 0x50(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x18432
movq 0x68(%rbx), %rcx
movl $0x1e0, %eax            # imm = 0x1E0
addq -0x8(%rcx), %rax
addq $-0x28, %rax
movq %rax, 0x70(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::write_pfixnum(unsigned long, Srl::Lib::Out&)
bool write_pfixnum(uint64_t i, Out& out)
    {
        if(i > 0x7F) {
            return false;
        }

        out.write_byte(i);
        return true;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x7f, %rdi
ja 0x18d56
movq %rsi, %r14
incq 0x50(%rsi)
cmpb $0x0, 0x80(%rsi)
je 0x18d47
cmpq $0x0, 0x58(%r14)
jne 0x18d21
movq %r14, %rdi
callq 0xb460
cmpq $0x0, 0x60(%r14)
jne 0x18d35
movl $0x1, %esi
movq %r14, %rdi
callq 0xbc90
decq 0x58(%r14)
movq 0x70(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%r14)
jmp 0x18d54
movl $0x1, %esi
movq %r14, %rdi
callq 0xb4f0
movb %bl, (%rax)
cmpq $0x80, %rbx
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::write_nfixnum(long, Srl::Lib::Out&)
bool write_nfixnum(int64_t i, Out& out)
    {
        if(i > -1 || i < -31) {
            return false;
        }

        out.write_byte(0xE0 | (uint8_t)i);
        return true;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $-0x1f, %rdi
jb 0x18dc9
movq %rsi, %r14
incq 0x50(%rsi)
cmpb $0x0, 0x80(%rsi)
je 0x18dba
cmpq $0x0, 0x58(%r14)
jne 0x18d94
movq %r14, %rdi
callq 0xb460
cmpq $0x0, 0x60(%r14)
jne 0x18da8
movl $0x1, %esi
movq %r14, %rdi
callq 0xbc90
decq 0x58(%r14)
movq 0x70(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%r14)
jmp 0x18dc7
movl $0x1, %esi
movq %r14, %rdi
callq 0xb4f0
movb %bl, (%rax)
cmpq $-0x1f, %rbx
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/include/Srl/In.hpp
// Function: unsigned char Srl::Lib::In::read_move<unsigned char>(std::function<void ()> const&)
T In::read_move(const Error& error)
    {
        auto block = this->read_block(sizeof(T), error);

        if(block.size < sizeof(T)) {
            return T();
        }

        return Aux::read<T>(block.ptr);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rdi)
incq %rax
cmpq 0x8(%rdi), %rax
jb 0x18ee1
movq %rsi, %rdx
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb210
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq $0x0, 0x48(%rbx)
movb (%rax), %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: Srl::PSrl::write_head(unsigned char, Srl::Lib::MemBlock const&, Srl::Lib::Out&)
void PSrl::write_head(Flag flag, const MemBlock& str, Out& out)
{
    if(str.size < 1 || scope == Type::Null || scope == Type::Array) {
        out.write_byte(flag);
        return;
    }

    flag |= FNamed;

    auto nstrings = this->hashed_strings.num_entries();

    bool exists; size_t* index;
    tie(exists, index) = this->hashed_strings.insert(str, nstrings);

    if(exists) {
        out.write_byte(flag | FIndexed);
        encode_integer(*index, out);

    } else {
        out.write_byte(flag);
        encode_integer(str.size, out);
        out.write(str);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %esi, %ebp
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x19b3d
movq %rdi, %r15
movzbl 0x8(%rdi), %eax
orl $0x4, %eax
cmpl $0xf, %eax
jne 0x19b9c
incq 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x19b7f
cmpq $0x0, 0x58(%rbx)
jne 0x19b59
movq %rbx, %rdi
callq 0xb460
cmpq $0x0, 0x60(%rbx)
jne 0x19b6d
movl $0x1, %esi
movq %rbx, %rdi
callq 0xbc90
decq 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x19b8c
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb4f0
movb %bpl, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq 0xe0(%r15), %rax
addq $0xc8, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq (%rdx), %rdi
callq 0xb580
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %r12, %r8
callq 0xbfd0
incq 0x50(%rbx)
movb 0x80(%rbx), %cl
testb $0x1, %al
je 0x19c1f
movq %rdx, %r15
orb $0x6, %bpl
testb %cl, %cl
je 0x19c5c
cmpq $0x0, 0x58(%rbx)
jne 0x19bf9
movq %rbx, %rdi
callq 0xb460
cmpq $0x0, 0x60(%rbx)
jne 0x19c0d
movl $0x1, %esi
movq %rbx, %rdi
callq 0xbc90
decq 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x19c69
orb $0x2, %bpl
testb %cl, %cl
je 0x19c7c
cmpq $0x0, 0x58(%rbx)
jne 0x19c36
movq %rbx, %rdi
callq 0xb460
cmpq $0x0, 0x60(%rbx)
jne 0x19c4a
movl $0x1, %esi
movq %rbx, %rdi
callq 0xbc90
decq 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x19c89
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb4f0
movb %bpl, (%rax)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x19d0b
jmp 0x19b8f
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb4f0
movb %bpl, (%rax)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x19d0b
movq (%r14), %r15
movq 0x8(%r14), %r14
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x19cdd
cmpq %r14, 0x58(%rbx)
jae 0x19cba
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x19ccb
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
subq %r14, 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x19ce8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
cmpq $0x1, %r14
jne 0x19cf8
movb (%r15), %cl
movb %cl, (%rax)
jmp 0x19b8f
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb790
jmp 0x19b8f
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: (anonymous namespace)::encode_integer(unsigned long, Srl::Lib::Out&)
void encode_integer(uint64_t integer, Out& out)
    {
        uint8_t buffer[10];
        auto sz = 0U;

        while(integer >= mask_msb) {
            auto block = (integer | mask_msb);
            integer >>= 7;
            buffer[sz++] = (uint8_t)block;
        }

        /* just the lowest 7 bits left */
        buffer[sz++] = (uint8_t)integer;
        out.write(buffer, sz);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorl %r15d, %r15d
cmpq $0x80, %rdi
jb 0x19d42
xorl %r15d, %r15d
movq %rdi, %rax
shrq $0x7, %rdi
movl %eax, %ecx
orb $-0x80, %cl
movb %cl, 0x6(%rsp,%r15)
incq %r15
cmpq $0x3fff, %rax           # imm = 0x3FFF
ja 0x19d26
leal 0x1(%r15), %r14d
movl %r15d, %eax
movb %dil, 0x6(%rsp,%rax)
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x19d8c
cmpq %r14, 0x58(%rbx)
jae 0x19d69
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x19d7a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
subq %r14, 0x58(%rbx)
movq 0x70(%rbx), %rdi
leaq (%rdi,%r14), %rax
movq %rax, 0x70(%rbx)
jmp 0x19d9a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
movq %rax, %rdi
testl %r15d, %r15d
je 0x19dae
leaq 0x6(%rsp), %rsi
movq %r14, %rdx
callq 0xb790
jmp 0x19db4
movb 0x6(%rsp), %al
movb %al, (%rdi)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: Srl::PSrl::read_head(Srl::Lib::In&)
pair<Flag, MemBlock> PSrl::read_head(In& source)
{
    auto flag = source.read_move<uint8_t>(error);

    if(!(flag & FNamed) || scope == Type::Null || scope == Type::Array) {
        return { flag, MemBlock() };
    }

    if(flag & FIndexed) {
        auto index = decode_integer(source);
        if(index >= this->indexed_strings.size()) {
            error();
        }

        return { flag, this->indexed_strings[index] };

    } else {
        auto size  = decode_integer(source);
        auto block = source.read_block(size, error);

        if(source.is_streaming()) {
            block = Aux::copy(this->string_buffer, block);
        }

        auto& str = *this->indexed_strings.insert(indexed_strings.end(), block);

        return { flag, str };
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf864(%rip), %rsi      # 0x29640
movq %rdx, %rdi
callq 0xb660
movl %eax, %ebp
testb $0x2, %al
je 0x19df7
movzbl 0x8(%r14), %eax
orl $0x4, %eax
cmpl $0xf, %eax
jne 0x19e13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movb %bpl, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x19f0f
movq %rax, %r15
testb $0x4, %bpl
jne 0x19ec9
movq 0x10(%r12), %rax
movq %rax, 0x48(%r12)
addq %r15, %rax
cmpq 0x8(%r12), %rax
jb 0x19e4e
leaq 0xf7fd(%rip), %rdx      # 0x29640
movq %r12, %rdi
movq %r15, %rsi
callq 0xb210
movq 0x10(%r12), %r13
leaq (%r15,%r13), %rax
movq %rax, 0x10(%r12)
movq $0x0, 0x48(%r12)
movq %r13, 0x8(%rsp)
movq %r15, 0x10(%rsp)
cmpb $0x1, 0x18(%r12)
jne 0x19eac
testq %r15, %r15
je 0x19ea2
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0xb4f0
movq %rax, %r13
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0xb790
movq 0x10(%rsp), %r15
movq %r13, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq 0x18(%r14), %rsi
addq $0x10, %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xc030
movb %bpl, (%rbx)
movups (%rax), %xmm0
jmp 0x19f01
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x4, %rax
cmpq %rax, %r15
jb 0x19ef1
cmpq $0x0, 0xf76e(%rip)      # 0x29650
je 0x19f0a
leaq 0xf755(%rip), %rdi      # 0x29640
callq *0xf767(%rip)           # 0x29658
movq 0x10(%r14), %rax
shlq $0x4, %r15
movb %bpl, (%rbx)
movups (%rax,%r15), %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x19e01
callq 0xb2d0
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: (anonymous namespace)::decode_integer(Srl::Lib::In&)
uint64_t decode_integer(In& source)
    {
        uint8_t  block       = *source.pointer();
        uint64_t out_integer = mask_reset_msb & block;

        auto shift = 7U;
        /* first block w/o msb set is the last 8-bit block of the integer to decode */
        while(mask_msb & block) {
            source.move(1, error);
            block = *source.pointer();
            out_integer |= (mask_reset_msb & block) << shift;
            shift += 7;
        }

        /* no support for integers > 64 bit */
        if(shift > 10 * 7) {
            error();
        }

        source.move(1, error);

        return out_integer;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movzbl (%rax), %eax
movl %eax, %r14d
andl $0x7f, %r14d
testb %al, %al
js 0x19f2f
xorl %eax, %eax
jmp 0x19f82
movl $0x7, %ebp
leaq 0xf705(%rip), %r15      # 0x29640
movq 0x10(%rbx), %rax
incq %rax
cmpq 0x8(%rbx), %rax
jb 0x19f58
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb210
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movzbl 0x1(%rax), %eax
movl %eax, %edx
andl $0x7f, %edx
movl %ebp, %ecx
shlq %cl, %rdx
orq %rdx, %r14
addl $0x7, %ebp
testb %al, %al
js 0x19f3b
cmpl $0x47, %ebp
setae %al
testb %al, %al
je 0x19f9d
cmpq $0x0, 0xf6c2(%rip)      # 0x29650
je 0x19fd0
leaq 0xf6a9(%rip), %rdi      # 0x29640
callq *0xf6bb(%rip)           # 0x29658
movq 0x10(%rbx), %rax
incq %rax
cmpq 0x8(%rbx), %rax
jb 0x19fbe
leaq 0xf68f(%rip), %rdx      # 0x29640
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb210
incq 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: Srl::PSrl::pop_scope()
void PSrl::pop_scope()
{
    this->scope_stack.pop();
    this->scope = this->scope_stack.size() > 0
        ? this->scope_stack.top()
        : Type::Null;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x78, %rdi
callq 0xbbb0
movq 0xc0(%rbx), %rax
movq %rax, %rsi
subq 0xa0(%rbx), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rax
adcq $-0x1, %rsi
shlq $0x9, %rsi
movq 0xa8(%rbx), %rcx
movq 0xb0(%rbx), %rdx
movq %rcx, %rdi
subq %rdx, %rdi
addq 0x98(%rbx), %rdi
addq %rsi, %rdi
movb $0xb, %sil
cmpq 0x88(%rbx), %rdi
je 0x1a322
cmpq %rdx, %rcx
jne 0x1a31e
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rax), %rcx
movb -0x1(%rcx), %sil
movb %sil, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: Srl::PSrl::read_num(unsigned char, Srl::Lib::MemBlock const&, Srl::Lib::In&)
pair<Lib::MemBlock, Value> PSrl::read_num(Flag flag, const MemBlock& name, In& source)
{
    if(flag & (FTrue | FFalse)) {
        bool val = flag & FTrue;
        return { name, val };
    }

    if(flag & FFP32) {
        float val = source.read_move<float>(error);
        return { name, val };
    }

    if(flag & FFP64) {
        double val = source.read_move<double>(error);
        return { name, val };
    }

    uint64_t integer = decode_integer(source);

    return flag & FSigned
        ? make_pair(name, Value(-(int64_t)integer))
        : make_pair(name, Value(integer));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
cmpb $0x40, %bpl
jae 0x1a5b7
testb $0x10, %bpl
jne 0x1a5ef
cmpb $0x20, %bpl
jae 0x1a62b
movq %r8, %rdi
callq 0x19f0f
cmpb $0x8, %bpl
jae 0x1a682
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x8, 0x20(%rbx)
movw $0x8, 0x24(%rbx)
jmp 0x1a6a5
shrb $0x6, %bpl
andb $0x1, %bpl
movups (%r14), %xmm0
movups %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x1, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
leaq 0x26(%rbx), %rax
movb $0x0, 0x26(%rbx)
movzbl %bpl, %ecx
movq %rcx, 0x18(%rbx)
jmp 0x1a6b3
leaq 0xf04a(%rip), %rsi      # 0x29640
movq %r8, %rdi
callq 0xb160
movups (%r14), %xmm1
movups %xmm1, (%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rbx)
movl $0x4, 0x20(%rbx)
movw $0x9, 0x24(%rbx)
leaq 0x26(%rbx), %rax
movb $0x0, 0x26(%rbx)
movss %xmm0, 0x18(%rbx)
jmp 0x1a6b3
leaq 0xf00e(%rip), %rsi      # 0x29640
movq %r8, %rdi
callq 0xb7b0
movups (%r14), %xmm1
movups %xmm1, (%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rbx)
movl $0x8, 0x20(%rbx)
movw $0xa, 0x24(%rbx)
leaq 0x26(%rbx), %rax
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movb $0x0, 0x26(%rbx)
cvtss2sd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jne 0x1a6ae
jp 0x1a6ae
movss %xmm1, 0x18(%rbx)
movl $0x4, 0x20(%rbx)
movb $0x9, 0x24(%rbx)
jmp 0x1a6b3
negq %rax
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x8, 0x20(%rbx)
movw $0x7, 0x24(%rbx)
movq %rbx, %rax
addq $0x26, %rax
jmp 0x1a6b3
movsd %xmm0, 0x18(%rbx)
movb $0x1, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: Srl::PSrl::clear()
void PSrl::clear()
{
    this->indexed_strings.clear();
    this->string_buffer.clear();
    this->hashed_strings.clear();
    this->scope = Type::Null;

    Aux::clear_stack(this->scope_stack);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x1a6d0
movq %rax, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
callq 0xb510
cmpq $0x0, 0xe0(%rbx)
je 0x1a710
leaq 0x110(%rbx), %rdi
callq 0xb510
movq 0xf0(%rbx), %rax
cmpq %rax, 0xf8(%rbx)
je 0x1a706
movq %rax, 0xf8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movb $0xb, 0x8(%rbx)
addq $0x78, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xbc30
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Srl::Tools::get_base64_decoded_size(char const*, unsigned long)
size_t Tools::get_base64_decoded_size(const char* str, size_t str_len)
{
    if(str_len < 4) {
        return 0;
    }

    auto rem  = str[str_len - 1] == '=' ? 1 : 0;
         rem += str[str_len - 2] == '=' ? 1 : 0;

    return (str_len / 4) * 3 - rem;
}

// Assembly:
cmpq $0x4, %rsi
jae 0x1ba18
xorl %eax, %eax
retq
xorl %ecx, %ecx
cmpb $0x3d, -0x1(%rdi,%rsi)
sete %cl
xorl %edx, %edx
cmpb $0x3d, -0x2(%rdi,%rsi)
sete %dl
shrq $0x2, %rsi
leaq (%rsi,%rsi,2), %rax
subq %rcx, %rax
subq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Srl::Tools::base64_to_bytes(char const*, unsigned long)
vector<uint8_t> Tools::base64_to_bytes(const char* str, size_t str_len)
{
    auto vsize = get_base64_decoded_size(str, str_len);

    vector<uint8_t> bytesv(vsize);
    base64_to_bytes(bytesv.data(), vsize, str, str_len);

    return bytesv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x4, %rdx
jae 0x1ba57
xorl %r12d, %r12d
jmp 0x1ba7e
xorl %eax, %eax
cmpb $0x3d, -0x1(%r15,%r14)
sete %al
xorl %ecx, %ecx
cmpb $0x3d, -0x2(%r15,%r14)
sete %cl
movq %r14, %rdx
shrq $0x2, %rdx
leaq (%rdx,%rdx,2), %r12
subq %rax, %r12
subq %rcx, %r12
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbd40
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xbc10
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1bac5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xb940
movq %r14, %rdi
callq 0xbe90