LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_key_traits<double, void>::test(double, unsigned long)
static bool test(value_type value, std::size_t index)
		{
			assert(index < size(value));
			unsigned_value_type unsigned_value = to_unsigned(value);
			if (unsigned_value & 0x8000000000000000)
				unsigned_value = ~unsigned_value;
			else
				unsigned_value ^= 0x8000000000000000;
			return (unsigned_value & (static_cast<unsigned_value_type>(1) << static_cast<unsigned_value_type>(num_bits - index - 1))) != 0;
		}

// Assembly:
cmpq $0x40, %rdi
jae 0x1639d
movq %xmm0, %rcx
movq %rcx, %rax
btsq $0x3f, %rax
testq %rcx, %rcx
notq %rcx
cmovsq %rcx, %rax
movl %edi, %ecx
shlq %cl, %rax
shrq $0x3f, %rax
retq
pushq %rax
leaq 0x2f989(%rip), %rdi     # 0x45d2e
leaq 0x2acef(%rip), %rsi     # 0x4109b
leaq 0x30615(%rip), %rcx     # 0x469c8
movl $0xf6, %edx
callq 0xa280
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::msb(unsigned long)
inline int msb(std::uint64_t v)
		{
			v |= (v >> 1);
			v |= (v >> 2);
			v |= (v >> 4);
			v |= (v >> 8);
			v |= (v >> 16);
			v |= (v >> 32);

			return count_bit(v) - 1;
		}

// Assembly:
pushq %rax
movq %rdi, %rax
shrq %rax
orq %rax, %rdi
movq %rdi, %rax
shrq $0x2, %rax
orq %rax, %rdi
movq %rdi, %rax
shrq $0x4, %rax
orq %rax, %rdi
movq %rdi, %rax
shrq $0x8, %rax
orq %rax, %rdi
movq %rdi, %rax
shrq $0x10, %rax
orq %rax, %rdi
movq %rdi, %rax
shrq $0x20, %rax
orq %rax, %rdi
callq 0x16402
decl %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::count_bit(unsigned long)
inline int count_bit(std::uint64_t v)
		{
			std::uint64_t result;
			result = (v & 0x5555555555555555) + ((v >> 1) & 0x5555555555555555);
			result = (result & 0x3333333333333333) + ((result >> 2) & 0x3333333333333333);
			result = (result & 0x0f0f0f0f0f0f0f0f) + ((result >> 4) & 0x0f0f0f0f0f0f0f0f);
			result = (result & 0x00ff00ff00ff00ff) + ((result >> 8) & 0x00ff00ff00ff00ff);
			result = (result & 0x0000ffff0000ffff) + ((result >> 16) & 0x0000ffff0000ffff);
			result = (result & 0x00000000ffffffff) + ((result >> 32) & 0x00000000ffffffff);
			return static_cast<int>(result);
		}

// Assembly:
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
movq %rdi, %rax
andq %rcx, %rax
shrq %rdi
andq %rdi, %rcx
addq %rax, %rcx
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
movq %rcx, %rdx
andq %rax, %rdx
shrq $0x2, %rcx
andq %rax, %rcx
addq %rdx, %rcx
movabsq $0x707070707070707, %rax # imm = 0x707070707070707
movq %rcx, %rdx
andq %rax, %rdx
shrq $0x4, %rcx
andq %rax, %rcx
addq %rdx, %rcx
movabsq $0xf000f000f000f, %rax  # imm = 0xF000F000F000F
movq %rcx, %rdx
andq %rax, %rdx
shrq $0x8, %rcx
andq %rax, %rcx
addq %rdx, %rcx
movabsq $0x1f0000001f, %rax     # imm = 0x1F0000001F
movq %rcx, %rdx
andq %rax, %rdx
shrq $0x10, %rcx
andq %rax, %rcx
addq %rdx, %rcx
movq %rcx, %rax
shrq $0x20, %rax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %rax
addq $0x2, %rax
xorl %r12d, %r12d
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
leaq (,%rax,4), %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
pushq $0x3d
popq %rdx
callq 0xa480
leaq 0x2fd7a(%rip), %rax     # 0x46d10
pushq $0x1
popq %rcx
pushq $0x2
popq %rsi
xorl %edx, %edx
cmpq 0x8(%r14), %r12
je 0x1704f
movzbl (%r15,%r12), %edi
shrl $0x2, %edi
movb (%rdi,%rax), %dil
movq (%rbx), %r8
movb %dil, (%r8,%rdx)
movq 0x8(%r14), %r8
decq %r8
movzbl (%r15,%r12), %edi
shll $0x4, %edi
andl $0x30, %edi
cmpq %r8, %r12
je 0x17042
movzbl 0x1(%r15,%r12), %r8d
shrl $0x4, %r8d
orq %rdi, %r8
movb (%r8,%rax), %dil
movq (%rbx), %r8
movb %dil, 0x1(%r8,%rdx)
movq 0x8(%r14), %r8
addq $-0x2, %r8
movzbl 0x1(%r15,%r12), %edi
shll $0x2, %edi
andl $0x3c, %edi
cmpq %r8, %r12
je 0x1703f
movzbl 0x2(%r15,%r12), %r8d
shrl $0x6, %r8d
orq %rdi, %r8
movb (%r8,%rax), %dil
movq (%rbx), %r8
movb %dil, 0x2(%r8,%rdx)
movzbl 0x2(%r15,%r12), %edi
andl $0x3f, %edi
movb (%rdi,%rax), %dil
movq (%rbx), %r8
movb %dil, 0x3(%r8,%rdx)
addq $0x4, %rdx
addq $0x3, %r12
jmp 0x16f9e
movq %rsi, %rcx
movzbl %dil, %esi
movb (%rsi,%rax), %al
addq (%rbx), %rcx
movb %al, (%rdx,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::msb(unsigned short)
inline int msb(std::uint16_t v)
		{
			v |= (v >> 1);
			v |= (v >> 2);
			v |= (v >> 4);
			v |= (v >> 8);

			return count_bit(v) - 1;
		}

// Assembly:
pushq %rax
movl %edi, %eax
movl %edi, %ecx
shrl %ecx
orl %ecx, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %ecx, %eax
movzbl %ah, %ecx
orl %ecx, %eax
movl %eax, %edi
callq 0x18cc7
decl %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::count_bit(unsigned short)
inline int count_bit(std::uint16_t v)
		{
			std::uint16_t result;
			result = (v & 0x5555) + ((v >> 1) & 0x5555);
			result = (result & 0x3333) + ((result >> 2) & 0x3333);
			result = (result & 0x0f0f) + ((result >> 4) & 0x0f0f);
			result = (result & 0x00ff) + ((result >> 8) & 0x00ff);
			return static_cast<int>(result);
		}

// Assembly:
movl %edi, %eax
movl $0x5555, %ecx           # imm = 0x5555
movl %edi, %edx
andl %ecx, %edx
shrl %eax
andl %ecx, %eax
addl %edx, %eax
movl $0x3333, %ecx           # imm = 0x3333
movl %eax, %edx
andl %ecx, %edx
shrl $0x2, %eax
andl %ecx, %eax
addl %edx, %eax
movl $0x707, %ecx            # imm = 0x707
movl %eax, %edx
andl %ecx, %edx
shrl $0x4, %eax
andl %ecx, %eax
addl %edx, %eax
movzbl %ah, %ecx
addl %eax, %ecx
movzbl %cl, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ac8e
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 0x2b098(%rip), %rdi     # 0x45d2e
leaq 0x263fe(%rip), %rsi     # 0x4109b
leaq 0x2f92f(%rip), %rcx     # 0x4a5d3
movl $0x93, %edx
callq 0xa280
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x1420e
leaq 0x8(%r15), %r12
cmpq %r12, %rax
je 0x1f013
movq %rax, %rbx
movq %rax, %rdi
callq 0xbb8c
movq %rax, %rdi
callq 0xbc2e
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba8
andq $-0x10, %rax
movq (%r12), %rcx
movq %rbx, %r14
cmpq %rcx, %rbx
je 0x1efdb
movq 0x18(%r14), %rbx
cmpq 0x20(%rbx), %rax
jbe 0x1efc9
movq %r14, %rdi
callq 0xbf26
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbc5a
movq %r14, %rdi
callq 0x14310
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xbc5a
movq (%rbx), %rbx
movq (%r14), %rdx
jmp 0x1f029
movq %r15, %rdi
callq 0x13c08
movq %rax, %rbx
movq %r15, %rdi
callq 0x13c08
movq %rax, %rdx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
shlq $0x4, %r12
leaq 0x1(%r12), %rdx
callq 0xbb04
leaq 0x8(%rbx), %r13
cmpq %r13, %rax
je 0x1f0d9
movq %rax, %r14
movq %rax, %rdi
callq 0xbb8c
movq %rax, %rdi
callq 0xbc2e
movq %r15, %rdi
movq %rax, %rsi
callq 0xbba8
andq $-0x10, %rax
cmpq %r12, %rax
jne 0x1f0d9
movq (%r13), %rax
movq %r14, %rbx
cmpq %rax, %r14
je 0x1f0a3
movq 0x18(%rbx), %r14
cmpq 0x20(%r14), %r12
jbe 0x1f091
movq %rbx, %rdi
callq 0xbf26
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xbc5a
movq %rbx, %rdi
callq 0x14310
movq %rsp, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbc5a
movq (%r14), %r14
movq (%rbx), %rdx
jmp 0x1f0ef
movq %rbx, %rdi
callq 0x13c08
movq %rax, %r14
movq %rbx, %rdi
callq 0x13c08
movq %rax, %rdx
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1fef4
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1ff44
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fc62
testb %al, %al
jne 0x1f763
movq %rsp, %rdi
callq 0x1feca
addq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xa1d0
movq %rax, %rbx
leaq 0x2ebe0(%rip), %rsi     # 0x4e355
movq %rax, %rdi
callq 0xa070
movq 0x5683c(%rip), %rsi     # 0x75fc0
movq 0x5682d(%rip), %rdx     # 0x75fb8
movq %rbx, %rdi
callq 0xa670
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa6b0
// File: /workspace/github_cpp_makefile_star2_O2/AsherGlick[P]CommentHeader/source/headertitle.cpp
// Function: headerStyle::headerStyle()
headerStyle::headerStyle () {
  _TOP_LEFT     = "";
  _TOP_FILL     = " ";
  _TOP_RIGHT    = "";
  _LEFT_COLUMN  = "";
  _RIGHT_COLUMN = "";
  _BOTTOM_LEFT  = "";
  _BOTTOM_FILL  = " ";
  _BOTTOM_RIGHT = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
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)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x40(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movb %al, 0x70(%rdi)
leaq 0x90(%rdi), %rcx
movq %rcx, 0x80(%rdi)
andq $0x0, 0x88(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x80(%rdi), %r13
movb %al, 0x90(%rdi)
leaq 0xb0(%rdi), %rcx
movq %rcx, 0xa0(%rdi)
andq $0x0, 0xa8(%rdi)
leaq 0xa0(%rdi), %r14
movb %al, 0xb0(%rdi)
leaq 0xc0(%rdi), %r15
leaq 0xd0(%rdi), %rcx
movq %rcx, 0xc0(%rdi)
andq $0x0, 0xc8(%rdi)
movb %al, 0xd0(%rdi)
leaq 0xe0(%rdi), %r12
leaq 0xf0(%rdi), %rcx
movq %rcx, 0xe0(%rdi)
andq $0x0, 0xe8(%rdi)
movb %al, 0xf0(%rdi)
leaq 0x5f6d(%rip), %rsi      # 0xcbad
callq 0x33d0
leaq 0x53d0(%rip), %rsi      # 0xc01c
movq -0x40(%rbp), %rdi
callq 0x33d0
leaq 0x5f51(%rip), %rsi      # 0xcbad
movq -0x38(%rbp), %rdi
callq 0x33d0
leaq 0x5f41(%rip), %rsi      # 0xcbad
movq -0x30(%rbp), %rdi
callq 0x33d0
leaq 0x5f31(%rip), %rsi      # 0xcbad
movq %r13, %rdi
callq 0x33d0
leaq 0x5f22(%rip), %rsi      # 0xcbad
movq %r14, %rdi
callq 0x33d0
leaq 0x5382(%rip), %rsi      # 0xc01c
movq %r15, %rdi
callq 0x33d0
leaq 0x5f04(%rip), %rsi      # 0xcbad
movq %r12, %rdi
callq 0x33d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x48(%rbp)
movq %r12, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3120
movq %r13, %rdi
callq 0x3120
movq -0x30(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0x3120
movq -0x40(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3120
movq -0x48(%rbp), %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4efd(%rip), %rsi      # 0xc1ed
leaq -0x248(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x33b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x228(%rbp,%rax)
je 0x734b
movq 0xacae(%rip), %rdi      # 0x11fc8
leaq 0x4edb(%rip), %rsi      # 0xc1fc
callq 0x3260
movq %rax, %rdi
callq 0x3130
pushq $-0x1
popq %rbx
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 0x738f
callq 0x30a0
testl %eax, %eax
js 0x7393
je 0x7397
movl -0x18(%rbp), %edi
callq 0x33f0
movl -0x14(%rbp), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x30d0
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x73b8
xorl %ebx, %ebx
movl -0x14(%rbp), %edi
callq 0x33f0
jmp 0x7331
pushq $-0x2
jmp 0x7330
pushq $-0x3
jmp 0x7330
movl -0x14(%rbp), %edi
callq 0x33f0
movl -0x18(%rbp), %edi
testl %edi, %edi
je 0x73c7
xorl %esi, %esi
callq 0x3240
testl %eax, %eax
je 0x73bf
pushq $-0x5
jmp 0x7330
pushq $-0x6
jmp 0x7330
movl -0x18(%rbp), %edi
callq 0x33f0
movaps 0xa9b2(%rip), %xmm0     # 0x11d80
leaq -0x40(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps 0xa993(%rip), %xmm0     # 0x11d70
movaps %xmm0, (%rsi)
leaq 0x4e06(%rip), %rdi      # 0xc1ed
callq 0x3220
movl %eax, %ebx
sarl $0x1f, %ebx
andl $-0x4, %ebx
jmp 0x7331
jmp 0x73fb
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x5037(%rip), %rsi      # 0xcbad
leaq -0x68(%rbp), %rdx
callq 0x30f0
movq 0xa452(%rip), %r14      # 0x11fd8
leaq -0x48(%rbp), %r15
leaq 0x501c(%rip), %r12      # 0xcbad
leaq -0x68(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7be4
movq %r15, %rdi
movq %r12, %rsi
callq 0xa1a9
testb %al, %al
jne 0x7be4
movq %r13, %rdi
movq %r15, %rsi
leaq 0x4fe2(%rip), %rdx      # 0xcbac
callq 0xa1b9
movq %rbx, %rdi
movq %r13, %rsi
callq 0x33e0
movq %r13, %rdi
callq 0x3120
jmp 0x7b95
leaq -0x48(%rbp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7c1f
jmp 0x7c14
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3120
jmp 0x7c17
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
leaq -0x48(%rbp), %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
leaq 0x4f57(%rip), %rsi      # 0xcbad
leaq -0x21(%rbp), %rdx
callq 0x30f0
movq 0x8(%r14), %rcx
movl %ecx, %eax
shlq $0x20, %rcx
addq %r12, %rcx
decq %rax
movq %rcx, %r15
testl %eax, %eax
js 0x7c8e
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq (%r14), %rsi
leaq (%r15,%r12), %rcx
decq %rax
cmpb $0x20, (%rsi,%rdx)
je 0x7c6f
sarq $0x20, %r15
xorl %r12d, %r12d
cmpq %r15, %r12
jg 0x7caf
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x31f0
incq %r12
jmp 0x7c95
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3230
movl $0x1e1853e, %ecx        # imm = 0x1E1853E
cqto
idivq %rcx
leaq 0x7b2(%rax), %r14
leaq -0x198(%rbp), %rdi
callq 0x31a0
leaq -0x188(%rbp), %rdi
movq %r14, %rsi
callq 0x3180
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x3370
leaq -0x198(%rbp), %rdi
callq 0x31c0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0x2f8e
movl %eax, 0x28(%r15)
movl (%r15), %ecx
movl %ecx, 0x2c(%r15)
cmpl $0x15d, %eax            # imm = 0x15D
je 0x2f79
cmpb $0x0, 0x138(%r15)
je 0x2f79
movq 0x1806e(%rip), %rdi     # 0x1afd0
movq %r14, %rsi
callq 0x21b0
leaq 0xe34b(%rip), %rsi      # 0x112bc
movq %rax, %rdi
callq 0x21c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36f4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Parser(token_type*, Scanner*, scopeTracker*, codeGenerator*)
Parser::Parser(token_type* tokenPtr, Scanner* scannerPtr, scopeTracker* scopes, codeGenerator* genPtr){
	//Set default values needed to begin parsing and attach other compiler classes to their pointers
	token = tokenPtr;
	Scopes = scopes;
	scanner = scannerPtr;
	generator = genPtr;
	textLine = "";
	currentLine = 0;
	warning = false;
	error = false;
	lineError = false;
	outArg = false;
	
	//Start program parsing
	Program();
	
	// Ensure the end of the file is reached
	if(token->type != T_EOF) ReportWarning("Tokens remaining. Parsing stopped at 'end program' and will not include any tokens after that.");
	
	// Display all errors / warnings
	DisplayErrorQueue();
	
	if(error) cout << "\nParser completed with some errors.\n   Code cannot be generated.\n" << endl;
	else if(warning) cout << "\nParser completed with some warnings.\n\tCode can still be generated.\n" << endl;
	else cout << "\nParser completed with no errors or warnings.\n\tCode has been generated.\n" << endl;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x9630
leaq 0x58(%rbx), %r14
leaq 0x68(%rbx), %rax
movq %rax, 0x58(%rbx)
andq $0x0, 0x60(%rbx)
movb $0x0, 0x68(%rbx)
movq %rbp, 0x80(%rbx)
movq %r12, 0x90(%rbx)
movq %r13, 0x88(%rbx)
movq %r15, 0x98(%rbx)
leaq 0xeb17(%rip), %rsi      # 0x1293d
movq %r14, %rdi
callq 0x2370
andl $0x0, 0x78(%rbx)
andw $0x0, 0x50(%rbx)
xorl %eax, %eax
movb %al, 0x52(%rbx)
movb %al, 0x7c(%rbx)
movq %rbx, %rdi
callq 0x3f00
movq 0x80(%rbx), %rax
cmpl $0x15d, 0x20(%rax)      # imm = 0x15D
je 0x3e84
leaq 0xd2f2(%rip), %rsi      # 0x11150
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x36b8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4020
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x41e4
leaq 0xd35e(%rip), %rax      # 0x111f1
testb $0x1, 0x50(%rbx)
leaq 0xd398(%rip), %rcx      # 0x11236
cmovneq %rax, %rcx
leaq 0xd306(%rip), %rsi      # 0x111af
cmpb $0x0, 0x51(%rbx)
cmoveq %rcx, %rsi
movq 0x17118(%rip), %rdi     # 0x1afd0
callq 0x21c0
movq %rax, %rdi
callq 0x2100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x3ee8
jmp 0x3ee5
movq %rax, %r15
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x9910
movq %r15, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0xb0c2
movq %rbx, %rdi
callq 0x4b16
movq %rbx, %rdi
callq 0x4e5a
testb %al, %al
jne 0x3f55
leaq 0xd426(%rip), %rsi      # 0x11355
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x47e0
leaq 0x50(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x4f96
movq %rbx, %rdi
movl $0x12b, %esi            # imm = 0x12B
callq 0x49b0
testb %al, %al
jne 0x3f9b
leaq 0xd3f8(%rip), %rsi      # 0x1136d
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x4020
leaq 0x30(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
movl $0x15d, %esi            # imm = 0x15D
callq 0x49b0
testb %al, %al
je 0x3fba
movq 0x90(%rbx), %rdi
callq 0xb148
jmp 0x3fe7
leaq 0xd3cb(%rip), %rsi      # 0x1138c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x47e0
leaq 0x10(%rsp), %rdi
callq 0x20f0
addq $0x70, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x400d
jmp 0x4014
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x400d
jmp 0x4014
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20f0
jmp 0x4017
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ReportFatalError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parser::ReportFatalError(string message){
	generator->stopCodeGeneration();
	error_queue.push("Fatal Error: line - " + to_string(currentLine) + "\n\t" + message + "\n\tFound: " + textLine + " " + token->ascii);
	error = true;
	DisplayErrorQueue();
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
callq 0xbb62
movl 0x78(%rbx), %esi
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
callq 0x96b3
leaq 0xcfcf(%rip), %rsi      # 0x1127f
movq %rsp, %rdi
movq %r15, %rdx
callq 0x968f
leaq 0xe679(%rip), %rdx      # 0x1293b
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9670
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x9651
leaq 0xcfac(%rip), %rdx      # 0x11294
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9670
leaq 0x58(%rbx), %rdx
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x9651
leaq 0xcfa8(%rip), %rdx      # 0x112bc
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x9670
movq 0x80(%rbx), %rdx
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x9651
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdi
callq 0x964c
leaq 0xc0(%rsp), %rdi
callq 0x20f0
leaq 0xa0(%rsp), %rdi
callq 0x20f0
leaq 0x80(%rsp), %rdi
callq 0x20f0
leaq 0x60(%rsp), %rdi
callq 0x20f0
leaq 0x40(%rsp), %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rsp, %rdi
callq 0x20f0
leaq 0xe0(%rsp), %rdi
callq 0x20f0
movb $0x1, 0x51(%rbx)
movq %rbx, %rdi
callq 0x41e4
pushq $0x1
popq %rdi
callq 0x2230
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x20f0
jmp 0x43d8
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x20f0
jmp 0x43ea
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x20f0
jmp 0x43fc
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x20f0
jmp 0x440b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x20f0
jmp 0x441a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20f0
jmp 0x4429
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
jmp 0x4436
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ReportError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parser::ReportError(string message){
	generator->stopCodeGeneration();
	error_queue.push("Error: line - " + to_string(currentLine) + "\n\t" + message + "\n\tFound: " + textLine + " " + token->ascii);
	error = true;
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
callq 0xbb62
movl 0x78(%rbx), %esi
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
callq 0x96b3
leaq 0xca8d(%rip), %rsi      # 0x112a5
movq %rsp, %rdi
movq %r15, %rdx
callq 0x968f
leaq 0xe111(%rip), %rdx      # 0x1293b
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9670
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x9651
leaq 0xca44(%rip), %rdx      # 0x11294
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9670
leaq 0x58(%rbx), %rdx
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x9651
leaq 0xca40(%rip), %rdx      # 0x112bc
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x9670
movq 0x80(%rbx), %rdx
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x9651
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdi
callq 0x9e7a
leaq 0xc0(%rsp), %rdi
callq 0x20f0
leaq 0xa0(%rsp), %rdi
callq 0x20f0
leaq 0x80(%rsp), %rdi
callq 0x20f0
leaq 0x60(%rsp), %rdi
callq 0x20f0
leaq 0x40(%rsp), %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rsp, %rdi
callq 0x20f0
leaq 0xe0(%rsp), %rdi
callq 0x20f0
movb $0x1, 0x51(%rbx)
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x20f0
jmp 0x493d
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x20f0
jmp 0x494f
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x20f0
jmp 0x4961
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x20f0
jmp 0x4970
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rsp, %rdi
callq 0x20f0
leaq 0xe0(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
movq %rax, %rbx
jmp 0x497a
movq %rax, %rbx
jmp 0x4984
movq %rax, %rbx
jmp 0x498c
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::CheckToken(int)
bool Parser::CheckToken(int type){
	//skip all comment tokens
	while (token->type == T_COMMENT){
		*token = scanner->getToken();
	}

	if(token->line != currentLine ){
		currentLine = token->line;
		textLine = "";
	}
	//check that current token matches input type, if so move to next token
	if(token->type == type){
		textLine.append(" " + token->ascii);
		*token = scanner->getToken();
		return true;
	}
	else if(token->type == T_UNKNOWN){
			ReportError("Found unknown token " + token->ascii);
			*token = scanner->getToken();
		return CheckToken(type);
	}
	else if(token->type == T_EOF){
		return false;
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq 0x80(%rbx), %rdx
movl 0x20(%rdx), %eax
cmpl $0x15c, %eax            # imm = 0x15C
jne 0x4a00
movq 0x88(%rbx), %rsi
movq %r14, %rdi
callq 0x2f1e
movq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x9782
movq %r14, %rdi
callq 0x20f0
jmp 0x49c7
movl 0x24(%rdx), %ecx
cmpl 0x78(%rbx), %ecx
je 0x4a25
movl %ecx, 0x78(%rbx)
leaq 0x58(%rbx), %rdi
leaq 0xdf27(%rip), %rsi      # 0x1293d
callq 0x2370
movq 0x80(%rbx), %rdx
movl 0x20(%rdx), %eax
cmpl %ebp, %eax
jne 0x4a85
leaq 0x58(%rbx), %r14
leaq 0xc888(%rip), %rsi      # 0x112bc
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x970c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2390
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq 0x88(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2f1e
movq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x9782
movq %r14, %rdi
callq 0x20f0
movb $0x1, %al
jmp 0x4aea
cmpl $0x15e, %eax            # imm = 0x15E
jne 0x4ae8
leaq 0xc851(%rip), %rsi      # 0x112e4
movq %rsp, %r14
movq %r14, %rdi
callq 0x970c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47e0
movq %rsp, %rdi
callq 0x20f0
movq 0x88(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2f1e
movq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x9782
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x49b0
jmp 0x4aea
xorl %eax, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x4b08
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl $0x101, %esi            # imm = 0x101
callq 0x49b0
testb %al, %al
je 0x4f0e
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x52ec
testb %al, %al
je 0x4f12
movq 0x90(%rbx), %r14
leaq 0xc527(%rip), %rsi      # 0x113d1
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x970c
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0xb4e0
leaq 0x70(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x49b0
movb $0x1, %bpl
testb %al, %al
jne 0x4f41
leaq 0xc4ef(%rip), %rsi      # 0x113da
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x47e0
leaq 0x50(%rsp), %rdi
jmp 0x4f3a
xorl %ebp, %ebp
jmp 0x4f4b
leaq 0xc4e8(%rip), %rsi      # 0x11401
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x47e0
leaq 0x30(%rsp), %rdi
callq 0x20f0
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x20f0
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x4f77
jmp 0x4f80
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x4f77
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x20f0
jmp 0x4f83
jmp 0x4f80
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rsi
movq %rsp, %rdi
callq 0x2270
movq %r14, %rdi
movl $0x11c, %esi            # imm = 0x11C
callq 0x49b0
movl %eax, %ebp
testb %al, %al
je 0x5327
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2120
movq %rsp, %rdi
callq 0x20f0
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xd3b1(%rip), %rsi      # 0x1293d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x36b8
movq %rbx, %rdi
callq 0x6782
movb $0x1, %bpl
testb %al, %al
jne 0x55fb
movq %rbx, %rdi
callq 0x7110
testb %al, %al
jne 0x55fb
movq %rbx, %rdi
callq 0x7814
testb %al, %al
jne 0x55fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7842
testb %al, %al
jne 0x55fb
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2270
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5f80
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0x5620
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x5866
movl %eax, %ebp
testb %al, %al
je 0x5654
movq %rbx, %rdi
callq 0x5b12
testb %al, %al
je 0x565f
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc0ae(%rip), %rsi      # 0x11714
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x36b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4278
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 0x57e4
movl %eax, %ebx
testb %al, %al
je 0x5777
movq %r14, %rdi
movq %r12, %rsi
callq 0x52ec
testb %al, %al
je 0x5740
movq %r14, %rdi
movl $0x135, %esi            # imm = 0x135
callq 0x49b0
testb %al, %al
je 0x5772
movq %r14, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x49b0
testb %al, %al
je 0x5785
movq 0x80(%r14), %rax
movl 0x28(%rax), %eax
movl %eax, 0x4(%r15)
movq %r14, %rdi
movl $0x136, %esi            # imm = 0x136
callq 0x49b0
testb %al, %al
jne 0x5777
leaq 0xbf43(%rip), %rsi      # 0x11660
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x36b8
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x47e0
leaq 0x48(%rsp), %rdi
jmp 0x576b
leaq 0xbf85(%rip), %rsi      # 0x116cc
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x36b8
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x444c
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x5777
andl $0x0, 0x4(%r15)
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xbf07(%rip), %rsi      # 0x11693
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x36b8
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x444c
leaq 0x28(%rsp), %rdi
jmp 0x576b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x57d2
jmp 0x57d9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x57d2
jmp 0x57d9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x57dc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 0x49b0
testb %al, %al
jne 0x5859
movl $0x10b, %ebp            # imm = 0x10B
movq %r14, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x49b0
testb %al, %al
jne 0x5859
movl $0x10c, %ebp            # imm = 0x10C
movq %r14, %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x49b0
testb %al, %al
jne 0x5859
movl $0x10d, %ebp            # imm = 0x10D
movq %r14, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x49b0
testb %al, %al
jne 0x5859
movl $0x10e, %ebp            # imm = 0x10E
movq %r14, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x49b0
testb %al, %al
je 0x5862
movl %ebp, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x585d
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x65ca
testb %al, %al
je 0x5f5a
leaq 0xbb5c(%rip), %r15      # 0x11a69
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r13
movq %r14, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x49b0
testb %al, %al
je 0x5f5a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65ca
testb %al, %al
jne 0x5f17
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x36b8
movq %r14, %rdi
movq %r12, %rsi
callq 0x47e0
movq %r12, %rdi
callq 0x20f0
jmp 0x5f17
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10f, %esi            # imm = 0x10F
callq 0x49b0
movl %eax, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7d2e
movl %eax, %ebp
testb %al, %al
je 0x652b
testb %r12b, %r12b
je 0x6580
movl (%r15), %esi
cmpl $0x10a, %esi            # imm = 0x10A
je 0x651a
cmpl $0x10c, %esi            # imm = 0x10C
jne 0x6553
movq 0x98(%rbx), %rdi
movl (%r14), %edx
callq 0xd67c
jmp 0x6580
testb %r12b, %r12b
je 0x6594
leaq 0xbd1e(%rip), %rsi      # 0x12255
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x4278
leaq 0xbcc1(%rip), %rsi      # 0x1221b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x47e0
leaq 0x10(%rsp), %rdi
callq 0x20f0
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ecx, %r8d
callq 0x7d6a
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x65b7
jmp 0x65be
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20f0
jmp 0x65c1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2310
nop