LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd600
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $0x6, %eax
je 0x13584
jmp 0x13577
movl -0x2c(%rbp), %eax
subl $0x7, %eax
je 0x135cf
jmp 0x13614
leaq -0x12(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x87d0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x28e73(%rip), %rsi     # 0x3c413
callq 0x8610
jmp 0x135a7
leaq -0x12(%rbp), %rdi
callq 0x8490
jmp 0x13672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x8490
jmp 0x1367c
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x87d0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x28e36(%rip), %rsi     # 0x3c421
callq 0x8610
jmp 0x135f2
leaq -0x25(%rbp), %rdi
callq 0x8490
jmp 0x13672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x8490
jmp 0x1367c
movb -0x11(%rbp), %dl
leaq 0x293c4(%rip), %rcx     # 0x3c9e2
leaq 0x28e09(%rip), %rax     # 0x3c42e
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x60(%rbp)
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x87d0
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x8610
jmp 0x13650
leaq -0x26(%rbp), %rdi
callq 0x8490
jmp 0x13672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x8490
jmp 0x1367c
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
callq 0x16550
jmp 0x15dd6
leaq -0x18(%rbp), %rdi
callq 0x16650
testb $0x1, (%rax)
je 0x15e0a
leaq -0x18(%rbp), %rdi
callq 0x16670
movq (%rax), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15eba
movb $0x1, -0x69(%rbp)
movl $0x28, %edi
callq 0x8240
movq -0x78(%rbp), %rsi
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x16010
jmp 0x15e2b
leaq 0x26635(%rip), %rsi     # 0x3c467
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x16690
jmp 0x15e41
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd550
jmp 0x15e50
movq -0x80(%rbp), %rdi
movb $0x0, -0x69(%rbp)
leaq 0x3ff09(%rip), %rsi     # 0x55d68
leaq -0x88a6(%rip), %rdx     # 0xd5c0
callq 0x8770
jmp 0x15ed2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15ea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8878
leaq -0x68(%rbp), %rdi
callq 0x8878
testb $0x1, -0x69(%rbp)
jne 0x15eaf
jmp 0x15eb8
movq -0x80(%rbp), %rdi
callq 0x8300
jmp 0x15eba
cmpl $0x0, -0x24(%rbp)
jge 0x15ec9
movq -0x20(%rbp), %rdi
callq 0x8590
movq -0x20(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
callq 0x168d0
jmp 0x15f06
leaq -0x18(%rbp), %rdi
callq 0x169d0
testb $0x1, (%rax)
je 0x15f3b
leaq -0x18(%rbp), %rdi
callq 0x169f0
movsd (%rax), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15feb
movb $0x1, -0x69(%rbp)
movl $0x28, %edi
callq 0x8240
movq -0x78(%rbp), %rsi
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x16010
jmp 0x15f5c
leaq 0x26523(%rip), %rsi     # 0x3c486
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x16690
jmp 0x15f72
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd550
jmp 0x15f81
movq -0x80(%rbp), %rdi
movb $0x0, -0x69(%rbp)
leaq 0x3fdd8(%rip), %rsi     # 0x55d68
leaq -0x89d7(%rip), %rdx     # 0xd5c0
callq 0x8770
jmp 0x16003
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15fd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15fcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8878
leaq -0x68(%rbp), %rdi
callq 0x8878
testb $0x1, -0x69(%rbp)
jne 0x15fe0
jmp 0x15fe9
movq -0x80(%rbp), %rdi
callq 0x8300
jmp 0x15feb
cmpl $0x0, -0x24(%rbp)
jge 0x15ffa
movq -0x20(%rbp), %rdi
callq 0x8590
movq -0x20(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x166e0
movq -0x1c0(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x86d0
movq -0x1b8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x82a0
jmp 0x165bc
movq -0x1a0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a0(%rbp,%rax), %rdi
callq 0x8030
movb %al, -0x1d1(%rbp)
jmp 0x165dc
movq -0x1d0(%rbp), %rdi
movb -0x1d1(%rbp), %al
notb %al
andb $0x1, %al
movb %al, -0x1ad(%rbp)
leaq -0x1ad(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x16700
jmp 0x16605
leaq -0x1a0(%rbp), %rdi
callq 0x8320
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x8320
movq -0x1a8(%rbp), %rdi
callq 0x87b0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4007d(%rip), %rdi     # 0x57978
leaq -0x10(%rbp), %rsi
callq 0x18340
movq %rax, -0xa0(%rbp)
jmp 0x1790d
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x40059(%rip), %rdi     # 0x57978
callq 0x183a0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x18370
testb $0x1, %al
jne 0x1793b
jmp 0x1797a
leaq -0x18(%rbp), %rdi
callq 0x183d0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x8200
jmp 0x17959
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17a78
movb $0x1, -0x91(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x183f0
jmp 0x179a4
leaq 0x24d07(%rip), %rsi     # 0x3c6b2
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x16690
jmp 0x179bd
leaq 0x24cf6(%rip), %rdx     # 0x3c6ba
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16bb0
jmp 0x179d3
movq -0xb8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xd550
jmp 0x179e5
movq -0xb8(%rbp), %rdi
movb $0x0, -0x91(%rbp)
leaq 0x3e36e(%rip), %rsi     # 0x55d68
leaq -0xa441(%rip), %rdx     # 0xd5c0
callq 0x8770
jmp 0x17a90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17a4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8878
leaq -0x70(%rbp), %rdi
callq 0x8878
leaq -0x90(%rbp), %rdi
callq 0x8878
testb $0x1, -0x91(%rbp)
jne 0x17a6a
jmp 0x17a76
movq -0xb8(%rbp), %rdi
callq 0x8300
jmp 0x17a78
cmpl $0x0, -0x24(%rbp)
jge 0x17a87
movq -0x20(%rbp), %rdi
callq 0x8590
movq -0x20(%rbp), %rdi
callq 0x87b0
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3fdfd(%rip), %rdi     # 0x579d8
leaq -0x10(%rbp), %rsi
callq 0x18560
movq %rax, -0xa0(%rbp)
jmp 0x17bed
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x3fdd9(%rip), %rdi     # 0x579d8
callq 0x185c0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x18590
testb $0x1, %al
jne 0x17c1e
jmp 0x17d39
movb $0x1, -0x91(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x183f0
jmp 0x17c48
leaq 0x24a63(%rip), %rsi     # 0x3c6b2
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x16690
jmp 0x17c61
leaq 0x24a52(%rip), %rdx     # 0x3c6ba
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16bb0
jmp 0x17c77
movq -0xb8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xd550
jmp 0x17c89
movq -0xb8(%rbp), %rdi
movb $0x0, -0x91(%rbp)
leaq 0x3e0ca(%rip), %rsi     # 0x55d68
leaq -0xa6e5(%rip), %rdx     # 0xd5c0
callq 0x8770
jmp 0x17d70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17d2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17d11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17d05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x17cfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8878
leaq -0x70(%rbp), %rdi
callq 0x8878
leaq -0x90(%rbp), %rdi
callq 0x8878
testb $0x1, -0x91(%rbp)
jne 0x17d1c
jmp 0x17d28
movq -0xb8(%rbp), %rdi
callq 0x8300
jmp 0x17d2a
cmpl $0x0, -0x24(%rbp)
jge 0x17d67
movq -0x20(%rbp), %rdi
callq 0x8590
leaq -0x18(%rbp), %rdi
callq 0x185f0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xb900
jmp 0x17d57
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87b0
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x87d0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x8610
jmp 0x17dc8
leaq 0x3fbd9(%rip), %rdi     # 0x579a8
leaq -0x38(%rbp), %rsi
callq 0x18500
movq %rax, -0xe8(%rbp)
jmp 0x17de1
movq -0xe8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8878
leaq -0x39(%rbp), %rdi
callq 0x8490
leaq 0x3fba3(%rip), %rdi     # 0x579a8
callq 0x18530
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x18610
testb $0x1, %al
jne 0x17e24
jmp 0x17f90
movb $0x1, -0xba(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x87d0
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x8610
jmp 0x17e76
leaq 0x24848(%rip), %rsi     # 0x3c6c5
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x16690
jmp 0x17e92
leaq 0x24821(%rip), %rdx     # 0x3c6ba
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x16bb0
jmp 0x17eab
movq -0x100(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xd550
jmp 0x17ebd
movq -0x100(%rbp), %rdi
movb $0x0, -0xba(%rbp)
leaq 0x3de96(%rip), %rsi     # 0x55d68
leaq -0xa919(%rip), %rdx     # 0xd5c0
callq 0x8770
jmp 0x17fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17f06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8878
leaq -0x39(%rbp), %rdi
callq 0x8490
jmp 0x17fc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17f6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17f5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17f53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x8878
leaq -0x98(%rbp), %rdi
callq 0x8878
leaq -0xb8(%rbp), %rdi
callq 0x8878
leaq -0xb9(%rbp), %rdi
callq 0x8490
testb $0x1, -0xba(%rbp)
jne 0x17f82
jmp 0x17f8e
movq -0x100(%rbp), %rdi
callq 0x8300
jmp 0x17fc7
leaq -0x18(%rbp), %rdi
callq 0x18640
movq -0xe0(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x17bb0
jmp 0x17fab
movq -0xd8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jge 0x17fd6
movq -0x48(%rbp), %rdi
callq 0x8590
movq -0x48(%rbp), %rdi
callq 0x87b0
nop
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::AtomTypeCell<unsigned long, (ALisp::CellType)1>::IAtomCell::repr[abi:cxx11]() const
StringType repr() const final override {
				StringType r = "(atom \"";
				r += str();
				r += "\")";
				return r;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x87d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x22608(%rip), %rsi     # 0x3c6cb
callq 0x8610
jmp 0x1a0ca
leaq -0x12(%rbp), %rdi
callq 0x8490
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1a050
jmp 0x1a0e2
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8580
jmp 0x1a0f1
leaq -0x48(%rbp), %rdi
callq 0x8878
movq -0x58(%rbp), %rdi
leaq 0x225ce(%rip), %rsi     # 0x3c6d3
callq 0x83c0
jmp 0x1a10c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1a15d
jmp 0x1a154
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x8490
jmp 0x1a170
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1a167
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8878
jmp 0x1a167
movq -0x58(%rbp), %rdi
callq 0x8878
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x8878
movq -0x20(%rbp), %rdi
callq 0x87b0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x200a0(%rip), %rax     # 0x3c8a0
movsbl (%rax,%rcx), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jbe 0x1c821
movb $0x0, -0x1(%rbp)
jmp 0x1c830
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c840
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryFree
void linenoiseHistoryFree(void) {
  if (history) {
    for (int j = 0; j < historyLen; ++j) free(history[j]);
    historyLen = 0;
    free(history);
    history = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x3a870(%rip)     # 0x57a90
je 0x1d274
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x3a866(%rip), %eax     # 0x57a98
jge 0x1d253
movq 0x3a855(%rip), %rax     # 0x57a90
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8510
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d229
movl $0x0, 0x3a83b(%rip)     # 0x57a98
movq 0x3a82c(%rip), %rdi     # 0x57a90
callq 0x8510
movq $0x0, 0x3a81c(%rip) # 0x57a90
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: calculateScreenPosition(int, int, int, int, int&, int&)
static void calculateScreenPosition(int x, int y, int screenColumns,
                                    int charCount, int& xOut, int& yOut) {
  xOut = x;
  yOut = y;
  int charsRemaining = charCount;
  while (charsRemaining > 0) {
    int charsThisRow = (x + charsRemaining < screenColumns) ? charsRemaining
                                                            : screenColumns - x;
    xOut = x + charsThisRow;
    yOut = y;
    charsRemaining -= charsThisRow;
    x = 0;
    ++y;
  }
  if (xOut == screenColumns) {  // we have to special-case line wrap
    xOut = 0;
    ++yOut;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1d87a
movl -0x4(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1d839
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d842
movl -0xc(%rbp), %eax
subl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
addl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1d820
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1d89a
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: calculateColumnPosition(char32_t*, int)
static int calculateColumnPosition(char32_t* buf32, int len) {
  int width = mk_wcswidth(reinterpret_cast<const char32_t*>(buf32), len);
  if (width == -1)
    return len;
  else
    return width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x26bf0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x1d8cd
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d8d3
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: write32(int, char32_t*, int)
static int write32(int fd, char32_t* text32, int len32) {
#ifdef _WIN32
  if (isatty(fd)) {
    size_t len16 = 2 * len32 + 1;
    unique_ptr<char16_t[]> text16(new char16_t[len16]);
    size_t count16 = WinWrite32(text16.get(), text32, len32);

    return static_cast<int>(count16);
  } else {
    size_t len8 = 4 * len32 + 1;
    unique_ptr<char[]> text8(new char[len8]);
    size_t count8 = 0;

    copyString32to8(text8.get(), len8, &count8, text32, len32);

    return write(fd, text8.get(), static_cast<unsigned int>(count8));
  }
#else
  size_t len8 = 4 * len32 + 1;
  unique_ptr<char[]> text8(new char[len8]);
  size_t count8 = 0;

  copyString32to8(text8.get(), len8, &count8, text32, len32);

  return write(fd, text8.get(), count8);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, %eax
leal 0x1(,%rax,4), %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8040
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x23f80
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
callq 0x23fb0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %r8
leaq -0x30(%rbp), %rdx
callq 0x231b0
jmp 0x1d948
movl -0x4(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23fb0
movl -0x54(%rbp), %edi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x8190
movq %rax, -0x50(%rbp)
jmp 0x1d96c
movq -0x50(%rbp), %rax
movl %eax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23fe0
movl -0x58(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23fe0
movq -0x38(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: setDisplayAttribute(bool, bool)
static void setDisplayAttribute(bool enhancedDisplay, bool error) {
#ifdef _WIN32
  if (enhancedDisplay) {
    CONSOLE_SCREEN_BUFFER_INFO inf;
    GetConsoleScreenBufferInfo(console_out, &inf);
    oldDisplayAttribute = inf.wAttributes;
    BYTE oldLowByte = oldDisplayAttribute & 0xFF;
    BYTE newLowByte;
    switch (oldLowByte) {
      case 0x07:
        // newLowByte = FOREGROUND_BLUE | FOREGROUND_INTENSITY;  // too dim
        // newLowByte = FOREGROUND_BLUE;                         // even dimmer
        newLowByte = FOREGROUND_BLUE |
                     FOREGROUND_GREEN;  // most similar to xterm appearance
        break;
      case 0x70:
        newLowByte = BACKGROUND_BLUE | BACKGROUND_INTENSITY;
        break;
      default:
        newLowByte = oldLowByte ^ 0xFF;  // default to inverse video
        break;
    }
    inf.wAttributes = (inf.wAttributes & 0xFF00) | newLowByte;
    SetConsoleTextAttribute(console_out, inf.wAttributes);
  } else {
    SetConsoleTextAttribute(console_out, oldDisplayAttribute);
  }
#else
  if (enhancedDisplay) {
    char const* p = (error ? "\x1b[1;31m" : "\x1b[1;34m");
    if (write(1, p, 7) == -1)
      return; /* bright blue (visible with both B&W bg) */
  } else {
    if (write(1, "\x1b[0m", 4) == -1) return; /* reset */
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x1(%rbp)
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x1(%rbp)
je 0x1da14
testb $0x1, -0x2(%rbp)
je 0x1d9e2
leaq 0x1f185(%rip), %rax     # 0x3cb61
movq %rax, -0x18(%rbp)
jmp 0x1d9ef
leaq 0x1f180(%rip), %rax     # 0x3cb69
movq %rax, -0x18(%rbp)
jmp 0x1d9ef
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
movl $0x7, %edx
callq 0x8190
cmpq $-0x1, %rax
jne 0x1da12
jmp 0x1da34
jmp 0x1da34
movl $0x1, %edi
leaq 0x1f151(%rip), %rsi     # 0x3cb71
movl $0x4, %edx
callq 0x8190
cmpq $-0x1, %rax
jne 0x1da32
jmp 0x1da34
jmp 0x1da34
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: copyString32(char32_t*, char32_t const*, unsigned long)
static void copyString32(char32_t* dst, const char32_t* src, size_t len) {
  while (0 < len && *src) {
    *dst++ = *src++;
    --len;
  }

  *dst = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq -0x18(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0x1e88a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1e893
jmp 0x1e8c3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1e870
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: cleanupCtrl(int)
static int cleanupCtrl(int c) {
  if (c & CTRL) {
    int d = c & 0x1FF;
    if (d >= 'a' && d <= 'z') {
      c = (c + ('a' - ctrlChar('A'))) & ~CTRL;
    }
    if (d >= 'A' && d <= 'Z') {
      c = (c + ('A' - ctrlChar('A'))) & ~CTRL;
    }
    if (d >= ctrlChar('A') && d <= ctrlChar('Z')) {
      c = c & ~CTRL;
    }
  }
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x20000000, %eax       # imm = 0x20000000
cmpl $0x0, %eax
je 0x1eb2c
movl -0x4(%rbp), %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x8(%rbp)
cmpl $0x61, -0x8(%rbp)
jl 0x1eaf9
cmpl $0x7a, -0x8(%rbp)
jg 0x1eaf9
movl -0x4(%rbp), %eax
addl $0x60, %eax
andl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
movl %eax, -0x4(%rbp)
cmpl $0x41, -0x8(%rbp)
jl 0x1eb13
cmpl $0x5a, -0x8(%rbp)
jg 0x1eb13
movl -0x4(%rbp), %eax
addl $0x40, %eax
andl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
movl %eax, -0x4(%rbp)
cmpl $0x1, -0x8(%rbp)
jl 0x1eb2a
cmpl $0x1a, -0x8(%rbp)
jg 0x1eb2a
movl -0x4(%rbp), %eax
andl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
movl %eax, -0x4(%rbp)
jmp 0x1eb2c
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: getScreenRows()
static int getScreenRows(void) {
  int rows;
#ifdef _WIN32
  CONSOLE_SCREEN_BUFFER_INFO inf;
  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &inf);
  rows = 1 + inf.srWindow.Bottom - inf.srWindow.Top;
#else
  struct winsize ws;
  rows = (ioctl(1, TIOCGWINSZ, &ws) == -1) ? 24 : ws.ws_row;
#endif
  return (rows > 0) ? rows : 24;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x8640
cmpl $-0x1, %eax
jne 0x1eb6c
movl $0x18, %eax
movl %eax, -0x10(%rbp)
jmp 0x1eb73
movzwl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x1eb87
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1eb91
movl $0x18, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eb91
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: InputBuffer::clearScreen(PromptBase&)
void InputBuffer::clearScreen(PromptBase& pi) {
  linenoiseClearScreen();
  if (!pi.write()) return;
#ifndef _WIN32
  // we have to generate our own newline on line wrap on Linux
  if (pi.promptIndentation == 0 && pi.promptExtraLines > 0)
    if (write(1, "\n", 1) == -1) return;
#endif
  pi.promptCursorRowOffset = pi.promptExtraLines;
  refreshLine(pi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1eba0
movq -0x10(%rbp), %rdi
callq 0x23ee0
testb $0x1, %al
jne 0x1ebfc
jmp 0x1ec4b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1ec30
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jle 0x1ec30
movl $0x1, %edi
leaq 0x1e010(%rip), %rsi     # 0x3cc2c
movl $0x1, %edx
callq 0x8190
cmpq $-0x1, %rax
jne 0x1ec2e
jmp 0x1ec4b
jmp 0x1ec30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rsi
callq 0x1d280
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: enableRawMode()
static int enableRawMode(void) {
#ifdef _WIN32
  if (!console_in) {
    console_in = GetStdHandle(STD_INPUT_HANDLE);
    console_out = GetStdHandle(STD_OUTPUT_HANDLE);

    GetConsoleMode(console_in, &oldMode);
    SetConsoleMode(console_in, oldMode &
                                   ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT |
                                     ENABLE_PROCESSED_INPUT));
  }
  return 0;
#else
  struct termios raw;

  if (!isatty(STDIN_FILENO)) goto fatal;
  if (!atexit_registered) {
    atexit(linenoiseAtExit);
    atexit_registered = 1;
  }
  if (tcgetattr(0, &orig_termios) == -1) goto fatal;

  raw = orig_termios; /* modify the original mode */
  /* input modes: no break, no CR to NL, no parity check, no strip char,
   * no start/stop output control. */
  raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
  /* output modes - disable post processing */
  // this is wrong, we don't want raw output, it turns newlines into straight
  // linefeeds
  // raw.c_oflag &= ~(OPOST);
  /* control modes - set 8 bit chars */
  raw.c_cflag |= (CS8);
  /* local modes - echoing off, canonical off, no extended functions,
   * no signal chars (^Z,^C) */
  raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
  /* control chars - set return condition: min number of bytes and timer.
   * We want read to return every single byte, without timeout. */
  raw.c_cc[VMIN] = 1;
  raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

  /* put terminal in raw mode after flushing */
  if (tcsetattr(0, TCSADRAIN, &raw) < 0) goto fatal;
  rawmode = 1;
  return 0;

fatal:
  errno = ENOTTY;
  return -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
xorl %edi, %edi
callq 0x87a0
cmpl $0x0, %eax
jne 0x1ff29
jmp 0x1ffc3
cmpl $0x0, 0x37c20(%rip)     # 0x57b50
jne 0x1ff48
leaq 0x3b17(%rip), %rdi      # 0x23a50
callq 0x3b170
movl $0x1, 0x37c08(%rip)     # 0x57b50
xorl %edi, %edi
leaq 0x37bc3(%rip), %rsi     # 0x57b14
callq 0x84e0
cmpl $-0x1, %eax
jne 0x1ff5d
jmp 0x1ffc3
leaq -0x40(%rbp), %rdi
leaq 0x37bac(%rip), %rsi     # 0x57b14
movl $0x3c, %edx
callq 0x8360
movl -0x40(%rbp), %eax
andl $0xfffffacd, %eax       # imm = 0xFFFFFACD
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
andl $0xffff7ff4, %eax       # imm = 0xFFFF7FF4
movl %eax, -0x34(%rbp)
movb $0x1, -0x29(%rbp)
movb $0x0, -0x2a(%rbp)
xorl %edi, %edi
movl $0x1, %esi
leaq -0x40(%rbp), %rdx
callq 0x8570
cmpl $0x0, %eax
jge 0x1ffb0
jmp 0x1ffc3
movl $0x1, 0x37b56(%rip)     # 0x57b10
movl $0x0, -0x4(%rbp)
jmp 0x1ffd5
callq 0x8070
movl $0x19, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: strncmp32(char32_t const*, char32_t const*, unsigned long)
static int strncmp32(const char32_t* left, const char32_t* right, size_t len) {
  while (0 < len && *left) {
    if (*left != *right) {
      return *left - *right;
    }

    ++left;
    ++right;
    --len;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq -0x20(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x2008a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x20093
jmp 0x200d8
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x200b2
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x200df
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x20070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: getScreenColumns()
static int getScreenColumns(void) {
  int cols;
#ifdef _WIN32
  CONSOLE_SCREEN_BUFFER_INFO inf;
  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &inf);
  cols = inf.dwSize.X;
#else
  struct winsize ws;
  cols = (ioctl(1, TIOCGWINSZ, &ws) == -1) ? 80 : ws.ws_col;
#endif
  // cols is 0 in certain circumstances like inside debugger, which creates
  // further issues
  return (cols > 0) ? cols : 80;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x8640
cmpl $-0x1, %eax
jne 0x221fc
movl $0x50, %eax
movl %eax, -0x10(%rbp)
jmp 0x22203
movzwl -0xa(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x22217
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x22221
movl $0x50, %eax
movl %eax, -0x14(%rbp)
jmp 0x22221
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: isUnsupportedTerm()
static bool isUnsupportedTerm(void) {
  char* term = getenv("TERM");
  if (term == NULL) return false;
  for (int j = 0; unsupported_term[j]; ++j)
    if (!strcasecmp(term, unsupported_term[j])) {
      return true;
    }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1a106(%rip), %rdi     # 0x3cc65
callq 0x8520
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x22b75
movb $0x0, -0x1(%rbp)
jmp 0x22bc2
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x34c29(%rip), %rax     # 0x577b0
cmpq $0x0, (%rax,%rcx,8)
je 0x22bbe
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x34c13(%rip), %rax     # 0x577b0
movq (%rax,%rcx,8), %rsi
callq 0x84b0
cmpl $0x0, %eax
jne 0x22bb1
movb $0x1, -0x1(%rbp)
jmp 0x22bc2
jmp 0x22bb3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x22b7c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
  if (len < 1) {
    return 0;
  }
  if (history) {
    int tocopy = historyLen;
    char8_t** newHistory =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * len));
    if (newHistory == NULL) {
      return 0;
    }
    if (len < tocopy) {
      tocopy = len;
    }
    memcpy(newHistory, history + historyMaxLen - tocopy,
           sizeof(char8_t*) * tocopy);
    free(history);
    history = newHistory;
  }
  historyMaxLen = len;
  if (historyLen > historyMaxLen) {
    historyLen = historyMaxLen;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jge 0x22c7d
movl $0x0, -0x4(%rbp)
jmp 0x22d3d
cmpq $0x0, 0x34e0b(%rip)     # 0x57a90
je 0x22d13
movl 0x34e07(%rip), %eax     # 0x57a98
movl %eax, -0xc(%rbp)
movslq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x85e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22cb8
movl $0x0, -0x4(%rbp)
jmp 0x22d3d
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x22cc6
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movq 0x34dbf(%rip), %rsi     # 0x57a90
movslq 0x3479c(%rip), %rax     # 0x57474
shlq $0x3, %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
shlq $0x3, %rdx
callq 0x8360
movq 0x34d8d(%rip), %rdi     # 0x57a90
callq 0x8510
movq -0x18(%rbp), %rax
movq %rax, 0x34d7d(%rip)     # 0x57a90
movl -0x8(%rbp), %eax
movl %eax, 0x34758(%rip)     # 0x57474
movl 0x34d76(%rip), %eax     # 0x57a98
cmpl 0x3474c(%rip), %eax     # 0x57474
jle 0x22d36
movl 0x34744(%rip), %eax     # 0x57474
movl %eax, 0x34d62(%rip)     # 0x57a98
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistorySave
int linenoiseHistorySave(const char* filename) {
#if _WIN32
  FILE* fp = fopen(filename, "wt");
#else
  int fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR);

  if (fd < 0) {
    return -1;
  }

  FILE* fp = fdopen(fd, "wt");
#endif

  if (fp == NULL) {
    return -1;
  }

  for (int j = 0; j < historyLen; ++j) {
    if (history[j][0] != '\0') {
      fprintf(fp, "%s\n", history[j]);
    }
  }

  fclose(fp);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x8310
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x22dd6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22e60
movl -0x14(%rbp), %edi
leaq 0x19cdd(%rip), %rsi     # 0x3cabd
callq 0x8480
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22df9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22e60
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x34c8f(%rip), %eax     # 0x57a98
jge 0x22e50
movq 0x34c7e(%rip), %rax     # 0x57a90
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x22e43
movq -0x20(%rbp), %rdi
movq 0x34c63(%rip), %rax     # 0x57a90
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x19c84(%rip), %rsi     # 0x3cac0
movb $0x0, %al
callq 0x8650
jmp 0x22e45
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x22e00
movq -0x20(%rbp), %rdi
callq 0x83f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryLoad
int linenoiseHistoryLoad(const char* filename) {
  FILE* fp = fopen(filename, "rt");
  if (fp == NULL) {
    return -1;
  }

  char buf[LINENOISE_MAX_LINE];
  while (fgets(buf, LINENOISE_MAX_LINE, fp) != NULL) {
    char* p = strchr(buf, '\r');
    if (!p) {
      p = strchr(buf, '\n');
    }
    if (p) {
      *p = '\0';
    }
    if (p != buf) {
      linenoiseHistoryAdd(buf);
    }
  }
  fclose(fp);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1946f(%rip), %rsi     # 0x3c2f9
callq 0x8500
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22ea6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22f45
jmp 0x22ea8
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x86c0
cmpq $0x0, %rax
je 0x22f35
leaq -0x1020(%rbp), %rdi
movl $0xd, %esi
callq 0x81b0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x22efd
leaq -0x1020(%rbp), %rdi
movl $0xa, %esi
callq 0x81b0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0x22f11
movq -0x1028(%rbp), %rax
movb $0x0, (%rax)
movq -0x1028(%rbp), %rax
leaq -0x1020(%rbp), %rcx
cmpq %rcx, %rax
je 0x22f30
leaq -0x1020(%rbp), %rdi
callq 0x22000
jmp 0x22ea8
movq -0x18(%rbp), %rdi
callq 0x83f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoisePrintKeyCodes
void linenoisePrintKeyCodes(void) {
  char quit[4];

  printf(
      "Linenoise key codes debugging mode.\n"
      "Press keys to see scan codes. Type 'quit' at any time to exit.\n");
  if (enableRawMode() == -1) return;
  memset(quit, ' ', 4);
  while (1) {
    char c;
    int nread;

#if _WIN32
    nread = _read(STDIN_FILENO, &c, 1);
#else
    nread = read(STDIN_FILENO, &c, 1);
#endif
    if (nread <= 0) continue;
    memmove(quit, quit + 1, sizeof(quit) - 1); /* shift string to left. */
    quit[sizeof(quit) - 1] = c; /* Insert current char on the right. */
    if (memcmp(quit, "quit", sizeof(quit)) == 0) break;

    printf("'%c' %02x (%d) (type quit to exit)\n", isprint(c) ? c : '?', (int)c,
           (int)c);
    printf("\r"); /* Go left edge manually, we are in raw mode. */
    fflush(stdout);
  }
  disableRawMode();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x19b45(%rip), %rdi     # 0x3cac4
movb $0x0, %al
callq 0x8080
callq 0x1ff10
cmpl $-0x1, %eax
jne 0x22f95
jmp 0x23059
leaq -0x4(%rbp), %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x8270
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x8660
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x22fc3
jmp 0x22fa8
leaq -0x4(%rbp), %rax
leaq -0x4(%rbp), %rdx
addq $0x1, %rdx
movw (%rdx), %cx
movb 0x2(%rdx), %dl
movb %dl, 0x2(%rax)
movw %cx, (%rax)
movb -0x5(%rbp), %al
movb %al, -0x1(%rbp)
leaq -0x4(%rbp), %rax
movl (%rax), %eax
subl $0x74697571, %eax       # imm = 0x74697571
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x22ff9
jmp 0x23054
movsbl -0x5(%rbp), %edi
callq 0x87c0
cmpl $0x0, %eax
je 0x2300f
movb -0x5(%rbp), %al
movb %al, -0xd(%rbp)
jmp 0x23016
movb $0x3f, %al
movb %al, -0xd(%rbp)
jmp 0x23016
movb -0xd(%rbp), %al
movsbl %al, %esi
movsbl -0x5(%rbp), %edx
movsbl -0x5(%rbp), %ecx
leaq 0x19b02(%rip), %rdi     # 0x3cb2d
movb $0x0, %al
callq 0x8080
leaq 0x199fe(%rip), %rdi     # 0x3ca37
movb $0x0, %al
callq 0x8080
movq 0x33f39(%rip), %rax     # 0x56f80
movq (%rax), %rdi
callq 0x84f0
jmp 0x22fa8
callq 0x1fed0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseInstallWindowChangeHandler
int linenoiseInstallWindowChangeHandler(void) {
#ifndef _WIN32
  struct sigaction sa;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;
  sa.sa_handler = &WindowSizeChanged;

  if (sigaction(SIGWINCH, &sa, nullptr) == -1) {
    return errno;
  }
#endif
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x8550
movl $0x0, -0x18(%rbp)
leaq 0x47(%rip), %rax        # 0x230d0
movq %rax, -0xa0(%rbp)
movl $0x1c, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8560
cmpl $-0x1, %eax
jne 0x230b6
callq 0x8070
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x230bd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: copyString8to32(char32_t*, unsigned long, unsigned long&, char const*)
static ConversionResult copyString8to32(char32_t* dst, size_t dstSize,
                                        size_t& dstCount, const char* src) {
  const UTF8* sourceStart = reinterpret_cast<const UTF8*>(src);
  const UTF8* sourceEnd = sourceStart + strlen(src);
  UTF32* targetStart = reinterpret_cast<UTF32*>(dst);
  UTF32* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF8toUTF32(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    dstCount = targetStart - reinterpret_cast<UTF32*>(dst);

    if (dstCount < dstSize) {
      *targetStart = 0;
    }
  }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8210
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movl $0x1, %r8d
callq 0x1cf80
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x2319d
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x2319b
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2319d
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: copyString32to8(char*, unsigned long, unsigned long*, char32_t const*, unsigned long)
static void copyString32to8(char* dst, size_t dstSize, size_t* dstCount,
                            const char32_t* src, size_t srcSize) {
  const UTF32* sourceStart = reinterpret_cast<const UTF32*>(src);
  const UTF32* sourceEnd = sourceStart + srcSize;
  UTF8* targetStart = reinterpret_cast<UTF8*>(dst);
  UTF8* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF32toUTF8(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    *dstCount = targetStart - reinterpret_cast<UTF8*>(dst);

    if (*dstCount < dstSize) {
      *targetStart = 0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movl $0x1, %r8d
callq 0x1cd30
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x23247
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x23245
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
jmp 0x23247
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)