LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::set(Srl::Lib::Out::Source)
void Out::set(Source source)
{
    this->heap.clear();
    this->state = State();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rsi, -0x10(%rbp)
movb %al, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34800
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x343e0
leaq -0x48(%rbp), %rdi
callq 0x33330
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
leaq -0x48(%rbp), %rsi
movl $0x30, %edx
callq 0x35360
movq -0x50(%rbp), %rax
movb -0x8(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x80(%rax)
testb $0x1, -0x8(%rbp)
je 0x4e7c1
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x4e7c9
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x4e7c9
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x88(%rax)
testb $0x1, -0x8(%rbp)
jne 0x4e7e8
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x4e7f0
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x4e7f0
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x90(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::inc_cap(unsigned long)
void Out::inc_cap(size_t nbytes)
{
    this->state.cap = Stream_Buffer_Size < nbytes ? nbytes : Stream_Buffer_Size;
    this->state.mem_start = this->heap.get_mem(this->state.cap);
    this->state.left = this->state.cap;
    this->state.crr_mem = this->state.mem_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x400, %eax            # imm = 0x400
cmpq -0x10(%rbp), %rax
jae 0x4e83d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4e848
movl $0x400, %eax            # imm = 0x400
movq %rax, -0x20(%rbp)
jmp 0x4e848
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x60(%rdi)
movq 0x60(%rdi), %rsi
callq 0x34730
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq 0x60(%rax), %rcx
movq %rcx, 0x58(%rax)
movq 0x78(%rax), %rcx
movq %rcx, 0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::flush()
void Out::flush()
{
    if(this->streaming) {
        this->write_to_stream();
        this->stream->flush();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x80(%rax)
je 0x4e8b8
movq -0x10(%rbp), %rdi
callq 0x344a0
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x34b70
jmp 0x4e8c1
movq -0x10(%rbp), %rdi
callq 0x36710
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::write_to_stream()
void Out::write_to_stream()
{
    if(!this->streaming || this->state.mem_start == nullptr) {
        return;
    }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x80(%rax)
je 0x4e8f8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x4e8fa
jmp 0x4e936
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
movq 0x78(%rax), %rsi
movq 0x60(%rax), %rdx
subq 0x58(%rax), %rdx
callq 0x369d0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x58(%rax)
movq 0x78(%rax), %rcx
movq %rcx, 0x70(%rax)
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/Out.cpp
// Function: Srl::Lib::Out::write_to_buffer()
void Out::write_to_buffer()
{
    assert(this->buffer);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x90(%rax)
je 0x4e960
jmp 0x4e97f
leaq 0x1ae52(%rip), %rdi     # 0x697b9
leaq 0x1ae58(%rip), %rsi     # 0x697c6
movl $0x34, %edx
leaq 0x1ae5c(%rip), %rcx     # 0x697d6
callq 0x349a0
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x50(%rax), %rsi
callq 0x35f00
movq -0x28(%rbp), %rax
movl $0x0, -0xc(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4e9ff
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %ecx
movq -0x18(%rbp), %rdx
subl 0x10(%rdx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x90(%rax), %rdi
callq 0x36f40
movq %rax, %rdi
movl -0xc(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x35360
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4e9a6
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: night-shift[P]Srl/src/lib/PJson.cpp
// Function: Srl::PJson::insert_spacing(Srl::Type, Srl::Lib::Out&)
void PJson::insert_spacing(Type type, Out& out)
{
    if(!this->scope_closed && type != Type::Scope_End) {
        out.write(',');
    }
    if(this->compact) {
        return;
    }

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x61(%rax)
jne 0x4edfb
cmpb $0x10, -0x9(%rbp)
je 0x4edfb
movq -0x18(%rbp), %rdi
movb $0x2c, -0x19(%rbp)
leaq -0x19(%rbp), %rsi
callq 0x34740
movq -0x38(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x4ee07
jmp 0x4ee67
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x36180
movq %rax, -0x28(%rbp)
cmpb $0x10, -0x9(%rbp)
jne 0x4ee31
cmpq $0x0, -0x28(%rbp)
jbe 0x4ee31
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x36180
cmpq $0x0, %rax
jbe 0x4ee55
movq -0x18(%rbp), %rdi
movb $0xa, -0x29(%rbp)
leaq -0x29(%rbp), %rsi
callq 0x34740
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x9, %edx
callq 0x33670
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/PJson.cpp
// Function: (anonymous namespace)::insert_in_quotes(Srl::Lib::Out&, Srl::Lib::MemBlock const&, bool)
void insert_in_quotes(Out& out, const MemBlock& txt, bool escape = false)
    {
        out.write('\"');
        if(!escape) {
            out.write(txt);
        } else {
            write_escape(txt, out);
        }
        out.write('\"');
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movb $0x22, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x34740
testb $0x1, -0x11(%rbp)
jne 0x4eead
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35550
jmp 0x4eeba
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4fed0
movq -0x8(%rbp), %rdi
movb $0x22, -0x13(%rbp)
leaq -0x13(%rbp), %rsi
callq 0x34740
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpb $0xb, 0x60(%rax)
jne 0x4f17b
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0x1a78e(%rip), %rsi     # 0x698f3
callq 0x38ab0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x33320
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x37b75(%rip), %rdx     # 0x86d00
callq 0x384f0
movq -0x18(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0x4f1aa
movq -0x48(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x58(%rbp)
jmp 0x4f1b6
movq -0x48(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4fa50
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x35540
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x7b, %eax
jne 0x4f77e
movb $0xe, %al
movb %al, -0x51(%rbp)
jmp 0x4f79d
movsbl -0x9(%rbp), %ecx
movb $0xf, %al
movb $0x10, %dl
movb %dl, -0x53(%rbp)
cmpl $0x5b, %ecx
movb %al, -0x52(%rbp)
je 0x4f797
movb -0x53(%rbp), %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
movb %al, -0x19(%rbp)
cmpb $0x10, -0x19(%rbp)
jne 0x4f82e
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x36a30
testb $0x1, %al
jne 0x4f7c0
jmp 0x4f7e9
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x1a105(%rip), %rsi     # 0x698d8
callq 0x38950
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x33320
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x35800
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x36a30
testb $0x1, %al
jne 0x4f81b
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x37f90
movb (%rax), %al
movb %al, -0x61(%rbp)
jmp 0x4f822
movb $0xb, %al
movb %al, -0x61(%rbp)
jmp 0x4f822
movq -0x50(%rbp), %rax
movb -0x61(%rbp), %cl
movb %cl, 0x60(%rax)
jmp 0x4f849
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
leaq -0x19(%rbp), %rsi
callq 0x372f0
movq -0x50(%rbp), %rax
movb -0x19(%rbp), %cl
movb %cl, 0x60(%rax)
leaq -0x48(%rbp), %rdi
movzbl -0x19(%rbp), %esi
callq 0x33ff0
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x28(%rax)
addq $0x70, %rsp
popq %rbp
retq
// File: night-shift[P]Srl/src/lib/PJson.cpp
// Function: (anonymous namespace)::skip_comment(Srl::Lib::In&)
void skip_comment(Lib::In& source)
    {
        assert(*source.pointer() == '/');

        if(!source.try_peek(1)) {
            return;
        }

        if(*(source.pointer() + 1) == '*') {
            source.move_until(error, array<const char, 2> { { '*', '/' } });
            return;
        }

        if(*(source.pointer() + 1) == '/') {
            source.move_until(error, '\n', '\r');
            return;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34240
movzbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x4f89f
jmp 0x4f8be
leaq 0x1a0c9(%rip), %rdi     # 0x6996f
leaq 0x19fc1(%rip), %rsi     # 0x6986e
movl $0x4f, %edx
leaq 0x1a0cf(%rip), %rcx     # 0x69988
callq 0x349a0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x33830
testb $0x1, %al
jne 0x4f8d2
jmp 0x4f934
movq -0x8(%rbp), %rdi
callq 0x34240
movzbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x4f902
movq -0x8(%rbp), %rdi
movb $0x2a, -0xa(%rbp)
movb $0x2f, -0x9(%rbp)
leaq 0x37409(%rip), %rsi     # 0x86d00
leaq -0xa(%rbp), %rdx
callq 0x34910
jmp 0x4f934
movq -0x8(%rbp), %rdi
callq 0x34240
movzbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x4f934
movq -0x8(%rbp), %rdi
movb $0xa, -0xb(%rbp)
movb $0xd, -0xc(%rbp)
leaq 0x373d9(%rip), %rsi     # 0x86d00
leaq -0xb(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x37690
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34240
movq %rax, %rcx
movq -0x58(%rbp), %rax
movzbl (%rcx), %ecx
cmpb $0x0, 0x98(%rax,%rcx)
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x4fa45
movb $0x0, -0x22(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x2e, %esi
leaq -0x22(%rbp), %rdx
callq 0x38c10
movq -0x10(%rbp), %rdi
movb $0x2c, -0x49(%rbp)
movb $0x20, -0x4a(%rbp)
movb $0x7d, -0x4b(%rbp)
movb $0x5d, -0x4c(%rbp)
leaq 0x37342(%rip), %rsi     # 0x86d00
leaq -0x49(%rbp), %rdx
leaq -0x4a(%rbp), %rcx
leaq -0x4b(%rbp), %r8
leaq -0x4c(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x34360
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movb -0x22(%rbp), %cl
movb $0xa, %al
movb $0xb, %dl
movb %dl, -0x5a(%rbp)
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0x4fa03
movb -0x5a(%rbp), %al
movb %al, -0x59(%rbp)
movq -0x68(%rbp), %rdx
movq -0x58(%rbp), %rdi
movb -0x59(%rbp), %al
leaq -0x48(%rbp), %rsi
movzbl %al, %ecx
callq 0x332e0
movq -0x10(%rbp), %rdi
callq 0x34240
movzbl (%rax), %eax
cmpl $0x7d, %eax
je 0x4fa3c
movq -0x10(%rbp), %rdi
callq 0x34240
movzbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x4fa43
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x4fa45
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: night-shift[P]Srl/src/lib/PJson.cpp
// Function: (anonymous namespace)::read_unescape(Srl::Lib::In&, std::vector<unsigned char, std::allocator<unsigned char>>&)
MemBlock read_unescape(In& in, vector<uint8_t>& buffer)
    {
        auto len = in.read_substitue(error, '\"', buffer,
            '\"', ar('\"'), '\'', ar('\''), '\\', ar('\\'), '/', ar('/'), '\n', ar('n'),
            '\t', ar('t'), '\r',  ar('r'), '\b',  ar('b'), '\f', ar('f'), uc_literal, ar('u')
        );

        return { buffer.data(), len };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x22, -0x29(%rbp)
movl $0x22, %edi
movl %edi, -0x54(%rbp)
callq 0x50060
movw %ax, -0x2b(%rbp)
movb $0x27, -0x2c(%rbp)
movl $0x27, %edi
callq 0x50060
movw %ax, -0x2e(%rbp)
movb $0x5c, -0x2f(%rbp)
movl $0x5c, %edi
callq 0x50060
movw %ax, -0x31(%rbp)
movb $0x2f, -0x32(%rbp)
movl $0x2f, %edi
callq 0x50060
movw %ax, -0x34(%rbp)
movb $0xa, -0x35(%rbp)
movl $0x6e, %edi
callq 0x50060
movw %ax, -0x37(%rbp)
movb $0x9, -0x38(%rbp)
movl $0x74, %edi
callq 0x50060
movw %ax, -0x3a(%rbp)
movb $0xd, -0x3b(%rbp)
movl $0x72, %edi
callq 0x50060
movw %ax, -0x3d(%rbp)
movb $0x8, -0x3e(%rbp)
movl $0x62, %edi
callq 0x50060
movw %ax, -0x40(%rbp)
movb $0xc, -0x41(%rbp)
movl $0x66, %edi
callq 0x50060
movw %ax, -0x43(%rbp)
movl $0x75, %edi
callq 0x50060
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %edx
movq -0x50(%rbp), %rcx
movw %ax, -0x45(%rbp)
movq %rsp, %rax
leaq -0x45(%rbp), %rsi
movq %rsi, 0x88(%rax)
leaq 0x371da(%rip), %rsi     # 0x86d20
movq %rsi, 0x80(%rax)
leaq -0x43(%rbp), %rsi
movq %rsi, 0x78(%rax)
leaq -0x41(%rbp), %rsi
movq %rsi, 0x70(%rax)
leaq -0x40(%rbp), %rsi
movq %rsi, 0x68(%rax)
leaq -0x3e(%rbp), %rsi
movq %rsi, 0x60(%rax)
leaq -0x3d(%rbp), %rsi
movq %rsi, 0x58(%rax)
leaq -0x3b(%rbp), %rsi
movq %rsi, 0x50(%rax)
leaq -0x3a(%rbp), %rsi
movq %rsi, 0x48(%rax)
leaq -0x38(%rbp), %rsi
movq %rsi, 0x40(%rax)
leaq -0x37(%rbp), %rsi
movq %rsi, 0x38(%rax)
leaq -0x35(%rbp), %rsi
movq %rsi, 0x30(%rax)
leaq -0x34(%rbp), %rsi
movq %rsi, 0x28(%rax)
leaq -0x32(%rbp), %rsi
movq %rsi, 0x20(%rax)
leaq -0x31(%rbp), %rsi
movq %rsi, 0x18(%rax)
leaq -0x2f(%rbp), %rsi
movq %rsi, 0x10(%rax)
leaq -0x2e(%rbp), %rsi
movq %rsi, 0x8(%rax)
leaq -0x2c(%rbp), %rsi
movq %rsi, (%rax)
leaq 0x3712d(%rip), %rsi     # 0x86d00
leaq -0x29(%rbp), %r8
leaq -0x2b(%rbp), %r9
callq 0x377a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x36f40
movq %rax, %rsi
movq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x2a(%rax)
jne 0x4fc40
movq -0x48(%rbp), %rax
cmpb $0xf, 0x60(%rax)
jne 0x4fc78
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
callq 0x36f60
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x28(%rax)
jmp 0x4fcc9
movq -0x18(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0x4fcab
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x19c74(%rip), %rsi     # 0x69909
callq 0x36270
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x33320
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x29(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x40(%rbp), %rdi
movzbl -0x19(%rbp), %ecx
callq 0x33af0
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
leaq -0x50(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0x37460
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x38390
testb $0x1, -0x1a(%rbp)
jne 0x4fe77
movq -0x18(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xe0(%rbp)
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
movl $0x1, %ecx
callq 0x38280
movq -0x108(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
xorl %edx, %edx
callq 0x35e30
movq -0x100(%rbp), %rdx
leaq 0x19b6f(%rip), %rsi     # 0x69917
leaq -0xa0(%rbp), %rdi
callq 0x37e60
jmp 0x4fdb6
leaq 0x19b74(%rip), %rdx     # 0x69931
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x336d0
jmp 0x4fdcf
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x33960
jmp 0x4fdde
movq -0x110(%rbp), %rsi
movq -0xf8(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x33320
jmp 0x4fdf7
leaq -0x80(%rbp), %rdi
callq 0x38ce0
leaq -0xa0(%rbp), %rdi
callq 0x38ce0
leaq -0xc0(%rbp), %rdi
callq 0x38ce0
jmp 0x4fe77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x4fe69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x4fe5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x38ce0
leaq -0xa0(%rbp), %rdi
callq 0x38ce0
leaq -0xc0(%rbp), %rdi
callq 0x38ce0
jmp 0x4fe88
movq -0x18(%rbp), %rax
movb $0x1, 0x28(%rax)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34fb0
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x18(%rbp)
je 0x5392f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x35360
jmp 0x5393b
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rdi)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq 0x10(%rbp), %r10
movq %rsp, %rax
movq %r10, (%rax)
callq 0x35850
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq $0x0, 0x48(%rax)
movq 0x10(%rax), %rsi
movq -0x48(%rbp), %rdx
subq %rdx, %rsi
leaq -0x10(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movb %sil, %al
movq 0x68(%rbp), %rsi
movq 0x60(%rbp), %rsi
movq 0x58(%rbp), %rsi
movq 0x50(%rbp), %rsi
movq 0x48(%rbp), %rsi
movq 0x40(%rbp), %rsi
movq 0x38(%rbp), %rsi
movq 0x30(%rbp), %rsi
movq 0x28(%rbp), %rsi
movq 0x20(%rbp), %rsi
movq 0x18(%rbp), %rsi
movq 0x10(%rbp), %rsi
movq %rdi, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movzbl -0x31(%rbp), %eax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x541d5
movb -0x31(%rbp), %sil
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq 0x10(%rbp), %r8
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %rax
movq 0x28(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq 0x30(%rbp), %r13
movq 0x38(%rbp), %r12
movq 0x40(%rbp), %r15
movq 0x48(%rbp), %r14
movq 0x50(%rbp), %rbx
movq 0x58(%rbp), %r11
movq 0x60(%rbp), %r10
movq 0x68(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movzbl %sil, %esi
movq %rax, (%rsp)
movq -0x78(%rbp), %rax
movq %rax, 0x8(%rsp)
movq -0x70(%rbp), %rax
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x34d90
jmp 0x54208
movq -0x68(%rbp), %rdi
movl $0x2, %esi
callq 0x34fb0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rdi
callq 0x35380
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x365a0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
testb $0x1, 0x80(%rax)
jne 0x54380
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34730
movq %rax, -0x8(%rbp)
jmp 0x543e2
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x54397
movq -0x20(%rbp), %rdi
callq 0x344a0
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x543b2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37570
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x58(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq 0x70(%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/include/Srl/In.hpp
// Function: unsigned long Srl::Lib::In::move_until<false, std::array<char const, 2ul>>(std::function<void ()> const&, std::array<char const, 2ul> 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x54abc
movq -0x10(%rbp), %rdi
callq 0x35bb0
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x342a0
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x54af8
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x384f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x54ac3
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rdi)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x384f0
movq -0x30(%rbp), %rax
movq $0x0, 0x48(%rax)
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
subq %rdx, %rsi
leaq -0x10(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: Srl::PMsgPack::write(Srl::Value const&, Srl::Lib::MemBlock const&, Srl::Lib::Out&)
void PMsgPack::write(const Value& value, const MemBlock& name, Out& out)
{
    auto type = value.type();

    if(type == Type::Scope_End) {
        assert(this->scope_stack.size() > 0);

        uint32_t scope_elems = this->scope->elements;
        auto scope_elems_be = swap_bytes(scope_elems);

        out.write(this->scope->ticket, (const uint8_t*)&scope_elems_be, 0, 4);
        this->scope_stack.pop();
        this->scope = this->scope_stack.size() > 0 ? &this->scope_stack.top() : nullptr;

        return;
    }

    if(this->scope) {
        if(this->scope->type == Type::Object) {
            write_str(name, out);
        }
        this->scope_stack.top().elements++;
    }


    if(TpTools::is_scope(type)) {
        this->write_scope(type, out);
        return;
    }

    srl_to_msgp(value, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35b80
movb %al, -0x21(%rbp)
cmpb $0x10, -0x21(%rbp)
jne 0x57bc1
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x33890
cmpq $0x0, %rax
jbe 0x57b1b
jmp 0x57b3a
leaq 0x11fa3(%rip), %rdi     # 0x69ac5
leaq 0x11fb9(%rip), %rsi     # 0x69ae2
movl $0x178, %edx            # imm = 0x178
leaq 0x11fc2(%rip), %rcx     # 0x69af7
callq 0x349a0
movq -0x38(%rbp), %rax
movq 0x70(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x57c40
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq 0x70(%rax), %rsi
addq $0x8, %rsi
leaq -0x2c(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x4, %r8d
callq 0x37990
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x382b0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x33890
cmpq $0x0, %rax
jbe 0x57bab
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x343f0
movq %rax, -0x40(%rbp)
jmp 0x57bb3
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x57bb3
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x70(%rax)
jmp 0x57c2d
movq -0x38(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x57bfc
movq -0x38(%rbp), %rax
movq 0x70(%rax), %rax
cmpb $0xe, (%rax)
jne 0x57be6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x57ca0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x343f0
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movzbl -0x21(%rbp), %edi
callq 0x35db0
testb $0x1, %al
jne 0x57c0b
jmp 0x57c20
movq -0x38(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x37f00
jmp 0x57c2d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x57e30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: unsigned int (anonymous namespace)::swap_bytes<unsigned int>(unsigned int)
C swap_bytes(C in)
    {
        auto N = sizeof(C);

        C out;
        auto* mem_in = (uint8_t*)&in;
        auto* mem_out = (uint8_t*)&out;

        for(auto i = 0U; i < N; i++) {
            mem_out[i] = mem_in[N - i - 1];
        }

        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x4, -0x10(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpq -0x10(%rbp), %rax
jae 0x57c99
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %edx
subq %rdx, %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x57c66
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1f, 0x8(%rax)
ja 0x57cda
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
orq $0xa0, %rax
movzbl %al, %esi
callq 0x366f0
jmp 0x57d6d
movq -0x8(%rbp), %rax
cmpq $0xfe, 0x8(%rax)
ja 0x57d0c
movq -0x10(%rbp), %rdi
movl $0xd9, %esi
callq 0x366f0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl %al, %esi
callq 0x366f0
jmp 0x57d6b
movq -0x8(%rbp), %rax
cmpq $0xfffe, 0x8(%rax)      # imm = 0xFFFE
ja 0x57d43
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movl $0xda, %esi
callq 0x366f0
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x34610
jmp 0x57d69
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdb, %esi
callq 0x366f0
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x332f0
jmp 0x57d6b
jmp 0x57d6d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x364e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb -0x9(%rbp), %dl
movl $0xdd, %eax
movl $0xdf, %ecx
cmpb $0xe, %dl
cmovel %ecx, %eax
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x35af0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x4, %edx
callq 0x38120
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movl $0x0, -0x44(%rbp)
leaq -0x9(%rbp), %rsi
leaq -0x44(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x34b00
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x343f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x70(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::srl_to_msgp(Srl::Value const&, Srl::Lib::Out&)
void srl_to_msgp(const Value& val, Out& out)
    {
        switch(val.type()) {

            SRL_TYPES_SCALAR(SRL_TYPE_TO_MSGP)

            case Type::Binary :
                write_bin(MemBlock(val.data(), val.size()), out);
                break;
            case Type::String :
                write_str(MemBlock(val.data(), val.size()), out);
                break;

            default : assert(0);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x35b80
movzbl %al, %ecx
movq %rcx, -0x38(%rbp)
subb $0xd, %al
ja 0x57fae
movq -0x38(%rbp), %rax
leaq 0x11bcd(%rip), %rcx     # 0x69a30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58890
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x588e0
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58970
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x589f0
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58a80
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58b00
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58b90
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58c10
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58ca0
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58d20
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58d80
jmp 0x57fcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58de0
jmp 0x57fcd
movq -0x8(%rbp), %rdi
callq 0x36770
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34510
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x58e10
jmp 0x57fcd
movq -0x8(%rbp), %rdi
callq 0x36770
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34510
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x57ca0
jmp 0x57fcd
leaq 0x11b2b(%rip), %rdi     # 0x69ae0
leaq 0x11b26(%rip), %rsi     # 0x69ae2
movl $0xc2, %edx
leaq 0x11bf6(%rip), %rcx     # 0x69bbe
callq 0x349a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::read_name(unsigned char, std::vector<unsigned char, std::allocator<unsigned char>>&, Srl::Lib::In&)
MemBlock read_name(uint8_t prefix, vector<uint8_t>& buffer, In& in)
    {
        auto val = read_str(prefix, in);
        MemBlock block(val.data(), val.size());

        if(in.is_streaming()) {
            if(buffer.size() < block.size) { buffer.resize(block.size); }

            memcpy(buffer.data(), block.ptr, block.size);
            block = { buffer.data(), block.size };
        }

        return block;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x11(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movb -0x11(%rbp), %al
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movzbl %al, %esi
callq 0x585e0
leaq -0x40(%rbp), %rdi
callq 0x36770
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34510
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x33280
movq -0x28(%rbp), %rdi
callq 0x35130
testb $0x1, %al
jne 0x583ee
jmp 0x5844c
movq -0x20(%rbp), %rdi
callq 0x37840
cmpq -0x8(%rbp), %rax
jae 0x5840a
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x35f00
movq -0x20(%rbp), %rdi
callq 0x36f40
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x35360
movq -0x20(%rbp), %rdi
callq 0x36f40
movq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x33280
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::get_scope_info(unsigned char, Srl::Lib::In&)
pair<Type, size_t> get_scope_info(uint8_t prefix, In& in)
    {
        assert(prefix_is_scope(prefix));

        Type type; size_t size;

        /* big container bit at pos 7 set */
        if(prefix & (1 << 6)) {
            type = prefix & 2 ? Type::Object : Type::Array;

            if(prefix & 1) {
                uint32_t size_be = in.read_move<uint32_t>(error);
                size = swap_bytes(size_be);

            } else {
                uint16_t size_be = in.read_move<uint16_t>(error);
                size = swap_bytes(size_be);
            }


        } else {
            type = prefix & (1 << 4) ? Type::Array : Type::Object;
            size = 0xFF >> 4 & prefix;
        }

        return { type, size };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x11(%rbp)
movq %rsi, -0x20(%rbp)
movzbl -0x11(%rbp), %edi
callq 0x58460
testb $0x1, %al
jne 0x584e1
jmp 0x584e3
jmp 0x58502
leaq 0x11712(%rip), %rdi     # 0x69bfc
leaq 0x115f1(%rip), %rsi     # 0x69ae2
movl $0x149, %edx            # imm = 0x149
leaq 0x11717(%rip), %rcx     # 0x69c14
callq 0x349a0
movzbl -0x11(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x58585
movzbl -0x11(%rbp), %ecx
andl $0x2, %ecx
movb $0xe, %al
movb $0xf, %dl
movb %dl, -0x38(%rbp)
cmpl $0x0, %ecx
movb %al, -0x37(%rbp)
jne 0x5852a
movb -0x38(%rbp), %al
movb %al, -0x37(%rbp)
movb -0x37(%rbp), %al
movb %al, -0x21(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5855f
movq -0x20(%rbp), %rdi
leaq 0x2ea99(%rip), %rsi     # 0x86fe0
callq 0x33ba0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x57c40
movl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x58583
movq -0x20(%rbp), %rdi
leaq 0x2ea76(%rip), %rsi     # 0x86fe0
callq 0x333d0
movw %ax, -0x36(%rbp)
movzwl -0x36(%rbp), %edi
callq 0x590b0
movzwl %ax, %eax
movq %rax, -0x30(%rbp)
jmp 0x585b4
movzbl -0x11(%rbp), %ecx
andl $0x10, %ecx
movb $0xf, %al
movb $0xe, %dl
movb %dl, -0x3a(%rbp)
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jne 0x585a1
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x21(%rbp)
movzbl -0x11(%rbp), %eax
andl $0xf, %eax
cltq
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x35ba0
movb -0x10(%rbp), %al
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::prefix_is_scalar(unsigned char)
bool prefix_is_scalar(uint8_t prefix)
    {
        return (prefix >= 0xCA && prefix <= 0xD3) || // integers / floats
                prefix <= 0x7F || prefix >= 0xE0  || // pos fixnum / neg fixnum
                prefix == 0xC2 || prefix <= 0xC3  || // true / false
                prefix == 0xC0;                      // null
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0xca, %eax
jl 0x58676
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xd3, %ecx
movb %al, -0x2(%rbp)
jle 0x586c6
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7f, %ecx
movb %al, -0x2(%rbp)
jle 0x586c6
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xe0, %ecx
movb %al, -0x2(%rbp)
jge 0x586c6
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xc2, %ecx
movb %al, -0x2(%rbp)
je 0x586c6
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xc3, %ecx
movb %al, -0x2(%rbp)
jle 0x586c6
movzbl -0x1(%rbp), %eax
cmpl $0xc0, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: (anonymous namespace)::read_scalar(unsigned char, Srl::Lib::In&)
Value read_scalar(uint8_t prefix, In& in)
    {
        assert(prefix_is_scalar(prefix));

        return prefix == 0xC2 || prefix == 0xC3 ? read_bool(prefix)
             : prefix >= 0xCA && prefix <= 0xD3 ? read_num(prefix, in)
             : prefix == 0xC0 ? Value(MemBlock(), Type::Null)
             : read_fixnum(prefix);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %sil, %al
movq %rdi, -0x28(%rbp)
movb %al, -0x1(%rbp)
movq %rdx, -0x10(%rbp)
movzbl -0x1(%rbp), %edi
callq 0x58650
testb $0x1, %al
jne 0x586f9
jmp 0x586fb
jmp 0x5871a
leaq 0x115aa(%rip), %rdi     # 0x69cac
leaq 0x113d9(%rip), %rsi     # 0x69ae2
movl $0x111, %edx            # imm = 0x111
leaq 0x115b0(%rip), %rcx     # 0x69cc5
callq 0x349a0
movzbl -0x1(%rbp), %eax
cmpl $0xc2, %eax
je 0x58730
movzbl -0x1(%rbp), %eax
cmpl $0xc3, %eax
jne 0x5873f
movq -0x30(%rbp), %rdi
movzbl -0x1(%rbp), %esi
callq 0x59400
jmp 0x587a3
movzbl -0x1(%rbp), %eax
cmpl $0xca, %eax
jl 0x5876a
movzbl -0x1(%rbp), %eax
cmpl $0xd3, %eax
jg 0x5876a
movq -0x30(%rbp), %rdi
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rdx
movzbl %al, %esi
callq 0x59440
jmp 0x587a1
movzbl -0x1(%rbp), %eax
cmpl $0xc0, %eax
jne 0x58792
leaq -0x20(%rbp), %rdi
callq 0x374c0
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xb, %edx
callq 0x36df0
jmp 0x5879f
movq -0x30(%rbp), %rdi
movzbl -0x1(%rbp), %esi
callq 0x59550
jmp 0x587a1
jmp 0x587a3
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/PMsgPack.cpp
// Function: std::enable_if<Srl::TpTools::is_num(Srl::Type)((Srl::Type)1) && !Srl::TpTools::is_fp(Srl::Type)((Srl::Type)1), void>::type (anonymous namespace)::write_scalar<(Srl::Type)1>(Srl::Value const&, Srl::Lib::Out&)
typename enable_if<TpTools::is_num(TP) && !TpTools::is_fp(TP), void>::type
    write_scalar (const Value& val, Out& out)
    {
        typedef typename TpTools::Real<TP>::type IntType;

        uint8_t lk[] {
            0xD0 /* Type::I8 */,
            0xCC /* Type::UI8 */,
            0xD1 /* Type::I16 */,
            0xCD /* Type::UI16 */,
            0xD2 /* Type::I32 */,
            0xCE /* Type::UI32 */,
            0xD3 /* Type::I64 */,
            0xCF /* Type::UI64 */
        };

        uint8_t prefix = lk[(uint8_t)TP - 1];

        if(TpTools::is_signed(TP)) {

            IntType i = val.pblock().i64;
            if((i >= 0 && write_pfixnum(i, out)) || write_nfixnum(i, out)) {
                return;
            }

            auto swapped = swap_bytes(i);
            out.write(prefix);
            out.write(swapped);

        } else {

            IntType u = val.pblock().ui64;
            if(write_pfixnum(u, out)) {
                return;
            }

            auto swapped = swap_bytes(u);
            out.write(prefix);
            out.write(swapped);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x11488(%rip), %rax     # 0x69d7f
movq %rax, -0x18(%rbp)
movb -0x18(%rbp), %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34bd0
movq (%rax), %rax
movb %al, -0x1a(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jl 0x5892b
movsbq -0x1a(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58ed0
testb $0x1, %al
jne 0x5893f
movsbq -0x1a(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58f10
testb $0x1, %al
jne 0x5893f
jmp 0x58941
jmp 0x58967
movsbl -0x1a(%rbp), %edi
callq 0x58f60
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x35af0
movq -0x10(%rbp), %rdi
leaq -0x1b(%rbp), %rsi
callq 0x33370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)