LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3024
movq %r9, %r13
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq 0x20(%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
movl %ecx, 0x14(%rsp)
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq 0x20(%rbx), %r14
movq %r13, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl 0x14(%rsp), %r8d
movl %ebp, %r9d
callq 0x3272
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x21c0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3024
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3054
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3197
movq %rsi, %r14
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
movl (%r14), %esi
callq 0x2200
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x21f0
movq 0x38(%rbx), %rdi
shlq $0x5, %rdi
addq 0x20(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x21d0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3175
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
incq 0x38(%rbx)
movq 0x3e40(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x31a7
movq %rax, %rbx
movq 0x3e0f(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq 0x20(%rdi), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq $0x0, 0x3ef3(%rip) # 0x7148
movb $0x1, 0x3ef4(%rip)      # 0x7150
popq %rbx
retq
movq %rax, %rdi
callq 0x3266
// File: /workspace/github_cpp_makefile_star2_O3/WilstonOreo[P]Log/./log/Log.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Log::colorStr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int, int, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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 $0x198, %rsp            # imm = 0x198
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq 0x20(%r14), %rax
cmpq 0x34f2(%rip), %rax      # 0x6fd8
jne 0x3b41
leaq 0x20(%rsp), %rdi
leaq 0x158b(%rip), %rsi      # 0x507f
movl $0x2, %edx
callq 0x21c0
leaq 0x20(%rsp), %rdi
movl %r13d, %esi
callq 0x2200
movq %rax, %r13
leaq 0x156d(%rip), %rsi      # 0x5082
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq %r13, %rdi
movl %r12d, %esi
callq 0x2200
leaq 0x1553(%rip), %rsi      # 0x5087
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
leaq 0x20(%rsp), %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x21c0
movq 0x20(%r14), %rax
cmpq 0x3478(%rip), %rax      # 0x6fd8
jne 0x3b76
leaq 0x151b(%rip), %rsi      # 0x5084
movl $0x4, %edx
movq %r12, %rdi
callq 0x21c0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x21c0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21f0
movq 0x3421(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x33eb(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%r14), %rdx
callq 0x21c0
movq 0x20(%rbx), %rbx
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x21f0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x21c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cf2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x32c7(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d40
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x3d40
jmp 0x3d3d
movq %rax, %rbx
movq 0x3279(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3e3b
leaq 0x20(%rsp), %r15
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
xorl %ebp, %ebp
movq (%r14), %rcx
movzbl (%rcx,%rbp), %edx
cmpl $0x5c, %edx
je 0x3df1
cmpl $0x25, %edx
jne 0x3e17
testq %rbp, %rbp
je 0x3dc0
cmpb $0x5c, -0x1(%rcx,%rbp)
je 0x3e2b
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rcx, %r13
jae 0x3e2b
movq %r13, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r15, %rdi
callq 0x21c0
incq %r13
jmp 0x3e2b
decq %rax
cmpq %rax, %rbp
jae 0x3e17
cmpb $0x25, 0x1(%rcx,%rbp)
jne 0x3e17
movb $0x25, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
jmp 0x3e2b
movb %dl, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
incq %rbp
movq 0x8(%r14), %rax
cmpq %rax, %rbp
jb 0x3da3
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21f0
movq 0x3171(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e7d
movq %rax, %rbx
movq 0x3139(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $0x0, 0x38(%rdi)
callq 0x20b0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3fba
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpb $0x25, (%rcx,%rdx)
jne 0x3fb0
testq %rdx, %rdx
je 0x3fad
cmpb $0x5c, -0x1(%rcx,%rdx)
je 0x3fb0
incq %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x3f9b
jmp 0x3fbc
xorl %esi, %esi
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3fd0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14a68
movl 0xc(%r14), %r13d
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x14be0
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x14aaa
movl (%rax), %r15d
movl 0x4(%rax), %ebp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14a21
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52d0
addq $0x10, %rbx
xorl %eax, %eax
cmpl %r13d, %r15d
cmovnel %eax, %ebp
cmpq %rbx, %r14
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14a46
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14a60
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52d0
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1822a
retq
movl $0x1, %esi
jmp 0x1891a
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x7a8(%rdi), %xmm0
addsd 0xf460(%rip), %xmm0     # 0x4e098
movsd %xmm0, 0x7a8(%rdi)
cmpb $0x1, 0x39(%rdi)
jne 0x3ec4c
cmpb $0x0, 0x3a(%rbx)
jne 0x3ec55
movq 0x50(%rbx), %rdi
callq 0x3ccda
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x3ec85
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x3ec8c
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x3ec65
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups 0xcc0(%rdi), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xcc0(%rdi)
movq 0xcd0(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x1e90(%rip), %rcx      # 0x47dec
movq %rcx, 0xcd0(%rdi)
movq 0xcd8(%rdi), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x1df4(%rip), %rcx      # 0x47d6a
movq %rcx, 0xcd8(%rdi)
testq %rax, %rax
je 0x45f8f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xcc0(%rbx), %rsi
addq $0xce0, %rbx            # imm = 0xCE0
movq %rbx, %rdi
callq 0x4830e
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x7cd9
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups 0x1440(%rdi), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x1440(%rdi)
movq 0x1450(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x1e58(%rip), %rcx      # 0x47e3c
movq %rcx, 0x1450(%rdi)
movq 0x1458(%rdi), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x1e06(%rip), %rcx      # 0x47e04
movq %rcx, 0x1458(%rdi)
testq %rax, %rax
je 0x46017
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x1440(%rbx), %rsi
addq $0x1460, %rbx           # imm = 0x1460
movq %rbx, %rdi
callq 0x4830e
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x7cd9
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x60(%rdi), %rdx
cmpq 0x60(%rbx), %rdx
jne 0x206fd
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rdx, %rdx
je 0x206be
movq 0x58(%rbx), %rsi
movq 0x58(%r15), %rdi
callq 0xa5a0
testl %eax, %eax
jne 0x206fd
movb 0x98(%rbx), %al
cmpb 0x98(%r15), %al
jne 0x206fd
movq 0x30(%rbx), %rax
addq $0x5a, %rax
cmpq 0x30(%r15), %rax
jb 0x206fd
testq %r14, %r14
movq %r14, %rax
cmoveq %rbx, %rax
testq %r12, %r12
movq %r12, %rcx
cmoveq %r15, %rcx
movq 0x38(%rcx), %rcx
addq $0x5a, %rcx
cmpq %rcx, 0x38(%rax)
jbe 0x2070b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r15), %rcx
testq %r12, %r12
je 0x20722
addq 0x8(%r12), %rcx
movq (%r12), %rax
addq (%r15), %rax
jmp 0x20725
movq (%r15), %rax
movq %rcx, %xmm3
movq 0x588de(%rip), %xmm1    # 0x79010
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movapd 0x588e2(%rip), %xmm2    # 0x79020
subpd %xmm2, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
addsd %xmm3, %xmm0
movq %rax, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
divsd %xmm4, %xmm0
movq 0x8(%rbx), %rcx
testq %r14, %r14
je 0x20780
addq 0x8(%r14), %rcx
movq (%r14), %rax
addq (%rbx), %rax
jmp 0x20783
movq (%rbx), %rax
movq %rcx, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
movq %rax, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm1
unpckhpd %xmm3, %xmm1            # xmm1 = xmm1[1],xmm3[1]
addsd %xmm3, %xmm1
divsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
setae %al
jmp 0x206ff
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
addq %rsi, %rdx
callq 0x23e50
leaq 0x5861b(%rip), %rsi     # 0x79ebe
movq %rbx, %rdi
callq 0xaa80
leaq 0x58584(%rip), %rsi     # 0x79e36
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x21961
leaq 0x58578(%rip), %rsi     # 0x79e41
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x2196a
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x58593(%rip), %rsi     # 0x79e7c
leaq 0x58593(%rip), %rdx     # 0x79e83
movq %rsp, %rdi
callq 0x26c92
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xa9a0
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x21924
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa580
cmpq $-0x1, %r15
je 0x21987
leaq 0x585ba(%rip), %rsi     # 0x79eeb
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x25be4
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6c0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x21979
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa580
jmp 0x21979
leaq 0x5855e(%rip), %rsi     # 0x79ec6
jmp 0x21971
leaq 0x58566(%rip), %rsi     # 0x79ed7
movq %rbx, %rdi
callq 0xaa80
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x584e5(%rip), %rsi     # 0x79e73
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x219fc
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x58a15(%rip), %rsi     # 0x7a3bc
leaq 0x58a13(%rip), %rdx     # 0x7a3c1
callq 0x26c92
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xa9a0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x219df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa580
cmpq $-0x1, %r14
je 0x21979
leaq 0x58512(%rip), %rsi     # 0x79efe
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x25be4
jmp 0x2193c
leaq 0x584f1(%rip), %rsi     # 0x79ef4
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x25be4
jmp 0x2193c
jmp 0x21a1f
jmp 0x21a1f
jmp 0x21a1f
jmp 0x21a1f
jmp 0x21a1f
jmp 0x21a1f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x21a36
movq (%r12), %rsi
incq %rsi
callq 0xa580
movq %r14, %rdi
callq 0xa9d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2138e
testb %al, %al
jne 0x21e0c
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %xmm0
movq 0x57260(%rip), %xmm1    # 0x79010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x57264(%rip), %xmm2    # 0x79020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq 0x28(%rbx), %rdx
movq %rdx, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
movsd 0x57283(%rip), %xmm0    # 0x79078
ucomisd %xmm3, %xmm0
ja 0x21e0c
incq %rcx
xorq %rdx, %rcx
orq %rcx, %rax
je 0x21e0c
cmpb $0x0, 0x51(%rbx)
je 0x21e10
xorl %eax, %eax
popq %rbx
retq
movb 0x50(%rbx), %al
xorb $0x1, %al
jmp 0x21e0e
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rsi), %rsi
testq %rsi, %rsi
je 0xc662
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0x8(%rsp), %r15
movq (%r14), %rax
movq %r15, (%rsp)
testq %rax, %rax
je 0xc66d
cmpl $0x5, 0x8(%rax)
jne 0xc66d
jmp 0xc6b4
movq $0x0, (%rsp)
xorl %r15d, %r15d
movl $0x28, %edi
callq 0x7310
movl $0x5, 0x8(%rax)
leaq 0x20843(%rip), %rcx     # 0x2cec8
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%rsp)
testq %r15, %r15
je 0xc6a9
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0xce90
movq 0x18(%rbx), %r14
movq %rsp, %rdi
callq 0xceac
movq %rax, %r15
movq %rsp, %rdi
callq 0xcf74
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xd03c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc6ef
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0xc71a
jmp 0xc705
jmp 0xc705
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc71a
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
testl %r14d, %r14d
jns 0xc727
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movl 0x8(%rdi), %eax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0xc74a
movl 0x8(%rcx), %ecx
jmp 0xc74c
xorl %ecx, %ecx
cmpl %ecx, %eax
jne 0xc7ac
movq 0x10(%r15), %r12
movq %rbx, %rdi
callq 0xceac
movq %rax, %r14
movq 0x18(%r15), %rax
cmpq %rax, %r12
setne %cl
cmpq %rax, %r14
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc7a7
movq (%r12), %rdi
testq %rdi, %rdi
je 0xc7ac
cmpq %rdi, (%r14)
je 0xc795
movq (%rdi), %rax
movq %r14, %rsi
callq *0x78(%rax)
testb %al, %al
je 0xc7ac
movq 0x18(%r15), %rax
addq $0x8, %r12
addq $0x8, %r14
cmpq %rax, %r12
je 0xc7a7
cmpq %rax, %r14
jne 0xc776
cmpq %rax, %r12
je 0xc7ba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xcf74
cmpq %rax, %r14
sete %al
jmp 0xc7ae
// File: /workspace/github_cpp_makefile_star2_O3/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 0x74c0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xcdde
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x73d0
movq %rbx, 0x28(%rsp)
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xcc7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
movq 0x10(%r14), %r12
cmpq 0x18(%r14), %r12
je 0xccfa
leaq 0x8(%rsp), %r13
leaq 0x30(%rsp), %rbx
cmpq 0x10(%r14), %r12
je 0xccaa
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x13fe2(%rip), %rsi     # 0x20c87
callq 0x73d0
testb %bpl, %bpl
je 0xccbc
movq %r13, %rdi
movq %r12, %rsi
callq 0xac9c
jmp 0xccc7
movq %r13, %rdi
movq %r12, %rsi
callq 0xce56
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x73d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xccf0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
addq $0x8, %r12
cmpq 0x18(%r14), %r12
jne 0xcc90
movq %r15, 0x8(%rsp)
movw $0x29, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x73d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
movq 0x28(%rsp), %rbx
je 0xcd3d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7580
movq 0x21267(%rip), %rsi     # 0x2dfb8
leaq 0x30(%rsp), %rdi
callq 0x71e0
leaq 0xa0(%rsp), %rdi
callq 0x7120
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcd98
jmp 0xcd9d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xcdaa
jmp 0xcdb7
jmp 0xcd98
jmp 0xcd98
movq %rax, %rbx
jmp 0xcdb7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xcdb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
movq 0x211fa(%rip), %rsi     # 0x2dfb8
leaq 0x30(%rsp), %rdi
callq 0x71e0
leaq 0xa0(%rsp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x7, %eax
je 0xce06
cmpl $0x6, %eax
jne 0xce1d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1362d(%rip), %rsi     # 0x2042a
leaq 0x13633(%rip), %rdx     # 0x20437
jmp 0xce49
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13624(%rip), %rsi     # 0x20438
leaq 0x13629(%rip), %rdx     # 0x20444
jmp 0xce49
leaq 0x13d06(%rip), %rax     # 0x20b2a
leaq 0x1361a(%rip), %rsi     # 0x20445
testb %dl, %dl
cmovneq %rax, %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
xorb $0x1, %dl
movzbl %dl, %eax
leaq (%rax,%rax,4), %rax
leaq (%rsi,%rax), %rdx
incq %rdx
movq %rbx, %rdi
callq 0xb160
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/./cell.hpp
// Function: ALisp::StringTypeCell<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (ALisp::CellType)4>::IStringCell::integerValue() const
IntegerType integerValue() const EXCEPT final override {
				auto isInteger = tryStringToNumber<IntegerType>(_value);
				if (std::get<0>(isInteger))
					return std::get<1>(isInteger);
				else throw Exception("Failed to convert to integer: " + str());
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0xdde5
cmpb $0x1, 0x28(%rsp)
jne 0xd826
movq 0x20(%rsp), %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xb0ca
leaq 0x12c27(%rip), %rsi     # 0x2047e
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
callq 0xde7e
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0x1f443(%rip), %rsi     # 0x2ccc0
leaq -0x2b64(%rip), %rdx     # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rdx, %r15
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd8ad
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7330
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xd8c3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0xd8ee
jmp 0xd8fe
movq %rdx, %r15
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xd8ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xd8ee
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
jmp 0xd8fe
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xd90b
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/./cell.hpp
// Function: ALisp::StringTypeCell<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (ALisp::CellType)4>::IStringCell::floatValue() const
FloatType floatValue() const EXCEPT final override {
				auto isFloat = tryStringToNumber<FloatType>(_value);
				if (std::get<0>(isFloat))
					return std::get<1>(isFloat);
				else throw Exception("Failed to convert to float: " + str());
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0xdeee
cmpb $0x1, 0x28(%rsp)
jne 0xd947
movsd 0x20(%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xb0ca
leaq 0x12b25(%rip), %rsi     # 0x2049d
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
callq 0xde7e
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0x1f322(%rip), %rsi     # 0x2ccc0
leaq -0x2c85(%rip), %rdx     # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rdx, %r15
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd9ce
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7330
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xd9e4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0xda0f
jmp 0xda1f
movq %rdx, %r15
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xda0f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xda0f
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
jmp 0xda1f
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xda2c
callq 0x7480
callq 0x7630
nop
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/./cell.hpp
// Function: std::tuple<bool, long> ALisp::tryStringToNumber<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::tuple<bool, T> tryStringToNumber(const std::string &str) {
		T value;
		std::stringstream stream(str);
		stream >> value;
		return std::make_tuple(!stream.fail(), value);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x7590
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7340
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
sete 0x8(%rbx)
movq 0x20153(%rip), %rsi     # 0x2df88
callq 0x7290
leaq 0x90(%rsp), %rdi
callq 0x7120
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20129(%rip), %rsi     # 0x2df88
leaq 0x10(%rsp), %rdi
callq 0x7290
leaq 0x90(%rsp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::ToString[abi:cxx11](unsigned long)
std::string ToString(AtomType id) EXCEPT {
			auto it = detail::atom_to_string.find(id);
			if (it != detail::atom_to_string.end())
				return it->second;
			throw Exception("atomid " + std::to_string(id) + " not found");
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq 0x204e6(%rip), %rcx     # 0x2e578
testq %rcx, %rcx
je 0xe0f4
movq %rdi, %rbx
leaq 0x204cf(%rip), %rax     # 0x2e570
xorl %edx, %edx
cmpq %r14, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xe0a1
leaq 0x204b1(%rip), %rcx     # 0x2e570
cmpq %rcx, %rax
je 0xe0f4
cmpq %r14, 0x20(%rax)
ja 0xe0f4
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xb0ca
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe879
leaq 0x125af(%rip), %rsi     # 0x206c2
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
callq 0xde7e
leaq 0x125a3(%rip), %rsi     # 0x206ca
leaq 0x40(%rsp), %rdi
callq 0x7680
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe154
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xe161
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0x1eb2f(%rip), %rsi     # 0x2ccc0
leaq -0x3478(%rip), %rdx     # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rdx, %r15
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xe1c8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe1c8
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe1e3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7330
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe1fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0xe236
jmp 0xe23e
movq %rdx, %r15
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe236
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe236
movq %rdx, %r15
movq %rax, %r14
jmp 0xe23e
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
movq %r14, %rdi
testl %r15d, %r15d
jns 0xe24b
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::Get(unsigned long)
Cell Get(AtomType id) EXCEPT {
			auto it = detail::atom_to_cell.find(id);
			if (it == detail::atom_to_cell.end())
				throw Exception("atomid " + std::to_string(id) + " not found");
			return it->second;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq 0x202b1(%rip), %rcx     # 0x2e5d8
testq %rcx, %rcx
je 0xe38e
movq %rdi, %rbx
leaq 0x2029a(%rip), %rax     # 0x2e5d0
xorl %edx, %edx
cmpq %r14, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xe336
leaq 0x2027c(%rip), %rcx     # 0x2e5d0
cmpq %rcx, %rax
je 0xe38e
cmpq %r14, 0x20(%rax)
ja 0xe38e
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0xe379
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *(%rax)
movq 0x20(%rsp), %rax
jmp 0xe37b
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe879
leaq 0x12315(%rip), %rsi     # 0x206c2
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xde7e
leaq 0x12309(%rip), %rsi     # 0x206ca
leaq 0x20(%rsp), %rdi
callq 0x7680
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe3ee
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xe3fb
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0x1e895(%rip), %rsi     # 0x2ccc0
leaq -0x3712(%rip), %rdx     # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rdx, %r15
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0xe462
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe462
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe47d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7330
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe498
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0xe4d0
jmp 0xe4d8
movq %rdx, %r15
movq %rax, %r14
jmp 0xe4d8
movq %rdx, %r15
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4d0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe4d0
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
movq %r14, %rdi
testl %r15d, %r15d
jns 0xe4e5
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::Get(char const*)
Cell Get(const char *name) EXCEPT {
			auto it = detail::string_to_atom.find(StringType(name));
			if (it == detail::string_to_atom.end())
				throw Exception("atom " + StringType(name) + " not found");
			return Get(it->second);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7160
leaq 0x20084(%rip), %rdi     # 0x2e598
leaq 0x8(%rsp), %rsi
callq 0xeadc
movq %rax, %r15
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xe53d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
leaq 0x2005c(%rip), %rax     # 0x2e5a0
cmpq %rax, %r15
je 0xe567
movq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0xe311
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7160
leaq 0x12148(%rip), %rsi     # 0x206d5
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xde7e
leaq 0x12127(%rip), %rsi     # 0x206ca
leaq 0x8(%rsp), %rdi
callq 0x7680
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe5cf
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xe5dc
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0x1e6b4(%rip), %rsi     # 0x2ccc0
leaq -0x38f3(%rip), %rdx     # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rdx, %r15
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xe643
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe643
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe65a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe675
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0xe6a5
jmp 0xe6da
movq %rdx, %r15
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe6a5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe6a5
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
jmp 0xe6da
jmp 0xe6d4
movq %rdx, %r15
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe6da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe6da
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xe6e7
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::Declare(char const*)
Cell Declare(const char *name) EXCEPT {
			if (Exists(name))
				return Get(name);
			AtomType id = detail::atom_counter++;
			AtomCell atom(id);
			detail::atom_to_cell.emplace(id, atom);
			detail::atom_to_string.emplace(id, StringType(name));
			detail::string_to_atom.emplace(StringType(name), id);
			return atom;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe291
testb %al, %al
je 0xe717
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe4ea
jmp 0xe7f0
movq 0x1feda(%rip), %r15     # 0x2e5f8
leaq 0x1(%r15), %rax
movq %rax, 0x1fecf(%rip)     # 0x2e5f8
movq %r15, 0x10(%rsp)
movl $0x18, %edi
callq 0x7310
movl $0x1, 0x8(%rax)
leaq 0x1e9e2(%rip), %rcx     # 0x2d128
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x1fe6c(%rip), %rdi     # 0x2e5c8
leaq 0x10(%rsp), %rsi
callq 0xecaa
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x7160
leaq 0x1fde9(%rip), %rdi     # 0x2e568
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xee9c
leaq 0x28(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xe7a9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7330
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x7160
leaq 0x1fdd6(%rip), %rdi     # 0x2e598
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xf030
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xe7e8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7330
movq 0x38(%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
jne 0xe825
jmp 0xe83c
jmp 0xe836
movq %rdx, %r14
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe83c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0xe83c
jmp 0xe836
movq %rdx, %r14
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xe856
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0xe856
jmp 0xe850
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0xe863
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/ConvertUTF.cpp
// Function: linenoise_ng::ConvertUTF32toUTF16(unsigned int const**, unsigned int const*, char16_t**, char16_t*, linenoise_ng::ConversionFlags)
ConversionResult ConvertUTF32toUTF16 (
        const UTF32** sourceStart, const UTF32* sourceEnd, 
        char16_t** targetStart, char16_t* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF32* source = *sourceStart;
    char16_t* target = *targetStart;
    while (source < sourceEnd) {
        UTF32 ch;
        if (target >= targetEnd) {
            result = targetExhausted; break;
        }
        ch = *source++;
        if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
            /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
            if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
                if (flags == strictConversion) {
                    --source; /* return to the illegal value itself */
                    result = sourceIllegal;
                    break;
                } else {
                    *target++ = UNI_REPLACEMENT_CHAR;
                }
            } else {
                *target++ = (UTF16)ch; /* normal case */
            }
        } else if (ch > UNI_MAX_LEGAL_UTF32) {
            if (flags == strictConversion) {
                result = sourceIllegal;
            } else {
                *target++ = UNI_REPLACEMENT_CHAR;
            }
        } else {
            /* target is a character in range 0xFFFF - 0x10FFFF. */
            if (target + 1 >= targetEnd) {
                --source; /* Back up source pointer! */
                result = targetExhausted; break;
            }
            ch -= halfBase;
            *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
            *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
        }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

// Assembly:
movq (%rdi), %r10
movq (%rdx), %r9
xorl %eax, %eax
cmpq %rsi, %r10
jae 0xf5d9
pushq %rbx
xorl %eax, %eax
cmpq %rcx, %r9
jae 0xf5d3
movl (%r10), %r11d
cmpl $0xffff, %r11d          # imm = 0xFFFF
ja 0xf569
movl %r11d, %ebx
andl $0xf800, %ebx           # imm = 0xF800
cmpl $0xd800, %ebx           # imm = 0xD800
jne 0xf57f
testl %r8d, %r8d
jne 0xf577
jmp 0xf5e0
cmpl $0x110000, %r11d        # imm = 0x110000
jb 0xf589
testl %r8d, %r8d
je 0xf5bf
movw $0xfffd, (%r9)          # imm = 0xFFFD
jmp 0xf583
movw %r11w, (%r9)
addq $0x2, %r9
jmp 0xf5c4
leaq 0x2(%r9), %rbx
cmpq %rcx, %rbx
jae 0xf5d3
leal 0x3ff0000(%r11), %ebx
shrl $0xa, %ebx
addl $0xffffd800, %ebx       # imm = 0xFFFFD800
movw %bx, (%r9)
andl $0x3ff, %r11d           # imm = 0x3FF
orl $0xdc00, %r11d          # imm = 0xDC00
movw %r11w, 0x2(%r9)
addq $0x4, %r9
jmp 0xf5c4
movl $0x3, %eax
addq $0x4, %r10
cmpq %rsi, %r10
jb 0xf53c
jmp 0xf5d8
movl $0x2, %eax
popq %rbx
movq %r10, (%rdi)
movq %r9, (%rdx)
retq
movl $0x3, %eax
jmp 0xf5d8
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/ConvertUTF.cpp
// Function: linenoise_ng::isLegalUTF8Sequence(unsigned char const*, unsigned char const*)
Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
    int length = trailingBytesForUTF8[*source]+1;
    if (source+length > sourceEnd) {
        return false;
    }
    return isLegalUTF8(source, length);
}

// Assembly:
movq %rsi, %rax
movzbl (%rdi), %ecx
leaq 0x11074(%rip), %rdx     # 0x20860
movsbq (%rcx,%rdx), %rsi
leaq (%rdi,%rsi), %rcx
incq %rcx
cmpq %rax, %rcx
jbe 0xf800
xorl %eax, %eax
retq
incq %rsi
jmp 0xf805