LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x249f4
movq %rcx, %r14
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
leaq 0x124ef(%rip), %rax     # 0x36e58
movq %rax, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x20(%r14), %r8
leaq 0x1251f(%rip), %rdx     # 0x36ea7
leaq 0x20(%rsp), %r15
movl $0x15e, %esi            # imm = 0x15E
movq %r15, %rdi
xorl %eax, %eax
callq 0x78a0
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 0x124a3(%rip), %rax     # 0x36e5f
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 0x23058
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x12487(%rip), %rsi     # 0x36e8f
movq %rax, %rdi
callq 0x77a0
movq 0x215a1(%rip), %rsi     # 0x45fb8
movq 0x21572(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7970
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24af7
movq %r8, %r9
movq %rcx, %r14
movl %edx, %ecx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
leaq 0x123ec(%rip), %rax     # 0x36e58
movq %rax, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x20(%r14), %r8
leaq 0x12427(%rip), %rdx     # 0x36eb2
leaq 0x20(%rsp), %r15
movl $0x15e, %esi            # imm = 0x15E
movq %r15, %rdi
xorl %eax, %eax
callq 0x78a0
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 0x123a0(%rip), %rax     # 0x36e5f
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 0x23058
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x12384(%rip), %rsi     # 0x36e8f
movq %rax, %rdi
callq 0x77a0
movq 0x2149e(%rip), %rsi     # 0x45fb8
movq 0x2146f(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7970
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24ba6
leaq 0x8(%rdi), %rax
leaq 0x12300(%rip), %rcx     # 0x36e58
movq %rcx, 0x8(%rdi)
movq $0x6, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x122ec(%rip), %rcx     # 0x36e5f
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 0x23058
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x122d5(%rip), %rsi     # 0x36e8f
movq %rax, %rdi
callq 0x77a0
movq 0x213ef(%rip), %rsi     # 0x45fb8
movq 0x213c0(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7970
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7700
leaq 0x11f41(%rip), %rsi     # 0x36fb2
movl $0x14, %edx
movq %r14, %rdi
callq 0x7580
leaq 0x21e3b(%rip), %r14     # 0x46ec0
movl (%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x11dc6(%rip), %rsi     # 0x36e5f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7580
leaq 0x11f1a(%rip), %rsi     # 0x36fc7
leaq 0x20(%rsp), %rdi
movl $0x11, %edx
callq 0x7580
movl 0x38(%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x11d8e(%rip), %rsi     # 0x36e5f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7580
leaq 0x11ef4(%rip), %rsi     # 0x36fd9
leaq 0x20(%rsp), %rdi
movl $0x15, %edx
callq 0x7580
movq 0x50(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x11d56(%rip), %rsi     # 0x36e5f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7580
leaq 0x11ed2(%rip), %rsi     # 0x36fef
leaq 0x20(%rsp), %rdi
movl $0x17, %edx
callq 0x7580
movl 0x30(%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x11d1e(%rip), %rsi     # 0x36e5f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7580
leaq 0x11eb2(%rip), %rsi     # 0x37007
leaq 0x20(%rsp), %rdi
movl $0x15, %edx
callq 0x7580
movq 0x40(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7330
leaq 0x11ce6(%rip), %rsi     # 0x36e5f
movl $0x2, %edx
movq %rax, %rdi
callq 0x7580
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x7880
movq (%rbx), %rdi
movups (%rsp), %xmm0
leaq 0x198(%rsp), %rsi
movq %rdi, (%rsi)
movups %xmm0, 0x8(%rsi)
movb $0x0, 0x18(%rsi)
callq 0x17b04
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x251cd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7510
movq 0x20dac(%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 0x2521b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7510
jmp 0x2521b
jmp 0x25218
movq %rax, %rbx
movq 0x20d5e(%rip), %rsi     # 0x45f80
leaq 0x20(%rsp), %rdi
callq 0x7260
leaq 0x90(%rsp), %rdi
callq 0x7140
movq %rbx, %rdi
callq 0x79b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x102d9(%rip), %rcx     # 0x36e86
movq %rcx, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
leaq 0x102b0(%rip), %rcx     # 0x36e70
movq %rcx, 0x18(%rdi)
movq $0x15, 0x20(%rdi)
leaq 0x1028c(%rip), %rcx     # 0x36e5f
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 0x23058
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x50, %rsp
movq 0x70(%rsp), %rax
movl 0x20(%rdx), %r10d
leaq 0x30(%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), %r10
movl %esi, (%r10)
leaq 0x10(%rdi), %rcx
movq %r11, 0x10(%rdi)
movq $0x18, 0x18(%rdi)
movq %r10, 0x20(%rdi)
movq $0x4, 0x28(%rdi)
testq %r9, %r9
je 0x27435
movq %r9, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq (%rdx), %rax
movq 0x20(%rdx), %rdx
movq %rax, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movq (%rdi), %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, (%rsi)
jmp 0x27452
movq (%rdx), %rax
movq 0x20(%rdx), %rdx
movq %rax, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq (%rdi), %rdi
leaq 0x10(%rsp), %rsi
movl $0x3, (%rsi)
movq %rdi, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movb %r8b, 0x18(%rsi)
callq 0x23058
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsp, %rax
movb $-0x7f, (%rax)
movq 0x8(%rdi), %rcx
movb 0x1a(%rcx), %r8b
movb %r8b, 0x1(%rax)
movl %edx, %r8d
rolw $0x8, %r8w
movw %r8w, 0x2(%rax)
movl $0x0, 0x4(%rax)
movzwl %dx, %r8d
bswapl %r8d
movl %r8d, 0x8(%rax)
movq (%rcx), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq $0x0, 0x10(%rax)
leaq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movq $0x18, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq (%rdi), %rdi
leaq 0x18(%rsp), %rsi
movl $0x2, (%rsi)
movq %rdi, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movb $0x0, 0x18(%rsi)
callq 0x23058
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rsp, %rax
movb $-0x7f, (%rax)
movq 0x8(%rdi), %rcx
movb 0x1a(%rcx), %r8b
movb %r8b, 0x1(%rax)
movl $0x0, 0x2(%rax)
movw $0x0, 0x6(%rax)
movl $0x8000000, 0x8(%rax)   # imm = 0x8000000
movq (%rcx), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
bswapq %rdx
bswapq %rsi
movq %rdx, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq (%rdi), %rdi
leaq 0x28(%rsp), %rsi
movq %rdi, (%rsi)
movq %rax, 0x8(%rsi)
movq $0x20, 0x10(%rsi)
movb $0x1, 0x18(%rsi)
callq 0x17b04
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4bd2(%rip), %xmm0     # 0x36e70
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 0x17b04
addq $0x58, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76f0
movq (%r12), %r12
xorq %r12, %r15
xorl %ebp, %ebp
orq %rax, %r15
je 0x32345
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x3231b
callq 0x7040
cmpl $0x22, (%rax)
je 0x32345
movzbl (%r12), %eax
cmpq $0x20, %rax
ja 0x32345
movabsq $0x100002400, %rcx      # imm = 0x100002400
btq %rax, %rcx
jae 0x32345
movq %r14, %rax
shrq $0x20, %rax
jne 0x32345
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_O1/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 0x32aa2
cmpq %r14, %r13
je 0x32b60
movq %r14, %rdx
subq %r15, %rdx
movq %r13, %rdi
movl $0x20, %esi
callq 0x7550
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 0x32aea
cmpq %r14, %r15
je 0x32b49
movq %r14, %r13
subq %r12, %r13
movq %r15, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7550
movq %rax, %rcx
subq %r12, %rcx
testq %rax, %rax
cmoveq %r13, %rcx
cmpq $0x7, %rcx
jne 0x32b60
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r15), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r15), %edx
orl %ecx, %edx
jne 0x32b60
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x32b4c
cmpq %r14, %r15
jne 0x32b60
movb $0x1, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq %rsi, %r15
decq %r15
incq %r14
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x32dab
cmpq %r12, %r15
je 0x32e7e
movq %r12, %rdx
subq %r14, %rdx
incq %rdx
movq %r15, %rdi
movl $0x20, %esi
callq 0x7550
testq %rax, %rax
cmoveq %r12, %rax
movq %rax, %rcx
subq %r14, %rcx
incq %rcx
cmpq $0x8, %rcx
je 0x32e52
cmpq $0x5, %rcx
je 0x32e21
cmpq $0x3, %rcx
jne 0x32e82
movzwl (%r15), %edx
xorl $0x706f, %edx           # imm = 0x706F
movzbl 0x2(%r15), %esi
xorl $0x73, %esi
orw %dx, %si
je 0x32e6f
cmpq $0x8, %rcx
je 0x32e52
cmpq $0x5, %rcx
jne 0x32e82
movl $0x6d657469, %ecx       # imm = 0x6D657469
xorl (%r15), %ecx
movzbl 0x4(%r15), %edx
xorl $0x73, %edx
orl %ecx, %edx
je 0x32e68
movl $0x657a6973, %ecx       # imm = 0x657A6973
xorl (%r15), %ecx
movzbl 0x4(%r15), %edx
xorl $0x73, %edx
orl %ecx, %edx
je 0x32e76
addq $-0x7, %rax
cmpq %r14, %rax
jne 0x32e82
movabsq $0x73676e6974746573, %rax # imm = 0x73676E6974746573
cmpq %rax, (%r15)
jne 0x32e82
movl $0x1, %eax
jmp 0x32e7b
movl $0x2, %eax
jmp 0x32e7b
movl $0x4, %eax
jmp 0x32e7b
movl $0x3, %eax
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_O1/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 0x32ea5
cmpq %r15, %r12
je 0x32ee3
movq %r15, %rdx
subq %r14, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7550
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_O1/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 0x32f0a
cmpq %r14, %r13
je 0x32fa6
movq %r14, %rdx
subq %r15, %rdx
movq %r13, %rdi
movl $0x20, %esi
callq 0x7550
testq %rax, %rax
je 0x32fa6
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 0x32f53
cmpq %r14, %r12
je 0x32fa6
movq %r12, %rdi
movl $0x20, %esi
callq 0x7550
movq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
movq %rsp, %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x76f0
movq (%rbp), %rbp
xorq %rbp, %r12
orq %rax, %r12
jne 0x32fb5
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 0x32fc8
callq 0x7040
cmpl $0x22, (%rax)
je 0x32f9e
movzbl (%rbp), %eax
cmpq $0x20, %rax
ja 0x32f9e
movabsq $0x100002400, %rcx      # imm = 0x100002400
btq %rax, %rcx
jae 0x32f9e
movq %r13, 0x58(%rbx)
decq %r15
movq %r15, %r12
incq %r15
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x32fec
cmpq %r14, %r12
je 0x33057
movq %r14, %r13
subq %r15, %r13
movq %r12, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7550
movq %rax, %rcx
subq %r15, %rcx
testq %rax, %rax
cmoveq %r13, %rcx
cmpq $0x7, %rcx
jne 0x32fa6
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r12), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r12), %edx
orl %ecx, %edx
jne 0x32fa6
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x3305a
cmpq %r14, %r12
jne 0x32fa6
movb $0x1, 0x1c(%rbx)
jmp 0x32fa6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33091
cmpq %r14, %r12
je 0x330e4
movq %r14, %rdx
subq %r15, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7550
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 0x330d1
cmpq %r14, %rax
jne 0x330e4
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3310b
cmpq %r15, %r12
je 0x33145
movq %r15, %rdx
subq %r14, %rdx
movq %r12, %rdi
movl $0x20, %esi
callq 0x7550
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_O1/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 0x17c58
movb $0x1, 0x8(%r15)
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %r8
callq 0x20820
testb %al, %al
je 0x3322f
movb $0x1, 0xa0(%rbx)
movq 0x70(%rbx), %rax
cmpq 0x78(%rbx), %rax
jne 0x33233
movq 0x90(%rbx), %rax
cmpq %rax, 0x88(%rbx)
jne 0x33233
movq %rbx, %rdi
movl %ebp, %esi
callq 0x17c04
xorl %ebx, %ebx
jmp 0x3324e
leaq 0x8(%rsp), %rdi
callq 0x17c94
addq $0xd0, %rbx
movq %rbx, %rdi
callq 0x7950
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x17c42
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17c42
movq %rbx, %rdi
callq 0x79b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x30(%rdx), %rax
leaq 0x28(%rdx), %rsi
leaq 0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rsi, %rdi
movl (%rdi), %esi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movzwl %cx, %edi
rolw $0x8, %cx
movw $0x1180, 0x10(%rsp)     # imm = 0x1180
movw %cx, 0x12(%rsp)
movb $0x8, 0x14(%rsp)
leal (%rdi,%rsi), %ecx
addl $0x8, %ecx
bswapl %ecx
movl %ecx, 0x18(%rsp)
movl 0x38(%rdx), %ecx
bswapl %ecx
movl %ecx, 0x8(%rsp)
movl 0x40(%rdx), %ecx
bswapl %ecx
movl %ecx, 0xc(%rsp)
leaq 0x90(%rsp), %rsi
movq %rax, 0x20(%rsi)
movaps %xmm0, (%rsi)
movups %xmm0, 0x9(%rsi)
movq %rdx, %rdi
callq 0x1f998
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 0x3339c
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 0x23058
addq $0x8, %r15
cmpq %r12, %r15
jne 0x33372
leaq 0x90(%rsp), %rdi
callq 0x96e2
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x333bc
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x96e2
movq %rbx, %rdi
callq 0x79b0
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
testq %r12, %r12
setne %bl
je 0x33e9e
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, (%rsp)
addq $0x28, %r13
movq 0x18(%rsi), %rbp
movq 0x20(%rsi), %r14
movq 0x20(%r12), %rdx
cmpq %r14, %rdx
jne 0x33e1b
movq 0x18(%r12), %rdi
cmpq %rbp, %rdi
je 0x33e37
movq %rbp, %rsi
callq 0x7520
testl %eax, %eax
je 0x33e37
movq %r12, %r13
movq 0x90(%r12), %r12
addq $0x90, %r13
testq %r12, %r12
setne %bl
jne 0x33dfb
jmp 0x33e9e
movq 0x90(%r12), %rax
movq %rax, (%r13)
movq 0x60(%r12), %rsi
testq %rsi, %rsi
je 0x33e57
leaq 0x60(%r12), %rdi
callq 0x18286
movq $0x0, 0x60(%r12)
leaq 0x38(%r12), %rdi
callq 0x96e2
movq (%r12), %rdi
testq %rdi, %rdi
je 0x33e80
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x7510
movl $0x98, %esi
movq %r12, %rdi
callq 0x7510
movq (%rsp), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x33e9e
movq %r15, %rsi
callq *0x18(%rdi)
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./debug_rep.h
// Function: debug_rep(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string debug_rep(const std::string& s)
{
#ifdef DEBUG
	std::cout << "const string &" << "\t";
#endif
	return '"' + s + '"';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3aea(%rip), %r15      # 0x5fd0
leaq 0x1b17(%rip), %rsi      # 0x4004
movl $0xe, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x1b12(%rip), %rsi      # 0x4013
movl $0x1, %edx
movq %r15, %rdi
callq 0x2170
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movl $0x22, %esi
movq %r14, %rdx
callq 0x2a87
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x2240
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x255d
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x2563
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2593
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25bd
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b7
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r13
movaps %xmm0, -0x10(%r13)
movaps %xmm0, (%r13)
movaps %xmm0, 0x10(%r13)
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
movl $0x0, 0x10(%r13)
movq %rax, 0x18(%r13)
leaq -0x60(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
movapd 0x20(%r12), %xmm0
movupd %xmm0, (%r15)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x35cb
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x35cb
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_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/Sales_data.cc
// Function: read(std::istream&, Sales_data&)
istream& read(istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
movq $0x0, (%r15)
callq 0x2190
leaq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movq %r15, %rsi
callq 0x20c0
movl 0x20(%rbx), %eax
cvtsi2sd %rax, %xmm0
mulsd (%r15), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/utility.h
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<string> split(const string &s, char delim, vector<string> &elems) {
    stringstream ss(s);
    string item;
    while (getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %rbx
leaq -0x1d0(%rbp), %r15
movq %r15, %rdi
movl $0x18, %edx
callq 0x3500
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %r12b, %r12d
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x3610
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3995
movq %r14, %rdi
movq %r13, %rsi
callq 0x87da
jmp 0x396c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8826
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x39b2
callq 0x32f0
movq 0x125ef(%rip), %rsi     # 0x15fa8
leaq -0x1d0(%rbp), %rdi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39e8
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x39fd
callq 0x32f0
movq 0x125a4(%rip), %rsi     # 0x15fa8
leaq -0x1d0(%rbp), %rdi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d9c
cmpq $0x2, 0x8(%rsi)
jb 0x3d9c
movq (%rdi), %rax
movb 0x1(%rax), %cl
movq (%rsi), %rdx
movb $0x1, %al
cmpb 0x1(%rdx), %cl
jne 0x3d9e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x3e12
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 0x3e04
callq 0x32f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd8f2(%rip), %rdi      # 0x1170b
xorl %esi, %esi
xorl %eax, %eax
callq 0x34b0
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3e3a
callq 0x32f0
jmp 0x3e3a
jmp 0x3e37
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3e4b
callq 0x32f0
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: getRightCircularPermutation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
string getRightCircularPermutation(string * str) {
    string s(1, str -> at(str -> length() - 1));
    string s2 = str -> substr(0, str -> length() - 1);

    s += s2;

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rdx
movq %rdx, %rsi
subq $0x1, %rsi
jb 0x3ed0
movq %rdi, %rbx
movq (%r14), %rax
movsbl (%rax,%rsi), %edx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movl $0x1, %esi
callq 0x33b0
movq 0x8(%r14), %rcx
decq %rcx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3360
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x30f0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ec2
callq 0x32f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd834(%rip), %rdi      # 0x1170b
xorl %eax, %eax
callq 0x34b0
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ef8
callq 0x32f0
jmp 0x3ef8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3f05
callq 0x32f0
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/src/ups_indel.cpp
// Function: cleanup()
int cleanup() {
    string remove_temp_vcf_files_command =
        "rm " + input_file_base_name + ".*.vcf";

	if (system(remove_temp_vcf_files_command.c_str()) < 0)
		return 1;

    string remove_temp_uvcf_files_command =
        "rm " + output_file_name + ".*.uvcf";

	if (system(remove_temp_uvcf_files_command.c_str()) < 0)
		return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x8ee6(%rip), %rsi      # 0x111ea
leaq 0xe0b5(%rip), %rdx      # 0x163c0
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x8c80
leaq 0x8ed0(%rip), %rsi      # 0x111ee
movq %rbx, %rdi
callq 0x3640
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x834a
movq %rdx, -0x58(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x48(%rbp)
jmp 0x8351
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -0x50(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x28(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x837a
callq 0x32f0
movq -0x58(%rbp), %rdi
callq 0x32c0
testl %eax, %eax
js 0x83ce
leaq 0x8e5c(%rip), %rsi      # 0x111ea
leaq 0xe04b(%rip), %rdx      # 0x163e0
leaq -0x78(%rbp), %rdi
callq 0x8c80
leaq 0x8e50(%rip), %rsi      # 0x111f5
leaq -0x78(%rbp), %rdi
callq 0x3640
movq %r15, -0x38(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x83d5
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x83dc
movl $0x1, %ebx
jmp 0x8421
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0x30(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8405
callq 0x32f0
movq -0x38(%rbp), %rdi
callq 0x32c0
movl %eax, %ebx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x841e
callq 0x32f0
shrl $0x1f, %ebx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x842f
callq 0x32f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x845a
jmp 0x8466
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8466
callq 0x32f0
jmp 0x8466
jmp 0x8463
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x8474
callq 0x32f0
movq %rbx, %rdi
callq 0x35b0
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x846f
jmp 0x8474
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/seqan/basic/debug_test_system.h
// Function: seqan::ClassTest::forceFail(char const*, int, char const*, ...)
inline void forceFail(const char * file, int line,
                      const char * comment, ...)
{
    StaticData::errorCount() += 1;
    std::cerr << file << ":" << line << " FAILED! ";
    if (comment)
    {
        std::cerr << " (";
        va_list args;
        va_start(args, comment);
        vfprintf(stderr, comment, args);
        va_end(args);
        std::cerr << ")";
    }
    std::cerr << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movl %esi, %r15d
testb %al, %al
je 0x8db2
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
incl 0xd633(%rip)            # 0x16400
testq %rdi, %rdi
je 0x8dee
movq %rdi, %r14
callq 0x3170
movq 0xd20f(%rip), %rdi      # 0x15ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x33a0
jmp 0x8e0c
movq 0xd1fb(%rip), %rax      # 0x15ff0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x3560
movq 0xd1dd(%rip), %r14      # 0x15ff0
leaq 0x84a2(%rip), %rsi      # 0x112bc
movl $0x1, %edx
movq %r14, %rdi
callq 0x33a0
movq %r14, %rdi
movl %r15d, %esi
callq 0x3570
leaq 0x8485(%rip), %rsi      # 0x112be
movl $0x9, %edx
movq %rax, %rdi
callq 0x33a0
testq %rbx, %rbx
jne 0x8e80
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3310
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3220
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd169(%rip), %r15      # 0x15ff0
leaq 0x856b(%rip), %rsi      # 0x113f9
movl $0x2, %edx
movq %r15, %rdi
callq 0x33a0
leaq -0xe0(%rbp), %rax
leaq -0x30(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq 0xd10a(%rip), %rax      # 0x15fd0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3440
leaq 0x866c(%rip), %rsi      # 0x11544
movl $0x1, %edx
movq %r15, %rdi
callq 0x33a0
jmp 0x8e4b
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/seqan/system/file_async.h
// Function: seqan::File<seqan::Async<void>>::close()
bool close() {
			bool result = true;
			if (handleAsync != handle && handleAsync != -1)
	            result &= (::close(handleAsync) == 0);
            result &= (::close(handle) == 0);
            handleAsync = -1;
            handle = -1;
			SEQAN_PROSUB(SEQAN_PROOPENFILES, 1);
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rdi), %edi
movb $0x1, %r14b
cmpl $-0x1, %edi
je 0xa589
cmpl 0x8(%rbx), %edi
je 0xa589
callq 0x3660
testl %eax, %eax
sete %r14b
movl 0x8(%rbx), %edi
callq 0x3660
testl %eax, %eax
sete %al
andb %r14b, %al
movq $-0x1, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mshabbirhasan[P]ups-indel/include/seqan/system/file_sync.h
// Function: seqan::File<seqan::Sync<void>>::close()
virtual bool close() {
            if (::close(this->handle) == -1) return false;
            handle = -1;
			SEQAN_PROSUB(SEQAN_PROOPENFILES, 1);
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
callq 0x3660
cmpl $-0x1, %eax
je 0xa7ab
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq