LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: yrmcds::memcache::file_flusher::~file_flusher()
file_flusher::~file_flusher() {
    if( m_fd == -1 ) return;
    if( ::fdatasync(m_fd) == 0 )
        ::posix_fadvise(m_fd, 0, 0, POSIX_FADV_DONTNEED);
    ::close(m_fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $-0x1, (%rax)
jne 0x3f8cb
jmp 0x3f907
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x82e0
movl %eax, -0x14(%rbp)
jmp 0x3f8db
movl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x3f8fa
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x4, %ecx
movq %rdx, %rsi
callq 0x84c0
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x8ce0
jmp 0x3f907
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa7e0
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: yrmcds::memcache::object::object(unsigned long, long)
object::object(std::uint64_t initial, std::time_t exptime)
    : m_length(0), m_data(24, g_config.secure_erase()),
      m_file(nullptr), m_flags(0), m_exptime(exptime) {
    char s_value[24]; // uint64 can be as large as 20 byte decimal string.
    m_length = ::snprintf(s_value, sizeof(s_value),
                          "%llu", (unsigned long long)initial);
    m_data.append(s_value, m_length);
    g_stats.total_objects.fetch_add(1, std::memory_order_relaxed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x0, (%rax)
addq $0x8, %rax
movq %rax, -0x88(%rbp)
leaq 0x70118(%rip), %rdi     # 0xafd00
callq 0xaf80
movq -0x88(%rbp), %rdi
movzbl %al, %edx
movl $0x18, %esi
movq %rsi, -0x90(%rbp)
callq 0x22f90
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xa0(%rbp)
xorl %eax, %eax
movl %eax, -0x94(%rbp)
movl %eax, %esi
callq 0x40880
movq -0x78(%rbp), %rdi
movl $0x0, 0x38(%rdi)
movq -0x40(%rbp), %rax
movq %rax, 0x40(%rdi)
movq $0x1, 0x48(%rdi)
movl $0x0, 0x50(%rdi)
movl $0xffffffff, 0x54(%rdi) # imm = 0xFFFFFFFF
addq $0x58, %rdi
callq 0xc6b0
movl -0x94(%rbp), %eax
movq -0x90(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq 0x3bb0d(%rip), %rdx     # 0x7b77d
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x8aa0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl %eax, %ecx
movq -0x78(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, (%rax)
movq (%rax), %rdx
callq 0x33d60
jmp 0x3fc9e
leaq 0x7035b(%rip), %rax     # 0xb0000
subq $-0x80, %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0xa8(%rbp)
subl $0x4, %eax
ja 0x3fcf9
movq -0xa8(%rbp), %rax
leaq 0x3ba70(%rip), %rcx     # 0x7b760
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0xb0(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x3fd65
movq -0xb0(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x3fd65
movq -0xb0(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x3fd65
movq -0xb0(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x3fd65
movq -0xb0(%rbp), %rcx
movq -0x20(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x3f180
movq -0x88(%rbp), %rdi
callq 0xc580
movq -0x68(%rbp), %rdi
callq 0x8bc0
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: yrmcds::memcache::object::set(char const*, unsigned long, unsigned int, long)
void object::set(const char* p, std::size_t len,
                 std::uint32_t flags_, std::time_t exptime) {
    m_flags = flags_;
    m_exptime = exptime;
    ++ m_cas;
    m_gc_old = 0;
    m_data.reset();

    if( len > g_config.heap_data_limit() ) {
        if( m_file.get() == nullptr ) {
            m_file = std::unique_ptr<tempfile>(new tempfile);
        } else {
            m_file->clear();
        }
        m_file->write(p, len);
    } else {
        m_file = nullptr;
        if( len > 0 )
            m_data.append(p, len);
    }
    m_length = len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, 0x38(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x40(%rdi)
movq 0x48(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x48(%rdi)
movl $0x0, 0x50(%rdi)
addq $0x8, %rdi
callq 0x263d0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x6ff04(%rip), %rdi     # 0xafd00
callq 0xafc0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jbe 0x3feb8
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x40980
cmpq $0x0, %rax
jne 0x3fe84
movl $0x10, %edi
callq 0x8640
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x408c0
jmp 0x3fe3f
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x40900
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
callq 0x40930
leaq -0x30(%rbp), %rdi
callq 0x3f180
jmp 0x3fe99
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x8650
jmp 0x3fef8
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq %rax, %rdi
callq 0x55020
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54f90
jmp 0x3fee7
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x409b0
cmpq $0x0, -0x18(%rbp)
jbe 0x3fee5
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x33d60
jmp 0x3fee7
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: yrmcds::memcache::object::append(char const*, unsigned long)
void object::append(const char* p, std::size_t len) {
    ++ m_cas;
    m_gc_old = 0;
    if( len == 0 ) return;

    std::size_t new_size = m_length + len;
    if( new_size > g_config.heap_data_limit() ) {
        if( m_file.get() == nullptr ) {
            m_file = std::unique_ptr<tempfile>(new tempfile);
            if( m_length > 0 )
                m_file->write(m_data.data(), m_length);
            m_data.reset();
            m_file->write(p, len);
        } else {
            m_file->write(p, len);
        }
    } else {
        m_data.append(p, len);
    }
    m_length = new_size;
}

// 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, -0x40(%rbp)
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movl $0x0, 0x50(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x3ff4b
jmp 0x4009b
movq -0x40(%rbp), %rax
movq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x6fd97(%rip), %rdi     # 0xafd00
callq 0xafc0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jbe 0x4007b
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40980
cmpq $0x0, %rax
jne 0x4005c
movl $0x10, %edi
callq 0x8640
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x408c0
jmp 0x3ffb0
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x40900
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
leaq -0x28(%rbp), %rsi
callq 0x40930
leaq -0x28(%rbp), %rdi
callq 0x3f180
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x40030
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x33dd0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x40(%rbp), %rax
movq (%rax), %rdx
callq 0x54f90
jmp 0x40030
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x10, %esi
callq 0x8650
jmp 0x400a1
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x263d0
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54f90
jmp 0x40079
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54f90
jmp 0x40090
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x33d60
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: yrmcds::memcache::object::incr(unsigned long)
std::uint64_t object::incr(std::uint64_t n) {
    if( m_file.get() != nullptr )
        throw not_a_number{};
    std::uint64_t u64_value;
    try {
        u64_value = to_uint64(m_data.data(), m_length);
    } catch( const std::logic_error& ) {
        throw not_a_number{};
    }
    u64_value += n;
    char s_value[24]; // uint64 can be as large as 20 byte decimal string.
    m_length = ::snprintf(s_value, sizeof(s_value),
                          "%llu", (unsigned long long)u64_value);
    m_data.reset();
    m_data.append(s_value, m_length);
    ++ m_cas;
    m_gc_old = 0;
    return u64_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x30, %rdi
callq 0x40980
cmpq $0x0, %rax
je 0x40433
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x40a40
jmp 0x40402
movq -0x60(%rbp), %rdi
leaq 0x6e4f3(%rip), %rsi     # 0xae900
leaq 0x66c(%rip), %rdx       # 0x40a80
callq 0x8b70
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x4055f
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x33dd0
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rsi
callq 0x40570
movq %rax, -0x68(%rbp)
jmp 0x40455
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x404ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4055f
movq -0x18(%rbp), %rdi
callq 0x8230
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x40a40
jmp 0x404a6
movq -0x70(%rbp), %rdi
leaq 0x6e44f(%rip), %rsi     # 0xae900
leaq 0x5c8(%rip), %rdx       # 0x40a80
callq 0x8b70
jmp 0x40570
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x404e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8ae0
jmp 0x404ec
jmp 0x4055f
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x18, %esi
leaq 0x3b26f(%rip), %rdx     # 0x7b77d
movb $0x0, %al
callq 0x8aa0
movq -0x58(%rbp), %rdi
cltq
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x263d0
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
movq (%rax), %rdx
callq 0x33d60
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movl $0x0, 0x50(%rax)
movq -0x28(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8bc0
movq %rax, %rdi
callq 0xa7e0
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: (anonymous namespace)::to_uint64(char const*, unsigned long)
std::uint64_t to_uint64(const char* p, std::size_t len) {
    unsigned long long ull = std::stoull( std::string(p, len) );
    if( ull > std::numeric_limits<std::uint64_t>::max() )
        throw std::out_of_range("out of range for uint64");
    return static_cast<std::uint64_t>(ull);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8bd0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x8700
jmp 0x405b7
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movl $0xa, %edx
callq 0x1d520
movq %rax, -0x70(%rbp)
jmp 0x405cf
leaq -0x38(%rbp), %rdi
callq 0x83f0
leaq -0x39(%rbp), %rdi
callq 0x86a0
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x40f00
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jbe 0x40680
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x3b16d(%rip), %rsi     # 0x7b78a
callq 0x8070
jmp 0x40624
movq -0x80(%rbp), %rdi
movq 0x6e981(%rip), %rsi     # 0xaefb0
movq 0x6e96a(%rip), %rdx     # 0xaefa0
callq 0x8b70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4065e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x83f0
leaq -0x39(%rbp), %rdi
callq 0x86a0
jmp 0x4068d
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x8490
jmp 0x4068d
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/object.cpp
// Function: yrmcds::memcache::object::decr(unsigned long)
std::uint64_t object::decr(std::uint64_t n) {
    if( m_file.get() != nullptr )
        throw not_a_number{};
    std::uint64_t u64_value;
    try {
        u64_value = to_uint64(m_data.data(), m_length);
    } catch( const std::logic_error& ) {
        throw not_a_number{};
    }
    u64_value = (u64_value < n) ? 0 : (u64_value - n);
    char s_value[24]; // uint64 can be as large as 20 byte decimal string.
    m_length = ::snprintf(s_value, sizeof(s_value),
                          "%llu", (unsigned long long)u64_value);
    m_data.reset();
    m_data.append(s_value, m_length);
    ++ m_cas;
    m_gc_old = 0;
    return u64_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x30, %rdi
callq 0x40980
cmpq $0x0, %rax
je 0x40716
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x40a40
jmp 0x406e5
movq -0x60(%rbp), %rdi
leaq 0x6e210(%rip), %rsi     # 0xae900
leaq 0x389(%rip), %rdx       # 0x40a80
callq 0x8b70
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x40862
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x33dd0
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rsi
callq 0x40570
movq %rax, -0x68(%rbp)
jmp 0x40738
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x407d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x40862
movq -0x18(%rbp), %rdi
callq 0x8230
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x40a40
jmp 0x40789
movq -0x70(%rbp), %rdi
leaq 0x6e16c(%rip), %rsi     # 0xae900
leaq 0x2e5(%rip), %rdx       # 0x40a80
callq 0x8b70
jmp 0x40873
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x407c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8ae0
jmp 0x407cf
jmp 0x40862
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x407e6
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x407f2
movq -0x28(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x18, %esi
leaq 0x3af6f(%rip), %rdx     # 0x7b77d
movb $0x0, %al
callq 0x8aa0
movq -0x58(%rbp), %rdi
cltq
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x263d0
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
movq (%rax), %rdx
callq 0x33d60
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movl $0x0, 0x50(%rax)
movq -0x28(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8bc0
movq %rax, %rdi
callq 0xa7e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/src/memcache/../tempfile.hpp
// Function: yrmcds::mkstemp_wrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline int mkstemp_wrap(const std::string& tempdir) {
    std::string tmpl = tempdir + "/XXXXXX\0";
    int fd = ::mkostemp(&(tmpl[0]), O_CLOEXEC);
    if( fd == -1 )
        cybozu::throw_unix_error(errno, "mkstemp");
    ::unlink(tmpl.data());
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3abcd(%rip), %rdx     # 0x7b774
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x40c70
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8d10
movq %rax, -0x48(%rbp)
jmp 0x40bc7
movq -0x48(%rbp), %rdi
movl $0x80000, %esi          # imm = 0x80000
callq 0x8200
movl %eax, -0x54(%rbp)
jmp 0x40bda
movl -0x54(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x40c12
callq 0x8050
movl (%rax), %edi
leaq 0x3ab8e(%rip), %rsi     # 0x7b782
callq 0xa320
jmp 0x40bfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x83f0
jmp 0x40c3b
leaq -0x28(%rbp), %rdi
callq 0x83b0
movq %rax, %rdi
callq 0x82b0
movl -0x2c(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x83f0
movl -0x58(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/src/memcache/sockets.cpp
// Function: yrmcds::memcache::memcache_socket::~memcache_socket()
memcache_socket::~memcache_socket() {
    // the destructor is the safe place to release remaining locks.
    for( auto& ref: m_locks ) {
        m_hash.apply(ref.get(),
                     [](const cybozu::hash_key&, object& obj) -> bool {
                         obj.unlock(true);
                         return true;
                     }, nullptr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x6d4b2(%rip), %rcx     # 0xae940
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50750
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50780
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x507b0
testb $0x1, %al
jne 0x414cf
jmp 0x41566
leaq -0x18(%rbp), %rdi
callq 0x507f0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x110(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rdi
callq 0x50860
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x49(%rbp), %rsi
callq 0x415d0
xorl %eax, %eax
movl %eax, %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x50880
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x50810
jmp 0x41546
leaq -0x70(%rbp), %rdi
callq 0x508c0
leaq -0x48(%rbp), %rdi
callq 0x508e0
leaq -0x18(%rbp), %rdi
callq 0x50900
jmp 0x414b9
movq -0x78(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x506f0
movq -0x78(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0xc560
movq -0x78(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0xc560
movq -0x78(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x39ae0
movq -0x78(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0xc580
movq -0x78(%rbp), %rdi
callq 0x33280
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa7e0
// File: cybozu[P]yrmcds/src/memcache/sockets.cpp
// Function: yrmcds::memcache::memcache_socket::on_readable(int)
bool memcache_socket::on_readable(int) {
    if( m_busy.load(std::memory_order_acquire) ) {
        m_reactor->add_readable(*this);
        return true;
    }

    // find an idle worker.
    cybozu::worker* w = m_finder();
    if( w == nullptr ) {
        m_reactor->add_readable(*this);
        return true;
    }

    // copy the current list of slaves
    m_slaves = m_slaves_origin;

    m_busy.store(true, std::memory_order_release);
    w->post_job(m_recvjob);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x100, %rdi            # imm = 0x100
movl $0x2, %esi
callq 0x235b0
testb $0x1, %al
jne 0x416ce
jmp 0x416e4
movq -0x58(%rbp), %rsi
movq 0x8(%rsi), %rdi
callq 0x32800
movb $0x1, -0x1(%rbp)
jmp 0x4179b
movq -0x58(%rbp), %rax
movq 0x108(%rax), %rdi
callq 0x32830
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x41715
movq -0x58(%rbp), %rsi
movq 0x8(%rsi), %rdi
callq 0x32800
movb $0x1, -0x1(%rbp)
jmp 0x4179b
movq -0x58(%rbp), %rdi
movq 0x140(%rdi), %rsi
addq $0x148, %rdi            # imm = 0x148
callq 0x50920
movq -0x58(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl $0x1, %esi
movl $0x3, %edx
callq 0x23390
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x160, %rsi            # imm = 0x160
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x328c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x32870
jmp 0x41775
leaq -0x40(%rbp), %rdi
callq 0xc560
movb $0x1, -0x1(%rbp)
jmp 0x4179b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc560
jmp 0x417a6
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8bc0
nop
// File: cybozu[P]yrmcds/src/memcache/sockets.hpp
// Function: yrmcds::memcache::memcache_socket::unlock_all()
void unlock_all() {
        for( auto& ref: m_locks ) {
            m_hash.apply(ref.get(),
                         [](const cybozu::hash_key&, object& obj) -> bool {
                             obj.unlock(false);
                             return true;
                         }, nullptr);
        }
        m_locks.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50750
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50780
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x507b0
testb $0x1, %al
jne 0x50ed4
jmp 0x50f94
leaq -0x18(%rbp), %rdi
callq 0x507f0
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x110(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rdi
callq 0x50860
movq %rax, -0xa0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x49(%rbp), %rsi
callq 0x51b40
xorl %eax, %eax
movl %eax, %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x50880
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq 0x50810
jmp 0x50f54
leaq -0x70(%rbp), %rdi
callq 0x508c0
leaq -0x48(%rbp), %rdi
callq 0x508e0
leaq -0x18(%rbp), %rdi
callq 0x50900
jmp 0x50ebe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x508c0
leaq -0x48(%rbp), %rdi
callq 0x508e0
jmp 0x50fb0
movq -0x88(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x51bd0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: cybozu[P]yrmcds/src/memcache/memcache.hpp
// Function: yrmcds::memcache::text_request::next_key(std::tuple<char const*, unsigned long> const&)
static item next_key(const item& prev) noexcept {
        const char* b;
        std::size_t len;
        std::tie(b, len) = prev;

        b += len;
        while( *b == '\x20' ) ++b;
        const char* e = (const char*)::rawmemchr(b, '\x0d');
        if( b == e ) return eos;

        const char* key_end = (const char*)std::memchr(b, '\x20', e-b);
        if( key_end == nullptr ) key_end = e;
        return item(b, key_end-b);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x50d10
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x51310
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x513b7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5139d
movq -0x18(%rbp), %rdi
movl $0xd, %esi
callq 0x8820
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x513ee
movq -0x60(%rbp), %rax
movq 0x2b5fa(%rip), %rcx     # 0x7c9d8
movq %rcx, (%rax)
movq 0x2b5f8(%rip), %rcx     # 0x7c9e0
movq %rcx, 0x8(%rax)
jmp 0x5143a
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x86f0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5141a
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x524d0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/src/memcache/sockets.hpp
// Function: yrmcds::memcache::memcache_socket::on_invalidate(int)
virtual void on_invalidate(int fd) override final {
        // In order to avoid races and deadlocks, remaining locks
        // are not released here.  They are released in the destructor
        // where no other threads have access to this object.
        g_stats.curr_connections.fetch_sub(1);
        cybozu::tcp_socket::on_invalidate(fd);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x5e782(%rip), %rax     # 0xb0000
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movl $0x5, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x4, %eax
ja 0x518cb
movq -0x40(%rbp), %rax
leaq 0x2ae8a(%rip), %rcx     # 0x7c74c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x51937
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x51937
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x51937
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x51937
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x33310
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: cybozu[P]yrmcds/src/memcache/object.hpp
// Function: yrmcds::memcache::object::unlock(bool)
void unlock(bool force = false) {
        if( ! force && ! locked_by_self() ) {
            cybozu::dump_stack();
            std::ostringstream os;
            os << "object::unlock bug (m_lock=" << m_lock
               << ", g_context=" << g_context
               << ", unlocked thread=" << m_unlocker
               << ", this thread=" << std::this_thread::get_id();
            throw std::logic_error(os.str());
        }
        m_unlocker = std::this_thread::get_id();
        m_lock = -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x51ff7
movq -0x1e0(%rbp), %rdi
callq 0x52040
testb $0x1, %al
jne 0x51ff7
callq 0x16af0
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x88e0
movq -0x1f0(%rbp), %rdi
leaq 0x2a9d0(%rip), %rsi     # 0x7c806
callq 0x8630
movq %rax, -0x1e8(%rbp)
jmp 0x51e44
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rax
movl 0x54(%rax), %esi
callq 0x8ba0
movq %rax, -0x1f8(%rbp)
jmp 0x51e63
movq -0x1f8(%rbp), %rdi
leaq 0x2a9b1(%rip), %rsi     # 0x7c822
callq 0x8630
movq %rax, -0x200(%rbp)
jmp 0x51e7f
callq 0x41040
movq -0x200(%rbp), %rdi
movl (%rax), %esi
callq 0x8ba0
movq %rax, -0x208(%rbp)
jmp 0x51e9b
movq -0x208(%rbp), %rdi
leaq 0x2a986(%rip), %rsi     # 0x7c82f
callq 0x8630
movq %rax, -0x210(%rbp)
jmp 0x51eb7
movq -0x210(%rbp), %rdi
movq -0x1e0(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rsi
callq 0x267d0
movq %rax, -0x218(%rbp)
jmp 0x51ee5
movq -0x218(%rbp), %rdi
leaq 0x2a94f(%rip), %rsi     # 0x7c842
callq 0x8630
movq %rax, -0x220(%rbp)
jmp 0x51f01
callq 0x22a10
movq -0x220(%rbp), %rdi
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rsi
callq 0x267d0
jmp 0x51f22
movb $0x1, -0x1c9(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, -0x228(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x8660
jmp 0x51f4f
movq -0x228(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x8a00
jmp 0x51f64
movq -0x228(%rbp), %rdi
movb $0x0, -0x1c9(%rbp)
movq 0x5d047(%rip), %rsi     # 0xaefc0
movq 0x5d000(%rip), %rdx     # 0xaef80
callq 0x8b70
jmp 0x52034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x51fe9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x51fd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x83f0
testb $0x1, -0x1c9(%rbp)
jne 0x51fdb
jmp 0x51fe7
movq -0x228(%rbp), %rdi
callq 0x8490
jmp 0x51fe9
leaq -0x188(%rbp), %rdi
callq 0x8120
jmp 0x52028
callq 0x22a10
movq %rax, %rcx
movq -0x1e0(%rbp), %rax
movq %rcx, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/src/memcache/object.hpp
// Function: yrmcds::memcache::object::expired() const
bool expired() const noexcept {
        if( locked() ) return false;
        std::time_t t = g_stats.flush_time.load(std::memory_order_relaxed);
        std::time_t now = g_current_time.load(std::memory_order_relaxed);
        if( t != 0 && t <= now ) return true;
        if( m_exptime == 0 ) return false;
        return m_exptime <= now;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x533d0
testb $0x1, %al
jne 0x534d2
jmp 0x534db
movb $0x0, -0x31(%rbp)
jmp 0x535fd
leaq 0x5cb1e(%rip), %rax     # 0xb0000
addq $0xc0, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x104e0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x53531
jmp 0x5351a
movl -0x5c(%rbp), %eax
subl $0x5, %eax
je 0x5353e
jmp 0x53524
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x53549
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x53549
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x5ca68(%rip), %rax     # 0xaffc0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x104e0
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x535a1
jmp 0x5358a
movl -0x6c(%rbp), %eax
subl $0x5, %eax
je 0x535ae
jmp 0x53594
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x535b9
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x535b9
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x535d8
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
jg 0x535d8
movb $0x1, -0x31(%rbp)
jmp 0x535fd
movq -0x58(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x535e9
movb $0x0, -0x31(%rbp)
jmp 0x535fd
movq -0x58(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x50(%rbp), %rax
setle %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/object.hpp
// Function: yrmcds::memcache::object::data(cybozu::dynbuf&) const
const cybozu::dynbuf& data(cybozu::dynbuf& buf) const {
        m_gc_old = 0;
        if( m_file.get() == nullptr ) return m_data;
        buf.reset();
        m_file->read_contents(buf);
        return buf;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, 0x50(%rdi)
addq $0x30, %rdi
callq 0x40980
cmpq $0x0, %rax
jne 0x5367c
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x536a6
movq -0x18(%rbp), %rdi
callq 0x263d0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x40960
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x550a0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: cybozu[P]yrmcds/src/memcache/sockets.hpp
// Function: yrmcds::memcache::memcache_socket::remove_lock(cybozu::hash_key const&)
void remove_lock(const cybozu::hash_key& k) {
        for( auto it = m_locks.begin(); it != m_locks.end(); ++it ) {
            if( it->get() == k ) {
                m_locks.erase(it);
                return;
            }
        }
        cybozu::dump_stack();
        throw std::logic_error("<memcache_socket::remove_lock> bug");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x50750
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x50780
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x507b0
testb $0x1, %al
jne 0x541af
jmp 0x54214
leaq -0x18(%rbp), %rdi
callq 0x54270
movq %rax, %rdi
callq 0x50860
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x348b0
testb $0x1, %al
jne 0x541d2
jmp 0x54204
movq -0x48(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x54300
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x54290
movq %rax, -0x30(%rbp)
addq $0x60, %rsp
popq %rbp
retq
jmp 0x54206
leaq -0x18(%rbp), %rdi
callq 0x50900
jmp 0x54188
callq 0x16af0
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x28728(%rip), %rsi     # 0x7c95c
callq 0x89a0
jmp 0x5423b
movq -0x58(%rbp), %rdi
movq 0x5ad7a(%rip), %rsi     # 0xaefc0
movq 0x5ad33(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8490
movq -0x38(%rbp), %rdi
callq 0x8bc0
// File: cybozu[P]yrmcds/./cybozu/hash_map.hpp
// Function: cybozu::hash_map<yrmcds::memcache::object>::bucket::remove_if(cybozu::hash_key const&, std::function<bool (cybozu::hash_key const&, yrmcds::memcache::object&)> const&)
bool remove_if(const hash_key& key,
                       const std::function<bool(const hash_key&, T&)>& pred) {
            lock_guard g(m_lock);
            for( item** p = &m_objects; *p != nullptr; p = &((*p)->next) ) {
                item* to_delete = *p;
                if( to_delete->key == key ) {
                    if( pred(key, to_delete->object) ) {
                        *p = to_delete->next;
                        delete to_delete;
                    }
                    return true;
                }
            }
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb7a0
movq -0x50(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54828
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x348b0
testb $0x1, %al
jne 0x54790
jmp 0x54810
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x30, %rdx
callq 0x529e0
movb %al, -0x51(%rbp)
jmp 0x547aa
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x547b3
jmp 0x54803
movq -0x38(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x547ea
movq -0x60(%rbp), %rdi
callq 0x3f120
movq -0x60(%rbp), %rdi
movl $0x98, %esi
callq 0x8650
jmp 0x54803
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb7d0
jmp 0x54847
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x54833
jmp 0x54812
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x90, %rax
movq %rax, -0x30(%rbp)
jmp 0x54761
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb7d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8bc0
// File: cybozu[P]yrmcds/src/tempfile.cpp
// Function: yrmcds::tempfile::write(char const*, unsigned long)
void tempfile::write(const char* p, std::size_t len) {
    while( len != 0 ) {
        ssize_t n = ::write(m_fd, p, len);
        if( n == -1 )
            cybozu::throw_unix_error(errno, "write");
        p += n;
        len -= n;
        m_length += n;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x55011
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x81d0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x54fe4
callq 0x8050
movl (%rax), %edi
leaq 0x252cb(%rip), %rsi     # 0x7a2aa
callq 0xa320
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
subq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x54fac
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/tempfile.cpp
// Function: yrmcds::tempfile::clear()
void tempfile::clear() {
    if( lseek(m_fd, 0, SEEK_SET) == (off_t)-1 )
        cybozu::throw_unix_error(errno, "lseek");
    if( ftruncate(m_fd, 0) == -1 )
        cybozu::throw_unix_error(errno, "ftruncate");
    m_length = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8c60
cmpq $-0x1, %rax
jne 0x5505a
callq 0x8050
movl (%rax), %edi
leaq 0x27993(%rip), %rsi     # 0x7c9e8
callq 0xa320
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x8920
cmpl $-0x1, %eax
jne 0x55081
callq 0x8050
movl (%rax), %edi
leaq 0x27972(%rip), %rsi     # 0x7c9ee
callq 0xa320
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/tempfile.cpp
// Function: yrmcds::tempfile::read_contents(cybozu::dynbuf&) const
void tempfile::read_contents(cybozu::dynbuf& buf) const {
    char* p = buf.prepare(m_length);

    std::size_t to_read = m_length;
    while( to_read != 0 ) {
        ssize_t n = pread(m_fd, p, to_read, m_length - to_read);
        if( n == -1 )
            cybozu::throw_unix_error(errno, "pread");
        if( n == 0 )
            throw std::runtime_error("<tempfile::read_contents> unexpected EOF.");
        p += n;
        to_read -= n;
        buf.consume(n);
    }
}

// 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)
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x343b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x551a0
movq -0x40(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x8(%rax), %rcx
subq -0x20(%rbp), %rcx
callq 0x87c0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x5511c
callq 0x8050
movl (%rax), %edi
leaq 0x278e1(%rip), %rsi     # 0x7c9f8
callq 0xa320
cmpq $0x0, -0x28(%rbp)
jne 0x55173
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x278c0(%rip), %rsi     # 0x7c9fe
callq 0x8220
jmp 0x55145
movq -0x48(%rbp), %rdi
movq 0x59ea0(%rip), %rsi     # 0xaeff0
movq 0x59e19(%rip), %rdx     # 0xaef70
callq 0x8b70
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8490
jmp 0x551a6
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x344c0
jmp 0x550d8
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nop
// File: cybozu[P]yrmcds/cybozu/hash_map.cpp
// Function: cybozu::nearest_prime(unsigned int)
unsigned int nearest_prime(unsigned int n) noexcept {
    static_assert( sizeof(n) >= 4, "Too small unsigned int." );
    if( n == 2 ) return 2;
    for( unsigned int i = n|1; ; i += 2 ) {
        bool prime = true;
        unsigned int r = (unsigned int)std::rint( std::sqrt((double)i) );
        for( unsigned int j = 3; j <= r; j += 2 ) {
            if( (i % j) == 0 ) {
                prime = false;
                break;
            }
        }
        if( prime ) return i;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x551ca
movl $0x2, -0x4(%rbp)
jmp 0x5523b
movl -0x8(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movb $0x1, -0xd(%rbp)
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
callq 0x8500
callq 0x8970
cvttsd2si %xmm0, %rax
movl %eax, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x55220
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl -0x18(%rbp)
cmpl $0x0, %edx
jne 0x55213
movb $0x0, -0xd(%rbp)
jmp 0x55220
jmp 0x55215
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x551f8
testb $0x1, -0xd(%rbp)
je 0x5522e
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5523b
jmp 0x55230
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x551d3
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/cybozu/tcp.cpp
// Function: cybozu::tcp_socket::free_buffers()
void tcp_socket::free_buffers() {
    lock_guard g(m_lock);
    for( auto& t: m_pending ) {
        char* p;
        std::tie(p, std::ignore, std::ignore) = t;
        FREE(p);
    }
    m_pending.clear();
    for( char* p: m_free_buffers ) {
        FREE(p);
    }
    m_free_buffers.clear();
    m_tmpbuf.clear();
    m_tmpbuf.shrink_to_fit();
    m_shutdown = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x90(%rbp)
addq $0xa8, %rsi
leaq -0x18(%rbp), %rdi
callq 0x3cc10
movq -0x90(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x57bf0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x57c20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x57c50
testb $0x1, %al
jne 0x55b06
jmp 0x55b7f
leaq -0x28(%rbp), %rdi
callq 0x57c90
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x27138(%rip), %rcx     # 0x7cc5d
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x40(%rbp), %rsi
movq %rcx, %rdx
callq 0x57cb0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x57cf0
jmp 0x55b51
movq -0x40(%rbp), %rdi
callq 0x8760
leaq -0x28(%rbp), %rdi
callq 0x57d20
jmp 0x55af3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3ccf0
jmp 0x55c4d
movq -0x90(%rbp), %rdi
addq $0x70, %rdi
callq 0x57d40
movq -0x90(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x57a80
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x57ab0
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x57ae0
testb $0x1, %al
jne 0x55bcb
jmp 0x55bf5
leaq -0x78(%rbp), %rdi
callq 0x57b20
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x8760
leaq -0x78(%rbp), %rdi
callq 0x57b40
jmp 0x55bb8
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
callq 0x57b60
movq -0x90(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x57d60
movq -0xa8(%rbp), %rdi
callq 0x57d80
jmp 0x55c2d
movq -0x90(%rbp), %rax
movb $0x1, 0xa0(%rax)
leaq -0x18(%rbp), %rdi
callq 0x3ccf0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/tcp.hpp
// Function: cybozu::tcp_socket::can_send(unsigned long) const
bool can_send(std::size_t len) const {
        if( m_shutdown ) return true; // in fact, fail
        if( ! m_tmpbuf.empty() ) return false;
        if( m_pending.empty() ) return true;
        return capacity() >= len;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xa0(%rax)
je 0x57dc7
movb $0x1, -0x1(%rbp)
jmp 0x57e0f
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x3cdd0
testb $0x1, %al
jne 0x57de1
movb $0x0, -0x1(%rbp)
jmp 0x57e0f
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0x3cd90
testb $0x1, %al
jne 0x57df4
jmp 0x57dfa
movb $0x1, -0x1(%rbp)
jmp 0x57e0f
movq -0x20(%rbp), %rdi
callq 0x57e60
cmpq -0x18(%rbp), %rax
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/src/counter/counter.cpp
// Function: yrmcds::counter::response::send_error(yrmcds::counter::status, char const*, unsigned long)
void response::send_error(counter::status status, const char* message,
                          std::size_t length) {
    char header[HEADER_SIZE];
    fill_header(header, status, length);
    cybozu::tcp_socket::iovec iov[] = {
        {header, HEADER_SIZE},
        {message, length},
    };
    m_socket.sendv(iov, 2, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x2c(%rbp), %rsi
movb -0x9(%rbp), %al
movq -0x20(%rbp), %rcx
movzbl %al, %edx
callq 0x5d3e0
movq -0x58(%rbp), %rax
leaq -0x2c(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq $0xc, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rdi
leaq -0x50(%rbp), %rsi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x5d4a0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/counter/counter.cpp
// Function: yrmcds::counter::response::get(unsigned int)
void response::get(std::uint32_t consumption) {
    char header[HEADER_SIZE];
    char body[4];
    fill_header(header, counter::status::OK, sizeof(body));
    cybozu::hton(consumption, body);
    cybozu::tcp_socket::iovec iov[] = {
        {header, HEADER_SIZE},
        {body, sizeof(body)},
    };
    m_socket.sendv(iov, 2, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x5d3e0
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
callq 0x5d470
movq -0x48(%rbp), %rax
leaq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq $0xc, -0x38(%rbp)
leaq -0x1c(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x5d4a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)