LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/counter/counter.cpp
// Function: (anonymous namespace)::add_stat(std::vector<char, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void add_stat(std::vector<char>& body, const std::string& name,
              const std::string& value) {
    char buffer[4];
    cybozu::hton((uint16_t)name.size(), buffer);
    cybozu::hton((uint16_t)value.size(), buffer + 2);
    body.insert(body.end(), buffer, buffer + 4);
    body.insert(body.end(), name.begin(), name.end());
    body.insert(body.end(), value.begin(), value.end());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movzwl 0x8(%rsi), %eax
rolw $0x8, %ax
movq %rdi, %r14
leaq 0x10(%rsp), %rcx
movw %ax, -0x4(%rcx)
movzwl 0x8(%rdx), %eax
rolw $0x8, %ax
movw %ax, -0x2(%rcx)
movq 0x8(%rdi), %rsi
leaq 0xc(%rsp), %rdx
callq 0x2287a
movq 0x8(%r14), %rsi
movq (%r15), %rdx
movq 0x8(%r15), %rcx
addq %rdx, %rcx
movq %r14, %rdi
callq 0x22a62
movq 0x8(%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
addq %rdx, %rcx
movq %r14, %rdi
callq 0x22a62
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/tcp.hpp
// Function: cybozu::tcp_socket::sendv(cybozu::tcp_socket::iovec const*, int, bool)::'lambda'(int)::operator()(int) const
bool sendv(const iovec* iov, int iovcnt, bool flush=false) {
        return with_fd([=](int fd) -> bool {
            if( iovcnt >= MAX_IOVCNT )
                throw std::logic_error("<tcp_socket::sendv> too many iovec.");
            lock_guard g(m_lock);
            if( ! _sendv(fd, iov, iovcnt, g) )
                return false;
            if( flush && empty() )
                _flush(fd);
            return true;
        });
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x14, (%rdi)
jge 0x22828
movl %esi, %ebx
movq %rdi, %r15
movq 0x8(%rdi), %r14
leaq 0xa8(%r14), %rax
movq %rsp, %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0x17b8c
movb $0x1, 0x8(%r12)
movq 0x10(%r15), %rdx
movl (%r15), %ecx
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %r8
callq 0x2037c
movl %eax, %ebp
testb %al, %al
je 0x22811
cmpb $0x1, 0x18(%r15)
jne 0x22811
movq 0x70(%r14), %rax
cmpq 0x78(%r14), %rax
jne 0x22811
movq 0x90(%r14), %rax
cmpq %rax, 0x88(%r14)
jne 0x22811
movq %r14, %rdi
movl %ebx, %esi
callq 0x17b38
movq %rsp, %rdi
callq 0x17b76
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x141f7(%rip), %rsi     # 0x36a33
movq %rax, %rdi
callq 0x7790
movq 0x2376d(%rip), %rsi     # 0x45fb8
movq 0x2373e(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7960
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
jmp 0x22872
movq %rax, %r14
movq %rsp, %rdi
callq 0x17b76
movq %r14, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/counter/gc.cpp
// Function: yrmcds::counter::gc_thread::run()
void gc_thread::run() {
    using namespace std::chrono;
    auto t1 = steady_clock::now();

    gc();
    g_stats.objects.store(m_objects, std::memory_order_relaxed);
    g_stats.used_memory.store(m_used_memory, std::memory_order_relaxed);
    g_stats.conflicts.store(m_conflicts, std::memory_order_relaxed);
    g_stats.gc_count.fetch_add(1, std::memory_order_relaxed);

    auto t2 = steady_clock::now();
    std::uint64_t us = (std::uint64_t)duration_cast<microseconds>(t2-t1).count();
    g_stats.last_gc_elapsed.store(us, std::memory_order_relaxed);
    g_stats.total_gc_elapsed.fetch_add(us, std::memory_order_relaxed);

    cybozu::logger::debug() << "Semaphore GC end: elapsed=" << us
                            << "us, survived=" << m_objects;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x76c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x22de0
movl 0x18(%rbx), %eax
leaq 0x24012(%rip), %r15     # 0x46d00
movl %eax, (%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x8(%r15)
movl 0x1c(%rbx), %eax
movl %eax, 0x10(%r15)
lock
incl 0x14(%r15)
callq 0x76c0
subq %r14, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r14
addq %rax, %r14
movq %r14, 0x18(%r15)
lock
addq %r14, 0x20(%r15)
leaq 0x23d4d(%rip), %rax     # 0x46a88
movl (%rax), %eax
xorl %esi, %esi
cmpl $0x3, %eax
setge %sil
leaq 0x114fa(%rip), %rdx     # 0x34247
movq %rsp, %r15
movq %r15, %rdi
callq 0x96e6
movb (%r15), %al
cmpb $0x1, %al
jne 0x22d78
movq 0x8(%rsp), %rdi
leaq 0x13dce(%rip), %rsi     # 0x36b39
movl $0x1a, %edx
callq 0x7570
movb (%rsp), %al
testb $0x1, %al
je 0x22d8c
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7330
movb (%rsp), %al
testb $0x1, %al
je 0x22da9
movq 0x8(%rsp), %rdi
leaq 0x13db8(%rip), %rsi     # 0x36b54
movl $0xd, %edx
callq 0x7570
movb (%rsp), %al
testb $0x1, %al
je 0x22dba
movq 0x8(%rsp), %rdi
movl 0x18(%rbx), %esi
callq 0x7330
movq %rsp, %rdi
callq 0x8f4e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8f4e
movq %rbx, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/counter/gc.cpp
// Function: yrmcds::counter::gc_thread::gc()
void gc_thread::gc() {
    auto pred = [this](const cybozu::hash_key& k, object& obj) -> bool {
        if( obj.deletable() )
            return true;
        ++m_objects;
        ++m_objects_in_bucket;
        if( m_objects_in_bucket == 2 )
            ++m_conflicts;
        m_used_memory += sizeof(cybozu::hash_key) + k.length() + sizeof(object);
        return false;
    };

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r14
cmpq 0x10(%rax), %r14
je 0x22e5d
movq %rdi, %rbx
leaq 0x93(%rip), %r12        # 0x22e98
leaq 0xec(%rip), %r13        # 0x22ef8
movq %rsp, %r15
movl $0x0, 0x28(%rbx)
movq $0x0, 0x8(%rsp)
movq %rbx, (%rsp)
movq %r12, 0x18(%rsp)
movq %r13, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f1e
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x22e4f
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
addq $0x30, %r14
movq 0x10(%rbx), %rax
cmpq 0x10(%rax), %r14
jne 0x22e0f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x22e8f
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x22e87
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x79a0
movq %rax, %rdi
callq 0x8f80
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/hash_map.hpp
// Function: cybozu::hash_map<yrmcds::memcache::object>::bucket::gc(std::function<bool (cybozu::hash_key const&, yrmcds::memcache::object&)> const&)
void gc(const std::function<bool(const hash_key&, T&)>& pred) {
            lock_guard g(m_lock);
            for( item** p = &m_objects; *p != nullptr; ) {
                item* to_delete = *p;
                if( pred(to_delete->key, to_delete->object) ) {
                    *p = to_delete->next;
                    delete to_delete;
                } else {
                    p = &(to_delete->next);
                }
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x77d0
testl %eax, %eax
jne 0x2388d
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x23875
leaq 0x28(%rbx), %r12
cmpq $0x0, 0x10(%r14)
je 0x23888
leaq 0x30(%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%r14)
testb %al, %al
je 0x2385e
movq 0x90(%r15), %rax
movq %rax, (%r12)
movq 0x60(%r15), %rsi
testq %rsi, %rsi
je 0x2382a
leaq 0x60(%r15), %rdi
callq 0x1818e
movq $0x0, 0x60(%r15)
leaq 0x38(%r15), %rdi
callq 0x96b0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2384f
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x7500
movl $0x98, %esi
movq %r15, %rdi
callq 0x7500
jmp 0x23868
addq $0x90, %r15
movq %r15, %r12
movq (%r12), %r15
testq %r15, %r15
jne 0x237f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x73c0
callq 0x7170
movl %eax, %edi
callq 0x7320
jmp 0x23896
movq %rax, %r14
movq %rbx, %rdi
callq 0x73c0
movq %r14, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/memcache/object.hpp
// Function: yrmcds::memcache::object::survive(std::vector<yrmcds::memcache::file_flusher, std::allocator<yrmcds::memcache::file_flusher>>&) const
void survive(std::vector<file_flusher>& flushers) const {
        ++ m_gc_old;
        if( m_gc_old != FLUSH_AGE || m_file.get() == nullptr )
            return;

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

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl 0x50(%rdi), %eax
incl %eax
movl %eax, 0x50(%rdi)
cmpl $0xa, %eax
jne 0x2394f
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x2394f
movq %rsi, %rbx
movl (%rax), %edi
callq 0x7820
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x238f6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x23942
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2394f
leaq 0x2318b(%rip), %rax     # 0x46a88
movl (%rax), %eax
xorl %esi, %esi
testl %eax, %eax
setg %sil
leaq 0x10c9d(%rip), %rdx     # 0x345ab
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x96e6
cmpb $0x1, (%rbx)
jne 0x23936
movq 0x18(%rsp), %rdi
leaq 0x132e9(%rip), %rsi     # 0x36c15
movl $0x1f, %edx
callq 0x7570
leaq 0x10(%rsp), %rdi
callq 0x8f4e
jmp 0x2394f
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x2396a
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8f4e
movq %rbx, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x188, %rsp            # imm = 0x188
cmpq $0xfb, 0x20(%rsi)
jae 0x24000
movq %rcx, %r14
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
leaq 0x12e93(%rip), %rax     # 0x36e08
movq %rax, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x20(%r14), %r8
leaq 0x12ec3(%rip), %rdx     # 0x36e57
leaq 0x20(%rsp), %r15
movl $0x15e, %esi            # imm = 0x15E
movq %r15, %rdi
xorl %eax, %eax
callq 0x7890
cltq
movq %r15, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq (%r14), %rax
movq 0x20(%r14), %rcx
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
leaq 0x12e47(%rip), %rax     # 0x36e0f
movq %rax, 0x48(%rbx)
movq $0x2, 0x50(%rbx)
movq (%rbx), %rdi
movq %rsp, %rsi
movl $0x5, (%rsi)
movq %rdi, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movb $0x0, 0x18(%rsi)
callq 0x22726
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x12e2b(%rip), %rsi     # 0x36e3f
movq %rax, %rdi
callq 0x7790
movq 0x21f95(%rip), %rsi     # 0x45fb8
movq 0x21f66(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7960
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x188, %rsp            # imm = 0x188
cmpq $0xfb, 0x20(%rsi)
jae 0x24103
movq %r8, %r9
movq %rcx, %r14
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
leaq 0x12d90(%rip), %rax     # 0x36e08
movq %rax, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x20(%r14), %r8
leaq 0x12dcb(%rip), %rdx     # 0x36e62
leaq 0x20(%rsp), %r15
movl $0x15e, %esi            # imm = 0x15E
movq %r15, %rdi
xorl %eax, %eax
callq 0x7890
cltq
movq %r15, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq (%r14), %rax
movq 0x20(%r14), %rcx
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
leaq 0x12d44(%rip), %rax     # 0x36e0f
movq %rax, 0x48(%rbx)
movq $0x2, 0x50(%rbx)
movq (%rbx), %rdi
movq %rsp, %rsi
movl $0x5, (%rsi)
movq %rdi, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movb $0x0, 0x18(%rsi)
callq 0x22726
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x12d28(%rip), %rsi     # 0x36e3f
movq %rax, %rdi
callq 0x7790
movq 0x21e92(%rip), %rsi     # 0x45fb8
movq 0x21e63(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7960
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x28, %rsp
cmpq $0xfb, 0x20(%rsi)
jae 0x241b2
leaq 0x8(%rdi), %rax
leaq 0x12ca4(%rip), %rcx     # 0x36e08
movq %rcx, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x12c90(%rip), %rcx     # 0x36e0f
movq %rcx, 0x28(%rdi)
movq $0x2, 0x30(%rdi)
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
movq %rdi, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movb $0x0, 0x18(%rsi)
callq 0x22726
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x12c79(%rip), %rsi     # 0x36e3f
movq %rax, %rdi
callq 0x7790
movq 0x21de3(%rip), %rsi     # 0x45fb8
movq 0x21db4(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7960
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x76f0
leaq 0x128e5(%rip), %rsi     # 0x36f62
movl $0x14, %edx
movq %r14, %rdi
callq 0x7570
leaq 0x2282f(%rip), %r14     # 0x46ec0
movl (%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x1276a(%rip), %rsi     # 0x36e0f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7570
leaq 0x128be(%rip), %rsi     # 0x36f77
leaq 0x20(%rsp), %rdi
movl $0x11, %edx
callq 0x7570
movl 0x38(%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x12732(%rip), %rsi     # 0x36e0f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7570
leaq 0x12898(%rip), %rsi     # 0x36f89
leaq 0x20(%rsp), %rdi
movl $0x15, %edx
callq 0x7570
movq 0x50(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x126fa(%rip), %rsi     # 0x36e0f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7570
leaq 0x12876(%rip), %rsi     # 0x36f9f
leaq 0x20(%rsp), %rdi
movl $0x17, %edx
callq 0x7570
movl 0x30(%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x126c2(%rip), %rsi     # 0x36e0f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7570
leaq 0x12856(%rip), %rsi     # 0x36fb7
leaq 0x20(%rsp), %rdi
movl $0x15, %edx
callq 0x7570
movq 0x40(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x1268a(%rip), %rsi     # 0x36e0f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7570
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x7870
movq (%rbx), %rdi
movups (%rsp), %xmm0
leaq 0x198(%rsp), %rsi
movq %rdi, (%rsi)
movups %xmm0, 0x8(%rsi)
movb $0x0, 0x18(%rsi)
callq 0x17a4e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x247d9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7500
movq 0x217a0(%rip), %rsi     # 0x45f80
leaq 0x20(%rsp), %rdi
callq 0x7260
leaq 0x90(%rsp), %rdi
callq 0x7140
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24827
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7500
jmp 0x24827
jmp 0x24824
movq %rax, %rbx
movq 0x21752(%rip), %rsi     # 0x45f80
leaq 0x20(%rsp), %rdi
callq 0x7260
leaq 0x90(%rsp), %rdi
callq 0x7140
movq %rbx, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
subq $0x28, %rsp
leaq 0x8(%rdi), %rax
leaq 0x10c83(%rip), %rcx     # 0x36e36
movq %rcx, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
leaq 0x10c5a(%rip), %rcx     # 0x36e20
movq %rcx, 0x18(%rdi)
movq $0x15, 0x20(%rdi)
leaq 0x10c36(%rip), %rcx     # 0x36e0f
movq %rcx, 0x28(%rdi)
movq $0x2, 0x30(%rdi)
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
movq %rdi, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movb $0x1, 0x18(%rsi)
callq 0x22726
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
leaq 0x20(%rsp), %rax
movb $-0x7f, (%rax)
movq 0x8(%rdi), %rcx
movb 0x1a(%rcx), %dl
movb %dl, 0x1(%rax)
movl $0x0, 0x2(%rax)
movw $0x0, 0x6(%rax)
movl $0x15000000, 0x8(%rax)  # imm = 0x15000000
movq (%rcx), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq $0x0, 0x10(%rax)
movaps 0x549e(%rip), %xmm0     # 0x36e20
movups %xmm0, 0x18(%rax)
movabsq $0x32312e312e31206e, %rcx # imm = 0x32312E312E31206E
movq %rcx, 0x25(%rax)
movq (%rdi), %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
movq %rax, 0x8(%rsi)
movq $0x2d, 0x10(%rsi)
movb $0x1, 0x18(%rsi)
callq 0x17a4e
addq $0x58, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: unsigned int (anonymous namespace)::to_uint<unsigned int>(char const*, bool&)
inline UInt to_uint(const char* p, bool& result) {
    static_assert( sizeof(UInt) <= sizeof(unsigned long long),
                   "UInt is larger than unsigned long long" );
    result = false;
    char* end;
    unsigned long long i = strtoull(p, &end, 10);
    if( i == 0 && p == end ) return 0;
    if( i == std::numeric_limits<unsigned long long>::max() &&
        errno == ERANGE ) return 0;
    char c = *end;
    if( c != CR && c != LF && c != SP ) return 0;
    if( i > static_cast<unsigned long long>(std::numeric_limits<UInt>::max()) ) return 0;
    result = true;
    return static_cast<UInt>(i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movb $0x0, (%rsi)
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x76e0
movq (%r12), %r12
xorq %r12, %r15
xorl %ebp, %ebp
orq %rax, %r15
je 0x31a29
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x319ff
callq 0x7040
cmpl $0x22, (%rax)
je 0x31a29
movzbl (%r12), %eax
cmpq $0x20, %rax
ja 0x31a29
movabsq $0x100002400, %rcx      # imm = 0x100002400
btq %rax, %rcx
jae 0x31a29
movq %r14, %rax
shrq $0x20, %rax
jne 0x31a29
movb $0x1, (%rbx)
movl %r14d, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x153b9(%rip), %rax     # 0x46e80
movq (%rax), %rax
movq %rax, 0x38(%rdi)
subq %rsi, %rdx
decq %r12
incq %rdx
movb 0x1(%r12), %al
incq %r12
decq %rdx
cmpb $0x20, %al
je 0x31ad7
cmpq %r14, %r12
je 0x31c12
addb $-0x30, %al
cmpb $0xa, %al
jae 0x31b91
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
movq %rsp, %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x76e0
movq (%rbp), %rbp
xorq %rbp, %r12
orq %rax, %r12
je 0x31c16
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x31b4a
callq 0x7040
cmpl $0x22, (%rax)
je 0x31c16
movzbl (%rbp), %eax
cmpq $0x20, %rax
ja 0x31c16
movabsq $0x100002400, %rcx      # imm = 0x100002400
btq %rax, %rcx
jae 0x31c16
testq %r13, %r13
js 0x31c16
cmpq $0x278d00, %r13         # imm = 0x278D00
ja 0x31b8b
leaq 0x152fb(%rip), %rax     # 0x46e80
movq (%rax), %rax
addq %rax, %r13
movq %r13, 0x38(%rbx)
jmp 0x31b94
movq %r12, %r15
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x31b9a
cmpq %r14, %r12
je 0x31bfd
movq %r14, %r13
subq %r15, %r13
movq %r12, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7540
movq %rax, %rcx
subq %r15, %rcx
testq %rax, %rax
cmoveq %r13, %rcx
cmpq $0x7, %rcx
jne 0x31c16
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r12), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r12), %edx
orl %ecx, %edx
jne 0x31c16
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x31c00
cmpq %r14, %r12
jne 0x31c16
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_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
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 0x31c3e
cmpq %r14, %r12
je 0x31d7e
movq %r14, %rdx
subq %r13, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
cmpq %r15, %r12
je 0x31d7e
movq %r15, %rax
subq %r13, %rax
cmpq $0x4, %rax
je 0x31ce6
cmpq $0x7, %rax
je 0x31cc8
cmpq $0x5, %rax
jne 0x31cfc
movl $0x6f727265, %eax       # imm = 0x6F727265
xorl (%r12), %eax
movzbl 0x4(%r12), %ecx
xorl $0x72, %ecx
orl %eax, %ecx
je 0x31cf7
movl $0x75626564, %eax       # imm = 0x75626564
xorl (%r12), %eax
movzbl 0x4(%r12), %ecx
xorl $0x67, %ecx
orl %eax, %ecx
jne 0x31cfc
movl $0x3, %eax
jmp 0x31cf9
movl $0x6e726177, %eax       # imm = 0x6E726177
xorl (%r12), %eax
movl $0x676e696e, %ecx       # imm = 0x676E696E
xorl 0x3(%r12), %ecx
orl %eax, %ecx
jne 0x31cfc
movl $0x1, %eax
jmp 0x31cf9
cmpl $0x6f666e69, (%r12)     # imm = 0x6F666E69
jne 0x31cfc
movl $0x2, %eax
jmp 0x31cf9
xorl %eax, %eax
movl %eax, 0x60(%rbx)
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x31d02
cmpq %r14, %r12
je 0x31d65
movq %r14, %r13
subq %r15, %r13
movq %r12, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7540
movq %rax, %rcx
subq %r15, %rcx
testq %rax, %rax
cmoveq %r13, %rcx
cmpq $0x7, %rcx
jne 0x31d7e
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r12), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r12), %edx
orl %ecx, %edx
jne 0x31d7e
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x31d68
cmpq %r14, %r12
jne 0x31d7e
movb $0x1, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
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 0x32102
cmpq %r14, %r13
je 0x321c0
movq %r14, %rdx
subq %r15, %rdx
movq %r13, %rdi
movl $0x20, %esi
callq 0x7540
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 0x3214a
cmpq %r14, %r15
je 0x321a9
movq %r14, %r13
subq %r12, %r13
movq %r15, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7540
movq %rax, %rcx
subq %r12, %rcx
testq %rax, %rax
cmoveq %r13, %rcx
cmpq $0x7, %rcx
jne 0x321c0
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r15), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r15), %edx
orl %ecx, %edx
jne 0x321c0
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x321ac
cmpq %r14, %r15
jne 0x321c0
movb $0x1, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x323f1
cmpq %r12, %r14
je 0x324a1
movq %r12, %rdx
subq %r15, %rdx
movq %r14, %rdi
movl $0x20, %esi
callq 0x7540
testq %rax, %rax
cmoveq %r12, %rax
subq %r15, %rax
cmpq $0x8, %rax
je 0x32483
cmpq $0x5, %rax
je 0x32454
cmpq $0x3, %rax
jne 0x324a5
movzwl (%r14), %eax
xorl $0x706f, %eax           # imm = 0x706F
movzbl 0x2(%r14), %ecx
xorl $0x73, %ecx
orw %ax, %cx
jne 0x324a5
movl $0x4, %eax
jmp 0x3249e
movl $0x6d657469, %eax       # imm = 0x6D657469
xorl (%r14), %eax
movzbl 0x4(%r14), %ecx
xorl $0x73, %ecx
orl %eax, %ecx
je 0x32499
movl $0x657a6973, %eax       # imm = 0x657A6973
xorl (%r14), %eax
movzbl 0x4(%r14), %ecx
xorl $0x73, %ecx
orl %eax, %ecx
jne 0x324a5
movl $0x3, %eax
jmp 0x3249e
movabsq $0x73676e6974746573, %rax # imm = 0x73676E6974746573
cmpq %rax, (%r14)
jne 0x324a5
movl $0x1, %eax
jmp 0x3249e
movl $0x2, %eax
movl %eax, 0x64(%rbx)
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x324c9
cmpq %r15, %r12
je 0x32507
movq %r15, %rdx
subq %r14, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
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_O3/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 0x3252e
cmpq %r14, %r13
je 0x325ca
movq %r14, %rdx
subq %r15, %rdx
movq %r13, %rdi
movl $0x20, %esi
callq 0x7540
testq %rax, %rax
je 0x325ca
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 0x32577
cmpq %r14, %r12
je 0x325ca
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
movq %rsp, %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x76e0
movq (%rbp), %rbp
xorq %rbp, %r12
orq %rax, %r12
jne 0x325d9
movq $0x0, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x325ec
callq 0x7040
cmpl $0x22, (%rax)
je 0x325c2
movzbl (%rbp), %eax
cmpq $0x20, %rax
ja 0x325c2
movabsq $0x100002400, %rcx      # imm = 0x100002400
btq %rax, %rcx
jae 0x325c2
movq %r13, 0x58(%rbx)
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x32610
cmpq %r14, %r12
je 0x3267b
movq %r14, %r13
subq %r15, %r13
movq %r12, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7540
movq %rax, %rcx
subq %r15, %rcx
testq %rax, %rax
cmoveq %r13, %rcx
cmpq $0x7, %rcx
jne 0x325ca
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r12), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r12), %edx
orl %ecx, %edx
jne 0x325ca
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x3267e
cmpq %r14, %r12
jne 0x325ca
movb $0x1, 0x1c(%rbx)
jmp 0x325ca
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x326b5
cmpq %r14, %r12
je 0x32708
movq %r14, %rdx
subq %r15, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
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 0x326f5
cmpq %r14, %rax
jne 0x32708
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3272f
cmpq %r15, %r12
je 0x32769
movq %r15, %rdx
subq %r14, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
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_O3/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), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x17b8c
movb $0x1, 0x8(%r15)
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %r8
callq 0x20000
testb %al, %al
je 0x32853
movb $0x1, 0xa0(%rbx)
movq 0x70(%rbx), %rax
cmpq 0x78(%rbx), %rax
jne 0x32857
movq 0x90(%rbx), %rax
cmpq %rax, 0x88(%rbx)
jne 0x32857
movq %rbx, %rdi
movl %ebp, %esi
callq 0x17b38
xorl %ebx, %ebx
jmp 0x32872
leaq 0x8(%rsp), %rdi
callq 0x17bc8
addq $0xd0, %rbx
movq %rbx, %rdi
callq 0x7940
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x17b76
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17b76
movq %rbx, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/memcache/replication.cpp
// Function: yrmcds::memcache::repl_object(std::vector<yrmcds::memcache::repl_socket*, std::allocator<yrmcds::memcache::repl_socket*>> const&, cybozu::hash_key const&, yrmcds::memcache::object const&, bool)
void repl_object(const std::vector<repl_socket*>& slaves,
                 const cybozu::hash_key& key, const object& obj,
                 bool flush) {
    char header[BINARY_HEADER_SIZE];
    fill_header(header, key.length(), 8, obj.size(), binary_command::SetQ);
    char extras[8];
    cybozu::hton(obj.flags(), extras);
    cybozu::hton(obj.exptime(), &extras[4]);
    cybozu::dynbuf buf(0);
    const cybozu::dynbuf& data = obj.data(buf);
    cybozu::tcp_socket::iovec iov[4] = {
        {header, sizeof(header)},
        {extras, sizeof(extras)},
        {key.data(), key.length()},
        {data.data(), data.size()}
    };
    for( cybozu::tcp_socket* s: slaves )
        s->sendv(iov, 4, flush);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl %ecx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
movq 0x30(%rdx), %rcx
leaq 0x28(%rdx), %rsi
leaq 0x8(%rcx), %rdi
testq %rcx, %rcx
cmoveq %rsi, %rdi
movl (%rdi), %ecx
xorps %xmm0, %xmm0
movups %xmm0, 0x15(%rsp)
movl $0x0, 0x24(%rsp)
movzwl %ax, %esi
rolw $0x8, %ax
movw $0x1180, 0x10(%rsp)     # imm = 0x1180
movw %ax, 0x12(%rsp)
movb $0x8, 0x14(%rsp)
leal (%rsi,%rcx), %eax
addl $0x8, %eax
bswapl %eax
movl %eax, 0x18(%rsp)
movl 0x38(%rdx), %eax
bswapl %eax
movl %eax, 0x8(%rsp)
movl 0x40(%rdx), %eax
bswapl %eax
movl %eax, 0xc(%rsp)
leaq 0x90(%rsp), %rsi
movq $0x0, 0x20(%rsi)
movaps %xmm0, (%rsi)
movups %xmm0, 0x9(%rsi)
movq %rdx, %rdi
callq 0x1f19c
leaq 0x10(%rsp), %rcx
movq %rcx, 0x50(%rsp)
movq $0x18, 0x58(%rsp)
leaq 0x8(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq $0x8, 0x68(%rsp)
movq 0x18(%r15), %rcx
movq %rcx, 0x70(%rsp)
movq 0x20(%r15), %rcx
movq %rcx, 0x78(%rsp)
movq (%rax), %rcx
movq %rcx, 0x80(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x88(%rsp)
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x329c5
leaq 0x50(%rsp), %r13
leaq 0x30(%rsp), %r14
movq (%r15), %rdi
movl $0x4, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movq %r13, 0x40(%rsp)
movb %bl, 0x48(%rsp)
movq %r14, %rsi
callq 0x22726
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3299b
leaq 0x90(%rsp), %rdi
callq 0x96b0
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x329e5
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x96b0
movq %rbx, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/hash_map.hpp
// Function: cybozu::hash_map<yrmcds::memcache::object>::bucket::remove_nolock(cybozu::hash_key const&, std::function<void (cybozu::hash_key const&)> const&)
bool remove_nolock(const hash_key& key,
                           const std::function<void(const hash_key&)>& callback) {
            for( item** p = &m_objects; *p != nullptr; p = &((*p)->next) ) {
                if( (*p)->key == key ) {
                    item* to_delete = *p;
                    *p = to_delete->next;
                    delete to_delete;
                    if( callback ) callback(key);
                    return true;
                }
            }
            return false;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x3335a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x28, %r12
movq 0x18(%rsi), %r13
movq 0x20(%rsi), %rbp
cmpq %rbp, 0x20(%r15)
jne 0x33341
movq 0x18(%r15), %rdi
cmpq %r13, %rdi
je 0x3335e
movq %r13, %rsi
movq %rbp, %rdx
callq 0x7510
testl %eax, %eax
je 0x3335e
movq %r15, %r12
movq 0x90(%r15), %rax
addq $0x90, %r12
movq %rax, %r15
testq %rax, %rax
jne 0x33323
xorl %ebp, %ebp
jmp 0x333c0
movq 0x90(%r15), %rax
movq %rax, (%r12)
movq 0x60(%r15), %rsi
testq %rsi, %rsi
je 0x3337b
leaq 0x60(%r15), %rdi
callq 0x1818e
movq $0x0, 0x60(%r15)
leaq 0x38(%r15), %rdi
callq 0x96b0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x333a0
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x7500
movl $0x98, %esi
movq %r15, %rdi
callq 0x7500
movb $0x1, %bpl
cmpq $0x0, 0x10(%rbx)
je 0x333c0
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/Sales_data.cc
// Function: operator>>(std::istream&, Sales_data&)
istream& operator>>(istream& is, Sales_data& item)
{
	double price;  // no need to initialize; we'll read into price before we use it
	is >> item.bookNo >> item.units_sold >> price;
	if (is)        // check that the inputs succeeded
		item.revenue = item.units_sold * price;
	else
		item = Sales_data(); // input failed: give the object the default state
	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2190
leaq 0x20(%r14), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x35ab
leaq -0x50(%rbp), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movl $0x0, 0x10(%r13)
leaq -0x60(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
movupd 0x20(%r12), %xmm0
movupd %xmm0, (%r15)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x35bf
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x35bf
movl 0x20(%r14), %eax
cvtsi2sd %rax, %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: isComplexVariant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isComplexVariant(string r, string a){
    if(r.length() > 1 && a.length() > 1){
        if(r.at(1) != a.at(1)){
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x2, 0x8(%rdi)
jb 0x3d89
cmpq $0x2, 0x8(%rsi)
jb 0x3d89
movq (%rdi), %rax
movb 0x1(%rax), %cl
movq (%rsi), %rdx
movb $0x1, %al
cmpb 0x1(%rdx), %cl
jne 0x3d8b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: getLeftCircularPermutation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
string getLeftCircularPermutation(string * str) {
    string s = str -> substr(1, str -> length());
    string s2(1, str -> at(0));

    s += s2;

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
movl $0x1, %edx
callq 0x3360
cmpq $0x0, 0x8(%r14)
je 0x3dfd
movq (%r14), %rax
movsbl (%rax), %edx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x33b0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x30f0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3def
callq 0x32f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd8cd(%rip), %rdi      # 0x116d1
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x34b0
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3e27
callq 0x32f0
jmp 0x3e27
jmp 0x3e24
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3e38
callq 0x32f0
movq %r14, %rdi
callq 0x35b0