LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_response::value(cybozu::hash_key const&, unsigned int, cybozu::dynbuf const&)
void text_response::value(const cybozu::hash_key& key, std::uint32_t flags,
                          const cybozu::dynbuf& data) {
    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()};
    char buf[MAX_KEY_LENGTH + 100];
    static_assert( sizeof(unsigned int) >= sizeof(std::uint32_t),
                   "unsigned int is smaller than std::uint32_t" );
    int length = snprintf(buf, sizeof(buf), " %u %llu\x0d\x0a",
                          (unsigned int)flags,
                          (long long unsigned int)data.size());
    m_iov[2] = {buf, (std::size_t)length};
    m_iov[3] = {data.data(), data.size()};
    m_iov[4] = {CRLF, sizeof(CRLF) - 1};
    m_socket.sendv(m_iov, 5, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
cmpq $0xfb, 0x20(%rsi)
jae 0x1f6dd
movq %rcx, %r15
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x9737(%rip), %rax      # 0x28d98
movq %rax, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x20(%r15), %r8
leaq 0x97f6(%rip), %rdx      # 0x28e76
movq %rsp, %r12
movl $0x15e, %esi            # imm = 0x15E
movq %r12, %rdi
xorl %eax, %eax
callq 0x78a0
cltq
movq %r12, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq (%r15), %rax
movq 0x20(%r15), %rcx
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
leaq 0x96ed(%rip), %rax      # 0x28d9f
movq %rax, 0x48(%rbx)
movq $0x2, 0x50(%rbx)
movq (%rbx), %rdi
pushq $0x5
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1e020
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x7240
movq %rax, %rbx
leaq 0x976f(%rip), %rsi      # 0x28e5e
movq %rax, %rdi
callq 0x77a0
movq 0x1b8c2(%rip), %rsi     # 0x3afc0
movq 0x1b883(%rip), %rdx     # 0x3af88
movq %rbx, %rdi
callq 0x7950
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_response::value(cybozu::hash_key const&, unsigned int, cybozu::dynbuf const&, unsigned long)
void text_response::value(const cybozu::hash_key& key, std::uint32_t flags,
                          const cybozu::dynbuf& data, std::uint64_t cas) {
    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()};
    char buf[MAX_KEY_LENGTH + 100];
    static_assert( sizeof(unsigned int) >= sizeof(std::uint32_t),
                   "unsigned int is smaller than std::uint32_t" );
    int length = snprintf(buf, sizeof(buf), " %u %llu %llu\x0d\x0a",
                          (unsigned int)flags,
                          (long long unsigned int)data.size(),
                          (long long unsigned int)cas);
    m_iov[2] = {buf, (std::size_t)length};
    m_iov[3] = {data.data(), data.size()};
    m_iov[4] = {CRLF, sizeof(CRLF) - 1};
    m_socket.sendv(m_iov, 5, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
cmpq $0xfb, 0x20(%rsi)
jae 0x1f7ce
movq %r8, %r9
movq %rcx, %r15
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x9646(%rip), %rax      # 0x28d98
movq %rax, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x20(%r15), %r8
leaq 0x9710(%rip), %rdx      # 0x28e81
movq %rsp, %r12
movl $0x15e, %esi            # imm = 0x15E
movq %r12, %rdi
xorl %eax, %eax
callq 0x78a0
cltq
movq %r12, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq (%r15), %rax
movq 0x20(%r15), %rcx
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
leaq 0x95fc(%rip), %rax      # 0x28d9f
movq %rax, 0x48(%rbx)
movq $0x2, 0x50(%rbx)
movq (%rbx), %rdi
pushq $0x5
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1e020
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x7240
movq %rax, %rbx
leaq 0x967e(%rip), %rsi      # 0x28e5e
movq %rax, %rdi
callq 0x77a0
movq 0x1b7d1(%rip), %rsi     # 0x3afc0
movq 0x1b792(%rip), %rdx     # 0x3af88
movq %rbx, %rdi
callq 0x7950
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpq $0xfb, 0x20(%rsi)
jae 0x1f869
leaq 0x8(%rdi), %rax
leaq 0x956d(%rip), %rcx      # 0x28d98
movq %rcx, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x9559(%rip), %rcx      # 0x28d9f
movq %rcx, 0x28(%rdi)
movq $0x2, 0x30(%rdi)
movq (%rdi), %rdi
pushq $0x3
popq %rdx
movq %rax, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e020
pushq $0x10
popq %rdi
callq 0x7240
movq %rax, %rbx
leaq 0x95e3(%rip), %rsi      # 0x28e5e
movq %rax, %rdi
callq 0x77a0
movq 0x1b736(%rip), %rsi     # 0x3afc0
movq 0x1b6f7(%rip), %rdx     # 0x3af88
movq %rbx, %rdi
callq 0x7950
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_response::stats_items()
void text_response::stats_items() {
    std::ostringstream os;
    os << "STAT items:1:number "
       << g_stats.objects.load(relaxed) << CRLF;
    os << "STAT items:1:age "
       << g_stats.oldest_age.load(relaxed) << CRLF;
    os << "STAT items:1:evicted "
       << g_stats.total_evictions.load(relaxed) << CRLF;
    os << "STAT items:1:conflicts "
       << g_stats.conflicts.load(relaxed) << CRLF;
    os << "STAT items:1:largest "
       << g_stats.largest_object_size.load(relaxed) << CRLF;
    std::string s = os.str();
    m_socket.send(s.data(), s.size());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x7700
leaq 0x9392(%rip), %rsi      # 0x28f81
movq %r14, %rdi
callq 0x7500
leaq 0x1c2c2(%rip), %r14     # 0x3bec0
movl (%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x918f(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x9377(%rip), %rsi      # 0x28f96
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x9163(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x935d(%rip), %rsi      # 0x28fa8
leaq 0x20(%rsp), %rdi
callq 0x7500
movq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0x7360
leaq 0x9137(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x9347(%rip), %rsi      # 0x28fbe
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x30(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x910b(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x9333(%rip), %rsi      # 0x28fd6
leaq 0x20(%rsp), %rdi
callq 0x7500
movq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x7360
leaq 0x90df(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x7870
movq (%rbx), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x1523e
movq %rsp, %rdi
callq 0x71d0
leaq 0x20(%rsp), %rdi
callq 0x70b0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x71d0
jmp 0x1fd17
jmp 0x1fd14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x70b0
movq %rbx, %rdi
callq 0x7990
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_response::stats_sizes()
void text_response::stats_sizes() {
    std::ostringstream os;
    os << "STAT 1024 "
       << g_stats.objects_under_1k.load(relaxed) << CRLF;
    os << "STAT 4096 "
       << g_stats.objects_under_4k.load(relaxed) << CRLF;
    os << "STAT 16384 "
       << g_stats.objects_under_16k.load(relaxed) << CRLF;
    os << "STAT 65536 "
       << g_stats.objects_under_64k.load(relaxed) << CRLF;
    os << "STAT 262144 "
       << g_stats.objects_under_256k.load(relaxed) << CRLF;
    os << "STAT 1048576 "
       << g_stats.objects_under_1m.load(relaxed) << CRLF;
    os << "STAT 4194304 "
       << g_stats.objects_under_4m.load(relaxed) << CRLF;
    os << "STAT huge "
       << g_stats.objects_huge.load(relaxed) << CRLF;
    std::string s = os.str();
    m_socket.send(s.data(), s.size());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x7700
leaq 0x92a1(%rip), %rsi      # 0x28fec
movq %r14, %rdi
callq 0x7500
leaq 0x1c166(%rip), %r14     # 0x3bec0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x9032(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x927b(%rip), %rsi      # 0x28ff7
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x9006(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x925a(%rip), %rsi      # 0x29002
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x8fda(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x923a(%rip), %rsi      # 0x2900e
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x8fae(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x921a(%rip), %rsi      # 0x2901a
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x14(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x8f82(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x91fb(%rip), %rsi      # 0x29027
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x8f56(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x91dd(%rip), %rsi      # 0x29035
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x1c(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x8f2a(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x91bf(%rip), %rsi      # 0x29043
leaq 0x20(%rsp), %rdi
callq 0x7500
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x7360
leaq 0x8efe(%rip), %rsi      # 0x28d9f
movq %rax, %rdi
callq 0x7500
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x7870
movq (%rbx), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x1523e
movq %rsp, %rdi
callq 0x71d0
leaq 0x20(%rsp), %rdi
callq 0x70b0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x71d0
jmp 0x1fef8
jmp 0x1fef5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x70b0
movq %rbx, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0x8(%rdi), %rsi
leaq 0x7cb7(%rip), %rax      # 0x28dc6
movq %rax, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
leaq 0x7c8e(%rip), %rax      # 0x28db0
movq %rax, 0x18(%rdi)
movq $0x15, 0x20(%rdi)
leaq 0x7c6a(%rip), %rax      # 0x28d9f
movq %rax, 0x28(%rdi)
movq $0x2, 0x30(%rdi)
movq (%rdi), %rdi
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
jmp 0x1e020
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/./cybozu/util.hpp
// Function: (anonymous namespace)::binary_exptime(char const*)
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:
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x21435
cmpl $-0x1, %ecx
je 0x21438
bswapl %ecx
movl %ecx, %eax
cmpl $0x278d00, %ecx         # imm = 0x278D00
ja 0x21437
leaq 0x1aa52(%rip), %rcx     # 0x3be80
movq (%rcx), %rcx
addq %rcx, %rax
retq
xorl %eax, %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::error(yrmcds::memcache::binary_status)
void
binary_response::error(binary_status status) {
    switch( status ) {
    case binary_status::NotFound:
        send_error(status, STATUS_NOT_FOUND, sizeof(STATUS_NOT_FOUND) - 1);
        break;
    case binary_status::Exists:
        send_error(status, STATUS_EXISTS, sizeof(STATUS_EXISTS) - 1);
        break;
    case binary_status::TooLargeValue:
        send_error(status, STATUS_TOO_LARGE, sizeof(STATUS_TOO_LARGE) - 1);
        break;
    case binary_status::Invalid:
        send_error(status, STATUS_INVALID, sizeof(STATUS_INVALID) - 1);
        break;
    case binary_status::NotStored:
        send_error(status, STATUS_NOT_STORED, sizeof(STATUS_NOT_STORED) - 1);
        break;
    case binary_status::NonNumeric:
        send_error(status, STATUS_NON_NUMERIC, sizeof(STATUS_NON_NUMERIC) - 1);
        break;
    case binary_status::Locked:
        send_error(status, STATUS_LOCKED, sizeof(STATUS_LOCKED) - 1);
        break;
    case binary_status::NotLocked:
        send_error(status, STATUS_NOT_LOCKED, sizeof(STATUS_NOT_LOCKED) - 1);
        break;
    case binary_status::UnknownCommand:
        send_error(status, STATUS_UNKNOWN, sizeof(STATUS_UNKNOWN) - 1);
        break;
    case binary_status::OutOfMemory:
        send_error(status, STATUS_OOM, sizeof(STATUS_OOM) - 1);
        break;
    default:
        throw std::logic_error("<memcache::binary_response::error> bug");
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leal -0x1(%rsi), %eax
cmpl $0x10, %eax
ja 0x21469
leaq 0x7905(%rip), %rcx      # 0x28d54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7970(%rip), %rdx      # 0x28dcf
pushq $0x1
popq %rsi
pushq $0x9
jmp 0x214e9
cmpl $0x81, %esi
je 0x214f6
cmpl $0x82, %esi
jne 0x21507
leaq 0x79c8(%rip), %rdx      # 0x28e50
pushq $0xd
popq %rcx
movl $0x82, %esi
jmp 0x214ea
leaq 0x7989(%rip), %rdx      # 0x28e22
pushq $0x10
jmp 0x214d8
leaq 0x796c(%rip), %rdx      # 0x28e10
pushq $0x6
popq %rsi
pushq $0x11
jmp 0x214e9
leaq 0x794e(%rip), %rdx      # 0x28e00
pushq $0x5
jmp 0x214e6
leaq 0x7933(%rip), %rdx      # 0x28df0
pushq $0x4
jmp 0x214ca
leaq 0x7918(%rip), %rdx      # 0x28de0
pushq $0x3
popq %rsi
pushq $0xf
jmp 0x214e9
leaq 0x7903(%rip), %rdx      # 0x28dd9
pushq $0x2
popq %rsi
pushq $0x6
jmp 0x214e9
leaq 0x7945(%rip), %rdx      # 0x28e29
pushq $0x11
popq %rsi
pushq $0xa
popq %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24ed8
leaq 0x7943(%rip), %rdx      # 0x28e40
pushq $0xf
popq %rcx
movl $0x81, %esi
jmp 0x214ea
pushq $0x10
popq %rdi
callq 0x7240
movq %rax, %rbx
leaq 0x81f1(%rip), %rsi      # 0x2970a
movq %rax, %rdi
callq 0x77a0
movq 0x19a98(%rip), %rsi     # 0x3afc0
movq 0x19a59(%rip), %rdx     # 0x3af88
movq %rbx, %rdi
callq 0x7950
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x50(%rsp), %rax
movl 0x20(%rdx), %r10d
leaq 0x10(%rsp), %r11
movb $-0x7f, (%r11)
movq 0x8(%rdi), %rbx
movb 0x1a(%rbx), %bpl
movb %bpl, 0x1(%r11)
movl %eax, %ebp
rolw $0x8, %bp
movw %bp, 0x2(%r11)
movl $0x4, 0x4(%r11)
movzwl %ax, %r14d
addl %r14d, %r10d
addl $0x4, %r10d
bswapl %r10d
movl %r10d, 0x8(%r11)
movq (%rbx), %r10
movl 0xc(%r10), %r10d
movl %r10d, 0xc(%r11)
bswapq %rcx
movq %rcx, 0x10(%r11)
bswapl %esi
leaq 0xc(%rsp), %rcx
movl %esi, (%rcx)
leaq 0x10(%rdi), %rsi
movq %r11, 0x10(%rdi)
movq $0x18, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq $0x4, 0x28(%rdi)
testq %r9, %r9
je 0x21623
movq %r9, 0x30(%rdi)
movq %rax, 0x38(%rdi)
pushq $0x4
popq %rax
pushq $0x48
popq %rcx
pushq $0x40
jmp 0x2162b
pushq $0x3
popq %rax
pushq $0x38
popq %rcx
pushq $0x30
popq %r9
movq (%rdx), %r10
movq 0x20(%rdx), %rdx
movq %r10, (%rdi,%r9)
movq %rdx, (%rdi,%rcx)
movq (%rdi), %rdi
movzbl %r8b, %ecx
movl %eax, %edx
callq 0x1e020
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x18, %rsp
movq %rsp, %rcx
movb $-0x7f, (%rcx)
movq 0x8(%rdi), %rax
movb 0x1a(%rax), %r8b
movb %r8b, 0x1(%rcx)
movl %edx, %r8d
rolw $0x8, %r8w
movw %r8w, 0x2(%rcx)
andl $0x0, 0x4(%rcx)
movzwl %dx, %r8d
bswapl %r8d
movl %r8d, 0x8(%rcx)
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rcx)
andq $0x0, 0x10(%rcx)
leaq 0x10(%rdi), %rax
movq %rcx, 0x10(%rdi)
movq $0x18, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq (%rdi), %rdi
pushq $0x2
popq %rdx
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x1e020
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x28, %rsp
movq %rsp, %rax
movb $-0x7f, (%rax)
movq 0x8(%rdi), %rcx
movb 0x1a(%rcx), %r8b
movb %r8b, 0x1(%rax)
andl $0x0, 0x2(%rax)
andw $0x0, 0x6(%rax)
movl $0x8000000, 0x8(%rax)   # imm = 0x8000000
movq (%rcx), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
bswapq %rdx
movq %rdx, 0x10(%rax)
bswapq %rsi
movq %rsi, 0x18(%rax)
movq (%rdi), %rdi
pushq $0x20
popq %rdx
pushq $0x1
popq %rcx
movq %rax, %rsi
callq 0x1523e
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::binary_response::stats_items()
void
binary_response::stats_items() {
    send_stat("items:1:number",
              std::to_string(g_stats.objects.load(relaxed)));
    send_stat("items:1:age",
              std::to_string(g_stats.oldest_age.load(relaxed)));
    send_stat("items:1:evicted",
              std::to_string(g_stats.total_evictions.load(relaxed)));
    send_stat("items:1:conflicts",
              std::to_string(g_stats.conflicts.load(relaxed)));
    send_stat("items:1:largest",
              std::to_string(g_stats.largest_object_size.load(relaxed)));
    success();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x7b1f(%rip), %rsi      # 0x297b0
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84d8
leaq 0x1a219(%rip), %r14     # 0x3bec0
movl (%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x10464
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24fb2
leaq 0x8(%rsp), %rdi
callq 0x71d0
leaq 0x28(%rsp), %rdi
callq 0x71d0
leaq 0x7ade(%rip), %rsi      # 0x297bf
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84d8
movl 0x38(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x10464
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24fb2
leaq 0x8(%rsp), %rdi
callq 0x71d0
leaq 0x28(%rsp), %rdi
callq 0x71d0
leaq 0x7aa0(%rip), %rsi      # 0x297cb
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84d8
movq 0x50(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1e186
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24fb2
leaq 0x8(%rsp), %rdi
callq 0x71d0
leaq 0x28(%rsp), %rdi
callq 0x71d0
leaq 0x7a66(%rip), %rsi      # 0x297db
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84d8
movl 0x30(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x10464
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24fb2
leaq 0x8(%rsp), %rdi
callq 0x71d0
leaq 0x28(%rsp), %rdi
callq 0x71d0
leaq 0x7a2e(%rip), %rsi      # 0x297ed
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84d8
movq 0x40(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1e186
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24fb2
leaq 0x8(%rsp), %rdi
callq 0x71d0
leaq 0x28(%rsp), %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x2154a
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x21e2a
jmp 0x21e39
jmp 0x21e48
jmp 0x21e2a
jmp 0x21e39
jmp 0x21e48
jmp 0x21e2a
jmp 0x21e39
jmp 0x21e48
jmp 0x21e2a
jmp 0x21e39
jmp 0x21e48
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x71d0
jmp 0x21e3c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x71d0
jmp 0x21e4b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x38, %rsp
movq %rsp, %rsi
movb $-0x7f, (%rsi)
movq 0x8(%rdi), %rax
movb 0x1a(%rax), %cl
movb %cl, 0x1(%rsi)
andl $0x0, 0x2(%rsi)
andw $0x0, 0x6(%rsi)
movl $0x15000000, 0x8(%rsi)  # imm = 0x15000000
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsi)
andq $0x0, 0x10(%rsi)
movaps 0x4b0f(%rip), %xmm0     # 0x28db0
movups %xmm0, 0x18(%rsi)
movabsq $0x32312e312e31206e, %rax # imm = 0x32312E312E31206E
movq %rax, 0x25(%rsi)
movq (%rdi), %rdi
pushq $0x2d
popq %rdx
pushq $0x1
popq %rcx
callq 0x1523e
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movb $0x0, (%rsi)
movq %rsp, %r12
pushq $0xa
popq %rdx
movq %r12, %rsi
callq 0x7ac0
movq (%r12), %r12
xorq %r12, %r15
orq %rax, %r15
jne 0x242f5
xorl %eax, %eax
jmp 0x24330
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x24308
callq 0x7030
cmpl $0x22, (%rax)
je 0x242f1
movzbl (%r12), %ecx
xorl %eax, %eax
cmpq $0x20, %rcx
ja 0x24330
movabsq $0x100002400, %rdx      # imm = 0x100002400
btq %rcx, %rdx
jae 0x24330
testq %r14, %r14
js 0x242f1
movb $0x1, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_flushall(char const*, char const*)
inline void
text_request::parse_flushall(const char* b, const char* e) noexcept {
    m_exptime = g_current_time.load(relaxed);

    while( *b == SP ) ++b;
    if( b == e ) {
        m_valid = true;
        return;
    }

    if( '0' <= *b && *b <= '9' ) {
        const char* exp_end = cfind(b, SP, e-b);
        if( exp_end == nullptr ) exp_end = e;
        bool result;
        std::time_t t = to_uint<std::time_t>(b, result);
        if( ! result ) return;
        m_exptime = (t > EXPTIME_THRESHOLD) ? t :
            (g_current_time.load(relaxed) + t);
        b = exp_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x17a39(%rip), %rbp     # 0x3be80
movq (%rbp), %rax
movq %rax, 0x38(%rdi)
subq %rsi, %rdx
decq %r12
incq %rdx
movb 0x1(%r12), %al
incq %r12
decq %rdx
cmpb $0x20, %al
je 0x24458
cmpq %r14, %r12
je 0x24539
addb $-0x30, %al
cmpb $0xa, %al
jae 0x244bb
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
leaq 0x7(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x242c6
cmpb $0x1, (%r13)
jne 0x2453d
cmpq $0x278d00, %rax         # imm = 0x278D00
jg 0x244b5
movq (%rbp), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rbx)
jmp 0x244be
movq %r12, %r15
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x244c4
cmpq %r14, %r12
je 0x24524
movq %r14, %rbp
subq %r15, %rbp
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x7560
movq %rax, %r13
subq %r15, %rax
testq %r13, %r13
cmoveq %rbp, %rax
cmpq $0x7, %rax
jne 0x2453d
leaq 0x5732(%rip), %rsi      # 0x29c39
pushq $0x7
popq %rdx
movq %r12, %rdi
callq 0x7530
testl %eax, %eax
jne 0x2453d
testq %r13, %r13
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %r13
movq %r13, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24527
cmpq %r14, %r12
jne 0x2453d
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_verbosity(char const*, char const*)
inline void
text_request::parse_verbosity(const char* b, const char* e) noexcept {
    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* vb_end = cfind(b, SP, e-b);
    if( vb_end == nullptr ) vb_end = e;
    std::size_t len = vb_end - b;
    if( len == 0 ) return; // invalid

    if( len == 5 ) {
        if( std::memcmp("error", b, 5) == 0 ) {
            m_verbosity = cybozu::severity::error;
        } else if( std::memcmp("debug", b, 5) == 0 ) {
            m_verbosity = cybozu::severity::debug;
        }
    }
    if( len == 7 && std::memcmp("warning", b, 7) == 0 )
        m_verbosity = cybozu::severity::warning;
    if( len == 4 && std::memcmp("info", b, 4) == 0 )
        m_verbosity = cybozu::severity::info;

    b = vb_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
decq %r13
movq %r13, %r12
incq %r13
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24566
cmpq %r14, %r12
je 0x24698
movq %r14, %rdx
subq %r13, %rdx
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
cmpq %r15, %r12
je 0x24698
movq %r15, %rax
subq %r13, %rax
cmpq $0x4, %rax
je 0x24605
cmpq $0x7, %rax
je 0x245eb
cmpq $0x5, %rax
jne 0x24619
leaq 0x1dee(%rip), %rdi      # 0x263b0
pushq $0x5
popq %rdx
movq %r12, %rsi
callq 0x7530
testl %eax, %eax
je 0x24614
leaq 0x1de6(%rip), %rdi      # 0x263be
pushq $0x5
popq %rdx
movq %r12, %rsi
callq 0x7530
testl %eax, %eax
jne 0x24619
pushq $0x3
jmp 0x24611
leaq 0x1dc4(%rip), %rdi      # 0x263b6
pushq $0x7
popq %rdx
movq %r12, %rsi
callq 0x7530
testl %eax, %eax
jne 0x24619
pushq $0x1
jmp 0x24611
cmpl $0x6f666e69, (%r12)     # imm = 0x6F666E69
jne 0x24619
pushq $0x2
popq %rax
jmp 0x24616
xorl %eax, %eax
movl %eax, 0x60(%rbx)
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x2461f
cmpq %r14, %r12
je 0x2467f
movq %r14, %rbp
subq %r15, %rbp
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x7560
movq %rax, %r13
subq %r15, %rax
testq %r13, %r13
cmoveq %rbp, %rax
cmpq $0x7, %rax
jne 0x24698
leaq 0x55d7(%rip), %rsi      # 0x29c39
pushq $0x7
popq %rdx
movq %r12, %rdi
callq 0x7530
testl %eax, %eax
jne 0x24698
testq %r13, %r13
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %r13
movq %r13, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24682
cmpq %r14, %r12
jne 0x24698
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
movq %r15, %r13
incq %r15
cmpb $0x20, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x24972
cmpq %r14, %r13
je 0x24a2d
movq %r14, %rdx
subq %r15, %rdx
pushq $0x20
popq %rsi
movq %r13, %rdi
callq 0x7560
movq %rax, %r12
testq %rax, %rax
cmoveq %r14, %r12
movq %r12, %rax
subq %r15, %rax
movq %r13, 0x28(%rbx)
movq %rax, 0x20(%rbx)
decq %r12
movq %r12, %r15
incq %r12
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x249b8
cmpq %r14, %r15
je 0x24a16
movq %r14, %rbp
subq %r12, %rbp
pushq $0x20
popq %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x7560
movq %rax, %r13
subq %r12, %rax
testq %r13, %r13
cmoveq %rbp, %rax
cmpq $0x7, %rax
jne 0x24a2d
leaq 0x5240(%rip), %rsi      # 0x29c39
pushq $0x7
popq %rdx
movq %r15, %rdi
callq 0x7530
testl %eax, %eax
jne 0x24a2d
testq %r13, %r13
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %r13
movq %r13, %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x24a19
cmpq %r14, %r15
jne 0x24a2d
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_touch(char const*, char const*)
inline void
text_request::parse_touch(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 ) return;
    m_key = item(b, key_end-b);
    b = key_end;

    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* exptime_end = cfind(b, SP, e-b);
    if( exptime_end == nullptr ) exptime_end = e;
    bool result;
    std::time_t t = to_uint<std::time_t>(b, result);
    if( ! result ) return;
    if( t != 0 )
        m_exptime = (t > EXPTIME_THRESHOLD) ? t :
            (g_current_time.load(relaxed) + t);
    b = exptime_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
movq %r15, %r13
incq %r15
cmpb $0x20, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x24a56
cmpq %r14, %r13
je 0x24b87
movq %r14, %rdx
subq %r15, %rdx
pushq $0x20
popq %rsi
movq %r13, %rdi
callq 0x7560
testq %rax, %rax
je 0x24b87
movq %rax, %r12
subq %r15, %rax
movq %r13, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %r14, %rdx
subq %r12, %rdx
decq %r12
incq %rdx
decq %rdx
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24aa1
cmpq %r14, %r12
je 0x24b87
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
leaq 0x7(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x242c6
cmpb $0x1, (%r13)
jne 0x24b87
testq %rax, %rax
je 0x24b08
cmpq $0x278d00, %rax         # imm = 0x278D00
jg 0x24b04
leaq 0x17382(%rip), %rcx     # 0x3be80
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rbx)
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24b0e
cmpq %r14, %r12
je 0x24b6e
movq %r14, %rbp
subq %r15, %rbp
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x7560
movq %rax, %r13
subq %r15, %rax
testq %r13, %r13
cmoveq %rbp, %rax
cmpq $0x7, %rax
jne 0x24b87
leaq 0x50e8(%rip), %rsi      # 0x29c39
pushq $0x7
popq %rdx
movq %r12, %rdi
callq 0x7530
testl %eax, %eax
jne 0x24b87
testq %r13, %r13
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %r13
movq %r13, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24b71
cmpq %r14, %r12
jne 0x24b87
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
movq %r15, %r14
incq %r15
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0x24bad
cmpq %r12, %r14
je 0x24c54
movq %r12, %rdx
subq %r15, %rdx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x7560
testq %rax, %rax
cmoveq %r12, %rax
subq %r15, %rax
cmpq $0x8, %rax
je 0x24c3b
cmpq $0x5, %rax
je 0x24c0b
cmpq $0x3, %rax
jne 0x24c58
leaq 0x4b0e(%rip), %rsi      # 0x29706
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x7530
testl %eax, %eax
jne 0x24c58
pushq $0x4
jmp 0x24c50
leaq 0x4fb8(%rip), %rsi      # 0x29bca
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x7530
testl %eax, %eax
je 0x24c4e
leaq 0x4ad8(%rip), %rsi      # 0x29700
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x7530
testl %eax, %eax
jne 0x24c58
pushq $0x3
jmp 0x24c50
movabsq $0x73676e6974746573, %rax # imm = 0x73676E6974746573
cmpq %rax, (%r14)
jne 0x24c58
pushq $0x1
jmp 0x24c50
pushq $0x2
popq %rax
movl %eax, 0x64(%rbx)
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
decq %r14
movq %r14, %r12
incq %r14
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24c7b
cmpq %r15, %r12
je 0x24cb7
movq %r15, %rdx
subq %r14, %rdx
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
testq %rax, %rax
cmoveq %r15, %rax
subq %r14, %rax
movq %r12, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_incdec(char const*, char const*)
inline void
text_request::parse_incdec(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 ) return;
    m_key = item(b, key_end-b);
    b = key_end;

    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* value_end = cfind(b, SP, e-b);
    if( value_end == nullptr ) value_end = e;
    bool result;
    m_value = to_uint<std::uint64_t>(b, result);
    if( ! result ) return;
    b = value_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
movq %r15, %r13
incq %r15
cmpb $0x20, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x24cde
cmpq %r14, %r13
je 0x24df5
movq %r14, %rdx
subq %r15, %rdx
pushq $0x20
popq %rsi
movq %r13, %rdi
callq 0x7560
testq %rax, %rax
je 0x24df5
movq %rax, %r12
subq %r15, %rax
movq %r13, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %r14, %rdx
subq %r12, %rdx
decq %r12
incq %rdx
decq %rdx
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24d29
cmpq %r14, %r12
je 0x24df5
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
movq %rax, %r15
leaq 0x7(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x243bb
movq %rax, 0x58(%rbx)
cmpb $0x1, (%r13)
jne 0x24df5
testq %r15, %r15
cmoveq %r14, %r15
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24d7c
cmpq %r14, %r12
je 0x24ddc
movq %r14, %rbp
subq %r15, %rbp
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x7560
movq %rax, %r13
subq %r15, %rax
testq %r13, %r13
cmoveq %rbp, %rax
cmpq $0x7, %rax
jne 0x24df5
leaq 0x4e7a(%rip), %rsi      # 0x29c39
pushq $0x7
popq %rdx
movq %r12, %rdi
callq 0x7530
testl %eax, %eax
jne 0x24df5
testq %r13, %r13
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %r13
movq %r13, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24ddf
cmpq %r14, %r12
jne 0x24df5
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24e1b
cmpq %r14, %r12
je 0x24e6c
movq %r14, %rdx
subq %r15, %rdx
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
testq %rax, %rax
cmoveq %r14, %rax
movq %rax, %rcx
subq %r15, %rcx
movq %r12, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
decq %rax
cmpb $0x20, 0x1(%rax)
leaq 0x1(%rax), %rax
je 0x24e59
cmpq %r14, %rax
jne 0x24e6c
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, 0x1c(%rdi)
decq %r14
movq %r14, %r12
incq %r14
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x24e93
cmpq %r15, %r12
je 0x24ecb
movq %r15, %rdx
subq %r14, %rdx
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x7560
testq %rax, %rax
cmoveq %r15, %rax
subq %r14, %rax
movq %r12, 0x28(%rbx)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x88, %rsp
cmpq $0x65, %rcx
jae 0x24f4e
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %rdi
movb $-0x7f, -0x18(%rdi)
movq 0x8(%r14), %rax
movb 0x1a(%rax), %cl
movb %cl, -0x17(%rdi)
andl $0x0, -0x16(%rdi)
rolw $0x8, %si
movw %si, -0x12(%rdi)
movl %ebx, %ecx
shll $0x18, %ecx
movl %ecx, -0x10(%rdi)
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rdi)
andq $0x0, -0x8(%rdi)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x7420
movq (%r14), %rdi
addq $0x18, %rbx
movq %rsp, %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdx
callq 0x1523e
addq $0x88, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x7240
movq %rax, %rbx
leaq 0x4ce1(%rip), %rsi      # 0x29c41
movq %rax, %rdi
callq 0x77a0
movq 0x16051(%rip), %rsi     # 0x3afc0
movq 0x16012(%rip), %rdx     # 0x3af88
movq %rbx, %rdi
callq 0x7950
movq %rax, %r14
movq %rbx, %rdi
callq 0x7390
movq %r14, %rdi
callq 0x7990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x18, %rsp
movq 0x8(%rsi), %rax
movzwl %ax, %ecx
addl 0x8(%rdx), %ecx
movq %rsp, %r8
movb $-0x7f, (%r8)
movq 0x8(%rdi), %r9
movb 0x1a(%r9), %r10b
movb %r10b, 0x1(%r8)
rolw $0x8, %ax
movw %ax, 0x2(%r8)
andl $0x0, 0x4(%r8)
bswapl %ecx
movl %ecx, 0x8(%r8)
movq (%r9), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%r8)
andq $0x0, 0x10(%r8)
leaq 0x10(%rdi), %rax
movq %r8, 0x10(%rdi)
movq $0x18, 0x18(%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x30(%rdi)
movq (%rdi), %rdi
pushq $0x3
popq %rdx
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x1e020
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rbx
leaq 0xa8(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x159c8
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %r8
callq 0x1c03a
testb %al, %al
je 0x2515e
movb $0x1, 0xa0(%rbx)
movq 0x70(%rbx), %rax
cmpq 0x78(%rbx), %rax
jne 0x25162
movq 0x90(%rbx), %rax
cmpq %rax, 0x88(%rbx)
jne 0x25162
movq %rbx, %rdi
movl %ebp, %esi
callq 0x159de
xorl %ebx, %ebx
jmp 0x2517d
leaq 0x8(%rsp), %rdi
callq 0x15a56
addq $0xd0, %rbx
movq %rbx, %rdi
callq 0x7930
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x15a16
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x15a16
movq %rbx, %rdi
callq 0x7990
nopl (%rax)