LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::missingArgsException()
inline void CmdLine::missingArgsException()
{
		int count = 0;

		std::string missingArgList;
		for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
		{
			if ( (*it)->isRequired() && !(*it)->isSet() )
			{
				missingArgList += (*it)->getName();
				missingArgList += ", ";
				count++;
			}
		}
		missingArgList = missingArgList.substr(0,missingArgList.length()-2);

		std::string msg;
		if ( count > 1 )
			msg = "Required arguments missing: ";
		else
			msg = "Required argument missing: ";

		msg += missingArgList;

		throw(CmdLineParseException(msg));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rdi), %r13
addq $0x8, %rbx
xorl %ebp, %ebp
cmpq %rbx, %r13
jne 0x967b
movq $-0x2, %rcx
jmp 0x96e1
leaq 0x28(%rsp), %r14
leaq 0x1c58(%rip), %r15      # 0xb2df
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x96c8
movq 0x10(%r13), %rax
cmpb $0x1, 0x91(%rax)
jne 0x96ab
cmpb $0x1, 0xa1(%rax)
jne 0x96c8
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %r14, %rdi
callq 0x3080
movq %r14, %rdi
movq %r15, %rsi
callq 0x3340
incl %ebp
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x9687
movq 0x30(%rsp), %rcx
addq $-0x2, %rcx
cmpl $0x2, %ebp
setge %bpl
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x31e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3230
movq (%rbx), %rdi
leaq 0x18(%rsp), %r15
cmpq %r15, %rdi
je 0x971e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1ba9(%rip), %rax      # 0xb2e2
leaq 0x1bbf(%rip), %rcx      # 0xb2ff
testb %bpl, %bpl
cmovneq %rax, %rcx
movzbl %bpl, %r8d
addq $0x1b, %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0x3280
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x3080
movl $0x68, %edi
callq 0x30e0
movq %rax, %rbx
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1b4c(%rip), %rsi      # 0xb2d5
leaq 0x1b4e(%rip), %rdx      # 0xb2de
leaq 0x48(%rsp), %rdi
callq 0x6ef2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x3d26
xorl %ebp, %ebp
leaq 0x51c0(%rip), %rsi      # 0xe978
leaq 0x849(%rip), %rdx       # 0xa008
movq %rbx, %rdi
callq 0x32e0
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x97e1
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
jne 0x97eb
jmp 0x97f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
jmp 0x97f8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9816
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x9816
jmp 0x9813
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x982d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %r14, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/test11.cpp
// Function: Vect3D::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Vect3D& operator=(const std::string &str)
    {
	std::istringstream iss(str);
	if (!(iss >> v[0] >> v[1] >> v[2]))
	    throw TCLAP::ArgParseException(str + " is not a 3D vector");

	return *this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x32d0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3120
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3120
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x3120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xa403
movq 0x4bed(%rip), %rsi      # 0xefc8
leaq 0x48(%rsp), %rdi
callq 0x3250
leaq 0xc0(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x68, %edi
callq 0x30e0
movq %rax, %rbx
leaq 0xfb9(%rip), %rdx       # 0xb3d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x733f
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xea1(%rip), %rsi       # 0xb2d5
leaq 0xea3(%rip), %rdx       # 0xb2de
leaq 0x28(%rsp), %rdi
callq 0x6ef2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x9e3e
xorl %ebp, %ebp
leaq 0x48fd(%rip), %rsi      # 0xed60
leaq -0x462(%rip), %rdx      # 0xa008
movq %rbx, %rdi
callq 0x32e0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xa48c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
jne 0xa4d1
jmp 0xa4de
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0xa4d1
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
jmp 0xa4de
movq %rax, %r14
movq 0x4ae3(%rip), %rsi      # 0xefc8
leaq 0x48(%rsp), %rdi
callq 0x3250
leaq 0xc0(%rsp), %rdi
callq 0x3090
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/ArgException.h
// Function: TCLAP::ArgException::argId[abi:cxx11]() const
std::string argId() const  
		{ 
			if ( _argId == "undefined" )
				return " ";
			else
				return ( "Argument: " + _argId ); 
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %r14
leaq 0xd62(%rip), %rsi       # 0xb2d5
movq %r14, %rdi
callq 0x3070
testl %eax, %eax
je 0xa593
leaq 0xecd(%rip), %rsi       # 0xb453
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7a24
jmp 0xa5b0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xe77(%rip), %rsi       # 0xb418
leaq 0xe71(%rip), %rdx       # 0xb419
movq %rbx, %rdi
callq 0x6ef2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/logger.hpp
// Function: cybozu::logger::close_nolock()
void close_nolock() {
        if( m_fd == -1 || m_fd == STDERR_FILENO ) return;
        fsync(m_fd);
        ::close(m_fd);
        m_fd = -1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $-0x1, %edi
je 0x950e
cmpl $0x2, %edi
je 0x950e
callq 0x7430
movl (%rbx), %edi
callq 0x7a80
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/dynbuf.hpp
// Function: cybozu::dynbuf::~dynbuf()
~dynbuf() {
        if( m_p != nullptr ) {
            if( m_erase )
                clear_memory(m_p, m_used);
            _free(m_p);
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x96db
cmpb $0x1, 0x18(%rbx)
jne 0x96d5
leaq 0x3bc6f(%rip), %rax     # 0x45338
movq (%rax), %rax
movq 0x20(%rbx), %rsi
callq *%rax
movq (%rbx), %rdi
popq %rbx
jmp 0x75a0
popq %rbx
retq
movq %rax, %rdi
callq 0x8f80
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/filesystem.cpp
// Function: cybozu::get_stat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, stat&)
bool get_stat(const std::string& path, struct stat& st) {
    if( ::stat(path.c_str(), &st) == 0 )
        return true;
    if( errno == EFAULT || errno == ENOMEM )
        throw_unix_error(errno, "stat");
    auto ec = std::system_category().default_error_condition(3);
    logger::debug() << "stat failed. path="
                    << path << ", error=" << ec.message()
                    << " (" << errno << ")";
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x7460
movl %eax, %ebx
testl %eax, %eax
je 0x9cca
callq 0x7040
movq %rax, %r14
movl (%rax), %edi
movl %edi, %eax
orl $0x2, %eax
cmpl $0xe, %eax
je 0x9cde
callq 0x72e0
movq (%rax), %rcx
movq %rax, %rdi
movl $0x3, %esi
callq *0x28(%rcx)
movl %eax, %ebp
movq %rdx, %r15
leaq 0x3ced6(%rip), %rax     # 0x46a88
movl (%rax), %eax
xorl %esi, %esi
cmpl $0x3, %eax
setge %sil
leaq 0x2a683(%rip), %rdx     # 0x34247
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x96e6
movb (%r13), %al
cmpb $0x1, %al
jne 0x9bf3
movq 0x10(%rsp), %rdi
leaq 0x2a646(%rip), %rsi     # 0x3422b
movl $0x12, %edx
callq 0x7570
movb 0x8(%rsp), %al
testb $0x1, %al
je 0x9c0e
movq 0x10(%rsp), %rdi
movq (%r12), %rsi
movq 0x8(%r12), %rdx
callq 0x7570
movb 0x8(%rsp), %al
testb $0x1, %al
je 0x9c28
movq 0x10(%rsp), %rdi
leaq 0x2a620(%rip), %rsi     # 0x3423e
movl $0x8, %edx
callq 0x7570
movq (%r15), %rax
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq *0x20(%rax)
movb 0x8(%rsp), %al
cmpb $0x1, %al
jne 0x9c58
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x7570
movb 0x8(%rsp), %al
testb $0x1, %al
je 0x9c76
movq 0x10(%rsp), %rdi
leaq 0x2cb9f(%rip), %rsi     # 0x36807
movl $0x2, %edx
callq 0x7570
movb 0x8(%rsp), %al
testb $0x1, %al
je 0x9c8b
movq 0x10(%rsp), %rdi
movl (%r14), %esi
callq 0x7980
movb 0x8(%rsp), %al
testb $0x1, %al
je 0x9ca5
movq 0x10(%rsp), %rdi
leaq 0x2b154(%rip), %rsi     # 0x34def
movl $0x1, %edx
callq 0x7570
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cc0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7500
leaq 0x8(%rsp), %rdi
callq 0x8f4e
testl %ebx, %ebx
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a541(%rip), %rsi     # 0x34226
callq 0x8d8d
jmp 0x9cec
movq %rax, %rbx
jmp 0x9d0f
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d0f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7500
leaq 0x8(%rsp), %rdi
callq 0x8f4e
movq %rbx, %rdi
callq 0x79a0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logstream::add_prefix(char const*)
void logstream::add_prefix(const char* level) {
    char buf[64];
    std::time_t t = std::time(nullptr);
    std::tm ct;
    // beware that std::gmtime is not thread-safe.
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %T ", ::gmtime_r(&t, &ct));
    *m_os << buf << level << " ";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x7490
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %rsi
callq 0x7a90
leaq 0x2a4f9(%rip), %rdx     # 0x3424d
leaq 0x40(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
movq %rax, %rcx
callq 0x73f0
movq 0x8(%r14), %r14
movq %r15, %rdi
callq 0x71b0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7570
testq %rbx, %rbx
je 0x9da0
movq %rbx, %rdi
callq 0x71b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7570
jmp 0x9db8
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x7930
leaq 0x2a314(%rip), %rsi     # 0x340d3
movl $0x1, %edx
movq %r14, %rdi
callq 0x7570
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logstream::output()
void logstream::output() {
    if( m_os.get() == nullptr ) return;
    *m_os << "\n";
    logger::instance().log(m_os->str());
    m_os.reset(nullptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x9e58
leaq 0x2d06a(%rip), %rsi     # 0x36e60
movl $0x1, %edx
callq 0x7570
callq 0x8de6
movq %rax, %r14
movq 0x8(%rbx), %rsi
addq $0x8, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x7870
movq %r14, %rdi
movq %r15, %rsi
callq 0x9e88
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e41
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7500
movq 0x8(%rbx), %rdi
movq $0x0, 0x8(%rbx)
testq %rdi, %rdi
je 0x9e58
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7500
movq %rbx, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logger::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void logger::log(const std::string& msg) {
    lock_guard g(m_lock);
    std::size_t to_write = msg.size();
    const char* ptr = msg.data();
    while( to_write != 0 ) {
        ssize_t n = ::write(m_fd, ptr, to_write);
        if( n == -1 ) {
            if( errno == EAGAIN || errno == EINTR ) continue;
            throw_unix_error(errno, "<logger::log> write");
        }
        ptr += n;
        to_write -= n;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x77d0
testl %eax, %eax
jne 0x9f05
movq 0x8(%r12), %r15
testq %r15, %r15
je 0x9ee6
movq (%r12), %r12
movl (%r14), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7150
cmpq $-0x1, %rax
je 0x9ed0
addq %rax, %r12
subq %rax, %r15
jmp 0x9ee1
callq 0x7040
movl (%rax), %edi
cmpl $0x4, %edi
je 0x9ee1
cmpl $0xb, %edi
jne 0x9ef9
testq %r15, %r15
jne 0x9eb4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x73c0
leaq 0x2a37c(%rip), %rsi     # 0x3427c
callq 0x8d8d
movl %eax, %edi
callq 0x7320
jmp 0x9f0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x73c0
movq %r14, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logger::open_nolock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void logger::open_nolock(const std::string& path) {
    if( m_fd != -1 && m_fd != STDERR_FILENO )
        throw std::logic_error("<logger::open> double open.");
    m_fd = ::open(path.c_str(), O_WRONLY|O_APPEND|O_CREAT, 0644);
    if( m_fd == -1 ) {
        m_fd = STDERR_FILENO;
        throw_unix_error(errno, ("open(" + path + ")").c_str());
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $-0x1, %eax
je 0x9f3d
cmpl $0x2, %eax
jne 0x9fb9
movq (%r14), %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x7390
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x9f62
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x2, (%rbx)
callq 0x7040
movl (%rax), %ebx
leaq 0x2a300(%rip), %rsi     # 0x34276
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xa064
leaq 0x2ae62(%rip), %rsi     # 0x34def
movq %r15, %rdi
callq 0x7a70
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
jne 0x9feb
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
jmp 0x9ff7
movl $0x10, %edi
callq 0x7220
movq %rax, %r14
leaq 0x2a28d(%rip), %rsi     # 0x3425a
movq %rax, %rdi
callq 0x7790
movq 0x3bfdc(%rip), %rsi     # 0x45fb8
movq 0x3bfad(%rip), %rdx     # 0x45f90
movq %r14, %rdi
callq 0x7960
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl %ebx, %edi
callq 0x8d8d
movq %rax, %rbx
movq %r14, %rdi
callq 0x7370
jmp 0xa05c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xa041
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7500
jmp 0xa041
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa05c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7500
movq %rbx, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::resource::invalidate_and_close_()
void resource::invalidate_and_close_() {
    bool expected = true;
    if( ! m_valid.compare_exchange_strong(expected, false) )
        return;

    // no need to read-lock `m_lock` here because `m_fd` will not be
    // closed before this function calls `reactor::request_removal`.
    on_invalidate(m_fd);
    m_reactor->request_removal(*this);
}

// Assembly:
xorl %ecx, %ecx
movb $0x1, %al
lock
cmpxchgb %cl, 0x10(%rdi)
jne 0xa111
pushq %rbx
movq %rdi, %rbx
movl 0x50(%rdi), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xa86e
retq
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::reactor()
reactor::reactor():
    m_fd( epoll_create1(EPOLL_CLOEXEC) ), m_running(true)
{
    if( m_fd == -1 )
        throw_unix_error(errno, "epoll_create1");
    m_resources.max_load_factor(1.0);
    m_resources.reserve(100000);
    m_readables.reserve(256);
    m_readables_copy.reserve(256);
    m_drop_req.reserve(256);
    m_drop_req_copy.reserve(256);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x80000, %edi          # imm = 0x80000
callq 0x76a0
movl %eax, (%rbx)
movb $0x1, 0x4(%rbx)
leaq 0x8(%rbx), %r14
leaq 0x38(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x3f800000, 0x28(%rbx) # imm = 0x3F800000
leaq 0x40(%rbx), %r15
leaq 0x58(%rbx), %r12
leaq 0x78(%rbx), %r13
leaq 0x90(%rbx), %rbp
leaq 0xa8(%rbx), %rcx
movq %rcx, 0x10(%rsp)
leaq 0xc0(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movb $0x0, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0xb8(%rbx)
movups %xmm0, 0xc8(%rbx)
cmpl $-0x1, %eax
je 0xa21f
movl $0x3f800000, 0x28(%rbx) # imm = 0x3F800000
movq $0x0, 0x30(%rbx)
movl $0x186a0, %esi          # imm = 0x186A0
movq %r14, %rdi
callq 0xac7c
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
callq 0xa8c8
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
callq 0xa8c8
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
callq 0xa8c8
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
callq 0xa8c8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7040
movl (%rax), %edi
leaq 0x2a08b(%rip), %rsi     # 0x342b8
callq 0x8d8d
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xa964
movq 0x10(%rsp), %rdi
callq 0xa964
movq (%rbp), %rdi
testq %rdi, %rdi
je 0xa262
movq 0xa0(%rbx), %rsi
subq %rdi, %rsi
callq 0x7500
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x7bc5
movq %r14, %rdi
callq 0xab96
movq (%rsp), %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::modify_events(cybozu::resource const&, int)
void reactor::modify_events(const resource& res, int events) {
    const int fd = res.m_fd;
    struct epoll_event ev;
    ev.events = events | EPOLLET;
    ev.data.fd = fd;
    if( epoll_ctl(m_fd, EPOLL_CTL_MOD, fd, &ev) == -1 )
        throw_unix_error(errno, "epoll_ctl");
}

// Assembly:
subq $0x18, %rsp
movl 0x50(%rsi), %eax
orl $0x80000000, %edx       # imm = 0x80000000
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movl %eax, 0x4(%rcx)
movl (%rdi), %edi
movl $0x3, %esi
movl %eax, %edx
callq 0x7710
cmpl $-0x1, %eax
je 0xa405
addq $0x18, %rsp
retq
callq 0x7040
movl (%rax), %edi
leaq 0x29eda(%rip), %rsi     # 0x342ed
callq 0x8d8d
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::run(std::function<void (cybozu::reactor&)>, int)
void reactor::run(std::function<void(reactor& r)> callback, int interval) {
    namespace crn = std::chrono;
    const int milli_interval = interval * 1000;
    auto last = crn::steady_clock::now();

    m_running = true;
    while( m_running ) {
        poll();
        auto now = crn::steady_clock::now();
        auto diff = crn::duration_cast<crn::milliseconds>(now - last).count();
        if( diff > milli_interval ) {
            callback(*this);
            last = now;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x76c0
movq %rax, %r15
movb $0x1, 0x4(%r14)
imull $0x3e8, %ebp, %eax      # imm = 0x3E8
movslq %eax, %r13
movabsq $0x431bde82d7b634db, %rbp # imm = 0x431BDE82D7B634DB
movq %r14, %rdi
callq 0xa4a2
callq 0x76c0
movq %rax, %r12
subq %r15, %rax
imulq %rbp
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
cmpq %r13, %rdx
jle 0xa487
cmpq $0x0, 0x10(%rbx)
je 0xa49d
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rbx)
movq %r12, %r15
cmpb $0x0, 0x4(%r14)
jne 0xa44b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7170
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::remove_resource(int)
void reactor::remove_resource(int fd) {
    resource_map::iterator it = m_resources.find(fd);
    if( it == m_resources.end() ) {
        dump_stack();
        throw std::logic_error("bug in remove_resource");
    }
    auto res = it->second.get();
    m_garbage.emplace_back( std::move(it->second) );
    m_resources.erase(it);
    if( epoll_ctl(m_fd, EPOLL_CTL_DEL, fd, NULL) == -1 )
        throw_unix_error(errno, "epoll_ctl(EPOLL_CTL_DEL)");
    m_readables.erase(std::remove(m_readables.begin(), m_readables.end(), fd),
                      m_readables.end());

    if( ! res->try_close() ) {
        logger::debug() << "failed to close fd (will be closed later): " << fd;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x8(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xb01a
testq %rax, %rax
je 0xa801
movq %rax, %r12
movq %rax, %rsi
addq $0x10, %rsi
movq 0x10(%rax), %r14
leaq 0xa8(%rbx), %rdi
callq 0xa9b8
movq %r15, %rdi
movq %r12, %rsi
callq 0xb1d2
movl (%rbx), %edi
movl 0x4(%rsp), %edx
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x7710
cmpl $-0x1, %eax
je 0xa838
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
leaq 0x4(%rsp), %rdx
callq 0xb2a2
cmpq 0x48(%rbx), %rax
je 0xa787
movq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0xa9f6
testb %al, %al
jne 0xa7f5
leaq 0x3c2ee(%rip), %rax     # 0x46a88
movl (%rax), %eax
xorl %esi, %esi
cmpl $0x3, %eax
setge %sil
leaq 0x29a9b(%rip), %rdx     # 0x34247
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x96e6
movb (%rbx), %al
cmpb $0x1, %al
jne 0xa7d9
movq 0x10(%rsp), %rdi
leaq 0x29b5c(%rip), %rsi     # 0x34327
movl $0x2b, %edx
callq 0x7570
movb 0x8(%rsp), %al
testb $0x1, %al
je 0xa7eb
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x7980
leaq 0x8(%rsp), %rdi
callq 0x8f4e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xbb26
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x29add(%rip), %rsi     # 0x342f7
movq %rax, %rdi
callq 0x7790
movq 0x3b78f(%rip), %rsi     # 0x45fb8
movq 0x3b760(%rip), %rdx     # 0x45f90
movq %rbx, %rdi
callq 0x7960
callq 0x7040
movl (%rax), %edi
leaq 0x29ac8(%rip), %rsi     # 0x3430e
callq 0x8d8d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8f4e
jmp 0xa865
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
movq %r14, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/reactor.hpp
// Function: cybozu::resource::try_close()
bool try_close() {
        write_lock g(m_lock, std::try_to_lock);
        if( ! g ) return false;

        if( ! m_closed ) {
            ::close(m_fd);
            m_closed = true;
        }
        return true;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0x7a00
movl %eax, %ebp
cmpl $0x10, %eax
setne 0x10(%rsp)
je 0xaa2b
cmpb $0x0, 0x11(%rbx)
jne 0xaa2b
movl 0x50(%rbx), %edi
callq 0x7a80
movb $0x1, 0x11(%rbx)
cmpl $0x10, %ebp
setne %bl
leaq 0x8(%rsp), %rdi
callq 0xac3e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xac3e
movq %rbx, %rdi
callq 0x79a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/util.cpp
// Function: cybozu::demangler::demangler(char const*)
demangler::demangler(const char* name) {
    int status;
    char* demangled = abi::__cxa_demangle(name, 0, 0, &status);
    if( status == 0 ) {
        m_name = demangled;
        std::free(demangled);
    } else {
        m_name = name;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xc(%rsp), %rcx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7420
cmpl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %r12
je 0xbad3
movq %r14, %rdi
callq 0x71b0
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x7850
jmp 0xbaf9
movq %rax, %r15
movq %rax, %rdi
callq 0x71b0
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x7850
movq %r15, %rdi
callq 0x75a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xbb1e
movq (%r13), %rsi
incq %rsi
callq 0x7500
movq %r14, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/util.cpp
// Function: cybozu::dump_stack()
void dump_stack() noexcept {
    char buf[32];
    std::time_t t = std::time(nullptr);
    std::size_t len = std::strlen(ctime_r(&t, buf));
    ::write(STDERR_FILENO, buf, len);

    void* bt[100];
    int n = backtrace(bt, 100);
    backtrace_symbols_fd(bt, n, STDERR_FILENO);
}

// Assembly:
pushq %rbx
subq $0x350, %rsp            # imm = 0x350
xorl %edi, %edi
callq 0x7490
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x7590
movq %rax, %rdi
callq 0x71b0
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7150
leaq 0x30(%rsp), %rdi
movl $0x64, %esi
callq 0x77e0
leaq 0x30(%rsp), %rdi
movl %eax, %esi
movl $0x2, %edx
callq 0x7880
addq $0x350, %rsp            # imm = 0x350
popq %rbx
retq
movq %rax, %rdi
callq 0x8f80
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/cybozu/util.cpp
// Function: cybozu::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> tokenize(const std::string& s, char c) {
    auto end = s.cend();
    auto start = end;  // initially, token start position is not set.

    std::vector<std::string> v;
    for( auto it = s.cbegin(); it != end; ++it ) {
        if( *it != c ) {
            if( start == end )
                start = it;
            continue;
        }
        if( start != end ) {
            v.emplace_back(start, it);
            start = end;
        }
    }
    if( start != end )
        v.emplace_back(start, end);
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq (%rax,%rcx), %r12
movq %r12, 0x18(%rsp)
movq %r12, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rax, 0x10(%rsp)
testq %rcx, %rcx
je 0xbc4e
movl %edx, %ebp
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %r12, %rcx
movq %r12, %rdx
movq %r12, %rsi
cmpb %bpl, (%rax)
jne 0xbc17
movq %r12, %rsi
cmpq %r12, %rdx
movq %r12, %rdx
je 0xbc2a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xbc88
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %r12, %rcx
movq %r12, %rdx
movq %r12, %rsi
jmp 0xbc2a
cmpq %r12, %rsi
jne 0xbc2a
movq %rax, 0x8(%rsp)
movq %rax, %rcx
movq %rax, %rdx
movq %rax, %rsi
incq %rax
movq %rax, 0x10(%rsp)
cmpq %r12, %rax
jne 0xbbe4
cmpq %r12, %rcx
je 0xbc4e
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0xbc88
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc60
movq %rax, %r14
movq %rbx, %rdi
callq 0x903a
movq %r14, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/config.cpp
// Function: (anonymous namespace)::parse_unit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
inline std::size_t parse_unit(std::string& s, const char* cmd) {
    std::size_t base = 1;
    switch( s.back() ) {
    case 'k':
    case 'K':
        base <<= 10;
        break;
    case 'm':
    case 'M':
        base <<= 20;
        break;
    case 'g':
    case 'G':
        base <<= 30;
        break;
    }
    if( base != 1 )
        s.pop_back();
    int n = std::stoi( s );
    if( n < 1 )
        throw yrmcds::config::bad_config(cmd + std::string(" must be > 0"));
    return base * static_cast<std::size_t>(n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movzbl -0x1(%r15,%rax), %eax
movl $0x1, %r13d
addl $-0x47, %eax
cmpl $0x26, %eax
ja 0xde4b
movq %rdi, %rbx
movabsq $0x100000001, %rcx      # imm = 0x100000001
btq %rax, %rcx
jb 0xde37
movl $0x400, %r12d           # imm = 0x400
movabsq $0x1000000010, %rcx     # imm = 0x1000000010
btq %rax, %rcx
jb 0xde3d
movabsq $0x4000000040, %rcx     # imm = 0x4000000040
btq %rax, %rcx
jae 0xde4b
movl $0x100000, %r12d        # imm = 0x100000
jmp 0xde3d
movl $0x40000000, %r12d      # imm = 0x40000000
movq %rbx, %rdi
callq 0x75c0
movq (%rbx), %r15
movq %r12, %r13
callq 0x7040
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x7760
cmpq %r15, (%r12)
je 0xdea7
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xdeb3
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0xdeb3
testl %ecx, %ecx
jne 0xde8b
movl %ebp, (%rbx)
testl %eax, %eax
jle 0xdebf
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
imulq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x266e8(%rip), %rdi     # 0x34596
callq 0x72f0
leaq 0x266dc(%rip), %rdi     # 0x34596
callq 0x77a0
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x26635(%rip), %rsi     # 0x34511
leaq 0x2663a(%rip), %rdx     # 0x3451d
leaq 0x8(%rsp), %rdi
callq 0x9760
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0xe391
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7610
leaq 0x374d2(%rip), %rax     # 0x453e8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3741e(%rip), %rsi     # 0x45340
movq 0x3805f(%rip), %rdx     # 0x45f88
movq %rbx, %rdi
callq 0x7960
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdf4f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7500
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xdf66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7500
testb %bpl, %bpl
jne 0xdf8c
jmp 0xdfa0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xdf8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7500
jmp 0xdf8c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7370
jmp 0xdfa0
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0xdfa0
movl %ebp, (%rbx)
movq %r14, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/config_parser.hpp
// Function: cybozu::config_parser::get_as_bool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool get_as_bool(const std::string& key) const {
        const std::string& s = get(key);
        if( s == "true" ) return true;
        if( s == "false" ) return false;
        throw illegal_value(key);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0xe174
movq %rax, %r14
leaq 0x265b4(%rip), %rsi     # 0x34578
movq %rax, %rdi
callq 0x70f0
movl %eax, %ebp
testl %eax, %eax
je 0xdfe5
leaq 0x265a4(%rip), %rsi     # 0x3457d
movq %r14, %rdi
callq 0x70f0
testl %eax, %eax
jne 0xdfef
testl %ebp, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe882
leaq 0x3734a(%rip), %rsi     # 0x45358
movq 0x37f73(%rip), %rdx     # 0x45f88
movq %r14, %rdi
callq 0x7960
movq %rax, %rbx
movq %r14, %rdi
callq 0x7370
movq %rbx, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/config_parser.hpp
// Function: cybozu::config_parser::get_as_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int get_as_int(const std::string& key) const {
        try {
            return std::stoi(get(key));
        } catch(const std::invalid_argument& e) {
            throw illegal_value(key);
        } catch(const std::out_of_range& e) {
            throw illegal_value(key);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0xe174
movq (%rax), %r14
callq 0x7040
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x7760
cmpq %r14, (%r12)
je 0xe096
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xe0a2
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0xe0a2
testl %ecx, %ecx
jne 0xe089
movl %ebp, (%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x264f9(%rip), %rdi     # 0x34596
callq 0x72f0
leaq 0x264ed(%rip), %rdi     # 0x34596
callq 0x77a0
movq %rax, %r14
jmp 0xe0bf
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0xe0bf
movl %ebp, (%r15)
cmpl $0x2, %edx
jne 0xe0fc
movq %r14, %rdi
callq 0x71a0
movl $0x10, %edi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe882
leaq 0x3726d(%rip), %rsi     # 0x45358
movq 0x37e96(%rip), %rdx     # 0x45f88
movq %r15, %rdi
callq 0x7960
jmp 0xe137
cmpl $0x1, %edx
jne 0xe163
movq %r14, %rdi
callq 0x71a0
movl $0x10, %edi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe882
leaq 0x37230(%rip), %rsi     # 0x45358
movq 0x37e59(%rip), %rdx     # 0x45f88
movq %r15, %rdi
callq 0x7960
movq %rax, %r14
jmp 0xe147
movq %rax, %r14
movq %r15, %rdi
callq 0x7370
callq 0x78e0
jmp 0xe163
movq %rax, %r14
jmp 0xe15e
movq %rax, %r14
movq %r15, %rdi
callq 0x7370
callq 0x78e0
movq %r14, %rdi
callq 0x79a0
movq %rax, %rdi
callq 0x8f80
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/config_parser.hpp
// Function: cybozu::config_parser::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string& get(const std::string& key) const {
        auto it = m_config.find(key);
        if( it == m_config.end() )
            throw not_found(key);
        return it->second;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xe76a
testq %rax, %rax
je 0xe191
addq $0x28, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe91a
leaq 0x371e8(%rip), %rsi     # 0x45398
movq 0x37dd1(%rip), %rdx     # 0x45f88
movq %r14, %rdi
callq 0x7960
movq %rax, %rbx
movq %r14, %rdi
callq 0x7370
movq %rbx, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/config_parser.hpp
// Function: cybozu::config_parser::get_as_uint64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::uint64_t get_as_uint64(const std::string& key) const {
        try {
            return std::stoull(get(key));
        } catch(const std::invalid_argument& e) {
            throw illegal_value(key);
        } catch(const std::out_of_range& e) {
            throw illegal_value(key);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0xe174
movq (%rax), %r14
callq 0x7040
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x76e0
cmpq %r14, (%r12)
je 0xe2c0
movl (%r15), %ecx
testl %ecx, %ecx
je 0xe2b0
cmpl $0x22, %ecx
jne 0xe2b3
leaq 0x26305(%rip), %rdi     # 0x345b0
callq 0x77a0
movl %ebp, (%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x262e9(%rip), %rdi     # 0x345b0
callq 0x72f0
movq %rax, %r14
jmp 0xe2dd
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0xe2dd
movl %ebp, (%r15)
cmpl $0x2, %edx
jne 0xe31a
movq %r14, %rdi
callq 0x71a0
movl $0x10, %edi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe882
leaq 0x3704f(%rip), %rsi     # 0x45358
movq 0x37c78(%rip), %rdx     # 0x45f88
movq %r15, %rdi
callq 0x7960
jmp 0xe355
cmpl $0x1, %edx
jne 0xe381
movq %r14, %rdi
callq 0x71a0
movl $0x10, %edi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe882
leaq 0x37012(%rip), %rsi     # 0x45358
movq 0x37c3b(%rip), %rdx     # 0x45f88
movq %r15, %rdi
callq 0x7960
movq %rax, %r14
jmp 0xe365
movq %rax, %r14
movq %r15, %rdi
callq 0x7370
callq 0x78e0
jmp 0xe381
movq %rax, %r14
jmp 0xe37c
movq %rax, %r14
movq %r15, %rdi
callq 0x7370
callq 0x78e0
movq %r14, %rdi
callq 0x79a0
movq %rax, %rdi
callq 0x8f80
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/server.cpp
// Function: yrmcds::server::server()
server::server(): m_syncer(m_workers) {
    auto finder = [this]() ->cybozu::worker* {
        std::size_t n_workers = m_workers.size();
        for( std::size_t i = 0; i < n_workers; ++i ) {
            cybozu::worker* pw = m_workers[m_worker_index].get();
            m_worker_index = (m_worker_index + 1) % n_workers;
            if( ! pw->is_running() )
                return pw;
        }
        return nullptr;
    };

    m_handlers.emplace_back(new memcache::handler(finder, m_reactor, m_syncer));
    if( g_config.counter().enable() )
        m_handlers.emplace_back(new counter::handler(finder, m_reactor));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movb $0x0, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xa112
leaq 0xe0(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xec(%r14)
movups %xmm0, 0xe0(%r14)
movq %rax, 0x28(%rsp)
movq %rax, 0x100(%r14)
leaq 0x120(%r14), %rax
movq %rax, (%rsp)
movups %xmm0, 0x108(%r14)
movups %xmm0, 0x118(%r14)
movups %xmm0, 0x128(%r14)
movl $0xb0, %edi
callq 0x74f0
movq %rax, %rbp
leaq 0x100(%r14), %rcx
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r14, (%rsi)
leaq 0x928(%rip), %r13       # 0xfc18
movq %r13, 0x18(%rsi)
leaq 0x975(%rip), %r15       # 0xfc70
movq %r15, 0x10(%rsi)
movb $0x1, %r12b
movq %rax, %rdi
movq %rbx, %rdx
callq 0x159ec
leaq 0x30(%rsp), %rsi
movq %rbp, (%rsi)
xorl %r12d, %r12d
movq (%rsp), %rdi
callq 0x1012c
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xf33a
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x3787f(%rip), %rax     # 0x46bc0
cmpb $0x1, 0x110(%rax)
jne 0xf3aa
movl $0x60, %edi
callq 0x74f0
movq %rax, %rbp
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r14, (%rsi)
movq %r13, 0x18(%rsi)
movq %r15, 0x10(%rsi)
movb $0x1, %r15b
movq %rax, %rdi
movq %rbx, %rdx
callq 0x128f0
leaq 0x30(%rsp), %rsi
movq %rbp, (%rsi)
xorl %r15d, %r15d
movq (%rsp), %rdi
callq 0x10164
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xf3aa
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf454
jmp 0xf3ef
jmp 0xf454
movq %rax, %r13
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xf3e1
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testb %r15b, %r15b
je 0xf422
movl $0x60, %esi
jmp 0xf41a
jmp 0xf454
movq %rax, %r13
jmp 0xf422
movq %rax, %r13
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xf410
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testb %r12b, %r12b
je 0xf422
movl $0xb0, %esi
movq %rbp, %rdi
callq 0x7500
addq $0x108, %r14            # imm = 0x108
movq (%rsp), %rdi
callq 0x9510
movq %r14, %rdi
callq 0x9594
movq 0x28(%rsp), %rdi
callq 0x9564
movq %rbx, %rdi
callq 0xa284
movq %r13, %rdi
callq 0x79a0
movq %rax, %rdi
callq 0x8f80
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/server.cpp
// Function: yrmcds::server::serve_slave()
void server::serve_slave() {
    for( auto it1 = m_handlers.begin(); it1 != m_handlers.end(); ++it1 ) {
        if( ! (*it1)->on_slave_start() ) {
            // failed to start. stop already started handlers.
            for( auto it2 = m_handlers.begin(); it2 != it1; ++it2 )
                (*it2)->on_slave_end();
            return;
        }
    }

    cybozu::logger::info() << "Slave start";

    m_reactor.run([this](cybozu::reactor& r) {
            if( is_master() ) {
                cybozu::logger::info() << "Detected that this node is eligible to be master. Exit slave mode.";
                r.quit();
                return;
            }

            std::time_t now = std::time(nullptr);
            g_current_time.store(now, std::memory_order_relaxed);

            for( auto& handler: m_handlers )
                handler->on_slave_interval();

            r.fix_garbage();
            r.gc();
        });
    for( auto& handler: m_handlers )
        handler->on_slave_end();

    cybozu::logger::info() << "Slave end";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x120(%rdi), %r14
cmpq 0x128(%rdi), %r14
je 0xf72e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0xf831
addq $0x8, %r14
cmpq 0x128(%rbx), %r14
jne 0xf710
leaq 0x37353(%rip), %r15     # 0x46a88
movl (%r15), %eax
xorl %esi, %esi
cmpl $0x2, %eax
setge %sil
leaq 0x25315(%rip), %rdx     # 0x34a5d
movq %rsp, %r14
movq %r14, %rdi
callq 0x96e6
cmpb $0x1, (%r14)
jne 0xf76f
movq 0x8(%rsp), %rdi
leaq 0x252b2(%rip), %rsi     # 0x34a17
movl $0xb, %edx
callq 0x7570
movq %rsp, %rdi
callq 0x8f4e
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %rbx, (%rsi)
leaq 0x69a(%rip), %rax       # 0xfe2c
movq %rax, 0x18(%rsi)
leaq 0x763(%rip), %rax       # 0xff00
movq %rax, 0x10(%rsi)
movl $0x1, %edx
callq 0xa418
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xf7c4
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x120(%rbx), %r14
movq 0x128(%rbx), %rbx
cmpq %rbx, %r14
je 0xf7e6
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x8, %r14
jmp 0xf7d2
movl (%r15), %eax
xorl %esi, %esi
cmpl $0x2, %eax
setge %sil
leaq 0x25264(%rip), %rdx     # 0x34a5d
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x96e6
cmpb $0x1, (%rbx)
jne 0xf81f
movq 0x8(%rsp), %rdi
leaq 0x2520e(%rip), %rsi     # 0x34a23
movl $0x9, %edx
callq 0x7570
movq %rsp, %rdi
callq 0x8f4e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x120(%rbx), %rbx
cmpq %rbx, %r14
je 0xf827
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x8, %rbx
jmp 0xf838
jmp 0xf84e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8f4e
jmp 0xf879
jmp 0xf881
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xf879
leaq 0x10(%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/dynbuf.hpp
// Function: cybozu::dynbuf::_malloc(unsigned long)
static char* _malloc(std::size_t len) {
#ifdef USE_TCMALLOC
        char* p = (char*)tc_malloc(len);
#else
        char* p = (char*)std::malloc(len);
#endif
        if( p == nullptr )
            throw std::runtime_error("failed to allocate memory.");
        return p;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x76d0
testq %rax, %rax
je 0x10440
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x7220
movq %rax, %rbx
leaq 0x24616(%rip), %rsi     # 0x34a6a
movq %rax, %rdi
callq 0x7190
movq 0x35b8d(%rip), %rsi     # 0x45ff0
movq 0x35b06(%rip), %rdx     # 0x45f70
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/./cybozu/worker.hpp
// Function: cybozu::worker::notify()
void notify() {
        std::uint64_t i = 1;
        ssize_t n = ::write(m_event, &i, sizeof(i));
        if( n == -1 )
            throw_unix_error(errno, "write(eventfd)");
    }

// Assembly:
pushq %rax
movq %rsp, %rsi
movq $0x1, (%rsi)
movl 0x44(%rdi), %edi
movl $0x8, %edx
callq 0x7150
cmpq $-0x1, %rax
je 0x104a6
popq %rax
retq
callq 0x7040
movl (%rax), %edi
leaq 0x245d1(%rip), %rsi     # 0x34a85
callq 0x8d8d
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/logger.hpp
// Function: cybozu::logger::reopen()
void reopen() {
        lock_guard g(m_lock);
        if( m_fd == STDERR_FILENO ) return;
        close_nolock();
        open_nolock(m_path);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x77d0
testl %eax, %eax
jne 0x10742
cmpl $0x2, (%r14)
je 0x10733
movq %r14, %rdi
callq 0x94ec
leaq 0x8(%r14), %rsi
movq %r14, %rdi
callq 0x9f22
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73c0
movl %eax, %edi
callq 0x7320
movq %rax, %r14
movq %rbx, %rdi
callq 0x73c0
movq %r14, %rdi
callq 0x79a0
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/worker.hpp
// Function: cybozu::worker::run()
void run() {
        while ( true ) {
            // wait a new job or an exit signal
            m_running.store(false, std::memory_order_release);
            std::uint64_t i;
            ssize_t n = ::read(m_event, &i, sizeof(i));
            if( n == -1 )
                throw_unix_error(errno, "read(eventfd)");
            while( ! m_running.load(std::memory_order_acquire) );

            if( m_exit ) return;

            m_job(m_buffer);
            m_buffer.reset();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x40(%rdi)
movl 0x44(%rdi), %edi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x7780
cmpq $-0x1, %rax
je 0x10e6d
leaq 0x70(%rbx), %r14
leaq 0x48(%rbx), %r15
movq %rsp, %r12
movb 0x40(%rbx), %al
testb $0x1, %al
je 0x10e28
cmpb $0x0, 0x41(%rbx)
jne 0x10e80
cmpq $0x0, 0x80(%rbx)
je 0x10e8c
movq %r14, %rdi
movq %r15, %rsi
callq *0x88(%rbx)
movq %r15, %rdi
callq 0x10e92
movb $0x0, 0x40(%rbx)
movl 0x44(%rbx), %edi
movl $0x8, %edx
movq %r12, %rsi
callq 0x7780
cmpq $-0x1, %rax
jne 0x10e28
callq 0x7040
movl (%rax), %edi
leaq 0x23cf6(%rip), %rsi     # 0x34b71
callq 0x8d8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x7170
nop
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/./cybozu/dynbuf.hpp
// Function: cybozu::dynbuf::reset()
void reset() {
        if( m_used && m_erase )
            clear_memory(m_p, m_used);
        m_used = 0;
        if( m_default_capacity == m_capacity )
            return;
        char* new_p = nullptr;
        if( m_default_capacity != 0 )
            new_p = _malloc(m_default_capacity);
        _free(m_p);
        m_p = new_p;
        m_capacity = m_default_capacity;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x10eb7
cmpb $0x1, 0x18(%rbx)
jne 0x10eb7
leaq 0x34489(%rip), %rax     # 0x45338
movq (%rax), %rax
movq (%rbx), %rdi
callq *%rax
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %rdi
je 0x10eee
testq %rdi, %rdi
je 0x10ed8
callq 0x1042a
movq %rax, %r14
jmp 0x10edb
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x75a0
movq %r14, (%rbx)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/cybozu[P]yrmcds/src/memcache/../sync.hpp
// Function: yrmcds::syncer::check()
void check() {
        const std::size_t n = m_workers.size();
        for( std::size_t i = 0; i < n; ++i ) {
            if( ! m_workers[i]->is_running() ) {
                for( auto& req: m_requests )
                    req->set(i);
            }
        }
        for( auto it = m_requests.begin(); it != m_requests.end(); ) {
            if( (*it)->check() ) {
                it = m_requests.erase(it);
            } else {
                ++it;
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
je 0x10f57
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %ecx, %ecx
movq (%rbx), %rdx
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rdx
movb 0x40(%rdx), %dl
testb $0x1, %dl
jne 0x10f4f
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
cmpq %rsi, %rdx
je 0x10f4f
movl $0x1, %edi
shlq %cl, %rdi
movq (%rdx), %r8
orq %rdi, 0x20(%r8)
addq $0x8, %rdx
cmpq %rsi, %rdx
jne 0x10f3f
incq %rcx
cmpq %rax, %rcx
jne 0x10f18
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rax
cmpq %rax, %r14
je 0x10f99
leaq 0x8(%rbx), %r15
movq (%r14), %rdi
cmpq $-0x1, 0x20(%rdi)
je 0x10f78
addq $0x8, %r14
jmp 0x10f94
cmpq $0x0, 0x10(%rdi)
je 0x10f9f
callq *0x18(%rdi)
movq %r15, %rdi
movq %r14, %rsi
callq 0x11112
movq %rax, %r14
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jne 0x10f68
popq %rbx
popq %r14
popq %r15
retq
callq 0x7170