LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
cmpb $0x0, 0x2a(%rdx)
jne 0x1a85e
cmpb $0xf, 0x60(%rdi)
je 0x1a85e
cmpb $0x1, 0x29(%rbx)
je 0x1a884
movups (%rsi), %xmm0
movups %xmm0, (%rbx)
movb $0x1, 0x29(%rbx)
jmp 0x1a87e
movq (%rsi), %rax
movl 0x8(%rsi), %ecx
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl %ecx, 0x20(%rbx)
movw $0x10c, 0x24(%rbx)      # imm = 0x10C
movb $0x0, 0x26(%rbx)
movb $0x1, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6fdb(%rip), %rdi      # 0x21866
callq 0x111c0
movq %rsp, %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
movw $0x10c, 0xc(%rcx)       # imm = 0x10C
movb $0x0, 0xe(%rcx)
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x11100
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x113d0
cmpb $0x0, (%r15)
movq 0x18(%r15), %rax
movq %rax, 0x20(%rbx)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x10(%rbx)
je 0x1a8fa
movb $0x1, 0x28(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movl 0x8(%r14), %ecx
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movw $0x10c, 0xc(%rsi)       # imm = 0x10C
movb $0x0, 0xe(%rsi)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x11f30
leaq 0x6f48(%rip), %rsi      # 0x21874
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x128a0
leaq 0x6f4e(%rip), %rdx      # 0x2188e
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x11250
movq (%rsp), %rax
movl 0x8(%rsp), %ecx
leaq 0x70(%rsp), %rdx
movq %rax, (%rdx)
movl %ecx, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb $0x0, 0xe(%rdx)
movq %rbx, %rsi
callq 0x11100
movq %rax, %rbx
movq %rsp, %rdi
callq 0x12cd8
jmp 0x1a982
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x12cd8
jmp 0x1a991
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x12cd8
movq %rbx, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Out.hpp
// Function: Srl::Lib::Out::write(unsigned char const*, unsigned long)
inline void Out::write(const uint8_t* bytes, size_t nbytes)
    {
        auto* mem = this->alloc(nbytes);

        if(nbytes != 1) {
            memcpy(mem, bytes, nbytes);
        } else {
            *mem = *bytes;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdx, %rsi
callq 0x11a90
cmpq $0x1, %rbx
jne 0x1ab05
movb (%r14), %cl
movb %cl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11bf0
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/In.hpp
// Function: Srl::Lib::MemBlock Srl::Lib::In::read_block_until<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&)
MemBlock In::read_block_until(const Error& error, const Tokens&... tokens)
    {
        this->anchor = this->pos;
        auto steps = this->move_until(error, tokens...);
        this->anchor = nullptr;

        return { this->pos - steps, steps };
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rsp), %rax
movq 0x10(%rdi), %rdi
movq %rdi, 0x48(%rbx)
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x11360
movq %rax, %rdx
andq $0x0, 0x48(%rbx)
movq 0x10(%rbx), %rax
subq %rdx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Out.hpp
// Function: void Srl::Lib::Out::substitute_token<char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>>(unsigned char, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, 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 %rbx
movsbl (%rdx), %eax
cmpl %eax, %esi
jne 0x1acdd
movq %rcx, %rbx
pushq $0x2
popq %rsi
callq 0x11a90
movb (%rbx), %cl
movb %cl, (%rax)
movb 0x1(%rbx), %cl
movb %cl, 0x1(%rax)
popq %rbx
retq
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %r10
movzbl %sil, %esi
movq %r8, %rdx
movq %r9, %rcx
movq %r10, %r8
movq %rax, %r9
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x119e0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Out.hpp
// Function: Srl::Lib::Out::alloc(unsigned long)
inline uint8_t* Out::alloc(size_t nbytes)
    {
        this->state.sz_total += nbytes;

        if(!this->streaming) {
            return this->heap.get_mem(nbytes);
        }

        if(this->state.left < nbytes) {
            this->write_to_stream();
        }

        if(this->state.cap < nbytes) {
            this->inc_cap(nbytes);
        }

        this->state.left -= nbytes;
        this->state.crr_mem += nbytes;

        return this->state.crr_mem - nbytes;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq %rsi, 0x50(%rdi)
cmpb $0x0, 0x80(%rdi)
je 0x1addb
cmpq %rbx, 0x58(%r14)
jae 0x1adb3
movq %r14, %rdi
callq 0x116f0
cmpq %rbx, 0x60(%r14)
jae 0x1adc4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x125e0
subq %rbx, 0x58(%r14)
movq 0x70(%r14), %rax
addq %rax, %rbx
movq %rbx, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x117f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/In.hpp
// Function: unsigned long Srl::Lib::In::move_until<false, char, char>(std::function<void ()> const&, char const&, char 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
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
jne 0x1b072
movq %r15, %rdi
callq 0x11e90
xorl %ebp, %ebp
pushq $0x1
popq %r13
movsbl (%r14), %ecx
movq 0x10(%r12), %rax
movzbl (%rax), %eax
cmpl %ecx, %eax
je 0x1b0a1
movsbl (%rbx), %ecx
cmpl %ecx, %eax
je 0x1b0a1
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x12a40
incl %ebp
jmp 0x1b078
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/In.hpp
// Function: unsigned long Srl::Lib::In::substitute_token<char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, char, std::array<char const, 2ul>, 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, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, char const&, std::array<char const, 2ul> const&, 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:
cmpq $0x2, %rcx
jb 0x1b24b
movq 0x10(%rdi), %rax
movzbl (%rax), %r10d
movsbl (%r9), %r11d
cmpl %r11d, %r10d
jne 0x1b24b
movzbl 0x1(%rax), %eax
movsbl 0x1(%r9), %r9d
cmpl %r9d, %eax
jne 0x1b24b
movb (%r8), %al
movq (%rsi), %rcx
movb %al, (%rcx,%rdx)
addq $0x2, 0x10(%rdi)
pushq $0x1
popq %rax
retq
pushq %rax
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %r8
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
callq 0x118d0
addq $0x80, %rsp
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/In.hpp
// Function: Srl::Lib::In::read_block(unsigned long, std::function<void ()> const&)
inline MemBlock In::read_block(size_t steps, const Error& error)
    {
        this->anchor = this->pos;
        this->move(steps, error);
        this->anchor = nullptr;

        return { this->pos - steps, steps };
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rdi)
callq 0x12a40
andq $0x0, 0x48(%r14)
movq 0x10(%r14), %rax
subq %rbx, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::write_str(Srl::Lib::MemBlock const&, Srl::Lib::Out&)
void write_str(const MemBlock& block, Out& out)
    {
        if(block.size <= 0x1F) {
            out.write_byte(0xA0 | block.size);

        } else if(block.size <= 0xFE) {
            out.write_byte(0xD9);
            out.write_byte(block.size);

        } else if (block.size <= 0xFFFE) {
            uint16_t sz = block.size;
            out.write_byte(0xDA);
            out.write(sz);

        } else {
            uint32_t sz = block.size;
            out.write_byte(0xDB);
            out.write(sz);
        }

        out.write(block.ptr, block.size);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq $0x1f, %rax
ja 0x1c28d
orb $-0x60, %al
movzbl %al, %esi
jmp 0x1c2a7
cmpq $0xfe, %rax
ja 0x1c2c8
movq %rbx, %rdi
movl $0xd9, %esi
callq 0x12160
movzbl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x12160
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x120f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpq $0xfffe, %rax           # imm = 0xFFFE
ja 0x1c2f3
leaq 0xa(%rsp), %r15
movw %ax, (%r15)
movq %rbx, %rdi
movl $0xda, %esi
callq 0x12160
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11770
jmp 0x1c2af
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movq %rbx, %rdi
movl $0xdb, %esi
callq 0x12160
movq %rbx, %rdi
movq %r15, %rsi
callq 0x110f0
jmp 0x1c2af
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x3(%rsp), %r15
movb %sil, (%r15)
cmpl $0xe, %esi
sete %al
addb %al, %al
orb $-0x23, %al
leaq 0x2(%rsp), %rsi
movb %al, (%rsi)
movq %rdx, %rdi
callq 0x11e50
leaq 0x8(%rsp), %r12
pushq $0x4
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x12960
leaq 0x20(%rbx), %rdi
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
movq %r15, %rsi
movq %r12, %rcx
callq 0x124f0
movq 0x50(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x1c389
movq 0x68(%rbx), %rcx
movl $0x1e0, %eax            # imm = 0x1E0
addq -0x8(%rcx), %rax
addq $-0x28, %rax
movq %rax, 0x70(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Out.hpp
// Function: Srl::Lib::Out::write(Srl::Lib::Out::Ticket&, unsigned char const*, unsigned long, unsigned long)
inline void Out::write(Out::Ticket& ticket, const uint8_t* bytes, size_t offset, size_t nbytes)
    {
        assert(ticket.size >= offset + nbytes);

        if(!this->streaming || ticket.seg_id == this->state.segs_flushed) {
            memcpy(ticket.mem + offset, bytes, nbytes);

        } else {
            auto crr = this->stream->tellp();

            this->stream->seekp(ticket.pos + offset);
            this->stream->write((const char*)bytes, nbytes);

            this->stream->seekp(crr);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq (%r8,%rcx), %rax
cmpq %rax, 0x8(%rsi)
jb 0x1cc14
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
cmpb $0x1, 0x80(%rdi)
jne 0x1cb99
movq 0x18(%r13), %rax
cmpq 0x68(%r15), %rax
jne 0x1cbb9
addq (%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11bf0
movq 0x88(%r15), %rdi
callq 0x11c50
movq %rax, %rbp
movq %rdx, (%rsp)
movq 0x88(%r15), %rdi
addq 0x10(%r13), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x12110
movq 0x88(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12270
movq 0x88(%r15), %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12110
leaq 0x4e5e(%rip), %rdi      # 0x21a79
leaq 0x4e76(%rip), %rsi      # 0x21a98
leaq 0x4e83(%rip), %rcx      # 0x21aac
pushq $0x2c
popq %rdx
callq 0x11890
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/include/Srl/Out.hpp
// Function: Srl::Lib::Out::reserve(unsigned long)
inline Out::Ticket Out::reserve(size_t nbytes)
    {
        auto pos = this->state.sz_total;
        auto* reserved = this->alloc(nbytes);
        memset(reserved, 0, nbytes);

        return { reserved, nbytes, pos, this->state.segs_flushed };
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rsi), %r13
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x11a90
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x116a0
movq 0x68(%r14), %rax
movq %r12, (%r15)
movq %rbx, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/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 %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
cmpq $0x0, 0x8(%rdx)
je 0x1d407
movzbl 0x8(%rdi), %eax
orl $0x4, %eax
cmpl $0xf, %eax
jne 0x1d41d
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12160
movq %rdx, %r14
movq 0xe0(%rdi), %rax
addq $0xc8, %rdi
movq %rsp, %rdx
movq %rax, (%rdx)
movq %r14, %rsi
callq 0x11710
testb $0x1, %al
je 0x1d460
movq %rdx, %r15
orb $0x6, %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x12160
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1d492
jmp 0x1d487
orb $0x2, %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x12160
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1d492
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11cd0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/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:
subq $0x18, %rsp
movq %rsi, %rax
pushq $0x1
popq %rdx
cmpq $0x80, %rdi
jb 0x1d4bd
movq %rdi, %rcx
shrq $0x7, %rcx
orb $-0x80, %dil
movb %dil, 0xd(%rsp,%rdx)
incq %rdx
movq %rcx, %rdi
jmp 0x1d49c
movb %dil, 0xd(%rsp,%rdx)
leaq 0xe(%rsp), %rsi
movq %rax, %rdi
callq 0x120f0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10790(%rip), %rsi     # 0x2dc80
movq %rdx, %rdi
callq 0x11a00
movl %eax, %ebp
testb $0x2, %al
je 0x1d50b
movzbl 0x8(%r14), %eax
orl $0x4, %eax
cmpl $0xf, %eax
jne 0x1d525
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movb %bpl, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x1d5c2
movq %rax, %r12
testb $0x4, %bpl
jne 0x1d589
leaq 0x10743(%rip), %rdx     # 0x2dc80
movq %r15, %rdi
movq %r12, %rsi
callq 0x12a90
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
cmpb $0x1, 0x18(%r15)
jne 0x1d56e
leaq 0x28(%r14), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x117a0
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0x18(%r14), %rsi
addq $0x10, %r14
movq %rsp, %rdx
movq %r14, %rdi
callq 0x12ca0
movb %bpl, (%rbx)
movups (%rax), %xmm0
jmp 0x1d5b9
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r12
jb 0x1d5ad
leaq 0x106dc(%rip), %rdi     # 0x2dc80
callq 0x11e90
movq 0x10(%r14), %rax
shlq $0x4, %r12
movb %bpl, (%rbx)
movups (%rax,%r12), %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x1d515
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movzbl (%rax), %eax
movl %eax, %r14d
andl $0x7f, %r14d
pushq $0x7
popq %rbp
leaq 0x1069b(%rip), %r15     # 0x2dc80
pushq $0x1
popq %r12
testb %al, %al
jns 0x1d614
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x12a40
movq 0x10(%rbx), %rax
movzbl (%rax), %eax
movl %eax, %edx
andl $0x7f, %edx
movl %ebp, %ecx
shlq %cl, %rdx
orq %rdx, %r14
addl $0x7, %ebp
jmp 0x1d5e9
cmpl $0x47, %ebp
jb 0x1d625
leaq 0x10660(%rip), %rdi     # 0x2dc80
callq 0x11e90
leaq 0x10654(%rip), %rdx     # 0x2dc80
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12a40
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x78(%rdi), %r14
movq %r14, %rdi
callq 0x123e0
movq %r14, %rdi
callq 0x12300
testq %rax, %rax
je 0x1d841
movq 0xa8(%rbx), %rax
cmpq 0xb0(%rbx), %rax
jne 0x1d83c
movq 0xc0(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movb -0x1(%rax), %al
jmp 0x1d843
movb $0xb, %al
movb %al, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/PSrl.cpp
// Function: Srl::PSrl::read(Srl::Lib::In&)
pair<Lib::MemBlock, Value> PSrl::read(In& source)
{
    Flag flag; MemBlock name;
    tie(flag, name) = this->read_head(source);

    if(!flag) {
        if(this->scope_stack.size() < 1) {
            error();
        }
        this->pop_scope();

        return { MemBlock(), Type::Scope_End };
    }

    if(is_scope(flag)) {
        auto tp = flag & FObject ? Type::Object : Type::Array;
        this->push_scope(tp);

        return { name, tp };
    }

    if(flag & FNum) {
        return this->read_num(flag, name, source);
    }


    if(flag & (FBinary | FString)) {
        auto size  = decode_integer(source);
        auto block = source.read_block(size, error);
        auto type = flag & FBinary ? Type::Binary : Type::String;

        return { name, Value(block, type, Encoding::UTF8) };
    }

    if(flag & FNull) {
        return { name, Type::Null };
    }

    /* shouldn't end down here */
    error();
    return { name, Type::Null };
;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x12670
movzbl (%r12), %ebp
movups 0x8(%r12), %xmm0
movaps %xmm0, (%rsp)
testl %ebp, %ebp
je 0x1d8f6
cmpb $0x40, %bpl
setb %al
orb %bpl, %al
testb $0x1, %al
jne 0x1d932
xorl %esi, %esi
testb $0x40, %bpl
sete %sil
movl %esi, %ebp
orb $0xe, %bpl
orl $0xe, %esi
movq %r14, %rdi
callq 0x129e0
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
movb %bpl, 0x24(%rbx)
andw $0x0, 0x25(%rbx)
jmp 0x1d990
leaq 0x78(%r14), %rdi
callq 0x12300
testq %rax, %rax
jne 0x1d910
leaq 0x10375(%rip), %rdi     # 0x2dc80
callq 0x11e90
movq %r14, %rdi
callq 0x12ac0
xorps %xmm0, %xmm0
andl $0x0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movw $0x10, 0x24(%rbx)
movb $0x0, 0x26(%rbx)
jmp 0x1d990
testb $0x1, %bpl
jne 0x1d980
testb $0x30, %bpl
je 0x1d9a0
movq %r15, %rdi
callq 0x1d5c2
leaq 0x10333(%rip), %rdx     # 0x2dc80
movq %r15, %rdi
movq %rax, %rsi
callq 0x12a90
testb $0x10, %bpl
sete %cl
xorb $0xd, %cl
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl %edx, 0x20(%rbx)
movb %cl, 0x24(%rbx)
movw $0x1, 0x25(%rbx)
jmp 0x1d990
movq %rsp, %rcx
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %r8
callq 0x121a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb $0x8, %bpl
jne 0x1d9b2
leaq 0x102d3(%rip), %rdi     # 0x2dc80
callq 0x11e90
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
andl $0x0, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movw $0xb, 0x24(%rbx)
jmp 0x1d92c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
cmpb $0x40, %bpl
jae 0x1da27
testb $0x10, %bpl
jne 0x1da51
cmpb $0x20, %bpl
jae 0x1da90
movq %r8, %rdi
callq 0x1d5c2
cmpb $0x8, %bpl
jae 0x1dabd
movups (%r14), %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x8, 0x20(%rbx)
movw $0x8, 0x24(%rbx)
jmp 0x1da80
shrb $0x6, %bpl
movups (%r14), %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movl $0x1, 0x20(%rbx)
andw $0x0, 0x24(%rbx)
andb $0x1, %bpl
movzbl %bpl, %eax
movq %rax, 0x18(%rbx)
jmp 0x1da80
leaq 0x10228(%rip), %rsi     # 0x2dc80
movq %r8, %rdi
callq 0x11210
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)
movb $0x1, 0x26(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x101e9(%rip), %rsi     # 0x2dc80
movq %r8, %rdi
callq 0x11c20
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
callq 0x11bb0
jmp 0x1da84
negq %rax
movups (%r14), %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl $0x8, 0x20(%rbx)
movw $0x7, 0x24(%rbx)
jmp 0x1da80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1daf2
movq %rax, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x11830
leaq 0xc8(%rbx), %rdi
callq 0x12cc0
movb $0xb, 0x8(%rbx)
addq $0x78, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x124d0
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Srl::Tools::bytes_to_base64(unsigned char const*, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>>&)
size_t Tools::bytes_to_base64(const uint8_t* bytes, size_t nbytes, vector<uint8_t>& out)
{
    auto min_size = 4 * ((nbytes + 2) / 3);

    if(out.size() < min_size) {
        out.resize(min_size);
    }

    Base64Table table;
    uint8_t b0 = 0, b1 = 0, b2 = 0;

    for(size_t in_idx = 0U, out_idx = 0U; in_idx < nbytes;
               in_idx += 3, out_idx += 4) {

        b0 = bytes[in_idx];
        b1 = in_idx + 1 < nbytes ? bytes[in_idx + 1] : 0;
        b2 = in_idx + 2 < nbytes ? bytes[in_idx + 2] : 0;

        /* [BBBBBB]BB BBBBBBBB BBBBBBBB */
        out[out_idx]     = table.encode[b0 >> 2];
        /* PPPPPP [BB BBBB]BBBB BBBBBBBB */
        out[out_idx + 1] = table.encode[((b0 << 4) | (b1 >> 4)) & 0x3F];
        /* PPPPPP PPPPPP [BBBB BB]BBBBBB */
        out[out_idx + 2] = table.encode[((b1 << 2) | (b2 >> 6)) & 0x3F];
        /* PPPPPP PPPPPP PPPPPP [BBBBBB] */
        out[out_idx + 3] = table.encode[b2 & 0x3F];
    }

    auto rem = nbytes % 3;
    /* rem == 1 -> 2 equals signs, rem == 2 -> 1 equals sign */
    if(rem > 0) {
        out[min_size - 1] = '=';
    }
    if(rem == 1) {
        out[min_size - 2] = '=';
    }

    return min_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x2(%rsi), %rax
pushq $0x3
popq %r13
xorl %edx, %edx
divq %r13
movq %rax, %r14
shlq $0x2, %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq %r14, %rax
jae 0x1eaea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11f70
leaq 0xe(%rsp), %rdi
callq 0x12980
xorl %edi, %edi
xorl %eax, %eax
cmpq %r15, %rdi
jae 0x1eb8f
leaq 0x1(%rdi), %rcx
xorl %edx, %edx
movl $0x0, %esi
cmpq %r15, %rcx
jae 0x1eb17
movzbl 0x1(%r12,%rdi), %esi
incq %rcx
cmpq %r15, %rcx
jae 0x1eb25
movzbl 0x2(%r12,%rdi), %edx
movzbl (%r12,%rdi), %edi
movl %edi, %r8d
shrl $0x2, %r8d
movb 0x10(%rsp,%r8), %r8b
movq (%rbx), %r9
movb %r8b, (%r9,%rax)
shll $0x4, %edi
movl %esi, %r8d
shrl $0x4, %r8d
andl $0x30, %edi
orl %r8d, %edi
movb 0x10(%rsp,%rdi), %dil
movq (%rbx), %r8
movb %dil, 0x1(%r8,%rax)
movl %edx, %edi
shrl $0x6, %edi
andl $0xf, %esi
leal (%rdi,%rsi,4), %esi
movb 0x10(%rsp,%rsi), %sil
movq (%rbx), %rdi
movb %sil, 0x2(%rdi,%rax)
andl $0x3f, %edx
movb 0x10(%rsp,%rdx), %dl
movq (%rbx), %rsi
movb %dl, 0x3(%rsi,%rax)
addq $0x4, %rax
incq %rcx
movq %rcx, %rdi
jmp 0x1eaf8
movq %r15, %rax
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
je 0x1ebb4
movq (%rbx), %rax
movb $0x3d, -0x1(%rax,%r14)
cmpq $0x1, %rdx
jne 0x1ebb4
movq (%rbx), %rax
movb $0x3d, -0x2(%rax,%r14)
movq %r14, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x126e0
movq %rax, %r12
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12780
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x124b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x126a0
movq %r14, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12780
xorl %eax, %eax
leaq 0x3162(%rip), %rcx      # 0x21f90
cmpq %rax, %rbx
je 0x1ee5b
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
jmp 0x1ee2e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Srl::Tools::hex_to_bytes(unsigned char*, unsigned long, unsigned char const*, unsigned long)
void Tools::hex_to_bytes(uint8_t* dest, size_t dest_size, const uint8_t* str, size_t str_len)
{
    if(str_len % 2 != 0) {
        throw Exception("Unable to convert hex string to binary data. Size of source must be even.");
    }

    if(dest_size < str_len / 2) {
        throw Exception("Unable to convert hex string to binary data. Destination buffer too small.");
    }

    const auto conv = [](uint8_t& c) {
        if(c >= '0' && c <= '9') {
            c -= '0';

        } else if(c >= 'A' && c <= 'F') {
            c = (c - 'A') + 10;

        } else if(c >= 'a' && c <= 'f') {
            c = (c - 'a') + 10;

        } else {
            throw Exception("Unable to convert hex string to binary data. String malformed.");
        }
    };

    uint8_t low = 0, high = 0;
    uint8_t packed = 0;

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

        high = str[in_idx];
        low  = str[in_idx + 1];

        conv(high);
        conv(low);

        packed = (high << 4U) | low;
        dest[out_idx] = packed;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
testb $0x1, %bl
jne 0x1ef42
movq %rbx, %rax
shrq %rax
cmpq %rsi, %rax
ja 0x1ef8d
movq %rdx, %r14
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x7(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpq %rbx, %rbp
jae 0x1ef33
movb (%r14,%rbp), %al
movb %al, 0x7(%rsp)
movb 0x1(%r14,%rbp), %al
movb %al, 0x8(%rsp)
movq %r12, %rdi
callq 0x1f002
movq %r13, %rdi
callq 0x1f002
movb 0x7(%rsp), %al
shlb $0x4, %al
orb 0x8(%rsp), %al
movb %al, (%r15)
addq $0x2, %rbp
incq %r15
jmp 0x1eef6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x115e0
movq %rax, %rbx
leaq 0x2f31(%rip), %rsi      # 0x21e85
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x128f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11300
xorl %ebp, %ebp
movq 0xd06c(%rip), %rsi      # 0x2bfe8
movq 0xcfc5(%rip), %rdx      # 0x2bf48
movq %rbx, %rdi
callq 0x12920
jmp 0x1efd6
pushq $0x28
popq %rdi
callq 0x115e0
movq %rax, %rbx
leaq 0x2f30(%rip), %rsi      # 0x21ecf
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x128f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11300
xorl %ebp, %ebp
movq 0xd021(%rip), %rsi      # 0x2bfe8
movq 0xcf7a(%rip), %rdx      # 0x2bf48
movq %rbx, %rdi
callq 0x12920
jmp 0x1efda
jmp 0x1efee
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x12cd8
testb %bpl, %bpl
jne 0x1eff1
jmp 0x1eff9
movq %rax, %r14
movq %rbx, %rdi
callq 0x119b0
movq %r14, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Base64Table::Base64Table()
Base64Table()
    {
        for(auto i = 0U; i < 256U; i++) {
            decode[i] = val_invalid;
        }
        decode[(size_t)'='] = val_fill;
        for(auto i = 0U; i < 64U; i++) {
            decode[(size_t)encode[i]] = i;
        }
    }

// Assembly:
movw $0xfeff, (%rdi)         # imm = 0xFEFF
movups 0x2e9a(%rip), %xmm0     # 0x21fa0
movups %xmm0, 0x2(%rdi)
movups 0x2e9f(%rip), %xmm0     # 0x21fb0
movups %xmm0, 0x12(%rdi)
movups 0x2ea4(%rip), %xmm0     # 0x21fc0
movups %xmm0, 0x22(%rdi)
movups 0x2ea9(%rip), %xmm0     # 0x21fd0
movups %xmm0, 0x32(%rdi)
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x1f13f
movb $-0x1, 0x42(%rdi,%rax)
incq %rax
jmp 0x1f12d
movb $-0x2, 0x7f(%rdi)
xorl %eax, %eax
cmpq $0x40, %rax
je 0x1f15a
movsbq 0x2(%rdi,%rax), %rcx
movb %al, 0x42(%rdi,%rcx)
incq %rax
jmp 0x1f145
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
testq %rdx, %rdx
je 0x1f23e
movq (%rsi), %rax
decq %rax
incq %rdx
movabsq $0x100003e00, %rcx      # imm = 0x100003E00
cmpq $-0x1, %rax
je 0x1f21d
movzbl -0x1(%rdx), %r8d
cmpq $0x20, %r8
ja 0x1f21d
btq %r8, %rcx
jae 0x1f21d
movq %rdx, (%rdi)
movq %rax, (%rsi)
decq %rax
incq %rdx
jmp 0x1f1f8
movq (%rdi), %rdx
cmpq $-0x1, %rax
je 0x1f23e
movzbl (%rdx,%rax), %edi
cmpq $0x20, %rdi
ja 0x1f23e
btq %rdi, %rcx
jae 0x1f23e
movq %rax, (%rsi)
decq %rax
jmp 0x1f220
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f5c5
cmpb $0x0, 0xe(%rdx)
movq %rdx, %rsi
jne 0x1f5b4
movq (%rdx), %rsi
movl 0x8(%rdx), %edx
movzbl %bpl, %ecx
movq %rbx, %rdi
callq 0x113d0
jmp 0x1f613
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x129a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
je 0x1f5f1
movzbl %bpl, %ecx
movq %rbx, %rdi
callq 0x113d0
jmp 0x1f609
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
andl $0x0, 0x18(%rbx)
xorl %eax, %eax
movb %al, (%rbx)
movw $0xb, 0x1c(%rbx)
movb %al, 0x1e(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x126a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x126a0
movq %rbx, %rdi
callq 0x12990
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %rcx
movq %rcx, %rax
testq %rcx, %rcx
js 0x1fa45
jne 0x1fa48
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
jne 0x1fa3c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x11f70
movq (%rbx), %rax
movb $0x30, (%rax)
pushq $0x1
popq %r14
jmp 0x1fa96
negq %rax
leaq 0x13(%rsp), %rsi
xorl %edi, %edi
pushq $0xa
popq %r8
xorl %r14d, %r14d
testq %rax, %rax
je 0x1fa6f
xorl %edx, %edx
divq %r8
orb $0x30, %dl
movb %dl, 0x13(%rsp,%rdi)
incq %r14
decq %rdi
jmp 0x1fa56
testq %rcx, %rcx
js 0x1fa80
movq %rsp, %rsi
subq %r14, %rsi
addq $0x14, %rsi
jmp 0x1fa8b
subq %r14, %rsi
movb $0x2d, 0x13(%rsp,%rdi)
incq %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x12430
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
callq 0x11a50
movq (%rbx), %rax
testq %rax, %rax
je 0x200f2
movq %rbx, (%rax)
andq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2021f
movq %rbx, %rdi
callq 0x12060
jmp 0x2022a
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x11dc0
movq (%rbx), %rdi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rsi
callq 0x115d0
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 0x202a7
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 0x112a0
addq $0x8, %rax
movq %rax, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x115e0
movq %rax, %rbx
leaq 0x1f0c(%rip), %rsi      # 0x221c5
leaq 0x20(%rsp), %rdi
leaq 0x1f(%rsp), %rdx
callq 0x128f0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x11300
xorl %ebp, %ebp
movq 0xbd07(%rip), %rsi      # 0x2bfe8
movq 0xbc60(%rip), %rdx      # 0x2bf48
movq %rbx, %rdi
callq 0x12920
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x12cd8
testb %bpl, %bpl
jne 0x20307
jmp 0x2030f
movq %rax, %r14
movq %rbx, %rdi
callq 0x119b0
movq %r14, %rdi
callq 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2039d
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x11dc0
movq (%rbx), %rdi
movzbl %r13b, %ecx
movq %r12, %rsi
movq %r15, %rdx
callq 0x127b0
movq (%rbx), %rdi
movb $0x1, 0x258(%rdi)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %r15
testq %r15, %r15
jne 0x203ca
movq 0xbb76(%rip), %r15      # 0x2bf40
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
andl $0x0, 0x10(%r12)
movb %bpl, 0x14(%r12)
andw $0x0, 0x15(%r12)
movq %r12, %rsi
movq %r15, %rdx
callq 0x11e20
movq %r14, %rdi
callq 0x11e90
movq (%rbx), %rdi
andl $0x0, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movw $0x10, 0x14(%r12)
xorl %ebp, %ebp
movb %bpl, 0x16(%r12)
movq %rsp, %rsi
movq %r15, %rdx
callq 0x11e20
movq (%rbx), %rdi
movb %bpl, 0x258(%rdi)
addq $0x2b0, %rdi            # imm = 0x2B0
callq 0x12860
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/night-shift[P]Srl/src/lib/fpconv/fpconv.c
// Function: round_digit
static void round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac)
{
    while (rem < frac && delta - rem >= kappa &&
           (rem + kappa < frac || frac - rem > rem + kappa - frac)) {

        digits[ndigits - 1]--;
        rem += kappa;
    }
}

// Assembly:
movslq %esi, %rax
subq %rcx, %rdx
movq %r8, %rsi
subq %r9, %rsi
movq %r9, %r10
subq %rcx, %r10
cmpq %r9, %rcx
jae 0x20e0a
subq %r8, %rdx
jb 0x20e0a
leaq (%rcx,%r8), %r11
cmpq %r9, %r11
jb 0x20dfe
addq %rsi, %rcx
cmpq %rcx, %r10
jbe 0x20e0a
decb -0x1(%rdi,%rax)
subq %r8, %r10
movq %r11, %rcx
jmp 0x20de3
retq