LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lega911[P]ijson/src/connect.cpp
// Function: Connect::write_mode(bool)
void Connect::write_mode(bool active) {
    if(active) {
        if(_socket_status & 2) return;
        _socket_status |= 2;
    } else {
        if(!(_socket_status & 2)) return;
        _socket_status = _socket_status & 0xfd;
    }
    loop->_queue_to_send.push_back(this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x19a4f
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x19a42
jmp 0x19a86
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x19a6d
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x19a5f
jmp 0x19a86
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xfd, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x60, %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1e6a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: Connect::read_mode(bool)
void Connect::read_mode(bool active) {
    if(active) {
        if(_socket_status & 1) return;
        _socket_status |= 1;
    } else {
        if(!(_socket_status & 1)) return;
        _socket_status = _socket_status & 0xfe;
    }
    loop->set_poll_mode(fd, _socket_status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x19acf
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x19ac2
jmp 0x19aff
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x19aed
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x19adf
jmp 0x19aff
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xfe, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movl 0xc(%rax), %esi
movl (%rax), %edx
callq 0x292d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: HttpSender::status(char const*)
HttpSender *HttpSender::status(const char *status) {
    conn->send_buffer.resize(256);
    conn->send_buffer.add("HTTP/1.1 ");
    conn->send_buffer.add(status);
    conn->send_buffer.add("\r\n");
    if(conn->keep_alive) {
        conn->send_buffer.add("Connection: keep-alive\r\n");
    }
    return this;
}

// 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)
movq (%rax), %rdi
addq $0x20, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x1fb40
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1d02f(%rip), %rsi     # 0x3873a
callq 0x1f2c0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x1f2c0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1cfe0(%rip), %rsi     # 0x38716
callq 0x1f2c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x10(%rax)
je 0x1b75f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1cfea(%rip), %rsi     # 0x38744
callq 0x1f2c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: HttpSender::done(int)
void HttpSender::done(int error) {
    if(!conn->server->jsonrpc2) done();
    else {
        Slice msg;
        if(error == -32700) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32700, \"message\": \"Parse error\"}, \"id\": null}");
        else if(error == -32600) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32600, \"message\": \"Invalid Request\"}, \"id\": null}");
        else if(error == -32601) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32601, \"message\": \"Method not found\"}, \"id\": null}");
        else if(error == -32602) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32602, \"message\": \"Invalid params\"}, \"id\": null}");
        else if(error == -1) msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32001, \"message\": \"Error, see http code\"}, \"id\": null}");
        else if(error == 1) msg.set("{\"jsonrpc\": \"2.0\", \"result\": true, \"id\": null}");
        else msg.set("{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32603, \"message\": \"Internal error\"}, \"id\": null}");
        done(msg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x2c(%rax)
jne 0x1b7a2
movq -0x28(%rbp), %rdi
callq 0x1bf70
jmp 0x1b871
leaq -0x20(%rbp), %rdi
callq 0x1e9d0
cmpl $0xffff8044, -0xc(%rbp) # imm = 0xFFFF8044
jne 0x1b7c9
leaq -0x20(%rbp), %rdi
leaq 0x1cff6(%rip), %rsi     # 0x387b5
callq 0x1fce0
jmp 0x1b864
cmpl $0xffff80a8, -0xc(%rbp) # imm = 0xFFFF80A8
jne 0x1b7e4
leaq -0x20(%rbp), %rdi
leaq 0x1d02c(%rip), %rsi     # 0x38809
callq 0x1fce0
jmp 0x1b862
cmpl $0xffff80a7, -0xc(%rbp) # imm = 0xFFFF80A7
jne 0x1b7ff
leaq -0x20(%rbp), %rdi
leaq 0x1d069(%rip), %rsi     # 0x38861
callq 0x1fce0
jmp 0x1b860
cmpl $0xffff80a6, -0xc(%rbp) # imm = 0xFFFF80A6
jne 0x1b81a
leaq -0x20(%rbp), %rdi
leaq 0x1d0a7(%rip), %rsi     # 0x388ba
callq 0x1fce0
jmp 0x1b85e
cmpl $-0x1, -0xc(%rbp)
jne 0x1b832
leaq -0x20(%rbp), %rdi
leaq 0x1d0e6(%rip), %rsi     # 0x38911
callq 0x1fce0
jmp 0x1b85c
cmpl $0x1, -0xc(%rbp)
jne 0x1b84a
leaq -0x20(%rbp), %rdi
leaq 0x1d12b(%rip), %rsi     # 0x3896e
callq 0x1fce0
jmp 0x1b85a
leaq -0x20(%rbp), %rdi
leaq 0x1d148(%rip), %rsi     # 0x3899d
callq 0x1fce0
jmp 0x1b85c
jmp 0x1b85e
jmp 0x1b860
jmp 0x1b862
jmp 0x1b864
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1be40
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: Connect::read_method(Slice&)
int Connect::read_method(Slice &line) {
    int start = 0;
    char *buf = line.ptr();
    int part = 0;
    int i = 0;
    path.clear();
    for(;i<line.size();i++) {
        if(buf[i] != ' ') continue;

        if(part == 1) {
            if(i>start+1 && buf[start] == '/') start++;
            path.set(&buf[start], i - start);
            break;
        }
        start = i + 1;
        part++;
    }
    if(buf[line.size() - 1] == '1') http_version = 11;
    else http_version = 10;

    if(path.empty()) return -1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e6f0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
addq $0x98, %rdi
callq 0x1eab0
movl -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e6d0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1b969
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1b8f9
jmp 0x1b95b
cmpl $0x1, -0x2c(%rbp)
jne 0x1b949
movl -0x30(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1b926
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x1b926
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
movq -0x28(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movl -0x30(%rbp), %edx
subl -0x1c(%rbp), %edx
callq 0x1edf0
jmp 0x1b969
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1b8ca
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e6d0
movl %eax, %ecx
movq -0x48(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x1b99f
movq -0x38(%rbp), %rax
movl $0xb, 0x80(%rax)
jmp 0x1b9ad
movq -0x38(%rbp), %rax
movl $0xa, 0x80(%rax)
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x1eb40
testb $0x1, %al
jne 0x1b9c3
jmp 0x1b9cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b9d3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: Connect::_set_type(ISlice&)
void Connect::_set_type(ISlice &name) {
    if(name == "get") {
        type = RequestType::get;
    } else if (name == "get+") {
        type = RequestType::get_plus;
    } else if (name == "worker") {
        type = RequestType::worker;
    } else if (name == "async") {
        type = RequestType::async;
    } else if (name == "pub") {
        type = RequestType::pub;
    } else if (name == "result") {
        type = RequestType::result;
    } else if (name == "create") {
        type = RequestType::create;
    } else if (name == "delete") {
        type = RequestType::del;
    } else throw error::InvalidData();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1c501(%rip), %rsi     # 0x381a4
callq 0x1ee30
testb $0x1, %al
jne 0x1bcae
jmp 0x1bcc1
movq -0x28(%rbp), %rax
movl $0x1, 0xc8(%rax)
jmp 0x1be31
movq -0x10(%rbp), %rdi
leaq 0x1c4dc(%rip), %rsi     # 0x381a8
callq 0x1ee30
testb $0x1, %al
jne 0x1bcd7
jmp 0x1bcea
movq -0x28(%rbp), %rax
movl $0x2, 0xc8(%rax)
jmp 0x1be2f
movq -0x10(%rbp), %rdi
leaq 0x1da05(%rip), %rsi     # 0x396fa
callq 0x1ee30
testb $0x1, %al
jne 0x1bd00
jmp 0x1bd13
movq -0x28(%rbp), %rax
movl $0x3, 0xc8(%rax)
jmp 0x1be2d
movq -0x10(%rbp), %rdi
leaq 0x1c48f(%rip), %rsi     # 0x381ad
callq 0x1ee30
testb $0x1, %al
jne 0x1bd29
jmp 0x1bd3c
movq -0x28(%rbp), %rax
movl $0x4, 0xc8(%rax)
jmp 0x1be2b
movq -0x10(%rbp), %rdi
leaq 0x1c46c(%rip), %rsi     # 0x381b3
callq 0x1ee30
testb $0x1, %al
jne 0x1bd52
jmp 0x1bd65
movq -0x28(%rbp), %rax
movl $0x5, 0xc8(%rax)
jmp 0x1be29
movq -0x10(%rbp), %rdi
leaq 0x1c4f6(%rip), %rsi     # 0x38266
callq 0x1ee30
testb $0x1, %al
jne 0x1bd7b
jmp 0x1bd8e
movq -0x28(%rbp), %rax
movl $0x6, 0xc8(%rax)
jmp 0x1be27
movq -0x10(%rbp), %rdi
leaq 0x1c41e(%rip), %rsi     # 0x381b7
callq 0x1ee30
testb $0x1, %al
jne 0x1bda4
jmp 0x1bdb4
movq -0x28(%rbp), %rax
movl $0x7, 0xc8(%rax)
jmp 0x1be25
movq -0x10(%rbp), %rdi
leaq 0x1c3ff(%rip), %rsi     # 0x381be
callq 0x1ee30
testb $0x1, %al
jne 0x1bdca
jmp 0x1bdda
movq -0x28(%rbp), %rax
movl $0x8, 0xc8(%rax)
jmp 0x1be23
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x1ee60
jmp 0x1bdf5
movq -0x30(%rbp), %rdi
leaq 0x2ae58(%rip), %rsi     # 0x46c58
leaq 0x2ef9(%rip), %rdx      # 0x1ed00
callq 0x19480
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19210
jmp 0x1be37
jmp 0x1be25
jmp 0x1be27
jmp 0x1be29
jmp 0x1be2b
jmp 0x1be2d
jmp 0x1be2f
jmp 0x1be31
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x194a0
// File: lega911[P]ijson/src/connect.cpp
// Function: HttpSender::done(ISlice&)
void HttpSender::done(ISlice &body) {
    if(conn->is_closed()) THROW("Trying to send to closed socket");

    int body_size = body.size();
    if(body_size == 0) {
        conn->send_buffer.add("Content-Length: 0\r\n\r\n");
    } else {
        conn->send_buffer.add("Content-Length: ");
        conn->send_buffer.add_number(body_size);
        conn->send_buffer.add("\r\n\r\n");
        conn->send_buffer.add(body);
    }
    conn->write_mode(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x1fcc0
testb $0x1, %al
jne 0x1be66
jmp 0x1becc
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1c8dc(%rip), %rsi     # 0x3875d
leaq 0x1c1c1(%rip), %rdx     # 0x38049
leaq 0x1c8ee(%rip), %r8      # 0x3877d
movl $0x2eb, %ecx            # imm = 0x2EB
callq 0x22ba0
jmp 0x1be9b
movq -0x30(%rbp), %rdi
leaq 0x2ae5a(%rip), %rsi     # 0x46d00
leaq 0x7263(%rip), %rdx      # 0x23110
callq 0x19480
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19210
jmp 0x1bf64
movq -0x10(%rbp), %rdi
callq 0x1e6d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x1bef7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1c813(%rip), %rsi     # 0x38703
callq 0x1f2c0
jmp 0x1bf4d
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1c810(%rip), %rsi     # 0x38719
callq 0x1f2c0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
movslq -0x20(%rbp), %rsi
callq 0x1f1d0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1c7e0(%rip), %rsi     # 0x38714
callq 0x1f2c0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x1ea60
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x19a10
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x194a0
nopl (%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: Connect::create_queue(Slice)
void Connect::create_queue(Slice name) {
    if(name.empty()) {
        this->send.status("400 Wrong queue")->done(-32600);
        return;
    }
    if(name.ptr()[0] == '/') name.remove(1);
    server->get_queue(name, true);
    this->send.status("200 OK")->done(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1eb40
testb $0x1, %al
jne 0x1c90a
jmp 0x1c92d
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1be11(%rip), %rsi     # 0x3872a
callq 0x1b6d0
movq %rax, %rdi
movl $0xffff80a8, %esi       # imm = 0xFFFF80A8
callq 0x1b770
jmp 0x1c996
leaq -0x10(%rbp), %rdi
callq 0x1e6f0
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1c94c
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1ef50
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
movl $0x1, %ecx
callq 0x281f0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1b8ad(%rip), %rsi     # 0x38231
callq 0x1b6d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b770
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: Connect::delete_queue(Slice)
void Connect::delete_queue(Slice name) {
    if(name.empty()) {
        this->send.status("400 Wrong queue")->done(-32600);
        return;
    }
    if(name.ptr()[0] == '/') name.remove(1);
    server->delete_queue(name);
    this->send.status("200 OK")->done(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1eb40
testb $0x1, %al
jne 0x1c9ca
jmp 0x1c9ed
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1bd51(%rip), %rsi     # 0x3872a
callq 0x1b6d0
movq %rax, %rdi
movl $0xffff80a8, %esi       # imm = 0xFFFF80A8
callq 0x1b770
jmp 0x1ca51
leaq -0x10(%rbp), %rdi
callq 0x1e6f0
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1ca0c
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1ef50
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x284d0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1b7f2(%rip), %rsi     # 0x38231
callq 0x1b6d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b770
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/connect.cpp
// Function: HttpSender::header(char const*, ISlice const&)
HttpSender *HttpSender::header(const char *key, const ISlice &value) {
    conn->send_buffer.add(key);
    conn->send_buffer.add(": ");
    conn->send_buffer.add(value);
    conn->send_buffer.add("\r\n");
    return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x1f2c0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1bdc9(%rip), %rsi     # 0x39467
callq 0x1f2c0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x1ea60
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
leaq 0x1b04d(%rip), %rsi     # 0x38716
callq 0x1f2c0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::remove_left(int)
void remove_left(int n) {
        if(n <= 0) return;
        if(_size <= n) {
            _size = 0;
        } else {
            _size -= n;
            memmove(_ptr, &_ptr[n], _size);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x1e72f
jmp 0x1e76d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0x1e748
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x1e76d
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq (%rax), %rdi
movq (%rax), %rsi
movslq -0xc(%rbp), %rcx
addq %rcx, %rsi
movslq 0x8(%rax), %rdx
callq 0x19440
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::add(char const*, int)
void add(const char *buf, int size) {
        if(buf == NULL) throw error::NoData("Buffer.add buf == NULL");
        resize(_size + size);
        memmove(&_ptr[_size], buf, size);
        _size += size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e92a
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1a107(%rip), %rsi     # 0x389f4
xorl %ecx, %ecx
movl %ecx, %r8d
movq %r8, %rdx
callq 0x20000
jmp 0x1e8fc
movq -0x38(%rbp), %rdi
leaq 0x28369(%rip), %rsi     # 0x46c70
leaq 0x1742(%rip), %rdx      # 0x20050
callq 0x19480
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x19210
jmp 0x1e967
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %esi
addl -0x14(%rbp), %esi
callq 0x1fb40
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movslq 0x8(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x19440
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x194a0
// File: lega911[P]ijson/src/buffer.h
// Function: Slice::pop(int)
Slice pop(int len) {
        Slice r = get(len);
        _ptr += len;
        _size -= len;
        return r;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x1c(%rbp), %esi
callq 0x20100
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl %edx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x8(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movslq -0x1c(%rbp), %rdx
movq (%rax), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %edx
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x40, %rsp
popq %rbp
retq
// File: lega911[P]ijson/src/buffer.h
// Function: Slice::pop_line()
Slice pop_line() {
        for(int i=0;i<size();i++) {
            if(_ptr[i] != '\n') continue;
            return pop(i + 1);
        }
        return Slice(NULL, 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x1e6d0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1ebe9
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x1ebb9
jmp 0x1ebde
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
incl %esi
callq 0x1ead0
movl %edx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x1ebf8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1eb8b
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1ea20
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: lega911[P]ijson/src/buffer.h
// Function: Slice::rstrip()
void rstrip() {
        int i=_size-1;
        for(;i>=0;i--) {
            if(_ptr[i] == ' ' || _ptr[i] == '\n' || _ptr[i] == '\r') continue;
            break;
        }
        _size = i + 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x1ec9a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1ec8b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x1ec8b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x1ec8d
jmp 0x1ec8f
jmp 0x1ec9a
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ec49
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: lega911[P]ijson/src/json.h
// Function: Json::reset()
void reset() {
        _status = 0;
        key.reset();
        value.reset();
        index = 0;
        _data.reset();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x24(%rdi)
callq 0x1ed70
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1ed70
movq -0x10(%rbp), %rdi
movl $0x0, 0x38(%rdi)
addq $0x28, %rdi
callq 0x1ed70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: ISlice::starts_with_lc(char const*)
bool starts_with_lc(const char *s) {
        // lower case
        int i = 0;
        while(*s) {
            if(i >= _size) return false;
            char a = _ptr[i];
            if(a >= 'A' && a <= 'Z') a += 'a' - 'A';
            if(*s != a) return false;
            i++;
            s++;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1ef3f
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jl 0x1eee6
movb $0x0, -0x1(%rbp)
jmp 0x1ef43
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x41, %eax
jl 0x1ef13
movsbl -0x1d(%rbp), %eax
cmpl $0x5a, %eax
jg 0x1ef13
movsbl -0x1d(%rbp), %eax
addl $0x20, %eax
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
je 0x1ef28
movb $0x0, -0x1(%rbp)
jmp 0x1ef43
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1eecb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: ISlice::atoi() const
i64 atoi() const {
        if(!size()) throw error::NoData();
        char *p = ptr();
        char *end = p + size();
        bool negative = false;
        if(*p == '-') {
            negative = true;
            if(size() < 2) throw error::InvalidData();
            p++;
        }
        i64 value = 0;
        for(;p < end; p++) {
            char a = *p - '0';
            if(a < 0 || a > 9) throw error::InvalidData();
            value = value * 10 + a;
        }
        return negative?-value:value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1e6d0
cmpl $0x0, %eax
jne 0x1f01a
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x202a0
jmp 0x1efe9
movq -0x50(%rbp), %rdi
leaq 0x27c7c(%rip), %rsi     # 0x46c70
leaq 0x1055(%rip), %rdx      # 0x20050
callq 0x19480
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x19210
jmp 0x1f186
movq -0x48(%rbp), %rdi
callq 0x1e6f0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1e6d0
movl %eax, %ecx
movq -0x58(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1f0c2
movq -0x48(%rbp), %rdi
movb $0x1, -0x29(%rbp)
callq 0x1e6d0
cmpl $0x2, %eax
jge 0x1f0b6
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x1ee60
jmp 0x1f085
movq -0x60(%rbp), %rdi
leaq 0x27bc8(%rip), %rsi     # 0x46c58
leaq -0x397(%rip), %rdx      # 0x1ed00
callq 0x19480
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x19210
jmp 0x1f186
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1f162
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x0, %eax
jl 0x1f0f7
movsbl -0x39(%rbp), %eax
cmpl $0x9, %eax
jle 0x1f140
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x1ee60
jmp 0x1f112
movq -0x68(%rbp), %rdi
leaq 0x27b3b(%rip), %rsi     # 0x46c58
leaq -0x424(%rip), %rdx      # 0x1ed00
callq 0x19480
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x19210
jmp 0x1f186
imulq $0xa, -0x38(%rbp), %rax
movsbq -0x39(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f0ca
testb $0x1, -0x29(%rbp)
je 0x1f174
xorl %eax, %eax
subq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x1f17c
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x194a0
nop
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::add_number(long)
void add_number(i64 n) {
        resize(_size + 20);

        char s[20];
        int d;
        int i=19;
        bool negative = false;
        if(n == 0) s[i--] = '0';
        else if(n < 0) {
            n = -n;
            negative = true;
        }
        while(n) {
            d = n % 10;
            s[i--] = d + '0';
            n = n / 10;
        }
        if(negative) s[i--] = '-';
        add(&s[i + 1], 19 - i);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl 0x8(%rdi), %esi
addl $0x14, %esi
callq 0x1fb40
movl $0x13, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f219
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cltq
movb $0x30, -0x30(%rbp,%rax)
jmp 0x1f230
cmpq $0x0, -0x10(%rbp)
jge 0x1f22e
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x1, -0x39(%rbp)
jmp 0x1f230
jmp 0x1f232
cmpq $0x0, -0x10(%rbp)
je 0x1f279
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movl -0x38(%rbp), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, -0x38(%rbp)
cltq
movb %cl, -0x30(%rbp,%rax)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
jmp 0x1f232
testb $0x1, -0x39(%rbp)
je 0x1f291
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cltq
movb $0x2d, -0x30(%rbp,%rax)
movq -0x48(%rbp), %rdi
movl -0x38(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x30(%rbp), %rsi
addq %rax, %rsi
movl $0x13, %edx
subl -0x38(%rbp), %edx
callq 0x1e8b0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::add(char const*)
void add(const char *i) {
        while(*i != 0) {
            if(_size >= _cap) resize(_size + 1);
            _ptr[_size++] = *i;
            i++;
        }
    }

// 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)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1f32b
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
cmpl 0xc(%rcx), %eax
jl 0x1f2ff
movq -0x18(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x1fb40
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq (%rsi), %rax
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1f2d8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: ISlice::as_string[abi:cxx11](int) const
std::string as_string(int _default=-1) const {
        std::string s;
        if(valid()) {
            s.append(ptr(), size());
        } else {
            if(_default == 1) s.append("<empty>");
            else if(_default != 0) throw error::NoData();
        }
        return s;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x193c0
movq -0x30(%rbp), %rdi
callq 0x1ec10
testb $0x1, %al
jne 0x1f37e
jmp 0x1f3bc
movq -0x30(%rbp), %rdi
callq 0x1e6f0
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1e6d0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movslq %eax, %rdx
callq 0x19070
jmp 0x1f3a6
jmp 0x1f42b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1f448
cmpl $0x1, -0x14(%rbp)
jne 0x1f3d6
movq -0x40(%rbp), %rdi
leaq 0x1967f(%rip), %rsi     # 0x38a4c
callq 0x194e0
jmp 0x1f3d4
jmp 0x1f429
cmpl $0x0, -0x14(%rbp)
je 0x1f427
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x202a0
jmp 0x1f3f7
movq -0x50(%rbp), %rdi
leaq 0x2786e(%rip), %rsi     # 0x46c70
leaq 0xc47(%rip), %rdx       # 0x20050
callq 0x19480
jmp 0x1f45a
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x19210
jmp 0x1f448
jmp 0x1f429
jmp 0x1f42b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1f43e
movq -0x40(%rbp), %rdi
callq 0x191e0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x191e0
movq -0x20(%rbp), %rdi
callq 0x194a0
nopw (%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::resize(int)
void resize(int capacity) {
        if(_ptr == NULL) {
            _cap = _get_cap(capacity);
            _ptr = (char*)_malloc(_cap);
            if(_ptr == NULL) THROW("No memory");
        } else if(capacity > _cap) {
            _cap = _get_cap(capacity);
            char *p = (char*)_realloc(_ptr, _cap);
            if(!p) THROW("Realloc error");
            _ptr = p;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0x1fbf9
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x20560
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %edi
callq 0x271e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x1fbf4
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x18eb2(%rip), %rsi     # 0x38a5b
leaq 0x18e71(%rip), %rdx     # 0x38a21
leaq 0x18eae(%rip), %r8      # 0x38a65
movl $0xe8, %ecx
callq 0x22ba0
jmp 0x1fbc3
movq -0x38(%rbp), %rdi
leaq 0x27132(%rip), %rsi     # 0x46d00
leaq 0x353b(%rip), %rdx      # 0x23110
callq 0x19480
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19210
jmp 0x1fcab
jmp 0x1fca5
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jle 0x1fca3
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x20560
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movq (%rax), %rdi
movslq 0xc(%rax), %rsi
callq 0x19460
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1fc98
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x18e2e(%rip), %rsi     # 0x38a7e
leaq 0x18dca(%rip), %rdx     # 0x38a21
leaq 0x18e07(%rip), %r8      # 0x38a65
movl $0xec, %ecx
callq 0x22ba0
jmp 0x1fc6a
movq -0x40(%rbp), %rdi
leaq 0x2708b(%rip), %rsi     # 0x46d00
leaq 0x3494(%rip), %rdx      # 0x23110
callq 0x19480
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19210
jmp 0x1fcab
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1fca5
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x194a0
nopw %cs:(%rax,%rax)
nop
// File: lega911[P]ijson/src/buffer.h
// Function: ISlice::equal(char const*) const
bool equal(const char *s) const {
        int i = 0;
        while(*s) {
            if(i >= _size) return false;
            if(*s != _ptr[i]) return false;
            i++;
            s++;
        }
        return i == _size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2027d
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jl 0x20246
movb $0x0, -0x1(%rbp)
jmp 0x2028f
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x20266
movb $0x0, -0x1(%rbp)
jmp 0x2028f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2022b
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::_get_cap(int)
int _get_cap(int size) {
        int cap = 16;
        int step = 16;
        while(cap < size) {
            cap += step;
            if(step < 4096) {
                step *= 2;
            }
        }
        return cap;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, -0x10(%rbp)
movl $0x10, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2059d
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jge 0x2059b
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
jmp 0x20579
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: ISlice::compare(ISlice const&) const
int compare(const ISlice &s) const {
        int i = 0;
        int d;
        for(; i<size(); i++) {
            if(i >= s.size()) return 1;
            d = ptr()[i] - s.ptr()[i];
            if(d) return d;
        }
        if(i < s.size()) return -1;
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x1e6d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x21c66
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e6d0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jl 0x21c18
movl $0x1, -0x4(%rbp)
jmp 0x21c8e
movq -0x28(%rbp), %rdi
callq 0x1e6f0
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e6f0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x21c56
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21c8e
jmp 0x21c58
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21bdf
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e6d0
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jge 0x21c87
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21c8e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/exception.cpp
// Function: Exception::print(char const*) const
void Exception::print(const char *msg) const {
        std::cout << ltime() << msg << " '" << _reason << "'";
        if(_file) std::cout << ", file " << _file << ":" << _line << " " << _func << std::endl;
        else std::cout << std::endl;
        std::cout << _trace->ptr();
    }

// 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)
callq 0x36960
movq %rax, %rsi
movq 0x23fb9(%rip), %rdi     # 0x46fd0
callq 0x192e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x192e0
movq %rax, %rdi
leaq 0x15aca(%rip), %rsi     # 0x38afc
callq 0x192e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x192e0
movq %rax, %rdi
leaq 0x15aac(%rip), %rsi     # 0x38afd
callq 0x192e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x230d2
movq 0x23f68(%rip), %rdi     # 0x46fd0
leaq 0x15a90(%rip), %rsi     # 0x38aff
callq 0x192e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x192e0
movq %rax, %rdi
leaq 0x1535d(%rip), %rsi     # 0x383eb
callq 0x192e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x19490
movq %rax, %rdi
leaq 0x155f8(%rip), %rsi     # 0x386a4
callq 0x192e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x192e0
movq %rax, %rdi
movq 0x23ee5(%rip), %rsi     # 0x46fb0
callq 0x19320
jmp 0x230e5
movq 0x23ef7(%rip), %rdi     # 0x46fd0
movq 0x23ed0(%rip), %rsi     # 0x46fb0
callq 0x19320
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1e6f0
movq %rax, %rsi
movq 0x23ed4(%rip), %rdi     # 0x46fd0
callq 0x192e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lega911[P]ijson/src/exception.cpp
// Function: fatal_error(int)
void fatal_error(int sig) {
        Buffer trace;
        get_traceback(trace);
        std::cerr << "Error: signal " << sig << std::endl;
        std::cerr << trace.ptr() << std::endl;
        exit(1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x203c0
movq -0x30(%rbp), %rdi
callq 0x22c70
jmp 0x231c3
movq 0x23e26(%rip), %rdi     # 0x46ff0
leaq 0x15936(%rip), %rsi     # 0x38b07
callq 0x192e0
movq %rax, -0x38(%rbp)
jmp 0x231dc
movq -0x38(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x19490
movq %rax, -0x40(%rbp)
jmp 0x231ee
movq -0x40(%rbp), %rdi
movq 0x23db7(%rip), %rsi     # 0x46fb0
callq 0x19320
jmp 0x23200
leaq -0x18(%rbp), %rdi
callq 0x1e6f0
movq %rax, -0x48(%rbp)
jmp 0x2320f
movq -0x48(%rbp), %rsi
movq 0x23dd6(%rip), %rdi     # 0x46ff0
callq 0x192e0
movq %rax, -0x50(%rbp)
jmp 0x23225
movq -0x50(%rbp), %rdi
movq 0x23d80(%rip), %rsi     # 0x46fb0
callq 0x19320
jmp 0x23237
movl $0x1, %edi
callq 0x19360
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1f460
movq -0x20(%rbp), %rdi
callq 0x194a0
nop
// File: lega911[P]ijson/src/buffer.h
// Function: Slice::split_left(char)
Slice split_left(char a) {
        for(int i=0;i<size();++i) {
            if(_ptr[i] != a) continue;
            Slice result = Slice(_ptr, i);
            _size -= i + 1;
            _ptr += i + 1;
            return result;
        }
        return pop(_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x1e6d0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x23336
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x232f2
jmp 0x2332b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movl -0x20(%rbp), %edx
leaq -0x10(%rbp), %rdi
callq 0x1ea20
movq -0x38(%rbp), %rax
movl -0x20(%rbp), %edx
addl $0x1, %edx
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %edx
addl $0x1, %edx
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x23357
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x232c1
movq -0x38(%rbp), %rdi
movl 0x8(%rdi), %esi
callq 0x1ead0
movl %edx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: lega911[P]ijson/src/json.cpp
// Function: json::escape(Buffer&, int)
void json::escape(Buffer &s, int start) {
    int col = 0;
    for(int i = start;i<s.size();i++) {
        if(s.ptr()[i] == '"') col++;
    }
    if(!col) return;

    s.resize(0, s.size() + col);
    char *ptr = s.ptr();
    for(int i=s.size() -1;i>=start;i--) {
        char a = ptr[i - col];
        ptr[i] = a;
        if(a == '"') {
            i--;
            ptr[i] = '\\';
            col--;
            if(!col) break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e6d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x23610
movq -0x8(%rbp), %rdi
callq 0x1e6f0
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0x23603
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x23605
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x235cc
cmpl $0x0, -0x10(%rbp)
jne 0x2361b
jmp 0x236bf
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e6d0
movq -0x38(%rbp), %rdi
movl %eax, %edx
addl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x1f840
movq -0x8(%rbp), %rdi
callq 0x1e6f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e6d0
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x236bf
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movsbl -0x25(%rbp), %eax
cmpl $0x22, %eax
jne 0x236b2
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x5c, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x236b0
jmp 0x236bf
jmp 0x236b2
jmp 0x236b4
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x23658
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lega911[P]ijson/src/json.cpp
// Function: Json::strip()
void Json::strip() {
    while(index < _data.size()) {
        char a = _data.ptr()[index];
        if(a == ' ' || a == '\n' || a == '\r' || a == '\t') {
            index++;
            continue;
        }
        return;
    }
    throw error::InvalidData();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl 0x38(%rdi), %eax
movl %eax, -0x2c(%rbp)
addq $0x28, %rdi
callq 0x1e6d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x23ad4
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x1e6f0
movq -0x28(%rbp), %rcx
movslq 0x38(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
je 0x23abf
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
je 0x23abf
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0x23abf
movsbl -0x9(%rbp), %eax
cmpl $0x9, %eax
jne 0x23ace
movq -0x28(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x23a64
addq $0x40, %rsp
popq %rbp
retq
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x1ee60
jmp 0x23aef
movq -0x38(%rbp), %rdi
leaq 0x2315e(%rip), %rsi     # 0x46c58
leaq -0x4e01(%rip), %rdx     # 0x1ed00
callq 0x19480
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19210
movq -0x18(%rbp), %rdi
callq 0x194a0
nopw %cs:(%rax,%rax)
// File: lega911[P]ijson/src/json.cpp
// Function: Json::read_string()
Slice Json::read_string() {
    if(next() != '"') throw error::InvalidData();
    int start = index;
    const char *ptr = _data.ptr();
    for(;index < _data.size();index++) {
        if(ptr[index] == '"' && ptr[index-1] != '\\') {
            index++;
            return Slice(&ptr[start], index - start - 1);
        }
    }
    throw error::InvalidData();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x24130
movsbl %al, %eax
cmpl $0x22, %eax
je 0x23b9d
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x1ee60
jmp 0x23b6c
movq -0x40(%rbp), %rdi
leaq 0x230e1(%rip), %rsi     # 0x46c58
leaq -0x4e7e(%rip), %rdx     # 0x1ed00
callq 0x19480
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x19210
jmp 0x23c90
movq -0x38(%rbp), %rdi
movl 0x38(%rdi), %eax
movl %eax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x1e6f0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movl 0x38(%rdi), %eax
movl %eax, -0x44(%rbp)
addq $0x28, %rdi
callq 0x1e6d0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x23c49
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq 0x38(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0x23c35
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x23c35
movq -0x38(%rbp), %rax
movl 0x38(%rax), %ecx
incl %ecx
movl %ecx, 0x38(%rax)
movq -0x30(%rbp), %rsi
movslq -0x28(%rbp), %rcx
movl %ecx, %edx
addq %rcx, %rsi
movl 0x38(%rax), %eax
notl %edx
addl %eax, %edx
leaq -0x10(%rbp), %rdi
callq 0x1ea20
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x50, %rsp
popq %rbp
retq
jmp 0x23c37
movq -0x38(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x23bb4
movl $0x30, %edi
callq 0x19180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x1ee60
jmp 0x23c64
movq -0x50(%rbp), %rdi
leaq 0x22fe9(%rip), %rsi     # 0x46c58
leaq -0x4f76(%rip), %rdx     # 0x1ed00
callq 0x19480
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x19210
movq -0x20(%rbp), %rdi
callq 0x194a0
nopl (%rax)