LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::argMatches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool Arg::argMatches( const std::string& argFlag ) const
{
	if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
		 argFlag == Arg::nameStartString() + _name )
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x8850
movq -0xc0(%rbp), %rdx
movq -0xb8(%rbp), %rsi
addq $0x8, %rdx
movb $0x0, -0xa9(%rbp)
movb $0x0, -0xaa(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10ce0
jmp 0x6d14
movq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x88c0
testb $0x1, %al
jne 0x6d2a
jmp 0x6d50
movq -0xc0(%rbp), %rdi
addq $0x8, %rdi
leaq 0xc6e3(%rip), %rsi      # 0x1341f
callq 0x10cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xc9(%rbp)
jne 0x6db0
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x8950
jmp 0x6d69
movq -0xc0(%rbp), %rdx
movb $0x1, -0xa9(%rbp)
addq $0x28, %rdx
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x10ce0
jmp 0x6d90
movq -0xd8(%rbp), %rdi
movb $0x1, -0xaa(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x88c0
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
movb %al, -0xd9(%rbp)
testb $0x1, -0xaa(%rbp)
jne 0x6dc7
jmp 0x6dd3
leaq -0x88(%rbp), %rdi
callq 0x44d8
testb $0x1, -0xa9(%rbp)
jne 0x6dde
jmp 0x6dea
leaq -0xa8(%rbp), %rdi
callq 0x44d8
leaq -0x38(%rbp), %rdi
callq 0x44d8
leaq -0x58(%rbp), %rdi
callq 0x44d8
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x6e08
jmp 0x6e63
movb $0x1, -0x1(%rbp)
jmp 0x6e67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6e58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6e4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0xa9(%rbp)
jne 0x6e41
jmp 0x6e4d
leaq -0xa8(%rbp), %rdi
callq 0x44d8
jmp 0x6e4f
leaq -0x38(%rbp), %rdi
callq 0x44d8
leaq -0x58(%rbp), %rdi
callq 0x44d8
jmp 0x6e75
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4420
nop
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::trimFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
inline void Arg::trimFlag(std::string& flag, std::string& value) const
{
	int stop = 0;
	for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
		if ( flag[i] == Arg::delimiter() )
		{
			stop = i;
			break;
		}

	if ( stop > 1 )
	{
		value = flag.substr(stop+1);
		flag = flag.substr(0,stop);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4390
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x7ac7
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x44c0
movsbl (%rax), %eax
movl %eax, -0x6c(%rbp)
callq 0x89c0
movb %al, %cl
movl -0x6c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x7aba
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7ac7
jmp 0x7abc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7a72
cmpl $0x1, -0x1c(%rbp)
jle 0x7b2b
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq -0x40(%rbp), %rdi
movq $-0x1, %rcx
callq 0x4280
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4310
leaq -0x40(%rbp), %rdi
callq 0x44d8
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rcx
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x4280
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4310
leaq -0x60(%rbp), %rdi
callq 0x44d8
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/StdOutput.h
// Function: TCLAP::StdOutput::version(TCLAP::CmdLineInterface&)
inline void StdOutput::version(CmdLineInterface& _cmd) 
{
	std::string progName = _cmd.getProgramName();
	std::string version = _cmd.getVersion();

	std::cout << std::endl << progName << "  version: " 
			  << version << std::endl << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x40f0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movq %rax, -0x68(%rbp)
jmp 0x7e1f
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x40f0
jmp 0x7e2e
movq 0x1319b(%rip), %rdi     # 0x1afd0
movq 0x13174(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, -0x70(%rbp)
jmp 0x7e47
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4230
movq %rax, -0x78(%rbp)
jmp 0x7e5a
movq -0x78(%rbp), %rdi
leaq 0xb593(%rip), %rsi      # 0x133f8
callq 0x4250
movq %rax, -0x80(%rbp)
jmp 0x7e70
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4230
movq %rax, -0x88(%rbp)
jmp 0x7e86
movq -0x88(%rbp), %rdi
movq 0x1311c(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, -0x90(%rbp)
jmp 0x7ea2
movq -0x90(%rbp), %rdi
movq 0x13100(%rip), %rsi     # 0x1afb0
callq 0x4290
jmp 0x7eb7
leaq -0x50(%rbp), %rdi
callq 0x44d8
leaq -0x30(%rbp), %rdi
callq 0x44d8
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7ef5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x44d8
leaq -0x30(%rbp), %rdi
callq 0x44d8
movq -0x58(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::add(TCLAP::Arg*)
inline void CmdLine::add( Arg* a )
{
	for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
		if ( *a == *(*it) )
			throw( SpecificationException(
			       	"Argument with same flag/name already exists!",
					a->longID() ) );

	a->addToList( _argList );

	if ( a->isRequired() )
		_numRequired++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x8, %rdi
callq 0x9220
movq %rax, -0x18(%rbp)
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
callq 0x9280
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9250
testb $0x1, %al
jne 0x82d5
jmp 0x8471
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9390
movq -0xb8(%rbp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x8302
jmp 0x8458
movb $0x1, -0x9a(%rbp)
movl $0x68, %edi
callq 0x4140
movq %rax, -0xc8(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4430
movq -0xc0(%rbp), %rdx
leaq 0xb12c(%rip), %rsi      # 0x13464
leaq -0x40(%rbp), %rdi
callq 0x5110
jmp 0x8343
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4430
movq -0xd0(%rbp), %rdx
leaq 0xad5b(%rip), %rsi      # 0x130ca
leaq -0x98(%rbp), %rdi
callq 0x5110
jmp 0x837d
movq -0xd8(%rbp), %rsi
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq *%rax
jmp 0x839a
movq -0xc8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xcfd0
jmp 0x83b0
movq -0xc8(%rbp), %rdi
movb $0x0, -0x9a(%rbp)
leaq 0x1283b(%rip), %rsi     # 0x1ac00
leaq 0x4e64(%rip), %rdx      # 0xd230
callq 0x4400
jmp 0x84be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8436
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8421
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8415
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x44d8
leaq -0x98(%rbp), %rdi
callq 0x44d8
leaq -0x99(%rbp), %rdi
callq 0x42b0
leaq -0x40(%rbp), %rdi
callq 0x44d8
leaq -0x41(%rbp), %rdi
callq 0x42b0
testb $0x1, -0x9a(%rbp)
jne 0x844a
jmp 0x8456
movq -0xc8(%rbp), %rdi
callq 0x41d0
jmp 0x84b5
jmp 0x845a
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x9400
movq %rax, -0xa8(%rbp)
jmp 0x82ab
movq -0xb0(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x8496
jmp 0x84ac
movq -0xb0(%rbp), %rax
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
addq $0xe0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4420
nop
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::xorAdd(TCLAP::Arg&, TCLAP::Arg&)
inline void CmdLine::xorAdd( Arg& a, Arg& b )
{
    std::vector<Arg*> ors;
    ors.push_back( &a );
    ors.push_back( &b );
	xorAdd( ors );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x10ea0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x10ec0
jmp 0x8500
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x10ec0
jmp 0x8517
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x30(%rbp), %rsi
callq *%rax
jmp 0x852a
leaq -0x30(%rbp), %rdi
callq 0xaef0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xaef0
movq -0x40(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::xorAdd(std::vector<TCLAP::Arg*, std::allocator<TCLAP::Arg*>>&)
inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
{
	_xorHandler.add( ors );

	for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
	{
		(*it)->forceRequired();
		(*it)->setRequireLabel( "OR required" );

		add( *it );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x88, %rdi
movq -0x10(%rbp), %rsi
callq 0x11510
movq -0x10(%rbp), %rdi
callq 0x90d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9140
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9100
testb $0x1, %al
jne 0x85bb
jmp 0x867c
leaq -0x18(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x91c0
movq (%rax), %rdi
callq 0x11540
movq -0x80(%rbp), %rdi
callq 0x91c0
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4430
movq -0x70(%rbp), %rdx
leaq 0xae99(%rip), %rsi      # 0x13491
leaq -0x40(%rbp), %rdi
callq 0x5110
jmp 0x8603
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11560
jmp 0x8612
leaq -0x40(%rbp), %rdi
callq 0x44d8
leaq -0x41(%rbp), %rdi
callq 0x42b0
leaq -0x18(%rbp), %rdi
callq 0x91c0
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x91e0
movq %rax, -0x60(%rbp)
jmp 0x8598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x44d8
leaq -0x41(%rbp), %rdi
callq 0x42b0
jmp 0x8685
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4420
nop
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/XorHandler.h
// Function: TCLAP::XorHandler::contains(TCLAP::Arg const*)
inline bool XorHandler::contains( const Arg* a )
{
	for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
		for ( ArgVectorIterator it = _orList[i].begin(); 
			  it != _orList[i].end(); 
			  it++ )	
			if ( a == (*it) )
				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, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x9080
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x937a
movq -0x40(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x90d0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x9140
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9100
testb $0x1, %al
jne 0x9334
jmp 0x936a
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x91c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq (%rcx), %rax
jne 0x9357
movb $0x1, -0x1(%rbp)
jmp 0x937e
jmp 0x9359
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x91e0
movq %rax, -0x38(%rbp)
jmp 0x9308
jmp 0x936c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92cf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::getDescription[abi:cxx11]() const
inline std::string Arg::getDescription() const
{
	std::string desc = "";
	if ( _required )
		desc = "(" + _requireLabel + ")  ";

//	if ( _valueRequired )
//		desc += "(value required)  ";

	desc += _description;
	return desc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4430
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x8296(%rip), %rsi      # 0x1341f
callq 0x5110
jmp 0xb190
leaq -0x12(%rbp), %rdi
callq 0x42b0
movq -0x80(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0xb234
movq -0x80(%rbp), %rdx
addq $0x70, %rdx
leaq 0x7f23(%rip), %rsi      # 0x130d9
leaq -0x68(%rbp), %rdi
callq 0xb2c0
jmp 0xb1c1
leaq 0x7f13(%rip), %rdx      # 0x130db
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9170
jmp 0xb1d7
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4310
leaq -0x48(%rbp), %rdi
callq 0x44d8
leaq -0x68(%rbp), %rdi
callq 0x44d8
jmp 0xb234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x42b0
jmp 0xb273
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xb26a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x44d8
jmp 0xb26a
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
addq $0x48, %rsi
callq 0x4330
jmp 0xb247
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb25a
movq -0x78(%rbp), %rdi
callq 0x44d8
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x44d8
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/XorHandler.h
// Function: TCLAP::XorHandler::check(TCLAP::Arg const*)
inline int XorHandler::check( const Arg* a ) 
{
	// iterate over each XOR list
	for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
	{
		// if the XOR list contains the arg..
		ArgVectorIterator ait = std::find( _orList[i].begin(), 
		                                   _orList[i].end(), a );
		if ( ait != _orList[i].end() )
		{
			// go through and set each arg that is not a
			for ( ArgVectorIterator it = _orList[i].begin(); 
				  it != _orList[i].end(); 
				  it++ )	
				if ( a != (*it) )
					(*it)->xorSet();

			// return the number of required args that have now been set
			if ( (*ait)->allowMore() )
				return 0;
			else
				return static_cast<int>(_orList[i].size());
		}
	}

	if ( a->isRequired() )
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x68(%rbp)
callq 0x9080
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xeb26
movq -0x60(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x90d0
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x9140
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xf320
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x9140
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9100
testb $0x1, %al
jne 0xea55
jmp 0xeb16
movq -0x60(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x90d0
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0x9140
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9100
testb $0x1, %al
jne 0xea9a
jmp 0xeadb
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x91c0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq (%rcx), %rax
je 0xeac8
leaq -0x48(%rbp), %rdi
callq 0x91c0
movq (%rax), %rdi
callq 0xf370
jmp 0xeaca
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x91e0
movq %rax, -0x58(%rbp)
jmp 0xea6e
leaq -0x28(%rbp), %rdi
callq 0x91c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb $0x1, %al
jne 0xeaf3
jmp 0xeafc
movl $0x0, -0x4(%rbp)
jmp 0xeb46
movq -0x60(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x90b0
movq %rax, %rdi
callq 0xa720
movl %eax, -0x4(%rbp)
jmp 0xeb46
jmp 0xeb18
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe9bf
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xeb36
jmp 0xeb3f
movl $0x1, -0x4(%rbp)
jmp 0xeb46
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::_emptyCombined(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool CmdLine::_emptyCombined(const std::string& s)
{
	if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
		return false;

	for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
		if ( s[i] != Arg::blankChar() )
			return false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4390
cmpq $0x0, %rax
jbe 0xeb99
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x42d0
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
callq 0xf6d0
movb %al, %cl
movl -0x20(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
je 0xeb99
movb $0x0, -0x1(%rbp)
jmp 0xebf7
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4390
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xebf3
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x42d0
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x89d0
movb %al, %cl
movl -0x2c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
je 0xebe6
movb $0x0, -0x1(%rbp)
jmp 0xebf7
jmp 0xebe8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xeba0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::isSet() const
inline bool Arg::isSet() const
{
	if ( _alreadySet && !_xorSet )
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x91(%rax)
je 0xf70c
movq -0x18(%rbp), %rax
testb $0x1, 0xa1(%rax)
jne 0xf70c
movb $0x1, -0x1(%rbp)
jmp 0xf710
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::_hasBlanks(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool Arg::_hasBlanks( const std::string& s ) const
{
	for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
		if ( s[i] == Arg::blankChar() )
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4390
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1037a
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x42d0
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x89d0
movb %al, %cl
movl -0x2c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1036d
movb $0x1, -0x1(%rbp)
jmp 0x1037e
jmp 0x1036f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10327
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x200(%rbp)
movl $0x8, %edx
callq 0x43f0
movq -0x200(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
callq 0x4200
movq %rax, -0x1f0(%rbp)
jmp 0x10966
movq -0x1f0(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
addq $0x8, %rsi
callq 0x4200
movq %rax, -0x208(%rbp)
jmp 0x10986
movq -0x208(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
addq $0x10, %rsi
callq 0x4200
movq %rax, -0x210(%rbp)
jmp 0x109a6
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4120
movb %al, -0x211(%rbp)
jmp 0x109c4
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x109d3
jmp 0x10b03
movb $0x1, -0x1e2(%rbp)
movl $0x68, %edi
callq 0x4140
movq %rax, -0x220(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x29c0(%rip), %rdx      # 0x133b6
leaq -0x1c0(%rbp), %rdi
callq 0x8e10
jmp 0x10a04
leaq -0x1e1(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x4430
movq -0x228(%rbp), %rdx
leaq 0x2896(%rip), %rsi      # 0x132bb
leaq -0x1e0(%rbp), %rdi
callq 0x5110
jmp 0x10a33
movq -0x220(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
leaq -0x1e0(%rbp), %rdx
callq 0x10390
jmp 0x10a4f
movq -0x220(%rbp), %rdi
movb $0x0, -0x1e2(%rbp)
leaq 0xa2f4(%rip), %rsi      # 0x1ad58
leaq -0x54b(%rip), %rdx      # 0x10520
callq 0x4400
jmp 0x10b37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x10b1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x10aea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x10ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x44d8
leaq -0x1e1(%rbp), %rdi
callq 0x42b0
leaq -0x1c0(%rbp), %rdi
callq 0x44d8
testb $0x1, -0x1e2(%rbp)
jne 0x10af5
jmp 0x10b01
movq -0x220(%rbp), %rdi
callq 0x41d0
jmp 0x10b1f
leaq -0x190(%rbp), %rdi
callq 0x4130
movq -0x1f8(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x4130
movq -0x198(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
leaq 0x249d(%rip), %rsi      # 0x132bb
callq 0xd280
testb $0x1, %al
jne 0x10e29
jmp 0x10e6e
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4430
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x25d9(%rip), %rsi      # 0x1341e
callq 0x5110
jmp 0x10e4c
leaq -0x11(%rbp), %rdi
callq 0x42b0
jmp 0x10e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x42b0
jmp 0x10e90
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rdx
addq $0x28, %rdx
leaq 0x25d8(%rip), %rsi      # 0x13459
callq 0xb2c0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: cybozu[P]yrmcds/src/main.cpp
// Function: (anonymous namespace)::seed_siphash()
void seed_siphash() {
    union {
        char key[16];
        std::uint64_t ikey[2];
    } k;

    std::random_device rd;
    std::uniform_int_distribution<std::uint64_t> dis;
    k.ikey[0] = dis(rd);
    k.ikey[1] = dis(rd);
    cybozu::siphash24_seed(k.key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x13d0, %rsp           # imm = 0x13D0
leaq -0x1398(%rbp), %rdi
callq 0xaa10
leaq -0x13a8(%rbp), %rdi
callq 0xaab0
jmp 0x9da5
leaq -0x13a8(%rbp), %rdi
leaq -0x1398(%rbp), %rsi
callq 0xaae0
movq %rax, -0x13c0(%rbp)
jmp 0x9dc1
movq -0x13c0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x13a8(%rbp), %rdi
leaq -0x1398(%rbp), %rsi
callq 0xaae0
movq %rax, -0x13c8(%rbp)
jmp 0x9de8
movq -0x13c8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x161e0
jmp 0x9dfe
leaq -0x1398(%rbp), %rdi
callq 0xab10
addq $0x13d0, %rsp           # imm = 0x13D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13b0(%rbp)
movl %eax, -0x13b4(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0xab10
movq -0x13b0(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $-0x1, (%rax)
je 0xb772
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xb774
jmp 0xb794
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x8580
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x8ce0
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0xc5cb
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0xc5bf
movq -0x10(%rbp), %rcx
leaq 0xa1d11(%rip), %rax     # 0xae2c0
movq (%rax), %rax
movq (%rcx), %rdi
movq 0x20(%rcx), %rsi
callq *%rax
jmp 0xc5bd
jmp 0xc5bf
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xc600
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa7e0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8240
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x85c0
cmpl $0x0, %eax
jne 0xdd66
movb $0x1, -0x1(%rbp)
jmp 0xdeb5
callq 0x8050
cmpl $0xe, (%rax)
je 0xdd7a
callq 0x8050
cmpl $0xc, (%rax)
jne 0xdd8d
callq 0x8050
movl (%rax), %edi
leaq 0x6c4be(%rip), %rsi     # 0x7a246
callq 0xa320
callq 0x83a0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
movl $0x3, %esi
callq *%rax
movl %eax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xded0
movq -0x78(%rbp), %rdi
leaq 0x6c489(%rip), %rsi     # 0x7a24b
callq 0xdf20
movq %rax, -0x70(%rbp)
jmp 0xddcd
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa690
movq %rax, -0x80(%rbp)
jmp 0xdde0
movq -0x80(%rbp), %rdi
leaq 0x6c473(%rip), %rsi     # 0x7a25e
callq 0xdf60
movq %rax, -0x88(%rbp)
jmp 0xddf9
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdfa0
jmp 0xde08
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa690
movq %rax, -0x90(%rbp)
jmp 0xde21
movq -0x90(%rbp), %rdi
leaq 0x6ed7d(%rip), %rsi     # 0x7cbac
callq 0xa6e0
movq %rax, -0x98(%rbp)
jmp 0xde3d
callq 0x8050
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0xdff0
movq %rax, -0xa0(%rbp)
jmp 0xde5a
movq -0xa0(%rbp), %rdi
leaq 0x6d043(%rip), %rsi     # 0x7aeab
callq 0xa650
jmp 0xde6f
leaq -0x68(%rbp), %rdi
callq 0x83f0
leaq -0x38(%rbp), %rdi
callq 0xa770
movb $0x0, -0x1(%rbp)
jmp 0xdeb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xdeaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x83f0
leaq -0x38(%rbp), %rdi
callq 0xa770
jmp 0xdec3
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x85f0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x8d00
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl $0x40, %esi
leaq 0x6c1a1(%rip), %rdx     # 0x7a26d
callq 0x8530
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0xdc40
movq %rax, %rdi
leaq -0x50(%rbp), %rsi
callq 0x8630
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8630
movq %rax, %rdi
leaq 0x6bff0(%rip), %rsi     # 0x7a0f3
callq 0x8630
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0xdc70
cmpq $0x0, %rax
jne 0xe145
jmp 0xe1b0
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0xdc40
movq %rax, %rdi
leaq 0x6f18f(%rip), %rsi     # 0x7d2ef
callq 0x8630
callq 0xa450
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xe4b0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8660
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe1e0
jmp 0xe196
leaq -0x28(%rbp), %rdi
callq 0x83f0
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe4d0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x83f0
movq -0x30(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x28, %rsi
leaq -0x18(%rbp), %rdi
callq 0xb7a0
movq -0x10(%rbp), %rdi
callq 0x8450
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8830
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe2b4
movq -0x48(%rbp), %rax
movl (%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x81d0
movq %rax, -0x50(%rbp)
jmp 0xe243
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0xe294
callq 0x8050
cmpl $0xb, (%rax)
je 0xe266
callq 0x8050
cmpl $0x4, (%rax)
jne 0xe27f
jmp 0xe21f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb7d0
jmp 0xe2c3
callq 0x8050
movl (%rax), %edi
leaq 0x6c00f(%rip), %rsi     # 0x7a29c
callq 0xa320
jmp 0xe294
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xe21f
leaq -0x18(%rbp), %rdi
callq 0xb7d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $-0x1, (%rax)
je 0xe34c
movq -0x68(%rbp), %rax
cmpl $0x2, (%rax)
je 0xe34c
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x6bf66(%rip), %rsi     # 0x7a27a
callq 0x89a0
jmp 0xe31b
movq -0x70(%rbp), %rdi
movq 0xa0c9a(%rip), %rsi     # 0xaefc0
movq 0xa0c53(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8490
jmp 0xe409
movq -0x10(%rbp), %rdi
callq 0x8240
movq %rax, %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x84b0
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
jne 0xe400
movq -0x68(%rbp), %rax
movl $0x2, (%rax)
callq 0x8050
movl (%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x6befd(%rip), %rsi     # 0x7a296
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xe550
movq -0x78(%rbp), %rsi
leaq 0x6cafa(%rip), %rdx     # 0x7aeab
leaq -0x40(%rbp), %rdi
callq 0xe500
jmp 0xe3bc
leaq -0x40(%rbp), %rdi
callq 0x8240
movl -0x7c(%rbp), %edi
movq %rax, %rsi
callq 0xa320
jmp 0xe3d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xe3f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x83f0
leaq -0x60(%rbp), %rdi
callq 0x83f0
jmp 0xe409
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8bc0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
addq $0x10, %rdi
leaq -0x9(%rbp), %rsi
xorl %edx, %edx
movl $0x5, %ecx
callq 0xf340
testb $0x1, %al
jne 0xe782
jmp 0xe79c
movq -0x18(%rbp), %rdi
movl 0x50(%rdi), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rdi
callq 0xf8a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x80000, %edi          # imm = 0x80000
callq 0x8890
movq -0x20(%rbp), %rdi
movl %eax, (%rdi)
movb $0x1, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0xf910
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x30(%rbp)
callq 0xf930
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x28(%rbp)
callq 0xf930
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0xf950
jmp 0xe816
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x58(%rbp)
callq 0xf930
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x50(%rbp)
callq 0xf930
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x48(%rbp)
callq 0xf970
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x40(%rbp)
callq 0xf970
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0xe8c7
callq 0x8050
movl (%rax), %edi
leaq 0x6ba9e(%rip), %rsi     # 0x7a318
callq 0xa320
jmp 0xe881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xe94b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xfaf0
movq -0x48(%rbp), %rdi
callq 0xfaf0
movq -0x50(%rbp), %rdi
callq 0xfb50
movq -0x58(%rbp), %rdi
callq 0xfb50
jmp 0xe94b
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movss 0x6b9ed(%rip), %xmm0    # 0x7a2c4
callq 0xf990
jmp 0xe8de
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl $0x186a0, %esi          # imm = 0x186A0
callq 0xf9c0
jmp 0xe8f2
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xf9f0
jmp 0xe906
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xf9f0
jmp 0xe91a
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xf9f0
jmp 0xe92e
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xf9f0
jmp 0xe945
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xfb50
movq -0x30(%rbp), %rdi
callq 0xfb50
movq -0x38(%rbp), %rdi
callq 0xfbb0
movq -0x10(%rbp), %rdi
callq 0x8bc0
nop
// File: cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::add_resource(std::unique_ptr<cybozu::resource, std::default_delete<cybozu::resource>>, int)
void reactor::add_resource(std::unique_ptr<resource> res, int events) {
    if( res->m_reactor != nullptr )
        throw std::logic_error("<reactor::add_resource> already added!");
    res->m_reactor = this;
    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_ADD, fd, &ev) == -1 )
        throw_unix_error(errno, "epoll_ctl");
    m_resources.emplace(fd, std::move(res));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xfbd0
cmpq $0x0, 0x8(%rax)
je 0xea89
movl $0x10, %edi
callq 0x82f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x6b8d5(%rip), %rsi     # 0x7a326
callq 0x89a0
jmp 0xea58
movq -0x68(%rbp), %rdi
movq 0xa055d(%rip), %rsi     # 0xaefc0
movq 0xa0516(%rip), %rdx     # 0xaef80
callq 0x8b70
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8490
jmp 0xeb0f
movq -0x58(%rbp), %rdi
callq 0xfbd0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
callq 0xfbd0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl 0x50(%rcx), %ecx
movl %ecx, -0x28(%rbp)
movl -0x14(%rbp), %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, -0x34(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movl (%rax), %edi
movl -0x28(%rbp), %edx
movl $0x1, %esi
leaq -0x34(%rbp), %rcx
callq 0x8910
cmpl $-0x1, %eax
jne 0xeaed
callq 0x8050
movl (%rax), %edi
leaq 0x6b865(%rip), %rsi     # 0x7a34d
callq 0xa320
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0xfbf0
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8bc0
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, -0x24(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movl (%rax), %edi
movl -0x18(%rbp), %edx
movl $0x3, %esi
leaq -0x24(%rbp), %rcx
callq 0x8910
cmpl $-0x1, %eax
jne 0xeb7e
callq 0x8050
movl (%rax), %edi
leaq 0x6b7d4(%rip), %rsi     # 0x7a34d
callq 0xa320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
imull $0x3e8, -0x14(%rbp), %eax # imm = 0x3E8
movl %eax, -0x18(%rbp)
callq 0x88b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movb $0x1, 0x4(%rax)
movq -0x48(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0xec38
movq -0x48(%rbp), %rdi
callq 0xec40
callq 0x88b0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xfc70
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xfc40
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xfcc0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jle 0xec36
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0xfce0
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xebcd
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0x11890
leaq -0x20(%rbp), %rdi
callq 0x118d0
testb $0x1, %al
jne 0x1008b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x100cf
movq -0x40(%rbp), %rax
testb $0x1, 0x11(%rax)
jne 0x100c4
movq -0x40(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x8ce0
jmp 0x100a3
movq -0x40(%rbp), %rax
movb $0x1, 0x11(%rax)
jmp 0x100c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x118f0
jmp 0x100e3
movb $0x1, -0x1(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x118f0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: cybozu[P]yrmcds/cybozu/siphash.cpp
// Function: cybozu::siphash24_seed(char const*)
void siphash24_seed(const char key[16]) {
    uint64_t t;
    std::memcpy(&t, key, sizeof(t));
    static_k0 = le64toh(t);
    std::memcpy(&t, key + 8, sizeof(t));
    static_k1 = le64toh(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16230
movq %rax, 0x99a99(%rip)     # 0xafca0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16230
movq %rax, 0x99a85(%rip)     # 0xafca8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x8930
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x14(%rbp), %rcx
movq %rdx, %rsi
callq 0x8570
movq %rax, -0x38(%rbp)
jmp 0x16a8e
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x16acd
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x88f0
jmp 0x16aab
movq -0x20(%rbp), %rdi
callq 0x8760
jmp 0x16ade
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x83f0
jmp 0x16ae4
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x88f0
jmp 0x16adc
jmp 0x16ade
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8bc0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x370, %rsp            # imm = 0x370
xorl %eax, %eax
movl %eax, %edi
callq 0x85f0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x360(%rbp)
callq 0x8750
movq %rax, %rdi
callq 0x8270
movq -0x360(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movl $0x2, %edi
callq 0x81d0
jmp 0x16b3f
leaq -0x350(%rbp), %rdi
movl $0x64, %esi
callq 0x89f0
movl %eax, -0x364(%rbp)
jmp 0x16b58
movl -0x364(%rbp), %eax
movl %eax, -0x354(%rbp)
leaq -0x350(%rbp), %rdi
movl -0x354(%rbp), %esi
movl $0x2, %edx
callq 0x8a90
addq $0x370, %rsp            # imm = 0x370
popq %rbp
retq
movq %rax, %rdi
callq 0xa7e0
nopl (%rax)