LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80c0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
callq 0xa110
movq -0x10(%rbp), %rdi
callq 0x8250
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16d10
testb $0x1, %al
jne 0x16bf5
jmp 0x16c7d
leaq -0x38(%rbp), %rdi
callq 0x16d50
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x16c26
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16d70
testb $0x1, %al
jne 0x16c1c
jmp 0x16c24
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x16c6f
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16d10
testb $0x1, %al
jne 0x16c39
jmp 0x16c6d
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x16db0
jmp 0x16c4c
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x16c6d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xa900
jmp 0x16cc2
jmp 0x16c6f
leaq -0x38(%rbp), %rdi
callq 0x16e30
jmp 0x16bdf
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16d10
testb $0x1, %al
jne 0x16c90
jmp 0x16ca5
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x16db0
jmp 0x16ca3
jmp 0x16ca5
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x16cb8
movq -0x50(%rbp), %rdi
callq 0xa900
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8bc0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8480
movsbl (%rax), %eax
movl %eax, -0x7c(%rbp)
subl $0x47, %eax
je 0x1af9f
jmp 0x1af51
movl -0x7c(%rbp), %eax
subl $0x4b, %eax
je 0x1af83
jmp 0x1af5b
movl -0x7c(%rbp), %eax
subl $0x4d, %eax
je 0x1af91
jmp 0x1af65
movl -0x7c(%rbp), %eax
subl $0x67, %eax
je 0x1af9f
jmp 0x1af6f
movl -0x7c(%rbp), %eax
subl $0x6b, %eax
je 0x1af83
jmp 0x1af79
movl -0x7c(%rbp), %eax
subl $0x6d, %eax
je 0x1af91
jmp 0x1afab
movq -0x18(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x18(%rbp)
jmp 0x1afab
movq -0x18(%rbp), %rax
shlq $0x14, %rax
movq %rax, -0x18(%rbp)
jmp 0x1afab
movq -0x18(%rbp), %rax
shlq $0x1e, %rax
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
je 0x1afbb
movq -0x8(%rbp), %rdi
callq 0x8780
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1cb50
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x1b0c4
movb $0x1, -0x75(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8bd0
movq -0x88(%rbp), %rdx
leaq 0x5f555(%rip), %rsi     # 0x7a56d
leaq -0x60(%rbp), %rdi
callq 0xa160
jmp 0x1b023
movq -0x90(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xb510
jmp 0x1b039
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1b680
jmp 0x1b04b
movq -0x98(%rbp), %rdi
movb $0x0, -0x75(%rbp)
leaq 0x9326b(%rip), %rsi     # 0xae2c8
leaq 0x65c(%rip), %rdx       # 0x1b6c0
callq 0x8b70
jmp 0x1b0e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b0a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b09c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x83f0
leaq -0x60(%rbp), %rdi
callq 0x83f0
leaq -0x61(%rbp), %rdi
callq 0x86a0
testb $0x1, -0x75(%rbp)
jne 0x1b0b6
jmp 0x1b0c2
movq -0x98(%rbp), %rdi
callq 0x8490
jmp 0x1b0d9
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rcx, %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b5d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x5f208(%rip), %rsi     # 0x7a5d4
callq 0xb2f0
testb $0x1, %al
jne 0x1b3d7
jmp 0x1b3dd
movb $0x1, -0x1(%rbp)
jmp 0x1b446
movq -0x20(%rbp), %rdi
leaq 0x5f1f1(%rip), %rsi     # 0x7a5d9
callq 0xb2f0
testb $0x1, %al
jne 0x1b3f3
jmp 0x1b3f9
movb $0x0, -0x1(%rbp)
jmp 0x1b446
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1ca80
jmp 0x1b418
movq -0x38(%rbp), %rdi
leaq 0x92ebd(%rip), %rsi     # 0xae2e0
leaq 0x16d6(%rip), %rdx      # 0x1cb00
callq 0x8b70
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8490
jmp 0x1b451
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8bc0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b5d0
movq %rax, -0x38(%rbp)
jmp 0x1b483
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1cb50
movl %eax, -0x3c(%rbp)
jmp 0x1b49a
movl -0x3c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x1b506
movq -0x18(%rbp), %rdi
callq 0x8230
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ca80
jmp 0x1b4ea
movq -0x48(%rbp), %rdi
leaq 0x92deb(%rip), %rsi     # 0xae2e0
leaq 0x1604(%rip), %rdx      # 0x1cb00
callq 0x8b70
jmp 0x1b5c4
movl -0x40(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b5b3
movq -0x18(%rbp), %rdi
callq 0x8230
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ca80
jmp 0x1b542
movq -0x50(%rbp), %rdi
leaq 0x92d93(%rip), %rsi     # 0xae2e0
leaq 0x15ac(%rip), %rdx      # 0x1cb00
callq 0x8b70
jmp 0x1b5c4
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x1b57e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8ae0
jmp 0x1b585
jmp 0x1b5b3
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x1b5aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8ae0
jmp 0x1b5b1
jmp 0x1b5b3
movq -0x18(%rbp), %rdi
callq 0x8bc0
movq %rax, %rdi
callq 0xa7e0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c360
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1c390
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1cd30
testb $0x1, %al
jne 0x1b615
jmp 0x1b662
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1cd60
jmp 0x1b634
movq -0x40(%rbp), %rdi
leaq 0x92ce1(%rip), %rsi     # 0xae320
leaq 0x179a(%rip), %rdx      # 0x1cde0
callq 0x8b70
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8490
jmp 0x1b675
leaq -0x18(%rbp), %rdi
callq 0x1ce00
addq $0x20, %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8bc0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b5d0
movq %rax, -0x38(%rbp)
jmp 0x1b9a3
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1d520
movq %rax, -0x40(%rbp)
jmp 0x1b9bb
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x1ba28
movq -0x18(%rbp), %rdi
callq 0x8230
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ca80
jmp 0x1ba0c
movq -0x50(%rbp), %rdi
leaq 0x928c9(%rip), %rsi     # 0xae2e0
leaq 0x10e2(%rip), %rdx      # 0x1cb00
callq 0x8b70
jmp 0x1bae6
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1bad5
movq -0x18(%rbp), %rdi
callq 0x8230
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ca80
jmp 0x1ba64
movq -0x58(%rbp), %rdi
leaq 0x92871(%rip), %rsi     # 0xae2e0
leaq 0x108a(%rip), %rdx      # 0x1cb00
callq 0x8b70
jmp 0x1bae6
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x1baa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8ae0
jmp 0x1baa7
jmp 0x1bad5
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x1bacc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8ae0
jmp 0x1bad3
jmp 0x1bad5
movq -0x18(%rbp), %rdi
callq 0x8bc0
movq %rax, %rdi
callq 0xa7e0
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/./cybozu/thread.hpp
// Function: cybozu::thread_base<cybozu::worker, 1>::start()
void start() {
        if( m_thread.joinable() )
            throw std::logic_error("Thread already started!");
        m_done.store(false, std::memory_order_relaxed);
        m_thread = std::thread([this]() { run_in_try(); });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0xc650
testb $0x1, %al
jne 0x22903
jmp 0x22953
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x582e4(%rip), %rsi     # 0x7ac02
callq 0x89a0
jmp 0x22925
movq -0x38(%rbp), %rdi
movq 0x8c690(%rip), %rsi     # 0xaefc0
movq 0x8c649(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8490
jmp 0x22995
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x23390
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x25bc0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x25c80
leaq -0x20(%rbp), %rdi
callq 0xc620
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x8bc0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x88c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x230f0
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x57a58(%rip), %rsi     # 0x7ab13
callq 0x8220
jmp 0x230c2
movq -0x28(%rbp), %rdi
movq 0x8bf23(%rip), %rsi     # 0xaeff0
movq 0x8be9c(%rip), %rdx     # 0xaef70
callq 0x8b70
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x230fa
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/./cybozu/worker.hpp
// Function: cybozu::worker::stop()
void stop() {
        m_exit = true;
        m_running.store(true, std::memory_order_release);
        notify();
        m_thread.join();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x1, 0x41(%rdi)
addq $0x40, %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x23390
movq -0x10(%rbp), %rdi
callq 0x23420
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8b60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/./cybozu/reactor.hpp
// Function: cybozu::resource::invalidate()
bool invalidate() {
        bool expected = true;
        if( ! m_valid.compare_exchange_strong(expected, false) ) {
            return true;
        }

        // no need to read-lock `m_lock` because this is on the reactor thread.
        on_invalidate(m_fd);
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
addq $0x10, %rdi
leaq -0x11(%rbp), %rsi
xorl %edx, %edx
movl $0x5, %ecx
callq 0xf340
testb $0x1, %al
jne 0x232c6
movb $0x1, -0x1(%rbp)
jmp 0x232d7
movq -0x20(%rbp), %rdi
movl 0x50(%rdi), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x1, -0x10(%rbp)
movl 0x44(%rax), %edi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x81d0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x23467
callq 0x8050
movl (%rax), %edi
leaq 0x576cc(%rip), %rsi     # 0x7ab2e
callq 0xa320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x28, %rsi
leaq -0x10(%rbp), %rdi
callq 0xb7a0
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x245c3
movl $0x1, -0x14(%rbp)
jmp 0x245e7
movq -0x30(%rbp), %rdi
callq 0xb750
jmp 0x245ce
movq -0x30(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0xe2d0
jmp 0x245e0
movl $0x0, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xb7d0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xb7d0
movq -0x20(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/./cybozu/reactor.hpp
// Function: cybozu::reactor::fix_garbage()
bool fix_garbage() {
        if( ! m_garbage_copy.empty() )
            throw std::logic_error("No gc() was called after fix_garbage()!");
        std::size_t n = m_garbage.size();
        if( n == 0 ) return false;

        logger::debug() << "reactor: collecting " << n << " resources.";
        m_garbage_copy.swap(m_garbage);

        // eagerly close the file descriptors before gc() is called.
        for( auto& res: m_garbage_copy )
            res->try_close();

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0xc0, %rdi
callq 0x24dd0
testb $0x1, %al
jne 0x24c3a
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x55f9d(%rip), %rsi     # 0x7ab9f
callq 0x89a0
jmp 0x24c09
movq -0x68(%rbp), %rdi
movq 0x8a3ac(%rip), %rsi     # 0xaefc0
movq 0x8a365(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0x24d56
movq -0x60(%rbp), %rdi
addq $0xa8, %rdi
callq 0x13860
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x24c5e
movb $0x0, -0x1(%rbp)
jmp 0x24d48
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xded0
movq -0x78(%rbp), %rdi
leaq 0x55f51(%rip), %rsi     # 0x7abc7
callq 0x22640
movq %rax, -0x70(%rbp)
jmp 0x24c81
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24e10
movq %rax, -0x80(%rbp)
jmp 0x24c94
movq -0x80(%rbp), %rdi
leaq 0x55f57(%rip), %rsi     # 0x7abf6
callq 0x225a0
jmp 0x24ca6
leaq -0x38(%rbp), %rdi
callq 0xa770
movq -0x60(%rbp), %rsi
movq %rsi, %rdi
addq $0xc0, %rdi
addq $0xa8, %rsi
callq 0x24e60
movq -0x60(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x13760
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x135a0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x24ec0
testb $0x1, %al
jne 0x24d04
jmp 0x24d44
leaq -0x48(%rbp), %rdi
callq 0x13bc0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xfbd0
movq %rax, %rdi
callq 0x10050
leaq -0x48(%rbp), %rdi
callq 0x24f00
jmp 0x24cf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa770
jmp 0x24d56
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8bc0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x23390
movq -0x20(%rbp), %rax
movl 0x44(%rax), %edi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x8990
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x2633b
callq 0x8050
movl (%rax), %edi
leaq 0x548e4(%rip), %rsi     # 0x7ac1a
callq 0xa320
jmp 0x2633d
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movl $0x2, %esi
callq 0x235b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x26357
jmp 0x26359
jmp 0x2633d
movq -0x20(%rbp), %rax
testb $0x1, 0x41(%rax)
je 0x26369
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x70, %rdi
addq $0x48, %rsi
callq 0x26390
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0x263d0
jmp 0x262f4
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x2640c
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x2640c
movq -0x18(%rbp), %rcx
leaq 0x87ec0(%rip), %rax     # 0xae2c0
movq (%rax), %rax
movq (%rcx), %rdi
movq 0x20(%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x20(%rcx)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x26424
jmp 0x26467
movq -0x18(%rbp), %rax
movq $0x0, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x26448
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23080
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xc600
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rdi
callq 0x23540
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x26947
movq -0x60(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x26ce0
movq %rax, %rdi
callq 0x228c0
movq %rax, %rdi
callq 0x23580
testb $0x1, %al
jne 0x26934
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x26d00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x26d30
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x26d60
testb $0x1, %al
jne 0x26903
jmp 0x26932
leaq -0x28(%rbp), %rdi
callq 0x26da0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x26dc0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x26de0
leaq -0x28(%rbp), %rdi
callq 0x26e30
jmp 0x268f0
jmp 0x26934
jmp 0x26936
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x26898
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x26d00
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x26d30
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x26d60
testb $0x1, %al
jne 0x2697c
jmp 0x269dd
leaq -0x40(%rbp), %rdi
callq 0x26da0
movq %rax, %rdi
callq 0x26dc0
movq %rax, %rdi
callq 0x26e50
testb $0x1, %al
jne 0x2699b
jmp 0x269cf
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x26f00
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x26e90
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x269d8
leaq -0x40(%rbp), %rdi
callq 0x26e30
jmp 0x26958
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/src/server.cpp
// Function: yrmcds::server::reactor_gc_ready()
inline bool server::reactor_gc_ready() {
    if( ! m_reactor.has_garbage() ) return false;
    if( ! m_syncer.empty() ) return false;
    auto ready = [](const std::unique_ptr<protocol_handler>& p) {
        return p->reactor_gc_ready();
    };
    return std::all_of(m_handlers.cbegin(), m_handlers.cend(), ready);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
callq 0x277a0
testb $0x1, %al
jne 0x26a17
movb $0x0, -0x1(%rbp)
jmp 0x26a6b
movq -0x38(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x26840
testb $0x1, %al
jne 0x26a31
movb $0x0, -0x1(%rbp)
jmp 0x26a6b
movq -0x38(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x27820
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x120, %rdi            # imm = 0x120
callq 0x27850
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x277d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/src/memcache/../sync.hpp
// Function: yrmcds::syncer::add_request(std::unique_ptr<yrmcds::sync_request, std::default_delete<yrmcds::sync_request>>)
void add_request(std::unique_ptr<sync_request> req) {
        const std::size_t n = m_workers.size();
        for( std::size_t i = 0; i < n; ++i ) {
            if( ! m_workers[i]->is_running() )
                req->set(i);
        }
        for( std::size_t i = n; i < MAX_WORKERS; ++i )
            req->set(i);
        if( ! req->check() )
            m_requests.emplace_back( std::move(req) );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
callq 0x23540
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x26b05
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x26ce0
movq %rax, %rdi
callq 0x228c0
movq %rax, %rdi
callq 0x23580
testb $0x1, %al
jne 0x26af5
movq -0x38(%rbp), %rdi
callq 0x26dc0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x26de0
jmp 0x26af7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26ab0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x40, -0x28(%rbp)
jae 0x26b39
movq -0x38(%rbp), %rdi
callq 0x26dc0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x26de0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26b0d
movq -0x38(%rbp), %rdi
callq 0x26dc0
movq %rax, %rdi
callq 0x26e50
testb $0x1, %al
jne 0x26b5f
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x27cc0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cybozu[P]yrmcds/cybozu/config_parser.hpp
// Function: cybozu::config_parser::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set(const std::string& key, const std::string& value) {
        auto it = m_config.find(key);
        if( it == m_config.end() ) {
            m_config.emplace(key, value);
        } else {
            it->second = value;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x290a0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x290d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cd30
testb $0x1, %al
jne 0x28e79
jmp 0x28e93
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29100
movq %rax, -0x38(%rbp)
movb %dl, -0x30(%rbp)
jmp 0x28eb4
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x29150
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x8040
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/ip_address.cpp
// Function: cybozu::ip_address::ip_address(sockaddr const*)
ip_address::ip_address(const struct sockaddr* ifa_addr) {
    if( ifa_addr->sa_family == AF_INET ) {
        af = addr_family::ipv4;
        std::memcpy(&addr, ifa_addr, sizeof(struct sockaddr_in));
        return;
    }
    if( ifa_addr->sa_family == AF_INET6 ) {
        af = addr_family::ipv6;
        std::memcpy(&addr, ifa_addr, sizeof(struct sockaddr_in6));
        return;
    }
    throw bad_address("Invalid address family");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0x2a05c
movq -0x50(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x4(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0xc(%rax)
jmp 0x2a138
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
jne 0x2a098
movq -0x50(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x4(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0xc(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x14(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2a138
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x82f0
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8bd0
movq -0x58(%rbp), %rdx
leaq 0x50c60(%rip), %rsi     # 0x7ad22
leaq -0x30(%rbp), %rdi
callq 0xa160
jmp 0x2a0cd
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2a640
jmp 0x2a0dc
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x8436d(%rip), %rsi     # 0xae458
leaq 0x58e(%rip), %rdx       # 0x2a680
callq 0x8b70
jmp 0x2a147
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2a11c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x83f0
leaq -0x31(%rbp), %rdi
callq 0x86a0
testb $0x1, -0x45(%rbp)
jne 0x2a12d
jmp 0x2a136
movq -0x60(%rbp), %rdi
callq 0x8490
jmp 0x2a13e
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8bc0
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/ip_address.cpp
// Function: cybozu::ip_address::operator==(cybozu::ip_address const&) const
bool ip_address::operator==(const ip_address& rhs) const {
    if( af != rhs.af ) return false;
    if( af == addr_family::none ) return true;
    if( is_v4() ) {
        return std::memcmp(v4addr(), rhs.v4addr(), sizeof(struct in_addr)) == 0;
    }
    if( v6scope() != rhs.v6scope() ) return false;
    return std::memcmp(v6addr(), rhs.v6addr(), sizeof(struct in6_addr)) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x2a17b
movb $0x0, -0x1(%rbp)
jmp 0x2a237
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2a18d
movb $0x1, -0x1(%rbp)
jmp 0x2a237
movq -0x20(%rbp), %rdi
callq 0x2a6a0
testb $0x1, %al
jne 0x2a19c
jmp 0x2a1d2
movq -0x20(%rbp), %rdi
callq 0x2a6c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a6c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2a237
movq -0x20(%rbp), %rdi
callq 0x2a6e0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a6e0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
je 0x2a1f6
movb $0x0, -0x1(%rbp)
jmp 0x2a237
movq -0x20(%rbp), %rdi
callq 0x2a700
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a700
movq %rax, %rcx
movq -0x38(%rbp), %rax
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/ip_address.cpp
// Function: cybozu::ip_address::str[abi:cxx11]() const
std::string ip_address::str() const {
    char host[101];
    if( is_v4() || is_v6() ) {
        std::size_t slen = is_v4() ?
            sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
        int e = getnameinfo((const struct sockaddr*)&addr, (socklen_t)slen,
                            host, sizeof(host), nullptr, 0, NI_NUMERICHOST);
        if( e != 0 ) throw std::runtime_error(gai_strerror(e));
        return std::string(host);
    }
    return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2a6a0
testb $0x1, %al
jne 0x2a29d
movq -0xa8(%rbp), %rdi
callq 0x2a720
testb $0x1, %al
jne 0x2a29d
jmp 0x2a3ce
movq -0xa8(%rbp), %rdi
callq 0x2a6a0
movq -0xa8(%rbp), %rdi
movb %al, %dl
movl $0x1c, %eax
movl $0x10, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x88(%rbp)
addq $0x4, %rdi
movq -0x88(%rbp), %rax
movl %eax, %esi
leaq -0x80(%rbp), %rdx
movl $0x65, %ecx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movl $0x1, (%rsp)
callq 0x8400
movl %eax, -0x8c(%rbp)
cmpl $0x0, -0x8c(%rbp)
je 0x2a374
movl $0x10, %edi
callq 0x82f0
movq %rax, -0xc0(%rbp)
movq %rax, -0xc8(%rbp)
movl -0x8c(%rbp), %edi
callq 0x8940
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x8220
jmp 0x2a337
movq -0xc8(%rbp), %rdi
movq 0x84cab(%rip), %rsi     # 0xaeff0
movq 0x84c24(%rip), %rdx     # 0xaef70
callq 0x8b70
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
callq 0x8490
jmp 0x2a43b
leaq -0x9d(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x8bd0
movq -0xb8(%rbp), %rdi
movq -0xd0(%rbp), %rdx
leaq -0x80(%rbp), %rsi
callq 0xa160
jmp 0x2a3a0
leaq -0x9d(%rbp), %rdi
callq 0x86a0
jmp 0x2a42b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x9d(%rbp), %rdi
callq 0x86a0
jmp 0x2a43b
leaq -0x9e(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x8bd0
movq -0xb8(%rbp), %rdi
movq -0xd8(%rbp), %rdx
leaq 0x52efa(%rip), %rsi     # 0x7d2f0
callq 0xa160
jmp 0x2a3fd
leaq -0x9e(%rbp), %rdi
callq 0x86a0
jmp 0x2a42b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x9e(%rbp), %rdi
callq 0x86a0
jmp 0x2a43b
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x8bc0
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/ip_address.cpp
// Function: (anonymous namespace)::ifaddrs_wrapper::find(cybozu::ip_address const&) const
bool find(const cybozu::ip_address& addr) const {
        for(auto a = m_addr; a != nullptr; a = a->ifa_next) {
            if( a->ifa_addr == NULL ) continue;
            switch(a->ifa_addr->sa_family) {
            case AF_INET:
            case AF_INET6:
                if( addr == cybozu::ip_address(a->ifa_addr) )
                    return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2a577
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2a51f
jmp 0x2a56a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %eax
orl $0x8, %eax
subl $0xa, %eax
je 0x2a534
jmp 0x2a568
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2a010
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2a150
testb $0x1, %al
jne 0x2a560
jmp 0x2a566
movb $0x1, -0x1(%rbp)
jmp 0x2a57b
jmp 0x2a568
jmp 0x2a56a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2a50b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/ip_address.cpp
// Function: cybozu::get_peer_ip_address(int)
ip_address get_peer_ip_address(int sockfd) {
    union {
        struct sockaddr sa;
        struct sockaddr_storage ss;
    } addr;
    socklen_t addrlen = sizeof(addr);
    if( ::getpeername(sockfd, &addr.sa, &addrlen) != 0 )
        throw_unix_error(errno, "getpeername");
    return ip_address(&addr.sa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x98(%rbp)
movl %esi, -0x4(%rbp)
movl $0x80, -0x8c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x88(%rbp), %rsi
leaq -0x8c(%rbp), %rdx
callq 0x84a0
cmpl $0x0, %eax
je 0x2a614
callq 0x8050
movl (%rax), %edi
leaq 0x5072a(%rip), %rsi     # 0x7ad39
callq 0xa320
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2a010
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/signal.cpp
// Function: cybozu::signal_setup(std::initializer_list<int>)
std::unique_ptr<signal_reader> signal_setup(std::initializer_list<int> sigs) {
    sigset_t mask[1];
    sigemptyset(mask);
    for( int i: sigs )
        sigaddset(mask, i);
    int e = pthread_sigmask(SIG_BLOCK, mask, NULL);
    if( e != 0 )
        throw_unix_error(e, "pthread_sigmask");

    // signal disposition is a per-process attribute.
    struct sigaction act;
    std::memset(&act, 0, sizeof(act));
    act.sa_handler = SIG_IGN;
    if( sigaction(SIGPIPE, &act, NULL) == -1 )
        throw_unix_error(errno, "sigaction");

    std::memset(&act, 0, sizeof(act));
    act.sa_handler = handle_abort;
    act.sa_flags = SA_RESETHAND;
    if( sigaction(SIGABRT, &act, NULL) == -1 )
        throw_unix_error(errno, "sigaction");

    return std::unique_ptr<signal_reader>( new signal_reader(mask) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x178(%rbp)
movq %rdi, %rax
movq %rax, -0x170(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x87d0
leaq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x2aa30
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x2aa50
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0xb8(%rbp), %rax
je 0x2a81a
movq -0xb0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
leaq -0xa0(%rbp), %rdi
movl -0xbc(%rbp), %esi
callq 0x8a40
movq -0xb0(%rbp), %rax
addq $0x4, %rax
movq %rax, -0xb0(%rbp)
jmp 0x2a7d5
leaq -0xa0(%rbp), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x8160
movl %eax, -0xc0(%rbp)
cmpl $0x0, -0xc0(%rbp)
je 0x2a84d
movl -0xc0(%rbp), %edi
leaq 0x5052b(%rip), %rsi     # 0x7ad73
callq 0xa320
leaq -0x158(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x8340
movl $0x1, %eax
movq %rax, -0x158(%rbp)
movl $0xd, %edi
leaq -0x158(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x87f0
cmpl $-0x1, %eax
jne 0x2a899
callq 0x8050
movl (%rax), %edi
leaq 0x504ef(%rip), %rsi     # 0x7ad83
callq 0xa320
leaq -0x158(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x8340
leaq 0xbd(%rip), %rax        # 0x2a970
movq %rax, -0x158(%rbp)
movl $0x80000000, -0xd0(%rbp) # imm = 0x80000000
movl $0x6, %edi
leaq -0x158(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x87f0
cmpl $-0x1, %eax
jne 0x2a8f1
callq 0x8050
movl (%rax), %edi
leaq 0x50497(%rip), %rsi     # 0x7ad83
callq 0xa320
movl $0x78, %edi
callq 0x8640
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x180(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x2aa90
jmp 0x2a916
movq -0x180(%rbp), %rsi
movq -0x178(%rbp), %rdi
callq 0x2ab10
movq -0x170(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x180(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
movl $0x78, %esi
callq 0x8650
movq -0x160(%rbp), %rdi
callq 0x8bc0
nopl (%rax,%rax)
// File: cybozu[P]yrmcds/cybozu/reactor.hpp
// Function: bool cybozu::resource::with_fd<cybozu::signal_reader::signal_reader(__sigset_t const*, std::function<void (signalfd_siginfo const&, cybozu::reactor&)>)::'lambda'(int)>(cybozu::signal_reader::signal_reader(__sigset_t const*, std::function<void (signalfd_siginfo const&, cybozu::reactor&)>)::'lambda'(int)&&)
bool with_fd(Func&& f) {
        read_lock g(m_lock);
        if( ! valid() ) return false;
        // no need to check m_closed because it becomes true only after m_valid is set to false.

        if( f(m_fd) ) {
            return true;
        }

        invalidate_and_close_();
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x18, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2b050
movq -0x48(%rbp), %rdi
callq 0x2b080
movb %al, -0x39(%rbp)
jmp 0x2ace3
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2ad10
jmp 0x2acec
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x2ad51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2b0f0
jmp 0x2ad65
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x50(%rax), %esi
callq 0x2b0b0
movb %al, -0x49(%rbp)
jmp 0x2ad25
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x2ad2e
jmp 0x2ad3b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x2ad51
movq -0x48(%rbp), %rdi
callq 0xe750
jmp 0x2ad46
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2b0f0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nop
// File: cybozu[P]yrmcds/cybozu/signal.hpp
// Function: cybozu::signal_reader::on_readable(int)
virtual bool on_readable(int fd) override final {
        while( true ) {
            struct signalfd_siginfo si;
            ssize_t n = read(fd, &si, sizeof(si));
            if( n == -1 ) {
                if( errno == EINTR ) continue;
                if( errno == EAGAIN || errno ==EWOULDBLOCK ) return true;
                throw_unix_error(errno, "read");
            }
            if( n != sizeof(si) )
                throw std::runtime_error("<signal_reader::on_readable> bug?");
            if( m_callback ) m_callback(si, *m_reactor);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %edi
leaq -0x90(%rbp), %rsi
movl $0x80, %edx
callq 0x8990
movq %rax, -0x98(%rbp)
cmpq $-0x1, -0x98(%rbp)
jne 0x2ae72
callq 0x8050
cmpl $0x4, (%rax)
jne 0x2ae3e
jmp 0x2ae0d
callq 0x8050
cmpl $0xb, (%rax)
je 0x2ae52
callq 0x8050
cmpl $0xb, (%rax)
jne 0x2ae5f
movb $0x1, %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
callq 0x8050
movl (%rax), %edi
leaq 0x4fddb(%rip), %rsi     # 0x7ac48
callq 0xa320
cmpq $0x80, -0x98(%rbp)
je 0x2aede
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
leaq 0x4fef9(%rip), %rsi     # 0x7ad96
callq 0x8220
jmp 0x2aea4
movq -0xb8(%rbp), %rdi
movq 0x8413e(%rip), %rsi     # 0xaeff0
movq 0x840b7(%rip), %rdx     # 0xaef70
callq 0x8b70
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
callq 0x8490
jmp 0x2af17
movq -0xb0(%rbp), %rdi
addq $0x58, %rdi
callq 0x22e30
testb $0x1, %al
jne 0x2aef4
jmp 0x2af12
movq -0xb0(%rbp), %rax
movq %rax, %rdi
addq $0x58, %rdi
movq 0x8(%rax), %rdx
leaq -0x90(%rbp), %rsi
callq 0x2b1d0
jmp 0x2ae0d
movq -0xa0(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cybozu[P]yrmcds/src/counter/handler.cpp
// Function: yrmcds::counter::handler::gc_ready()
bool handler::gc_ready() {
    std::time_t now = g_current_time.load(relaxed);

    if( m_gc_thread.get() != nullptr ) {
        if( ! m_gc_thread->done() )
            return false;
        m_last_gc = now;
        m_gc_thread = nullptr;  // join
    }

    unsigned int interval = g_config.counter().stat_interval();
    std::time_t boundary = (now / interval) * interval;
    return m_last_gc < boundary;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x84b95(%rip), %rax     # 0xaffc0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x104e0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
decl %eax
subl $0x2, %eax
jb 0x2b474
jmp 0x2b45d
movl -0x44(%rbp), %eax
subl $0x5, %eax
je 0x2b481
jmp 0x2b467
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b48c
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b48c
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x58, %rdi
callq 0x2c560
cmpq $0x0, %rax
je 0x2b4df
movq -0x58(%rbp), %rdi
addq $0x58, %rdi
callq 0x2c590
movq %rax, %rdi
callq 0x2c5b0
testb $0x1, %al
jne 0x2b4c6
movb $0x0, -0x19(%rbp)
jmp 0x2b524
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x50(%rdi)
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2c5e0
leaq 0x8481a(%rip), %rdi     # 0xafd00
callq 0x220f0
movq %rax, %rdi
callq 0x2c610
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl -0x34(%rbp), %edx
imulq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq 0x50(%rax), %rax
cmpq -0x40(%rbp), %rax
setl %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop