LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/SwitchArg.h
// Function: TCLAP::SwitchArg::processArg(int*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
{
	if ( _ignoreable && Arg::ignoreRest() )
		return false;

	if ( argMatches( args[*i] ) || combinedSwitchesMatch( args[*i] ) )
	{
		// If we match on a combined switch, then we want to return false
		// so that other switches in the combination will also have a
		// chance to match.
		bool ret = false;
		if ( argMatches( args[*i] ) )
			ret = true;

		if ( _alreadySet || ( !ret && combinedSwitchesMatch( args[*i] ) ) )
			throw(CmdLineParseException("Argument already set!", toString()));	

		_alreadySet = true;

		if ( _value == true )
			_value = false;
		else
			_value = true;

		_checkWithVisitor();

		return ret;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x1, 0xa0(%rdi)
jne 0x3739
cmpb $0x0, 0xaaaf(%rip)      # 0xe1e2
jne 0x37c0
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x3766
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x3864
testb %al, %al
je 0x37c0
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpb $0x0, 0x91(%rbx)
jne 0x37cf
movl %eax, %ebp
testb %al, %al
jne 0x379e
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x3864
testb %al, %al
jne 0x37cf
movb $0x1, 0x91(%rbx)
xorb $0x1, 0xa3(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x37c2
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x37c2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x68
popq %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x5823(%rip), %rsi      # 0x9004
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x39b2
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x39ee
xorl %ebp, %ebp
leaq 0xa164(%rip), %rsi      # 0xd980
leaq 0x415f(%rip), %rdx      # 0x7982
movq %r14, %rdi
callq 0x32b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x3840
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3348
testb %bpl, %bpl
jne 0x3854
jmp 0x385c
movq %rax, %rbx
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/SwitchArg.h
// Function: TCLAP::SwitchArg::combinedSwitchesMatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
{
	// make sure this is actually a combined switch
	if ( combinedSwitches.length() > 0 &&
	     combinedSwitches[0] != Arg::flagStartString()[0] )
		return false;

	// make sure it isn't a long name 
	if ( combinedSwitches.substr( 0, Arg::nameStartString().length() ) == 
		 Arg::nameStartString() )
		return false;

	// make sure the delimiter isn't in the string 
	if ( combinedSwitches.find_first_of( Arg::delimiter() ) != std::string::npos )
		return false;

	// ok, we're not specifying a ValueArg, so we know that we have
	// a combined switch list.  
	for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
		if ( _flag.length() > 0 && 
		     combinedSwitches[i] == _flag[0] &&
		     _flag[0] != Arg::flagStartString()[0] ) 
		{
			// update the combined switches so this one is no longer present
			// this is necessary so that no unlabeled args are matched
			// later in the processing.
			//combinedSwitches.erase(i,1);
			combinedSwitches[i] = Arg::blankChar(); 
			return true;
		}

	// none of the switches passed in the list match. 
	return false;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x38a5
movq (%rbx), %rax
movb (%rax), %bpl
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x54b6
movq (%r15), %rax
movb (%rax), %r12b
movq %r15, %rdi
callq 0x3348
cmpb %r12b, %bpl
jne 0x3905
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x5502
movq 0x8(%r15), %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31c0
leaq 0x48(%rsp), %rdi
callq 0x5502
leaq 0x8(%rsp), %r15
leaq 0x48(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x54d8
movl %eax, %ebp
movq %r12, %rdi
callq 0x3348
movq %r15, %rdi
callq 0x3348
leaq 0x28(%rsp), %rdi
callq 0x3348
testb %bpl, %bpl
je 0x390a
xorl %r15d, %r15d
jmp 0x3924
movsbl 0xa89f(%rip), %esi      # 0xe1b0
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3210
cmpq $-0x1, %rax
je 0x3936
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
movl %r12d, %r12d
cmpq %r12, 0x8(%rbx)
jbe 0x3905
cmpq $0x0, 0x10(%r14)
je 0x397c
movq (%rbx), %rax
movb (%rax,%r12), %bpl
movq 0x8(%r14), %rax
cmpb (%rax), %bpl
jne 0x397c
movq %r15, %rdi
callq 0x54b6
movq 0x8(%rsp), %rax
movb (%rax), %r13b
movq %r15, %rdi
callq 0x3348
cmpb %r13b, %bpl
jne 0x3981
incl %r12d
jmp 0x393f
movq (%rbx), %rax
movb $0x7, (%rax,%r12)
movb $0x1, %r15b
jmp 0x3924
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x39a0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3348
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/StdOutput.h
// Function: TCLAP::StdOutput::usage(TCLAP::CmdLineInterface&)
inline void StdOutput::usage(CmdLineInterface& _cmd ) 
{
	std::cout << std::endl << "USAGE: " << std::endl << std::endl; 

	_shortUsage( _cmd, std::cout );

	std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;

	_longUsage( _cmd, std::cout );

	std::cout << std::endl; 

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xa424(%rip), %rbx      # 0xdfd0
movq %rbx, %rdi
callq 0x30d0
leaq 0x5865(%rip), %rsi      # 0x9420
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c2c
movq %rbx, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
leaq 0x5422(%rip), %rsi      # 0x901a
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3f56
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::~CmdLine()
inline CmdLine::~CmdLine()
{
	ClearContainer(_argDeleteOnExitList);
	ClearContainer(_visitorDeleteOnExitList);

	if ( !_userSetOutput ) {
		delete _output;
		_output = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x9667(%rip), %rax      # 0xd9a8
movq %rax, (%rdi)
leaq 0xa0(%rdi), %r14
movq %r14, %rdi
callq 0x42aa
leaq 0xb8(%rbx), %r15
movq %r15, %rdi
callq 0x42e7
cmpb $0x0, 0xd9(%rbx)
jne 0x4385
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x437d
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xd0(%rbx)
movq %r15, %rdi
callq 0x5f72
movq %r14, %rdi
callq 0x5c00
leaq 0x88(%rbx), %rdi
callq 0x5ade
leaq 0x60(%rbx), %rdi
callq 0x3348
leaq 0x40(%rbx), %rdi
callq 0x3348
leaq 0x20(%rbx), %rdi
callq 0x3348
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5c00
movq %rax, %rdi
callq 0x42dc
nop
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::parse(int, char const* const*)
inline void CmdLine::parse(int argc, const char * const * argv)
{
		// this step is necessary so that we have easy access to
		// mutable strings.
		std::vector<std::string> args;
		for (int i = 0; i < argc; i++)
			args.push_back(argv[i]);

		parse(args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r12
andq $0x0, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
xorl %ebx, %ebx
testl %esi, %esi
cmovlel %ebx, %r15d
leaq 0x28(%rsp), %r13
leaq 0x7(%rsp), %rbp
cmpq %rbx, %r15
je 0x465c
movq (%r14,%rbx,8), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0x39b2
movq %r12, %rdi
movq %r13, %rsi
callq 0x6ea2
movq %r13, %rdi
callq 0x3348
incq %rbx
jmp 0x4630
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x6ba0
leaq 0x10(%rsp), %rdi
callq 0x6e80
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4686
movq %rax, %rbx
jmp 0x4698
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3348
leaq 0x10(%rsp), %rdi
callq 0x6e80
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x54b6
leaq 0x8(%r14), %r15
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7d6f
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x54d8
testb %al, %al
je 0x47c9
leaq 0x4c5f(%rip), %rsi      # 0x9419
movq %r15, %rdi
callq 0x7d65
movb $0x1, %bpl
testb %al, %al
jne 0x4807
movq %rsp, %rdi
callq 0x5502
addq $0x28, %r14
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x7d6f
leaq 0x60(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54d8
movl %eax, %ebp
movq %r14, %rdi
callq 0x3348
movq %rsp, %rdi
callq 0x3348
leaq 0x20(%rsp), %rdi
callq 0x3348
leaq 0x40(%rsp), %rdi
callq 0x3348
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3348
jmp 0x483d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3348
jmp 0x484c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3348
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::toString[abi:cxx11]() const
inline std::string Arg::toString() const
{
	std::string s = "";

	if ( _flag != "" )
		s += Arg::flagStartString() + _flag + " ";

	s += "(" + Arg::nameStartString() + _name + ")";

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4ba0(%rip), %r12      # 0x9419
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0x39b2
leaq 0x8(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x7d65
testb %al, %al
je 0x48f6
leaq 0x28(%rsp), %rdi
callq 0x54b6
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r15, %rdx
callq 0x7d6f
leaq 0x4b5c(%rip), %rdx      # 0x9418
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5886
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3320
leaq 0x8(%rsp), %rdi
callq 0x3348
leaq 0x48(%rsp), %rdi
callq 0x3348
leaq 0x28(%rsp), %rdi
callq 0x3348
leaq 0x68(%rsp), %rdi
callq 0x5502
leaq 0x47ec(%rip), %rsi      # 0x90f3
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x5efc
addq $0x28, %r14
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x579b
leaq 0x4ab1(%rip), %rdx      # 0x93e4
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5886
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3320
leaq 0x8(%rsp), %rdi
callq 0x3348
leaq 0x48(%rsp), %rdi
callq 0x3348
leaq 0x28(%rsp), %rdi
callq 0x3348
leaq 0x68(%rsp), %rdi
callq 0x3348
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x499b
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3348
jmp 0x49aa
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x49e8
jmp 0x49ef
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x49c5
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3348
jmp 0x49d4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3348
jmp 0x49e3
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3348
jmp 0x49f2
movq %rax, %r14
movq %rbx, %rdi
callq 0x3348
movq %r14, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::shortID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline std::string Arg::shortID( const std::string& valueId ) const
{
	std::string id = "";

	if ( _flag != "" )
		id = Arg::flagStartString() + _flag;
	else
		id = Arg::nameStartString() + _name;

	if ( _valueRequired )
		id += std::string( 1, Arg::delimiter() ) + "<" + valueId  + ">";

	if ( !_required )
		id = "[" + id + "]";

	return id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x49f7(%rip), %r13      # 0x9419
leaq 0x20(%rsp), %rdx
movq %r13, %rsi
callq 0x39b2
leaq 0x8(%r14), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x7d65
testb %al, %al
je 0x4a5c
movq %rsp, %rdi
callq 0x54b6
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r12, %rdx
callq 0x7d6f
jmp 0x4a75
movq %rsp, %rdi
callq 0x5502
leaq 0x28(%r14), %rdx
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x7d6f
leaq 0x20(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31f0
movq %r12, %rdi
callq 0x3348
movq %rsp, %rdi
callq 0x3348
cmpb $0x1, 0x90(%r14)
jne 0x4b2d
movsbl 0x9706(%rip), %edx      # 0xe1b0
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x31d0
leaq 0x491f(%rip), %rdx      # 0x93e6
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5886
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
movq %r15, %rdx
callq 0x579b
leaq 0x48fb(%rip), %rdx      # 0x93e8
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5886
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3320
leaq 0x20(%rsp), %rdi
callq 0x3348
movq %rsp, %rdi
callq 0x3348
leaq 0x60(%rsp), %rdi
callq 0x3348
leaq 0x40(%rsp), %rdi
callq 0x3348
cmpb $0x0, 0x68(%r14)
jne 0x4b7a
leaq 0x48af(%rip), %rsi      # 0x93ea
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x5efc
leaq 0x489f(%rip), %rdx      # 0x93ec
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5886
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31f0
movq %r14, %rdi
callq 0x3348
movq %rsp, %rdi
callq 0x3348
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3348
jmp 0x4ba2
jmp 0x4bcb
movq %rax, %r14
movq %rsp, %rdi
callq 0x3348
jmp 0x4bb1
jmp 0x4bda
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x3348
jmp 0x4bc0
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x4bd1
jmp 0x4bda
jmp 0x4bcb
movq %rax, %r14
movq %rsp, %rdi
callq 0x3348
jmp 0x4bdd
jmp 0x4bda
movq %rax, %r14
movq %rbx, %rdi
callq 0x3348
movq %r14, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movb 0x9328(%rip), %dl       # 0xe1b0
xorl %r12d, %r12d
cmpq %r12, %rcx
je 0x4ef4
cmpb %dl, (%rax,%r12)
je 0x4e9b
incq %r12
jmp 0x4e8b
cmpq $0x2, %r12
jb 0x4ef4
leal 0x1(%r12), %edx
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x31c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x31f0
movq %r15, %rdi
callq 0x3348
movl %r12d, %ecx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31f0
movq %r14, %rdi
callq 0x3348
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x50(%rax)
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x3220
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x3220
movq 0x9007(%rip), %rdi      # 0xdfd0
callq 0x30d0
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3180
leaq 0x4410(%rip), %rsi      # 0x93f2
movq %rax, %rdi
callq 0x3190
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq %rsp, %rdi
callq 0x3348
leaq 0x20(%rsp), %rdi
callq 0x3348
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x502d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3348
leaq 0x20(%rsp), %rdi
callq 0x3348
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/StdOutput.h
// Function: TCLAP::StdOutput::failure(TCLAP::CmdLineInterface&, TCLAP::ArgException&)
inline void StdOutput::failure( CmdLineInterface& _cmd,
								ArgException& e ) 
{
	std::string progName = _cmd.getProgramName();

	std::cerr << "PARSE ERROR: " << e.argId() << std::endl
		      << "             " << e.error() << std::endl << std::endl;

	if ( _cmd.hasHelpAndVersion() )
		{
			std::cerr << "Brief USAGE: " << std::endl;

			_shortUsage( _cmd, std::cerr );	

			std::cerr << std::endl << "For complete USAGE and HELP type: " 
					  << std::endl << "   " << progName << " --help" 
					  << std::endl << std::endl;
		}
	else
		usage(_cmd);

	throw ExitException(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x50(%rax)
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x3220
movq 0x8f7f(%rip), %rdi      # 0xdff0
leaq 0x4386(%rip), %rsi      # 0x93fe
callq 0x3190
movq %rax, %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x7da8
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3180
movq %rax, %rdi
callq 0x30d0
leaq 0x4363(%rip), %rsi      # 0x940c
movq %rax, %rdi
callq 0x3190
movq %rax, %r12
addq $0x8, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3220
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
leaq 0x8(%rsp), %rdi
callq 0x3348
leaq 0x28(%rsp), %rdi
callq 0x3348
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x78(%rax)
testb %al, %al
je 0x5194
movq 0x8ee2(%rip), %rdi      # 0xdff0
leaq 0x4305(%rip), %rsi      # 0x941a
callq 0x3190
movq %rax, %rdi
callq 0x30d0
movq 0x8ec7(%rip), %rdx      # 0xdff0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c2c
movq 0x8eb5(%rip), %rdi      # 0xdff0
callq 0x30d0
leaq 0x42e1(%rip), %rsi      # 0x9428
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30d0
leaq 0x42b8(%rip), %rsi      # 0x9416
movq %rax, %rdi
callq 0x3190
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x3180
leaq 0x42d1(%rip), %rsi      # 0x944b
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
jmp 0x51a0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
pushq $0x4
popq %rdi
callq 0x30e0
movl $0x1, (%rax)
leaq 0x8a4b(%rip), %rsi      # 0xdc00
movq %rax, %rdi
xorl %edx, %edx
callq 0x32b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x51d3
jmp 0x51d0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3348
jmp 0x51e4
jmp 0x51e1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3348
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x52af
movq 0x10(%r12), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testb %al, %al
je 0x5219
pushq $0x68
popq %rdi
callq 0x30e0
movq %rax, %rbx
leaq 0x4214(%rip), %rsi      # 0x945e
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x39b2
leaq 0x3e84(%rip), %rsi      # 0x90e4
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x39b2
movq (%r14), %rax
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq *0x48(%rax)
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x691e
xorl %ebp, %ebp
leaq 0x8970(%rip), %rsi      # 0xdc10
leaq 0x26db(%rip), %rdx      # 0x7982
movq %rbx, %rdi
callq 0x32b0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x52ce
incl 0x80(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3348
jmp 0x52f0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x3348
jmp 0x5302
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0x3348
testb %bpl, %bpl
jne 0x5316
jmp 0x531e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x7dfc
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7dfc
movq (%rbx), %rax
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq *0x28(%rax)
leaq 0x10(%rsp), %rdi
callq 0x5d7e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x5389
jmp 0x5389
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5d7e
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x88, %rdi
callq 0x7f3c
movq (%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %r13
cmpq 0x8(%rbx), %r15
je 0x5413
movq (%r15), %rbp
movb $0x1, 0x68(%rbp)
movq %r12, %rdi
leaq 0x40a9(%rip), %rsi      # 0x948b
movq %r13, %rdx
callq 0x39b2
addq $0x70, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3100
movq %r12, %rdi
callq 0x3348
movq (%r15), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
addq $0x8, %r15
jmp 0x53cb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3348
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
xorl %edx, %edx
cmpq %rax, %rdx
je 0x58e4
imulq $0x18, %rdx, %rdi
movq (%rcx,%rdi), %r8
movq 0x8(%rcx,%rdi), %rdi
cmpq %rdi, %r8
je 0x58df
leaq 0x8(%r8), %r9
cmpq %rsi, (%r8)
movq %r9, %r8
jne 0x58cc
jmp 0x58e4
incq %rdx
jmp 0x58ba
cmpq %rdx, %rax
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x35b3(%rip), %rsi      # 0x9419
leaq 0x20(%rsp), %rdx
callq 0x39b2
cmpb $0x1, 0x68(%r14)
jne 0x5ebe
leaq 0x70(%r14), %rdx
leaq 0x3271(%rip), %rsi      # 0x90f3
movq %rsp, %rdi
callq 0x5efc
leaq 0x3264(%rip), %rdx      # 0x90f5
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5886
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31f0
movq %r15, %rdi
callq 0x3348
movq %rsp, %rdi
callq 0x3348
addq $0x48, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3320
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3348
jmp 0x5eec
jmp 0x5ee9
movq %rax, %r14
movq %rbx, %rdi
callq 0x3348
movq %r14, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
pushq $0x8
popq %r15
xorl %r12d, %r12d
pushq $0x18
popq %r13
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x70e3
movq -0x8(%rcx,%r15), %rdi
movq (%rcx,%r15), %rsi
movq %r14, %rdx
callq 0x7383
movq (%rbx), %rdx
movq (%rdx,%r15), %rcx
cmpq %rcx, %rax
jne 0x70f3
incq %r12
addq $0x18, %r15
jmp 0x70a9
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movzbl %al, %eax
jmp 0x7142
movq -0x8(%rdx,%r15), %rdx
movq 0x8(%rsp), %rsi
movb $0x1, %dil
cmpq %rcx, %rdx
je 0x7121
movq (%rdx), %r8
cmpq %r8, %rsi
je 0x711b
movb %dil, 0x91(%r8)
movb %dil, 0xa1(%r8)
addq $0x8, %rdx
jmp 0x7100
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x7142
movq (%rbx), %rcx
movq (%rcx,%r15), %rax
subq -0x8(%rcx,%r15), %rax
shrq $0x3, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x7161
cmpb $0x2d, (%rcx)
jne 0x7177
pushq $0x1
popq %rsi
cmpq %rsi, %rdx
setbe %al
jbe 0x7176
cmpb $0x7, (%rcx,%rsi)
leaq 0x1(%rsi), %rsi
je 0x7164
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/ValueArg.h
// Function: TCLAP::ValueArg<Vect3D>::_extractValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ValueArg<T>::_extractValue( const std::string& val ) 
{
    try {
	ExtractValue(_value, val, typename ArgTraits<T>::ValueCategory());
    } catch( ArgParseException &e) {
	throw ArgParseException(e.error(), toString());
    }
    
    if ( _constraint != NULL )
	if ( ! _constraint->check( _value ) )
	    throw( CmdLineParseException( "Value '" + val + 
					  + "' does not meet constraint: " 
					  + _constraint->description(),
					  toString() ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa8(%rdi), %rbx
movq %rbx, %rdi
callq 0x7bda
movq 0xf8(%r15), %rdi
testq %rdi, %rdi
je 0x79ef
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x79fd
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x68
popq %rdi
callq 0x30e0
movq %rax, %rbx
leaq 0x199c(%rip), %rsi      # 0x93ab
leaq 0x88(%rsp), %rdi
movq %r14, %rdx
callq 0x5efc
leaq 0x198d(%rip), %rdx      # 0x93b3
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5886
movq 0xf8(%r15), %rsi
movq (%rsi), %rax
leaq 0x68(%rsp), %rdi
callq *(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x55c5
movq (%r15), %rax
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x39ee
xorl %ebp, %ebp
leaq 0x5ef7(%rip), %rsi      # 0xd980
leaq -0x10e(%rip), %rdx      # 0x7982
movq %rbx, %rdi
callq 0x32b0
jmp 0x7b7d
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3348
jmp 0x7ab2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3348
jmp 0x7ac4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x3348
jmp 0x7ad6
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x7ae8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x3348
testb %bpl, %bpl
jne 0x7b02
jmp 0x7bb3
movq %rax, %r14
movq %rbx, %rdi
callq 0x3140
jmp 0x7bb3
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7bb3
movq %r14, %rdi
callq 0x3090
movq %rax, %r14
pushq $0x68
popq %rdi
callq 0x30e0
movq %rax, %rbx
addq $0x8, %r14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x3220
movq (%r15), %rax
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x78b8
xorl %ebp, %ebp
leaq 0x61fa(%rip), %rsi      # 0xdd68
leaq -0x1f3(%rip), %rdx      # 0x7982
movq %rbx, %rdi
callq 0x32b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x7b92
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3348
testb %bpl, %bpl
jne 0x7ba6
jmp 0x7bae
movq %rax, %r14
movq %rbx, %rdi
callq 0x3140
callq 0x3290
movq %r14, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x42dc
nop
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/test11.cpp
// Function: Vect3D::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Vect3D& operator=(const std::string &str)
    {
	std::istringstream iss(str);
	if (!(iss >> v[0] >> v[1] >> v[2]))
	    throw TCLAP::ArgParseException(str + " is not a 3D vector");

	return *this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x32a0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3120
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3120
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x3120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7c49
leaq 0x48(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x68
popq %rdi
callq 0x30e0
movq %rax, %rbx
leaq 0x1775(%rip), %rdx      # 0x93d0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x57ba
leaq 0x1666(%rip), %rsi      # 0x92d5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x39b2
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x78b8
xorl %ebp, %ebp
leaq 0x60cc(%rip), %rsi      # 0xdd68
leaq -0x321(%rip), %rdx      # 0x7982
movq %rbx, %rdi
callq 0x32b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3348
jmp 0x7cc0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3348
testb %bpl, %bpl
jne 0x7cd4
jmp 0x7ce1
movq %rax, %r14
movq %rbx, %rdi
callq 0x3140
jmp 0x7ce1
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x30c0
movq %r14, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/./cybozu/logger.hpp
// Function: cybozu::logger::close_nolock()
void close_nolock() {
        if( m_fd == -1 || m_fd == STDERR_FILENO ) return;
        fsync(m_fd);
        ::close(m_fd);
        m_fd = -1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $-0x1, %edi
je 0x8b5b
cmpl $0x2, %edi
je 0x8b5b
callq 0x7450
movl (%rbx), %edi
callq 0x7a90
orl $-0x1, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/./cybozu/dynbuf.hpp
// Function: cybozu::dynbuf::~dynbuf()
~dynbuf() {
        if( m_p != nullptr ) {
            if( m_erase )
                clear_memory(m_p, m_used);
            _free(m_p);
        }
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x7490
movl %eax, %ebx
testl %eax, %eax
je 0x9319
callq 0x7030
movq %rax, %r14
movl (%rax), %edi
movl %edi, %eax
orl $0x2, %eax
cmpl $0xe, %eax
je 0x932d
callq 0x72f0
movq (%rax), %rcx
pushq $0x3
popq %rsi
movq %rax, %rdi
callq *0x28(%rcx)
movl %eax, %ebp
movq %rdx, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x9360
leaq 0x1cf92(%rip), %rsi     # 0x2622b
movq %r13, %rdi
callq 0x9388
movq %rax, %rdi
movq %r15, %rsi
callq 0x869a
leaq 0x1cf8b(%rip), %rsi     # 0x2623e
movq %rax, %rdi
callq 0x93a0
movq %rax, %r15
movq (%r12), %rax
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq *0x20(%rax)
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x869a
leaq 0x1f4b4(%rip), %rsi     # 0x28797
movq %rax, %rdi
callq 0x86b2
movq %rax, %rdi
movq %r14, %rsi
callq 0x93b8
leaq 0x1da83(%rip), %rsi     # 0x26d80
movq %rax, %rdi
callq 0x8682
leaq 0x18(%rsp), %rdi
callq 0x71d0
leaq 0x8(%rsp), %rdi
callq 0x86e4
testl %ebx, %ebx
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1cef2(%rip), %rsi     # 0x26226
callq 0x8513
jmp 0x933b
movq %rax, %rbx
jmp 0x934d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x71d0
leaq 0x8(%rsp), %rdi
callq 0x86e4
movq %rbx, %rdi
callq 0x7990
nop
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logstream::add_prefix(char const*)
void logstream::add_prefix(const char* level) {
    char buf[64];
    std::time_t t = std::time(nullptr);
    std::tm ct;
    // beware that std::gmtime is not thread-safe.
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %T ", ::gmtime_r(&t, &ct));
    *m_os << buf << level << " ";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x74c0
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %rsi
callq 0x7aa0
leaq 0x1ce49(%rip), %rdx     # 0x2624d
leaq 0x40(%rsp), %r15
pushq $0x40
popq %rsi
movq %r15, %rdi
movq %rax, %rcx
callq 0x7410
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x7500
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7500
leaq 0x1cc9e(%rip), %rsi     # 0x260d3
movq %rax, %rdi
callq 0x7500
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logstream::output()
void logstream::output() {
    if( m_os.get() == nullptr ) return;
    *m_os << "\n";
    logger::instance().log(m_os->str());
    m_os.reset(nullptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x94ad
leaq 0x1fa19(%rip), %rsi     # 0x28e7f
callq 0x7500
callq 0x856a
movq %rax, %r14
movq 0x8(%rbx), %rsi
addq $0x8, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x7870
movq %r14, %rdi
movq %r15, %rsi
callq 0x94ca
movq %rsp, %rdi
callq 0x71d0
movq 0x8(%rbx), %rdi
andq $0x0, 0x8(%rbx)
testq %rdi, %rdi
je 0x94ad
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/cybozu/logger.cpp
// Function: cybozu::logger::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void logger::log(const std::string& msg) {
    lock_guard g(m_lock);
    std::size_t to_write = msg.size();
    const char* ptr = msg.data();
    while( to_write != 0 ) {
        ssize_t n = ::write(m_fd, ptr, to_write);
        if( n == -1 ) {
            if( errno == EAGAIN || errno == EINTR ) continue;
            throw_unix_error(errno, "<logger::log> write");
        }
        ptr += n;
        to_write -= n;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x8b5e
movq (%r12), %r15
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x9521
movl (%r14), %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7150
cmpq $-0x1, %rax
jne 0x9519
callq 0x7030
movl (%rax), %edi
cmpl $0x4, %edi
je 0x94ed
cmpl $0xb, %edi
je 0x94ed
jmp 0x9534
addq %rax, %r15
subq %rax, %r12
jmp 0x94ed
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x73e0
leaq 0x1cd41(%rip), %rsi     # 0x2627c
callq 0x8513
jmp 0x9542
movq %rax, %r14
movq %rbx, %rdi
callq 0x73e0
movq %r14, %rdi
callq 0x7990
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $-0x1, %eax
je 0x9570
cmpl $0x2, %eax
jne 0x95d7
movq (%rbx), %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x73b0
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x9595
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x2, (%r14)
callq 0x7030
movl (%rax), %ebp
leaq 0x1cccc(%rip), %rsi     # 0x26276
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x9655
leaq 0x1d7bf(%rip), %rdx     # 0x26d80
movq %rsp, %rdi
movq %r14, %rsi
callq 0x9636
movq (%rsp), %rsi
movl %ebp, %edi
callq 0x8513
pushq $0x10
popq %rdi
callq 0x7240
movq %rax, %r14
leaq 0x1cc71(%rip), %rsi     # 0x2625a
movq %rax, %rdi
callq 0x77a0
movq 0x319c8(%rip), %rsi     # 0x3afc0
movq 0x31989(%rip), %rdx     # 0x3af88
movq %r14, %rdi
callq 0x7950
movq %rax, %rbx
movq %r14, %rdi
callq 0x7390
jmp 0x962e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x71d0
jmp 0x9624
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rsi
movb $0x1, (%rsi)
addq $0x10, %rdi
pushq $0x5
popq %rcx
xorl %edx, %edx
callq 0x9d70
testb %al, %al
je 0x9706
movl 0x50(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0x9dc6
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::reactor()
reactor::reactor():
    m_fd( epoll_create1(EPOLL_CLOEXEC) ), m_running(true)
{
    if( m_fd == -1 )
        throw_unix_error(errno, "epoll_create1");
    m_resources.max_load_factor(1.0);
    m_resources.reserve(100000);
    m_readables.reserve(256);
    m_readables_copy.reserve(256);
    m_drop_req.reserve(256);
    m_drop_req_copy.reserve(256);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x80000, %edi          # imm = 0x80000
callq 0x76c0
movl %eax, (%r15)
movb $0x1, 0x4(%r15)
leaq 0x8(%r15), %rbx
leaq 0x38(%r15), %rcx
movq %rcx, 0x8(%r15)
movq $0x1, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movl $0x3f800000, 0x28(%r15) # imm = 0x3F800000
leaq 0x40(%r15), %r14
leaq 0x58(%r15), %r12
leaq 0x78(%r15), %r13
leaq 0x90(%r15), %rbp
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x60(%r15)
movb $0x0, 0x70(%r15)
movups %xmm0, 0x78(%r15)
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x98(%r15)
movups %xmm0, 0xa8(%r15)
movups %xmm0, 0xb8(%r15)
movups %xmm0, 0xc8(%r15)
cmpl $-0x1, %eax
je 0x980b
movl $0x3f800000, 0x28(%r15) # imm = 0x3F800000
andq $0x0, 0x30(%r15)
movl $0x186a0, %esi          # imm = 0x186A0
movq %rbx, %rdi
callq 0xa2b2
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x9e04
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
callq 0x9e04
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
callq 0x9e04
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
callq 0x9e04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7030
movl (%rax), %edi
leaq 0x1cabf(%rip), %rsi     # 0x262d8
callq 0x8513
movq %rax, (%rsp)
leaq 0xc0(%r15), %rdi
addq $0xa8, %r15
callq 0x9e9a
movq %r15, %rdi
callq 0x9e9a
movq %rbp, %rdi
callq 0xa23a
movq %r13, %rdi
callq 0xa23a
movq %r12, %rdi
callq 0xa23a
movq %r14, %rdi
callq 0xa23a
movq %rbx, %rdi
callq 0xa10c
movq (%rsp), %rdi
callq 0x7990
// File: /workspace/github_cpp_makefile_star2_O2/cybozu[P]yrmcds/cybozu/reactor.cpp
// Function: cybozu::reactor::modify_events(cybozu::resource const&, int)
void reactor::modify_events(const resource& res, int events) {
    const int fd = res.m_fd;
    struct epoll_event ev;
    ev.events = events | EPOLLET;
    ev.data.fd = fd;
    if( epoll_ctl(m_fd, EPOLL_CTL_MOD, fd, &ev) == -1 )
        throw_unix_error(errno, "epoll_ctl");
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
imull $0x3e8, %edx, %ebp      # imm = 0x3E8
callq 0x76e0
movq %rax, %r15
movb $0x1, 0x4(%r14)
movslq %ebp, %r13
movb $0x1, %al
movl $0xf4240, %ebp          # imm = 0xF4240
testb $0x1, %al
je 0x9a29
movq %r14, %rdi
callq 0x9a38
callq 0x76e0
movq %rax, %r12
subq %r15, %rax
cqto
idivq %rbp
cmpq %r13, %rax
jle 0x9a23
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9ebc
movq %r12, %r15
movb 0x4(%r14), %al
jmp 0x99f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq