LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cybozu[P]yrmcds/src/counter/counter.cpp
// Function: yrmcds::counter::response::dump(char const*, unsigned short, unsigned int, unsigned int)
void response::dump(const char* name, std::uint16_t name_len,
                    std::uint32_t consumption, std::uint32_t max_conumption) {
    char header[HEADER_SIZE];
    char body[10];
    fill_header(header, counter::status::OK, sizeof(body) + name_len);
    cybozu::hton(consumption, body);
    cybozu::hton(max_conumption, body + 4);
    cybozu::hton(name_len, body + 8);
    cybozu::tcp_socket::iovec iov[] = {
        {header, HEADER_SIZE},
        {body, sizeof(body)},
        {name, name_len},
    };
    m_socket.sendv(iov, 3, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x28(%rbp), %rsi
movzwl -0x12(%rbp), %eax
addq $0xa, %rax
movl %eax, %ecx
xorl %edx, %edx
callq 0x5d3e0
movl -0x18(%rbp), %edi
leaq -0x32(%rbp), %rsi
callq 0x5d470
movl -0x1c(%rbp), %edi
leaq -0x32(%rbp), %rsi
addq $0x4, %rsi
callq 0x5d470
movw -0x12(%rbp), %ax
leaq -0x32(%rbp), %rsi
addq $0x8, %rsi
movzwl %ax, %edi
callq 0x5d4f0
movq -0x78(%rbp), %rax
leaq -0x28(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq $0xc, -0x68(%rbp)
leaq -0x32(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq $0xa, -0x58(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movzwl -0x12(%rbp), %ecx
movq %rcx, -0x48(%rbp)
movq (%rax), %rdi
leaq -0x70(%rbp), %rsi
movl $0x3, %edx
xorl %ecx, %ecx
callq 0x5d4a0
addq $0x80, %rsp
popq %rbp
retq
nop
// File: cybozu[P]yrmcds/src/counter/counter.cpp
// Function: (anonymous namespace)::add_stat(std::vector<char, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void add_stat(std::vector<char>& body, const std::string& name,
              const std::string& value) {
    char buffer[4];
    cybozu::hton((uint16_t)name.size(), buffer);
    cybozu::hton((uint16_t)value.size(), buffer + 2);
    body.insert(body.end(), buffer, buffer + 4);
    body.insert(body.end(), name.begin(), name.end());
    body.insert(body.end(), value.begin(), value.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8450
leaq -0x1c(%rbp), %rsi
movzwl %ax, %edi
callq 0x5d4f0
movq -0x18(%rbp), %rdi
callq 0x8450
leaq -0x1c(%rbp), %rsi
addq $0x2, %rsi
movzwl %ax, %edi
callq 0x5d4f0
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x59ea0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x58300
movq -0xa0(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
addq $0x4, %rcx
movq -0x28(%rbp), %rsi
callq 0x5d830
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
callq 0x59ea0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x58300
movq -0x10(%rbp), %rdi
callq 0x8620
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c70
movq -0x98(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x5d8d0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdi
callq 0x59ea0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x58300
movq -0x18(%rbp), %rdi
callq 0x8620
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c70
movq -0x90(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x5d8d0
movq %rax, -0x88(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: cybozu[P]yrmcds/./cybozu/util.hpp
// Function: void cybozu::ntoh<unsigned int>(char const*, unsigned int&)
inline void ntoh(const char* p, UInt& n) noexcept {
    UInt d;
    static_assert( sizeof(d) == 2 || sizeof(d) == 4 || sizeof(d) == 8,
                   "Wrong integer type" );
    std::memcpy(&d, p, sizeof(d));
    switch( sizeof(d) ) {
    case 2:
        n = be16toh(d);
        return;
    case 4:
        n = be32toh(d);
        return;
    case 8:
        n = be64toh(d);
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x5d320
movl %eax, -0x18(%rbp)
jmp 0x5d386
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa7e0
nopl (%rax)
// File: cybozu[P]yrmcds/src/counter/counter.cpp
// Function: yrmcds::counter::response::fill_header(char*, yrmcds::counter::status, unsigned int)
inline void response::fill_header(char* header, counter::status status,
                                  std::uint32_t body_length) {
    header[0] = (char)RESPONSE_MAGIC;
    header[1] = (char)m_request.command();
    header[2] = (char)status;
    header[3] = 0;
    cybozu::hton(body_length, header + 4);
    std::memcpy(header + 8, m_request.opaque(), 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movb $-0x6f, (%rcx)
movq 0x8(%rax), %rdi
callq 0x32a10
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x3(%rax)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x5d470
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x5d540
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/./cybozu/util.hpp
// Function: void cybozu::hton<unsigned short>(unsigned short, char*)
inline void hton(UInt d, char* p) noexcept {
    static_assert( sizeof(d) == 2 || sizeof(d) == 4 || sizeof(d) == 8,
                   "Wrong integer type" );
    UInt n;
    switch( sizeof(d) ) {
    case 2:
        n = htobe16(d);
        std::memcpy(p, &n, 2);
        return;
    case 4:
        n = htobe32(d);
        std::memcpy(p, &n, 4);
        return;
    case 8:
        n = htobe64(d);
        std::memcpy(p, &n, 8);
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %edi
callq 0x5d2f0
movw %ax, -0x14(%rbp)
jmp 0x5d512
movw -0x14(%rbp), %ax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movw -0x12(%rbp), %cx
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa7e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/./cybozu/tcp.hpp
// Function: cybozu::tcp_socket::sendv(cybozu::tcp_socket::iovec const*, int, bool)::'lambda'(int)::operator()(int) const
bool sendv(const iovec* iov, int iovcnt, bool flush=false) {
        return with_fd([=](int fd) -> bool {
            if( iovcnt >= MAX_IOVCNT )
                throw std::logic_error("<tcp_socket::sendv> too many iovec.");
            lock_guard g(m_lock);
            if( ! _sendv(fd, iov, iovcnt, g) )
                return false;
            if( flush && empty() )
                _flush(fd);
            return true;
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
cmpl $0x14, (%rax)
jl 0x5d697
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x1f7b4(%rip), %rsi     # 0x7ce13
callq 0x89a0
jmp 0x5d666
movq -0x58(%rbp), %rdi
movq 0x5194f(%rip), %rsi     # 0xaefc0
movq 0x51908(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8490
jmp 0x5d743
movq -0x48(%rbp), %rsi
addq $0xa8, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3cc10
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %r8
movl -0x14(%rbp), %esi
movq 0x10(%rax), %rdx
movl (%rax), %ecx
callq 0x56180
movb %al, -0x59(%rbp)
jmp 0x5d6ce
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x5d6fb
jmp 0x5d6d7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x5d72f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ccf0
jmp 0x5d743
movq -0x50(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x5d724
movq -0x48(%rbp), %rdi
callq 0x3cc50
testb $0x1, %al
jne 0x5d714
jmp 0x5d724
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3cca0
jmp 0x5d722
jmp 0x5d724
movb $0x1, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ccf0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: cybozu[P]yrmcds/src/counter/gc.cpp
// Function: yrmcds::counter::gc_thread::gc()
void gc_thread::gc() {
    auto pred = [this](const cybozu::hash_key& k, object& obj) -> bool {
        if( obj.deletable() )
            return true;
        ++m_objects;
        ++m_objects_in_bucket;
        if( m_objects_in_bucket == 2 )
            ++m_conflicts;
        m_used_memory += sizeof(cybozu::hash_key) + k.length() + sizeof(object);
        return false;
    };

    for( auto it = m_hash.begin(); it != m_hash.end(); ++it ) {
        m_objects_in_bucket = 0;
        it->gc(pred);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rdi
callq 0x2cda0
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2cdd0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ce00
testb $0x1, %al
jne 0x5f709
jmp 0x5f76c
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
leaq -0x18(%rbp), %rdi
callq 0x5fd00
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x5f780
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x5fd20
jmp 0x5f741
leaq -0x40(%rbp), %rdi
callq 0x32bb0
leaq -0x18(%rbp), %rdi
callq 0x2ced0
jmp 0x5f6e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x32bb0
jmp 0x5f772
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8bc0
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/./cybozu/hash_map.hpp
// Function: cybozu::hash_map<yrmcds::counter::object>::bucket::gc(std::function<bool (cybozu::hash_key const&, yrmcds::counter::object&)> const&)
void gc(const std::function<bool(const hash_key&, T&)>& pred) {
            lock_guard g(m_lock);
            for( item** p = &m_objects; *p != nullptr; ) {
                item* to_delete = *p;
                if( pred(to_delete->key, to_delete->object) ) {
                    *p = to_delete->next;
                    delete to_delete;
                } else {
                    p = &(to_delete->next);
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb7a0
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5fde6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rdx
addq $0x30, %rdx
callq 0x34950
movb %al, -0x41(%rbp)
jmp 0x5fd7f
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5fd88
jmp 0x5fdd5
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x5fdbc
movq -0x50(%rbp), %rdi
callq 0x2ecd0
movq -0x50(%rbp), %rdi
movl $0x48, %esi
callq 0x8650
jmp 0x5fde1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb7d0
jmp 0x5fdf5
movq -0x28(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
jmp 0x5fd4d
leaq -0x18(%rbp), %rdi
callq 0xb7d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nop
// File: cybozu[P]yrmcds/src/memcache/object.hpp
// Function: yrmcds::memcache::object::survive(std::vector<yrmcds::memcache::file_flusher, std::allocator<yrmcds::memcache::file_flusher>>&) const
void survive(std::vector<file_flusher>& flushers) const {
        ++ m_gc_old;
        if( m_gc_old != FLUSH_AGE || m_file.get() == nullptr )
            return;

        int new_fd = ::dup(m_file->fileno());
        if( new_fd == -1 ) {
            cybozu::logger::warning() << "Failed to dup a file descriptor";
            return;
        }
        flushers.emplace_back(new_fd);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
cmpl $0xa, 0x50(%rax)
jne 0x61fca
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40980
cmpq $0x0, %rax
jne 0x61fcc
jmp 0x6203f
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq %rax, %rdi
callq 0x620b0
movl %eax, %edi
callq 0x8a30
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x62032
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1b6e0
movq -0x48(%rbp), %rdi
leaq 0x1b09b(%rip), %rsi     # 0x7d0a4
callq 0x581c0
jmp 0x62010
leaq -0x28(%rbp), %rdi
callq 0xa770
jmp 0x6203f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa770
jmp 0x62045
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x620c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nop
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_response::value(cybozu::hash_key const&)
void text_response::value(const cybozu::hash_key& key) {
    if( key.length() > MAX_KEY_LENGTH )
        throw std::logic_error("MAX_KEY_LENGTH over bug");
    m_iov[0] = {VALUE, sizeof(VALUE) - 1};
    m_iov[1] = {key.data(), key.length()};
    m_iov[2] = {CRLF, sizeof(CRLF) - 1};
    m_socket.sendv(m_iov, 3, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
cmpq $0xfa, %rax
jbe 0x6355c
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x19daa(%rip), %rsi     # 0x7d2ce
callq 0x89a0
jmp 0x6352b
movq -0x60(%rbp), %rdi
movq 0x4ba8a(%rip), %rsi     # 0xaefc0
movq 0x4ba43(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x635ed
movq -0x58(%rbp), %rax
leaq 0x19cad(%rip), %rcx     # 0x7d214
movq %rcx, -0x30(%rbp)
movq $0x6, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x355a0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq -0x58(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0x18(%rsi)
movq -0x38(%rbp), %rax
movq %rax, 0x20(%rsi)
leaq 0x19c63(%rip), %rax     # 0x7d21b
movq %rax, -0x50(%rbp)
movq $0x2, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, 0x28(%rsi)
movq -0x48(%rbp), %rax
movq %rax, 0x30(%rsi)
movq (%rsi), %rdi
addq $0x8, %rsi
movl $0x3, %edx
xorl %ecx, %ecx
callq 0x5d4a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_response::version()
void text_response::version() {
    m_iov[0] = {TEXT_VERSION, sizeof(TEXT_VERSION) -1};
    m_iov[1] = {VERSION, sizeof(VERSION) - 1};
    m_iov[2] = {CRLF, sizeof(CRLF) - 1};
    m_socket.sendv(m_iov, 3, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x139df(%rip), %rax     # 0x7d236
movq %rax, -0x18(%rbp)
movq $0x8, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rsi)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rsi)
leaq 0x139a6(%rip), %rax     # 0x7d220
movq %rax, -0x28(%rbp)
movq $0x15, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x18(%rsi)
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rsi)
leaq 0x1397e(%rip), %rax     # 0x7d21b
movq %rax, -0x38(%rbp)
movq $0x2, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, 0x28(%rsi)
movq -0x30(%rbp), %rax
movq %rax, 0x30(%rsi)
movq (%rsi), %rdi
addq $0x8, %rsi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x5d4a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: (anonymous namespace)::binary_exptime(char const*)
inline std::time_t binary_exptime(const char* p) noexcept {
    std::uint32_t t;
    cybozu::ntoh(p, t);
    if( t == 0 ) return 0;
    if( t == 0xffffffffUL )
        return memcache::binary_request::EXPTIME_NONE;
    if( t > EXPTIME_THRESHOLD )
        return t;
    return g_current_time.load(relaxed) + t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x5d360
cmpl $0x0, -0x2c(%rbp)
jne 0x69eec
movq $0x0, -0x20(%rbp)
jmp 0x69f90
movl -0x2c(%rbp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x69f06
movq $-0x1, -0x20(%rbp)
jmp 0x69f90
movl -0x2c(%rbp), %eax
cmpq $0x278d00, %rax         # imm = 0x278D00
jle 0x69f1a
movl -0x2c(%rbp), %eax
movq %rax, -0x20(%rbp)
jmp 0x69f90
leaq 0x4609f(%rip), %rax     # 0xaffc0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x104e0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
decl %eax
subl $0x2, %eax
jb 0x69f6a
jmp 0x69f53
movl -0x30(%rbp), %eax
subl $0x5, %eax
je 0x69f77
jmp 0x69f5d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x69f82
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x69f82
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::get(unsigned int, cybozu::dynbuf const&, unsigned long, bool, char const*, unsigned long)
void
binary_response::get(std::uint32_t flags, const cybozu::dynbuf& data,
                     std::uint64_t cas, bool flush,
                     const char* key, std::size_t key_len) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key_len, sizeof(flags), data.size(), cas);
    char b_flags[sizeof(flags)];
    cybozu::hton(flags, b_flags);
    m_iov[0] = {header, BINARY_HEADER_SIZE};
    m_iov[1] = {b_flags, sizeof(b_flags)};
    if( key == nullptr ) {
        m_iov[2] = {data.data(), data.size()};
        m_socket.sendv(m_iov, 3, flush);
    } else {
        m_iov[2] = {key, key_len};
        m_iov[3] = {data.data(), data.size()};
        m_socket.sendv(m_iov, 4, flush);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %r8b, %al
movq 0x10(%rbp), %r8
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq 0x10(%rbp), %rax
movw %ax, -0xb2(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33df0
movq -0xc0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movw -0xb2(%rbp), %ax
movl %ecx, %r8d
movq -0x20(%rbp), %r9
movl $0x4, %ecx
xorl %edx, %edx
movzwl %ax, %edx
movl $0x0, (%rsp)
callq 0x769d0
movl -0xc(%rbp), %edi
leaq -0x54(%rbp), %rsi
callq 0x5d470
movq -0xb0(%rbp), %rax
leaq -0x50(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq $0x18, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
leaq -0x54(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq $0x4, -0x70(%rbp)
movq -0x78(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x6a388
movq -0x18(%rbp), %rdi
callq 0x33dd0
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33df0
movq -0xb0(%rbp), %rsi
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
movq %rax, 0x30(%rsi)
movq -0x80(%rbp), %rax
movq %rax, 0x38(%rsi)
movq (%rsi), %rdi
addq $0x10, %rsi
movb -0x21(%rbp), %al
movl $0x3, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x5d4a0
jmp 0x6a411
movq -0xb0(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq 0x10(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq -0x98(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x90(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rdi
callq 0x33dd0
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33df0
movq -0xb0(%rbp), %rsi
movq %rax, -0xa0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, 0x40(%rsi)
movq -0xa0(%rbp), %rax
movq %rax, 0x48(%rsi)
movq (%rsi), %rdi
addq $0x10, %rsi
movb -0x21(%rbp), %al
movl $0x4, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x5d4a0
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::key(char const*, unsigned long)
void
binary_response::key(const char* key, std::size_t key_len) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key_len, 0, 0, 0);
    m_iov[0] = {header, BINARY_HEADER_SIZE};
    m_iov[1] = {key, key_len};
    m_socket.sendv(m_iov, 2, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
xorl %r8d, %r8d
xorl %ecx, %ecx
movl %ecx, %r9d
movzwl %ax, %edx
movl %r8d, %ecx
movl $0x0, (%rsp)
callq 0x769d0
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x18, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%rsi)
movq -0x38(%rbp), %rax
movq %rax, 0x18(%rsi)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, 0x20(%rsi)
movq -0x48(%rbp), %rax
movq %rax, 0x28(%rsi)
movq (%rsi), %rdi
addq $0x10, %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x5d4a0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::incdec(unsigned long, unsigned long)
void
binary_response::incdec(std::uint64_t value, std::uint64_t cas) {
    char header[BINARY_HEADER_SIZE + sizeof(value)];
    fill_header(header, 0, 0, sizeof(value), cas);
    cybozu::hton(value, &header[BINARY_HEADER_SIZE]);
    m_socket.send(header, sizeof(header), 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), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %r9
xorl %ecx, %ecx
movl $0x8, %r8d
movl %ecx, %edx
movl $0x0, (%rsp)
callq 0x769d0
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0x18, %rsi
callq 0x76ab0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
movl $0x1, %ecx
callq 0x3a550
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::version()
void
binary_response::version() {
    char header[BINARY_HEADER_SIZE + sizeof(VERSION) - 1];
    fill_header(header, 0, 0, sizeof(VERSION) - 1, 0);
    std::memcpy(&header[BINARY_HEADER_SIZE], VERSION, sizeof(VERSION) - 1);
    m_socket.send(header, sizeof(header), true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x40(%rbp), %rsi
xorl %ecx, %ecx
movl $0x15, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movl $0x0, (%rsp)
callq 0x769d0
movq -0x48(%rbp), %rax
movq 0x8522(%rip), %rcx      # 0x7d220
movq %rcx, -0x28(%rbp)
movq 0x851f(%rip), %rcx      # 0x7d228
movq %rcx, -0x20(%rbp)
movl 0x851d(%rip), %ecx      # 0x7d230
movl %ecx, -0x18(%rbp)
movb 0x8518(%rip), %cl       # 0x7d234
movb %cl, -0x14(%rbp)
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movl $0x2d, %edx
movl $0x1, %ecx
callq 0x3a550
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: long (anonymous namespace)::to_uint<long>(char const*, bool&)
inline UInt to_uint(const char* p, bool& result) {
    static_assert( sizeof(UInt) <= sizeof(unsigned long long),
                   "UInt is larger than unsigned long long" );
    result = false;
    char* end;
    unsigned long long i = strtoull(p, &end, 10);
    if( i == 0 && p == end ) return 0;
    if( i == std::numeric_limits<unsigned long long>::max() &&
        errno == ERANGE ) return 0;
    char c = *end;
    if( c != CR && c != LF && c != SP ) return 0;
    if( i > static_cast<unsigned long long>(std::numeric_limits<UInt>::max()) ) return 0;
    result = true;
    return static_cast<UInt>(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x8d28
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x74d8b
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x74d8b
movq $0x0, -0x8(%rbp)
jmp 0x74e18
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x76d70
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x74db8
callq 0x8050
cmpl $0x22, (%rax)
jne 0x74db8
movq $0x0, -0x8(%rbp)
jmp 0x74e18
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0xd, %eax
je 0x74de6
movsbl -0x29(%rbp), %eax
cmpl $0xa, %eax
je 0x74de6
movsbl -0x29(%rbp), %eax
cmpl $0x20, %eax
je 0x74de6
movq $0x0, -0x8(%rbp)
jmp 0x74e18
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x76d80
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jbe 0x74e09
movq $0x0, -0x8(%rbp)
jmp 0x74e18
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_delete(char const*, char const*)
inline void
text_request::parse_delete(const char* b, const char* e) noexcept {
    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* key_end = cfind(b, SP, e-b);
    if( key_end == nullptr ) key_end = e;
    m_key = item(b, key_end-b);
    b = key_end;

    while( *b == SP ) ++b;
    if( b != e ) {
        // noreply ?
        const char* we = cfind(b, SP, e-b);
        std::size_t noreply_len = (we != nullptr) ? (we - b) : (e - b);
        if( noreply_len != 7 ) return;
        if( std::memcmp(b, "noreply", 7) != 0 ) return;
        m_no_reply = true;
        b = (we != nullptr) ? we : e;
    }

    while( *b == SP ) ++b;
    if( b != e ) return; // garbage left

    m_valid = true;
}

// 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, -0x50(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x75d76
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x75d5c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x75d85
jmp 0x75edc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x63090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x75db1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x524d0
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x51450
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x75e04
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x75dea
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x75eac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x63090
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x75e47
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0x75e56
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x7, -0x48(%rbp)
je 0x75e67
jmp 0x75edc
movq -0x10(%rbp), %rdi
leaq 0x8237(%rip), %rsi      # 0x7e0a9
movl $0x7, %edx
callq 0x8280
cmpl $0x0, %eax
je 0x75e83
jmp 0x75edc
movq -0x50(%rbp), %rax
movb $0x1, 0x1d(%rax)
cmpq $0x0, -0x40(%rbp)
je 0x75e9c
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x75ea4
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x75eae
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x75ec8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x75eae
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x75ed4
jmp 0x75edc
movq -0x50(%rbp), %rax
movb $0x1, 0x1c(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_stats(char const*, char const*)
inline void
text_request::parse_stats(const char* b, const char* e) noexcept {
    while( *b == SP ) ++b;
    if( b == e ) {
        m_valid = true;
        return;
    }

    const char* value_end = cfind(b, SP, e-b);
    if( value_end == nullptr ) value_end = e;
    std::size_t value_len = value_end - b;

    if( value_len == 3 && std::memcmp(b, "ops", 3) == 0 ) {
        m_stats = stats_t::OPS;
        m_valid = true;
        return;
    }
    if( value_len == 5 ) {
        if( std::memcmp(b, "items", 5) == 0 ) {
            m_stats = stats_t::ITEMS;
            m_valid = true;
            return;
        }
        if( std::memcmp(b, "sizes", 5) == 0 ) {
            m_stats = stats_t::SIZES;
            m_valid = true;
            return;
        }
    }
    if( value_len == 8 && std::memcmp(b, "settings", 8) == 0 ) {
        m_stats = stats_t::SETTINGS;
        m_valid = true;
        return;
    }
}

// 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, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x76246
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7622c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x7625d
movq -0x30(%rbp), %rax
movb $0x1, 0x1c(%rax)
jmp 0x76361
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x63090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x76289
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jne 0x762cd
movq -0x10(%rbp), %rdi
leaq 0x78cc(%rip), %rsi      # 0x7db76
movl $0x3, %edx
callq 0x8280
cmpl $0x0, %eax
jne 0x762cd
movq -0x30(%rbp), %rax
movl $0x4, 0x64(%rax)
movb $0x1, 0x1c(%rax)
jmp 0x76361
cmpq $0x5, -0x28(%rbp)
jne 0x7632c
movq -0x10(%rbp), %rdi
leaq 0x7d5b(%rip), %rsi      # 0x7e03a
movl $0x5, %edx
callq 0x8280
cmpl $0x0, %eax
jne 0x762ff
movq -0x30(%rbp), %rax
movl $0x2, 0x64(%rax)
movb $0x1, 0x1c(%rax)
jmp 0x76361
movq -0x10(%rbp), %rdi
leaq 0x7866(%rip), %rsi      # 0x7db70
movl $0x5, %edx
callq 0x8280
cmpl $0x0, %eax
jne 0x7632a
movq -0x30(%rbp), %rax
movl $0x3, 0x64(%rax)
movb $0x1, 0x1c(%rax)
jmp 0x76361
jmp 0x7632c
cmpq $0x8, -0x28(%rbp)
jne 0x76361
movq -0x10(%rbp), %rax
movq (%rax), %rax
movabsq $0x73676e6974746573, %rcx # imm = 0x73676E6974746573
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x76361
movq -0x30(%rbp), %rax
movl $0x1, 0x64(%rax)
movb $0x1, 0x1c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_get(char const*, char const*)
inline void
text_request::parse_get(const char* b, const char* e) noexcept {
    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* key_end = cfind(b, SP, e-b);
    if( key_end == nullptr ) key_end = e;
    m_key = item(b, key_end-b);
    m_valid = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x763a6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7638c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x763b2
jmp 0x76417
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x63090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x763de
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x524d0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x51450
movq -0x40(%rbp), %rax
movb $0x1, 0x1c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_lock(char const*, char const*)
inline void
text_request::parse_lock(const char* b, const char* e) noexcept {
    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* key_end = cfind(b, SP, e-b);
    if( key_end == nullptr ) key_end = e;
    m_key = item(b, key_end-b);
    b = key_end;

    while( *b == SP ) ++b;
    if( b != e ) return; // garbage left

    m_valid = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x76676
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7665c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x76685
jmp 0x76718
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x63090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x766b1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x524d0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x51450
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x76704
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x766ea
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x76710
jmp 0x76718
movq -0x40(%rbp), %rax
movb $0x1, 0x1c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_keys(char const*, char const*)
inline void
text_request::parse_keys(const char* b, const char* e) noexcept {
    m_valid = true;
    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* key_end = cfind(b, SP, e-b);
    if( key_end == nullptr ) key_end = e;
    m_key = item(b, key_end-b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x1, 0x1c(%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x7675a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x76740
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x76766
jmp 0x767c3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x63090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x76792
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x524d0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x51450
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::send_error(yrmcds::memcache::binary_status, char const*, unsigned long)
inline void
binary_response::send_error(binary_status status,
                            const char* msg, std::size_t len) {
    if( len > 100 )
        throw std::logic_error("<memcache::binary_response::send_error> Too long message");
    char header[BINARY_HEADER_SIZE + 100];
    fill_header(header, 0, 0, len, 0, status);
    std::memcpy(&header[BINARY_HEADER_SIZE], msg, len);
    m_socket.send(header, BINARY_HEADER_SIZE + len, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x64, -0x20(%rbp)
jbe 0x76959
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
leaq 0x7793(%rip), %rsi      # 0x7e0b1
callq 0x89a0
jmp 0x76925
movq -0xc0(%rbp), %rdi
movq 0x3868d(%rip), %rsi     # 0xaefc0
movq 0x38646(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8490
jmp 0x769c7
movq -0xb8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %r8d
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movzwl -0xa(%rbp), %eax
movl %eax, (%rsp)
callq 0x769d0
leaq -0xb0(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8540
movq -0xb8(%rbp), %rax
movq (%rax), %rdi
leaq -0xb0(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x18, %rdx
movl $0x1, %ecx
callq 0x3a550
addq $0xd0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8bc0
// File: cybozu[P]yrmcds/src/memcache/memcache.hpp
// Function: yrmcds::memcache::binary_response::fill_header(char*, unsigned short, unsigned char, unsigned int, unsigned long, yrmcds::memcache::binary_status) const
void fill_header(char* buf, std::uint16_t key_len, std::uint8_t extras_len,
                     std::uint32_t data_len, std::uint64_t cas,
                     binary_status status = binary_status::OK) const noexcept {
        buf[0] = '\x81';
        buf[1] = (char)m_request.command();
        cybozu::hton(key_len, buf+2);
        buf[4] = (char)extras_len;
        buf[5] = '\x00';
        cybozu::hton((std::uint16_t)status, buf+6);
        std::uint32_t total_len = key_len + extras_len + data_len;
        cybozu::hton(total_len, buf+8);
        std::memcpy(buf+12, m_request.opaque(), 4);
        cybozu::hton(cas, buf+16);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movw %dx, %cx
movw 0x10(%rbp), %dx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movb %al, -0x13(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movb $-0x7f, (%rcx)
movq 0x8(%rax), %rdi
callq 0x50bc0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movw -0x12(%rbp), %ax
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movzwl %ax, %edi
callq 0x5d4f0
movb -0x13(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x5(%rax)
movw 0x10(%rbp), %ax
movq -0x10(%rbp), %rsi
addq $0x6, %rsi
movzwl %ax, %edi
callq 0x5d4f0
movzwl -0x12(%rbp), %eax
movzbl -0x13(%rbp), %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x5d470
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x76f90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x76ab0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::send_stat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void
binary_response::send_stat(const std::string& key, const std::string& value) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key.size(), 0, value.size(), 0);
    m_iov[0] = {header, sizeof(header)};
    m_iov[1] = {key.data(), key.size()};
    m_iov[2] = {value.data(), value.size()};
    m_socket.sendv(m_iov, 3, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8450
movw %ax, -0x6a(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8450
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movw -0x6a(%rbp), %ax
movl %ecx, %r8d
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %r9d
movzwl %ax, %edx
movl $0x0, (%rsp)
callq 0x769d0
movq -0x68(%rbp), %rax
leaq -0x30(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq $0x18, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x8830
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8450
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0x8830
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8450
movq -0x68(%rbp), %rsi
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0x30(%rsi)
movq -0x58(%rbp), %rax
movq %rax, 0x38(%rsi)
movq (%rsi), %rdi
addq $0x10, %rsi
movl $0x3, %edx
xorl %ecx, %ecx
callq 0x5d4a0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/./cybozu/tcp.hpp
// Function: cybozu::tcp_socket::send_close(char const*, unsigned long)::'lambda'(int)::operator()(int) const
bool send_close(const char* p, std::size_t len) {
        return with_fd([=](int fd) -> bool {
            lock_guard g(m_lock);
            if( ! _send(fd, p, len, g) )
                return false;
            m_shutdown = true;
            if( empty() ) {
                _flush(fd);
                return false;
            }
            g.unlock();
            m_cond_write.notify_all();
            return true;
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%rax), %rsi
movq %rsi, -0x50(%rbp)
addq $0xa8, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3cc10
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %r8
movl -0x14(%rbp), %esi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0x55c60
movb %al, -0x39(%rbp)
jmp 0x770c3
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x770f0
jmp 0x770cc
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x77147
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ccf0
jmp 0x7715b
movq -0x50(%rbp), %rdi
movb $0x1, 0xa0(%rdi)
callq 0x3cc50
testb $0x1, %al
jne 0x77106
jmp 0x77121
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3cca0
jmp 0x77114
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x77147
leaq -0x28(%rbp), %rdi
callq 0x3cfb0
jmp 0x7712c
movq -0x50(%rbp), %rdi
addq $0xd0, %rdi
callq 0x8b50
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ccf0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/src/memcache/replication.cpp
// Function: yrmcds::memcache::repl_object(std::vector<yrmcds::memcache::repl_socket*, std::allocator<yrmcds::memcache::repl_socket*>> const&, cybozu::hash_key const&, yrmcds::memcache::object const&, bool)
void repl_object(const std::vector<repl_socket*>& slaves,
                 const cybozu::hash_key& key, const object& obj,
                 bool flush) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key.length(), 8, obj.size(), binary_command::SetQ);
    char extras[8];
    cybozu::hton(obj.flags(), extras);
    cybozu::hton(obj.exptime(), &extras[4]);
    cybozu::dynbuf buf(0);
    const cybozu::dynbuf& data = obj.data(buf);
    cybozu::tcp_socket::iovec iov[4] = {
        {header, sizeof(header)},
        {extras, sizeof(extras)},
        {key.data(), key.length()},
        {data.data(), data.size()}
    };
    for( cybozu::tcp_socket* s: slaves )
        s->sendv(iov, 4, flush);
}

// 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)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq %rax, -0x108(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62050
movq %rax, %rcx
movq -0x108(%rbp), %rax
movzwl %ax, %esi
leaq -0x40(%rbp), %rdi
movl $0x8, %edx
movl $0x11, %r8d
callq 0x77360
movq -0x18(%rbp), %rdi
callq 0x536b0
movl %eax, %edi
leaq -0x48(%rbp), %rsi
callq 0x5d470
movq -0x18(%rbp), %rdi
callq 0x78e60
movl %eax, %edi
leaq -0x44(%rbp), %rsi
callq 0x5d470
xorl %edx, %edx
movl %edx, %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x22f90
movq -0x100(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x53640
movq %rax, -0xf8(%rbp)
jmp 0x7721d
movq -0xf8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq $0x18, -0xc8(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x8, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355a0
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x355c0
movq %rax, -0xa8(%rbp)
movq -0x78(%rbp), %rdi
callq 0x33dd0
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rdi
callq 0x33df0
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x3b1f0
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x3b220
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x3b250
testb $0x1, %al
jne 0x772de
jmp 0x7733f
leaq -0xe0(%rbp), %rdi
callq 0x3b290
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
leaq -0xd0(%rbp), %rsi
movl $0x4, %edx
callq 0x5d4a0
jmp 0x77315
jmp 0x77317
leaq -0xe0(%rbp), %rdi
callq 0x3b340
jmp 0x772c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc580
jmp 0x77351
leaq -0x70(%rbp), %rdi
callq 0xc580
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x8bc0
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/replication.cpp
// Function: (anonymous namespace)::fill_header(char*, unsigned short, unsigned char, unsigned int, yrmcds::memcache::binary_command)
inline void
fill_header(char* buf, std::uint16_t key_len, std::uint8_t extras_len,
            std::uint32_t data_len, binary_command cmd) noexcept {
        std::memset(buf, 0, BINARY_HEADER_SIZE);
        buf[0] = '\x80';
        buf[1] = (char)cmd;
        cybozu::hton(key_len, buf+2);
        buf[4] = (char)extras_len;
        std::uint32_t total_len = key_len + extras_len + data_len;
        cybozu::hton(total_len, buf+8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movb %dl, -0xb(%rbp)
movl %ecx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x8340
movq -0x8(%rbp), %rax
movb $-0x80, (%rax)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movw -0xa(%rbp), %ax
movq -0x8(%rbp), %rsi
addq $0x2, %rsi
movzwl %ax, %edi
callq 0x5d4f0
movb -0xb(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movzwl -0xa(%rbp), %eax
movzbl -0xb(%rbp), %ecx
addl %ecx, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x5d470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)