LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: shijiajia[P]TinyMudo/Acceptor.cpp
// Function: TinyMuduo::Acceptor::SocketAndBind()
void Acceptor::SocketAndBind()
{
	int on=1;
	if ((m_nListenFd=socket(AF_INET, SOCK_STREAM, 0))<0) 
		std::cout<<"Socket Failed errno:"<<errno<<std::endl;
	setsockopt(m_nListenFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	fcntl(m_nListenFd,F_SETFL,O_NONBLOCK);
	m_sServerAddr.sin_family = AF_INET;
	m_sServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	m_sServerAddr.sin_port = htons(PORT);
	if (bind(m_nListenFd,(struct sockaddr *)&m_sServerAddr,sizeof(m_sServerAddr))<0) 
		std::cout<<"Socket Failed errno:"<<errno<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movq -0x18(%rbp), %rcx
movl %eax, 0x28(%rcx)
cmpl $0x0, %eax
jge 0x294e
movq 0x46b9(%rip), %rdi      # 0x6fd8
leaq 0x1778(%rip), %rsi      # 0x409e
callq 0x2140
movq %rax, -0x20(%rbp)
callq 0x2030
movq -0x20(%rbp), %rdi
movl (%rax), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x467f(%rip), %rsi      # 0x6fc8
callq 0x2170
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x2200
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
movb $0x0, %al
callq 0x2100
movq -0x18(%rbp), %rax
movw $0x2, 0x8(%rax)
xorl %edi, %edi
callq 0x2110
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x2253, %edi           # imm = 0x2253
callq 0x2040
movq -0x18(%rbp), %rsi
movw %ax, 0xa(%rsi)
movl 0x28(%rsi), %edi
addq $0x8, %rsi
movl $0x10, %edx
callq 0x2050
cmpl $0x0, %eax
jge 0x29fe
movq 0x4609(%rip), %rdi      # 0x6fd8
leaq 0x16c8(%rip), %rsi      # 0x409e
callq 0x2140
movq %rax, -0x28(%rbp)
callq 0x2030
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x45cf(%rip), %rsi      # 0x6fc8
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: shijiajia[P]TinyMudo/TcpServer.cpp
// Function: TinyMuduo::TcpServer::Start()
void TcpServer::Start()
{
	m_pAcceptor=new Acceptor(m_nEpollFd);
	m_pAcceptor->SetCallBack(this);
	m_pAcceptor->Start();
	for(;;)
	{
		int nfds=epoll_wait(m_nEpollFd,m_aEpollEvents,MAXEPOLLEVENTS,-1);
		vector< Channel *> vChannel;
		for (int i=0;i<nfds;i++)
		{
			Channel * pTemp=static_cast<Channel *> (m_aEpollEvents[i].data.ptr);
			pTemp->SetRevent(m_aEpollEvents[i].events);
			vChannel.push_back(pTemp);
		}
		for (int i=0;i<vChannel.size();i++)
		{
			vChannel[i]->HandleEvent();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x38, %edi
callq 0x2150
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movl 0x8(%rax), %esi
callq 0x2b80
jmp 0x2a46
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rax
movq %rax, 0x2ef0(%rsi)
movq 0x2ef0(%rsi), %rdi
callq 0x2bd0
movq -0x58(%rbp), %rax
movq 0x2ef0(%rax), %rdi
callq 0x2800
movq -0x58(%rbp), %rsi
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x20d0
movl %eax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2bf0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2b21
movq -0x58(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,4), %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0xc(%rax,%rcx,4), %esi
callq 0x2550
jmp 0x2ad2
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2c10
jmp 0x2ae1
jmp 0x2ae3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2a9e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x38, %esi
callq 0x2160
jmp 0x2b77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2cc0
jmp 0x2b77
movl $0x0, -0x44(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c80
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b69
movslq -0x44(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2ca0
movq (%rax), %rdi
callq 0x2510
jmp 0x2b5c
jmp 0x2b5e
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2b28
leaq -0x30(%rbp), %rdi
callq 0x2cc0
jmp 0x2a71
movq -0x10(%rbp), %rdi
callq 0x21f0
// File: shijiajia[P]TinyMudo/./Acceptor.h
// Function: TinyMuduo::Acceptor::HandleEvent()
virtual void HandleEvent()
	{
		std::cout<<"Acceptor::HandleEvent()"<<std::endl;
		struct sockaddr_in cliaddr;
		socklen_t clilen=sizeof(cliaddr);
		memset(&cliaddr,0,sizeof(cliaddr));
		int connFd=accept(m_nListenFd,(struct sockaddr *)&cliaddr,&clilen);
		if(connFd<0) std::cout<<"Accept failed errno:"<<errno<<std::endl;
		else
		{
			std::cout << "new connection from " 
	                     << "[" << inet_ntoa(cliaddr.sin_addr) 
	                     << ":" << ntohs(cliaddr.sin_port) << "]" 
	                     << " accept socket fd:" << connFd 
	                     << std::endl;
	        fcntl(connFd,F_SETFL,O_NONBLOCK);
	        m_pIAcceptorCallBack->NewConnection(connFd);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x429d(%rip), %rdi      # 0x6fd8
leaq 0x1387(%rip), %rsi      # 0x40c9
callq 0x2140
movq %rax, %rdi
movq 0x4277(%rip), %rsi      # 0x6fc8
callq 0x2170
movl $0x10, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x20f0
movq -0x30(%rbp), %rax
movl 0x28(%rax), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x2080
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x2dc5
movq 0x4247(%rip), %rdi      # 0x6fd8
leaq 0x1349(%rip), %rsi      # 0x40e1
callq 0x2140
movq %rax, -0x38(%rbp)
callq 0x2030
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x420d(%rip), %rsi      # 0x6fc8
callq 0x2170
jmp 0x2e89
movq 0x420c(%rip), %rdi      # 0x6fd8
leaq 0x1323(%rip), %rsi      # 0x40f6
callq 0x2140
movq %rax, %rdi
leaq 0x1329(%rip), %rsi      # 0x410b
callq 0x2140
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x20c0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x1311(%rip), %rsi      # 0x4120
callq 0x2140
movq %rax, -0x40(%rbp)
movzwl -0x16(%rbp), %edi
callq 0x2210
movq -0x40(%rbp), %rdi
movzwl %ax, %esi
callq 0x21d0
movq %rax, %rdi
leaq 0x12d6(%rip), %rsi      # 0x410d
callq 0x2140
movq %rax, %rdi
leaq 0x12c9(%rip), %rsi      # 0x410f
callq 0x2140
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x4168(%rip), %rsi      # 0x6fc8
callq 0x2170
movl -0x20(%rbp), %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
movb $0x0, %al
callq 0x2100
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x20(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::instance()
static Log* instance()
	{
		if (!_instance)
		{
			if (destroyed_) 
				onDeadReference();
			else 
				create();
		}
		return _instance;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x60a4(%rip)      # 0x91e0
jne 0x3155
testb $0x1, 0x60a3(%rip)      # 0x91e8
je 0x314e
callq 0x3660
jmp 0x3153
callq 0x3680
jmp 0x3155
movq 0x6084(%rip), %rax      # 0x91e0
popq %rbp
retq
nop
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline Log& log(string file, string function, 
			int linenumber, int _level, string type)
	{
#ifdef LOGGING
		LOCK;
		curLevel = _level;
		if (curLevel > level_) return *this;  
#ifdef THREAD_SAFE
		if (threadBuffers.count(boost::this_thread::get_id()))
		{
			(*output_) << threadBuffers[boost::this_thread::get_id()];
		}
#endif
		(*output_) << endl;
		(*output_) << logHeader(file,function,linenumber,_level,type); 

#ifdef THREAD_SAFE
		threadBuffers.erase(boost::this_thread::get_id());
#endif
#endif
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq %r9, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movl -0x28(%rbp), %eax
movl %eax, 0x4(%rcx)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jle 0x31b0
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x323c
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x5e09(%rip), %rsi      # 0x8fc8
callq 0x2220
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq 0x20(%rsi), %rax
movq %rax, -0x90(%rbp)
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movq %rsp, %rax
movq %rdi, (%rax)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3810
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x21b0
jmp 0x3212
leaq -0x50(%rbp), %rdi
callq 0x20d0
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x323c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20d0
jmp 0x3249
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::operator<<(fmt&)
inline Log& operator<< (fmt& f)
	{
#ifdef LOGGING
		if (curLevel <= level_) 
			appendThreadBuffer(f.str());
#endif
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jg 0x3441
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x45e0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x44f0
jmp 0x341f
leaq -0x30(%rbp), %rdi
callq 0x20d0
jmp 0x3441
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20d0
jmp 0x344b
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nop
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: fmt& fmt::operator%<int>(int const&)
fmt& operator%(const T &t) 
	{
		if (nParams < params.size())
		{
			stringstream ss; ss << t;
			params[nParams] = ss.str();
			nParams++;
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
movq 0x38(%rdi), %rax
movq %rax, -0x1d0(%rbp)
addq $0x20, %rdi
callq 0x4850
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
cmpq %rcx, %rax
jae 0x35bd
leaq -0x198(%rbp), %rdi
callq 0x2120
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x2310
jmp 0x3535
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x21d0
jmp 0x354a
movq -0x1d8(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x38(%rax), %rsi
callq 0x5b80
movq %rax, %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x2290
leaq -0x1c8(%rbp), %rdi
callq 0x20d0
movq -0x1d8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
leaq -0x198(%rbp), %rdi
callq 0x2150
jmp 0x35bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2150
jmp 0x35cd
movq -0x1d8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x2320
nopl (%rax)
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::init()
void init()
	{
		counter = 0;
		level(1); 
		resetTimer();
		output(&cout);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x3390
movq -0x10(%rbp), %rdi
callq 0x3780
movq -0x10(%rbp), %rdi
movq 0x586f(%rip), %rsi      # 0x8fd8
callq 0x3790
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::~Log()
~Log()
	{
#ifdef THREAD_SAFE
		(*output_) << threadBuffers[boost::this_thread::get_id()];
#endif
		(*output_) << endl;

		_instance = 0;
		destroyed_ = true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x57fd(%rip), %rsi      # 0x8fc8
callq 0x2220
jmp 0x37d2
movq $0x0, 0x5a03(%rip) # 0x91e0
movb $0x1, 0x5a04(%rip)      # 0x91e8
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3800
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Log::colorStr<int>(int, int, char, int const&) const
string colorStr(int color, int bold, char delimiter, const T& t) const
	{
		stringstream ss;
#ifdef OUTPUT_COLOR
		if (output_ == &cout)
			ss << "\033[" << bold << ";" << color << "m";
#endif
		ss << t;
#ifdef OUTPUT_COLOR
		if (output_ == &cout) ss << "\033[0m";
#endif
		ss << delimiter;
		return ss.str();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d8(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x2120
movq -0x1c8(%rbp), %rax
movq 0x507f(%rip), %rcx      # 0x8fd8
cmpq %rcx, 0x20(%rax)
jne 0x4005
leaq -0x1a0(%rbp), %rdi
leaq 0x210e(%rip), %rsi      # 0x607f
callq 0x21e0
movq %rax, -0x1e0(%rbp)
jmp 0x3f7f
movq -0x1e0(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2310
movq %rax, -0x1e8(%rbp)
jmp 0x3f97
movq -0x1e8(%rbp), %rdi
leaq 0x20dd(%rip), %rsi      # 0x6082
callq 0x21e0
movq %rax, -0x1f0(%rbp)
jmp 0x3fb3
movq -0x1f0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2310
movq %rax, -0x1f8(%rbp)
jmp 0x3fcb
movq -0x1f8(%rbp), %rdi
leaq 0x20ae(%rip), %rsi      # 0x6087
callq 0x21e0
jmp 0x3fe0
jmp 0x4005
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x2150
jmp 0x4087
leaq -0x1a0(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x2310
jmp 0x4019
movq -0x1c8(%rbp), %rax
movq 0x4fb1(%rip), %rcx      # 0x8fd8
cmpq %rcx, 0x20(%rax)
jne 0x4044
leaq -0x1a0(%rbp), %rdi
leaq 0x2049(%rip), %rsi      # 0x6084
callq 0x21e0
jmp 0x4042
jmp 0x4044
leaq -0x1a0(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x2280
jmp 0x4056
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x21d0
jmp 0x406b
leaq -0x1b0(%rbp), %rdi
callq 0x2150
movq -0x1d0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: void Log::appendThreadBuffer<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&)
void appendThreadBuffer(const T& t)
	{
		stringstream ss; ss << t;
#ifdef THREAD_SAFE
		threadBuffers[boost::this_thread::get_id()] += ss.str();
#endif 
#ifndef THREAD_SAFE
		(*output_) << ss.str();
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2120
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21b0
jmp 0x452c
movq -0x1d0(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x21d0
jmp 0x4553
movq -0x1d8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x21b0
jmp 0x4568
leaq -0x1c8(%rbp), %rdi
callq 0x20d0
leaq -0x198(%rbp), %rdi
callq 0x2150
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x45bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x20d0
leaq -0x198(%rbp), %rdi
callq 0x2150
movq -0x1a0(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: fmt::str[abi:cxx11]() const
string str() const
	{ 
		stringstream ss; size_t n = 0; 
		for (size_t i = 0; i < buf.length(); i++)
		{
			char c = buf[i];
			switch (c)			{
				case '%':
					if (i > 0) 
						if (buf[i-1] == '\\') continue;
					if (n >= params.size()) continue;
					ss << params[n]; n++;
					break;
				case '\\':
					if (i < buf.length()-1)
						if (buf[i+1]=='%') 
						{ ss << '%'; continue; }
				default:
					ss << c;
			}
		}
		return ss.str(); 
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2120
movq $0x0, -0x1a0(%rbp)
movq $0x0, -0x1a8(%rbp)
movq -0x1c8(%rbp), %rdi
movq -0x1a8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
callq 0x22e0
movq %rax, %rcx
movq -0x1e0(%rbp), %rax
cmpq %rcx, %rax
jae 0x4808
movq -0x1c8(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
callq 0x2260
movb (%rax), %al
movb %al, -0x1a9(%rbp)
movsbl -0x1a9(%rbp), %eax
movl %eax, -0x1e4(%rbp)
subl $0x25, %eax
je 0x46a1
jmp 0x468d
movl -0x1e4(%rbp), %eax
subl $0x5c, %eax
je 0x4773
jmp 0x47d8
cmpq $0x0, -0x1a8(%rbp)
jbe 0x46d1
movq -0x1c8(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
subq $0x1, %rsi
callq 0x2260
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x46cf
jmp 0x47f1
jmp 0x46d1
movq -0x1c8(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movq %rax, -0x1f0(%rbp)
addq $0x20, %rdi
callq 0x4850
movq %rax, %rcx
movq -0x1f0(%rbp), %rax
cmpq %rcx, %rax
jb 0x4703
jmp 0x47f1
movq -0x1c8(%rbp), %rdi
leaq -0x188(%rbp), %rax
movq %rax, -0x1f8(%rbp)
addq $0x20, %rdi
movq -0x1a0(%rbp), %rsi
callq 0x4870
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x21b0
jmp 0x4739
movq -0x1a0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1a0(%rbp)
jmp 0x47ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2150
jmp 0x4839
movq -0x1c8(%rbp), %rdi
movq -0x1a8(%rbp), %rax
movq %rax, -0x200(%rbp)
callq 0x22e0
movq %rax, %rcx
movq -0x200(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x47d6
movq -0x1c8(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
addq $0x1, %rsi
callq 0x2260
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x47d4
leaq -0x188(%rbp), %rdi
movl $0x25, %esi
callq 0x2280
jmp 0x47d2
jmp 0x47f1
jmp 0x47d6
jmp 0x47d8
leaq -0x188(%rbp), %rdi
movsbl -0x1a9(%rbp), %esi
callq 0x2280
jmp 0x47ed
jmp 0x47ef
jmp 0x47f1
movq -0x1a8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1a8(%rbp)
jmp 0x4631
movq -0x1d8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x21d0
jmp 0x481d
leaq -0x198(%rbp), %rdi
callq 0x2150
movq -0x1d0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nop
// File: WilstonOreo[P]Log/./log/Log.hpp
// Function: fmt::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void operator()(const string& s) 
	{ 
		nParams = 0; buf = s; size_t n = 0;
		for (size_t i = 0; i < s.length(); i++)
			if (s[i] == '%')
			{
				if (i > 0) 
					if (s[i-1] == '\\') continue;
				n++;
			}
		params.resize(n);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq $0x0, 0x38(%rdi)
movq -0x10(%rbp), %rsi
callq 0x2030
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x4b0b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2260
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x4afb
cmpq $0x0, -0x20(%rbp)
jbe 0x4aef
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x2260
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x4aed
jmp 0x4afd
jmp 0x4aef
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4afd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4a99
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x4b30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ALSchwalm[P]cppEvolve/examples/traveling.cpp
// Function: fitness(std::array<char, 4ul> const&)
double fitness(const Genome& ind) {
    double total = 0;
    for(auto i= 0U; i < ind.size()-1; ++i) {
        if (ind[i] < ind[i+1]) {
            total += distances.at({ind[i], ind[i+1]});
        }
        else {
            total += distances.at({ind[i+1], ind[i]});
        }
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2587
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2cc0
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x2cc0
movq %rax, %rcx
movl -0x24(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x252e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2cc0
movb (%rax), %al
movb %al, -0x16(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
incl %eax
movl %eax, %esi
callq 0x2cc0
movb (%rax), %al
movb %al, -0x15(%rbp)
leaq 0xec0e(%rip), %rdi      # 0x11120
leaq -0x16(%rbp), %rsi
callq 0x2cf0
movl (%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2577
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
incl %eax
movl %eax, %esi
callq 0x2cc0
movb (%rax), %al
movb %al, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2cc0
movb (%rax), %al
movb %al, -0x17(%rbp)
leaq 0xebc3(%rip), %rdi      # 0x11120
leaq -0x18(%rbp), %rsi
callq 0x2cf0
movl (%rax), %eax
cvtsi2sd %rax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2579
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x248b
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ALSchwalm[P]cppEvolve/examples/traveling.cpp
// Function: main
int main()
{
    //All members of the population start with route A->B->C->D
    auto generator = []() -> Genome { return {'a', 'b', 'c', 'd'}; };

    SimpleGA<Genome, 50> gaList(
        //Generator: The above generator func
        generator,

        //The above fitness function
        fitness,

        //Crossover: Take a random copy of one parent (no crossing over)
        list1d::crossover::randomCopy<Genome>,

        //Mutator: Swap two of the cities
        list1d::mutator::swap<Genome>,

        //Select the top 5 each generation ordered by lowest fitness value
        //(smaller distance is better)
        selector::top<Genome, 5, Ordering::LOWER>);

    //Evolve for 100 generations, converges on "acbd" or "dbca"
    gaList.run(100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
leaq -0x100(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
leaq -0x1(%rbp), %rsi
callq 0x2740
leaq -0x159(%rip), %rsi      # 0x2470
leaq -0x120(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x2d90
leaq 0x83d(%rip), %rsi       # 0x2e20
leaq -0x140(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x2e60
leaq 0x8f3(%rip), %rsi       # 0x2ef0
leaq -0x160(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x2f70
leaq 0x9e9(%rip), %rsi       # 0x3000
leaq -0x180(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x3060
movq -0x1b8(%rbp), %rsi
movq -0x1b0(%rbp), %rdx
movq -0x1a8(%rbp), %rcx
movq -0x1a0(%rbp), %r8
movq -0x198(%rbp), %r9
leaq -0xe0(%rbp), %rdi
callq 0x30f0
jmp 0x265b
leaq -0x180(%rbp), %rdi
callq 0x3280
leaq -0x160(%rbp), %rdi
callq 0x32a0
leaq -0x140(%rbp), %rdi
callq 0x32c0
leaq -0x120(%rbp), %rdi
callq 0x32e0
leaq -0x100(%rbp), %rdi
callq 0x3300
leaq -0xe0(%rbp), %rdi
movl $0x64, %edx
movl %edx, %esi
callq 0x3320
jmp 0x26ac
leaq -0xe0(%rbp), %rdi
callq 0x37c0
xorl %eax, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x3280
leaq -0x160(%rbp), %rdi
callq 0x32a0
leaq -0x140(%rbp), %rdi
callq 0x32c0
leaq -0x120(%rbp), %rdi
callq 0x32e0
leaq -0x100(%rbp), %rdi
callq 0x3300
jmp 0x2731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x37c0
movq -0x188(%rbp), %rdi
callq 0x21a0
nopl (%rax)
// File: CMU-SAFARI[P]SMLA/src/Scheduler.h
// Function: ramulator::RowTable<ramulator::WideIO>::get_hits(std::vector<int, std::allocator<int>>&)
int get_hits(vector<int>& addr_vec)
    {
        auto begin = addr_vec.begin();
        auto end = begin + int(T::Level::Row);

        vector<int> rowgroup(begin, end);
        int row = *end;

        auto itr = table.find(rowgroup);
        auto entry = table[rowgroup];
        if (itr == table.end() || entry.row != row)
            return 0;

        return entry.hits;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c9e0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x1ca10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1ca50
movq -0x98(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x1ca70
jmp 0x1c8a7
leaq -0x51(%rbp), %rdi
callq 0x1caf0
leaq -0x28(%rbp), %rdi
callq 0x1cb10
movq -0xa0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x68(%rbp)
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0x1cb30
movq %rax, -0xa8(%rbp)
jmp 0x1c8db
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0x1cb60
movq %rax, -0xb0(%rbp)
jmp 0x1c903
movq -0xa0(%rbp), %rdi
movq -0xb0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
callq 0x1cc70
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1cc40
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x1c95e
movl -0x80(%rbp), %eax
cmpl -0x68(%rbp), %eax
setne %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x1c96a
jmp 0x1c9ab
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0x1c9bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x1caf0
jmp 0x1c9d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1cca0
jmp 0x1c9d0
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1cca0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x65b0
nopl (%rax)
// File: CMU-SAFARI[P]SMLA/src/Refresh.h
// Function: ramulator::Refresh<ramulator::WideIO>::tick_ref()
void tick_ref() {
    clk++;

    int refresh_interval = ctrl->channel->spec->speed_entry.nREFI;

    // Time to schedule a refresh
    if ((clk - refreshed) >= refresh_interval) {
      inject_refresh(true);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x10(%rcx)
movq 0x8(%rcx), %rax
movq 0x1000(%rax), %rax
movq 0x390(%rax), %rax
movl 0x2750(%rax), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
subq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jl 0x2a2fa
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2b4e0
addq $0x20, %rsp
popq %rbp
retq
// File: CMU-SAFARI[P]SMLA/src/Processor.cpp
// Function: ramulator::Processor::tick()
void Processor::tick() {
  cpu_cycles++;
  if (!(no_core_caches && no_shared_cache)) {
    cachesys->tick();
  }
  for (unsigned int i = 0 ; i < cores.size() ; ++i) {
    Core* core = cores[i].get();
    core->tick();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x738, %rdi            # imm = 0x738
xorl %esi, %esi
callq 0x29c60
movq -0x20(%rbp), %rax
testb $0x1, 0x39(%rax)
je 0x6c5e6
movq -0x20(%rbp), %rax
testb $0x1, 0x3a(%rax)
jne 0x6c5fb
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x64630
movq %rax, %rdi
callq 0x63470
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x6f4c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c64c
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x6f400
movq %rax, %rdi
callq 0x6f4e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6c660
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c602
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::Operon::betterEq((anonymous namespace)::Operon const&) const
bool betterEq (const Operon &other) const
    {  if (al1->targetName != other. al1->targetName)
         return false;
       if (! other. insideEq (*this, 3 * slack))  // PAR
         return false;
     #ifdef PROT_MATCH
       if (perfect () > other. perfect ())
         return true;
       if (perfect () < other. perfect ())
         return false;
     #endif
       return getIdentity () >= other. getIdentity ();
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
addq $0x58, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
addq $0x58, %rsi
callq 0x37c60
testb $0x1, %al
jne 0x25fd6
jmp 0x25fdd
movb $0x0, 0x27(%rsp)
jmp 0x2602a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl $0x5a, %edx
callq 0x2cbc0
testb $0x1, %al
jne 0x25ffc
movb $0x0, 0x27(%rsp)
jmp 0x2602a
movq 0x8(%rsp), %rdi
callq 0x25f10
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x25f10
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::BlastAlignment::perfect() const
bool perfect () const
    { return    ! truncated ()
             && ! partial ()
             && ! c_extended ()  // redundant
             && ! frameshift
             && ! stopCodon;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x26f60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x29d2d
movq (%rsp), %rdi
callq 0x27040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x29d2d
movq (%rsp), %rdi
callq 0x289d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x29d2d
movq (%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0x51(%rcx)
movb %al, 0xf(%rsp)
jne 0x29d2d
movq (%rsp), %rax
movb 0x50(%rax), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: andrakis[P]alisp/ALisp.cpp
// Function: show_help()
void show_help() {
	std::cerr << "ALisp v " << alisp_version_str << std::endl;
	std::cerr << std::endl;
	std::cerr << "Usage:" << std::endl;
	std::cerr << "alisp [-i] [-t] [-T] [-d] [file] [args]" << std::endl;
	std::cerr << "Where:" << std::endl;
	std::cerr << "\t-i             Interactive mode (REPL)" << std::endl;
	std::cerr << "\t-t             Display timing information" << std::endl;
	std::cerr << "\t-T             Run tests" << std::endl;
	std::cerr << "\t-d             Debug mode" << std::endl;
	std::cerr << "\tfile           File to parse and execute" << std::endl;
	std::cerr << "\targs           Arguments to pass" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x4ccb5(%rip), %rdi     # 0x56ff0
leaq 0x31d3f(%rip), %rsi     # 0x3c081
callq 0x83e0
movq %rax, %rdi
leaq 0x334ff(%rip), %rsi     # 0x3d850
callq 0x83e0
movq %rax, %rdi
movq 0x4cc30(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cc84(%rip), %rdi     # 0x56ff0
movq 0x4cc1d(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cc71(%rip), %rdi     # 0x56ff0
leaq 0x31d04(%rip), %rsi     # 0x3c08a
callq 0x83e0
movq %rax, %rdi
movq 0x4cbfb(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cc4f(%rip), %rdi     # 0x56ff0
leaq 0x31ce9(%rip), %rsi     # 0x3c091
callq 0x83e0
movq %rax, %rdi
movq 0x4cbd9(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cc2d(%rip), %rdi     # 0x56ff0
leaq 0x31cef(%rip), %rsi     # 0x3c0b9
callq 0x83e0
movq %rax, %rdi
movq 0x4cbb7(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cc0b(%rip), %rdi     # 0x56ff0
leaq 0x31cd4(%rip), %rsi     # 0x3c0c0
callq 0x83e0
movq %rax, %rdi
movq 0x4cb95(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cbe9(%rip), %rdi     # 0x56ff0
leaq 0x31cda(%rip), %rsi     # 0x3c0e8
callq 0x83e0
movq %rax, %rdi
movq 0x4cb73(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cbc7(%rip), %rdi     # 0x56ff0
leaq 0x31ce3(%rip), %rsi     # 0x3c113
callq 0x83e0
movq %rax, %rdi
movq 0x4cb51(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cba5(%rip), %rdi     # 0x56ff0
leaq 0x31cdb(%rip), %rsi     # 0x3c12d
callq 0x83e0
movq %rax, %rdi
movq 0x4cb2f(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cb83(%rip), %rdi     # 0x56ff0
leaq 0x31cd4(%rip), %rsi     # 0x3c148
callq 0x83e0
movq %rax, %rdi
movq 0x4cb0d(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x4cb61(%rip), %rdi     # 0x56ff0
leaq 0x31cdc(%rip), %rsi     # 0x3c172
callq 0x83e0
movq %rax, %rdi
movq 0x4caeb(%rip), %rsi     # 0x56f90
callq 0x8460
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/./timekeeping.hpp
// Function: std::tuple<long, ALisp::Cell> ALisp::Timekeeping::timeCallbackResult<ALisp::Cell, main::$_0, std::chrono::duration<long, std::ratio<1l, 1000l>>, long>(main::$_0)
std::tuple<Time, Result> timeCallbackResult(Callback callback) {
			auto start = ClockType::now();
			Result result = callback();
			auto finish = ClockType::now();
			auto duration = std::chrono::duration_cast<Resolution>(finish - start);
			return std::make_tuple((Time)duration.count(), result);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x8090
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xb6f0
callq 0x8090
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x174e0
movq %rax, -0x58(%rbp)
jmp 0xb540
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x174b0
movq %rax, -0x70(%rbp)
jmp 0xb557
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x17570
movq %rax, -0x78(%rbp)
jmp 0xb56e
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x17530
jmp 0xb589
leaq -0x20(%rbp), %rdi
callq 0xb9d0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb9d0
movq -0x40(%rbp), %rdi
callq 0x87b0
nopl (%rax)
// File: andrakis[P]alisp/./timekeeping.hpp
// Function: long ALisp::Timekeeping::timeCall<main::$_2, std::chrono::duration<long, std::ratio<1l, 1000l>>, long>(main::$_2)
Time timeCall(Callback callback) {
			auto start = ClockType::now();
			callback();
			auto finish = ClockType::now();
			auto duration = std::chrono::duration_cast<Resolution>(finish - start);
			return (Time)duration.count();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x8090
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xb7a0
callq 0x8090
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x174e0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x174b0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x17570
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/./environment.hpp
// Function: ALisp::Environment::create(ALisp::Cell const&, ALisp::Cell)
void create(const Cell &cell, val_type val) {
			switch (cell.type()) {
				case CellType::Atom: return create(cell.atomId(), val);
				case CellType::String: return create(Atoms::Declare(cell.str().c_str()), val);
				default: throw Exception("Cannot convert cell to atom");
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd3a0
movl %eax, %ecx
movl %ecx, -0x88(%rbp)
subl $0x1, %eax
je 0xbaf1
jmp 0xbae1
movl -0x88(%rbp), %eax
subl $0x4, %eax
je 0xbb5c
jmp 0xbc1a
movq -0x10(%rbp), %rdi
callq 0xd430
movq -0x98(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xb900
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0xd3f0
jmp 0xbb34
leaq -0x20(%rbp), %rdi
callq 0xb9d0
jmp 0xbcdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb9d0
jmp 0xbce4
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xd4b0
movq -0xb0(%rbp), %rdi
callq 0x81e0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x17fe0
jmp 0xbb8a
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xb900
jmp 0xbb9c
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0xbaa0
jmp 0xbbb2
leaq -0x60(%rbp), %rdi
callq 0xb9d0
leaq -0x38(%rbp), %rdi
callq 0xb9d0
leaq -0x58(%rbp), %rdi
callq 0x8878
jmp 0xbcdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xbc0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xbc03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb9d0
leaq -0x38(%rbp), %rdi
callq 0xb9d0
leaq -0x58(%rbp), %rdi
callq 0x8878
jmp 0xbce4
movb $0x1, -0x82(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0xc0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x87d0
movq -0xb8(%rbp), %rdx
leaq 0x306a9(%rip), %rsi     # 0x3c2fc
leaq -0x80(%rbp), %rdi
callq 0x8610
jmp 0xbc5e
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xd550
jmp 0xbc70
movq -0xc0(%rbp), %rdi
movb $0x0, -0x82(%rbp)
leaq 0x4a0e3(%rip), %rsi     # 0x55d68
leaq 0x1934(%rip), %rdx      # 0xd5c0
callq 0x8770
jmp 0xbced
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xbcb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x8878
leaq -0x81(%rbp), %rdi
callq 0x8490
testb $0x1, -0x82(%rbp)
jne 0xbccd
jmp 0xbcd9
movq -0xc0(%rbp), %rdi
callq 0x8300
jmp 0xbce4
addq $0xc0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x87b0
nopl (%rax)
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::Cell::operator==(ALisp::Cell const&) const
bool operator==(const Cell &other) const {
			// Special case: no implementation, nothing is equal
			if (!pImpl) return false;
			// Special case: comparison to self
			if (other.pImpl == pImpl) return true;
			return pImpl->equals(other);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xcd90
testb $0x1, %al
jne 0xbfa7
movb $0x0, -0x1(%rbp)
jmp 0xbfdb
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xedc0
testb $0x1, %al
jne 0xbfba
jmp 0xbfc0
movb $0x1, -0x1(%rbp)
jmp 0xbfdb
movq -0x20(%rbp), %rdi
callq 0xcdc0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x78(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::add(ALisp::Cell const&)
void add(const Cell &other) EXCEPT final override {
				Cell to_add = other;
				if (other.type() != CellType::List) {
					to_add = ListTypeCell<ValueType, CellTypeType>();
					to_add.push(other);
				}
				_value.insert(_value.end(), to_add.cbegin(), to_add.cend());
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xb900
jmp 0x1214a
movq -0x10(%rbp), %rdi
callq 0xd3a0
movl %eax, -0x64(%rbp)
jmp 0x12158
movl -0x64(%rbp), %eax
cmpl $0x5, %eax
je 0x121d0
leaq -0x30(%rbp), %rdi
callq 0x137c0
jmp 0x1216b
leaq -0x18(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x30(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0x13810
movq -0x78(%rbp), %rdi
callq 0xbd80
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13840
jmp 0x12198
jmp 0x121d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x121bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb9d0
cmpl $0x0, -0x24(%rbp)
jge 0x12267
movq -0x20(%rbp), %rdi
callq 0x8590
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x88(%rbp)
callq 0xc5c0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x13960
leaq -0x18(%rbp), %rdi
callq 0x139a0
movq %rax, -0x80(%rbp)
jmp 0x12204
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13ac0
movq %rax, -0x90(%rbp)
jmp 0x1221e
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x138b0
movq %rax, -0x98(%rbp)
jmp 0x1224a
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb9d0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87b0
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::equals(ALisp::Cell const&) const
bool equals(const Cell &other) const final override {
				if (type() != other.type()) return false;
				auto it1 = cbegin();
				auto it2 = other.cbegin();
				for (; it1 != cend() && it2 != cend(); ++it1, ++it2) {
					if (*it1 != *it2) return false;
				}
				return it1 == cend() && it2 == other.cend();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xd600
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd3a0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
je 0x122ab
movb $0x0, -0x1(%rbp)
jmp 0x123a7
movq -0x58(%rbp), %rdi
callq 0x12710
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x139a0
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rdi
callq 0x12740
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12d80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0x122ed
jmp 0x1230a
movq -0x58(%rbp), %rdi
callq 0x12740
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12d80
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x12313
jmp 0x1235a
leaq -0x20(%rbp), %rdi
callq 0x12df0
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12df0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x14c90
testb $0x1, %al
jne 0x1233b
jmp 0x12341
movb $0x0, -0x1(%rbp)
jmp 0x123a7
jmp 0x12343
leaq -0x20(%rbp), %rdi
callq 0x12e10
leaq -0x28(%rbp), %rdi
callq 0x12e10
jmp 0x122c5
movq -0x58(%rbp), %rdi
callq 0x12740
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14cc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x12382
jmp 0x1239f
movq -0x18(%rbp), %rdi
callq 0x13ac0
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14cc0
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::index(unsigned long) const
Cell index(size_t i) const EXCEPT final override {
				if (i >= size())
					return Nil;
				auto it = cbegin() + i;
				return *it;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x12590
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x126af
movq -0x58(%rbp), %rdi
leaq 0x454cd(%rip), %rsi     # 0x57b58
callq 0xb900
jmp 0x12692
jmp 0x126f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x126fa
movq -0x20(%rbp), %rdi
callq 0x8590
movq -0x48(%rbp), %rdi
callq 0x12710
movq %rax, -0x60(%rbp)
jmp 0x126be
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x15050
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x12df0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xb900
jmp 0x126ee
jmp 0x126f0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::str_or_repr[abi:cxx11](bool) const
StringType str_or_repr(bool str) const {
				std::ostringstream ss;
				ss << stringOpen(str);
				for (auto it = _value.cbegin(); it != _value.cend(); ++it) {
					if (it != _value.cbegin())
						ss << " ";
					ss << (str ? it->str() : it->repr());
				}
				ss << stringClose();
				return ss.str();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x230(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x85f0
movq -0x220(%rbp), %rsi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
leaq -0x1b0(%rbp), %rdi
callq 0x13540
jmp 0x1331e
leaq -0x190(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x8390
jmp 0x13333
leaq -0x1b0(%rbp), %rdi
callq 0x8878
movq -0x220(%rbp), %rdi
addq $0x10, %rdi
callq 0x12f00
movq %rax, -0x1c8(%rbp)
movq -0x220(%rbp), %rdi
addq $0x10, %rdi
callq 0x12f30
movq %rax, -0x1d0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x12d80
testb $0x1, %al
jne 0x13389
jmp 0x134a3
movq -0x220(%rbp), %rdi
addq $0x10, %rdi
callq 0x12f00
movq %rax, -0x1d8(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x12d80
testb $0x1, %al
jne 0x133b9
jmp 0x1340a
leaq 0x29839(%rip), %rsi     # 0x3cbf9
leaq -0x190(%rbp), %rdi
callq 0x83e0
jmp 0x133ce
jmp 0x1340a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x13528
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x8878
jmp 0x13528
testb $0x1, -0x11(%rbp)
je 0x1342f
leaq -0x1c8(%rbp), %rdi
callq 0x13690
movq %rax, %rsi
leaq -0x1f8(%rbp), %rdi
callq 0xd4b0
jmp 0x1342d
jmp 0x1344e
leaq -0x1c8(%rbp), %rdi
callq 0x13690
movq %rax, %rsi
leaq -0x1f8(%rbp), %rdi
callq 0x136b0
jmp 0x1344c
jmp 0x1344e
leaq -0x190(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x8390
jmp 0x13463
leaq -0x1f8(%rbp), %rdi
callq 0x8878
leaq -0x1c8(%rbp), %rdi
callq 0x12e10
jmp 0x13356
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x8878
jmp 0x13528
movq -0x220(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x13750
jmp 0x134b8
leaq -0x190(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x8390
jmp 0x134cd
leaq -0x218(%rbp), %rdi
callq 0x8878
movq -0x230(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x8430
jmp 0x134ee
leaq -0x190(%rbp), %rdi
callq 0x8130
movq -0x228(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x8878
leaq -0x190(%rbp), %rdi
callq 0x8130
movq -0x1b8(%rbp), %rdi
callq 0x87b0