// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/memcache/memcache.cpp
// Function: yrmcds::memcache::text_request::parse_storage(char const*, char const*, bool)
inline void
text_request::parse_storage(const char* b, const char* e, bool is_cas) 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* flags_end = cfind(b, SP, e-b);
    if( flags_end == nullptr ) return;
    bool result;
    m_flags = to_uint<std::uint32_t>(b, result);
    if( ! result ) return;
    b = flags_end;

    while( *b == SP ) ++b;
    if( b == e ) return;
    const char* exptime_end = cfind(b, SP, e-b);
    if( exptime_end == nullptr ) return;
    std::time_t t = to_uint<std::time_t>(b, result);
    if( ! result ) return;
    if( t != 0 )
        m_exptime = (t > EXPTIME_THRESHOLD) ? t :
            (g_current_time.load(relaxed) + t);
    b = exptime_end;

    while( *b == SP ) ++b;
    if( b == e ) return;
    std::uint32_t nbytes = to_uint<std::uint32_t>(b, result);
    if( ! result ) return;
    const char* bytes_end = cfind(b, SP, e-b);
    b = (bytes_end == nullptr) ? e : bytes_end;

    if( is_cas ) {
        while( *b == SP ) ++b;
        if( b == e ) return;
        m_cas_unique = to_uint<std::uint64_t>(b, result);
        if( ! result ) return;
        const char* cas_end = cfind(b, SP, e-b);
        b = (cas_end == nullptr) ? e : cas_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

    // here, parsing was successful.  check data length.
    b += 2; // CRLF
    m_request_len = (b - m_p) + nbytes + 2;
    if( m_len < m_request_len ) {
        m_request_len = 0;
        return;
    }

    // check CRLF following the data
    if( *(b+nbytes) != CR || *(b+nbytes+1) != LF )
        return;

    // passed all checks.
    m_data = item(b, nbytes);
    m_valid = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
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 0x31da7
cmpq %r14, %r13
je 0x31e80
movq %r14, %rdx
subq %r15, %rdx
movq %r13, %rdi
movl $0x20, %esi
callq 0x7540
testq %rax, %rax
je 0x31e80
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 0x31df4
cmpq %r14, %r12
je 0x31e80
movq %r12, %rdi
movl $0x20, %esi
callq 0x7540
testq %rax, %rax
je 0x31e80
movq %rax, %r15
movl %ebp, 0xc(%rsp)
leaq 0x10(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x76e0
movq (%rbp), %rbp
xorq %rbp, %r12
orq %rax, %r12
je 0x31e79
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x31e56
callq 0x7040
cmpl $0x22, (%rax)
je 0x31e79
movzbl (%rbp), %eax
cmpq $0x20, %rax
ja 0x31e79
movabsq $0x100002400, %rbp      # imm = 0x100002400
btq %rax, %rbp
jae 0x31e79
movq %r13, %rax
shrq $0x20, %rax
je 0x31e8f
movl $0x0, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, 0x30(%rbx)
movq %r14, %rdx
subq %r15, %rdx
decq %r15
incq %rdx
decq %rdx
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0x31e9f
cmpq %r14, %r15
je 0x31e80
movq %r15, %rdi
movl $0x20, %esi
callq 0x7540
testq %rax, %rax
je 0x31e80
movq %rax, %r12
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x76e0
movq (%r13), %r13
xorq %r13, %r15
orq %rax, %r15
je 0x31e80
movq %rax, %rcx
cmpq $-0x1, %rax
jne 0x31f05
movq %rcx, %r15
callq 0x7040
movq %r15, %rcx
cmpl $0x22, (%rax)
je 0x31e80
movzbl (%r13), %eax
cmpq $0x20, %rax
ja 0x31e80
btq %rax, %rbp
jae 0x31e80
testq %rcx, %rcx
js 0x31e80
movb $0x1, 0xb(%rsp)
je 0x31f48
cmpq $0x278d00, %rcx         # imm = 0x278D00
ja 0x31f44
leaq 0x14f42(%rip), %rax     # 0x46e80
movq (%rax), %rax
addq %rax, %rcx
movq %rcx, 0x38(%rbx)
movq %r14, %r13
subq %r12, %r13
decq %r12
incq %r13
decq %r13
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x31f54
cmpq %r14, %r12
je 0x31e80
leaq 0xb(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x319b7
cmpb $0x1, (%rbp)
jne 0x31e80
movl %eax, %r15d
movq %r12, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7540
movq %rax, %r12
testq %rax, %rax
cmoveq %r14, %r12
cmpb $0x0, 0xc(%rsp)
je 0x32008
movq %r14, %r13
subq %r12, %r13
decq %r12
incq %r13
decq %r13
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x31fb7
cmpq %r14, %r12
je 0x31e80
leaq 0xb(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x31a38
movq %rax, 0x40(%rbx)
cmpb $0x1, (%rbp)
jne 0x31e80
movq %r12, %rdi
movl $0x20, %esi
movq %r13, %rdx
callq 0x7540
movq %rax, %r12
testq %rax, %rax
cmoveq %r14, %r12
decq %r12
movq %r12, %r13
incq %r12
cmpb $0x20, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x3200e
cmpq %r14, %r13
je 0x32076
movq %r14, %rbp
subq %r12, %rbp
movq %r13, %rdi
movl $0x20, %esi
movq %rbp, %rdx
callq 0x7540
movq %rax, %rcx
subq %r12, %rcx
testq %rax, %rax
cmoveq %rbp, %rcx
cmpq $0x7, %rcx
jne 0x31e80
movl $0x65726f6e, %ecx       # imm = 0x65726F6E
xorl (%r13), %ecx
movl $0x796c7065, %edx       # imm = 0x796C7065
xorl 0x3(%r13), %edx
orl %ecx, %edx
jne 0x31e80
testq %rax, %rax
movb $0x1, 0x1d(%rbx)
cmoveq %r14, %rax
movq %rax, %r13
movq $-0x3, %rax
subq %r13, %rax
decq %r13
decq %rax
cmpb $0x20, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x32083
cmpq %r14, %r13
jne 0x31e80
movl %r15d, %ecx
movq %rcx, %rdx
subq (%rbx), %rdx
subq %rax, %rdx
movq %rdx, 0x10(%rbx)
cmpq %rdx, 0x8(%rbx)
jae 0x320bd
movq $0x0, 0x10(%rbx)
jmp 0x31e80
cmpb $0xd, 0x2(%r13,%rcx)
jne 0x31e80
cmpb $0xa, 0x3(%r13,%rcx)
jne 0x31e80
addq $0x2, %r13
movq %r13, 0x50(%rbx)
movq %rcx, 0x48(%rbx)
movb $0x1, 0x1c(%rbx)
jmp 0x31e80