LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
movl (%rcx), %eax
movq (%r8), %r8
subl %r8d, %eax
leaq (%rdx,%rax), %r9
leaq (%rax,%rdi), %r10
decq %r10
xorl %ecx, %ecx
movq %r8, %r11
subq $0x1, %r11
jb 0x3ef3
movzbl (%r10,%r8), %ebx
addl %ebx, %ecx
movzbl -0x1(%rsi,%r8), %ebx
addl %ecx, %ebx
movb %bl, (%r9,%r8)
shrl $0x8, %ebx
movl %ebx, %ecx
movq %r11, %r8
jmp 0x3ed0
movq %rax, %rsi
subq $0x1, %rsi
jb 0x3f10
movzbl -0x1(%rdi,%rax), %r8d
addl %r8d, %ecx
movb %cl, (%rdx,%rax)
shrl $0x8, %ecx
movq %rsi, %rax
jmp 0x3ef6
movb %cl, (%rdx)
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rcx), %r15
movq %r15, %rdi
callq 0x2030
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x3f47
movb (%r12,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x3f36
leal -0x2(%r15), %ecx
subq $0x1, %r15
jb 0x3f8d
movb (%rax,%r15), %dl
subb (%r14,%r15), %dl
movb %dl, (%rbx,%r15)
jae 0x3f89
movslq %ecx, %rdx
testl %edx, %edx
jle 0x3f7a
movl %edx, %edi
movb (%rax,%rdi), %sil
testb %sil, %sil
jne 0x3f80
movb $-0x1, (%rax,%rdi)
decq %rdx
jmp 0x3f62
movb (%rax,%rdx), %sil
jmp 0x3f82
movl %edx, %edx
decb %sil
movb %sil, (%rax,%rdx)
decl %ecx
jmp 0x3f4b
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
movq (%rcx), %r14
movq %r14, %rdi
callq 0x2030
xorl %ecx, %ecx
movq %rax, %rdi
cmpq %rcx, %r14
je 0x3fd9
movb (%r13,%rcx), %dl
movb %dl, (%rdi,%rcx)
incq %rcx
jmp 0x3fc7
movq (%r12), %rcx
movq %r14, %rdx
subq %rcx, %rdx
leal -0x2(%r14), %esi
movq %rcx, %r8
subq $0x1, %r8
jb 0x4034
leaq (%r8,%rdx), %r9
movb (%rdi,%r9), %r10b
subb (%r15,%r8), %r10b
movb %r10b, (%rbx,%r9)
jae 0x4030
movslq %esi, %r9
testl %r9d, %r9d
jle 0x4020
movl %r9d, %r11d
movb (%rdi,%r11), %r10b
testb %r10b, %r10b
jne 0x4026
movb $-0x1, (%rdi,%r11)
decq %r9
jmp 0x4005
movb (%rdi,%r9), %r10b
jmp 0x4029
movl %r9d, %r9d
decb %r10b
movb %r10b, (%rdi,%r9)
decl %esi
jmp 0x3fea
movq %rcx, %rdx
notq %rdx
addq %rdx, %rbx
addq %rdx, %rax
cmpq %r14, %rcx
je 0x4052
movb (%rax,%r14), %dl
movb %dl, (%rbx,%r14)
decq %r14
jmp 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x80(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x22d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x26e6
movl %eax, %r12d
leaq -0x80(%rbp), %rdi
callq 0x2130
testb %r12b, %r12b
je 0x2667
movq %r15, %rdi
movq %r14, %rsi
callq 0x28a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28f8
jmp 0x26ab
leaq 0xb7f7(%rip), %rsi      # 0xde65
leaq -0x60(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x294e
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
pushq $0x1
popq %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0xc50c
leaq -0x40(%rbp), %rdi
callq 0x298a
leaq -0x60(%rbp), %rdi
callq 0x2130
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x298a
leaq -0x60(%rbp), %rdi
jmp 0x26d9
movq %rax, %rbx
jmp 0x26de
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq -0xa8(%rbp), %rbx
movq %rbx, %rdi
callq 0x22d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e6
movl %eax, %r13d
leaq -0xa8(%rbp), %rdi
callq 0x2130
testb %r13b, %r13b
je 0x27a8
movq %r14, %rdi
movq %r12, %rsi
callq 0x3614
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x2a30
jmp 0x27ed
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22d0
leaq -0x88(%rbp), %rdi
movq %r15, %rsi
callq 0x28f8
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26f8
leaq -0x88(%rbp), %rdi
callq 0x2a66
leaq -0x48(%rbp), %rdi
callq 0x2130
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x2a66
jmp 0x2815
jmp 0x2812
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mespyr[P]bop-lisp/src/errors.cpp
// Function: ParsingError::error[abi:cxx11]()
std::string ParsingError::error() 
{
    if (!empty_stream) 
    {
        std::string error_string;
        error_string += "Parsing Error on line " + std::to_string(tok.line) + ".\n";
        error_string += msg;
        return error_string;
    } 
    else 
    {
        std::string error_string;
        error_string += "Parsing Error on line 1.\n";
        error_string += msg;
        return error_string;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x48(%rsi), %al
andq $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movb $0x0, 0x10(%rdi)
testb %al, %al
je 0x3968
leaq 0x9728(%rip), %rsi      # 0xd07b
movq %rbx, %rdi
callq 0x23a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
jmp 0x39cf
movl 0x20(%r14), %esi
leaq -0x30(%rbp), %rdi
callq 0x3f14
leaq 0x96e8(%rip), %rsi      # 0xd064
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3ee6
leaq 0x9702(%rip), %rdx      # 0xd092
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ebd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3a09
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x39ee
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x39fc
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3a0c
jmp 0x3a09
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %esi
leaq -0x30(%rbp), %rdi
callq 0x3f14
leaq 0x9645(%rip), %rsi      # 0xd095
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3ee6
leaq 0x962e(%rip), %rdx      # 0xd092
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ebd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3adb
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x3ac2
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x3ad0
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3ade
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %esi
leaq -0x30(%rbp), %rdi
callq 0x3f14
leaq 0x958b(%rip), %rsi      # 0xd0ad
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3ee6
leaq 0x955c(%rip), %rdx      # 0xd092
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ebd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3bad
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x3b94
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x3ba2
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3bb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %esi
leaq -0x30(%rbp), %rdi
callq 0x3f14
leaq 0x94d4(%rip), %rsi      # 0xd0c4
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3ee6
leaq 0x948e(%rip), %rdx      # 0xd092
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ebd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
leaq 0x94a3(%rip), %rsi      # 0xd0e2
movq %rbx, %rdi
callq 0x23a0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3c7f
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x3c66
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x3c74
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3c82
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %esi
leaq -0x30(%rbp), %rdi
callq 0x3f14
leaq 0x9436(%rip), %rsi      # 0xd0fc
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3ee6
leaq 0x93b8(%rip), %rdx      # 0xd092
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ebd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3d51
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x3d38
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x3d46
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3d54
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl 0x20(%rsi), %esi
leaq -0x30(%rbp), %rdi
callq 0x3f14
leaq 0x9378(%rip), %rsi      # 0xd110
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3ee6
leaq 0x92e6(%rip), %rdx      # 0xd092
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3ebd
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x23d0
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3e23
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x3e0a
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x3e18
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3e26
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ea0
leaq 0x9202(%rip), %rcx      # 0xd050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x3a1c
jmp 0x3eb3
addq $0x88, %rsi
movq %rbx, %rdi
callq 0x3d64
jmp 0x3eb3
subq $-0x80, %rsi
movq %rbx, %rdi
callq 0x3bc0
jmp 0x3eb3
addq $0x58, %rsi
movq %rbx, %rdi
callq 0x3c92
jmp 0x3eb3
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x3aee
jmp 0x3eb3
leaq 0x927e(%rip), %rsi      # 0xd125
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x294e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movl 0x70(%rsi), %esi
leal 0x1(%rsi), %edi
movl %edi, 0x70(%rcx)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x70
popq %r8
cqto
idivq %r8
cmpl %eax, %edi
jb 0x4029
movb $0x1, 0x74(%rcx)
movq %rcx, %rdi
callq 0x97d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Mespyr[P]bop-lisp/src/eval.cpp
// Function: Function_format_string[abi:cxx11](std::vector<object, std::allocator<object>>)
std::string Function_format_string(std::vector<object> objs) 
{
    std::string res;
    for (int i = 0; i < (int)objs.size(); i++) 
    {
        res += repr(objs.at(i));
    }
    return "'"+res+"'";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r15d, %r15d
leaq -0xb0(%rbp), %r12
leaq -0x50(%rbp), %r13
leaq -0x70(%rbp), %rbx
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x6, %rax
cltq
cmpq %rax, %r15
jge 0x4153
movq %r14, %rdi
movq %r15, %rsi
callq 0x9846
movq %r12, %rdi
movq %rax, %rsi
callq 0x28f8
movq %r13, %rdi
movq %r12, %rsi
callq 0xc43b
movq %rbx, %rdi
movq %r13, %rsi
callq 0x23d0
movq %r13, %rdi
callq 0x2130
movq %r12, %rdi
callq 0x2a66
incq %r15
jmp 0x4100
leaq 0x9d7a(%rip), %rsi      # 0xded4
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x9867
leaq 0x9d66(%rip), %rdx      # 0xded4
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3ebd
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x70(%rbp), %rdi
callq 0x2130
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x41d7
jmp 0x41d4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2130
jmp 0x41c6
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2a66
jmp 0x41d7
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x9846
leaq 0x8(%rax), %rsi
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x22d0
movq %r15, %rdi
callq 0xc4b8
movsd %xmm0, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2130
pushq $0x1
popq %r12
leaq -0x68(%rbp), %r15
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x6, %rax
cltq
cmpq %rax, %r12
jge 0x4281
movq %r14, %rdi
movq %r12, %rsi
callq 0x9846
leaq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x22d0
movq %r15, %rdi
callq 0xc4b8
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movq %r15, %rdi
callq 0x2130
incq %r12
jmp 0x4235
movq %rbx, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x98dd
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42a0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x9846
leaq 0x8(%rax), %rsi
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x22d0
movq %r15, %rdi
callq 0xc4b8
movsd %xmm0, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2130
pushq $0x1
popq %r12
leaq -0x68(%rbp), %r15
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x6, %rax
cltq
cmpq %rax, %r12
jge 0x44e2
movq %r14, %rdi
movq %r12, %rsi
callq 0x9846
leaq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x22d0
movq %r15, %rdi
callq 0xc4b8
movsd -0x28(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movq %r15, %rdi
callq 0x2130
incq %r12
jmp 0x4496
movq %rbx, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x98dd
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4501
movq %rax, %rbx
movq %r15, %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x2826
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x22d0
leaq -0xd8(%rbp), %rdi
movq %r14, %rsi
callq 0x28f8
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x2744
leaq -0xd8(%rbp), %rdi
callq 0x2a66
leaq -0x38(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2850
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2efc
leaq -0x98(%rbp), %rsi
movq %rbx, %rdi
callq 0x2846
leaq -0x98(%rbp), %rdi
callq 0x3260
leaq -0x68(%rbp), %rdi
callq 0x3260
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x3260
jmp 0x45fa
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x2a66
jmp 0x45ec
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2130
jmp 0x45fa
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mespyr[P]bop-lisp/src/main.cpp
// Function: ast_out(std::vector<Node, std::allocator<Node>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ast_out(std::vector<Node> nodes, std::string indent = "") 
{
    for (int i = 0; i < (int) nodes.size(); i++) 
    {
        Node node = nodes.at(i);
        if (node.type == ATOM) 
        {
            std::cout << indent << "TYPE: " << node.atom.type << ", LINE: " << node.atom.line << ", VALUE: " << node.atom.value << std::endl;
        } 
        else 
        {
            std::cout << indent << "NODE:\n";
            ast_out(node.nodes, indent+"    ");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0xd0(%rbp), %r15
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
pushq $0x70
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r13
jge 0xa60f
movq %r14, %rdi
movq %r13, %rsi
callq 0x97d2
leaq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x97f0
cmpl $0x1, -0xb0(%rbp)
jne 0xa59c
movq 0x8a90(%rip), %rdi      # 0x12fc8
movq %rbx, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x38df(%rip), %rsi      # 0xde29
callq 0x2210
movl -0x6c(%rbp), %esi
movq %rax, %rdi
callq 0x2370
movq %rax, %rdi
leaq 0x38cc(%rip), %rsi      # 0xde30
callq 0x2210
movl -0x70(%rbp), %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
leaq 0x38bb(%rip), %rsi      # 0xde39
callq 0x2210
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0x21e0
movq %rax, %rdi
callq 0x2140
jmp 0xa5fb
movq 0x8a25(%rip), %rdi      # 0x12fc8
movq %rbx, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x388e(%rip), %rsi      # 0xde43
callq 0x2210
leaq -0x40(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9be4
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x3873(%rip), %rdx      # 0xde4a
callq 0xacc2
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xa4d0
movq %r15, %rdi
callq 0x2130
movq %r12, %rdi
callq 0x9c3e
leaq -0xb0(%rbp), %rdi
callq 0x99c0
incq %r13
jmp 0xa4f4
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xa635
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x2130
leaq -0x40(%rbp), %rdi
callq 0x9c3e
jmp 0xa643
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x99c0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
jle 0xac9b
movq 0x8(%rsi), %rsi
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0xc654
leaq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x22d0
leaq -0x28(%rbp), %rdi
callq 0xa657
movl %eax, %ebx
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x48(%rbp), %rdi
callq 0x2130
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
callq 0xa8c8
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2130
jmp 0xacb1
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x2, 0x8(%rdi)
jb 0xb5b4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x23c0
cmpb $0x2d, (%rax)
jne 0xb5b4
leaq -0x30(%rbp), %r14
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2240
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22a0
movq %r14, %rdi
callq 0x2130
xorl %r14d, %r14d
xorl %eax, %eax
cmpq %r14, 0x8(%rbx)
jbe 0xb5e7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23c0
movb (%rax), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setb %cl
cmpb $0x2e, %al
sete %dl
orb %cl, %dl
incq %r14
movb $0x1, %al
testb %dl, %dl
jne 0xb5b9
xorl %eax, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpb $0x27, -0x1(%rax,%rcx)
jne 0xb616
cmpb $0x27, (%rax)
jne 0xb616
pushq $0x1
popq %rax
jmp 0xb63d
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x22d0
movq %rbx, %rdi
callq 0xb567
movl %eax, %ebx
leaq -0x28(%rbp), %rdi
callq 0x2130
xorb $0x1, %bl
movzbl %bl, %eax
addl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
andl $0x0, 0x28(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rsi, %r14
movb %al, 0x40(%rdi)
leaq 0x8(%rsi), %r15
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x22d0
leaq -0x38(%rbp), %rdi
callq 0xb5f2
movl %eax, 0x24(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x28(%rbx), %rdi
movl (%r14), %eax
movl %eax, 0x20(%rbx)
movq %r14, %rsi
callq 0xbcdc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2130
jmp 0xb6f6
movq %rax, %r14
movq %rbx, %rdi
callq 0x996e
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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, %rcx
movq %rdi, %rbx
movslq 0x18(%rsi), %rsi
leal 0x1(%rsi), %edi
movl %edi, 0x18(%rcx)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x28
popq %r8
cqto
idivq %r8
cmpl %eax, %edi
jl 0xbd2e
movb $0x1, 0x1c(%rcx)
movq %rcx, %rdi
callq 0xbebe
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9f10
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
je 0xc463
addq $0x8, %rsi
cmpl $0x1, %eax
jne 0xc478
movq %rbx, %rdi
callq 0x22d0
jmp 0xc498
leaq 0x1a6c(%rip), %rsi      # 0xded6
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x294e
jmp 0xc498
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x22d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc418
leaq -0x38(%rbp), %rdi
callq 0x2130
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2130
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/Mespyr[P]bop-lisp/src/types.cpp
// Function: make_object(Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<object, std::allocator<object>>)
object make_object(Type type_, std::string value, std::vector<object> list) 
{
    object obj;
    obj.type = type_;

    if (type_ == BOP_LIST) 
    {
        obj.list = list;
    } 
    else 
    {
        obj.value = value;
    }
    return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
andq $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movl %esi, (%rdi)
cmpl $0x2, %esi
jne 0xc548
leaq 0x28(%rbx), %rdi
movq %rcx, %rsi
callq 0x2c88
jmp 0xc554
leaq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x2160
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a66
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/Mespyr[P]bop-lisp/src/util.cpp
// Function: read_ascii_file[abi:cxx11](char const*)
std::string read_ascii_file(const char* path) 
{
    // file
	std::fstream file;
	file.open(path, std::ios::in);
    std::string code;

	if (!file) 
	{
		std::cout << "Error: No such file or directory '" << path << "'" << std::endl;
        exit(1);
	}
	else 
	{
		std::string ch;
		
		while (getline(file, ch))
		{  
			code += ch + '\n';  
		}
	}
	file.close();
	return code+"\0";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x2a0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2280
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq -0x2a0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x280(%rbp,%rax)
jne 0xc771
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x2a0(%rbp), %r14
leaq -0x70(%rbp), %r15
leaq -0x90(%rbp), %r12
pushq $0xa
popq %r13
leaq -0x50(%rbp), %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xc71b
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xc7f4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23d0
movq %r12, %rdi
callq 0x2130
jmp 0xc6df
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x2a0(%rbp), %rdi
callq 0x2050
movq -0x30(%rbp), %rbx
leaq 0x17ca(%rip), %rdx      # 0xdf05
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xacc2
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x2a0(%rbp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6850(%rip), %rdi      # 0x12fc8
leaq 0x1763(%rip), %rsi      # 0xdee2
callq 0x2210
movq %rax, %rdi
movq %r14, %rsi
callq 0x2210
leaq 0x173e(%rip), %rsi      # 0xded4
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x2140
pushq $0x1
popq %rdi
callq 0x2290
movq %rax, %rbx
jmp 0xc7e0
movq %rax, %rbx
jmp 0xc7d7
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2130
jmp 0xc7ce
jmp 0xc7cb
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x2a0(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NFunctionDeclStatement::generateHeader()
void generateHeader() {
    NStatement::generate(0);

    cout << type->cpp_type_string() << ' ' << id->name << '(';
    if (args) args->generate();
    cout << ");\n";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x8852
movq 0x20(%rbx), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq *(%rax)
movq 0xb840(%rip), %rdi      # 0x13fc8
movq %r14, %rsi
callq 0x51c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x5220
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x51c0
pushq $0x28
popq %rsi
movq %rax, %rdi
callq 0x5220
leaq -0x30(%rbp), %rdi
callq 0x5120
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x87ce
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xb7f3(%rip), %rdi      # 0x13fc8
leaq 0x606a(%rip), %rsi      # 0xe846
callq 0x51e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NListIndex::generate()
virtual void generate() {
    list_expr->generate();
    cout << "[";
    index->generate();
    cout << "]";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xb419(%rip), %r14      # 0x13fc8
leaq 0x5875(%rip), %rsi      # 0xe42b
movq %r14, %rdi
callq 0x51e0
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x585e(%rip), %rsi      # 0xe42d
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NWhileStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "while (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x8852
movq 0xb1f1(%rip), %r15      # 0x13fc8
leaq 0x5651(%rip), %rsi      # 0xe42f
movq %r15, %rdi
callq 0x51e0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x5967(%rip), %rsi      # 0xe75e
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0x8852
leaq 0x5613(%rip), %rsi      # 0xe437
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5130
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NIfStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "if (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;

    if (elifStmt) {
      elifStmt->generate(level);
    } else if (elseStmt) {
      elseStmt->generate(level);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x8852
movq 0xb16f(%rip), %r15      # 0x13fc8
leaq 0x55de(%rip), %rsi      # 0xe43e
movq %r15, %rdi
callq 0x51e0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x58e5(%rip), %rsi      # 0xe75e
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0x8852
leaq 0x5591(%rip), %rsi      # 0xe437
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x8ec8
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x8edc
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NElifStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "else if (";
    expr->generate();
    cout << ") {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;

    if (elifStmt) {
      elifStmt->generate(level);
    } else if (elseStmt) { // huhu
      elseStmt->generate(level);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x8852
movq 0xb0c5(%rip), %r15      # 0x13fc8
leaq 0x552f(%rip), %rsi      # 0xe439
movq %r15, %rdi
callq 0x51e0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x583b(%rip), %rsi      # 0xe75e
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
movq 0x18(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0x8852
leaq 0x54e7(%rip), %rsi      # 0xe437
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x8f72
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x8f86
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NElseStatement::generate(int)
virtual void generate(int level) {
    NStatement::generate(level);
    cout << "else {" << endl;
    stmt->generate(level + 1);
    printIndent(level);
    cout << "}" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x8852
movq 0xb01b(%rip), %r15      # 0x13fc8
leaq 0x548f(%rip), %rsi      # 0xe443
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5130
movq 0x10(%r14), %rdi
leal 0x1(%rbx), %esi
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
movl %ebx, %esi
callq 0x8852
leaq 0x5456(%rip), %rsi      # 0xe437
movq %r15, %rdi
callq 0x51e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5130
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NArgs::generate()
virtual void generate() {
    cout << get_type()->cpp_type_string() << " " << id->name;

    if (next) {
      cout << ',';
      next->generate();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq (%rax), %rcx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0xad7b(%rip), %rdi      # 0x13fc8
movq %r14, %rsi
callq 0x51c0
leaq 0x517f(%rip), %rsi      # 0xe3db
movq %rax, %rdi
callq 0x51e0
movq 0x8(%rbx), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x51c0
leaq -0x30(%rbp), %rdi
callq 0x5120
cmpq $0x0, 0x10(%rbx)
je 0x929d
movq 0xad3d(%rip), %rdi      # 0x13fc8
pushq $0x2c
popq %rsi
callq 0x5220
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/obj/../src/node.hpp
// Function: NString::generate_itr_header(NIdentifier*)
virtual void generate_itr_header(NIdentifier *id) {
    cout << "for (std::string " << id->name << " : ";
    cout << "javelin::string_itr(";
    generate();
    cout << ")) {" << endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xaba9(%rip), %rbx      # 0x13fc8
leaq 0x530c(%rip), %rsi      # 0xe732
movq %rbx, %rdi
callq 0x51e0
addq $0x10, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x51c0
leaq 0x5300(%rip), %rsi      # 0xe744
movq %rax, %rdi
callq 0x51e0
leaq 0x52f5(%rip), %rsi      # 0xe748
movq %rbx, %rdi
callq 0x51e0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x52f2(%rip), %rsi      # 0xe75d
movq %rbx, %rdi
callq 0x51e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5130
nop
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: Scope::addDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Definition*)
void Scope::addDefinition(string name, Definition *definition) {
  if (table.find(name) != table.end()) {
    throw std::runtime_error("Definition '" + name +
                             "' previously declared as a " +
                             (table[name]->isFunction() ? "fun" : "var"));
  }
  table[name] = definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0xa910
testq %rax, %rax
jne 0x95a0
movq %r15, %rdi
movq %r14, %rsi
callq 0xaa0e
movq %rbx, (%rax)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5140
movq %rax, %rbx
leaq 0x53cc(%rip), %rsi      # 0xe97e
leaq -0x38(%rbp), %rdi
movq %r14, %rdx
callq 0x9c59
leaq 0x53c6(%rip), %rdx      # 0xe98b
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x91c8
movq %r15, %rdi
movq %r14, %rsi
callq 0xaa0e
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x53bb(%rip), %rcx      # 0xe9a7
leaq 0x53b8(%rip), %rdx      # 0xe9ab
testb %al, %al
cmovneq %rcx, %rdx
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x91c8
movb $0x1, %r15b
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
xorl %r15d, %r15d
movq 0xa9d1(%rip), %rsi      # 0x13ff0
movq 0xa99a(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x5350
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x5120
jmp 0x9642
movq %rax, %r14
movb $0x1, %r15b
leaq -0x58(%rbp), %rdi
callq 0x5120
jmp 0x9653
movq %rax, %r14
movb $0x1, %r15b
leaq -0x38(%rbp), %rdi
callq 0x5120
testb %r15b, %r15b
jne 0x9666
jmp 0x966e
movq %rax, %r14
movq %rbx, %rdi
callq 0x5180
movq %r14, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: Scope::findDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Definition * Scope::findDefinition(string name) {
  auto itr = table.find(name);
  if (itr != table.end()) {
    return (*itr).second;
  } else if (this->next != NULL) {
    return this->next->findDefinition(name);
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0xa910
testq %rax, %rax
je 0x969d
movq 0x28(%rax), %rbx
jmp 0x96d0
movq 0x40(%r14), %r14
testq %r14, %r14
je 0x96ce
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5290
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x5120
jmp 0x96d0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O2/Mulan-Szechuan-Sauce[P]javelin/src/scope.cpp
// Function: FunctionDefinition::argsMatch(NExpressionArgs*)
bool FunctionDefinition::argsMatch(NExpressionArgs *args) {
  NExpressionArgs *itr1 = args;
  NArgs *itr2 = stmt->args;

  for (; itr1 && itr2; itr1 = itr1->next, itr2 = itr2->next) {
    Type *itr1Type = itr1->expr->get_type();
    Type *itr2Type = itr2->get_type();
    if (itr1Type->cpp_type_string() != itr2Type->cpp_type_string()) {
      return false;
    }
  }
  return itr1 == NULL && itr2 == NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rdi), %r14
addq $0x18, %r14
leaq -0x50(%rbp), %r12
leaq -0x70(%rbp), %rbx
movq (%r14), %r14
testq %rsi, %rsi
je 0x9782
testq %r14, %r14
je 0x9782
movq %rsi, -0x30(%rbp)
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
movq (%r13), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *(%rax)
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8bdb
movl %eax, %r15d
movq %rbx, %rdi
callq 0x5120
movq %r12, %rdi
callq 0x5120
testb %r15b, %r15b
jne 0x978a
movq -0x30(%rbp), %rsi
movq 0x8(%rsi), %rsi
addq $0x10, %r14
jmp 0x9713
orq %r14, %rsi
sete %al
jmp 0x978c
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5370
nop