LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/./StrVec.h
// Function: StrVec::reallocate()
inline
void StrVec::reallocate()
{
	// we'll allocate space for twice as many elements as the current size
	auto newcapacity = size() ? 2 * size() : 1;

	// allocate new memory
	auto newdata = alloc.allocate(newcapacity);

	// move the data from the old memory to the new
	auto dest = newdata;  // points to the next free position in the new array
	auto elem = elements; // points to the next element in the old array
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));

	// String data move to new allocate memory
	// Vector memory store String metadata nedded to free
	free();  // free the old space once we've moved the elements

	// update our data structure to point to the new elements
	elements = newdata;
	first_free = dest;
	cap = elements + newcapacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3350
cmpq $0x0, %rax
je 0x3801
movq -0x38(%rbp), %rdi
callq 0x3350
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x380c
movl $0x1, %eax
movq %rax, -0x40(%rbp)
jmp 0x380c
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x2913(%rip), %rdi      # 0x6132
xorl %eax, %eax
movl %eax, %edx
callq 0x38e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x3350
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x389f
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
leaq 0x28a6(%rip), %rdi      # 0x6132
callq 0x3940
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x384a
movq -0x38(%rbp), %rdi
callq 0x3970
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/./StrVec.h
// Function: StrVec::free()
inline
void StrVec::free()
{
	// may not pass deallocate a 0 pointer; if elements is 0, there's no work to do
	if (elements) {
		// destroy the old elements in reverse order
		for (auto p = first_free; p != elements; /* empty */)
			alloc.destroy(--p);
		alloc.deallocate(elements, cap - elements);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x39de
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
je 0x39bd
movq -0x10(%rbp), %rsi
addq $-0x20, %rsi
movq %rsi, -0x10(%rbp)
leaq 0x277c(%rip), %rdi      # 0x6132
callq 0x3a10
jmp 0x3996
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movq (%rax), %rax
subq %rax, %rdx
sarq $0x5, %rdx
leaq 0x2759(%rip), %rdi      # 0x6132
callq 0x3a30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: willprice[P]parallel-cpp-workshop/test.cpp
// Function: main
int main(int argc, char **argv)
{
    auto a = std::vector<int>( { 1, 2, 3, 4, 5 } );
    auto b = std::vector<int>( { 6, 7, 8, 9, 10 } );

    auto result = parallel::mapReduce( std::multiplies<int>(),
                                       std::plus<int>(), 
                                       a, b );

    if (result == 130)
    {
        std::cout << "Everything is ok :-)" << std::endl;
    }
    else
    {
        std::cout << "Something went wrong? " << result << std::endl;
    }

    return 0;
}

// Assembly:
subq $0xf8, %rsp
movl $0x0, 0xf4(%rsp)
movl %edi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movups 0x49d8(%rip), %xmm0     # 0x7060
movaps %xmm0, 0xa0(%rsp)
movl $0x5, 0xb0(%rsp)
leaq 0xa0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq $0x5, 0xc8(%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2af0
movq 0x28(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
callq 0x2b00
jmp 0x26ed
leaq 0x9f(%rsp), %rdi
callq 0x2b90
movups 0x4973(%rip), %xmm0     # 0x7074
movaps %xmm0, 0x40(%rsp)
movl $0xa, 0x50(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq $0x5, 0x68(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2af0
movq 0x20(%rsp), %rcx
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x2b00
jmp 0x274b
leaq 0x3f(%rsp), %rdi
callq 0x2b90
leaq 0xd0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2ba0
movl %eax, 0x1c(%rsp)
jmp 0x276d
movl 0x1c(%rsp), %eax
movl %eax, 0x38(%rsp)
cmpl $0x82, 0x38(%rsp)
jne 0x281e
movq 0x884e(%rip), %rdi      # 0xafd8
leaq 0x48f7(%rip), %rsi      # 0x7088
callq 0x20f0
movq %rax, 0x10(%rsp)
jmp 0x279d
movq 0x10(%rsp), %rdi
movq 0x881f(%rip), %rsi      # 0xafc8
callq 0x2130
jmp 0x27b0
jmp 0x2860
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x9f(%rsp), %rdi
callq 0x2b90
jmp 0x289e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x2b90
jmp 0x2891
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x2c30
jmp 0x2891
movq 0x87b3(%rip), %rdi      # 0xafd8
leaq 0x4871(%rip), %rsi      # 0x709d
callq 0x20f0
movq %rax, 0x8(%rsp)
jmp 0x2838
movq 0x8(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x21c0
movq %rax, (%rsp)
jmp 0x284c
movq (%rsp), %rdi
movq 0x8771(%rip), %rsi      # 0xafc8
callq 0x2130
jmp 0x285e
jmp 0x2860
movl $0x0, 0xf4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x2c30
leaq 0xd0(%rsp), %rdi
callq 0x2c30
movl 0xf4(%rsp), %eax
addq $0xf8, %rsp
retq
leaq 0xd0(%rsp), %rdi
callq 0x2c30
movq 0x90(%rsp), %rdi
callq 0x21d0
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	spp::sparse_hash_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		z += ++h[get_key(n, x)];
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xb8, %rsp
movl %edi, 0xb4(%rsp)
movl %esi, 0xb0(%rsp)
movl $0x0, 0xa4(%rsp)
leaq 0x45(%rsp), %rdi
callq 0x1870
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x47(%rsp), %rdx
leaq 0x46(%rsp), %rcx
leaq 0x45(%rsp), %r8
callq 0x1880
movl $0x0, 0xac(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xac(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jae 0x17a2
movl 0xa8(%rsp), %edi
callq 0x1330
movl %eax, 0x2c(%rsp)
jmp 0x1716
movl 0x2c(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xb4(%rsp), %edi
movl 0xa8(%rsp), %esi
callq 0x13a0
movl %eax, 0x28(%rsp)
jmp 0x173a
movl 0x28(%rsp), %eax
movl %eax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x18d0
movq %rax, 0x20(%rsp)
jmp 0x1758
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0xa4(%rsp), %eax
movl %eax, 0xa4(%rsp)
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x16f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1910
jmp 0x1811
movq 0x982f(%rip), %rax      # 0xafd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1900
movq %rax, 0x18(%rsp)
jmp 0x17c2
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
movl 0xa4(%rsp), %ecx
leaq 0x48a7(%rip), %rsi      # 0x6081
xorl %eax, %eax
callq 0x1130
leaq 0x48(%rsp), %rdi
callq 0x1900
movq %rax, 0x8(%rsp)
jmp 0x17f2
movq 0x8(%rsp), %rax
movl %eax, 0x4(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1910
movl 0x4(%rsp), %eax
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11a0
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/client.cpp
// Function: path_from_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string path_from_url(const std::string &str) {
  int pos = str.find_first_of("/");
  if (pos == -1)
    return "/";
  return str.substr(pos, str.length() - pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1256c(%rip), %rsi     # 0x180e2
xorl %eax, %eax
movl %eax, %edx
callq 0x5210
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x5bcd
leaq -0x15(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x5690
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x1253e(%rip), %rsi     # 0x180e2
callq 0x54d0
jmp 0x5bab
leaq -0x15(%rbp), %rdi
callq 0x53c0
jmp 0x5c01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x53c0
jmp 0x5c0b
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5590
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
movslq -0x14(%rbp), %rax
subq %rax, %rcx
callq 0x53a0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/client.cpp
// Function: hostname_from_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string hostname_from_url(const std::string &str) {
  int pos = str.find_first_of("/");
  if (pos == -1)
    return str;
  return str.substr(0, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1249c(%rip), %rsi     # 0x180e2
xorl %eax, %eax
movl %eax, %edx
callq 0x5210
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x5c67
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x51c0
jmp 0x5c7c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x53a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/connect.hpp
// Function: asio::ip::tcp::endpoint asio::connect<asio::ip::tcp, asio::executor, asio::ip::basic_resolver_results<asio::ip::tcp>>(asio::basic_socket<asio::ip::tcp, asio::executor>&, asio::ip::basic_resolver_results<asio::ip::tcp> const&, std::enable_if<is_endpoint_sequence<asio::ip::basic_resolver_results<asio::ip::tcp>>::value, void>::type*)
typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
    const EndpointSequence& endpoints,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{
  asio::error_code ec;
  typename Protocol::endpoint result = connect(s, endpoints, ec);
  asio::detail::throw_error(ec, "connect");
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6f10
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x13190
leaq -0x30(%rbp), %rdi
leaq 0x119cb(%rip), %rsi     # 0x1862c
callq 0x8220
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: nurseiit[P]cpp-server/./include/asio/basic_streambuf.hpp
// Function: asio::basic_streambuf<std::allocator<char>>::basic_streambuf(unsigned long, std::allocator<char> const&)
explicit basic_streambuf(
      std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
      const Allocator& allocator = Allocator())
    : max_size_(maximum_size),
      buffer_(allocator)
  {
    std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
    buffer_.resize((std::max<std::size_t>)(pend, 1));
    setg(&buffer_[0], &buffer_[0], &buffer_[0]);
    setp(&buffer_[0], &buffer_[0] + pend);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x50f0
movq -0x58(%rbp), %rdi
callq 0x80d0
movq -0x58(%rbp), %rdi
leaq 0x1cb90(%rip), %rax     # 0x23848
movq %rax, (%rdi)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x40(%rdi)
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x15340
movq -0x50(%rbp), %rdi
movq $0x80, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xc110
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbb90
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0xbb00
jmp 0x6d1e
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x78(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x70(%rbp)
callq 0xb7c0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, -0x68(%rbp)
callq 0xb7c0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, -0x60(%rbp)
callq 0xb7c0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x5550
jmp 0x6d6f
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x90(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x88(%rbp)
callq 0xb7c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, -0x80(%rbp)
callq 0xb7c0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rax
addq %rax, %rdx
callq 0x55d0
jmp 0x6dbe
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xb400
movq -0x58(%rbp), %rdi
callq 0x8150
movq -0x58(%rbp), %rdi
callq 0x5730
movq -0x38(%rbp), %rdi
callq 0x5660
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/conditionally_enabled_mutex.hpp
// Function: asio::detail::conditionally_enabled_mutex::scoped_lock::scoped_lock(asio::detail::conditionally_enabled_mutex&)
explicit scoped_lock(conditionally_enabled_mutex& m)
      : mutex_(m)
    {
      if (m.enabled_)
      {
        mutex_.mutex_.lock();
        locked_ = true;
      }
      else
        locked_ = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x80d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x9b1c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x8b90
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x9b24
movq -0x18(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/op_queue.hpp
// Function: asio::detail::op_queue<asio::detail::scheduler_operation>::pop()
void pop()
  {
    if (front_)
    {
      Operation* tmp = front_;
      front_ = op_queue_access::next(front_);
      if (front_ == 0)
        back_ = 0;
      op_queue_access::next(tmp, static_cast<Operation*>(0));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0xa206
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0xa890
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0xa1f9
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa8b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/conditionally_enabled_event.hpp
// Function: asio::detail::conditionally_enabled_event::wait(asio::detail::conditionally_enabled_mutex::scoped_lock&)
void wait(conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      event_.wait(lock);
    else
      null_event().wait(lock);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x30(%rax)
je 0xa838
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xafa0
jmp 0xa876
leaq -0x11(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xb040
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb060
jmp 0xa854
leaq -0x11(%rbp), %rdi
callq 0xb080
jmp 0xa876
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xb080
jmp 0xa87c
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/posix_event.hpp
// Function: void asio::detail::posix_event::unlock_and_signal_one<asio::detail::conditionally_enabled_mutex::scoped_lock>(asio::detail::conditionally_enabled_mutex::scoped_lock&)
void unlock_and_signal_one(Lock& lock)
  {
    ASIO_ASSERT(lock.locked());
    state_ |= 1;
    bool have_waiters = (state_ > 1);
    lock.unlock();
    if (have_waiters)
      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa020
testb $0x1, %al
jne 0xa8f7
jmp 0xa8f9
jmp 0xa918
leaq 0xda1c(%rip), %rdi      # 0x1831c
leaq 0xda23(%rip), %rsi      # 0x1832a
movl $0x41, %edx
leaq 0xdab0(%rip), %rcx      # 0x183c3
callq 0x5290
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x30(%rax)
cmpq $0x1, 0x30(%rax)
seta %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa250
testb $0x1, -0x11(%rbp)
je 0xa94d
movq -0x20(%rbp), %rdi
callq 0x5030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/op_queue.hpp
// Function: asio::detail::op_queue<asio::detail::scheduler_operation>::push(asio::detail::scheduler_operation*)
void push(Operation* h)
  {
    op_queue_access::next(h, static_cast<Operation*>(0));
    if (back_)
    {
      op_queue_access::next(back_, h);
      back_ = h;
    }
    else
    {
      front_ = back_ = h;
    }
  }

// 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)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa8b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xaaaf
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xa8b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xaabe
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/op_queue.hpp
// Function: void asio::detail::op_queue<asio::detail::scheduler_operation>::push<asio::detail::scheduler_operation>(asio::detail::op_queue<asio::detail::scheduler_operation>&)
void push(op_queue<OtherOperation>& q)
  {
    if (Operation* other_front = op_queue_access::front(q))
    {
      if (back_)
        op_queue_access::next(back_, other_front);
      else
        front_ = other_front;
      back_ = op_queue_access::back(q);
      op_queue_access::front(q) = 0;
      op_queue_access::back(q) = 0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xadc0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xad6f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xad2d
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0xa8b0
jmp 0xad38
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xadd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xadc0
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0xadd0
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/posix_event.hpp
// Function: bool asio::detail::posix_event::maybe_unlock_and_signal_one<asio::detail::conditionally_enabled_mutex::scoped_lock>(asio::detail::conditionally_enabled_mutex::scoped_lock&)
bool maybe_unlock_and_signal_one(Lock& lock)
  {
    ASIO_ASSERT(lock.locked());
    state_ |= 1;
    if (state_ > 1)
    {
      lock.unlock();
      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
      return true;
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa020
testb $0x1, %al
jne 0xae67
jmp 0xae69
jmp 0xae88
leaq 0xd4ac(%rip), %rdi      # 0x1831c
leaq 0xd4b3(%rip), %rsi      # 0x1832a
movl $0x4d, %edx
leaq 0xd5be(%rip), %rcx      # 0x18441
callq 0x5290
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x30(%rax)
cmpq $0x1, 0x30(%rax)
jbe 0xaeb7
movq -0x18(%rbp), %rdi
callq 0xa250
movq -0x20(%rbp), %rdi
callq 0x5030
movb $0x1, -0x1(%rbp)
jmp 0xaebb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/posix_event.hpp
// Function: void asio::detail::posix_event::wait<asio::detail::conditionally_enabled_mutex::scoped_lock>(asio::detail::conditionally_enabled_mutex::scoped_lock&)
void wait(Lock& lock)
  {
    ASIO_ASSERT(lock.locked());
    while ((state_ & 1) == 0)
    {
      state_ += 2;
      ::pthread_cond_wait(&cond_, &lock.mutex().mutex_); // Ignore EINVAL.
      state_ -= 2;
    }
  }

// 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)
movq -0x10(%rbp), %rdi
callq 0xa020
testb $0x1, %al
jne 0xafc7
jmp 0xafc9
jmp 0xafe8
leaq 0xd34c(%rip), %rdi      # 0x1831c
leaq 0xd353(%rip), %rsi      # 0x1832a
movl $0x65, %edx
leaq 0xd550(%rip), %rcx      # 0x18533
callq 0x5290
jmp 0xafea
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xb033
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0xb0a0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x55b0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0x30(%rax)
jmp 0xafea
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/basic_streambuf.hpp
// Function: asio::basic_streambuf<std::allocator<char>>::underflow()
int_type underflow()
  {
    if (gptr() < pptr())
    {
      setg(&buffer_[0], gptr(), pptr());
      return traits_type::to_int_type(*gptr());
    }
    else
    {
      return traits_type::eof();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x5130
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x5120
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0xb517
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb7c0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x5130
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x5120
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rdi
movq %rax, %rcx
callq 0x5550
movq -0x20(%rbp), %rdi
callq 0x5130
movq %rax, %rdi
callq 0xb7e0
movl %eax, -0x4(%rbp)
jmp 0xb51f
callq 0xb800
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/basic_streambuf.hpp
// Function: asio::basic_streambuf<std::allocator<char>>::overflow(int)
int_type overflow(int_type c)
  {
    if (!traits_type::eq_int_type(c, traits_type::eof()))
    {
      if (pptr() == epptr())
      {
        std::size_t buffer_size = pptr() - gptr();
        if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
        {
          reserve(max_size_ - buffer_size);
        }
        else
        {
          reserve(buffer_delta);
        }
      }

      *pptr() = traits_type::to_char_type(c);
      pbump(1);
      return c;
    }

    return traits_type::not_eof(c);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xb800
movl %eax, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb810
xorb $-0x1, %al
testb $0x1, %al
jne 0xb567
jmp 0xb622
movq -0x28(%rbp), %rdi
callq 0x5120
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x5460
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0xb5f2
movq -0x28(%rbp), %rdi
callq 0x5120
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x5130
movq -0x28(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x40(%rcx), %rax
jae 0xb5e2
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
subq -0x20(%rbp), %rax
cmpq $0x80, %rax
jae 0xb5e2
movq -0x28(%rbp), %rdi
movq 0x40(%rdi), %rsi
subq -0x20(%rbp), %rsi
callq 0xb830
jmp 0xb5f0
movq -0x28(%rbp), %rdi
movl $0x80, %esi
callq 0xb830
jmp 0xb5f2
leaq -0x14(%rbp), %rdi
callq 0xbab0
movq -0x28(%rbp), %rdi
movb %al, -0x39(%rbp)
callq 0x5120
movb -0x39(%rbp), %cl
movq -0x28(%rbp), %rdi
movb %cl, (%rax)
movl $0x1, %esi
callq 0x5540
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb62e
leaq -0x14(%rbp), %rdi
callq 0xbac0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/thread_group.hpp
// Function: asio::detail::thread_group::join()
void join()
  {
    while (first_)
    {
      first_->thread_.join();
      item* tmp = first_;
      first_ = first_->next_;
      delete tmp;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc861
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xb1a0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc85f
movq -0x20(%rbp), %rdi
callq 0xc8a0
movq -0x20(%rbp), %rdi
callq 0x5360
jmp 0xc814
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/impl/service_registry.hpp
// Function: asio::detail::resolver_service<asio::ip::tcp>& asio::detail::service_registry::use_service<asio::detail::resolver_service<asio::ip::tcp>>(asio::io_context&)
Service& service_registry::use_service(io_context& owner)
{
  execution_context::service::key key;
  init_key<Service>(key, 0);
  factory_type factory = &service_registry::create<Service, io_context>;
  return *static_cast<Service*>(do_use_service(key, factory, &owner));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8690
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0xcc20
movq -0x30(%rbp), %rdi
leaq 0x57(%rip), %rax        # 0xcc50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x20(%rbp), %rsi
callq 0xccb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/impl/service_registry.hpp
// Function: asio::detail::scheduler& asio::detail::service_registry::use_service<asio::detail::scheduler>()
Service& service_registry::use_service()
{
  execution_context::service::key key;
  init_key<Service>(key, 0);
  factory_type factory = &service_registry::create<Service, execution_context>;
  return *static_cast<Service*>(do_use_service(key, factory, &owner_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8690
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x86b0
movq -0x28(%rbp), %rdi
leaq 0x1b(%rip), %rax        # 0xd250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x30(%rdi), %rcx
leaq -0x18(%rbp), %rsi
callq 0xccb0
addq $0x30, %rsp
popq %rbp
retq
// File: nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::impl<asio::io_context::executor_type, std::allocator<void>>::create(asio::io_context::executor_type const&, std::allocator<void>)
static impl_base* create(const Executor& e, Allocator a = Allocator())
  {
    raw_mem mem(a);
    impl* p = new (mem.ptr_) impl(e, a);
    mem.ptr_ = 0;
    return p;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x1(%rbp), %rsi
callq 0xd680
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x1(%rbp), %rdx
callq 0xd700
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd770
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::impl<asio::io_context::executor_type, std::allocator<void>>::destroy()
void destroy() ASIO_NOEXCEPT
  {
    if (--ref_count_ == 0)
    {
      allocator_type alloc(allocator_);
      impl* p = this;
      p->~impl();
      alloc.deallocate(p, 1);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
callq 0xaf10
cmpq $0x0, %rax
jne 0xd95a
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xd7b0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0xdbd0
jmp 0xd951
leaq -0x9(%rbp), %rdi
callq 0xd830
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x71c0
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::impl<asio::io_context::executor_type, std::allocator<void>>::equals(asio::executor::impl_base const*) const
bool equals(const impl_base* e) const ASIO_NOEXCEPT
  {
    if (this == e)
      return true;
    if (target_type() != e->target_type())
      return false;
    return executor_ == *static_cast<const Executor*>(e->target());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0xdaf4
movb $0x1, -0x1(%rbp)
jmp 0xdb4b
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xe720
testb $0x1, %al
jne 0xdb1e
jmp 0xdb24
movb $0x0, -0x1(%rbp)
jmp 0xdb4b
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xe750
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/io_context.hpp
// Function: void asio::io_context::executor_type::dispatch<asio::executor::function, std::allocator<void>>(asio::executor::function&&, std::allocator<void> const&) const
void io_context::executor_type::dispatch(
    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;

  // Invoke immediately if we are already inside the thread pool.
  if (io_context_.impl_.can_dispatch())
  {
    // Make a local, non-const copy of the function.
    function_type tmp(ASIO_MOVE_CAST(Function)(f));

    detail::fenced_block b(detail::fenced_block::full);
    asio_handler_invoke_helpers::invoke(tmp, tmp);
    return;
  }

  // Allocate and construct an operation to wrap the function.
  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);

  ASIO_HANDLER_CREATION((this->context(), *p.p,
        "io_context", &this->context(), 0, "dispatch"));

  io_context_.impl_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xddb0
testb $0x1, %al
jne 0xdcae
jmp 0xdd1e
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xdde0
leaq -0x21(%rbp), %rdi
xorl %esi, %esi
callq 0xde10
jmp 0xdcc8
leaq -0x20(%rbp), %rsi
movq %rsi, %rdi
callq 0xde70
jmp 0xdcd6
leaq -0x21(%rbp), %rdi
callq 0xdea0
leaq -0x20(%rbp), %rdi
callq 0xdf00
jmp 0xdd8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xdd10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xdea0
leaq -0x20(%rbp), %rdi
callq 0xdf00
jmp 0xdda6
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdf40
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdf80
jmp 0xdd52
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0xdfc0
jmp 0xdd72
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xe0a0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xe0a0
movq -0x30(%rbp), %rdi
callq 0x5660
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/call_stack.hpp
// Function: asio::detail::call_stack<asio::detail::thread_context, asio::detail::thread_info_base>::contains(asio::detail::thread_context*)
static Value* contains(Key* k)
  {
    context* elem = top_;
    while (elem)
    {
      if (elem->key_ == k)
        return elem->value_;
      elem = elem->next_;
    }
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x16326(%rip), %rdi     # 0x24409
callq 0xa0f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe11c
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xe10e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe124
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe0ec
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::function::operator()()
void operator()()
  {
    if (func_)
    {
      detail::executor_function_base* func = func_;
      func_ = 0;
      func->complete();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0xe185
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0xe190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/thread_info_base.hpp
// Function: void* asio::detail::thread_info_base::allocate<asio::detail::thread_info_base::default_tag>(asio::detail::thread_info_base::default_tag, asio::detail::thread_info_base*, unsigned long)
static void* allocate(Purpose, thread_info_base* this_thread,
      std::size_t size)
  {
    std::size_t chunks = (size + chunk_size - 1) / chunk_size;

    if (this_thread && this_thread->reusable_memory_[Purpose::mem_index])
    {
      void* const pointer = this_thread->reusable_memory_[Purpose::mem_index];
      this_thread->reusable_memory_[Purpose::mem_index] = 0;

      unsigned char* const mem = static_cast<unsigned char*>(pointer);
      if (static_cast<std::size_t>(mem[0]) >= chunks)
      {
        mem[size] = mem[0];
        return pointer;
      }

      ::operator delete(pointer);
    }

    void* const pointer = ::operator new(chunks * chunk_size + 1);
    unsigned char* const mem = static_cast<unsigned char*>(pointer);
    mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0;
    return pointer;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe2c4
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe2c4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpq -0x28(%rbp), %rax
jb 0xe2bb
movq -0x38(%rbp), %rax
movb (%rax), %dl
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe316
movq -0x30(%rbp), %rdi
callq 0x5360
movq -0x28(%rbp), %rdi
shlq $0x2, %rdi
addq $0x1, %rdi
callq 0x5390
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0xff, -0x28(%rbp)
ja 0xe2f7
movq -0x28(%rbp), %rax
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
jmp 0xe2fe
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0xe2fe
movl -0x4c(%rbp), %eax
movb %al, %dl
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: nurseiit[P]cpp-server/./include/asio/detail/executor_op.hpp
// Function: asio::detail::executor_op<asio::executor::function, std::allocator<void>, asio::detail::scheduler_operation>::do_complete(void*, asio::detail::scheduler_operation*, std::error_code const&, unsigned long)
static void do_complete(void* owner, Operation* base,
      const asio::error_code& /*ec*/,
      std::size_t /*bytes_transferred*/)
  {
    // Take ownership of the handler object.
    executor_op* o(static_cast<executor_op*>(base));
    Alloc allocator(o->allocator_);
    ptr p = { detail::addressof(allocator), o, o };

    ASIO_HANDLER_COMPLETION((*o));

    // Make a copy of the handler so that the memory can be deallocated before
    // the upcall is made. Even if we're not about to make an upcall, a
    // sub-object of the handler may be the true owner of the memory associated
    // with the handler. Consequently, a local copy of the handler is required
    // to ensure that any owning sub-object remains valid until after we have
    // deallocated the memory here.
    Handler handler(ASIO_MOVE_CAST(Handler)(o->handler_));
    p.reset();

    // Make the upcall if required.
    if (owner)
    {
      fenced_block b(fenced_block::half);
      ASIO_HANDLER_INVOCATION_BEGIN(());
      asio_handler_invoke_helpers::invoke(handler, handler);
      ASIO_HANDLER_INVOCATION_END;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x29(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
leaq -0x50(%rbp), %rdi
callq 0xdde0
leaq -0x48(%rbp), %rdi
callq 0xe440
jmp 0xe3b4
cmpq $0x0, -0x8(%rbp)
je 0xe406
leaq -0x5d(%rbp), %rdi
xorl %esi, %esi
callq 0xe4c0
jmp 0xe3c8
leaq -0x50(%rbp), %rsi
movq %rsi, %rdi
callq 0xde70
jmp 0xe3d6
leaq -0x5d(%rbp), %rdi
callq 0xdea0
jmp 0xe406
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xe41e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x5d(%rbp), %rdi
callq 0xdea0
jmp 0xe41e
leaq -0x50(%rbp), %rdi
callq 0xdf00
leaq -0x48(%rbp), %rdi
callq 0xe0a0
addq $0x60, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xdf00
leaq -0x48(%rbp), %rdi
callq 0xe0a0
movq -0x58(%rbp), %rdi
callq 0x5660
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/thread_info_base.hpp
// Function: void asio::detail::thread_info_base::deallocate<asio::detail::thread_info_base::default_tag>(asio::detail::thread_info_base::default_tag, asio::detail::thread_info_base*, void*, unsigned long)
static void deallocate(Purpose, thread_info_base* this_thread,
      void* pointer, std::size_t size)
  {
    if (size <= chunk_size * UCHAR_MAX)
    {
      if (this_thread && this_thread->reusable_memory_[Purpose::mem_index] == 0)
      {
        unsigned char* const mem = static_cast<unsigned char*>(pointer);
        mem[0] = mem[size];
        this_thread->reusable_memory_[Purpose::mem_index] = pointer;
        return;
      }
    }

    ::operator delete(pointer);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x3fc, -0x20(%rbp)     # imm = 0x3FC
ja 0xe597
cmpq $0x0, -0x10(%rbp)
je 0xe595
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xe595
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe5a0
jmp 0xe597
movq -0x18(%rbp), %rdi
callq 0x5360
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/io_context.hpp
// Function: void asio::io_context::executor_type::post<asio::executor::function, std::allocator<void>>(asio::executor::function&&, std::allocator<void> const&) const
void io_context::executor_type::post(
    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;

  // Allocate and construct an operation to wrap the function.
  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);

  ASIO_HANDLER_CREATION((this->context(), *p.p,
        "io_context", &this->context(), 0, "post"));

  io_context_.impl_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdf40
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdf80
jmp 0xe600
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0xdfc0
jmp 0xe620
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe0a0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe0a0
movq -0x38(%rbp), %rdi
callq 0x5660
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/io_context.hpp
// Function: void asio::io_context::executor_type::defer<asio::executor::function, std::allocator<void>>(asio::executor::function&&, std::allocator<void> const&) const
void io_context::executor_type::defer(
    ASIO_MOVE_ARG(Function) f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;

  // Allocate and construct an operation to wrap the function.
  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);

  ASIO_HANDLER_CREATION((this->context(), *p.p,
        "io_context", &this->context(), 0, "defer"));

  io_context_.impl_.post_immediate_completion(p.p, true);
  p.v = p.p = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdf40
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdf80
jmp 0xe6b0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0xdfc0
jmp 0xe6d3
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe0a0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe0a0
movq -0x38(%rbp), %rdi
callq 0x5660
// File: nurseiit[P]cpp-server/./include/asio/ip/basic_resolver.hpp
// Function: asio::ip::basic_resolver<asio::ip::tcp, asio::executor>::resolve(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&, asio::ip::resolver_base::flags)
results_type resolve(ASIO_STRING_VIEW_PARAM host,
      ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags)
  {
    asio::error_code ec;
    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);
    results_type r = impl_.get_service().resolve(
        impl_.get_implementation(), q, ec);
    asio::detail::throw_error(ec, "resolve");
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6f10
movq -0x18(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x51c0
movq -0x20(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x51c0
jmp 0xf1d6
movl -0x24(%rbp), %ecx
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0xf350
jmp 0xf1f5
leaq -0xe8(%rbp), %rdi
callq 0x5270
leaq -0xc8(%rbp), %rdi
callq 0x5270
movq -0x100(%rbp), %rdi
movb $0x0, -0xf5(%rbp)
callq 0xf460
movq %rax, -0x118(%rbp)
jmp 0xf229
movq -0x100(%rbp), %rdi
callq 0xf700
movq %rax, -0x120(%rbp)
jmp 0xf23e
movq -0x120(%rbp), %rdx
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdi
leaq -0xa8(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0xf480
jmp 0xf265
leaq 0x9367(%rip), %rsi      # 0x185d3
leaq -0x38(%rbp), %rdi
callq 0x8220
jmp 0xf277
movb $0x1, -0xf5(%rbp)
testb $0x1, -0xf5(%rbp)
jne 0xf30d
jmp 0xf301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0xf2bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x5270
leaq -0xc8(%rbp), %rdi
callq 0x5270
jmp 0xf335
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0xf329
movq -0x110(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
callq 0x7150
jmp 0xf329
movq -0x110(%rbp), %rdi
callq 0x7150
leaq -0xa8(%rbp), %rdi
callq 0xf720
movq -0x108(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0xa8(%rbp), %rdi
callq 0xf720
movq -0xf0(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)