LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: amukherj[P]concurrencyts/./future.h
// Function: void concurrencyts::future_state<int>::set_exception<std::exception&>(std::exception&)
void set_exception(E&& exc) {
    std::unique_lock<std::mutex> ul(mtx);
    assert(!is_available && !is_complete);
    eptr = std::make_exception_ptr(std::forward<E>(exc));
    is_complete = true;
    ul.unlock();

    completed.notify_all();
    notify_wait_queue();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x30, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc290
movq -0x48(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x5c(%rcx)
movb %al, -0x3d(%rbp)
jne 0xdb40
movq -0x48(%rbp), %rax
movb 0x5d(%rax), %al
xorb $-0x1, %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0xdb49
jmp 0xdb4b
jmp 0xdb6a
leaq 0x64d0(%rip), %rdi      # 0x14022
leaq 0x64e7(%rip), %rsi      # 0x14040
movl $0x38, %edx
leaq 0x6539(%rip), %rcx      # 0x1409e
callq 0x3120
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xdc80
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xdc10
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0xdca0
movq -0x58(%rbp), %rdi
callq 0xbe40
movq -0x50(%rbp), %rdi
callq 0x3320
movq -0x48(%rbp), %rax
movb $0x1, 0x5d(%rax)
leaq -0x20(%rbp), %rdi
callq 0xc470
jmp 0xdbc2
movq -0x48(%rbp), %rdi
callq 0x3290
movq -0x48(%rbp), %rdi
callq 0xcb50
leaq -0x20(%rbp), %rdi
callq 0xc380
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc380
movq -0x38(%rbp), %rdi
callq 0x32d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tdv[P]boss/boss/examples/simple_component/calc_service/calc_service.cpp
// Function: MyNs::Sum::CalcSum(int, int, int*)
Boss::RetCode BOSS_CALL Sum::CalcSum(int a, int b, int *sum)
  {
    if (*sum)
      return Boss::Status::InvalidArgument;
    *sum = a + b;
    return Boss::Status::Ok;
  }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x79e56
movl $0x5, -0x4(%rsp)
jmp 0x79e6d
movl -0x14(%rsp), %ecx
addl -0x18(%rsp), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/test4.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for string we got : " << _stringTest<< endl
		 << "for bool B we got : " << _boolTestB << endl
		 << "for bool A we got : " << _boolTestA << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5ef0
movq 0x1d17e(%rip), %rdi     # 0x22fd0
leaq 0x134ac(%rip), %rsi     # 0x19305
callq 0x5270
movq %rax, %rdi
leaq 0x1d4c0(%rip), %rsi     # 0x23328
callq 0x5250
movq %rax, %rdi
movq 0x1d139(%rip), %rsi     # 0x22fb0
callq 0x52d0
movq %rax, %rdi
leaq 0x13494(%rip), %rsi     # 0x1931a
callq 0x5270
movq %rax, %rdi
movb 0x1d48d(%rip), %al      # 0x23321
andb $0x1, %al
movzbl %al, %esi
callq 0x5500
movq %rax, %rdi
movq 0x1d108(%rip), %rsi     # 0x22fb0
callq 0x52d0
movq %rax, %rdi
leaq 0x13478(%rip), %rsi     # 0x1932f
callq 0x5270
movq %rax, %rdi
movb 0x1d45d(%rip), %al      # 0x23322
andb $0x1, %al
movzbl %al, %esi
callq 0x5500
movq %rax, %rdi
movq 0x1d0d7(%rip), %rsi     # 0x22fb0
callq 0x52d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18551(%rip), %rdi     # 0x22fd0
leaq 0xea39(%rip), %rsi      # 0x194bf
callq 0x5270
movq %rax, %rdi
movq 0x1851b(%rip), %rsi     # 0x22fb0
callq 0x52d0
movq %rax, %rdi
leaq 0xea1e(%rip), %rsi      # 0x194c2
callq 0x5270
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
testb $0x1, %al
jne 0xaab9
jmp 0xaacc
movq 0x18510(%rip), %rdi     # 0x22fd0
movl $0x2a, %esi
callq 0x5350
jmp 0xaae9
movl 0x18822(%rip), %esi     # 0x232f4
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x18817(%rip)     # 0x232f4
movq 0x184ec(%rip), %rdi     # 0x22fd0
callq 0x54d0
movq 0x184e0(%rip), %rdi     # 0x22fd0
movl $0x3a, %esi
callq 0x5350
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xab19
movq 0x184c1(%rip), %rdi     # 0x22fd0
movl $0x3a, %esi
callq 0x5350
movq -0x10(%rbp), %rdi
callq 0xf3e0
movq %rax, %rsi
movq 0x184a4(%rip), %rdi     # 0x22fd0
callq 0x5250
movq %rax, %rdi
movl $0x3a, %esi
callq 0x5350
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf3e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xf8c0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0xf920
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf8f0
testb $0x1, %al
jne 0xab87
jmp 0xaba5
leaq -0x18(%rbp), %rdi
callq 0xf950
movq %rax, %rsi
addq $0x20, %rsi
movq 0x18432(%rip), %rdi     # 0x22fd0
callq 0x5250
jmp 0xabd1
movq 0x18424(%rip), %rdi     # 0x22fd0
leaq 0xe913(%rip), %rsi      # 0x194c6
callq 0x5270
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf3e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5250
movq 0x183f8(%rip), %rdi     # 0x22fd0
movl $0x27, %esi
callq 0x5350
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/DocBookOutput.h
// Function: TCLAP::DocBookOutput::substituteSpecialChars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void DocBookOutput::substituteSpecialChars( std::string& s,
				                                   char r,
												   std::string& x )
{
	size_t p;
	while ( (p = s.find_first_of(r)) != std::string::npos )
	{
		s.erase(p,1);
		s.insert(p,x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0x51a0
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
je 0xf379
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x50a0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5460
jmp 0xf339
addq $0x30, %rsp
popq %rbp
retq
nop
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/ZshCompletionOutput.h
// Function: TCLAP::ZshCompletionOutput::quoteSpecialChars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void ZshCompletionOutput::quoteSpecialChars( std::string& s )
{
	size_t idx = s.find_last_of(':');
	while ( idx != std::string::npos )
	{
		s.insert(idx, 1, '\\');
		idx = s.find_last_of(':', idx);
	}
	idx = s.find_last_of('\'');
	while ( idx != std::string::npos )
	{
		s.insert(idx, "'\\'");
		if (idx == 0)
			idx = std::string::npos;
		else
			idx = s.find_last_of('\'', --idx);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
movq $-0x1, %rdx
callq 0x5550
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0xfe5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
movl $0x5c, %ecx
callq 0x55b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x3a, %esi
callq 0x5550
movq %rax, -0x18(%rbp)
jmp 0xfe29
movq -0x10(%rbp), %rdi
movl $0x27, %esi
movq $-0x1, %rdx
callq 0x5550
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0xfec4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x9671(%rip), %rdx      # 0x194ff
callq 0x50c0
cmpq $0x0, -0x18(%rbp)
jne 0xfea4
movq $-0x1, -0x18(%rbp)
jmp 0xfec2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movl $0x27, %esi
callq 0x5550
movq %rax, -0x18(%rbp)
jmp 0xfe78
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x11bc6(%rip), %rdi     # 0x22fd0
leaq 0x81a3(%rip), %rsi      # 0x195b4
callq 0x5270
movq %rax, %rdi
movq 0x11b90(%rip), %rsi     # 0x22fb0
callq 0x52d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x90b0
leaq -0x28(%rbp), %rdi
callq 0x9ae0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9b40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9b10
testb $0x1, %al
jne 0x1146b
jmp 0x1161b
leaq -0x30(%rbp), %rdi
callq 0x9c50
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x54f0
movq -0xc0(%rbp), %rdx
leaq 0x7e65(%rip), %rsi      # 0x19301
leaq -0x78(%rbp), %rdi
callq 0x6ee0
jmp 0x114a7
movq -0xc8(%rbp), %rsi
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq *%rax
jmp 0x114c1
movq 0x11b08(%rip), %rdi     # 0x22fd0
leaq -0x58(%rbp), %rsi
callq 0x5250
movq %rax, -0xd0(%rbp)
jmp 0x114da
movq -0xd0(%rbp), %rdi
leaq 0x80de(%rip), %rsi      # 0x195c6
callq 0x5270
movq %rax, -0xd8(%rbp)
jmp 0x114f6
leaq -0x30(%rbp), %rdi
callq 0x9c50
movq (%rax), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xeac0
jmp 0x11510
movq -0xd8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x5250
movq %rax, -0xe0(%rbp)
jmp 0x1152c
movq -0xe0(%rbp), %rdi
leaq 0x7fd3(%rip), %rsi      # 0x1950d
callq 0x5270
movq %rax, -0xe8(%rbp)
jmp 0x11548
movq -0xe8(%rbp), %rdi
movq 0x11a5a(%rip), %rsi     # 0x22fb0
callq 0x52d0
jmp 0x1155d
leaq -0xb0(%rbp), %rdi
callq 0x55c8
leaq -0x58(%rbp), %rdi
callq 0x55c8
leaq -0x78(%rbp), %rdi
callq 0x55c8
leaq -0x79(%rbp), %rdi
callq 0x5300
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x9c70
movq %rax, -0xb8(%rbp)
jmp 0x11448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x11607
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x115fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x115f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x55c8
leaq -0x58(%rbp), %rdi
callq 0x55c8
leaq -0x78(%rbp), %rdi
callq 0x55c8
leaq -0x79(%rbp), %rdi
callq 0x5300
leaq -0x28(%rbp), %rdi
callq 0x8330
jmp 0x1162d
leaq -0x28(%rbp), %rdi
callq 0x8330
addq $0xf0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x54e0
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_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>>>>::find_branch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf7f0
cmpq -0x20(%rbp), %rax
jne 0xf87d
jmp 0xf89c
leaq 0x9ba47(%rip), %rdi     # 0xab2cb
leaq 0x9b802(%rip), %rsi     # 0xab08d
movl $0x2a8, %edx            # imm = 0x2A8
leaq 0x9ba53(%rip), %rcx     # 0xab2ea
callq 0xc3b0
movq -0x30(%rbp), %rdi
callq 0xff80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf8c2
movq -0x30(%rbp), %rdi
callq 0xed30
movq %rax, -0x8(%rbp)
jmp 0xf97a
jmp 0xf8c4
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfb90
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq (%rcx), %rax
ja 0xf8e6
jmp 0xf972
movq -0x28(%rbp), %rdi
callq 0xed90
cmpq $0x0, (%rax)
jne 0xf906
movq -0x28(%rbp), %rdi
callq 0xfe90
cmpq $0x0, (%rax)
jne 0xf906
jmp 0xf972
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfb90
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0xfd90
testb $0x1, %al
jne 0xf929
jmp 0xf94c
movq -0x28(%rbp), %rdi
callq 0xfe90
cmpq $0x0, (%rax)
jne 0xf93a
jmp 0xf972
movq -0x28(%rbp), %rdi
callq 0xfe90
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xf96d
movq -0x28(%rbp), %rdi
callq 0xed90
cmpq $0x0, (%rax)
jne 0xf95d
jmp 0xf972
movq -0x28(%rbp), %rdi
callq 0xed90
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xf8c4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
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>>>>::any_leaf() const
node_pointer any_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

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

				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 0xfbb0
xorb $-0x1, %al
testb $0x1, %al
jne 0xf9ba
jmp 0xf9ed
movq -0x10(%rbp), %rdi
callq 0xed90
cmpq $0x0, (%rax)
je 0xf9db
movq -0x10(%rbp), %rdi
callq 0xed90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf9eb
movq -0x10(%rbp), %rdi
callq 0xfe90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf9a9
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%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>::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 * 2;

			if (mismatch_index == min_size)
			{
				if (s1.size() == s2.size())
					++mismatch_bit_index;
			}
			else
			{
				unsigned_char_type x = data1[mismatch_index];
				x ^= data2[mismatch_index];
				mismatch_bit_index += (num_bits - detail::msb(x)) * 2 - 1;
			}

			return mismatch_bit_index;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %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
shlq %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xfacd
movq -0x8(%rbp), %rdi
callq 0xc3e0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jne 0xfacb
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xfb13
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
shlq %rax
subq $0x1, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
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_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>>>>::make_new_iterator_to(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>>>>*)
iterator make_new_iterator_to(node_pointer node)
			{
				iterator it(node);

				if (std::next(it) == begin())
					begin_node() = node;

				return it;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xfc00
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x102a0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xff50
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x102d0
testb $0x1, %al
jne 0xfd2f
jmp 0xfd47
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xed50
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%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>::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));
			if (index & 1)
			{
				index >>= 1;
				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;
			}
			else
			{
				index >>= 1 + index_shift;
				return index != s.size();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf7f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xfdbf
jmp 0xfdde
leaq 0x9c2c5(%rip), %rdi     # 0xac08b
leaq 0x9c2ce(%rip), %rsi     # 0xac09b
movl $0x28, %edx
leaq 0x9c2e6(%rip), %rcx     # 0xac0bf
callq 0xc3b0
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xfe4d
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc640
movb (%rax), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
movl $0x8, %ecx
subq -0x28(%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
movb %al, -0x1(%rbp)
jmp 0xfe7c
movq -0x18(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::msb(unsigned char)
inline int msb(std::uint8_t v)
		{
			v |= (v >> 1);
			v |= (v >> 2);
			v |= (v >> 4);

			return count_bit(v) - 1;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %ecx
sarl %ecx
movzbl -0x1(%rbp), %eax
orl %ecx, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %ecx
sarl $0x2, %ecx
movzbl -0x1(%rbp), %eax
orl %ecx, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %ecx
sarl $0x4, %ecx
movzbl -0x1(%rbp), %eax
orl %ecx, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %edi
callq 0x101b0
subl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::count_bit(unsigned char)
inline int count_bit(std::uint8_t v)
		{
			std::uint8_t result;
			result = (v & 0x55) + ((v >> 1) & 0x55);
			result = (result & 0x33) + ((result >> 2) & 0x33);
			result = (result & 0x0f) + ((result >> 4) & 0x0f);
			return static_cast<int>(result);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x55, %eax
movzbl -0x1(%rbp), %ecx
sarl %ecx
andl $0x55, %ecx
addl %ecx, %eax
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
andl $0x33, %eax
movzbl -0x2(%rbp), %ecx
sarl $0x2, %ecx
andl $0x33, %ecx
addl %ecx, %eax
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
andl $0xf, %eax
movzbl -0x2(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
addl %ecx, %eax
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// 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_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfe90
cmpq $0x0, (%rax)
je 0x1050f
movq -0x18(%rbp), %rdi
callq 0xfe90
movq (%rax), %rdi
callq 0x10570
movq %rax, -0x8(%rbp)
jmp 0x1055b
jmp 0x10511
movq -0x18(%rbp), %rdi
callq 0xfeb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x10522
jmp 0x10534
movq -0x18(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10511
movq -0x18(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfbb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x104e9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
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>>>>::min_leaf() const
node_pointer min_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

				while (true)
				{
					if (node->left())
						node = node->left();
					else
						break;
				}

				assert(node->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 0xed90
cmpq $0x0, (%rax)
je 0x105aa
movq -0x10(%rbp), %rdi
callq 0xed90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x105ac
jmp 0x105ae
jmp 0x10589
movq -0x10(%rbp), %rdi
callq 0xfbb0
testb $0x1, %al
jne 0x105bd
jmp 0x105bf
jmp 0x105de
leaq 0x9b4dd(%rip), %rdi     # 0xabaa3
leaq 0x9af12(%rip), %rsi     # 0xab4df
movl $0xd5, %edx
leaq 0x9b4d7(%rip), %rcx     # 0xabab0
callq 0xc3b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// 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>>>>::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xed90
cmpq $0x0, (%rax)
je 0x1062f
movq -0x18(%rbp), %rdi
callq 0xed90
movq (%rax), %rdi
callq 0x10690
movq %rax, -0x8(%rbp)
jmp 0x10679
jmp 0x10631
movq -0x18(%rbp), %rdi
callq 0xfeb0
testb $0x1, %al
jne 0x10640
jmp 0x10652
movq -0x18(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10631
movq -0x18(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfbb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x10609
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// 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>>>>::max_leaf() const
node_pointer max_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

				while (true)
				{
					if (node->right())
						node = node->right();
					else
						break;
				}

				assert(node->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 0xfe90
cmpq $0x0, (%rax)
je 0x106ca
movq -0x10(%rbp), %rdi
callq 0xfe90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x106cc
jmp 0x106ce
jmp 0x106a9
movq -0x10(%rbp), %rdi
callq 0xfbb0
testb $0x1, %al
jne 0x106dd
jmp 0x106df
jmp 0x106fe
leaq 0x9b3bd(%rip), %rdi     # 0xabaa3
leaq 0x9adf2(%rip), %rsi     # 0xab4df
movl $0xe6, %edx
leaq 0x9b65d(%rip), %rcx     # 0xabd56
callq 0xc3b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// 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>>>>* 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>> const&>(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>> const&)
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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x107e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x10810
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movb $0x1, -0x21(%rbp)
leaq -0x21(%rbp), %rdx
callq 0x10840
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movq $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rdx
callq 0x10810
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rdx
callq 0x10810
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movl $0x0, -0x3c(%rbp)
leaq -0x3c(%rbp), %rdx
callq 0x10870
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0x10240
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// 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>>>>::construct(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>>>>>&)
static node_pointer construct(node_allocator_type& allocator)
			{
				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_), false);
				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);
				return p;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x107e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x10810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movb $0x0, -0x19(%rbp)
leaq -0x19(%rbp), %rdx
callq 0x10840
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x10810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rdx
callq 0x10810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movl $0x0, -0x34(%rbp)
leaq -0x34(%rbp), %rdx
callq 0x10870
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// 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>>>>::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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbb0
testb $0x1, %al
jne 0x10a6f
jmp 0x10a80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x10af0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10b20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x10b50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x10b20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x10b20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x10b80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x10bb0
addq $0x10, %rsp
popq %rbp
retq
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_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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x10d8a
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10da0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10df0
jmp 0x10d4a
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x10e20
jmp 0x10d59
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10e70
jmp 0x10d68
leaq -0x30(%rbp), %rdi
callq 0x10f10
jmp 0x10d8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10f10
jmp 0x10d94
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc9b0
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_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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x10e90
jmp 0x10f08
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11220
movq -0x18(%rbp), %rdi
callq 0xed50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed50
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x11250
movq -0x18(%rbp), %rdi
callq 0xed60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x11250
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x11290
movq -0x18(%rbp), %rdi
callq 0x112d0
movq -0x10(%rbp), %rdi
callq 0x112d0
addq $0x30, %rsp
popq %rbp
retq
nop
// 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>>>>::fix_swapped()
void fix_swapped()
			{
				if (root_node())
					root_node()->parent() = end_node();

				end_node()->left() = root_node();

				if (empty())
					begin_node() = end_node();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xed60
cmpq $0x0, (%rax)
je 0x11314
movq -0x10(%rbp), %rdi
callq 0xed30
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xed60
movq (%rax), %rdi
callq 0xfb70
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xed60
movq -0x10(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0xed30
movq %rax, %rdi
callq 0xed90
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq %rcx, (%rax)
callq 0x11380
testb $0x1, %al
jne 0x1134b
jmp 0x11368
movq -0x10(%rbp), %rdi
callq 0xed30
movq -0x10(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xed50
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// 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>>>>::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xed50
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xed30
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x114aa
movq -0x10(%rbp), %rdi
callq 0xfe90
cmpq $0x0, (%rax)
je 0x11405
movq -0x10(%rbp), %rdi
callq 0xfe90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x114a5
movq -0x10(%rbp), %rdi
callq 0xed90
cmpq $0x0, (%rax)
je 0x11426
movq -0x10(%rbp), %rdi
callq 0xed90
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x114a3
movq -0x10(%rbp), %rdi
callq 0xfeb0
testb $0x1, %al
jne 0x11435
jmp 0x1146c
movq -0x10(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xed90
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0xff20
movq -0x10(%rbp), %rdi
callq 0xed90
movq $0x0, (%rax)
jmp 0x114a1
movq -0x10(%rbp), %rdi
callq 0xfb70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfe90
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0xff20
movq -0x10(%rbp), %rdi
callq 0xfe90
movq $0x0, (%rax)
jmp 0x114a3
jmp 0x114a5
jmp 0x113c0
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x11750
movb $0x1, -0x1(%rbp)
jmp 0x117b5
movq -0x10(%rbp), %rdi
callq 0x117d0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x117d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x11778
movb $0x0, -0x1(%rbp)
jmp 0x117b5
movq -0x10(%rbp), %rdi
callq 0x10fd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11000
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10fd0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x117f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// 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>>>>::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x11c51
movq -0x18(%rbp), %rdi
callq 0x113a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11c60
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11c90
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)