LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
movq %rdi, %r14
addq $0x10, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xc39e
cmpb $0x1, 0x10(%rsp)
jne 0xbf23
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x71b0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x7490
leaq 0x10512(%rip), %rsi     # 0x1c454
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xc40d
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x9794
xorl %ebp, %ebp
leaq 0x1df36(%rip), %rsi     # 0x29ea0
leaq -0x27a7(%rip), %rdx     # 0x97ca
movq %rbx, %rdi
callq 0x75d0
movq %rdx, %r15
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x7688
jmp 0xbf94
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0x7688
testb %bpl, %bpl
jne 0xbfab
jmp 0xbfbb
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7250
jmp 0xbfbb
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xbfc8
callq 0x7430
callq 0x7600
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
movq %rdi, %r14
addq $0x10, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xc431
cmpb $0x1, 0x10(%rsp)
jne 0xc004
movsd 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x71b0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x7490
leaq 0x10450(%rip), %rsi     # 0x1c473
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xc40d
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x9794
xorl %ebp, %ebp
leaq 0x1de55(%rip), %rsi     # 0x29ea0
leaq -0x2888(%rip), %rdx     # 0x97ca
movq %rbx, %rdi
callq 0x75d0
movq %rdx, %r15
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x7688
jmp 0xc075
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0x7688
testb %bpl, %bpl
jne 0xc08c
jmp 0xc09c
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7250
jmp 0xc09c
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xc0a9
callq 0x7430
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x7550
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7320
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)
callq 0x7270
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7270
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x1f20a(%rip), %rdi     # 0x2b848
movq %rax, %rsi
callq 0xcda4
leaq 0x1f203(%rip), %rcx     # 0x2b850
cmpq %rcx, %rax
je 0xc66f
addq $0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7490
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x71b0
movq %rax, %rbx
movq (%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xcb69
leaq 0x1000b(%rip), %rsi     # 0x1c69a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xc40d
leaq 0xfffd(%rip), %rdx      # 0x1c6a2
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc4a2
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x9794
xorl %ebp, %ebp
leaq 0x1d7d3(%rip), %rsi     # 0x29ea0
leaq -0x2f0a(%rip), %rdx     # 0x97ca
movq %rbx, %rdi
callq 0x75d0
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x7688
jmp 0xc6f7
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x7688
jmp 0xc70c
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x7688
testb %bpl, %bpl
jne 0xc723
jmp 0xc733
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7250
jmp 0xc733
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xc740
callq 0x7430
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x1f0ca(%rip), %rdi     # 0x2b8a8
movq %rax, %rsi
callq 0xce84
leaq 0x1f0c3(%rip), %rcx     # 0x2b8b0
cmpq %rcx, %rax
je 0xc80f
addq $0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90a4
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x71b0
movq %rax, %rbx
movq (%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xcb69
leaq 0xfe6b(%rip), %rsi      # 0x1c69a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xc40d
leaq 0xfe5d(%rip), %rdx      # 0x1c6a2
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc4a2
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x9794
xorl %ebp, %ebp
leaq 0x1d633(%rip), %rsi     # 0x29ea0
leaq -0x30aa(%rip), %rdx     # 0x97ca
movq %rbx, %rdi
callq 0x75d0
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x7688
jmp 0xc897
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x7688
jmp 0xc8ac
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x7688
testb %bpl, %bpl
jne 0xc8c3
jmp 0xc8d3
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7250
jmp 0xc8d3
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xc8e0
callq 0x7430
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7150
leaq 0x1ef6d(%rip), %rdi     # 0x2b878
leaq 0x8(%rsp), %rsi
callq 0xcdfa
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x7688
leaq 0x1ef57(%rip), %rax     # 0x2b880
cmpq %rax, %r15
je 0xc948
movq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0xc7c4
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x71b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7150
leaq 0xfd41(%rip), %rsi      # 0x1c6ad
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xc40d
leaq 0xfd20(%rip), %rdx      # 0x1c6a2
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc4a2
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x9794
xorl %ebp, %ebp
leaq 0x1d4f6(%rip), %rsi     # 0x29ea0
leaq -0x31e7(%rip), %rdx     # 0x97ca
movq %rbx, %rdi
callq 0x75d0
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x7688
jmp 0xc9d4
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x7688
jmp 0xc9e9
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x7688
testb %bpl, %bpl
jne 0xca00
jmp 0xca24
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x7250
jmp 0xca24
jmp 0xca1e
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7688
jmp 0xca24
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xca31
callq 0x7430
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc767
testb %al, %al
je 0xca5f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8e5
jmp 0xcb02
movq 0x1ee72(%rip), %rsi     # 0x2b8d8
leaq 0x1(%rsi), %rax
movq %rax, 0x1ee67(%rip)     # 0x2b8d8
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xcbac
leaq 0x1ee21(%rip), %rdi     # 0x2b8a8
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xd03a
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7150
leaq 0x1ed99(%rip), %rdi     # 0x2b848
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xd240
leaq 0x18(%rsp), %rdi
callq 0x7688
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7150
leaq 0x1ed97(%rip), %rdi     # 0x2b878
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xd3f2
leaq 0x18(%rsp), %rdi
callq 0x7688
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0xcb11
jmp 0xcb25
movq %rdx, %r14
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7688
jmp 0xcb2b
jmp 0xcb25
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xcb45
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0xcb45
jmp 0xcb3f
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0xcb52
callq 0x7430
callq 0x7600
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf743(%rip), %rsi      # 0x1c6b3
leaq 0x8(%rsp), %rdx
callq 0x7150
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xcf4a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7670
leaq 0x8(%rsp), %rdi
callq 0x7688
leaq 0xf716(%rip), %rsi      # 0x1c6bb
movq %rbx, %rdi
callq 0x7650
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xcfc9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7688
jmp 0xcfcc
movq %rax, %r14
movq %rbx, %rdi
callq 0x7688
movq %r14, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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 0xed23(%rip), %rdx      # 0x1c830
movsbq (%rcx,%rdx), %rsi
leaq (%rdi,%rsi), %rcx
incq %rcx
cmpq %rax, %rcx
jbe 0xdb21
xorl %eax, %eax
retq
incq %rsi
jmp 0xdb26
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/ConvertUTF.cpp
// Function: linenoise_ng::isLegalUTF8(unsigned char const*, int)
static Boolean isLegalUTF8(const UTF8 *source, int length) {
    UTF8 a;
    const UTF8 *srcptr = source+length;
    switch (length) {
    default: return false;
        /* Everything else falls through when "true"... */
    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 2: if ((a = (*--srcptr)) > 0xBF) return false;

        switch (*source) {
            /* no fall-through in this inner switch */
            case 0xE0: if (a < 0xA0) return false; break;
            case 0xED: if (a > 0x9F) return false; break;
            case 0xF0: if (a < 0x90) return false; break;
            case 0xF4: if (a > 0x8F) return false; break;
            default:   if (a < 0x80) return false;
        }

    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
    }
    if (*source > 0xF4) return false;
    return true;
}

// Assembly:
leal -0x1(%rsi), %ecx
cmpl $0x3, %ecx
ja 0xdb6a
movslq %esi, %rax
addq %rdi, %rax
leaq 0xec95(%rip), %rdx      # 0x1c7d0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb (%rdi), %al
cmpb $-0x3e, %al
jl 0xdb6a
cmpb $-0xb, %al
setb %al
retq
cmpb $-0x41, -0x1(%rax)
jg 0xdb6a
decq %rax
cmpb $-0x41, -0x1(%rax)
jg 0xdb6a
decq %rax
movb -0x1(%rax), %cl
cmpb $-0x41, %cl
jbe 0xdb6d
xorl %eax, %eax
retq
movzbl (%rdi), %eax
cmpl $0xf4, %eax
je 0xdba7
cmpl $0xed, %eax
je 0xdb95
cmpl $0xf0, %eax
je 0xdb9e
cmpl $0xe0, %eax
jne 0xdbb0
movb $-0x20, %al
cmpb $-0x60, %cl
jae 0xdb4a
jmp 0xdb6a
movb $-0x13, %al
cmpb $-0x61, %cl
jbe 0xdb4a
jmp 0xdb6a
movb $-0x10, %al
cmpb $-0x70, %cl
jae 0xdb4a
jmp 0xdb6a
movb $-0xc, %al
cmpb $-0x71, %cl
jbe 0xdb4a
jmp 0xdb6a
testb %cl, %cl
jns 0xdb6a
jmp 0xdb46
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x1d934(%rip), %rbx     # 0x2b960
testq %rbx, %rbx
je 0xe06c
movl 0x1d930(%rip), %r14d    # 0x2b968
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0xe055
movq (%rbx,%r15,8), %rdi
callq 0x73c0
incq %r15
jmp 0xe042
andl $0x0, 0x1d90c(%rip)     # 0x2b968
movq %rbx, %rdi
callq 0x73c0
andq $0x0, 0x1d8f4(%rip)     # 0x2b960
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edi, (%r8)
movl %esi, (%r9)
testl %ecx, %ecx
jle 0xe44a
leal (%rdi,%rcx), %eax
movl %edx, %r10d
subl %edi, %r10d
cmpl %edx, %eax
cmovll %ecx, %r10d
addl %r10d, %edi
movl %edi, (%r8)
movl %esi, (%r9)
subl %r10d, %ecx
incl %esi
xorl %edi, %edi
jmp 0xe425
cmpl %edx, (%r8)
jne 0xe456
andl $0x0, (%r8)
incl (%r9)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(,%r14,4), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %rbx
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
movslq %r14d, %r8
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x1145b
movq 0x10(%rsp), %rdx
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x7120
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11a32
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11a32
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
cmpq %rax, %rdx
je 0xec2b
movl (%rsi,%rax,4), %ecx
testl %ecx, %ecx
je 0xec2b
movl %ecx, (%rdi,%rax,4)
incq %rax
jmp 0xec17
andl $0x0, (%rdi,%rax,4)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xee16
movq %rbx, %rdi
callq 0x11a0c
testb %al, %al
je 0xee89
cmpl $0x0, 0x24(%rbx)
sete %cl
movl 0x20(%rbx), %eax
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xee74
leaq 0xdd8e(%rip), %rsi      # 0x1cbee
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x7120
cmpq $-0x1, %rax
je 0xee89
movl 0x20(%rbx), %eax
movl %eax, 0x30(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe072
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char* line) {
  if (historyMaxLen == 0) {
    return 0;
  }
  if (history == NULL) {
    history =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * historyMaxLen));
    if (history == NULL) {
      return 0;
    }
    memset(history, 0, (sizeof(char*) * historyMaxLen));
  }
  char8_t* linecopy = strdup8(line);
  if (!linecopy) {
    return 0;
  }

  // convert newlines in multi-line code to spaces before storing
  char8_t* p = linecopy;
  while (*p) {
    if (*p == '\n') {
      *p = ' ';
    }
    ++p;
  }

  // prevent duplicate history entries
  if (historyLen > 0 && history[historyLen - 1] != nullptr &&
      strcmp(reinterpret_cast<char const*>(history[historyLen - 1]),
             reinterpret_cast<char const*>(linecopy)) == 0) {
    free(linecopy);
    return 0;
  }

  if (historyLen == historyMaxLen) {
    free(history[0]);
    memmove(history, history + 1, sizeof(char*) * (historyMaxLen - 1));
    --historyLen;
    if (--historyPreviousIndex < -1) {
      historyPreviousIndex = -2;
    }
  }

  history[historyLen] = linecopy;
  ++historyLen;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x1a83e(%rip), %r15d    # 0x2b374
movq 0x1ae23(%rip), %rbx     # 0x2b960
testq %rbx, %rbx
jne 0x10b65
leaq (,%r15,8), %rsi
pushq $0x1
popq %rdi
callq 0x7210
movq %rax, %rbx
movq %rax, 0x1ae04(%rip)     # 0x2b960
testq %rax, %rax
je 0x10c05
movq %r14, %rdi
callq 0x7630
xorl %ebp, %ebp
testq %rax, %rax
je 0x10c11
movq %rax, %r14
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x10b89
testl %ecx, %ecx
jne 0x10b8c
jmp 0x10b91
movb $0x20, (%rax)
incq %rax
jmp 0x10b7b
movslq 0x1add0(%rip), %r12     # 0x2b968
testq %r12, %r12
jle 0x10bb3
movq -0x8(%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0x10bb3
movq %r14, %rsi
callq 0x74b0
testl %eax, %eax
je 0x10c09
cmpl %r15d, %r12d
jne 0x10bf1
movq (%rbx), %rdi
callq 0x73c0
leaq 0x8(%rbx), %rsi
decl %r15d
leaq (,%r15,8), %rdx
movq %rbx, %rdi
callq 0x7590
movl 0x1a793(%rip), %eax     # 0x2b370
leal -0x1(%rax), %ecx
testl %eax, %eax
pushq $-0x2
popq %rax
cmovnsl %ecx, %eax
movl %eax, 0x1a782(%rip)     # 0x2b370
movl %r15d, %r12d
movslq %r12d, %rax
movq %r14, (%rbx,%rax,8)
incl %eax
movl %eax, 0x1ad68(%rip)     # 0x2b968
pushq $0x1
popq %rbp
jmp 0x10c11
xorl %ebp, %ebp
jmp 0x10c11
movq %r14, %rdi
callq 0x73c0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testl %edi, %edi
jle 0x1116e
movl %edi, %ebx
movq 0x1a859(%rip), %r14     # 0x2b960
movl 0x1a85a(%rip), %r12d    # 0x2b968
testq %r14, %r14
je 0x1115a
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x7470
testq %rax, %rax
je 0x1116e
movq %rax, %r15
cmpl %ebx, %r12d
movl %ebx, %eax
cmovll %r12d, %eax
movl 0x1a23f(%rip), %ecx     # 0x2b374
leaq (%r14,%rcx,8), %rsi
movslq %eax, %rdx
shlq $0x3, %rdx
subq %rdx, %rsi
movq %r15, %rdi
callq 0x7290
movq %r14, %rdi
callq 0x73c0
movq %r15, 0x1a806(%rip)     # 0x2b960
movl %ebx, 0x1a214(%rip)     # 0x2b374
pushq $0x1
popq %rbp
cmpl %ebx, %r12d
jle 0x1116e
movl %ebx, 0x1a7fa(%rip)     # 0x2b968
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x7260
pushq $-0x1
popq %rbp
testl %eax, %eax
js 0x11219
leaq 0xba05(%rip), %rsi      # 0x1cbc5
movl %eax, %edi
callq 0x7350
testq %rax, %rax
je 0x11219
movq %rax, %rbx
movl 0x1a793(%rip), %eax     # 0x2b968
leaq 0xb9ec(%rip), %r14      # 0x1cbc8
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x1120f
movq 0x1a772(%rip), %rcx     # 0x2b960
movq (%rcx,%r15,8), %rdx
cmpb $0x0, (%rdx)
je 0x1120a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x74d0
movl 0x1a75e(%rip), %eax     # 0x2b968
incq %r15
jmp 0x111df
movq %rbx, %rdi
callq 0x72e0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0xb0ac(%rip), %rsi      # 0x1c2e6
callq 0x73b0
testq %rax, %rax
je 0x112a3
movq %rax, %rbx
movq %rsp, %r14
pushq $0xd
popq %rbp
pushq $0xa
popq %r15
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0x7530
testq %rax, %rax
je 0x11297
movq %r14, %rdi
movl %ebp, %esi
callq 0x7140
testq %rax, %rax
jne 0x11285
movq %r14, %rdi
movl %r15d, %esi
callq 0x7140
testq %rax, %rax
je 0x1128d
movb $0x0, (%rax)
cmpq %r14, %rax
je 0x11251
movq %r14, %rdi
callq 0x10b24
jmp 0x11251
movq %rbx, %rdi
callq 0x72e0
xorl %eax, %eax
jmp 0x112a6
pushq $-0x1
popq %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xba47(%rip), %rdi      # 0x1cd0e
callq 0x7510
callq 0xf955
cmpl $-0x1, %eax
je 0x1137d
leaq 0x5(%rsp), %r13
movl $0x20202020, -0x1(%r13) # imm = 0x20202020
leaq 0x3(%rsp), %rbx
pushq $0x1
popq %r14
pushq $0xd
popq %rbp
movq 0x19c96(%rip), %r15     # 0x2af90
xorl %edi, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x74e0
testl %eax, %eax
jle 0x112fa
movzwl (%r13), %eax
movb 0x2(%r13), %cl
movb %cl, 0x6(%rsp)
movw %ax, 0x4(%rsp)
movsbl 0x3(%rsp), %r12d
movb %r12b, 0x7(%rsp)
cmpl $0x74697571, 0x4(%rsp)  # imm = 0x74697571
je 0x1136a
movl %r12d, %edi
callq 0x7610
testl %eax, %eax
movl %r12d, %esi
pushq $0x3f
popq %rax
cmovel %eax, %esi
leaq 0xb880(%rip), %rdi      # 0x1cbcc
movl %r12d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x7060
movl %ebp, %edi
callq 0x74a0
movq (%r15), %rdi
callq 0x73a0
jmp 0x112fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf928
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x7400
andl $0x0, 0x80(%rbx)
leaq 0x2c(%rip), %rax        # 0x113db
movq %rax, -0x8(%rbx)
xorl %ebx, %ebx
pushq $0x1c
popq %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x7410
cmpl $-0x1, %eax
jne 0x113d0
callq 0x7050
movl (%rax), %ebx
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r13
movq %rcx, (%r13)
movq %rcx, %rdi
callq 0x7170
addq %rax, %r12
movq %rsp, %rdx
movq %r15, (%rdx)
leaq (%r15,%rbx,4), %rcx
pushq $0x1
popq %r8
movq %r13, %rdi
movq %r12, %rsi
callq 0xde95
testl %eax, %eax
jne 0x1144d
movq (%rsp), %rcx
movq %rcx, %rdx
subq %r15, %rdx
sarq $0x2, %rdx
movq %rdx, (%r14)
cmpq %rbx, %rdx
jae 0x1144d
andl $0x0, (%rcx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
leaq (%rcx,%r8,4), %rsi
movq %rsp, %rdx
movq %r15, (%rdx)
leaq (%r15,%rbx), %rcx
pushq $0x1
popq %r8
callq 0xdd68
testl %eax, %eax
jne 0x114a5
movq (%rsp), %rax
movq %rax, %rcx
subq %r15, %rcx
movq %rcx, (%r14)
cmpq %rbx, %rcx
jae 0x114a5
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: readUnicodeCharacter()
static char32_t readUnicodeCharacter(void) {
  static char8_t utf8String[5];
  static size_t utf8Count = 0;
  while (true) {
    char8_t c;

    /* Continue reading if interrupted by signal. */
    ssize_t nread;
    do {
      nread = read(0, &c, 1);
    } while ((nread == -1) && (errno == EINTR));

    if (nread <= 0) return 0;
    if (c <= 0x7F) {  // short circuit ASCII
      utf8Count = 0;
      return c;
    } else if (utf8Count < sizeof(utf8String) - 1) {
      utf8String[utf8Count++] = c;
      utf8String[utf8Count] = 0;
      char32_t unicodeChar[2];
      size_t ucharCount;
      ConversionResult res =
          copyString8to32(unicodeChar, 2, ucharCount, utf8String);
      if (res == conversionOK && ucharCount) {
        utf8Count = 0;
        return unicodeChar[0];
      }
    } else {
      utf8Count =
          0;  // this shouldn't happen: got four bytes but no UTF-8 character
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x7(%rsp), %rbx
pushq $0x1
popq %r14
leaq 0x1a4ff(%rip), %r15     # 0x2b9cc
leaq 0x10(%rsp), %r12
pushq $0x2
popq %r13
leaq 0x8(%rsp), %rbp
xorl %edi, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x74e0
cmpq $-0x1, %rax
jne 0x114fa
callq 0x7050
cmpl $0x4, (%rax)
je 0x114db
jmp 0x11553
testq %rax, %rax
jle 0x11553
movsbl 0x7(%rsp), %eax
testl %eax, %eax
jns 0x11564
movq 0x1a4c9(%rip), %rcx     # 0x2b9d8
cmpq $0x3, %rcx
ja 0x11549
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1a4b8(%rip)     # 0x2b9d8
movb %al, (%rcx,%r15)
movb $0x0, 0x1(%rcx,%r15)
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x113ea
testl %eax, %eax
jne 0x114db
cmpq $0x0, 0x8(%rsp)
je 0x114db
jmp 0x1156e
andq $0x0, 0x1a487(%rip)     # 0x2b9d8
jmp 0x114db
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, 0x1a46c(%rip)     # 0x2b9d8
jmp 0x11555
andq $0x0, 0x1a462(%rip)     # 0x2b9d8
movl 0x10(%rsp), %eax
jmp 0x11555
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::setMetaRoutine(char32_t)
static char32_t setMetaRoutine(char32_t c) {
  thisKeyMetaCtrl = META;
  if (c == 0x1B) {  // another ESC, stay in ESC processing mode
    c = readUnicodeCharacter();
    if (c == 0) return 0;
    return doDispatch(c, escDispatch);
  }
  return doDispatch(c, initialDispatch);
}

// Assembly:
movl $0x40000000, 0x1a3ab(%rip) # imm = 0x40000000
cmpl $0x1b, %edi
jne 0x1163f
pushq %rax
callq 0x114af
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0x1164b
leaq 0x19d70(%rip), %rsi     # 0x2b3a8
movl %eax, %edi
jmp 0x1157c
leaq 0x19d32(%rip), %rsi     # 0x2b378
jmp 0x1157c
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::escLeftBracket1Semicolon3Routine(char32_t)
static char32_t escLeftBracket1Semicolon3Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  thisKeyMetaCtrl |= META;
  return doDispatch(c, escLeftBracket1Semicolon3or5Dispatch);
}

// Assembly:
pushq %rax
callq 0x114af
testl %eax, %eax
je 0x117ca
orb $0x40, 0x1a210(%rip)    # 0x2b9cb
leaq 0x19d16(%rip), %rsi     # 0x2b4d8
movl %eax, %edi
popq %rax
jmp 0x1157c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::escLeftBracket1Semicolon5Routine(char32_t)
static char32_t escLeftBracket1Semicolon5Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  thisKeyMetaCtrl |= CTRL;
  return doDispatch(c, escLeftBracket1Semicolon3or5Dispatch);
}

// Assembly:
pushq %rax
callq 0x114af
testl %eax, %eax
je 0x117ee
orb $0x20, 0x1a1ec(%rip)    # 0x2b9cb
leaq 0x19cf2(%rip), %rsi     # 0x2b4d8
movl %eax, %edi
popq %rax
jmp 0x1157c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: Utf32String::Utf32String(char const*)
explicit Utf32String(const char* src) : _length(0), _data(nullptr) {
    size_t len = strlen(src);
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[len + 1]();
    copyString8to32(_data, len + 1, _length, src);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
callq 0x7170
leaq 0x1(%rax), %r15
movq %r15, %rcx
shrq $0x3e, %rcx
leaq 0x4(,%rax,4), %rax
xorl %r12d, %r12d
negq %rcx
sbbq %r12, %r12
orq %rax, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x71f0
movq %r13, 0x8(%r14)
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x113ea
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: DynamicPrompt::updateSearchText(char32_t const*)
void updateSearchText(const char32_t* textPtr) {
    Utf32String tempUnicode(textPtr);
    searchTextLen = static_cast<int>(tempUnicode.chars());
    searchText = tempUnicode;
    updateSearchPrompt();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x124f6
movl (%r14), %eax
movl %eax, 0x58(%rbx)
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x11d46
movq %rbx, %rdi
callq 0x11c14
leaq 0x8(%rsp), %rdi
callq 0x118be
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118be
movq %rbx, %rdi
callq 0x7600
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: DynamicPrompt::updateSearchPrompt()
void updateSearchPrompt(void) {
    const Utf32String* basePrompt =
        (direction > 0) ? &forwardSearchBasePrompt : &reverseSearchBasePrompt;
    size_t promptStartLength = basePrompt->length();
    promptChars = static_cast<int>(promptStartLength + searchTextLen +
                                   endSearchBasePrompt.length());
    promptBytes = promptChars;
    Utf32String tempUnicode(promptChars + 1);
    memcpy(tempUnicode.get(), basePrompt->get(),
           sizeof(char32_t) * promptStartLength);
    memcpy(&tempUnicode[promptStartLength], searchText.get(),
           sizeof(char32_t) * searchTextLen);
    size_t endIndex = promptStartLength + searchTextLen;
    memcpy(&tempUnicode[endIndex], endSearchBasePrompt.get(),
           sizeof(char32_t) * (endSearchBasePrompt.length() + 1));
    tempUnicode.initFromBuffer();
    promptText = tempUnicode;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x5c(%rdi)
leaq 0x19cb3(%rip), %rax     # 0x2b8e0
leaq 0x19cbc(%rip), %rcx     # 0x2b8f0
cmovgq %rax, %rcx
movq (%rcx), %r14
movl 0x19cbf(%rip), %eax     # 0x2b900
leaq 0x19ca0(%rip), %rcx     # 0x2b8e8
leaq 0x19ca9(%rip), %r12     # 0x2b8f8
cmovgq %rcx, %r12
movl 0x58(%rdi), %ecx
addl %r14d, %ecx
leal (%rcx,%rax), %edx
movl %edx, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
leal (%rax,%rcx), %esi
incl %esi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x119cc
movq 0x8(%r15), %rdi
movq (%r12), %rsi
shlq $0x2, %r14
movq %r14, %rdx
callq 0x7290
movq 0x8(%r15), %rdi
addq %r14, %rdi
movq 0x48(%rbx), %rsi
movslq 0x58(%rbx), %rdx
shlq $0x2, %rdx
callq 0x7290
movslq 0x58(%rbx), %rax
addq 0x8(%r15), %r14
leaq (%r14,%rax,4), %rdi
movq 0x19c55(%rip), %rsi     # 0x2b908
movq 0x19c46(%rip), %rax     # 0x2b900
leaq 0x4(,%rax,4), %rdx
callq 0x7290
movq %r15, %rdi
callq 0x11d30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11d46
leaq 0x8(%rsp), %rdi
callq 0x118be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118be
movq %rbx, %rdi
callq 0x7600
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: Utf32String::operator=(Utf32String const&)
Utf32String& operator=(const Utf32String& that) {
    if (this != &that) {
      delete[] _data;
      _data = new char32_t[that._length]();
      _length = that._length;
      memcpy(_data, that._data, sizeof(char32_t) * _length);
    }

    return *this;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x11db6
movq %rsi, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x11d6a
callq 0x7440
movq (%r14), %rbp
movq %rbp, %rax
shrq $0x3e, %rax
leaq (,%rbp,4), %r15
xorl %r12d, %r12d
negq %rax
sbbq %r12, %r12
orq %r15, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x71f0
movq %r13, 0x8(%rbx)
movq %rbp, (%rbx)
movq 0x8(%r14), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0x7290
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: KillRing::yankPop()
Utf32String* yankPop() {
    if (size == 0) {
      return 0;
    }
    ++index;
    if (index == size) {
      index = 0;
    }
    return &theRing[indexToSlot[index]];
  }

// Assembly:
movl (%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x11fb2
movl 0x4(%rdi), %edx
incl %edx
cmpl %ecx, %edx
cmovel %eax, %edx
movl %edx, 0x4(%rdi)
movslq %edx, %rax
movsbq 0x8(%rdi,%rax), %rax
shlq $0x4, %rax
addq 0x18(%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: InputBuffer::preloadBuffer(char const*)
void preloadBuffer(const char* preloadText) {
    size_t ucharCount = 0;
    copyString8to32(buf32, buflen + 1, ucharCount, preloadText);
    recomputeCharacterWidths(buf32, charWidths, static_cast<int>(ucharCount));
    len = static_cast<int>(ucharCount);
    pos = static_cast<int>(ucharCount);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rsp, %r14
andq $0x0, (%r14)
movq %rdi, %rbx
movq (%rdi), %rdi
movslq 0x10(%rbx), %rsi
incq %rsi
movq %r14, %rdx
callq 0x113ea
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movl (%r14), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
cmpq %r14, %r13
je 0x12216
movl (%r15,%r14,4), %edi
callq 0x12864
movb %al, (%r12,%r14)
incq %r14
jmp 0x121ff
movl %ebp, 0x14(%rbx)
movl %ebp, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: Utf32String::Utf32String(char32_t const*)
explicit Utf32String(const char32_t* src) : _length(0), _data(nullptr) {
    for (_length = 0; src[_length] != 0; ++_length) {
    }

    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[_length + 1]();
    memcpy(_data, src, _length * sizeof(char32_t));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, %r15
incq %rax
cmpl $0x0, (%rbx,%r15,4)
jne 0x1250d
movq %r15, (%r14)
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %r12d, %r12d
negq %rcx
sbbq %r12, %r12
orq %rax, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x71f0
movq %r13, 0x8(%r14)
shlq $0x2, %r15
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7290
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/wcwidth.cpp
// Function: linenoise_ng::bisearch(char32_t, linenoise_ng::interval const*, int)
static int bisearch(char32_t ucs, const struct interval *table, int max) {
  int min = 0;
  int mid;

  if (ucs < table[0].first || ucs > table[max].last)
    return 0;
  while (max >= min) {
    mid = (min + max) / 2;
    if (ucs > table[mid].last)
      min = mid + 1;
    else if (ucs < table[mid].first)
      max = mid - 1;
    else
      return 1;
  }

  return 0;
}

// Assembly:
xorl %ecx, %ecx
cmpl %edi, (%rsi)
ja 0x129ba
movl %edx, %r8d
movl %edx, %eax
cmpl %edi, 0x4(%rsi,%rax,8)
jb 0x129ba
xorl %r10d, %r10d
pushq $0x2
popq %r9
pushq $0x1
popq %rcx
cmpl %r10d, %r8d
jl 0x129b8
leal (%r10,%r8), %eax
cltd
idivl %r9d
movslq %eax, %rdx
cmpl %edi, 0x4(%rsi,%rdx,8)
jae 0x129ac
incl %eax
movl %eax, %r10d
jmp 0x1298f
cmpl %edi, (%rsi,%rdx,8)
jbe 0x129ba
decl %eax
movl %eax, %r8d
jmp 0x1298f
xorl %ecx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/wcwidth.cpp
// Function: linenoise_ng::mk_wcswidth(char32_t const*, unsigned long)
int mk_wcswidth(const char32_t* pwcs, size_t n)
{
  int w, width = 0;

  for (;*pwcs && n-- > 0; pwcs++)
    if ((w = mk_wcwidth(*pwcs)) < 0)
      return -1;
    else
      width += w;

  return width;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $-0x1
popq %rbp
xorl %ebx, %ebx
movl (%r15,%r12,4), %edi
testl %edi, %edi
je 0x129f2
cmpq %r12, %r14
je 0x129f2
callq 0x12864
testl %eax, %eax
js 0x129f0
addl %eax, %ebx
incq %r12
jmp 0x129d3
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/contrib/linenoise-ng/src/wcwidth.cpp
// Function: linenoise_ng::mk_wcswidth_cjk(wchar_t const*, unsigned long)
int mk_wcswidth_cjk(const wchar_t *pwcs, size_t n)
{
  int w, width = 0;

  for (;*pwcs && n-- > 0; pwcs++)
    if ((w = mk_wcwidth_cjk(*pwcs)) < 0)
      return -1;
    else
      width += w;

  return width;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $-0x1
popq %rbp
xorl %ebx, %ebx
movl (%r15,%r12,4), %edi
testl %edi, %edi
je 0x12a57
cmpq %r12, %r14
je 0x12a57
callq 0x129fd
testl %eax, %eax
js 0x12a55
addl %eax, %ebx
incq %r12
jmp 0x12a38
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/andrakis[P]alisp/./environment.hpp
// Function: ALisp::Environment::get(unsigned long)
Cell get(key_type key) EXCEPT {
			auto it = find_key(key);
			if (it != cend())
				return it->second;
			else if (has_parent())
				return _outer->get(key);
			throw KeyNotFoundException(key);
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x13c5c
testq %rax, %rax
je 0x13927
addq $0x10, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90a4
jmp 0x1393b
movq 0x38(%r15), %rsi
testq %rsi, %rsi
je 0x13944
movq %rbx, %rdi
movq %r14, %rdx
callq 0x138f8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x28
popq %rdi
callq 0x71b0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x13c6e
leaq 0x16aff(%rip), %rsi     # 0x2a460
leaq -0xa19e(%rip), %rdx     # 0x97ca
movq %r15, %rdi
callq 0x75d0
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x7250
jmp 0x13986
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x13993
callq 0x7430
callq 0x7600