LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15625
movq %rsi, %r13
movq %rdi, %r14
movq 0x10(%rsi), %rax
leaq 0x1(%rax), %rcx
cmpq 0x8(%rsi), %rcx
jb 0x154a1
leaq 0x12c10(%rip), %rdx     # 0x280a0
movl $0x1, %esi
movq %r13, %rdi
callq 0xb210
movq 0x10(%r13), %rax
incq %rax
movq %rax, 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
movq %rbx, 0x20(%rsp)
leaq 0x1a(%rsp), %rbx
movw $0x755c, (%rbx)         # imm = 0x755C
leaq 0x12b45(%rip), %r11     # 0x280c0
leaq 0x12b1e(%rip), %rsi     # 0x280a0
movq %r13, %rdi
movl $0x22, %edx
movq %r15, %rcx
movq %r9, %r13
pushq %rbx
pushq %r11
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 0x9204(%rip), %rax      # 0x1e830
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::process_bracket(char, Srl::PJson::State&)
void PJson::process_bracket(char bracket, State& state)
{
    Type type = bracket == '{' ? Type::Object
              : bracket == '[' ? Type::Array
              : Type::Scope_End;

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x5b, %sil
sete %al
movb $0x10, %cl
subb %al, %cl
cmpb $0x7b, %sil
movzbl %cl, %ecx
movl $0xe, %eax
cmovnel %ecx, %eax
movb %al, 0xf(%rsp)
cmpb $0x10, %al
jne 0x15ba6
movq 0x40(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x15c04
leaq 0x10(%r14), %rdi
callq 0xbbb0
movq 0x40(%r14), %rax
movb $0x10, %cl
cmpq 0x20(%r14), %rax
je 0x15bd9
cmpq 0x48(%r14), %rax
jne 0x15ba1
movq 0x58(%r14), %rdx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rdx), %rax
movb -0x1(%rax), %al
jmp 0x15bdb
movq 0x40(%r14), %rcx
movq 0x50(%r14), %rdx
decq %rdx
cmpq %rdx, %rcx
je 0x15bc1
movb %al, (%rcx)
incq %rcx
movq %rcx, 0x40(%r14)
jmp 0x15bd5
leaq 0x10(%r14), %rdi
leaq 0xf(%rsp), %r15
movq %r15, %rsi
callq 0xbe50
movb (%r15), %al
movl %eax, %ecx
jmp 0x15bdb
movb $0xb, %al
movb %al, 0x60(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movb %cl, 0x24(%rbx)
movw $0x0, 0x25(%rbx)
movb $0x1, 0x28(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8c0a(%rip), %rax      # 0x1e815
leaq 0x10(%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_O3/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 0x15ce1
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 0x12404(%rip), %rsi     # 0x280a0
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 0x15ce1
movb $0x0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/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 0x15d0b
cmpb $0xf, 0x60(%rdi)
je 0x15d0b
cmpb $0x1, 0x29(%rdx)
je 0x15d2f
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 0x8b0c(%rip), %rcx      # 0x1e846
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_O3/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 0x38(%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 0x15db0
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 0x28(%rsp), %r14
testl %ecx, %ecx
jne 0x15dea
movq %r14, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
jmp 0x15dfb
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xb9a0
leaq 0x8a52(%rip), %rcx      # 0x1e854
leaq 0x18(%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 0x15e37
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x15e44
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 0x8a07(%rip), %rsi      # 0x1e86e
callq 0xc000
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rcx
movq %rax, %rdx
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x15e92
movups (%rdx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rcx
jmp 0x15e9f
movq %rcx, 0x38(%rsp)
movq (%rdx), %rsi
movq %rsi, 0x48(%rsp)
movq 0x8(%rax), %rsi
movq %rsi, 0x40(%rsp)
movq %rdx, (%rax)
movq $0x0, 0x8(%rax)
xorl %edi, %edi
movb %dil, 0x10(%rax)
leaq 0x78(%rsp), %rdx
movq %rcx, (%rdx)
movl %esi, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb %dil, 0xe(%rdx)
movq %rbx, %rsi
callq 0xb0b0
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x15ef5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb940
jmp 0x15ef5
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x15f11
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb940
jmp 0x15f11
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x15f28
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb940
movq %rbx, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O3/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 0x167c2
movq %rcx, %rbx
addq $0x2, 0x50(%r14)
cmpb $0x0, 0x80(%r14)
je 0x167d7
cmpq $0x1, 0x58(%r14)
ja 0x1679b
movq %r14, %rdi
callq 0xb460
cmpq $0x1, 0x60(%r14)
ja 0x167af
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 0x167e4
leaq 0x7(%rsp), %rax
movb %sil, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0xb8f0
jmp 0x167ee
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_O3/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, %r15
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %rbp
movq 0x10(%rdi), %rax
testq %rax, %rax
movq %rsi, 0x8(%rsp)
jne 0x174df
cmpq $0x0, 0x10(%rdx)
je 0x175a3
movq %rdx, %rdi
movq 0x8(%rsp), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rbp), %rax
movsbl (%r12), %esi
movzbl (%rax), %ecx
xorl %r13d, %r13d
cmpl %esi, %ecx
je 0x17591
movq 0x50(%rsp), %r8
movq %rbp, 0x10(%rsp)
movsbl (%r15), %esi
cmpl %esi, %ecx
je 0x1758e
movsbl (%r14), %esi
cmpl %esi, %ecx
je 0x1758e
movsbl (%rbx), %edi
cmpl %edi, %ecx
je 0x17528
movsbl (%r8), %esi
cmpl %esi, %ecx
jne 0x17528
movq 0x8(%r8), %rcx
movb $0x1, (%rcx)
jmp 0x1752c
cmpl %edi, %ecx
je 0x1758e
leaq 0x1(%rax), %rcx
cmpq 0x8(%rbp), %rcx
jb 0x1756f
movl $0x1, %esi
movq %rbp, %rdi
movq %r12, %rbp
movq %r15, %r12
movq %r14, %r15
movq %rbx, %r14
movq %r8, %rbx
callq 0xb210
movq %rbx, %r8
movq %r14, %rbx
movq %r15, %r14
movq %r12, %r15
movq %rbp, %r12
movq 0x10(%rsp), %rbp
movq 0x8(%rsp), %rdx
movq 0x10(%rbp), %rax
leaq 0x1(%rax), %rdi
movq %rdi, 0x10(%rbp)
incl %r13d
movsbl (%r12), %esi
movzbl 0x1(%rax), %ecx
movq %rdi, %rax
cmpl %esi, %ecx
jne 0x174fc
movl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x10(%rdi), %rdi
cmpq $0x2, %rcx
jb 0x16fc1
movzbl (%rdi), %ecx
movsbl (%r9), %r10d
cmpl %r10d, %ecx
jne 0x16fc1
movzbl 0x1(%rdi), %ecx
movsbl 0x1(%r9), %r9d
cmpl %r9d, %ecx
jne 0x16fc1
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%r8)
je 0x16fd8
movq %rsp, %rcx
movq %r8, %rdi
movq %rax, %rdx
callq *0x18(%r8)
jmp 0x16fd6
leaq 0x1(%rdi), %rcx
movq %rcx, 0x10(%rsi)
movb (%rdi), %cl
movq (%rax), %rax
movb %cl, (%rax,%rdx)
movl $0x1, %eax
popq %rcx
retq
callq 0xb2d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x181c9
cmpq $0x3, 0x58(%r14)
ja 0x181a2
movq %r14, %rdi
callq 0xb460
cmpq $0x3, 0x60(%r14)
ja 0x181b6
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 0x181d6
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 0x18222
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_O3/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 0x189d2
movq %rsi, %r14
incq 0x50(%rsi)
cmpb $0x0, 0x80(%rsi)
je 0x189c3
cmpq $0x0, 0x58(%r14)
jne 0x1899d
movq %r14, %rdi
callq 0xb460
cmpq $0x0, 0x60(%r14)
jne 0x189b1
movl $0x1, %esi
movq %r14, %rdi
callq 0xbc90
decq 0x58(%r14)
movq 0x70(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%r14)
jmp 0x189d0
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_O3/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 0x18a45
movq %rsi, %r14
incq 0x50(%rsi)
cmpb $0x0, 0x80(%rsi)
je 0x18a36
cmpq $0x0, 0x58(%r14)
jne 0x18a10
movq %r14, %rdi
callq 0xb460
cmpq $0x0, 0x60(%r14)
jne 0x18a24
movl $0x1, %esi
movq %r14, %rdi
callq 0xbc90
decq 0x58(%r14)
movq 0x70(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%r14)
jmp 0x18a43
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_O3/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)
leaq 0x1(%rax), %rcx
cmpq 0x8(%rdi), %rcx
jb 0x18b60
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_O3/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 0x197c5
movq %rdi, %r15
movzbl 0x8(%rdi), %eax
orl $0x4, %eax
cmpl $0xf, %eax
jne 0x19824
incq 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x19807
cmpq $0x0, 0x58(%rbx)
jne 0x197e1
movq %rbx, %rdi
callq 0xb460
cmpq $0x0, 0x60(%rbx)
jne 0x197f5
movl $0x1, %esi
movq %rbx, %rdi
callq 0xbc90
decq 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x19814
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 0x198a7
movq %rdx, %r15
orb $0x6, %bpl
testb %cl, %cl
je 0x198e4
cmpq $0x0, 0x58(%rbx)
jne 0x19881
movq %rbx, %rdi
callq 0xb460
cmpq $0x0, 0x60(%rbx)
jne 0x19895
movl $0x1, %esi
movq %rbx, %rdi
callq 0xbc90
decq 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x198f1
orb $0x2, %bpl
testb %cl, %cl
je 0x19904
cmpq $0x0, 0x58(%rbx)
jne 0x198be
movq %rbx, %rdi
callq 0xb460
cmpq $0x0, 0x60(%rbx)
jne 0x198d2
movl $0x1, %esi
movq %rbx, %rdi
callq 0xbc90
decq 0x58(%rbx)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
jmp 0x19911
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb4f0
movb %bpl, (%rax)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x19993
jmp 0x19817
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb4f0
movb %bpl, (%rax)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x19993
movq (%r14), %r15
movq 0x8(%r14), %r14
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x19965
cmpq %r14, 0x58(%rbx)
jae 0x19942
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x19953
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 0x19970
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
cmpq $0x1, %r14
jne 0x19980
movb (%r15), %cl
movb %cl, (%rax)
jmp 0x19817
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb790
jmp 0x19817
// File: /workspace/github_cpp_makefile_star2_O3/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 0x199ca
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 0x199ae
leal 0x1(%r15), %r14d
movl %r15d, %eax
movb %dil, 0x6(%rsp,%rax)
addq %r14, 0x50(%rbx)
cmpb $0x0, 0x80(%rbx)
je 0x19a14
cmpq %r14, 0x58(%rbx)
jae 0x199f1
movq %rbx, %rdi
callq 0xb460
cmpq %r14, 0x60(%rbx)
jae 0x19a02
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 0x19a22
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4f0
movq %rax, %rdi
testl %r15d, %r15d
je 0x19a36
leaq 0x6(%rsp), %rsi
movq %r14, %rdx
callq 0xb790
jmp 0x19a3c
movb 0x6(%rsp), %al
movb %al, (%rdi)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xebdc(%rip), %rsi      # 0x28640
movq %rdx, %rdi
callq 0xb660
movl %eax, %ebp
testb $0x2, %al
je 0x19a7f
movzbl 0x8(%r14), %eax
orl $0x4, %eax
cmpl $0xf, %eax
jne 0x19a9b
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 0x19b95
movq %rax, %r15
testb $0x4, %bpl
jne 0x19b4c
movq 0x10(%r12), %r13
movq %r13, 0x48(%r12)
leaq (%r15,%r13), %rax
cmpq 0x8(%r12), %rax
jb 0x19adc
leaq 0xeb74(%rip), %rdx      # 0x28640
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 0x19b2f
testq %r15, %r15
je 0x19b25
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0xb4f0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xb790
movq %r12, %r13
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 0x19b87
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r15
jb 0x19b7b
cmpq $0x0, 0xeae8(%rip)      # 0x28650
je 0x19b90
leaq 0xeacf(%rip), %rdi      # 0x28640
callq *0xeae1(%rip)           # 0x28658
movq 0x10(%r14), %rax
shlq $0x4, %r15
movb %bpl, (%rbx)
movups (%rax,%r15), %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x19a89
callq 0xb2d0
// File: /workspace/github_cpp_makefile_star2_O3/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), %ecx
movl %ecx, %r14d
andl $0x7f, %r14d
testb %cl, %cl
jns 0x19c1d
movl $0x7, %ebp
leaq 0xea83(%rip), %r15      # 0x28640
leaq 0x1(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jb 0x19bdb
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb210
movq 0x10(%rbx), %rax
movq %rax, %rcx
incq %rax
movq %rax, 0x10(%rbx)
movzbl 0x1(%rcx), %edx
movl %edx, %esi
andl $0x7f, %esi
movl %ebp, %ecx
shlq %cl, %rsi
orq %rsi, %r14
addl $0x7, %ebp
testb %dl, %dl
js 0x19bbd
cmpl $0x47, %ebp
jb 0x19c1d
cmpq $0x0, 0xea46(%rip)      # 0x28650
je 0x19c54
leaq 0xea2d(%rip), %rdi      # 0x28640
callq *0xea3f(%rip)           # 0x28658
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jb 0x19c3f
leaq 0xea12(%rip), %rdx      # 0x28640
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb210
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 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_O3/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 0x19f66
cmpq %rdx, %rcx
jne 0x19f62
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_O3/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 0x1a1ff
testb $0x10, %bpl
jne 0x1a230
cmpb $0x20, %bpl
jae 0x1a261
movq %r8, %rdi
callq 0x19b95
cmpb $0x8, %bpl
jae 0x1a2b0
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x8, 0x20(%rbx)
movw $0x8, 0x24(%rbx)
jmp 0x1a2da
shrb $0x6, %bpl
andb $0x1, %bpl
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x1, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
movzbl %bpl, %eax
movq %rax, 0x18(%rbx)
jmp 0x1a2da
leaq 0xe409(%rip), %rsi      # 0x28640
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)
movss %xmm0, 0x18(%rbx)
jmp 0x1a2da
leaq 0xe3d8(%rip), %rsi      # 0x28640
movq %r8, %rdi
callq 0xb7b0
movups (%r14), %xmm1
movups %xmm1, (%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rbx)
movl $0x8, 0x20(%rbx)
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movw $0xa, 0x24(%rbx)
cvtss2sd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jne 0x1a2d5
jp 0x1a2d5
movss %xmm1, 0x18(%rbx)
movl $0x4, 0x20(%rbx)
movb $0x9, 0x24(%rbx)
jmp 0x1a2da
negq %rax
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x8, 0x20(%rbx)
movw $0x7, 0x24(%rbx)
jmp 0x1a2da
movsd %xmm0, 0x18(%rbx)
movb $0x1, 0x26(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a2f8
movq %rax, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
callq 0xb510
cmpq $0x0, 0xe0(%rbx)
je 0x1a338
leaq 0x110(%rbx), %rdi
callq 0xb510
movq 0xf0(%rbx), %rax
cmpq %rax, 0xf8(%rbx)
je 0x1a32e
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_O3/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 0x1b61d
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_O3/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Srl::Tools::bytes_to_hex(unsigned char const*, unsigned long)
vector<uint8_t> Tools::bytes_to_hex(const uint8_t* bytes, size_t nbytes)
{
    const char hex_lk[] {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
    };

    vector<uint8_t> hexv(nbytes * 2);

    for(size_t in_idx = 0, out_idx = 0; in_idx < nbytes;
               in_idx++, out_idx += 2) {

        hexv[out_idx]     = hex_lk[(bytes[in_idx] >> 4) & 0x0F];
        hexv[out_idx + 1] = hex_lk[bytes[in_idx] & 0x0F];
    }

    return hexv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq (%rdx,%rdx), %rsi
leaq 0xf(%rsp), %rdx
callq 0xbd40
testq %rbx, %rbx
je 0x1b98d
xorl %eax, %eax
leaq 0x360e(%rip), %rcx      # 0x1ef70
movzbl (%r15,%rax), %edx
shrl $0x4, %edx
movb (%rdx,%rcx), %dl
movq (%r14), %rsi
movb %dl, (%rsi,%rax,2)
movzbl (%r15,%rax), %edx
andl $0xf, %edx
movb (%rdx,%rcx), %dl
movq (%r14), %rsi
movb %dl, 0x1(%rsi,%rax,2)
incq %rax
cmpq %rax, %rbx
jne 0x1b962
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: Srl::Tools::trim_space(unsigned char const*&, unsigned long&)
void Tools::trim_space(const uint8_t*& str, size_t& str_len)
{
    if(str == nullptr) {
        return;
    }

    while(str_len > 0 && is_space(*str)) {
        str++;
        str_len--;
    }

    while(str_len > 0 && is_space(*(str + str_len - 1))) {
        str_len--;
    }
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
sete %al
movq (%rsi), %rdx
testq %rdx, %rdx
sete %r8b
orb %al, %r8b
je 0x1bcfa
retq
leaq -0x1(%rdx), %rax
leaq 0x1(%rcx), %r8
movzbl -0x1(%r8), %r9d
leal -0x9(%r9), %r10d
cmpl $0x5, %r10d
jae 0x1bd22
movq %r8, (%rdi)
movq %rax, (%rsi)
incq %r8
addq $-0x1, %rax
jb 0x1bd02
jmp 0x1bcf9
cmpl $0x20, %r9d
je 0x1bd11
addq %rdx, %rcx
decq %rcx
movzbl (%rcx), %edx
leal -0x9(%rdx), %edi
cmpl $0x5, %edi
jae 0x1bd47
movq %rax, (%rsi)
decq %rcx
addq $-0x1, %rax
jb 0x1bd2e
jmp 0x1bcf9
cmpl $0x20, %edx
je 0x1bd39
jmp 0x1bcf9
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: Srl::Tools::str_to_type(Srl::String const&, Srl::Type)
pair<bool, Value> Tools::str_to_type(const String& string_wrap, Type hint)
{
    if(string_wrap.encoding() == Encoding::UTF8) {
        return str_to_type(string_wrap.data(), string_wrap.size(), hint);

    } else {
        auto vec = Tools::conv_charset(Encoding::UTF8, string_wrap, false);
        if(vec.size() < 1) {
            return make_pair(false, Value(Type::Null));
        }

        return str_to_type(vec.data(), vec.size(), hint);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
cmpb $0x1, 0xd(%rsi)
jne 0x1c110
cmpb $0x0, 0xe(%rdx)
movq %rdx, %rsi
jne 0x1c0ff
movq (%rdx), %rsi
movl 0x8(%rdx), %edx
movzbl %bpl, %ecx
movq %rbx, %rdi
callq 0xb270
jmp 0x1c176
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xbea0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
je 0x1c143
movzbl %bpl, %ecx
movq %rbx, %rdi
callq 0xb270
movq 0x8(%rsp), %rsi
jmp 0x1c15e
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
xorl %eax, %eax
movb %al, (%rbx)
movw $0xb, 0x1c(%rbx)
movb %al, 0x1e(%rbx)
testq %rsi, %rsi
je 0x1c176
movq 0x18(%rsp), %rax
subq %rsi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xb940
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c19c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xb940
movq %rbx, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: Srl::Tools::conv_charset(Srl::Encoding, Srl::String const&, bool)
vector<uint8_t> Tools::conv_charset(Encoding target_encoding, const String& string_wrap, bool throw_error)
{
    vector<uint8_t> buffer;
    auto converted_total = conv_charset(target_encoding, string_wrap, buffer, throw_error);
    buffer.resize(converted_total);

    return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %esi, %edi
movq %rdx, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xbc60
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb980
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1c1f6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xb940
movq %r14, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: std::enable_if<Srl::TpTools::is_num(Srl::Type)((Srl::Type)7) && !Srl::TpTools::is_fp(Srl::Type)((Srl::Type)7), unsigned long>::type (anonymous namespace)::conv_type<(Srl::Type)7>(Srl::Value const&, std::vector<unsigned char, std::allocator<unsigned char>>&)
typename enable_if<TpTools::is_num(TP) && !TpTools::is_fp(TP), size_t>::type
    conv_type(const Value& value, vector<uint8_t>& out)
    {
        typedef typename TpTools::Real<TP>::type T;
        const auto buffer_size = size_t(numeric_limits<T>::digits10) + 1 + TpTools::is_signed(TP);

        uint8_t buffer[buffer_size];

        bool negative = TpTools::is_signed(TP) && value.pblock().i64 < 0;

        uint64_t val = negative ? -value.pblock().i64 : value.pblock().ui64;

        if(val == 0) {
            if(out.size() < 1) out.resize(1);
            out[0] = '0';
            return 1;
        }

        size_t str_len = 0;
        auto* ptr = buffer + buffer_size - 1;

        for(; val > 0U;
            val /= 10U, ptr--, str_len++) {

            *ptr = '0' + val % 10;
        }

        if(negative) {
            *(ptr) = '-';
            str_len++;
        } else {
            ptr++;
        }

        Aux::copy_to_vec(out, ptr, str_len);

        return str_len;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rcx
testq %rdi, %rdi
js 0x1c750
jne 0x1c753
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
jne 0x1c742
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb980
movq (%rbx), %rax
movb $0x30, (%rax)
movl $0x1, %r14d
jmp 0x1c7e1
negq %rcx
movq $-0x1, %rsi
leaq 0x13(%rsp), %r15
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, 0x14(%rsp,%rsi)
incq %r14
decq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x1c76c
testq %rdi, %rdi
js 0x1c7ab
movq %rsp, %r15
subq %r14, %r15
addq $0x14, %r15
jmp 0x1c7b9
subq %r14, %r15
movb $0x2d, 0x14(%rsp,%rsi)
negq %rsi
movq %rsi, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cmpq %r14, %rax
jae 0x1c7d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb980
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb790
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::operator=(Srl::Tree&&)
Tree& Tree::operator= (Tree&& g)
{
    this->root_node = g.root_node;
    this->env       = move(g.env);
    if(this->env) {
        this->env->tree = this;
    }
    g.root_node = nullptr;

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq $0x0, (%r14)
callq 0xbda0
movq (%rbx), %rax
testq %rax, %rax
je 0x1cdbe
movq %rbx, (%rax)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::prologue_in(Srl::Parser&, Srl::Lib::In::Source&)
void Tree::prologue_in(Parser& parser, Lib::In::Source& source)
{
    if(this->env) {
        this->clear();

    } else {
        this->create_env();
    }

    this->env->set_input(parser, source);

    MemBlock name; Value val;
    tie(name, val) = parser.read(this->env->in);

    if(!TpTools::is_scope(val.type())) {
        throw Exception("Unable to parse source. Data malformed.");
    }

    auto* link = this->env->create_node(val.type(), name);
    this->root_node = &link->field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1cef7
movq %rbx, %rdi
callq 0xba20
jmp 0x1cf04
movq %rbx, %rdi
movl $0xe, %esi
callq 0xb890
movq (%rbx), %rdi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rsi
callq 0xb3a0
movl $0x260, %edx            # imm = 0x260
addq (%rbx), %rdx
movq (%r14), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movb 0x24(%r15), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0xe, %cl
jne 0x1cf81
leaq 0x20(%rsp), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rsi
movq (%rbx), %rdi
movq %rcx, (%rdx)
movl %esi, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb $0x0, 0xe(%rdx)
movzbl %al, %esi
callq 0xb1c0
addq $0x8, %rax
movq %rax, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0xb3b0
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2207(%rip), %rsi      # 0x1f1a5
leaq 0x2227(%rip), %rdx      # 0x1f1cc
leaq 0x20(%rsp), %rdi
callq 0xb2e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xb1d0
xorl %ebp, %ebp
movq 0xa020(%rip), %rsi      # 0x26fe8
movq 0x9f79(%rip), %rdx      # 0x26f48
movq %rbx, %rdi
callq 0xbe60
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cff1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb940
testb %bpl, %bpl
jne 0x1cffb
jmp 0x1d003
movq %rax, %r14
movq %rbx, %rdi
callq 0xb610
movq %r14, %rdi
callq 0xbe90
nop
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::clear()
void Tree::clear()
{
    if(!this->env) {
        return;
    }

    auto rtp = this->root().scope_type;

    this->env->clear();
    this->root_node = &env->create_node(rtp, "")->field;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1d059
movq 0x8(%rbx), %rax
movzbl 0x50(%rax), %ebp
callq 0xb970
movq (%rbx), %rdi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movl $0x0, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb $0x0, 0xe(%rdx)
movl %ebp, %esi
callq 0xb1c0
addq $0x8, %rax
movq %rax, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::to_source(Srl::Type, Srl::Parser&, Srl::Lib::Out::Source, std::function<void ()> const&)
void Tree::to_source(Type type, Parser& parser, Lib::Out::Source source, const function<void()>& store_switch)
{
    if(!this->env) {
        this->create_env();
    }
    this->env->set_output(parser, source);
    this->env->parsing = true;

    auto& name = this->root_node->name();
    this->env->write(Value(type), name);

    store_switch();

    this->env->write(Value(Type::Scope_End), name);

    this->env->parsing = false;
    this->env->out.flush();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %r8d, %r13d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x1d097
movq %rbx, %rdi
movl $0xe, %esi
callq 0xb890
movq (%rbx), %rdi
movzbl %r13b, %ecx
movq %r12, %rsi
movq %r15, %rdx
callq 0xbd60
movq (%rbx), %rdi
movb $0x1, 0x258(%rdi)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %r15
testq %r15, %r15
jne 0x1d0c4
movq 0x9e7c(%rip), %r15      # 0x26f40
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movb %bpl, 0x14(%rsi)
movw $0x0, 0x15(%rsi)
movq %r15, %rdx
callq 0xb8d0
cmpq $0x0, 0x10(%r14)
je 0x1d140
movq %r14, %rdi
callq *0x18(%r14)
movq (%rbx), %rdi
movq %rsp, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movw $0x10, 0x14(%rsi)
xorl %ebp, %ebp
movb %bpl, 0x16(%rsi)
movq %r15, %rdx
callq 0xb8d0
movq (%rbx), %rdi
movb %bpl, 0x258(%rdi)
addq $0x2b0, %rdi            # imm = 0x2B0
callq 0xbde0
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_O3/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: buildPrefixList(unsigned int*, unsigned int)
PrefixList* buildPrefixList(uint32_t* a, uint32_t a_len) {
	PrefixNode* head = NULL;
	PrefixNode* last = NULL;
	for (int i = 0; i < a_len; i++) {
		uint16_t h16 = _high16(a[i]);
		if (head != NULL) {
			assert(last != NULL);
			if (h16 == last->prefix) {
				last->cnt++;
			} else {
				PrefixNode* last2 = new PrefixNode(NULL, i, 1, h16);
				last->next = last2;
				last = last2;
			}
		} else {
			head = new PrefixNode(NULL, i, 1, h16);
			last = head;
		}
	}

	PrefixList* pl = new PrefixList;
	pl->head = head;
	pl->data = a;
	pl->data_len = a_len;
	return pl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl %esi, 0x4(%rsp)
testl %esi, %esi
je 0x24c9
movl %esi, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movzwl 0x2(%r14,%r13,4), %ebx
testq %rbp, %rbp
je 0x2473
testq %r15, %r15
je 0x24f2
cmpw %bx, 0xe(%r15)
jne 0x249a
incw 0xc(%r15)
jmp 0x24bf
movl $0x10, %edi
callq 0x2160
movq $0x0, (%rax)
movl %r13d, 0x8(%rax)
movw $0x1, 0xc(%rax)
movq %rax, %r15
movq %rax, %rbp
movw %bx, 0xe(%rax)
jmp 0x24bf
movl $0x10, %edi
callq 0x2160
movq $0x0, (%rax)
movl %r13d, 0x8(%rax)
movw $0x1, 0xc(%rax)
movw %bx, 0xe(%rax)
movq %rax, (%r15)
movq %rax, %r15
incq %r13
cmpq %r13, %r12
jne 0x2451
jmp 0x24cb
xorl %ebp, %ebp
movl $0x18, %edi
callq 0x2160
movl 0x4(%rsp), %ecx
movq %rbp, (%rax)
movq %r14, 0x8(%rax)
movl %ecx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b67(%rip), %rdi      # 0x6060
leaq 0x3b6d(%rip), %rsi      # 0x606d
leaq 0x3b75(%rip), %rcx      # 0x607c
movl $0x1b, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: dumpPrefixList(PrefixList*)
void dumpPrefixList(PrefixList* pl) {
	PrefixNode* n = pl->head;
	while (n != NULL) {
		cout<<n->offset<<"\t"<<n->cnt<<"\t"<<hex<<n->prefix<<endl;
		n = n->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
testq %r12, %r12
je 0x25d0
movq 0x6aac(%rip), %rbx      # 0x8fd8
leaq 0x435d(%rip), %r14      # 0x6890
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x20c0
movl $0x1, %edx
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movzwl 0xc(%r12), %esi
movq %r15, %rdi
callq 0x20c0
movl $0x1, %edx
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movq (%r15), %rax
movq %r15, %rdi
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movzwl 0xe(%r12), %esi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq (%r12), %r12
testq %r12, %r12
jne 0x2533
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq