LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/ZshCompletionOutput.h
// Function: TCLAP::ZshCompletionOutput::printArg(TCLAP::Arg*)
inline void ZshCompletionOutput::printArg(Arg* a)
{
	static int count = 1;

	std::cout << " \\" << std::endl << "  '";
	if ( a->acceptsMultipleValues() )
		std::cout << '*';
	else
		std::cout << count++;
	std::cout << ':';
	if ( !a->isRequired() )
		std::cout << ':';

	std::cout << a->getName() << ':';
	std::map<std::string, std::string>::iterator compArg = common.find(a->getName());
	if ( compArg != common.end() )
	{
		std::cout << compArg->second;
	}
	else
	{
		std::cout << "_guard \"^-*\" " << a->getName();
	}
	std::cout << '\'';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xbbd8(%rip), %r15      # 0x12fd0
leaq 0x6dec(%rip), %rsi      # 0xe1eb
movl $0x2, %edx
movq %r15, %rdi
callq 0x4250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
leaq 0x6db4(%rip), %rsi      # 0xe1ee
movl $0x3, %edx
movq %rax, %rdi
callq 0x4250
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
testb %al, %al
je 0x746f
leaq 0xb(%rsp), %rsi
movb $0x2a, (%rsi)
movq 0xbb6d(%rip), %rdi      # 0x12fd0
movl $0x1, %edx
callq 0x4250
jmp 0x748a
movl 0xbdb7(%rip), %esi      # 0x1322c
leal 0x1(%rsi), %eax
movl %eax, 0xbdae(%rip)      # 0x1322c
movq 0xbb4b(%rip), %rdi      # 0x12fd0
callq 0x4390
leaq 0xc(%rsp), %rsi
movb $0x3a, (%rsi)
movq 0xbb37(%rip), %rdi      # 0x12fd0
movl $0x1, %edx
callq 0x4250
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x74c9
leaq 0xd(%rsp), %rsi
movb $0x3a, (%rsi)
movq 0xbb11(%rip), %rdi      # 0x12fd0
movl $0x1, %edx
callq 0x4250
leaq 0x28(%rbx), %r15
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq 0xbaf4(%rip), %rdi      # 0x12fd0
callq 0x4250
leaq 0xe(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4250
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xa896
addq $0x10, %r14
cmpq %r14, %rax
je 0x7515
leaq 0x40(%rax), %r15
addq $0x48, %rax
jmp 0x7534
addq $0x30, %rbx
movq 0xbab0(%rip), %rdi      # 0x12fd0
leaq 0x6ccb(%rip), %rsi      # 0xe1f2
movl $0xd, %edx
callq 0x4250
movq %rbx, %rax
movq (%r15), %rsi
movq (%rax), %rdx
movq 0xba8f(%rip), %rbx      # 0x12fd0
movq %rbx, %rdi
callq 0x4250
leaq 0xf(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4250
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/statgen[P]statgen/lib/tclap-1.2.0/examples/test4.cpp
// Function: MyOutput::usage(TCLAP::CmdLineInterface&)
virtual void usage(CmdLineInterface& c)
		{
			cout << "my usage message:" << endl;
			list<Arg*> args = c.getArgList();
			for (ArgListIterator it = args.begin(); it != args.end(); it++)
				cout << (*it)->longID()
					 << "  (" << (*it)->getDescription() << ")" << endl;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq 0x7f90(%rip), %r14      # 0x12fd0
leaq 0x3299(%rip), %rsi      # 0xe2e0
movl $0x11, %edx
movq %r14, %rdi
callq 0x4250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6d64
movq (%rbx), %r15
cmpq %rbx, %r15
je 0xb1c1
leaq 0x50(%rsp), %r14
leaq 0x40(%rsp), %r12
leaq 0x3188(%rip), %r13      # 0xe239
movq 0x10(%r15), %rbp
movq %r14, 0x40(%rsp)
movq %r12, %rdi
leaq 0x2feb(%rip), %rsi      # 0xe0af
leaq 0x2fe7(%rip), %rdx      # 0xe0b2
callq 0xa028
movq (%rbp), %rax
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq *0x48(%rax)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x7edd(%rip), %rdi      # 0x12fd0
callq 0x4250
movq %rax, %rbp
movl $0x3, %edx
movq %rax, %rdi
leaq 0x31e8(%rip), %rsi      # 0xe2f2
callq 0x4250
movq 0x10(%r15), %rsi
movq %rsp, %rdi
callq 0xa63e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq 0x4250
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x4250
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %rbp, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb182
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xb19e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0xb1b5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x4200
movq (%r15), %r15
cmpq %rbx, %r15
jne 0xb0b1
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb1e0
movq (%rdi), %r14
movl $0x18, %esi
callq 0x4200
movq %r14, %rdi
cmpq %rbx, %r14
jne 0xb1cb
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xb251
movq %rax, %r15
jmp 0xb23a
jmp 0xb1fb
movq %rax, %r15
jmp 0xb21e
movq %rax, %r15
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb21e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xb23a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0xb251
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb270
movq (%rdi), %r14
movl $0x18, %esi
callq 0x4200
movq %r14, %rdi
cmpq %rbx, %r14
jne 0xb25b
movq %r15, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O1/statgen[P]statgen/lib/tclap-1.2.0/examples/test4.cpp
// Function: MyOutput::failure(TCLAP::CmdLineInterface&, TCLAP::ArgException&)
virtual void failure(CmdLineInterface& c, ArgException& e)
		{
			static_cast<void>(c); // Ignore input, don't warn
			cerr << "my failure message: " << endl
			     << e.what() << endl;
			exit(1);
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x7d26(%rip), %rdi      # 0x12ff0
leaq 0x303d(%rip), %rsi      # 0xe30e
callq 0x41e0
movq %rax, %rdi
callq 0x4100
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x41e0
movq %rax, %rdi
callq 0x4100
movl $0x1, %edi
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O1/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_leaf() const
node_pointer next_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

				do
				{
					if (node->right())
						return node->right()->min_leaf();

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

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

				return node;
			}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0xd6cc
movq %rdi, %rax
movq 0x18(%rdi), %rdi
cmpq %rax, (%rdi)
jne 0xd6b8
cmpb $0x1, 0x8(%rdi)
jne 0xd6af
jmp 0xd6dd
movq %rax, %rdi
movq (%rax), %rax
testq %rax, %rax
jne 0xd6cc
cmpb $0x0, 0x8(%rdi)
je 0xd6e2
movq %rdi, %rax
popq %rcx
retq
leaq 0x403d6(%rip), %rdi     # 0x4dabf
leaq 0x3fe0b(%rip), %rsi     # 0x4d4fb
leaq 0x403d5(%rip), %rcx     # 0x4dacc
movl $0xd5, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>::destroy(std::allocator<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>>>>>&, 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>>>>*)
static void destroy(node_allocator_type& allocator, node_pointer p)
			{
				if (p->leaf())
					node_allocator_traits::destroy(allocator, std::addressof(p->value_));
				node_allocator_traits::destroy(allocator, std::addressof(p->left_));
				node_allocator_traits::destroy(allocator, std::addressof(p->leaf_));
				node_allocator_traits::destroy(allocator, std::addressof(p->right_));
				node_allocator_traits::destroy(allocator, std::addressof(p->parent_));
				node_allocator_traits::destroy(allocator, std::addressof(p->index_));
				node_allocator_traits::deallocate(allocator, p, 1);
			}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0xd724
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xd724
movq (%rax), %rsi
incq %rsi
callq 0xb3c0
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xb3c0
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>::operator=(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>>>> const&)
cb_tree_base& operator =(const cb_tree_base& other)
			{
				if (&other != this)
				{
					cb_tree_base temp;
					temp.copy_assign_allocator(other);
					temp.copy_impl(other);
					swap(temp);
				}

				return *this;
			}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xd770
leaq 0x8(%rsp), %rax
movb $0x1, 0x8(%rax)
movq %rax, -0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x10(%rax)
movq %rsp, %rdi
callq 0xd796
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd7ca
movq %rsp, %rdi
callq 0xd938
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0xd78e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd938
movq %rbx, %rdi
callq 0xb690
movq %rax, %rdi
callq 0xcddd
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>::swap(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 swap(cb_tree_base& other)
			{
				if (&other == this)
					return;

				swap_allocator(other);

				std::swap(begin_node(), other.begin_node());
				std::swap(root_node(), other.root_node());
				std::swap(size_, other.size_);

				fix_swapped();
				other.fix_swapped();
			}

// Assembly:
cmpq %rdi, %rsi
je 0xd82b
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
leaq 0x8(%rdi), %rcx
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rdx
movq %rdx, 0x18(%rdi)
movq %rax, 0x18(%rsi)
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0xd80c
movq %rcx, 0x18(%rdx)
leaq 0x8(%rsi), %rdx
cmpq $0x0, 0x18(%rdi)
jne 0xd81a
movq %rcx, (%rdi)
movq (%rdx), %rcx
testq %rcx, %rcx
je 0xd826
movq %rdx, 0x18(%rcx)
testq %rax, %rax
je 0xd82c
retq
movq %rdx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>::destroy_impl()
void destroy_impl()
			{
				node_pointer node = begin_node();

				while (node != end_node())
				{
					if (node->right())
					{
						node = node->right();
					}
					else if (node->left())
					{
						node = node->left();
					}
					else
					{
						if (node->is_left_child())
						{
							node = node->parent();
							destroy_node(node->left());
							node->left() = nullptr;
						}
						else
						{
							node = node->parent();
							destroy_node(node->right());
							node->right() = nullptr;
						}
					}
				}
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
leaq 0x8(%rdi), %r14
cmpq %r14, %rax
je 0xd98f
movq %rdi, %rbx
movq 0x10(%rax), %r15
testq %r15, %r15
jne 0xd987
movq (%rax), %r15
testq %r15, %r15
jne 0xd987
movq 0x18(%rax), %r15
movq (%r15), %rsi
movq %r15, %r12
cmpq %rax, %rsi
je 0xd977
leaq 0x10(%r15), %r12
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0xd702
movq $0x0, (%r12)
movq %r15, %rax
cmpq %r14, %r15
jne 0xd94f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::operator==(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>>>> const&, 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>>>> const&)
bool operator ==(const derived_type& lhs, const derived_type& rhs)
			{
				if (&lhs == &rhs)
					return true;

				if (lhs.size() != rhs.size())
					return false;

				return std::equal(lhs.begin(), lhs.end(), rhs.begin());
			}

// Assembly:
pushq %rax
cmpq %rsi, %rdi
je 0xdb3b
movq %rdi, %rax
movq 0x18(%rdi), %rcx
cmpq 0x18(%rsi), %rcx
jne 0xdb3f
movq (%rax), %rdi
testq %rdi, %rdi
je 0xdb43
movq (%rsi), %rdx
testq %rdx, %rdx
je 0xdb43
addq $0x8, %rax
movq %rax, %rsi
popq %rax
jmp 0xdb62
movb $0x1, %al
jmp 0xdb41
xorl %eax, %eax
popq %rcx
retq
leaq 0x3fa9d(%rip), %rdi     # 0x4d5e7
leaq 0x3fa9b(%rip), %rsi     # 0x4d5ec
leaq 0x409c8(%rip), %rcx     # 0x4e520
movl $0x38, %edx
callq 0xb240
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>::operator=(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>>>>&&)
cb_tree_base& operator =(cb_tree_base&& other)
			{
				if (&other != this)
				{
					destroy_impl();
					move_assign_allocator(other);
					move_impl(std::move(other));
				}

				return *this;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xdc71
movq %rsi, %r14
movq %rbx, %rdi
callq 0xd938
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0x8(%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x8(%rbx), %rax
movq %rdx, 0x8(%rbx)
movq 0x18(%r14), %rdx
movq %rdx, 0x18(%rbx)
movq %rcx, (%r14)
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
movq %rcx, 0x18(%r14)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0xdc67
movq %rax, 0x18(%rcx)
cmpq $0x0, 0x18(%rbx)
jne 0xdc71
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x10736
testq %rax, %rax
je 0x100df
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x100db
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107a4
movl $0x1, %eax
jmp 0x100dd
xorl %eax, %eax
popq %rbx
retq
leaq 0x3dab7(%rip), %rdi     # 0x4db9d
leaq 0x3d4ff(%rip), %rsi     # 0x4d5ec
leaq 0x3f9be(%rip), %rcx     # 0x4fab2
movl $0x6d, %edx
callq 0xb240
// File: /workspace/github_cpp_makefile_star2_O1/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>>>>* 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>>>>::construct<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::allocator<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>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
static node_pointer construct(node_allocator_type& allocator, Value_&& value)
			{
				node_pointer p = node_allocator_traits::allocate(allocator, 1);
				node_allocator_traits::construct(allocator, std::addressof(p->left_), nullptr);
				node_allocator_traits::construct(allocator, std::addressof(p->leaf_), true);
				node_allocator_traits::construct(allocator, std::addressof(p->right_), nullptr);
				node_allocator_traits::construct(allocator, std::addressof(p->parent_), nullptr);
				node_allocator_traits::construct(allocator, std::addressof(p->index_), 0);
				node_allocator_traits::construct(allocator, std::addressof(p->value_), std::forward<Value_>(value));
				return p;
			}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x48, %edi
callq 0xb3a0
xorl %ecx, %ecx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
leaq 0x38(%rax), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq (%rbx), %rsi
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rsi
je 0x16807
movq %rsi, 0x28(%rax)
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
jmp 0x1680d
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rbx), %rdx
movq %rdx, 0x30(%rax)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
shlq $0x4, %rdx
incq %rdx
callq 0x1047c
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1077b
movq %rax, %r15
cmpb $0x1, 0x8(%rax)
jne 0x1077b
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x108f4
testb %al, %al
je 0x1077b
movq %r15, %rbx
testq %r15, %r15
je 0x10784
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3ce5c(%rip), %rdi     # 0x4d5e7
leaq 0x3ce5a(%rip), %rsi     # 0x4d5ec
leaq 0x3e8d4(%rip), %rcx     # 0x4f06d
movl $0x38, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1622c
movq %rax, (%rsp)
testq %rax, %rax
je 0x163fa
addq $0x8, %r14
cmpq %r14, %rax
je 0x163ee
movq %rsp, %rdi
callq 0x16b6e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x108f4
testb %al, %al
je 0x163ee
movq %rsp, %rdi
callq 0xd676
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3779c(%rip), %rdi     # 0x4db9d
leaq 0x371e4(%rip), %rsi     # 0x4d5ec
leaq 0x377a1(%rip), %rcx     # 0x4dbb0
movl $0x6d, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<unsigned short, cb_tree::cb_key_traits<unsigned short, void>, std::allocator<unsigned short>>, unsigned short, unsigned short, cb_tree::cb_key_traits<unsigned short, void>, std::allocator<unsigned short>>::find_branch(unsigned short const&, unsigned long) const
node_pointer find_branch(const key_type& key, size_type size) const
			{
				assert(traits_type::size(key) == size);
				node_pointer node = root_node();

				if (!node)
					return end_node();

				while (true)
				{
					if (size <= node->index())
						break;

					if (!node->left() && !node->right())
						break;

					if (traits_type::test(key, node->index()))
					{
						if (!node->right())
							break;

						node = node->right();
					}
					else
					{
						if (!node->left())
							break;

						node = node->left();
					}
				}

				return node;
			}

// Assembly:
pushq %rax
cmpq $0x10, %rdx
jne 0x1ba68
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1ba40
movq 0x20(%rax), %rdi
cmpq %rdx, %rdi
jae 0x1ba47
movzwl (%rsi), %ecx
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x1ba0b
cmpq $0x0, 0x10(%rax)
je 0x1ba47
cmpq $0x10, %rdi
jae 0x1ba49
movb $0xf, %r8b
subb %dil, %r8b
movzbl %r8b, %edi
btl %edi, %ecx
jae 0x1ba2d
cmpq $0x0, 0x10(%rax)
je 0x1ba47
addq $0x10, %rax
jmp 0x1ba32
testq %rsi, %rsi
je 0x1ba47
movq (%rax), %rax
movq 0x20(%rax), %rdi
cmpq %rdx, %rdi
jb 0x1b9fc
jmp 0x1ba47
addq $0x8, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x368e2(%rip), %rdi     # 0x52332
leaq 0x323ba(%rip), %rsi     # 0x4de11
leaq 0x37fdf(%rip), %rcx     # 0x53a3d
movl $0x6b, %edx
callq 0xb240
leaq 0x31878(%rip), %rdi     # 0x4d2e7
leaq 0x31633(%rip), %rsi     # 0x4d0a9
leaq 0x37824(%rip), %rcx     # 0x532a1
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x20, %rdi
jae 0x18250
movd %xmm0, %ecx
movl %ecx, %eax
orl $0x80000000, %eax       # imm = 0x80000000
testl %ecx, %ecx
notl %ecx
cmovsl %ecx, %eax
movl %edi, %ecx
shll %cl, %eax
shrl $0x1f, %eax
retq
pushq %rax
leaq 0x3a0da(%rip), %rdi     # 0x52332
leaq 0x35bb2(%rip), %rsi     # 0x4de11
leaq 0x3a0e0(%rip), %rcx     # 0x52346
movl $0xbb, %edx
callq 0xb240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18de9
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 0x39541(%rip), %rdi     # 0x52332
leaq 0x35019(%rip), %rsi     # 0x4de11
leaq 0x39f56(%rip), %rcx     # 0x52d55
movl $0xf6, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/planaria[P]cb_tree/tests/test_util.hpp
// Function: encode_base64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string encode_base64(const std::string& str)
{
	static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

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

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

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

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

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

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

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

		dst_pos += 4;
		src_pos += 3;
	}

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %rax
addq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
leaq (%rdx,%rdx), %rsi
andq $-0x4, %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl $0x3d, %edx
callq 0xb450
cmpq $0x0, 0x8(%r14)
je 0x199cb
xorl %eax, %eax
leaq 0x3977c(%rip), %rcx     # 0x53090
xorl %edx, %edx
movzbl (%r15,%rdx), %esi
shrl $0x2, %esi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, (%rdi,%rax)
movq 0x8(%r14), %rdi
decq %rdi
movzbl (%r15,%rdx), %esi
shll $0x4, %esi
andl $0x30, %esi
cmpq %rdi, %rdx
je 0x199b2
movzbl 0x1(%r15,%rdx), %edi
shrl $0x4, %edi
orq %rsi, %rdi
movb (%rdi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x1(%rdi,%rax)
movq 0x8(%r14), %rdi
addq $-0x2, %rdi
movzbl 0x1(%r15,%rdx), %esi
shll $0x2, %esi
andl $0x3c, %esi
cmpq %rdi, %rdx
je 0x199b9
movzbl 0x2(%r15,%rdx), %edi
shrl $0x6, %edi
orq %rsi, %rdi
movb (%rdi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x2(%rdi,%rax)
movzbl 0x2(%r15,%rdx), %esi
andl $0x3f, %esi
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, 0x3(%rdi,%rax)
addq $0x4, %rax
addq $0x3, %rdx
cmpq 0x8(%r14), %rdx
jne 0x19916
jmp 0x199cb
movl $0x1, %edx
jmp 0x199be
movl $0x2, %edx
movzbl %sil, %esi
movb (%rsi,%rcx), %cl
addq (%rbx), %rdx
movb %cl, (%rax,%rdx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d73e
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 0x34bec(%rip), %rdi     # 0x52332
leaq 0x306c4(%rip), %rsi     # 0x4de11
leaq 0x386a7(%rip), %rcx     # 0x55dfb
movl $0x93, %edx
callq 0xb240
// File: /workspace/github_cpp_makefile_star2_O1/planaria[P]cb_tree/./include/cb_tree/detail/cb_node.hpp
// Function: cb_tree::detail::cb_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prev_leaf() const
node_pointer prev_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

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

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

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

				return node;
			}

// Assembly:
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
jne 0x1faaf
movq %rdi, %rax
movq 0x18(%rdi), %rdi
cmpq %rax, (%rdi)
je 0x1fa9b
cmpb $0x1, 0x8(%rdi)
jne 0x1fa93
jmp 0x1fac1
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1faaf
cmpb $0x0, 0x8(%rdi)
je 0x1fac6
movq %rdi, %rax
popq %rcx
retq
leaq 0x2dff2(%rip), %rdi     # 0x4dabf
leaq 0x2da27(%rip), %rsi     # 0x4d4fb
leaq 0x37c50(%rip), %rcx     # 0x5772b
movl $0xe6, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::longest_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<iterator, iterator> longest_match(const key_type& key)
			{
				node_pointer branch = find_branch(key);
				if (branch == end_node())
					return std::make_pair(end(), end());

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
shlq $0x4, %rdx
incq %rdx
callq 0xd38a
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x21e35
movq %rax, %r14
cmpb $0x0, 0x8(%rax)
movq %rax, %rsi
jne 0x21db1
movq %r14, %rsi
xorl %eax, %eax
cmpq $0x0, (%rsi)
sete %al
shll $0x4, %eax
movq (%rsi,%rax), %rsi
cmpb $0x1, 0x8(%rsi)
jne 0x21d9b
cmpb $0x0, 0x8(%rsi)
je 0x21e41
addq $0x28, %rsi
movq %r15, %rdi
callq 0xd418
andq $-0x10, %rax
movq (%rbx), %rcx
movq %r14, %rdx
cmpq %rcx, %r14
je 0x21de0
movq 0x18(%rdx), %r14
cmpq 0x20(%r14), %rax
jbe 0x21dce
movq %rdx, %rax
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x21de3
cmpb $0x1, 0x8(%rbx)
jne 0x21e60
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rax, (%rdx)
jne 0x21df4
cmpb $0x0, 0x8(%rdx)
jne 0x21e11
movq %rdx, %rdi
callq 0xd6ae
movq %rax, %rdx
testq %rdx, %rdx
jne 0x21e38
leaq 0x2b7ca(%rip), %rdi     # 0x4d5e7
leaq 0x2b7c8(%rip), %rsi     # 0x4d5ec
leaq 0x2b7ea(%rip), %rcx     # 0x4d615
movl $0x38, %edx
callq 0xb240
movq %rbx, %rdx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b982(%rip), %rdi     # 0x4d7ca
leaq 0x2b6ac(%rip), %rsi     # 0x4d4fb
leaq 0x2b6ca(%rip), %rcx     # 0x4d520
movl $0x78, %edx
callq 0xb240
leaq 0x2bc58(%rip), %rdi     # 0x4dabf
leaq 0x2b68d(%rip), %rsi     # 0x4d4fb
leaq 0x2bc57(%rip), %rcx     # 0x4dacc
movl $0xd5, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prefix_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<iterator, iterator> prefix_match(const key_type& key)
			{
				size_type size = traits_type::size(key);
				node_pointer branch = find_branch(key, size);
				if (branch == end_node())
					return std::make_pair(end(), end());

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
shlq $0x4, %r12
leaq 0x1(%r12), %rdx
callq 0xd38a
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x21f5b
movq %rax, %r14
cmpb $0x0, 0x8(%rax)
movq %rax, %rsi
jne 0x21ed2
movq %r14, %rsi
xorl %eax, %eax
cmpq $0x0, (%rsi)
sete %al
shll $0x4, %eax
movq (%rsi,%rax), %rsi
cmpb $0x1, 0x8(%rsi)
jne 0x21ebc
cmpb $0x0, 0x8(%rsi)
je 0x21f6d
addq $0x28, %rsi
movq %r15, %rdi
callq 0xd418
andq $-0x10, %rax
cmpq %r12, %rax
jne 0x21f5b
movq (%rbx), %rcx
movq %r14, %rdx
cmpq %rcx, %r14
je 0x21f06
movq 0x18(%rdx), %r14
cmpq 0x20(%r14), %rax
jbe 0x21ef4
movq %rdx, %rax
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x21f09
cmpb $0x1, 0x8(%rbx)
jne 0x21f8c
movq %rdx, %rax
movq 0x18(%rdx), %rdx
cmpq %rax, (%rdx)
jne 0x21f1a
cmpb $0x0, 0x8(%rdx)
jne 0x21f37
movq %rdx, %rdi
callq 0xd6ae
movq %rax, %rdx
testq %rdx, %rdx
jne 0x21f5e
leaq 0x2b6a4(%rip), %rdi     # 0x4d5e7
leaq 0x2b6a2(%rip), %rsi     # 0x4d5ec
leaq 0x2b6c4(%rip), %rcx     # 0x4d615
movl $0x38, %edx
callq 0xb240
movq %rbx, %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2b856(%rip), %rdi     # 0x4d7ca
leaq 0x2b580(%rip), %rsi     # 0x4d4fb
leaq 0x2b59e(%rip), %rcx     # 0x4d520
movl $0x78, %edx
callq 0xb240
leaq 0x2bb2c(%rip), %rdi     # 0x4dabf
leaq 0x2b561(%rip), %rsi     # 0x4d4fb
leaq 0x2bb2b(%rip), %rcx     # 0x4dacc
movl $0xd5, %edx
callq 0xb240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22e8c
movq %rax, (%rsp)
testq %rax, %rax
je 0x22818
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x22837
movq %rsp, %rdi
callq 0x22e38
addq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2b37e(%rip), %rdi     # 0x4db9d
leaq 0x2adc6(%rip), %rsi     # 0x4d5ec
leaq 0x3678c(%rip), %rcx     # 0x58fb9
movl $0x6d, %edx
callq 0xb240
movl $0x10, %edi
callq 0xb190
movq %rax, %rbx
leaq 0x36d6f(%rip), %rsi     # 0x595ba
movq %rax, %rdi
callq 0xb080
movq 0x57766(%rip), %rsi     # 0x79fc0
movq 0x57757(%rip), %rdx     # 0x79fb8
movq %rbx, %rdi
callq 0xb640
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2c0
movq %r14, %rdi
callq 0xb690
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67c1(%rip), %rsi      # 0xf219
leaq -0x248(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x33b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x228(%rbp,%rax)
je 0x8ae2
movq 0xb534(%rip), %rbx      # 0x13fb8
leaq 0x679d(%rip), %rsi      # 0xf228
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x32c0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %esi
movq 0xb502(%rip), %rdi      # 0x13fb8
callq 0x3030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x31a0
leaq -0x248(%rbp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x3300
testl %eax, %eax
js 0x8b2b
callq 0x30a0
testl %eax, %eax
js 0x8b32
je 0x8b39
movl -0x18(%rbp), %edi
callq 0x33f0
movl -0x14(%rbp), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x30f0
movslq 0x8(%rbx), %rcx
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
cmpq %rcx, %rax
jne 0x8ac8
xorl %ebx, %ebx
movl -0x14(%rbp), %edi
callq 0x33f0
jmp 0x8ac8
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x8ac8
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x8ac8
movl -0x14(%rbp), %edi
callq 0x33f0
movl -0x18(%rbp), %edi
testl %edi, %edi
je 0x8b64
xorl %esi, %esi
callq 0x3250
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
testl %eax, %eax
jne 0x8ac8
movl -0x18(%rbp), %edi
callq 0x33f0
movaps 0xb1f5(%rip), %xmm0     # 0x13d60
leaq -0x40(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps 0xb1d6(%rip), %xmm0     # 0x13d50
movaps %xmm0, (%rsi)
leaq 0x6695(%rip), %rdi      # 0xf219
callq 0x3230
movl %eax, %ebx
sarl $0x1f, %ebx
andl $-0x4, %ebx
jmp 0x8ac8
jmp 0x8b98
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/AsherGlick[P]CommentHeader/source/main.cpp
// Function: captureExtendedInput[abi:cxx11]()
string captureExtendedInput() {
  string input;
  string output = "";
  while (getline(cin, input)) {
    if (input == "") return output;
    output += input + "\n";
  }
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x649c(%rip), %rdx      # 0xfbd9
movq %rdx, %rsi
callq 0x7590
leaq -0x40(%rbp), %r12
movq 0xa880(%rip), %r14      # 0x13fd0
leaq -0x70(%rbp), %r15
leaq -0x50(%rbp), %r13
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x97e8
movq %r15, %rdi
leaq 0x6447(%rip), %rsi      # 0xfbd9
callq 0x30c0
testl %eax, %eax
je 0x97e8
movq %r12, -0x50(%rbp)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x802a
movq %r13, %rdi
leaq 0x641c(%rip), %rsi      # 0xfbd8
callq 0x33e0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x9758
callq 0x3260
jmp 0x9758
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x97fa
callq 0x3260
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x9839
jmp 0x9815
jmp 0x9828
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x982b
callq 0x3260
jmp 0x982b
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x9839
callq 0x3260
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x984b
callq 0x3260
movq %r14, %rdi
callq 0x3390