LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x281c(%rip), %rdi      # 0x4fd8
leaq 0x923(%rip), %rsi       # 0x30e6
callq 0x2130
movq %rax, %rdi
callq 0x20d0
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl 0x28(%rbx), %edi
callq 0x2070
testl %eax, %eax
js 0x28a2
movl %eax, %ebp
movq 0x27d9(%rip), %rdi      # 0x4fd8
leaq 0x90d(%rip), %rsi       # 0x3113
callq 0x2130
leaq 0x916(%rip), %rsi       # 0x3128
movq %rax, %rdi
callq 0x2130
movq %rax, %r14
movl 0x14(%rsp), %edi
callq 0x20b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2130
leaq 0x905(%rip), %rsi       # 0x313d
movq %rax, %rdi
callq 0x2130
movzwl 0x12(%rsp), %ecx
rolw $0x8, %cx
movzwl %cx, %esi
movq %rax, %rdi
callq 0x21b0
leaq 0x8cf(%rip), %rsi       # 0x312a
movq %rax, %rdi
callq 0x2130
leaq 0x8c2(%rip), %rsi       # 0x312c
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
movl %ebp, %esi
callq 0x21c0
movq %rax, %rdi
callq 0x20d0
pushq $0x4
popq %rsi
movl %ebp, %edi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x2100
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *(%rax)
jmp 0x28cf
movq 0x272f(%rip), %rdi      # 0x4fd8
leaq 0x84e(%rip), %rsi       # 0x30fe
callq 0x2130
movq %rax, %rbx
callq 0x2030
movl (%rax), %esi
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::instance()
static Log* instance()
	{
		if (!_instance)
		{
			if (destroyed_) 
				onDeadReference();
			else 
				create();
		}
		return _instance;
	}

// Assembly:
cmpq $0x0, 0x46da(%rip)      # 0x7160
jne 0x2aa2
pushq %rax
cmpb $0x1, 0x46d8(%rip)      # 0x7168
jne 0x2a99
callq 0x2d18
jmp 0x2a9e
callq 0x2d44
addq $0x8, %rsp
movq 0x46b7(%rip), %rax      # 0x7160
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl %r8d, 0x4(%rdi)
cmpl %r8d, (%rdi)
jl 0x2b1c
movq %r9, %r13
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq 0x20(%rbx), %rdi
callq 0x20a0
movq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r13, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x2de8
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2160
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl (%rdi), %eax
jg 0x2be3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x35ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3566
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, 0x38(%rdi)
jae 0x2cc5
movq %rsi, %r14
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
movl (%r14), %esi
callq 0x2230
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x2210
movq 0x38(%rbx), %rdi
shlq $0x5, %rdi
addq 0x20(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2090
incq 0x38(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x2cd5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::onDeadReference()
static void onDeadReference()
	{
		create();
		new(_instance) Log;
#ifdef ATEXIT_FIXED
		atexit(killPhoenixLog);
#endif
		destroyed_ = false;
	}

// Assembly:
pushq %rax
callq 0x2d44
movq 0x443b(%rip), %rax      # 0x7160
andl $0x0, 0x8(%rax)
movl $0x1, (%rax)
movq 0x42a2(%rip), %rcx      # 0x6fd8
movq %rcx, 0x20(%rax)
movb $0x0, 0x4427(%rip)      # 0x7168
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x20(%rdi), %rdi
callq 0x20a0
andq $0x0, 0x4394(%rip)      # 0x7160
movb $0x1, 0x4395(%rip)      # 0x7168
popq %rax
retq
movq %rax, %rdi
callq 0x2ddd
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x20e0
movq 0x20(%r14), %rax
cmpq 0x3dde(%rip), %rax      # 0x6fd8
jne 0x3241
leaq 0x10(%rsp), %rdi
leaq 0xe77(%rip), %rsi       # 0x407f
callq 0x2180
movq %rax, %rdi
movl %r13d, %esi
callq 0x2230
leaq 0xe63(%rip), %rsi       # 0x4082
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movl %r12d, %esi
callq 0x2230
leaq 0xe4e(%rip), %rsi       # 0x4087
movq %rax, %rdi
callq 0x2180
leaq 0x10(%rsp), %r12
movl (%r15), %esi
movq %r12, %rdi
callq 0x2230
movq 0x20(%r14), %rax
cmpq 0x3d7c(%rip), %rax      # 0x6fd8
jne 0x326d
leaq 0xe1f(%rip), %rsi       # 0x4084
movq %r12, %rdi
callq 0x2180
movsbl %bpl, %esi
movq %r12, %rdi
callq 0x21c0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x2160
movq 0x20(%rbx), %rbx
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x2210
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2160
movq %rsp, %rdi
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x2110
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
jmp 0x35d8
jmp 0x35d5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x18(%rsp), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rdx
cmpq %rdx, %r12
jae 0x368c
movq (%r14), %rax
movzbl (%rax,%r12), %ecx
cmpl $0x5c, %ecx
je 0x3668
cmpl $0x25, %ecx
jne 0x367a
testq %r12, %r12
je 0x363d
cmpb $0x5c, -0x1(%rax,%r12)
je 0x3687
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0x3687
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0x2160
incq %r13
jmp 0x3687
decq %rdx
cmpq %rdx, %r12
jae 0x367a
movb $0x25, %dl
cmpb $0x25, 0x1(%rax,%r12)
je 0x367c
movl %ecx, %edx
movsbl %dl, %esi
movq %r15, %rdi
callq 0x21c0
incq %r12
jmp 0x3615
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x36b9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x38(%rdi)
callq 0x20c0
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %esi, %esi
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x377c
cmpb $0x25, (%rax,%rdx)
jne 0x3777
testq %rdx, %rdx
je 0x3774
cmpb $0x5c, -0x1(%rax,%rdx)
je 0x3777
incq %rsi
incq %rdx
jmp 0x375d
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
pushq $0x1
popq %r13
leaq 0x5d3b(%rip), %r14      # 0x8110
leaq -0x2c(%rbp), %r15
leaq -0x2a(%rbp), %r12
cmpq $0x4, %r13
je 0x242f
movsd %xmm0, -0x38(%rbp)
movb -0x1(%rbx,%r13), %al
movb (%rbx,%r13), %cl
cmpb %cl, %al
jge 0x2403
movb %al, -0x2c(%rbp)
movb %cl, -0x2b(%rbp)
movq %r14, %rdi
movq %r15, %rsi
jmp 0x240f
movb %cl, -0x2a(%rbp)
movb %al, -0x29(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2654
movl (%rax), %eax
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd -0x38(%rbp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incq %r13
jmp 0x23dd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq 0x171(%rip), %rax       # 0x25cc
movq %rax, 0x18(%rsi)
leaq 0x172(%rip), %rax       # 0x25d8
movq %rax, 0x10(%rsi)
leaq -0xb0(%rbp), %rdx
andq $0x0, 0x8(%rdx)
leaq -0xcb(%rip), %rax       # 0x23b2
movq %rax, (%rdx)
leaq 0xc01(%rip), %rax       # 0x3088
movq %rax, 0x18(%rdx)
leaq -0x90(%rbp), %rcx
andq $0x0, 0x8(%rcx)
leaq 0xbf8(%rip), %rax       # 0x3096
movq %rax, 0x10(%rdx)
leaq 0x1fa(%rip), %rax       # 0x26a3
movq %rax, (%rcx)
leaq 0xc0b(%rip), %rax       # 0x30be
movq %rax, 0x18(%rcx)
leaq 0xc10(%rip), %rax       # 0x30ce
movq %rax, 0x10(%rcx)
leaq -0x70(%rbp), %r8
andq $0x0, 0x8(%r8)
leaq 0x1f5(%rip), %rax       # 0x26c7
movq %rax, (%r8)
leaq 0xc1a(%rip), %rax       # 0x30f6
movq %rax, 0x18(%r8)
leaq -0x50(%rbp), %r9
andq $0x0, 0x8(%r9)
leaq 0xc14(%rip), %rax       # 0x3104
movq %rax, 0x10(%r8)
leaq 0x20e(%rip), %rax       # 0x2709
movq %rax, (%r9)
leaq 0x19e3(%rip), %rax      # 0x3ee8
movq %rax, 0x18(%r9)
leaq 0x19e2(%rip), %rax      # 0x3ef2
movq %rax, 0x10(%r9)
leaq -0x188(%rbp), %rdi
callq 0x273c
leaq -0x50(%rbp), %rdi
callq 0x3fba
leaq -0x70(%rbp), %rdi
callq 0x3fba
leaq -0x90(%rbp), %rdi
callq 0x3fba
leaq -0xb0(%rbp), %rdi
callq 0x3fba
leaq -0x30(%rbp), %rdi
callq 0x3fba
leaq -0x188(%rbp), %rdi
pushq $0x64
popq %rdx
movl %edx, %esi
callq 0x2836
leaq -0x188(%rbp), %rdi
callq 0x2af8
xorl %eax, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x188(%rbp), %rdi
callq 0x2af8
jmp 0x25c3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3fba
leaq -0x70(%rbp), %rdi
callq 0x3fba
leaq -0x90(%rbp), %rdi
callq 0x3fba
leaq -0xb0(%rbp), %rdi
callq 0x3fba
leaq -0x30(%rbp), %rdi
callq 0x3fba
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/anagrams.cpp
// Function: SortAnagramList(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>>>>*)
void SortAnagramList(vector<string>* list) {
    if(list == nullptr) {
        return;
    }
    unordered_map<string, vector<string>> table;
    for(auto s : (*list)) {
        string tmp(s);
        sort(tmp.begin(), tmp.end());
        table[tmp].push_back(s);
    }
    int index = 0;
    for(auto anagrams : table) {
        for(auto astr : anagrams.second) {
            (*list)[index++] = astr;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x2446
movq %rdi, %rbx
leaq 0x90(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq (%rdi), %r14
movq 0x8(%rdi), %rbp
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x60(%rsp), %r13
cmpq %rbp, %r14
je 0x23be
movq %r15, %rdi
movq %r14, %rsi
callq 0x2170
movq %r12, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rdi, %rsi
callq 0x29db
movq %r13, %rdi
movq %r12, %rsi
callq 0x2dba
movq %rax, %rdi
movq %r15, %rsi
callq 0x26b8
movq %r12, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2090
addq $0x20, %r14
jmp 0x2365
movq 0x70(%rsp), %rax
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
testq %rax, %rax
je 0x243c
movq %rax, (%rsp)
leaq 0x8(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x26e4
movq 0x48(%rsp), %r12
movq 0x50(%rsp), %r14
movslq %r13d, %r13
movq %r13, %rbp
shlq $0x5, %rbp
cmpq %r14, %r12
je 0x2429
movq %r15, %rdi
movq %r12, %rsi
callq 0x2170
movq (%rbx), %rdi
addq %rbp, %rdi
movq %r15, %rsi
callq 0x20c0
incq %r13
movq %r15, %rdi
callq 0x2090
addq $0x20, %r12
addq $0x20, %rbp
jmp 0x23f6
leaq 0x28(%rsp), %rdi
callq 0x271e
movq (%rsp), %rax
movq (%rax), %rax
jmp 0x23cb
leaq 0x60(%rsp), %rdi
callq 0x291e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x245f
movq %rax, %rbx
jmp 0x2471
movq %rax, %rbx
jmp 0x2499
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
callq 0x2090
jmp 0x2499
movq %rax, %rbx
jmp 0x248f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
callq 0x271e
leaq 0x60(%rsp), %rdi
callq 0x291e
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/anagrams.cpp
// Function: main
int main(int argc, char *argv[])
{
    vector<string> list;
    list.push_back("dog");
    list.push_back("something");
    list.push_back("god");
    list.push_back("licker");
    list.push_back("dice");
    list.push_back("kicler");
    list.push_back("cide");
    SortAnagramList(&list);
    for(auto str : list) {
        cout << str << endl;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x1b39(%rip), %rsi      # 0x4004
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x1b0e(%rip), %rsi      # 0x4008
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x1ae9(%rip), %rsi      # 0x4012
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x1abe(%rip), %rsi      # 0x4016
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x1a96(%rip), %rsi      # 0x401d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x1a6c(%rip), %rsi      # 0x4022
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x1a44(%rip), %rsi      # 0x4029
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2734
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33e2
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x30(%rsp), %rdi
callq 0x230c
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r12
leaq 0x10(%rsp), %r14
movq 0x49ab(%rip), %r15      # 0x6fd8
cmpq %r12, %rbx
je 0x265e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2170
movq %r15, %rdi
movq %r14, %rsi
callq 0x2120
movq %rax, %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2090
addq $0x20, %rbx
jmp 0x262d
leaq 0x30(%rsp), %rdi
callq 0x2770
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2694
jmp 0x2699
jmp 0x2694
jmp 0x2699
jmp 0x2694
jmp 0x2699
jmp 0x2694
jmp 0x2699
jmp 0x2694
jmp 0x2699
jmp 0x2694
jmp 0x2699
jmp 0x2694
jmp 0x2699
jmp 0x2694
movq %rax, %rbx
jmp 0x26a6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x30(%rsp), %rdi
callq 0x2770
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]SMLA/src/Main.cpp
// Function: void run_cputrace<ramulator::WideIO>(ramulator::Config const&, ramulator::Memory<ramulator::WideIO, ramulator::Controller>&, std::vector<char const*, std::allocator<char const*>> const&)
void run_cputrace(const Config& configs, Memory<T, Controller>& memory, const std::vector<const char *>& files)
{
    int cpu_tick = configs.get_cpu_tick();
    int mem_tick = configs.get_mem_tick();
    auto send = bind(&Memory<T, Controller>::send, &memory, placeholders::_1);
    Processor proc(configs, files, send, memory);
    for (long i = 0; ; i++) {
        proc.tick();
        Stats::curTick++; // processor clock, global, for Statistics
        if (i % cpu_tick == (cpu_tick - 1))
            for (int j = 0; j < mem_tick; j++)
                memory.tick();
      if (configs.calc_weighted_speedup()) {
        if (proc.has_reached_limit()) {
          break;
        }
      } else {
        if (configs.is_early_exit()) {
          if (proc.finished())
              break;
        } else {
          if (proc.finished() && (memory.pending_requests() == 0))
              break;
        }
      }
    }
    // This a workaround for statistics set only initially lost in the end
    memory.finish();
    Stats::statlist.printall();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x3c(%rdi), %rax
movq %rax, 0x10(%rsp)
movl 0x40(%rdi), %r12d
leaq 0x50(%rsp), %r15
movq $0x21, (%r15)
andq $0x0, 0x8(%r15)
movq %rsi, 0x10(%r15)
leaq 0x18(%rsp), %rdi
movq %rdx, %rsi
callq 0x13d80
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x13dce
leaq 0x68(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r14, %rsi
movq %rbx, %r8
callq 0x28264
leaq 0x30(%rsp), %rdi
callq 0x2564a
leaq 0x18(%rsp), %rdi
callq 0x737c
movq 0x10(%rsp), %rax
decl %eax
movslq %eax, %rbp
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
movl %r12d, 0xc(%rsp)
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x288de
leaq 0x46187(%rip), %rax     # 0x515e0
incq (%rax)
movq %r15, %rax
cqto
idivq 0x10(%rsp)
cmpq %rbp, %rdx
jne 0xb481
movl 0xc(%rsp), %r13d
subl $0x1, %r13d
jb 0xb481
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
jmp 0xb470
cmpq $0x0, 0x48(%r14)
je 0xb492
movq %r12, %rdi
callq 0x28ea0
jmp 0xb4a6
movq %r14, %rdi
callq 0x13e16
testb %al, %al
je 0xb4af
movq %r12, %rdi
callq 0x28d72
testb %al, %al
jne 0xb4c8
incq %r15
jmp 0xb44a
movq %r12, %rdi
callq 0x28d72
testb %al, %al
je 0xb4aa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0xb4aa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
leaq 0x45ef0(%rip), %rdi     # 0x513c8
callq 0x13ece
leaq 0x68(%rsp), %rdi
callq 0x13f50
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2564a
jmp 0xb50b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x737c
jmp 0xb528
jmp 0xb51b
jmp 0xb51b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x13f50
movq %rbx, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0xc(%r14), %rdx
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0xe83e
movl 0xc(%r14), %r13d
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xe9bc
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xe870
addq $0x10, %rbx
xorl %ecx, %ecx
movl $0x0, %ebp
cmpl %r13d, (%rax)
jne 0xe805
movl 0x4(%rax), %ebp
cmpq %rbx, %r14
cmovel %ecx, %ebp
leaq 0x10(%rsp), %rdi
callq 0xe932
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe828
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe932
movq %rbx, %rdi
callq 0x54a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
incq %rcx
movq %rcx, 0x10(%rdi)
movq 0x1000(%rax), %rax
movq 0x390(%rax), %rax
movslq 0x2750(%rax), %rax
subq 0x18(%rdi), %rcx
cmpq %rax, %rcx
jge 0x11ad6
retq
pushq $0x1
popq %rsi
jmp 0x1209a
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x7a8(%rdi), %xmm0
addsd 0xb763(%rip), %xmm0     # 0x34058
movsd %xmm0, 0x7a8(%rdi)
cmpb $0x1, 0x39(%rdi)
jne 0x28909
cmpb $0x0, 0x3a(%rbx)
jne 0x28912
movq 0x50(%rbx), %rdi
callq 0x26b6c
xorl %eax, %eax
movl %eax, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x28939
movq (%rax,%r14,8), %rdi
callq 0x28942
leal 0x1(%r14), %eax
jmp 0x28914
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]SMLA/src/SMLA_DIO.cpp
// Function: ramulator::SMLA_DIO::init_rowhit()
void SMLA_DIO::init_rowhit()
{
    // RD
    rowhit[int(Level::Bank)][int(Command::RD)] = [] (DRAM<SMLA_DIO>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened):
                if (node->row_state.find(id) != node->row_state.end())
                    return true;
                return false;
            default: assert(false);
        }};

    // WR
    rowhit[int(Level::Bank)][int(Command::WR)] = rowhit[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xcc0(%rdi), %r14
movups 0xcc0(%rdi), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xcc0(%rbx)
movups 0xcd0(%rbx), %xmm0
leaq 0x1296(%rip), %rax      # 0x2f4ce
movq %rax, 0xcd0(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0x1220(%rip), %rax      # 0x2f46a
movq %rax, 0xcd8(%rbx)
callq 0x2564a
addq $0xce0, %rbx            # imm = 0xCE0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f96c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]SMLA/src/SMLA_DIO.cpp
// Function: ramulator::SMLA_DIO::init_rowopen()
void SMLA_DIO::init_rowopen()
{
    // RD
    rowopen[int(Level::Bank)][int(Command::RD)] = [] (DRAM<SMLA_DIO>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened): return true;
            default: assert(false);
        }};

    // WR
    rowopen[int(Level::Bank)][int(Command::WR)] = rowopen[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1440(%rdi), %r14
movups 0x1440(%rdi), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1440(%rbx)
movups 0x1450(%rbx), %xmm0
leaq 0x1278(%rip), %rax      # 0x2f51e
movq %rax, 0x1450(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0x122e(%rip), %rax      # 0x2f4e6
movq %rax, 0x1458(%rbx)
callq 0x2564a
addq $0x1460, %rbx           # imm = 0x1460
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f96c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
addq $0x58, %rdi
movq (%rsi), %rsi
addq $0x58, %rsi
callq 0x1bae9
testb %al, %al
jne 0x16b2b
movq (%rbx), %rax
movb 0x98(%rax), %dl
movq (%r14), %rcx
cmpb 0x98(%rcx), %dl
jne 0x16b2b
movq 0x30(%rax), %rdx
addq $0x5a, %rdx
cmpq 0x30(%rcx), %rdx
jb 0x16b2b
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
cmovneq %rdx, %rax
movq 0x8(%r14), %rdx
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq 0x38(%rcx), %rcx
addq $0x5a, %rcx
cmpq %rcx, 0x38(%rax)
jbe 0x16b35
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x16a5e
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x16a5e
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
setae %al
jmp 0x16b2d
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::Operon::reportLess((anonymous namespace)::Operon const&, (anonymous namespace)::Operon const&)
static bool reportLess (const Operon &a,
                          const Operon &b)
    { LESS_PART (a, b, al1->targetName);
      LESS_PART (a, b, al1->targetStart);
      LESS_PART (a, b, al1->targetEnd);
      LESS_PART (b, a, al1->targetStrand);
      LESS_PART (a, b, hasAl2 ());
      // Tie resolution
      LESS_PART (a, b, al1->refAccession);
      LESS_PART (a, b, getRefAccession2 ());
      return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
addq $0x58, %rdi
movq (%rsi), %rsi
addq $0x58, %rsi
callq 0x1a81a
movb $0x1, %bl
testb %al, %al
jne 0x1710b
movq (%r15), %rdi
addq $0x58, %rdi
movq (%r14), %rsi
addq $0x58, %rsi
callq 0x1a81a
testb %al, %al
je 0x170f8
xorl %ebx, %ebx
jmp 0x1710b
movq (%r14), %rdi
movq 0x30(%rdi), %rax
movq (%r15), %rsi
movq 0x30(%rsi), %rcx
cmpq %rcx, %rax
jae 0x1711c
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
ja 0x170f4
movq 0x38(%rdi), %rax
movq 0x38(%rsi), %rcx
cmpq %rcx, %rax
jb 0x1710b
ja 0x170f4
movb 0x98(%rsi), %al
movb 0x98(%rdi), %cl
cmpb %cl, %al
jb 0x1710b
ja 0x170f4
movq 0x8(%r14), %rax
testq %rax, %rax
sete %dl
movq 0x8(%r15), %rcx
testq %rcx, %rcx
setne %r8b
testb %r8b, %dl
jne 0x1710b
testq %rcx, %rcx
sete %cl
testq %rax, %rax
setne %al
testb %cl, %al
jne 0x170f4
movl $0xa0, %r12d
addq %r12, %rdi
addq %r12, %rsi
callq 0x1a81a
testb %al, %al
jne 0x1710b
movq (%r15), %rdi
addq %r12, %rdi
addq (%r14), %r12
movq %r12, %rsi
callq 0x1a81a
testb %al, %al
jne 0x170f4
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1831a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1831a
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1a81a
movl %eax, %ebp
movq %r13, %rdi
callq 0xab28
movq %r12, %rdi
callq 0xab28
testb %bpl, %bpl
jne 0x1710b
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1831a
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x1831a
leaq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a81a
movq %r14, %rdi
callq 0xab28
movq %rbx, %rdi
callq 0xab28
jmp 0x170f4
jmp 0x17227
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xab28
movq %rbx, %rdi
callq 0xa9f0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::stxType_reported_operon2elementName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string stxType_reported_operon2elementName (const string &stxType_reported,
                                            const string &operon)
{
  string elementName (stxType_reported  + " operon");
       if (operon == "FRAMESHIFT")
    elementName += " with frameshift";
  else if (operon == "INTERNAL_STOP")
    elementName += " with internal stop";
  else if (contains (operon, "PARTIAL"))
    elementName = "Partial " + elementName;
  else if (operon == "EXTENDED")
    elementName = "Extended " + elementName;
  else if (contains (operon, "NOVEL"))
    elementName = "Novel " + elementName;
    
  return elementName;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x3978d(%rip), %rdx     # 0x50f09
callq 0x194be
leaq 0x396f9(%rip), %rsi     # 0x50e81
movq %r14, %rdi
callq 0x1b235
testb %al, %al
je 0x1779d
leaq 0x39776(%rip), %rsi     # 0x50f11
jmp 0x177b7
leaq 0x396e8(%rip), %rsi     # 0x50e8c
movq %r14, %rdi
callq 0x1b235
testb %al, %al
je 0x177c4
leaq 0x3976b(%rip), %rsi     # 0x50f22
movq %rbx, %rdi
callq 0xaa80
jmp 0x17899
leaq 0x396fc(%rip), %rsi     # 0x50ec7
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x18af0
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b862
movl %eax, %ebp
movq %r15, %rdi
callq 0xab28
testb %bpl, %bpl
je 0x1780f
leaq 0x39736(%rip), %rsi     # 0x50f36
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a4be
jmp 0x17881
leaq 0x396a8(%rip), %rsi     # 0x50ebe
movq %r14, %rdi
callq 0x1b235
testb %al, %al
je 0x17838
leaq 0x39716(%rip), %rsi     # 0x50f3f
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a4be
jmp 0x17881
leaq 0x39b94(%rip), %rsi     # 0x513d3
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x18af0
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b862
movl %eax, %ebp
movq %r15, %rdi
callq 0xab28
testb %bpl, %bpl
je 0x17899
leaq 0x396d5(%rip), %rsi     # 0x50f49
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a4be
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6d0
movq %r14, %rdi
callq 0xab28
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x178b1
jmp 0x178b1
jmp 0x178b1
jmp 0x178b1
jmp 0x178b1
movq %rax, %r14
movq %rbx, %rdi
callq 0xab28
movq %r14, %rdi
callq 0xa9f0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::BlastAlignment::perfect() const
bool perfect () const
    { return    ! truncated ()
             && ! partial ()
             && ! c_extended ()  // redundant
             && ! frameshift
             && ! stopCodon;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x17314
testb %al, %al
jne 0x17b0f
movq %rbx, %rdi
callq 0x1736e
testb %al, %al
jne 0x17b0f
cmpq $0x0, 0x18(%rbx)
jne 0x17b09
movq 0x20(%rbx), %rax
incq %rax
cmpq 0x28(%rbx), %rax
je 0x17b0f
cmpb $0x0, 0x51(%rbx)
je 0x17b13
xorl %eax, %eax
popq %rbx
retq
movb 0x50(%rbx), %al
xorb $0x1, %al
jmp 0x17b11
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::BlastAlignment::refMap[abi:cxx11](unsigned long) const
string refMap (size_t len) const
    { QC_ASSERT (refLen <= len);
      string s = string (refStart, '-'); 
      FFOR (size_t, i, refSeq. size ())
        if (refSeq [i] != '-')
          s += targetSeq [i];
      s += string (len - refEnd, '-'); 
      return s;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa060
andl $0x0, (%rax)
cmpq %rbx, 0x28(%r15)
ja 0x184ba
movq 0x18(%r15), %rsi
leaq 0x10(%r14), %rax
movq %rax, (%r14)
pushq $0x2d
popq %rdx
movq %r14, %rdi
callq 0xa650
movq 0xc8(%r15), %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x18472
movq 0xc0(%r15), %rax
cmpb $0x2d, (%rax,%r13)
je 0x1846d
movq 0x78(%r15), %rax
movsbl (%rax,%r13), %esi
movq %r14, %rdi
callq 0xa4d0
incq %r13
jmp 0x18449
subq 0x20(%r15), %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %rdi
pushq $0x2d
popq %rdx
movq %rbx, %rsi
callq 0xa650
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xaac0
leaq 0x10(%rsp), %rdi
callq 0xab28
movq %r14, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xa6a0
testl %eax, %eax
jne 0x1858e
leaq 0x3821a(%rip), %rsi     # 0x506e8
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x18af0
leaq 0x70(%rsp), %rdi
movl $0x1d6, %esi            # imm = 0x1D6
callq 0x1a2c7
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x19646
leaq 0x381ee(%rip), %rdx     # 0x506fe
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x19582
leaq 0x38ecb(%rip), %rsi     # 0x513f7
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x18af0
leaq 0x3968a(%rip), %rdx     # 0x51bcc
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x19582
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x19646
leaq 0x38ec8(%rip), %rdx     # 0x5143a
leaq 0x10(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x19582
leaq 0x10(%rsp), %rdi
callq 0x1ccf0
pushq $0x1
popq %rdi
callq 0xa6b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xab28
jmp 0x185a8
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xab28
jmp 0x185ba
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xab28
jmp 0x185c9
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xab28
jmp 0x185d8
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xab28
jmp 0x185ea
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xab28
jmp 0x185fc
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xab28
jmp 0x1860b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x18631
movq %rax, %rbx
jmp 0x18636
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xab28
jmp 0x1862e
jmp 0x1862b
movq %rax, %rbx
movq %r14, %rdi
callq 0xab28
movq %rbx, %rdi
callq 0xa9f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq 0x22c7a(%rip), %rbx     # 0x2aff0
leaq 0x13d00(%rip), %rsi     # 0x1c07d
movq %rbx, %rdi
callq 0x72d0
leaq 0x155ec(%rip), %rsi     # 0x1d978
movq %rax, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
movq %rbx, %rdi
callq 0x71a0
leaq 0x13cdb(%rip), %rsi     # 0x1c086
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13ccb(%rip), %rsi     # 0x1c08d
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13cdc(%rip), %rsi     # 0x1c0b5
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13ccc(%rip), %rsi     # 0x1c0bc
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13cdd(%rip), %rsi     # 0x1c0e4
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13cf1(%rip), %rsi     # 0x1c10f
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13cf4(%rip), %rsi     # 0x1c129
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13cf8(%rip), %rsi     # 0x1c144
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x71a0
leaq 0x13d0b(%rip), %rsi     # 0x1c16e
movq %rbx, %rdi
callq 0x72d0
movq %rax, %rdi
popq %rbx
jmp 0x71a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x90a4
movq (%r14), %rax
testq %rax, %rax
je 0xaf83
cmpl $0x5, 0x8(%rax)
je 0xafc6
leaq 0x8(%rsp), %rdi
callq 0xb658
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
movq %rax, (%rsp)
testq %rdi, %rdi
je 0xafbb
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xafbb
movq (%rdi), %rax
callq *0x10(%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0xb678
movq 0x18(%rbx), %r14
movq %rsp, %rdi
callq 0xb6b4
movq %rax, %r15
movq %rsp, %rdi
callq 0xb762
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xb694
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb001
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb017
jmp 0xb017
movq %rdx, %r14
movq %rax, %rbx
jmp 0xb02c
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb02c
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
testl %r14d, %r14d
jns 0xb039
callq 0x7430
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0xb05c
movl 0x8(%rcx), %ecx
jmp 0xb05e
xorl %ecx, %ecx
cmpl %ecx, %eax
jne 0xb09d
movq 0x10(%r14), %r12
movq %rbx, %rdi
callq 0xb6b4
movq %rax, %r15
movq 0x18(%r14), %rax
cmpq %rax, %r12
je 0xb098
cmpq %rax, %r15
je 0xb098
movq %r12, %rdi
movq %r15, %rsi
callq 0xbad6
testb %al, %al
jne 0xb09d
addq $0x8, %r12
addq $0x8, %r15
jmp 0xb071
cmpq %rax, %r12
je 0xb0ab
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xb762
cmpq %rax, %r15
sete %al
jmp 0xb09f
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
jbe 0xb1a6
leaq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x90a4
jmp 0xb1b5
leaq 0x2087b(%rip), %rsi     # 0x2ba28
movq %rbx, %rdi
callq 0x90a4
movq %rbx, %rax
popq %rbx
retq
jmp 0xb1bc
movq %rax, %rdi
testl %edx, %edx
jns 0xb1c8
callq 0x7430
callq 0x7600
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7480
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb5a2
movq %rbx, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x72b0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7688
movq 0x10(%r14), %r12
leaq 0x30(%rsp), %r13
leaq 0x1177a(%rip), %rbx     # 0x1cc47
cmpq 0x18(%r14), %r12
je 0xb51a
cmpq 0x10(%r14), %r12
je 0xb4e4
movq %r13, %rdi
movq %rbx, %rsi
callq 0x72d0
testb %bpl, %bpl
je 0xb4f6
movq %r15, %rdi
movq %r12, %rsi
callq 0x975c
jmp 0xb501
movq %r15, %rdi
movq %r12, %rsi
callq 0xb5fe
movq %r13, %rdi
movq %r15, %rsi
callq 0x72b0
movq %r15, %rdi
callq 0x7688
addq $0x8, %r12
jmp 0xb4cd
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xb636
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x72b0
movq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %rdi
callq 0x7688
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x30(%rsp), %rdi
callq 0x70d0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb57d
jmp 0xb582
jmp 0xb57d
jmp 0xb582
jmp 0xb57d
jmp 0xb57d
movq %rax, %rbx
jmp 0xb58f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7688
leaq 0x30(%rsp), %rdi
callq 0x70d0
movq %rbx, %rdi
callq 0x7600
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::stringOpen[abi:cxx11](bool) const
StringType stringOpen(bool str_or_repr) const {
				switch (type()) {
					case CellType::Lambda: return "(#ref:lambda "; 
					case CellType::Macro: return "(#ref:macro "; 
					//case CellType::Tuple: return "(tuple ";
					default: return (str_or_repr ? "(" : "(list ");
				}
			}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x7, %eax
je 0xb5c5
cmpl $0x6, %eax
jne 0xb5d3
leaq 0x10e42(%rip), %rsi     # 0x1c400
leaq 0xf(%rsp), %rdx
jmp 0xb5ec
leaq 0x10e42(%rip), %rsi     # 0x1c40e
leaq 0xe(%rsp), %rdx
jmp 0xb5ec
leaq 0x11510(%rip), %rax     # 0x1caea
leaq 0x10e3a(%rip), %rsi     # 0x1c41b
testb %dl, %dl
cmovneq %rax, %rsi
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x7150
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop