LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::division::align_divisor(unsigned char const*, unsigned char*, unsigned long const&)
int align_divisor(const unsigned char* dividend, unsigned char* divisor, const std::size_t& len) {
			  int result = 0;
				while (!less_or_equal(divisor, dividend, len)) {
					bits::shift_right(divisor, 1, len);
					++result;
				}
				return result;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
testq %rax, %rax
je 0x4434
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
leaq -0x30(%rbp), %r13
movq %rax, %rcx
negq %rcx
movl $0x1, %edx
xorl %esi, %esi
movb -0x1(%r12,%rdx), %dil
cmpb %dil, -0x1(%r15,%rdx)
jb 0x4436
ja 0x440c
cmpq %rax, %rdx
setae %sil
leaq (%rcx,%rdx), %rdi
incq %rdi
incq %rdx
cmpq $0x1, %rdi
jne 0x43e5
jmp 0x4436
testb $0x1, %sil
jne 0x4436
movq $0x1, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x42f3
incl %ebx
movq (%r14), %rax
testq %rax, %rax
jne 0x43d8
jmp 0x4436
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::division::readjust(unsigned char const*, unsigned char*, unsigned long const&)
int readjust(const unsigned char* dividend, unsigned char* divisor, const std::size_t& len) {
				int adjustment = 0;
				while (!less_or_equal(divisor, dividend, len)) {
					bits::shift_right(divisor, 1, len);
					++adjustment;
				}
				return adjustment;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
testq %rax, %rax
je 0x44fe
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
leaq -0x30(%rbp), %r13
movq %rax, %rcx
negq %rcx
movl $0x1, %edx
xorl %esi, %esi
movb -0x1(%r12,%rdx), %dil
cmpb %dil, -0x1(%r15,%rdx)
jb 0x4500
ja 0x44d6
cmpq %rax, %rdx
setae %sil
leaq (%rcx,%rdx), %rdi
incq %rdi
incq %rdx
cmpq $0x1, %rdi
jne 0x44af
jmp 0x4500
testb $0x1, %sil
jne 0x4500
movq $0x1, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x42f3
incl %ebx
movq (%r14), %rax
testq %rax, %rax
jne 0x44a2
jmp 0x4500
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::school_multiply(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&, unsigned long const&)
void school_multiply(const unsigned char* a, const unsigned char* b,
			unsigned char* result, const std::size_t& a_len, const std::size_t& b_len) {
		// end_pos tracks the least significant digit in the result array
		std::size_t a_index, b_index, result_index, end_pos;
		unsigned int carry, tmp;
		const std::size_t RESULT_LEN = a_len + b_len + 1;
		// initialize result to 0
		for (result_index = 0; result_index < RESULT_LEN; ++result_index) {
			result[result_index] = 0;
		}
		b_index = b_len;
		end_pos = RESULT_LEN;
		while (b_index > 0) {
			--b_index;
			result_index = end_pos;
			a_index = a_len;
			carry = 0;
			while (a_index > 0) {
				--a_index;
				--result_index;
				tmp = carry + result[result_index] + a[a_index] * b[b_index];
				result[result_index] = tmp % RADIX;
				carry = tmp / RADIX;
			}
			result[result_index - 1] = carry;
			--end_pos;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r11
movq (%r8), %rax
movq (%rcx), %r13
addq %rax, %r13
movq %r13, %r12
incq %r12
je 0x459a
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r11, -0x38(%rbp)
movq %r8, -0x30(%rbp)
callq 0x20b0
movq -0x38(%rbp), %r11
movq -0x30(%rbp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x4601
decq %r11
leaq (%r14,%r13), %rcx
notq %r13
decq %rax
movq (%rbx), %rdi
xorl %edx, %edx
testq %rdi, %rdi
je 0x45eb
leaq (%r11,%rdi), %r8
negq %rdi
xorl %esi, %esi
movzbl (%rcx,%rsi), %r9d
addl %edx, %r9d
movzbl (%r8,%rsi), %r10d
movzbl (%r15,%rax), %edx
imull %r10d, %edx
addl %r9d, %edx
movb %dl, (%rcx,%rsi)
shrl $0x8, %edx
decq %rsi
cmpq %rsi, %rdi
jne 0x45bf
subq %r13, %rsi
jmp 0x45ee
movq %r12, %rsi
movb %dl, -0x1(%r14,%rsi)
decq %r12
incq %r13
decq %rcx
testq %rax, %rax
jne 0x45a9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::add(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&)
void add(const unsigned char* a, const unsigned char* b, unsigned char* result,
			const std::size_t& len) {
		unsigned int carry = 0, tmp_sum;
		std::size_t i = len;
		while (i > 0) {
			--i;
			tmp_sum = carry + a[i] + b[i];
			result[i] = tmp_sum % RADIX;
			carry = tmp_sum / RADIX;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rcx), %rax
testq %rax, %rax
je 0x463b
xorl %ecx, %ecx
movzbl -0x1(%rdi,%rax), %r8d
addl %ecx, %r8d
movzbl -0x1(%rsi,%rax), %ecx
addl %r8d, %ecx
movb %cl, -0x1(%rdx,%rax)
shrl $0x8, %ecx
decq %rax
jne 0x461e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::add(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&, unsigned long const&)
void add(const unsigned char* a, const unsigned char* b,
			unsigned char* result, const std::size_t& a_len, const std::size_t& b_len) {
		unsigned int carry = 0, tmp_sum;
		unsigned int a_b_diff = a_len - b_len;
		std::size_t i = b_len;
		while (i > 0) {
			--i;
			tmp_sum = carry + a[i + a_b_diff] + b[i];
			result[i + a_b_diff + 1] = tmp_sum % RADIX;
			carry = tmp_sum / RADIX;
		}
		i = a_b_diff;
		while (i > 0) {
			--i;
			tmp_sum = carry + a[i];
			result[i + 1] = tmp_sum % RADIX;
			carry = tmp_sum / RADIX;
		}
		result[0] = carry;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rcx), %rax
movq (%r8), %r8
testq %r8, %r8
je 0x467b
subl %r8d, %eax
leaq (%rdx,%rax), %r9
leaq (%rax,%rdi), %r10
decq %r10
xorl %ecx, %ecx
movzbl (%r10,%r8), %r11d
addl %ecx, %r11d
movzbl -0x1(%rsi,%r8), %ecx
addl %r11d, %ecx
movb %cl, (%r9,%r8)
shrl $0x8, %ecx
decq %r8
jne 0x465c
jmp 0x467f
movl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x4699
movzbl -0x1(%rdi,%rax), %esi
addl %ecx, %esi
movl %esi, %ecx
shrl $0x8, %ecx
movb %sil, (%rdx,%rax)
decq %rax
jne 0x4684
movb %cl, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::subtract(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&)
void subtract(const unsigned char* a, const unsigned char* b, unsigned char* result,
			const std::size_t& len) {
		std::size_t i;
		// copy of a is needed because we have to modify it when we borrow
		unsigned char* a_copy = new unsigned char[len];
		for (i = 0; i < len; ++i) { a_copy[i] = a[i]; }
		i = len;
		int borrow_index;
		while (i > 0) {
			--i;
			if (a_copy[i] >= b[i]) { result[i] = a_copy[i] - b[i]; }
			else {
				result[i] = RADIX + a_copy[i] - b[i];
				borrow_index = i - 1;
				// get to a point where there is something to borrow
				while (borrow_index > 0 && a_copy[borrow_index] == 0) {
					a_copy[borrow_index--] = RADIX_MINUS_ONE;
				}
				--a_copy[borrow_index];
			}
		}
		delete[] a_copy;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq (%rcx), %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
testq %r15, %r15
je 0x4713
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2120
movb -0x1(%r12,%r15), %al
subb -0x1(%r14,%r15), %al
movb %al, -0x1(%rbx,%r15)
jae 0x470e
leal -0x2(%r15), %eax
testl %eax, %eax
jle 0x4708
movl %eax, %ecx
cmpb $0x0, (%r12,%rcx)
jne 0x4708
leal -0x1(%rax), %edx
movb $-0x1, (%r12,%rcx)
cmpl $0x1, %eax
movl %edx, %eax
jg 0x46ee
xorl %eax, %eax
cltq
decb (%r12,%rax)
decq %r15
jne 0x46d5
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::subtract(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&, unsigned long const&)
void subtract(const unsigned char* a, const unsigned char* b, unsigned char* result,
			const std::size_t& a_len, const std::size_t& b_len) {
		std::size_t i;
		// copy of a is needed because we have to modify it when we borrow
		unsigned char* a_copy = new unsigned char[a_len];
		for (i = 0; i < a_len; ++i) { a_copy[i] = a[i]; }
		std::size_t ab_len_diff = a_len - b_len;
		i = b_len;
		int borrow_index;
		while (i > 0) {
			--i;
			if (a_copy[i + ab_len_diff] >= b[i]) { result[i + ab_len_diff] = a_copy[i + ab_len_diff] - b[i]; }
			else {
				result[i + ab_len_diff] = RADIX + a_copy[i + ab_len_diff] - b[i];
				borrow_index = i + ab_len_diff - 1;
				// get to a point where there is something to borrow
				while (borrow_index > 0 && a_copy[borrow_index] == 0) {
					a_copy[borrow_index--] = RADIX_MINUS_ONE;
				}
				--a_copy[borrow_index];
			}
		}
		i = ab_len_diff;
		while (i > 0) {
			--i;
			result[i] = a_copy[i];
		}
		delete[] a_copy;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq (%rcx), %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r14
testq %r12, %r12
je 0x4766
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x2120
movq (%r13), %rax
movq %r12, %rdx
subq %rax, %rdx
testq %rax, %rax
je 0x47ba
movq %rax, %rcx
leaq (%rcx,%rdx), %rsi
decq %rsi
movb (%r14,%rsi), %dil
subb -0x1(%r15,%rcx), %dil
movb %dil, (%rbx,%rsi)
jae 0x47b5
decl %esi
testl %esi, %esi
jle 0x47ae
movl %esi, %edi
cmpb $0x0, (%r14,%rdi)
jne 0x47ae
movb $-0x1, (%r14,%rdi)
leal -0x1(%rsi), %edi
cmpl $0x1, %esi
movl %edi, %esi
jg 0x4794
xorl %esi, %esi
movslq %esi, %rsi
decb (%r14,%rsi)
decq %rcx
jne 0x4778
cmpq %rax, %r12
je 0x47ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2120
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/env.cpp
// Function: Env::at_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
object Env::at_key(std::string key) 
{
    if (has_key(key))
    {
        return dict.at(key);
    }
    else 
    {
        return make_object(BOP_NUMBER, "0");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x3688
movq %r15, %rdi
movq %r12, %rsi
callq 0x3812
movq %rax, %r12
leaq 0x8(%r15), %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x27b3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
cmpq %r13, %r12
je 0x27fb
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bc2
movq %rax, %r15
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3688
leaq 0x28(%rbx), %rdi
addq $0x28, %r15
movq %r15, %rsi
callq 0x2e02
jmp 0x2863
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x116ab(%rip), %rsi     # 0x13eb5
leaq 0x116a5(%rip), %rdx     # 0x13eb6
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x3774
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x11f20
leaq -0x90(%rbp), %rdi
callq 0x2c20
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x2863
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2c20
movq -0x70(%rbp), %rdi
movq %r15, -0x30(%rbp)
cmpq %r15, %rdi
jne 0x28b4
jmp 0x28c3
movq %rax, %rbx
movq (%r14), %rdi
movq %r12, -0x30(%rbp)
cmpq %r12, %rdi
jne 0x28b4
jmp 0x28c3
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x28c3
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/env.cpp
// Function: Env::set_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, object)
void Env::set_key(std::string key, object value) 
{
    if (has_key(key)) 
    {
        dict.find(key)->second = value;
    } 
    else 
    {
        add_key(key, value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x3688
movq %r14, %rdi
movq %r12, %rsi
callq 0x3812
movq %rax, %r12
leaq 0x8(%r14), %r13
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x29d2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2240
cmpq %r13, %r12
je 0x2a10
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b0c
movq %rax, %r14
movl (%rbx), %eax
movl %eax, 0x40(%r14)
leaq 0x48(%r14), %rdi
leaq 0x8(%rbx), %rsi
callq 0x2150
addq $0x68, %r14
addq $0x28, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fd0
jmp 0x2ab1
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x3688
movl (%rbx), %eax
leaq -0xa0(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0x90(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
callq 0x3688
leaq -0x80(%rbp), %r15
addq $0x28, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2e02
leaq -0x68(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
movq %r14, %rdi
callq 0x28ec
movq %r15, %rdi
callq 0x2c20
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x2a9c
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2ab1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2240
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2d8e
jmp 0x2af7
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x2af7
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x2af7
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2b0c
movq (%r13), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq %rax, %r13
cmpq %rax, %rdi
jne 0x2b00
jmp 0x2b0c
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/errors.cpp
// Function: ArgumentError::error[abi:cxx11]()
std::string ArgumentError::error() 
{
    std::string error_string;
    error_string += "Argument Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %r15d
movl $0x1, %eax
cmpl $0xa, %r15d
jb 0x40a0
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0x4099
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x409e
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x40a0
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x4068
addl $-0x3, %eax
jmp 0x40a0
addl $-0x2, %eax
jmp 0x40a0
decl %eax
movl %eax, %esi
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x90(%rbp), %rdi
xorl %edx, %edx
callq 0x22a0
leaq -0x90(%rbp), %r12
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x4c01
leaq 0xefda(%rip), %rcx      # 0x130b1
movl $0x17, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x410d
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x4114
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xef78(%rip), %rsi      # 0x130ae
callq 0x23e0
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4160
movq %rsi, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x416b
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x20f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x419f
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x41b4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x41cc
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4240
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x420c
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x420c
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x4226
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4226
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4243
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4243
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x425b
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/errors.cpp
// Function: KeywordError::error[abi:cxx11]()
std::string KeywordError::error() 
{
    std::string error_string;
    error_string += "Keyword Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %r15d
movl $0x1, %eax
cmpl $0xa, %r15d
jb 0x42e6
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0x42df
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x42e4
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x42e6
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x42ae
addl $-0x3, %eax
jmp 0x42e6
addl $-0x2, %eax
jmp 0x42e6
decl %eax
movl %eax, %esi
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x90(%rbp), %rdi
xorl %edx, %edx
callq 0x22a0
leaq -0x90(%rbp), %r12
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x4c01
leaq 0xedac(%rip), %rcx      # 0x130c9
movl $0x16, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4353
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x435a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xed32(%rip), %rsi      # 0x130ae
callq 0x23e0
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x43a6
movq %rsi, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x43b1
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x20f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x43e5
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x43fa
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4412
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4486
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4452
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4452
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x446c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x446c
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4489
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4489
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x44a1
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/errors.cpp
// Function: DivisionByZeroError::error[abi:cxx11]()
std::string DivisionByZeroError::error() 
{
    std::string error_string;
    error_string += "DivisionByZero Error on line " + std::to_string(line) + ".\n";
    error_string += "Can't divide number by 0.";
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %r14d
movl $0x1, %eax
cmpl $0xa, %r14d
jb 0x4524
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x451d
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x4522
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x4524
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x44ec
addl $-0x3, %eax
jmp 0x4524
addl $-0x2, %eax
jmp 0x4524
decl %eax
movl %eax, %esi
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x90(%rbp), %rdi
xorl %edx, %edx
callq 0x22a0
leaq -0x90(%rbp), %r15
movq (%r15), %rdi
movl 0x8(%r15), %esi
movl %r14d, %edx
callq 0x4c01
leaq 0xeb87(%rip), %rcx      # 0x130e0
movl $0x1d, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x458f
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x4596
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xeaf6(%rip), %rsi      # 0x130ae
callq 0x23e0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x45e1
movq %rsi, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x45eb
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x20f0
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x461f
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x4634
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x464c
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
leaq 0xeaab(%rip), %rsi      # 0x130fe
movq %rbx, %rdi
callq 0x23e0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46c3
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x468e
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x468e
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x46a9
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x46a9
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x46c7
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x46c7
movq %rax, -0x30(%rbp)
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x46db
movq (%r12), %rsi
incq %rsi
callq 0x2240
movq -0x30(%rbp), %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/errors.cpp
// Function: TypeError::error[abi:cxx11]()
std::string TypeError::error() 
{
    std::string error_string;
    error_string += "Type Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %r15d
movl $0x1, %eax
cmpl $0xa, %r15d
jb 0x4766
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0x475f
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x4764
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x4766
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x472e
addl $-0x3, %eax
jmp 0x4766
addl $-0x2, %eax
jmp 0x4766
decl %eax
movl %eax, %esi
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x90(%rbp), %rdi
xorl %edx, %edx
callq 0x22a0
leaq -0x90(%rbp), %r12
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x4c01
leaq 0xe97b(%rip), %rcx      # 0x13118
movl $0x13, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x47d3
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x47da
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe8b2(%rip), %rsi      # 0x130ae
callq 0x23e0
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4826
movq %rsi, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x4831
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x20f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4865
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x487a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4892
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4906
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x48d2
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x48d2
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x48ec
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x48ec
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4909
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4909
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x4921
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/errors.cpp
// Function: IndexError::error[abi:cxx11]()
std::string IndexError::error() 
{
    std::string error_string;
    error_string += "Index Error on line " + std::to_string(line) + ".\n";
    error_string += msg;
    return error_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %r15d
movl $0x1, %eax
cmpl $0xa, %r15d
jb 0x49ac
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0x49a5
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x49aa
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x49ac
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x4974
addl $-0x3, %eax
jmp 0x49ac
addl $-0x2, %eax
jmp 0x49ac
decl %eax
movl %eax, %esi
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x90(%rbp), %rdi
xorl %edx, %edx
callq 0x22a0
leaq -0x90(%rbp), %r12
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x4c01
leaq 0xe749(%rip), %rcx      # 0x1312c
movl $0x14, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4a19
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x4a20
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe66c(%rip), %rsi      # 0x130ae
callq 0x23e0
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4a6c
movq %rsi, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x4a77
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x20f0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4aab
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x4ac0
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4ad8
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b4c
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x4b18
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4b18
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x4b32
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4b32
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b4f
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x4b4f
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x4b67
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/errors.cpp
// Function: ErrorMap::error[abi:cxx11]()
std::string ErrorMap::error() 
{
    if (type == ARGUMENT_ERROR) 
    {
        return arg.error();
    }
    else if (type == KEYWORD_ERROR) 
    {
        return keyword.error();
    }
    else if (type == DIVISION_BY_ZERO_ERROR) 
    {
        return division.error();
    }
    else if (type == TYPE_ERROR) 
    {
        return type_.error();
    }
    else if (type == INDEX_ERROR) 
    {
        return index.error();
    }
    else 
    {
        return "Error Found with Bop: Can't get Error Type.";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x4bda
leaq 0xe4e4(%rip), %rcx      # 0x1306c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x401e
jmp 0x4bf7
addq $0x88, %rsi
movq %rbx, %rdi
callq 0x492a
jmp 0x4bf7
subq $-0x80, %rsi
movq %rbx, %rdi
callq 0x44aa
jmp 0x4bf7
addq $0x58, %rsi
movq %rbx, %rdi
callq 0x46e4
jmp 0x4bf7
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x4264
jmp 0x4bf7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xe559(%rip), %rsi      # 0x13141
leaq 0xe57d(%rip), %rdx      # 0x1316c
movq %rbx, %rdi
callq 0x3774
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/eval.cpp
// Function: AST_Handler::next()
Node AST_Handler::next() 
{
    ptr++;
    if (ptr >= (int) ast.nodes.size()) 
    {
        eof = true;
    }
    return ast.nodes.at(ptr-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movl 0x70(%rsi), %esi
leal 0x1(%rsi), %ecx
movl %ecx, 0x70(%rax)
movq (%rax), %r13
movq 0x8(%rax), %rdi
subq %r13, %rdi
sarq $0x4, %rdi
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rdx
cmpl %edx, %ecx
jb 0x4cb8
movb $0x1, 0x74(%rax)
cmpq %rsi, %rdx
jbe 0x4d49
imulq $0x70, %rsi, %r14
leaq (%r14,%r13), %r12
addq $0x8, %r12
movl -0x8(%r12), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movq %r12, %rsi
callq 0xdfe8
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x20(%rbx)
movq 0x18(%r12), %rsi
movq 0x20(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3688
addq %r14, %r13
movq 0x40(%r13), %rax
movq %rax, 0x40(%rbx)
movl 0x48(%r13), %eax
movl %eax, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq 0x50(%r13), %rsi
movq 0x58(%r13), %rdx
addq %rsi, %rdx
callq 0x3688
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xef9f(%rip), %rdi      # 0x13cef
xorl %eax, %eax
callq 0x2320
movq %rax, %rbx
movq (%r15), %rdi
cmpq -0x30(%rbp), %rdi
je 0x4d77
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2240
jmp 0x4d77
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0xe08a
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Function_add_nums[abi:cxx11](std::vector<object, std::allocator<object>>)
std::string Function_add_nums(std::vector<object> objs) 
{
    double res = to_number(objs.at(0).value);
    for (int i = 1; i < (int)objs.size(); i++) 
    {
        res += to_number(objs.at(i).value);
    }
    return std::to_string(res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x5205
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x3688
movq %r15, %rdi
callq 0x11e60
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x5115
movq -0x70(%rbp), %rsi
incq %rsi
movsd %xmm0, -0x30(%rbp)
callq 0x2240
movsd -0x30(%rbp), %xmm0
movq %rbx, -0x38(%rbp)
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
cmpl $0x2, %edx
jl 0x51c1
movl $0x1, %r15d
movl $0x50, %ebx
leaq -0x50(%rbp), %r13
leaq -0x60(%rbp), %r12
movsd %xmm0, -0x30(%rbp)
cmpq %r15, %rdx
jbe 0x51f4
movq %r13, -0x60(%rbp)
movq -0x8(%rax,%rbx), %rsi
movq (%rax,%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3688
movq %r12, %rdi
callq 0x11e60
movapd %xmm0, %xmm1
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x5194
movq -0x50(%rbp), %rsi
incq %rsi
movsd %xmm1, -0x40(%rbp)
callq 0x2240
movsd -0x40(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x6, %rdx
shrq $0x6, %rcx
movslq %ecx, %rcx
addq $0x40, %rbx
cmpq %rcx, %r15
jl 0x5143
movq 0x13df0(%rip), %rsi     # 0x18fb8
leaq 0xeb1d(%rip), %rcx      # 0x13cec
movl $0x148, %edx            # imm = 0x148
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0xe2c5
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xeaf4(%rip), %rdi      # 0x13cef
movq %r15, %rsi
xorl %eax, %eax
callq 0x2320
leaq 0xeae3(%rip), %rdi      # 0x13cef
xorl %esi, %esi
xorl %edx, %edx
jmp 0x51fe
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0x5222
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x5233
movq (%r13), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Function_div_nums[abi:cxx11](std::vector<object, std::allocator<object>>)
std::string Function_div_nums(std::vector<object> objs) 
{
    double res = to_number(objs.at(0).value);
    for (int i = 1; i < (int)objs.size(); i++) 
    {
        res /= to_number(objs.at(i).value);
    }
    return std::to_string(res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x56b5
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x3688
movq %r15, %rdi
callq 0x11e60
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x55c5
movq -0x70(%rbp), %rsi
incq %rsi
movsd %xmm0, -0x30(%rbp)
callq 0x2240
movsd -0x30(%rbp), %xmm0
movq %rbx, -0x38(%rbp)
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
cmpl $0x2, %edx
jl 0x5671
movl $0x1, %r15d
movl $0x50, %ebx
leaq -0x50(%rbp), %r13
leaq -0x60(%rbp), %r12
movsd %xmm0, -0x30(%rbp)
cmpq %r15, %rdx
jbe 0x56a4
movq %r13, -0x60(%rbp)
movq -0x8(%rax,%rbx), %rsi
movq (%rax,%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3688
movq %r12, %rdi
callq 0x11e60
movapd %xmm0, %xmm1
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x5644
movq -0x50(%rbp), %rsi
incq %rsi
movsd %xmm1, -0x40(%rbp)
callq 0x2240
movsd -0x40(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x6, %rdx
shrq $0x6, %rcx
movslq %ecx, %rcx
addq $0x40, %rbx
cmpq %rcx, %r15
jl 0x55f3
movq 0x13940(%rip), %rsi     # 0x18fb8
leaq 0xe66d(%rip), %rcx      # 0x13cec
movl $0x148, %edx            # imm = 0x148
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0xe2c5
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe644(%rip), %rdi      # 0x13cef
movq %r15, %rsi
xorl %eax, %eax
callq 0x2320
leaq 0xe633(%rip), %rdi      # 0x13cef
xorl %esi, %esi
xorl %edx, %edx
jmp 0x56ae
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0x56d2
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x56e3
movq (%r13), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Evaluator::destructive_return(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, object)
void Evaluator::destructive_return(std::string name, object value)
{
    Env top = env_stack.back();
    top.set_key(name, value);
    env_stack.pop();
    env_stack.push(top);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xb8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2b2a
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3688
movl (%r14), %eax
leaq -0x80(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x3688
leaq -0x60(%rbp), %r15
addq $0x28, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e02
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x296c
movq %r15, %rdi
callq 0x2c20
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x579d
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2240
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x57b2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x2b54
leaq -0xe8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3318
leaq -0xe8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2b4a
leaq -0xe8(%rbp), %rdi
callq 0x3670
leaq -0xb8(%rbp), %rdi
callq 0x3670
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x3670
jmp 0x585f
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2d8e
jmp 0x5845
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x5845
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x5845
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x585f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x585f
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x3670
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/main.cpp
// Function: main
int main(int argc, char const *argv[])
{   
    if (argc <2) 
    { 
        REPL();
        return 0;
    }
    std::string code = read_ascii_file(argv[1]);
    return evalString(code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x1, %edi
jle 0xfeed
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x11f84
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x3688
leaq -0x30(%rbp), %rdi
callq 0xed89
movl %eax, %ebx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xfec9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfee2
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf47d
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xff0f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0xff0f
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xff28
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/parser.cpp
// Function: is_number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_number(std::string value) 
{
    bool ret = false;
    bool dec_point_found = false;

    // If value is negative
    if (value.length() >= 2 and value.at(1) == '-') 
    {
        value = value.substr(1); 
    }
    for (int i = 0; i < value.length(); i++) 
    {
        char t = value.at(i);
        ret = is_num(t);
        if (t == '.') 
        {
            dec_point_found = !dec_point_found;
            ret = !ret;
        }
        if (!ret) 
        {
            break;
        }
    } 
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
cmpq $0x2, %rcx
jb 0x108ae
movq (%rbx), %rax
cmpb $0x2d, 0x1(%rax)
jne 0x108b3
leaq -0x30(%rbp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x2260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x108aa
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x108e3
movq (%rbx), %rdx
decq %rcx
xorl %esi, %esi
movb (%rdx,%rsi), %al
leal -0x30(%rax), %edi
cmpb $0xa, %dil
setb %dil
cmpb $0x2e, %al
sete %al
orb %dil, %al
cmpb $0x1, %al
jne 0x108e5
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rcx
movq %rdi, %rsi
jne 0x108bb
jmp 0x108e5
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/parser.cpp
// Function: Typeof(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
AtomType Typeof(std::string value) 
{
    if (value.back() == '\'' and value.front() == '\'') 
    {
        return STRING;
    }
    else if (is_number(value)) 
    {
        return NUMBER;
    }
    return SYMBOL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
cmpb $0x27, -0x1(%rsi,%rdx)
jne 0x10911
movl $0x1, %eax
cmpb $0x27, (%rsi)
je 0x1094f
addq %rsi, %rdx
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3688
movq %rbx, %rdi
callq 0x1084b
movl %eax, %ebx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x10947
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
xorb $0x1, %bl
movzbl %bl, %eax
addl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x10970
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/parser.cpp
// Function: create_atom(Token)
Atom create_atom(Token tok)  
{
    Atom atom{};
    atom.type = Typeof(tok.value);
    atom.value = tok.value;
    atom.line = tok.line;
    atom.token = tok;
    return atom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x3688
leaq -0x40(%rbp), %rdi
callq 0x108ee
leaq 0x8(%r14), %r15
movl %eax, 0x24(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x109f9
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
leaq 0x30(%rbx), %rdi
movl (%r14), %eax
movl %eax, 0x20(%rbx)
movl %eax, 0x28(%rbx)
movq %r15, %rsi
callq 0x2150
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x10a46
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2240
jmp 0x10a46
movq %rax, %r14
movq %rbx, %rdi
callq 0xdc86
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/../include/parser.h
// Function: Reader::next()
Token next() 
    {
        ptr++;
        if (ptr >= (int) tokens.token_stream.size()) 
        {
            eof = true;
        }
        return tokens.token_stream.at(ptr-1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movslq 0x18(%rsi), %rsi
leal 0x1(%rsi), %edi
movl %edi, 0x18(%rax)
movq (%rax), %rcx
movq 0x8(%rax), %r8
subq %rcx, %r8
sarq $0x3, %r8
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %r8, %rdx
cmpl %edx, %edi
jl 0x11552
movb $0x1, 0x1c(%rax)
cmpq %rsi, %rdx
jbe 0x11588
leaq (%rsi,%rsi,4), %rax
movl (%rcx,%rax,8), %edx
movl %edx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rdx
movq %rdx, 0x8(%rbx)
movq 0x8(%rcx,%rax,8), %rsi
movq 0x10(%rcx,%rax,8), %rdx
addq %rsi, %rdx
callq 0x3688
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2760(%rip), %rdi      # 0x13cef
xorl %eax, %eax
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/Mespyr[P]bop-lisp/src/types.cpp
// Function: repr[abi:cxx11](object)
std::string repr(object obj) 
{
    if (obj.type == BOP_NUMBER) 
    {
        return obj.value;
    }
    else if (obj.type == BOP_LIST) 
    {
        return "<List>";
    }
    else 
    {
        return format_string(obj.value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x11dc4
cmpl $0x1, %eax
jne 0x11de3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3688
jmp 0x11e32
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2154(%rip), %rsi      # 0x13f26
leaq 0x2153(%rip), %rdx      # 0x13f2c
movq %rbx, %rdi
callq 0x3774
jmp 0x11e32
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3688
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x11e32
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x11e58
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x23a0