LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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>>>>::move_impl(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>>>>&&)
void move_impl(cb_tree_base&& other)
			{
				begin_node() = other.begin_node();
				root_node() = other.root_node();
				size_ = other.size_;

				other.construct_impl();

				fix_swapped();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed50
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0xed50
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xed60
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0xed60
movq -0x20(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xebb0
movq -0x18(%rbp), %rdi
callq 0x112d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<counter, std::default_delete<counter>>, 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, std::unique_ptr<counter, std::default_delete<counter>>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>, 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, std::unique_ptr<counter, std::default_delete<counter>>>>>::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_type erase(const key_type& key)
			{
				auto it = find(key);
				if (it == end())
					return 0;

				erase(it);
				return 1;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x18df0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x18eb0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x18190
testb $0x1, %al
jne 0x16cd5
jmp 0x16cdf
movq $0x0, -0x8(%rbp)
jmp 0x16d11
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x191d0
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18ee0
movq %rax, -0x40(%rbp)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<counter, std::default_delete<counter>>, 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, std::unique_ptr<counter, std::default_delete<counter>>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>, 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, std::unique_ptr<counter, std::default_delete<counter>>>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator find(const key_type& key)
			{
				node_pointer node = find_branch(key);
				if (node == end_node() || !node->leaf())
					return end();

				if (!traits_type::equal(derived().key(node->value()), key))
					return end();

				return iterator(node);
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x19210
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x16e90
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x18e3f
movq -0x20(%rbp), %rdi
callq 0x17bb0
testb $0x1, %al
jne 0x18e4e
movq -0x30(%rbp), %rdi
callq 0x18eb0
movq %rax, -0x8(%rbp)
jmp 0x18e9c
movq -0x30(%rbp), %rdi
callq 0x17940
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b20
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17950
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x19250
testb $0x1, %al
jne 0x18e8f
movq -0x30(%rbp), %rdi
callq 0x18eb0
movq %rax, -0x8(%rbp)
jmp 0x18e9c
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x17c00
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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>>>>::upper_bound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator upper_bound(const key_type& key)
			{
				auto it = lower_bound(key);
				if (it == end())
					return it;

				if (!traits_type::equal(derived().key(*it), key))
					return it;

				++it;
				return it;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x22f80
movq -0x28(%rbp), %rdi
movq %rax, -0x8(%rbp)
callq 0x22e60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x102d0
testb $0x1, %al
jne 0x231f5
jmp 0x231f7
jmp 0x23234
movq -0x28(%rbp), %rdi
callq 0xf820
movq %rax, -0x30(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x24460
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xf830
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x19250
testb $0x1, %al
jne 0x2322b
jmp 0x23234
leaq -0x8(%rbp), %rdi
callq 0x10410
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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>>>>::next_branch_leaf() const
node_pointer next_branch_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

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

				node = node->parent();

				if (!node->leaf())
					node = node->next_leaf();

				return node;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfeb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2441a
jmp 0x2442c
movq -0x10(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x24409
movq -0x10(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbb0
testb $0x1, %al
jne 0x24456
movq -0x10(%rbp), %rdi
callq 0x104d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_raw_string_traits<char, std::char_traits<char>, std::allocator<char>>::mismatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::size_t mismatch(const string_type& s1, const string_type& s2)
		{
			std::size_t min_size = std::min(s1.size(), s2.size());
			auto data1 = reinterpret_cast<const unsigned_char_type*>(s1.data());
			auto data2 = reinterpret_cast<const unsigned_char_type*>(s2.data());

			std::size_t mismatch_index = std::mismatch(data1, data1 + min_size, data2).first - data1;
			std::size_t mismatch_bit_index = mismatch_index * num_bits;

			if (mismatch_index != min_size)
			{
				unsigned_char_type x = data1[mismatch_index];
				x ^= data2[mismatch_index];
				mismatch_bit_index += num_bits - detail::msb(x) - 1;
			}

			return mismatch_bit_index;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc3e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xffd0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc750
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc750
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x10010
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x256ad
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x59(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movzbl -0x59(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x59(%rbp)
movzbl -0x59(%rbp), %edi
callq 0x10070
movslq %eax, %rcx
movl $0x8, %eax
subq %rcx, %rax
subq $0x1, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_raw_string_traits<char, std::char_traits<char>, std::allocator<char>>::test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
static bool test(const string_type& s, std::size_t index)
		{
			assert(index < size(s));
			std::size_t q = index >> index_shift;
			std::size_t r = index & index_mask;
			unsigned_char_type c = static_cast<unsigned_char_type>(s[q]);
			return (c & (static_cast<unsigned_char_type>(1) << static_cast<unsigned_char_type>(num_bits - r - 1))) != 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25440
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x257bf
jmp 0x257de
leaq 0x868c5(%rip), %rdi     # 0xac08b
leaq 0x868ce(%rip), %rsi     # 0xac09b
movl $0x16d, %edx            # imm = 0x16D
leaq 0x8aa52(%rip), %rcx     # 0xb022b
callq 0xc3b0
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc640
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movl $0x8, %ecx
subq -0x20(%rbp), %rcx
subq $0x1, %rcx
movzbl %cl, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_key_traits<float, void>::test(float, 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 & 0x80000000)
				unsigned_value = ~unsigned_value;
			else
				unsigned_value ^= 0x80000000;
			return (unsigned_value & (static_cast<unsigned_value_type>(1) << static_cast<unsigned_value_type>(num_bits - index - 1))) != 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x27eb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x28391
jmp 0x283b0
leaq 0x8898e(%rip), %rdi     # 0xb0d26
leaq 0x83cfc(%rip), %rsi     # 0xac09b
movl $0xbb, %edx
leaq 0x8898f(%rip), %rcx     # 0xb0d3a
callq 0xc3b0
movss -0x4(%rbp), %xmm0
callq 0x28520
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x283d5
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x283e0
movl -0x14(%rbp), %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x20, %ecx
subq -0x10(%rbp), %rcx
subq $0x1, %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::msb(unsigned int)
inline int msb(std::uint32_t v)
		{
			v |= (v >> 1);
			v |= (v >> 2);
			v |= (v >> 4);
			v |= (v >> 8);
			v |= (v >> 16);

			return count_bit(v) - 1;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x2, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x4, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x285a0
subl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::count_bit(unsigned int)
inline int count_bit(std::uint32_t v)
		{
			std::uint32_t result;
			result = (v & 0x55555555) + ((v >> 1) & 0x55555555);
			result = (result & 0x33333333) + ((result >> 2) & 0x33333333);
			result = (result & 0x0f0f0f0f) + ((result >> 4) & 0x0f0f0f0f);
			result = (result & 0x00ff00ff) + ((result >> 8) & 0x00ff00ff);
			result = (result & 0x0000ffff) + ((result >> 16) & 0x0000ffff);
			return static_cast<int>(result);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl -0x4(%rbp), %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x33333333, %eax       # imm = 0x33333333
movl -0x8(%rbp), %ecx
shrl $0x2, %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl -0x8(%rbp), %ecx
shrl $0x4, %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
movl -0x8(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff00ff, %ecx         # imm = 0xFF00FF
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl -0x8(%rbp), %ecx
shrl $0x10, %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x2b4b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b991
jmp 0x2b9b0
leaq 0x8538e(%rip), %rdi     # 0xb0d26
leaq 0x806fc(%rip), %rsi     # 0xac09b
movl $0xf6, %edx
leaq 0x86015(%rip), %rcx     # 0xb19c0
callq 0xc3b0
movsd -0x8(%rbp), %xmm0
callq 0x2bb30
movq %rax, -0x18(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x2b9e0
movq -0x18(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2b9f2
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x40, %ecx
subq -0x10(%rbp), %rcx
subq $0x1, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2bbd0
subl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
andq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
andq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x2, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movabsq $0xf0f0f0f0f0f0f0f, %rax # imm = 0xF0F0F0F0F0F0F0F
andq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x4, %rcx
movabsq $0xf0f0f0f0f0f0f0f, %rdx # imm = 0xF0F0F0F0F0F0F0F
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movabsq $0xff00ff00ff00ff, %rax # imm = 0xFF00FF00FF00FF
andq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
movabsq $0xff00ff00ff00ff, %rdx # imm = 0xFF00FF00FF00FF
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movabsq $0xffff0000ffff, %rax   # imm = 0xFFFF0000FFFF
andq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x10, %rcx
movabsq $0xffff0000ffff, %rdx   # imm = 0xFFFF0000FFFF
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
sarl %ecx
movzwl -0x2(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
sarl $0x2, %ecx
movzwl -0x2(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
sarl $0x4, %ecx
movzwl -0x2(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
sarl $0x8, %ecx
movzwl -0x2(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %edi
callq 0x33b50
subl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0x5555, %eax           # imm = 0x5555
movzwl -0x2(%rbp), %ecx
sarl %ecx
andl $0x5555, %ecx           # imm = 0x5555
addl %ecx, %eax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
andl $0x3333, %eax           # imm = 0x3333
movzwl -0x4(%rbp), %ecx
sarl $0x2, %ecx
andl $0x3333, %ecx           # imm = 0x3333
addl %ecx, %eax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
andl $0xf0f, %eax            # imm = 0xF0F
movzwl -0x4(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf0f, %ecx            # imm = 0xF0F
addl %ecx, %eax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
andl $0xff, %eax
movzwl -0x4(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
addl %ecx, %eax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl -0x2(%rbp), %edi
callq 0x3c9a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ce92
jmp 0x3ceb1
leaq 0x73e8d(%rip), %rdi     # 0xb0d26
leaq 0x6f1fb(%rip), %rsi     # 0xac09b
movl $0x93, %edx
leaq 0x78717(%rip), %rcx     # 0xb55c3
callq 0xc3b0
movw -0x2(%rbp), %ax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
xorl $0x8000, %eax           # imm = 0x8000
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movl $0x10, %ecx
subq -0x10(%rbp), %rcx
subq $0x1, %rcx
movzwl %cx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>::lexical_index(unsigned long)
static std::size_t lexical_index(std::size_t index)
		{
			index >>= 1;
			index &= ~index_mask;
			index <<= 1;
			return index;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shlq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4e6c0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x4e780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x4db60
testb $0x1, %al
jne 0x4c7b5
jmp 0x4c805
movl $0x10, %edi
callq 0xc2b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x6cb75(%rip), %rsi     # 0xb9345
callq 0xc0b0
jmp 0x4c7d7
movq -0x40(%rbp), %rdi
movq 0xb97de(%rip), %rsi     # 0x105fc0
movq 0xb97c7(%rip), %rdx     # 0x105fb0
callq 0xc960
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xc420
jmp 0x4c818
leaq -0x18(%rbp), %rdi
callq 0x4e5a0
addq $0x20, %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc9b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x50(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x48(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x40(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x38(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x30(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0xe0, %rdi
movq %rdi, -0x28(%rbp)
callq 0x33b0
movq -0x20(%rbp), %rdi
leaq 0xb3ce(%rip), %rsi      # 0x18bf9
callq 0x3380
jmp 0xd832
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
leaq 0xa7db(%rip), %rsi      # 0x1801c
callq 0x3380
jmp 0xd848
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
leaq 0xb3a2(%rip), %rsi      # 0x18bf9
callq 0x3380
jmp 0xd85e
movq -0x60(%rbp), %rdi
addq $0x60, %rdi
leaq 0xb38c(%rip), %rsi      # 0x18bf9
callq 0x3380
jmp 0xd874
movq -0x60(%rbp), %rdi
subq $-0x80, %rdi
leaq 0xb376(%rip), %rsi      # 0x18bf9
callq 0x3380
jmp 0xd88a
movq -0x60(%rbp), %rdi
addq $0xa0, %rdi
leaq 0xb35d(%rip), %rsi      # 0x18bf9
callq 0x3380
jmp 0xd8a3
movq -0x60(%rbp), %rdi
addq $0xc0, %rdi
leaq 0xa767(%rip), %rsi      # 0x1801c
callq 0x3380
jmp 0xd8bc
movq -0x60(%rbp), %rdi
addq $0xe0, %rdi
leaq 0xb32b(%rip), %rsi      # 0x18bf9
callq 0x3380
jmp 0xd8d5
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31a0
movq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rdi
callq 0x31a0
movq -0x50(%rbp), %rdi
callq 0x31a0
movq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x20(%rbp), %rdi
callq 0x31a0
movq -0x10(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33b0
movb $0x0, -0x29(%rbp)
leaq -0x2a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3470
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x99f6(%rip), %rsi      # 0x18bf9
callq 0x33a0
jmp 0xf20a
leaq -0x2a(%rbp), %rdi
callq 0x3300
movq 0x11db6(%rip), %rdi     # 0x20fd0
leaq -0x28(%rbp), %rsi
callq 0x3070
movq %rax, -0x80(%rbp)
jmp 0xf229
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3360
movb %al, -0x81(%rbp)
jmp 0xf244
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0xf253
jmp 0xf2f6
leaq 0x999f(%rip), %rsi      # 0x18bf9
leaq -0x28(%rbp), %rdi
callq 0x13840
movb %al, -0x82(%rbp)
jmp 0xf26b
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0xf277
jmp 0xf2ac
movb $0x1, -0x29(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0xf301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x3300
jmp 0xf32f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf326
leaq 0x9945(%rip), %rdx      # 0x18bf8
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13870
jmp 0xf2c2
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3370
jmp 0xf2d1
leaq -0x60(%rbp), %rdi
callq 0x31a0
jmp 0xf213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31a0
jmp 0xf326
movb $0x1, -0x29(%rbp)
movl $0x1, -0x40(%rbp)
testb $0x1, -0x29(%rbp)
jne 0xf310
movq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x28(%rbp), %rdi
callq 0x31a0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x28(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3470
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x986a(%rip), %rsi      # 0x18bf9
callq 0x33a0
jmp 0xf396
leaq -0x12(%rbp), %rdi
callq 0x3300
movq -0x50(%rbp), %rdi
callq 0x31e0
subq $0x1, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xf414
movq -0x50(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x34c0
movq %rax, -0x58(%rbp)
jmp 0xf3c8
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xf407
jmp 0xf414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3300
jmp 0xf472
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31a0
jmp 0xf472
jmp 0xf409
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xf3af
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0xf455
movq -0x50(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x34c0
movq %rax, -0x60(%rbp)
jmp 0xf436
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
callq 0x31b0
jmp 0xf448
jmp 0xf44a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xf41b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xf468
movq -0x40(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3250
movabsq $0x22068a920e22bed1, %rcx # imm = 0x22068A920E22BED1
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x16, %rdx
leaq 0x7b2(%rdx,%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31f0
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3090
jmp 0x1339b
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3290
jmp 0x133b0
leaq -0x198(%rbp), %rdi
callq 0x3200
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3200
movq -0x1a0(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/grd2txt/grd2txt.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read grid file
  R3Grid *grid = ReadGrid(grid_name);
  if (!grid) exit(-1);

  // Write ascii text
  int status = WriteText(grid, txt_name);
  if (!status) exit(-1);

  // Return success
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x12550
cmpl $0x0, %eax
jne 0x124f2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x16504f(%rip), %rdi    # 0x177548
callq 0x126a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12515
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x10(%rsp), %rdi
movq 0x16502f(%rip), %rsi    # 0x177550
callq 0x12830
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1253b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/grd2txt/grd2txt.cpp
// Function: ParseArgs(int, char**)
static int 
ParseArgs(int argc, char **argv)
{
  // Check number of arguments
  if (argc < 2) {
    printf("Usage: grd2txt gridfile [txtfile] [-v]\n");
    exit(0);
  }

  // Parse arguments
  argc--; argv++;
  while (argc > 0) {
    if ((*argv)[0] == '-') {
      if (!strcmp(*argv, "-v")) { 
        print_verbose = 1; 
      }
      else { 
        RNFail("Invalid program argument: %s", *argv); 
        exit(1); 
      }
    }
    else {
      if (!grid_name) grid_name = *argv;
      else if (!txt_name) txt_name = *argv;
      else { 
        RNFail("Invalid program argument: %s", *argv); 
        exit(1); 
      }
    }
    argv++; argc--;
  }

  // Check grid filename
  if (!grid_name) {
    RNFail("You did not specify a grid file.\n");
    return 0;
  }

  // Return OK status 
  return 1;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x12579
leaq 0x11fa99(%rip), %rdi    # 0x132004
movb $0x0, %al
callq 0xf070
xorl %edi, %edi
callq 0xf600
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x1266c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x125f4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x11fa70(%rip), %rsi    # 0x13202c
callq 0xf700
cmpl $0x0, %eax
jne 0x125d2
movl $0x1, 0x164f88(%rip)    # 0x177558
jmp 0x125f2
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x11fa4e(%rip), %rdi    # 0x13202f
movb $0x0, %al
callq 0xd40b0
movl $0x1, %edi
callq 0xf600
jmp 0x1264e
cmpq $0x0, 0x164f4c(%rip)    # 0x177548
jne 0x1260f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x164f3b(%rip)    # 0x177548
jmp 0x1264c
cmpq $0x0, 0x164f39(%rip)    # 0x177550
jne 0x1262a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x164f28(%rip)    # 0x177550
jmp 0x1264a
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x11f9f6(%rip), %rdi    # 0x13202f
movb $0x0, %al
callq 0xd40b0
movl $0x1, %edi
callq 0xf600
jmp 0x1264c
jmp 0x1264e
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x12592
cmpq $0x0, 0x164ed4(%rip)    # 0x177548
jne 0x1268e
leaq 0x11f9cf(%rip), %rdi    # 0x13204c
movb $0x0, %al
callq 0xd40b0
movl $0x0, 0x14(%rsp)
jmp 0x12696
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/grd2txt/grd2txt.cpp
// Function: WriteText(gaps::R3Grid*, char const*)
static int
WriteText(R3Grid *grid, const char *txt_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Open file
  FILE *fp = stdout;
  if (txt_name) {
    fp = fopen(txt_name, "w");
    if (!fp) {
      RNFail("Unable to open TXT file %s\n", txt_name);
      return 0;
    }  
  }

  // Write values
  grid->Print(fp);

  // Close file
  if (txt_name) fclose(fp);

  // Print statistics
  if (print_verbose) {
    printf("Wrote text ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Values = %d\n", grid->NEntries());
    fflush(stdout);
  }

  // Return number of values written
  return grid->NEntries();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xcfe90
leaq 0x10(%rsp), %rdi
callq 0x12940
movq 0x15b737(%rip), %rax    # 0x16df90
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x128a9
movq 0x20(%rsp), %rdi
leaq 0x11fdb9(%rip), %rsi    # 0x13262e
callq 0xf5e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x128a7
movq 0x20(%rsp), %rsi
leaq 0x11f85b(%rip), %rdi    # 0x1320ee
movb $0x0, %al
callq 0xd40b0
movl $0x0, 0x34(%rsp)
jmp 0x12930
jmp 0x128a9
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x25fd0
cmpq $0x0, 0x20(%rsp)
je 0x128ca
movq 0x8(%rsp), %rdi
callq 0xf4b0
cmpl $0x0, 0x164c87(%rip)    # 0x177558
je 0x12922
leaq 0x11f830(%rip), %rdi    # 0x13210a
movb $0x0, %al
callq 0xf070
leaq 0x10(%rsp), %rdi
callq 0xcff50
leaq 0x11f7bf(%rip), %rdi    # 0x1320b1
movb $0x1, %al
callq 0xf070
movq 0x28(%rsp), %rdi
callq 0x129e0
movl %eax, %esi
leaq 0x11f80e(%rip), %rdi    # 0x13211a
movb $0x0, %al
callq 0xf070
movq 0x15b676(%rip), %rax    # 0x16df90
movq (%rax), %rdi
callq 0xf5d0
movq 0x28(%rsp), %rdi
callq 0x129e0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::isNum(char)
bool Scanner::isNum(char character){
	int ascii = (int)character;
	if ((ascii >= 48) && (ascii <= 57))
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x30, -0x18(%rbp)
jl 0x53c7
cmpl $0x39, -0x18(%rbp)
jg 0x53c7
movb $0x1, -0x1(%rbp)
jmp 0x53cb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::isLetter(char)
bool Scanner::isLetter(char character){
	int ascii = (int)character;
	if (((ascii >= 65) && (ascii <= 90)) || ((ascii >= 97) && (ascii <= 122)))
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x41, -0x18(%rbp)
jl 0x5401
cmpl $0x5a, -0x18(%rbp)
jle 0x540d
cmpl $0x61, -0x18(%rbp)
jl 0x5413
cmpl $0x7a, -0x18(%rbp)
jg 0x5413
movb $0x1, -0x1(%rbp)
jmp 0x5417
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::isString(char)
bool Scanner::isString(char character){
	if (character == '\"')
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x22, %eax
jne 0x543d
movb $0x1, -0x1(%rbp)
jmp 0x5441
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::isChar(char)
bool Scanner::isChar(char character){
	if (character == '\'')
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x27, %eax
jne 0x546d
movb $0x1, -0x1(%rbp)
jmp 0x5471
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::isSingleToken(char)
bool Scanner::isSingleToken(char character){
	switch(character){
		case '.': 
		case ':': 
		case ';': 
		case '(': 
		case ')': 
		case '=': 
		case ',': 
		case '+': 
		case '-': 
		case '*': 
		case '[': 
		case ']': 
		case '>': 
		case '<': 
		case '!': 
		case '&': 
		case '|':
			return true;
		default:
			return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5b, %eax
ja 0x54ba
movq -0x20(%rbp), %rax
leaq 0x1fb59(%rip), %rcx     # 0x25004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x54be
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::isSpace(char)
bool Scanner::isSpace(char character){
	int ascii = (int)character;
	if(ascii == '\n') line_number++;
	if (ascii <= 32 && character != EOF){
		return true;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jne 0x54fe
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x20, -0x18(%rbp)
jg 0x5513
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
je 0x5513
movb $0x1, -0x1(%rbp)
jmp 0x5517
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x130(%rdi), %rsi
movq %rdi, %rdx
addq $0x8, %rdx
callq 0x55c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movl (%rax), %ecx
movl %ecx, 0x2c(%rax)
testb $0x1, 0x138(%rax)
je 0x559d
movq -0x18(%rbp), %rax
cmpl $0x15d, 0x28(%rax)      # imm = 0x15D
je 0x559d
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq 0x2da47(%rip), %rdi     # 0x32fd0
callq 0x3260
movq %rax, %rdi
leaq 0x1ff8c(%rip), %rsi     # 0x25524
callq 0x3270
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x6380
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::DisplayErrorQueue()
void Parser::DisplayErrorQueue(){
	if(!error_queue.empty())
		cout << "\nWarnings / Errors:\n" << endl;
	else return;

	while(!error_queue.empty()){
		cout << error_queue.front() << "\n" << endl;
		error_queue.pop();
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x12650
testb $0x1, %al
jne 0x87e1
movq 0x2a80c(%rip), %rdi     # 0x32fd0
leaq 0x1cd6c(%rip), %rsi     # 0x25537
callq 0x3270
movq %rax, %rdi
movq 0x2a7de(%rip), %rsi     # 0x32fb8
callq 0x32c0
jmp 0x87e3
jmp 0x8839
jmp 0x87e5
movq -0x10(%rbp), %rdi
callq 0x12650
xorb $-0x1, %al
testb $0x1, %al
jne 0x87f6
jmp 0x8837
movq -0x10(%rbp), %rdi
callq 0x12670
movq %rax, %rsi
movq 0x2a7c7(%rip), %rdi     # 0x32fd0
callq 0x3260
movq %rax, %rdi
leaq 0x1e6fa(%rip), %rsi     # 0x26f12
callq 0x3270
movq %rax, %rdi
movq 0x2a791(%rip), %rsi     # 0x32fb8
callq 0x32c0
movq -0x10(%rbp), %rdi
callq 0x12690
jmp 0x87e5
jmp 0x8839
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x80(%rdi)
movq $0x0, 0x88(%rdi)
movq $0x0, 0x90(%rdi)
movq $0x0, 0x98(%rdi)
addq $0x58, %rdi
callq 0x31a0
movq -0x10(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)