LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/amukherj[P]concurrencyts/./future.h
// Function: void concurrencyts::future_state<std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::emplace<std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&&)
void emplace(Args&&... args) {
    std::unique_lock<std::mutex> ul(mtx);
    assert(!is_available && !is_complete);
    try {
      new (reinterpret_cast<T*>(&data)) T{std::forward<Args&&>(args)...};
      is_available = true;
    } catch (...) {
      eptr = std::current_exception();
    }
    is_complete = true;
    ul.unlock();

    completed.notify_all();
    notify_wait_queue();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5ab8
cmpb $0x0, 0x70(%rbx)
jne 0x6b29
cmpb $0x1, 0x71(%rbx)
je 0x6b29
movups (%r14), %xmm0
movups %xmm0, 0x58(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movw $0x101, 0x70(%rbx)      # imm = 0x101
leaq 0x8(%rsp), %rdi
callq 0x5b5a
movq %rbx, %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x6b5c
leaq 0x8(%rsp), %rdi
callq 0x5b06
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x14f2(%rip), %rdi      # 0x8022
leaq 0x1509(%rip), %rsi      # 0x8040
leaq 0x16f3(%rip), %rcx      # 0x8231
pushq $0x27
popq %rdx
callq 0x3100
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b06
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/amukherj[P]concurrencyts/./future.h
// Function: concurrencyts::future_state<int>::get()
T& get() {
    std::unique_lock<std::mutex> ul(mtx);
    completed.wait(ul, [this]()->bool { return is_complete; });

    if (eptr) {
      std::rethrow_exception(eptr);
    }

    return *(reinterpret_cast<T*>(&data));
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5ab8
movq %rbx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5ace
cmpq $0x0, 0x68(%rbx)
jne 0x5a7b
addq $0x58, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b06
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
addq $0x68, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5af6
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59d4
jmp 0x5aa5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b06
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/amukherj[P]concurrencyts/./future.h
// Function: concurrencyts::future_state<int>::wait()
void wait() {
    std::unique_lock<std::mutex> ul(mtx);
    completed.wait(ul, [this]()->bool { return is_complete; });

    if (eptr) {
      std::rethrow_exception(eptr);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5ab8
movq %rbx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5bfe
cmpq $0x0, 0x68(%rbx)
jne 0x5bc2
leaq 0x8(%rsp), %rdi
callq 0x5b06
addq $0x18, %rsp
popq %rbx
popq %r14
retq
addq $0x68, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5af6
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59d4
jmp 0x5bec
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b06
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
movq %rsp, %rdi
callq 0x5ab8
cmpb $0x0, 0x5c(%rbx)
jne 0x5eaf
cmpb $0x1, 0x5d(%rbx)
je 0x5eaf
movq 0x9177(%rip), %rax      # 0xefc0
addq $0x10, %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5edf
leaq 0x68(%rbx), %rdi
movq %r15, %rsi
callq 0x5f2c
movq %r15, %rdi
callq 0x59d4
movq %r14, %rdi
callq 0x32e0
movb $0x1, 0x5d(%rbx)
movq %rsp, %rdi
callq 0x5b5a
movq %rbx, %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x5c26
movq %rsp, %rdi
callq 0x5b06
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x216c(%rip), %rdi      # 0x8022
leaq 0x2183(%rip), %rsi      # 0x8040
leaq 0x21da(%rip), %rcx      # 0x809e
pushq $0x38
popq %rdx
callq 0x3100
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5b06
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/amukherj[P]concurrencyts/./future.h
// Function: concurrencyts::when_any_result<std::vector<std::iterator_traits<__gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>::value_type, std::allocator<std::iterator_traits<__gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>::value_type>>> concurrencyts::make_when_any_result<__gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>(unsigned long, __gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, __gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>)
auto make_when_any_result(size_t index, InputIt begin, InputIt end)
  -> when_any_result<std::vector<typename std::iterator_traits<InputIt>::value_type>>
{
  using ret_type = typename std::iterator_traits<InputIt>::value_type; 
  when_any_result<std::vector<ret_type>> result;

  for (auto it = begin; it != end; ++it) {
    result.futures.push_back(std::move(*it));
  }
  result.index = index;

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
cmpq %rbx, %r13
je 0x6e37
movq %r14, %rdi
movq %r13, %rsi
callq 0x640a
addq $0x10, %r13
jmp 0x6e21
movq %r15, (%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x56d0
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
callq 0x48a1
movq 0xc7a2(%rip), %rdi      # 0x10fd0
leaq 0x687e(%rip), %rsi      # 0xb0b3
callq 0x41c0
leaq 0xca17(%rip), %rsi      # 0x11258
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x4100
leaq 0x6870(%rip), %rsi      # 0xb0c8
movq %rax, %rdi
callq 0x41c0
movzbl 0xc9ea(%rip), %esi      # 0x11251
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x4100
leaq 0x685f(%rip), %rsi      # 0xb0dd
movq %rax, %rdi
callq 0x41c0
movzbl 0xc9c5(%rip), %esi      # 0x11252
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x4100
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb08d(%rip), %rdi      # 0x10fd0
leaq 0x52a1(%rip), %rsi      # 0xb1eb
callq 0x41c0
movq %rax, %rdi
callq 0x4100
leaq 0x5290(%rip), %rsi      # 0xb1ee
movq %rax, %rdi
callq 0x41c0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
testb %al, %al
je 0x5f84
movq 0xb056(%rip), %rdi      # 0x10fd0
pushq $0x2a
popq %rsi
callq 0x4230
jmp 0x5f9f
movl 0xb29a(%rip), %esi      # 0x11224
leal 0x1(%rsi), %eax
movl %eax, 0xb291(%rip)      # 0x11224
movq 0xb036(%rip), %rdi      # 0x10fd0
callq 0x4360
movq 0xb02a(%rip), %rdi      # 0x10fd0
pushq $0x3a
popq %rsi
callq 0x4230
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x5fca
movq 0xb00e(%rip), %rdi      # 0x10fd0
pushq $0x3a
popq %rsi
callq 0x4230
addq $0x28, %rbx
movq 0xaffb(%rip), %rdi      # 0x10fd0
movq %rbx, %rsi
callq 0x41b0
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x4230
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x808e
addq $0x10, %r14
cmpq %r14, %rax
je 0x600d
addq $0x40, %rax
movq 0xafc8(%rip), %rdi      # 0x10fd0
movq %rax, %rsi
jmp 0x6026
movq 0xafbc(%rip), %rdi      # 0x10fd0
leaq 0x51d7(%rip), %rsi      # 0xb1f2
callq 0x41c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41b0
movq 0xaf9e(%rip), %rdi      # 0x10fd0
pushq $0x27
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4230
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
pushq $-0x1
popq %r12
pushq $0x3a
popq %rbp
pushq $0x1
popq %r14
pushq $0x5c
popq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x43f0
cmpq $-0x1, %rax
je 0x81ef
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x4410
jmp 0x81c6
pushq $-0x1
popq %r12
pushq $0x27
popq %rbp
leaq 0x302e(%rip), %r14      # 0xb22b
movq %r12, %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x43f0
cmpq $-0x1, %rax
je 0x8231
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4090
movq %r12, %rax
testq %r15, %r15
je 0x820d
decq %r15
jmp 0x8200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movq %rsi, %rbx
movq 0x881f(%rip), %rdi      # 0x10fd0
leaq 0x2b28(%rip), %rsi      # 0xb2e0
callq 0x41c0
movq %rax, %rdi
callq 0x4100
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x5b18
leaq 0x48(%rsp), %r12
leaq 0x68(%rsp), %rbp
leaq 0x28(%rsp), %r15
movq %r13, %r14
movq (%r14), %r14
cmpq %r13, %r14
je 0x888f
movq 0x10(%r14), %rbx
movq %r12, %rdi
leaq 0x28a5(%rip), %rsi      # 0xb0af
leaq 0xf(%rsp), %rdx
callq 0x50f4
movq (%rbx), %rax
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x48(%rax)
movq 0x87a6(%rip), %rdi      # 0x10fd0
movq %rbp, %rsi
callq 0x41b0
movq %rax, %rdi
leaq 0x2ab6(%rip), %rsi      # 0xb2f2
callq 0x41c0
movq %rax, %rbx
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x7e9e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41b0
movq %rax, %rdi
leaq 0x29d4(%rip), %rsi      # 0xb239
callq 0x41c0
movq %rax, %rdi
callq 0x4100
movq %r15, %rdi
callq 0x4428
movq %rbp, %rdi
callq 0x4428
movq %r12, %rdi
callq 0x4428
jmp 0x87f0
leaq 0x10(%rsp), %rdi
callq 0x7fea
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x88b7
movq %rax, %rbx
jmp 0x88dd
movq %rax, %rbx
jmp 0x88d3
movq %rax, %rbx
jmp 0x88c9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4428
leaq 0x68(%rsp), %rdi
callq 0x4428
leaq 0x48(%rsp), %rdi
callq 0x4428
leaq 0x10(%rsp), %rdi
callq 0x7fea
movq %rbx, %rdi
callq 0x4370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x86d4(%rip), %rdi      # 0x10ff0
leaq 0x29eb(%rip), %rsi      # 0xb30e
callq 0x41c0
movq %rax, %rdi
callq 0x4100
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x41c0
movq %rax, %rdi
callq 0x4100
pushq $0x1
popq %rdi
callq 0x4240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %r15
movq 0x8(%rdi), %rbp
movq (%rsi), %r13
movq 0x8(%rsi), %rax
cmpq %rbp, %rax
cmovbq %rax, %rbp
leaq (%r15,%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0xbdb2
subq %r15, %rax
movq %rax, %rbx
shlq $0x4, %rbx
cmpq %rbp, %rax
jne 0xbbff
movq 0x8(%r12), %rax
xorl %ecx, %ecx
cmpq 0x8(%r14), %rax
sete %cl
orq %rcx, %rbx
jmp 0xbc1c
movb (%r13,%rax), %cl
xorb (%r15,%rax), %cl
movzbl %cl, %edi
callq 0xbd90
cltq
orq $0xf, %rbx
addq %rax, %rax
subq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xbc5a
movq (%r15), %rdi
pushq $0x1
popq %rsi
callq 0xbe0a
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0xbd72
movq %r15, %rdi
movq %rax, %rsi
callq 0xbe28
testb %al, %al
je 0xbd05
movq %rbx, (%r14)
movq (%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movl %edi, %eax
shrb %al
orb %dil, %al
movl %eax, %ecx
shrb $0x2, %cl
orb %al, %cl
movl %ecx, %eax
shrb $0x4, %al
orb %cl, %al
movzbl %al, %edi
callq 0xbddd
decl %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::count_bit(unsigned 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:
movl %edi, %eax
andb $0x55, %al
shrb %dil
andb $0x55, %dil
addb %al, %dil
movl %edi, %eax
andb $0x33, %al
shrb $0x2, %dil
andb $0x33, %dil
addb %al, %dil
movl %edi, %eax
andb $0x7, %al
shrb $0x4, %dil
addb %al, %dil
movzbl %dil, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xbf27
cmpb $0x0, 0x8(%rax)
je 0xbf3a
popq %rcx
retq
leaq 0x34b62(%rip), %rdi     # 0x40aa3
leaq 0x34597(%rip), %rsi     # 0x404df
leaq 0x34b61(%rip), %rcx     # 0x40ab0
movl $0xd5, %edx
callq 0xa280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x1
popq %rsi
callq 0xbff6
movq %rax, %r14
andq $0x0, (%rax)
movb $0x1, 0x8(%rax)
leaq 0x28(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq %rbx, %rsi
callq 0xa520
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc065
leaq 0x28(%rbx), %rdi
callq 0xa798
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xa420
nop
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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 0xc0b0
leaq 0x8(%rsp), %rax
movb $0x1, 0x8(%rax)
movq %rax, -0x8(%rax)
andq $0x0, (%rax)
andq $0x0, 0x10(%rax)
movq %rsp, %rdi
callq 0xc0cc
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc0fe
movq %rsp, %rdi
callq 0xb764
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb764
movq %rbx, %rdi
callq 0xa6b0
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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 0xc141
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x18(%rsi)
callq 0xc288
movq %rbx, %rdi
popq %rbx
jmp 0xc288
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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, %rbx
movq (%rdi), %r15
leaq 0x8(%rdi), %r14
cmpq %r14, %r15
je 0xc2f7
movq %r15, %rax
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xc2b8
movq (%rax), %r15
testq %r15, %r15
jne 0xc2b8
movq 0x18(%rax), %r15
movq (%r15), %rsi
movq %r15, %r12
cmpq %rax, %rsi
je 0xc2e8
leaq 0x10(%r15), %r12
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0xc052
andq $0x0, (%r12)
jmp 0xc2b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xc439
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0xc43d
movq %r14, %rdi
callq 0xc222
movq %rax, %r15
movq %r14, %rdi
callq 0xc268
movq %rax, %r14
movq %rbx, %rdi
callq 0xc222
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xc446
movb $0x1, %al
jmp 0xc43f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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 0xc56c
movq %rsi, %r14
movq %rbx, %rdi
callq 0xc2a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc578
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::move_impl(cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&)
void move_impl(cb_tree_base&& other)
			{
				begin_node() = other.begin_node();
				root_node() = other.root_node();
				size_ = other.size_;

				other.construct_impl();

				fix_swapped();
			}

// Assembly:
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x8(%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
andq $0x0, 0x18(%rsi)
jmp 0xc288
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xed3a
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0xed8a
movq %r14, %rdi
movq %rax, %rsi
callq 0xead8
testb %al, %al
je 0xe619
xorl %eax, %eax
jmp 0xe628
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0xedaa
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_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, %r15
movq %rdi, %rbx
callq 0xeeba
movq %rax, %r14
leaq 0x8(%rbx), %rax
cmpq %rax, %r14
je 0xed7d
cmpb $0x1, 0x8(%r14)
jne 0xed7d
movq %r14, %rdi
callq 0xe992
movq %rax, %rdi
movq %r15, %rsi
callq 0xc4bb
testb %al, %al
je 0xed7d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xed8a
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::lower_bound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator lower_bound(const key_type& key)
			{
				size_type size = traits_type::size(key);
				node_pointer branch = find_branch(key, size);
				if (branch == end_node())
					return end();

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

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

				if (mismatch == branch->index())
				{
					if (size == mismatch)
					{
						if (branch->leaf())
							return iterator(branch);

						return iterator(branch->next_leaf());
					}
					else
					{
						return iterator(branch->min_leaf());
					}
				}

				if (size == mismatch)
					return iterator(branch->next_leaf());

				if (traits_type::test(derived().key(leaf->value()), mismatch))
					return iterator(branch->min_leaf());

				return iterator(branch->next_branch_leaf());
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rbx
shlq $0x4, %rbx
incq %rbx
movq %rbx, %rdx
callq 0xbb04
leaq 0x8(%r15), %rbp
cmpq %rbp, %rax
je 0x13cf8
movq %rax, %r12
movq %rax, %rdi
callq 0xbb8c
movq %rax, %r15
movq %rax, %rdi
callq 0xbc2e
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba8
movq %rax, %r13
movq (%rbp), %rax
movq %r12, %r14
cmpq %rax, %r12
je 0x13ce0
movq 0x18(%r14), %r12
cmpq 0x20(%r12), %r13
jbe 0x13ccd
cmpq 0x20(%r14), %r13
jne 0x13d06
cmpq %r13, %rbx
jne 0x13d2c
cmpb $0x1, 0x8(%r14)
jne 0x13d0b
movq %r14, (%rsp)
jmp 0x13d49
movq %r15, %rdi
callq 0x13c08
movq %rax, (%rsp)
jmp 0x13d49
cmpq %r13, %rbx
jne 0x13d15
movq %r14, %rdi
callq 0xbefe
jmp 0x13d3e
movq %r15, %rdi
callq 0xbc2e
movq %rax, %rdi
movq %r13, %rsi
callq 0xbd14
testb %al, %al
je 0x13d36
movq %r14, %rdi
callq 0xbf26
jmp 0x13d3e
movq %r14, %rdi
callq 0x14310
movq %rsp, %rdi
movq %rax, %rsi
callq 0xbc5a
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13c78
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0x13c08
movq %r15, %rdi
movq %rax, %rsi
callq 0xbe28
testb %al, %al
jne 0x13db2
leaq 0x8(%rsp), %rdi
callq 0x1432a
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc4bb
testb %al, %al
je 0x13db2
leaq 0x8(%rsp), %rdi
callq 0xbe92
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<float, cb_tree::cb_key_traits<float, void>, std::allocator<float>>, float, float, cb_tree::cb_key_traits<float, void>, std::allocator<float>>::find_branch(float 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 %r14
pushq %rbx
pushq %rax
cmpq $0x20, %rdx
jne 0x155a0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x15591
movq %rsi, %r14
movq %rax, %rbx
movq 0x20(%rax), %rdi
cmpq $0x1f, %rdi
ja 0x15595
cmpq $0x0, (%rbx)
jne 0x15573
cmpq $0x0, 0x10(%rbx)
je 0x15595
movss (%r14), %xmm0
callq 0x156d4
testb %al, %al
je 0x15587
movq 0x10(%rbx), %rax
jmp 0x1558a
movq (%rbx), %rax
testq %rax, %rax
jne 0x15559
jmp 0x15595
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2ad24(%rip), %rdi     # 0x402cb
leaq 0x2aadf(%rip), %rsi     # 0x4008d
leaq 0x2ff44(%rip), %rcx     # 0x454f9
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xa280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x156f4
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 0x30632(%rip), %rdi     # 0x45d2e
leaq 0x2b998(%rip), %rsi     # 0x4109b
leaq 0x30638(%rip), %rcx     # 0x45d42
movl $0xbb, %edx
callq 0xa280
// File: /workspace/github_cpp_makefile_star2_O2/planaria[P]cb_tree/./include/cb_tree/detail/bit_util.hpp
// Function: cb_tree::detail::msb(unsigned int)
inline int msb(std::uint32_t v)
		{
			v |= (v >> 1);
			v |= (v >> 2);
			v |= (v >> 4);
			v |= (v >> 8);
			v |= (v >> 16);

			return count_bit(v) - 1;
		}

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

// Assembly:
movl $0x55555555, %eax       # imm = 0x55555555
movl %edi, %ecx
andl %eax, %ecx
shrl %edi
andl %edi, %eax
addl %ecx, %eax
movl $0x33333333, %ecx       # imm = 0x33333333
movl %eax, %edx
andl %ecx, %edx
shrl $0x2, %eax
andl %ecx, %eax
addl %edx, %eax
movl $0x7070707, %ecx        # imm = 0x7070707
movl %eax, %edx
andl %ecx, %edx
shrl $0x4, %eax
andl %ecx, %eax
addl %edx, %eax
movl $0xf000f, %ecx          # imm = 0xF000F
movl %eax, %edx
andl %ecx, %edx
shrl $0x8, %eax
andl %ecx, %eax
addl %edx, %eax
movzwl %ax, %ecx
shrl $0x10, %eax
addl %ecx, %eax
retq