LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/tests/test_util.hpp
// Function: encode_base64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string encode_base64(const std::string& str)
{
	static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

	const unsigned char* const s = reinterpret_cast<const unsigned char*>(str.c_str());
	std::string result((str.size() + 2) / 3 * 4, '=');
	std::size_t src_pos = 0;
	std::size_t dst_pos = 0;

	while (true)
	{
		if (src_pos == str.size())
			break;

		result[dst_pos] = table[(s[src_pos] & 0xfc) >> 2];

		if (src_pos == str.size() - 1)
		{
			result[dst_pos + 1] = table[(s[src_pos] & 0x03) << 4];
			break;
		}

		result[dst_pos + 1] = table[((s[src_pos] & 0x03) << 4) | ((s[src_pos + 1] & 0xf0) >> 4)];

		if (src_pos == str.size() - 2)
		{
			result[dst_pos + 2] = table[(s[src_pos + 1] & 0x0f) << 2];
			break;
		}

		result[dst_pos + 2] = table[((s[src_pos + 1] & 0x0f) << 2) | ((s[src_pos + 2] & 0xc0) >> 6)];
		result[dst_pos + 3] = table[s[src_pos + 2] & 0x3f];

		dst_pos += 4;
		src_pos += 3;
	}

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %rax
addq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
leaq (%rdx,%rdx), %rsi
andq $-0x4, %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl $0x3d, %edx
callq 0xa450
cmpq $0x0, 0x8(%r14)
je 0x18750
xorl %eax, %eax
leaq 0x39a27(%rip), %rcx     # 0x520c0
xorl %edx, %edx
movzbl (%r15,%rdx), %esi
shrl $0x2, %esi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, (%rdi,%rax)
movq 0x8(%r14), %rdi
decq %rdi
movzbl (%r15,%rdx), %esi
shll $0x4, %esi
andl $0x30, %esi
cmpq %rdi, %rdx
je 0x18737
movzbl 0x1(%r15,%rdx), %edi
shrl $0x4, %edi
orq %rsi, %rdi
movb (%rdi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x1(%rdi,%rax)
movq 0x8(%r14), %rdi
addq $-0x2, %rdi
movzbl 0x1(%r15,%rdx), %esi
shll $0x2, %esi
andl $0x3c, %esi
cmpq %rdi, %rdx
je 0x1873e
movzbl 0x2(%r15,%rdx), %edi
shrl $0x6, %edi
orq %rsi, %rdi
movb (%rdi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x2(%rdi,%rax)
movzbl 0x2(%r15,%rdx), %esi
andl $0x3f, %esi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x3(%rdi,%rax)
addq $0x4, %rax
addq $0x3, %rdx
cmpq 0x8(%r14), %rdx
jne 0x1869b
jmp 0x18750
movl $0x1, %edx
jmp 0x18743
movl $0x2, %edx
movzbl %sil, %esi
movb (%rsi,%rcx), %cl
addq (%rbx), %rdx
movb %cl, (%rax,%rdx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_key_traits<short, void>::test(short, unsigned long)
static bool test(value_type value, std::size_t index)
		{
			assert(index < size(value));
			unsigned_value_type unsigned_value = static_cast<unsigned_value_type>(value);
			unsigned_value ^= signbit;
			return (unsigned_value & (static_cast<unsigned_value_type>(1) << static_cast<unsigned_value_type>(num_bits - index - 1))) != 0;
		}

// Assembly:
cmpq $0x10, %rsi
jae 0x1c336
xorl $0x8000, %edi           # imm = 0x8000
movzwl %di, %eax
movb $0xf, %cl
subb %sil, %cl
movzbl %cl, %ecx
btl %ecx, %eax
setb %al
retq
pushq %rax
leaq 0x35024(%rip), %rdi     # 0x51362
leaq 0x30acc(%rip), %rsi     # 0x4ce11
leaq 0x38adf(%rip), %rcx     # 0x54e2b
movl $0x93, %edx
callq 0xa240
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_node.hpp
// Function: cb_tree::detail::cb_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prev_leaf() const
node_pointer prev_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

				do
				{
					if (node->left())
						return node->left()->max_leaf();

					while(node->is_left_child())
						node = node->parent();

					node = node->parent();
				} while (!node->leaf());

				return node;
			}

// Assembly:
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
jne 0x1e5c2
movq %rdi, %rcx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
cmpq %rcx, %rax
je 0x1e5ab
cmpb $0x1, 0x8(%rdi)
jne 0x1e5a6
jmp 0x1e5d4
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1e5c2
cmpb $0x0, 0x8(%rdi)
je 0x1e5d9
movq %rdi, %rax
popq %rcx
retq
leaq 0x2e4df(%rip), %rdi     # 0x4cabf
leaq 0x2df14(%rip), %rsi     # 0x4c4fb
leaq 0x3816d(%rip), %rcx     # 0x5675b
movl $0xe6, %edx
callq 0xa240
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::longest_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<iterator, iterator> longest_match(const key_type& key)
			{
				node_pointer branch = find_branch(key);
				if (branch == end_node())
					return std::make_pair(end(), end());

				node_pointer leaf = branch->any_leaf();
				size_type mismatch = traits_type::mismatch(key, derived().key(leaf->value()));
				mismatch = traits_type::lexical_index(mismatch);

				while (branch != root_node() && mismatch <= branch->parent()->index())
					branch = branch->parent();

				return std::make_pair(iterator(branch->min_leaf()), iterator(branch->next_branch_leaf()));
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
shlq $0x4, %rdx
incq %rdx
callq 0xc32c
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x20939
movq %rax, %r14
movb 0x8(%rax), %al
movq %r14, %rsi
testb %al, %al
jne 0x208b7
movq %r14, %rsi
xorl %eax, %eax
cmpq $0x0, (%rsi)
sete %al
shll $0x4, %eax
movq (%rsi,%rax), %rsi
movb 0x8(%rsi), %al
cmpb $0x1, %al
jne 0x208a0
testb %al, %al
je 0x20945
addq $0x28, %rsi
movq %r15, %rdi
callq 0xc3b8
andq $-0x10, %rax
movq (%rbx), %rcx
movq %r14, %rdx
cmpq %rcx, %r14
je 0x208e4
movq 0x18(%rdx), %r14
cmpq 0x20(%r14), %rax
jbe 0x208d2
movq %rdx, %rax
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x208e7
cmpb $0x1, 0x8(%rbx)
jne 0x20964
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rax, (%rdx)
jne 0x208f8
cmpb $0x0, 0x8(%rdx)
jne 0x2093c
movq %rdx, %rdi
callq 0xc654
movq %rax, %rdx
testq %rax, %rax
jne 0x2093c
leaq 0x2bcc6(%rip), %rdi     # 0x4c5e7
leaq 0x2bcc4(%rip), %rsi     # 0x4c5ec
leaq 0x2bce6(%rip), %rcx     # 0x4c615
movl $0x38, %edx
callq 0xa240
movq %rbx, %rdx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2be7e(%rip), %rdi     # 0x4c7ca
leaq 0x2bba8(%rip), %rsi     # 0x4c4fb
leaq 0x2bbc6(%rip), %rcx     # 0x4c520
movl $0x78, %edx
callq 0xa240
leaq 0x2c154(%rip), %rdi     # 0x4cabf
leaq 0x2bb89(%rip), %rsi     # 0x4c4fb
leaq 0x2c153(%rip), %rcx     # 0x4cacc
movl $0xd5, %edx
callq 0xa240
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prefix_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<iterator, iterator> prefix_match(const key_type& key)
			{
				size_type size = traits_type::size(key);
				node_pointer branch = find_branch(key, size);
				if (branch == end_node())
					return std::make_pair(end(), end());

				node_pointer leaf = branch->any_leaf();
				size_type mismatch = traits_type::mismatch(key, derived().key(leaf->value()));
				mismatch = traits_type::lexical_index(mismatch);

				if(mismatch != traits_type::lexical_index(size))
					return std::make_pair(end(), end());

				while (branch != root_node() && mismatch <= branch->parent()->index())
					branch = branch->parent();

				return std::make_pair(iterator(branch->min_leaf()), iterator(branch->next_branch_leaf()));
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
shlq $0x4, %r12
leaq 0x1(%r12), %rdx
callq 0xc32c
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x20a5f
movq %rax, %r14
movb 0x8(%rax), %al
movq %r14, %rsi
testb %al, %al
jne 0x209d8
movq %r14, %rsi
xorl %eax, %eax
cmpq $0x0, (%rsi)
sete %al
shll $0x4, %eax
movq (%rsi,%rax), %rsi
movb 0x8(%rsi), %al
cmpb $0x1, %al
jne 0x209c1
testb %al, %al
je 0x20a71
addq $0x28, %rsi
movq %r15, %rdi
callq 0xc3b8
andq $-0x10, %rax
cmpq %r12, %rax
jne 0x20a5f
movq (%rbx), %rax
movq %r14, %rdx
cmpq %rax, %r14
je 0x20a0a
movq 0x18(%rdx), %r14
cmpq 0x20(%r14), %r12
jbe 0x209f8
movq %rdx, %rax
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x20a0d
cmpb $0x1, 0x8(%rbx)
jne 0x20a90
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rax, (%rdx)
jne 0x20a1e
cmpb $0x0, 0x8(%rdx)
jne 0x20a62
movq %rdx, %rdi
callq 0xc654
movq %rax, %rdx
testq %rax, %rax
jne 0x20a62
leaq 0x2bba0(%rip), %rdi     # 0x4c5e7
leaq 0x2bb9e(%rip), %rsi     # 0x4c5ec
leaq 0x2bbc0(%rip), %rcx     # 0x4c615
movl $0x38, %edx
callq 0xa240
movq %rbx, %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2bd52(%rip), %rdi     # 0x4c7ca
leaq 0x2ba7c(%rip), %rsi     # 0x4c4fb
leaq 0x2ba9a(%rip), %rcx     # 0x4c520
movl $0x78, %edx
callq 0xa240
leaq 0x2c028(%rip), %rdi     # 0x4cabf
leaq 0x2ba5d(%rip), %rsi     # 0x4c4fb
leaq 0x2c027(%rip), %rcx     # 0x4cacc
movl $0xd5, %edx
callq 0xa240
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/cb_map.hpp
// Function: cb_tree::cb_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::at(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mapped_type& at(const key_type& key)
		{
			auto it = find(key);
			if (it == end())
				throw std::out_of_range("cb_map::at");

			return it->second;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2195a
movq %rax, (%rsp)
testq %rax, %rax
je 0x21312
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x21331
movq %rsp, %rdi
callq 0x21906
addq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2b884(%rip), %rdi     # 0x4cb9d
leaq 0x2b2cc(%rip), %rsi     # 0x4c5ec
leaq 0x36cc2(%rip), %rcx     # 0x57fe9
movl $0x6d, %edx
callq 0xa240
movl $0x10, %edi
callq 0xa190
movq %rax, %rbx
leaq 0x372a5(%rip), %rsi     # 0x585ea
movq %rax, %rdi
callq 0xa080
movq 0x57c6c(%rip), %rsi     # 0x78fc0
movq 0x57c5d(%rip), %rdx     # 0x78fb8
movq %rbx, %rdi
callq 0xa640
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2c0
movq %r14, %rdi
callq 0xa690
// File: /workspace/github_cpp_makefile_star2_O3/AsherGlick[P]CommentHeader/source/./pipein.h
// Function: copyToClipboard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int copyToClipboard(std::string contents)
{
    std::ifstream xclipBinary("/usr/bin/xclip");
    if (!xclipBinary.good()){
        std::cout << "Error: Cannot Find XClip binary" << std::endl;
        return -1;
    }
    int fd1[2];
    pid_t pid;
    // Create a pipe
    if ( (pipe(fd1) < 0) ) return -2; // Pipe Error (parent)
    // fork into a new process
    if ( (pid = fork()) < 0 ) return -3; // Fork Error (parent)
    
    // Child process
    else  if (pid == 0) {
        close(fd1[1]);
        if (fd1[0] != STDIN_FILENO) {
            if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO) return -5; // Dup2 error (Child)
            close(fd1[0]);
        }
        char *args[] = { (char*)"xclip" , (char*)"-sel", (char*)"clip", (char*)0};
        if ( execv("/usr/bin/xclip", args) < 0) return -4; //execv error (CHILD)
        return 0;
    }

    // PARENT process
    else {
        close(fd1[0]);
        if ( write(fd1[1], contents.c_str(), contents.size() ) != (int)contents.size() ) return -6; // WRITE ERROR FROM PIPE (PARENT)
        close(fd1[1]);
        return 0;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
movq %rdi, %rbx
leaq 0x683d(%rip), %rsi      # 0xf219
leaq -0x248(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x33b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x228(%rbp,%rax)
je 0x8a66
movq 0xb5b0(%rip), %rbx      # 0x13fb8
leaq 0x6819(%rip), %rsi      # 0xf228
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x32c0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %esi
movq 0xb57e(%rip), %rdi      # 0x13fb8
callq 0x3030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x31a0
leaq -0x248(%rbp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x3300
testl %eax, %eax
js 0x8aaf
callq 0x30a0
testl %eax, %eax
js 0x8ab6
je 0x8abd
movl -0x18(%rbp), %edi
callq 0x33f0
movl -0x14(%rbp), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x30f0
movslq 0x8(%rbx), %rcx
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
cmpq %rcx, %rax
jne 0x8a4c
xorl %ebx, %ebx
movl -0x14(%rbp), %edi
callq 0x33f0
jmp 0x8a4c
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x8a4c
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x8a4c
movl -0x14(%rbp), %edi
callq 0x33f0
movl -0x18(%rbp), %edi
testl %edi, %edi
je 0x8ae8
xorl %esi, %esi
callq 0x3250
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
testl %eax, %eax
jne 0x8a4c
movl -0x18(%rbp), %edi
callq 0x33f0
movaps 0xb271(%rip), %xmm0     # 0x13d60
leaq -0x40(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps 0xb252(%rip), %xmm0     # 0x13d50
movaps %xmm0, (%rsi)
leaq 0x6711(%rip), %rdi      # 0xf219
callq 0x3230
movl %eax, %ebx
sarl $0x1f, %ebx
andl $-0x4, %ebx
jmp 0x8a4c
jmp 0x8b1c
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/AsherGlick[P]CommentHeader/source/main.cpp
// Function: captureExtendedInput[abi:cxx11]()
string captureExtendedInput() {
  string input;
  string output = "";
  while (getline(cin, input)) {
    if (input == "") return output;
    output += input + "\n";
  }
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x6534(%rip), %rdx      # 0xfbd9
movq %rdx, %rsi
callq 0x750c
leaq -0x40(%rbp), %r12
movq 0xa918(%rip), %r14      # 0x13fd0
leaq -0x70(%rbp), %r15
leaq -0x50(%rbp), %r13
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x9750
movq %r15, %rdi
leaq 0x64df(%rip), %rsi      # 0xfbd9
callq 0x30c0
testl %eax, %eax
je 0x9750
movq %r12, -0x50(%rbp)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x7faa
movq %r13, %rdi
leaq 0x64b4(%rip), %rsi      # 0xfbd8
callq 0x33e0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x96c0
callq 0x3260
jmp 0x96c0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x9762
callq 0x3260
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x97a1
jmp 0x977d
jmp 0x9790
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x9793
callq 0x3260
jmp 0x9793
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x97a1
callq 0x3260
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x97b3
callq 0x3260
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/AsherGlick[P]CommentHeader/source/main.cpp
// Function: stripTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string stripTrailingSpaces(string withTrailingSpaces) {
  string withoutTrailingSpaces = "";
  int cutoff = withTrailingSpaces.size()-1;
  for (; cutoff >= 0; cutoff--) {
    if (withTrailingSpaces[cutoff] != ' ') {
      break;
    }
  }
  for (int i = 0; i <= cutoff; i++) {
    withoutTrailingSpaces += withTrailingSpaces[i];
  }

  return withoutTrailingSpaces;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x63fc(%rip), %rdx      # 0xfbd9
movq %rdx, %rsi
callq 0x750c
movq 0x8(%r14), %rax
movl %eax, %ecx
incl %eax
decq %rcx
testl %ecx, %ecx
js 0x9828
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq (%r14), %rsi
decl %eax
decq %rcx
cmpb $0x20, (%rsi,%rdx)
je 0x97f0
movl %eax, %r12d
xorl %r13d, %r13d
movq (%r14), %rax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x3210
incq %r13
cmpq %r13, %r12
jne 0x9810
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x984a
callq 0x3260
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/AsherGlick[P]CommentHeader/source/main.cpp
// Function: thisyear[abi:cxx11]()
string thisyear() {
  #define SECONDSPERYEAR 31556926
  #define EPOCH 1970
  unsigned long year = (time(NULL)/SECONDSPERYEAR)+EPOCH;
  stringstream ss;
  ss << year;
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3240
movabsq $0x22068a920e22bed1, %rcx # imm = 0x22068A920E22BED1
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x16, %rdx
leaq (%rdx,%rax), %r14
addq $0x7b2, %r14            # imm = 0x7B2
leaq -0x198(%rbp), %rdi
callq 0x31c0
leaq -0x188(%rbp), %rdi
movq %r14, %rsi
callq 0x3190
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x3370
movq 0x6f30(%rip), %rsi      # 0x13fa0
leaq -0x198(%rbp), %rdi
callq 0x31e0
leaq -0x118(%rbp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x6eff(%rip), %rsi      # 0x13fa0
leaq -0x198(%rbp), %rdi
callq 0x31e0
leaq -0x118(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::getToken()
token_type Scanner::getToken(){
	return_token.type = ScanOneToken(fPtr, &return_token);
	return_token.line = line_number;	
	if(debug && return_token.type != T_EOF){
		cout << return_token.ascii << " ";
	}
	return return_token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x130(%rsi), %rsi
leaq 0x8(%r15), %rdx
movq %r15, %rdi
callq 0x328e
leaq 0x28(%r15), %r14
movl %eax, 0x28(%r15)
movl (%r15), %ecx
movl %ecx, 0x2c(%r15)
cmpl $0x15d, %eax            # imm = 0x15D
je 0x3256
cmpb $0x0, 0x138(%r15)
je 0x3256
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq 0x1ed9b(%rip), %rdi     # 0x21fd8
callq 0x2230
leaq 0x16073(%rip), %rsi     # 0x192bc
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3bac
movq %rbx, %rdi
addq $0x20, %rdi
movl $0x108, %edx            # imm = 0x108
movq %r14, %rsi
callq 0x2190
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Program()
void Parser::Program(){
	Scopes->newScope(); //Create new scope for the program
	declareRunTime(); //set up runtime functions as global in the outermost scope
	if( !ProgramHeader() ) ReportError("Expected program header");
	if( !ProgramBody() ) ReportError("Expected program body");
	if( !CheckToken(T_PERIOD) ) ReportWarning("expected '.' at end of program");
	if( CheckToken(T_EOF) ) Scopes->exitScope(); //exit program scope once program ends
		
	else ReportError("Found some tokens remaining in file when end of program was expected");
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0xfa5e
movq %rbx, %rdi
callq 0x5e68
movq %rbx, %rdi
callq 0x6398
testb %al, %al
jne 0x428a
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15101(%rip), %rsi     # 0x19355
leaq 0x15111(%rip), %rdx     # 0x1936c
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3c42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5694
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x428a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x6550
movq %rbx, %rdi
movl $0x12b, %esi            # imm = 0x12B
callq 0x5c08
testb %al, %al
jne 0x42e9
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x150ba(%rip), %rsi     # 0x1936d
leaq 0x150d1(%rip), %rdx     # 0x1938b
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3c42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4388
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x42e9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movl $0x15d, %esi            # imm = 0x15D
callq 0x5c08
testb %al, %al
je 0x4308
movq 0x90(%rbx), %rdi
callq 0xfae6
jmp 0x434b
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15074(%rip), %rsi     # 0x1938c
leaq 0x150b1(%rip), %rdx     # 0x193d0
movq %rsp, %r14
movq %r14, %rdi
callq 0x3c42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5694
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x434b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x4370
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x4370
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x4380
movq (%r15), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::~Parser()
Parser::~Parser(){
	// set all pointers to nullptr
	token = nullptr;
	scanner = nullptr;
	Scopes = nullptr;
	generator = nullptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
movq 0x58(%rdi), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x49f9
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
popq %rbx
jmp 0xddd4
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ProgramHeader()
bool Parser::ProgramHeader(){
	if(CheckToken(T_PROGRAM)){
		string id;
		if( Identifier(id) ){
			Scopes->ChangeScopeName("Program " + id);	
			if(CheckToken(T_IS)) return true;
			else{
				ReportError("expected 'is' after program identifier");
				return false;
			}
		}
		else{
			ReportError("expected program identifier after 'program'");
			return false;
		}
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x101, %esi            # imm = 0x101
callq 0x5c08
testb %al, %al
je 0x6472
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6a76
testb %al, %al
je 0x6476
movq 0x90(%rbx), %r14
leaq 0x12fdf(%rip), %rsi     # 0x193d1
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xdcc7
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x101c4
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6429
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x5c08
movb $0x1, %bpl
testb %al, %al
jne 0x64bb
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12f8d(%rip), %rsi     # 0x193da
leaq 0x12fac(%rip), %rdx     # 0x19400
leaq 0x48(%rsp), %rdi
callq 0x3c42
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x5694
movq 0x48(%rsp), %rdi
jmp 0x64a9
xorl %ebp, %ebp
jmp 0x64d2
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12f7b(%rip), %rsi     # 0x19401
leaq 0x12f9f(%rip), %rdx     # 0x1942c
leaq 0x28(%rsp), %rdi
callq 0x3c42
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5694
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x64b9
movq (%r14), %rsi
incq %rsi
callq 0x2200
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x64d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x6531
movq 0x58(%rsp), %rsi
jmp 0x6522
jmp 0x652e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x6531
movq 0x38(%rsp), %rsi
jmp 0x6522
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6531
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6531
jmp 0x652e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6548
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Identifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Parser::Identifier(string &id){
	string tmp = token->ascii;
	bool ret_val = CheckToken(TYPE_IDENTIFIER);
	if(ret_val){
		id = tmp;
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3bac
movq %r14, %rdi
movl $0x11c, %esi            # imm = 0x11C
callq 0x5c08
movl %eax, %ebp
testb %al, %al
je 0x6aca
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2120
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6ae1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6b08
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Statement()
bool Parser::Statement(){
	string id = "";
	if( IfStatement() ) return true;
	else if( LoopStatement() ) return true;
	else if( ReturnStatement() ) return true;
	else if( Assignment(id) ) return true;
	else if( ProcedureCall(id) ) return true;
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x13a41(%rip), %rdx     # 0x1a95d
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3c42
movq %r14, %rdi
callq 0x8992
movb $0x1, %bl
testb %al, %al
jne 0x6fa7
movq %r14, %rdi
callq 0x9936
testb %al, %al
jne 0x6fa7
movq %r14, %rdi
callq 0xa4ae
testb %al, %al
jne 0x6fa7
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xa4dc
testb %al, %al
jne 0x6fa7
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3bac
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x7d7c
movl %eax, %ebx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fa7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6fbe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6feb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6feb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7002
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ProcedureDeclaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scopeValue&, bool)
bool Parser::ProcedureDeclaration(string &id, scopeValue &procDeclaration, bool global){
	//Get Procedure Header
	if( ProcedureHeader(id, procDeclaration, global) ){
		if( ProcedureBody() ) return true;
		else{
			ReportFatalError("Expected procedure body after procedure header.");
			return true;
		}
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x72b4
movl %eax, %ebp
testb %al, %al
je 0x702e
movq %rbx, %rdi
callq 0x76d8
testb %al, %al
je 0x703b
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x126c9(%rip), %rsi     # 0x19714
leaq 0x126f1(%rip), %rdx     # 0x19743
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3c42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a02
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7084
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::VariableDeclaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scopeValue&)
bool Parser::VariableDeclaration(string &id, scopeValue &varEntry){
	//get variable type, otherwise no variable should be declared
	if( !TypeMark(varEntry.type) ) return false;
	else{
		//get variable identifier
		if( Identifier(id) ){
			// Get size for array variable declarations
			if(CheckToken(T_LBRACKET)){
				if(CheckToken(TYPE_INTEGER)){
					varEntry.size = token->val.intValue;
					if( !CheckToken(T_RBRACKET) ) ReportError("expected ']' at end of array variable declaration.");
					return true;
				}
				else{
					ReportLineError("Expected integer for array size in variable declaration.");
					return true;
				}
			}
			else{
				varEntry.size = 0;
				return true;
			}
		}
		else{
			ReportLineError("Bad line. Expected variable identifier for declaration after type mark.");
			return true;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7232
movl %eax, %ebx
testb %al, %al
je 0x71a9
movq %r14, %rdi
movq %r12, %rsi
callq 0x6a76
testb %al, %al
je 0x7153
movq %r14, %rdi
movl $0x135, %esi            # imm = 0x135
callq 0x5c08
testb %al, %al
je 0x71a1
movq %r14, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x5c08
testb %al, %al
je 0x71b7
movq 0x80(%r14), %rax
movl 0x28(%rax), %eax
movl %eax, 0x4(%r15)
movq %r14, %rdi
movl $0x136, %esi            # imm = 0x136
callq 0x5c08
testb %al, %al
jne 0x71a9
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1253d(%rip), %rsi     # 0x19660
leaq 0x12568(%rip), %rdx     # 0x19692
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x3c42
movq %r14, %rdi
movq %r15, %rsi
callq 0x5694
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x71a9
movq 0x58(%rsp), %rsi
jmp 0x7197
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x12568(%rip), %rsi     # 0x196cc
leaq 0x125a8(%rip), %rdx     # 0x19713
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c42
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x4e96
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x71a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x71a9
movl $0x0, 0x4(%r15)
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x124cb(%rip), %rsi     # 0x19693
leaq 0x124fc(%rip), %rdx     # 0x196cb
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x3c42
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x4e96
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x71a9
movq 0x38(%rsp), %rsi
jmp 0x7197
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x7219
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x7219
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x722a
movq (%r12), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::TypeMark(int&)
bool Parser::TypeMark(int &type){
	if( CheckToken(T_INTEGER) ) type = TYPE_INTEGER;
	else if( CheckToken(T_FLOAT) ) type = TYPE_FLOAT;
	else if( CheckToken(T_BOOL) ) type = TYPE_BOOL;
	else if( CheckToken(T_STRING) ) type = TYPE_STRING;
	else if( CheckToken(T_CHAR) ) type = TYPE_CHAR;
	else return false;
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10a, %ebp            # imm = 0x10A
movl $0x10a, %esi            # imm = 0x10A
callq 0x5c08
testb %al, %al
jne 0x72a7
movl $0x10b, %ebp            # imm = 0x10B
movq %r14, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x5c08
testb %al, %al
jne 0x72a7
movl $0x10c, %ebp            # imm = 0x10C
movq %r14, %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x5c08
testb %al, %al
jne 0x72a7
movl $0x10d, %ebp            # imm = 0x10D
movq %r14, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x5c08
testb %al, %al
jne 0x72a7
movl $0x10e, %ebp            # imm = 0x10E
movq %r14, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x5c08
testb %al, %al
je 0x72b0
movl %ebp, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x72ab
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ParameterList(scopeValue&)
bool Parser::ParameterList(scopeValue &procEntry){
	if(Parameter(procEntry)){
		while(CheckToken(T_COMMA)){
			if( !Parameter(procEntry) ) ReportError("Expected parameter after ',' in procedure's parameter list");
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x86c2
testb %al, %al
je 0x7d49
movq %r14, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x5c08
testb %al, %al
je 0x7d49
leaq 0x18(%rsp), %rbp
leaq 0x11d81(%rip), %r15     # 0x19a69
leaq 0x11db4(%rip), %r12     # 0x19aa3
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x86c2
testb %al, %al
jne 0x7d38
movq %rbp, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3c42
movq %r14, %rdi
movq %r13, %rsi
callq 0x5694
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7d38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x5c08
testb %al, %al
jne 0x7cf4
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7d74
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Expression(int&, int&)
bool Parser::Expression(int &type, int &size){
	//flag used to determine if an expression is required following a 'NOT' token
	bool notOperation;
	if( CheckToken(T_NOT) ) notOperation = true;
	else notOperation = false;
	
	//get type and size of first arithOp
	if( ArithOp(type, size) ){
		if( (notOperation) && (type != TYPE_BOOL) && (type != TYPE_INTEGER) )ReportError("'NOT' operator is defined only for type Bool and Integer.");
		else if (notOperation) generator->NotOnRegister(type, size);
		ExpressionPrime(type, size, true, true);
		return true;
	}
	else if (notOperation){
		ReportFatalError("Expected an integer / boolean ArithOp following 'NOT'");
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10f, %esi            # imm = 0x10F
callq 0x5c08
movl %eax, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xab8e
movl %eax, %ebp
testb %al, %al
je 0x85ef
testb %r12b, %r12b
je 0x866d
movl (%r15), %esi
cmpl $0x10a, %esi            # imm = 0x10A
je 0x85de
cmpl $0x10c, %esi            # imm = 0x10C
jne 0x8627
movq 0x98(%rbx), %rdi
movl (%r14), %edx
callq 0x1305a
jmp 0x866d
testb %r12b, %r12b
je 0x8686
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11c4d(%rip), %rsi     # 0x1a255
leaq 0x11c7b(%rip), %rdx     # 0x1a28a
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3c42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a02
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11be4(%rip), %rsi     # 0x1a21b
leaq 0x11c16(%rip), %rdx     # 0x1a254
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3c42
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5694
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x866d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0xabd0
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x86a9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x86ba
movq (%r13), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Integer()
bool Parser::Integer(){
	string val = token->ascii;
	if(CheckToken(TYPE_INTEGER)){
		generator->val2reg( val, TYPE_INTEGER );
		return true;
	}
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3bac
movq %r14, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x5c08
movl %eax, %ebx
testb %al, %al
je 0xcf8a
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3bac
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10a, %ecx            # imm = 0x10A
callq 0x13342
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcf73
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xcf8a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xcfa1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xcfce
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xcfce
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xcfe5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Float()
bool Parser::Float(){
	string val = token->ascii;
	if(CheckToken(TYPE_FLOAT)){
		generator->val2reg( val, TYPE_FLOAT );
		return true;
	}
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3bac
movq %r14, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x5c08
movl %eax, %ebx
testb %al, %al
je 0xd0a4
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3bac
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10b, %ecx            # imm = 0x10B
callq 0x13342
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd08d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd0a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd0bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd0e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xd0e8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd0ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::String()
bool Parser::String(){
	string val = token->ascii;
	if(CheckToken(TYPE_STRING)){
		generator->val2reg( val, TYPE_STRING );
		return true;
	}
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3bac
movq %r14, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x5c08
movl %eax, %ebx
testb %al, %al
je 0xd926
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3bac
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10d, %ecx            # imm = 0x10D
callq 0x13342
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd90f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd926
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd93d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd96a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xd96a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd981
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Char()
bool Parser::Char(){
	string val = token->ascii;
	if(CheckToken(TYPE_CHAR)){
		generator->val2reg( val, TYPE_CHAR);
		return true;
	}
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3bac
movq %r14, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x5c08
movl %eax, %ebx
testb %al, %al
je 0xda40
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3bac
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10e, %ecx            # imm = 0x10E
callq 0x13342
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda29
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda40
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda84
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xda84
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Bool()
bool Parser::Bool(){
	string val = token->ascii;
	if(CheckToken(T_TRUE)){
		generator->val2reg( "1", TYPE_BOOL);
		return true;
	}
	else if(CheckToken(T_FALSE)){
		generator->val2reg( "0", TYPE_BOOL);
		return true;
	}
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rax
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x3bac
movq %rbx, %rdi
movl $0x115, %esi            # imm = 0x115
callq 0x5c08
testb %al, %al
je 0xdb52
movq 0x98(%rbx), %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcc10(%rip), %rsi      # 0x1a70f
leaq 0xcc0a(%rip), %rdx      # 0x1a710
leaq 0x20(%rsp), %rdi
callq 0x3c42
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0x13342
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdb4b
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x20(%rsp), %rdi
jmp 0xdbbd
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x5c08
testb %al, %al
je 0xdbd1
movq 0x98(%rbx), %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcb97(%rip), %rsi      # 0x1a711
leaq 0xcb91(%rip), %rdx      # 0x1a712
movq %rsp, %rdi
callq 0x3c42
leaq 0x60(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0x13342
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdbb9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xdbcd
movq (%r15), %rsi
incq %rsi
callq 0x2200
movb $0x1, %bl
jmp 0xdbd3
xorl %ebx, %ebx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0xdbea
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xdc2f
movq 0x10(%rsp), %rsi
jmp 0xdc20
jmp 0xdc2c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdc2f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xdc2f
jmp 0xdc2c
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0xdc46
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/AndrewAlbert[P]Compiler-Theory/SourceCode/scope.cpp
// Function: scope::scope(bool)
scope::scope(bool programScope){
	name = "";
	// Procedures allocate the first two bytes of their frame to pointers for stored FP and return address
	if( programScope ) totalBytes = 0;
	else totalBytes = 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x38(%rdi), %rax
movl %ecx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x70(%rdi), %r12
movq %r12, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
leaq 0xbf75(%rip), %rcx      # 0x1a95d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x22e0
xorb $0x1, %bpl
movzbl %bpl, %eax
addl %eax, %eax
movl %eax, 0x80(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xea27
movq (%r12), %rsi
incq %rsi
callq 0x2200
leaq 0x30(%rbx), %rdi
callq 0xf404
movq %rbx, %rdi
callq 0xf404
movq %r14, %rdi
callq 0x2330