LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nurseiit[P]cpp-server/./include/asio/basic_socket_acceptor.hpp
// Function: void asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>::initiate_async_accept::operator()<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, asio::ip::tcp, asio::executor>(accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0&&, asio::basic_socket<asio::ip::tcp, asio::executor>*, asio::ip::basic_endpoint<asio::ip::tcp>*) const
void operator()(ASIO_MOVE_ARG(AcceptHandler) handler,
        basic_socket<Protocol1, Executor1>* peer,
        endpoint_type* peer_endpoint) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a AcceptHandler.
      ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;

      detail::non_const_lvalue<AcceptHandler> handler2(handler);
      self_->impl_.get_service().async_accept(
          self_->impl_.get_implementation(), *peer, peer_endpoint,
          handler2.value, self_->impl_.get_implementation_executor());
    }

// 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 -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6fc0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x12b40
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
callq 0x12b60
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x12b80
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq %rax, %r9
callq 0x6fe0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service.hpp
// Function: void asio::detail::reactive_socket_service<asio::ip::tcp>::async_accept<asio::basic_socket<asio::ip::tcp, asio::executor>, accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, asio::detail::io_object_executor<asio::executor>>(asio::detail::reactive_socket_service<asio::ip::tcp>::implementation_type&, asio::basic_socket<asio::ip::tcp, asio::executor>&, asio::ip::basic_endpoint<asio::ip::tcp>*, accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0&, asio::detail::io_object_executor<asio::executor> const&)
void async_accept(implementation_type& impl, Socket& peer,
      endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex)
  {
    bool is_continuation =
      asio_handler_cont_helpers::is_continuation(handler);

    // Allocate and construct an operation to wrap the handler.
    typedef reactive_socket_accept_op<Socket, Protocol, Handler, IoExecutor> op;
    typename op::ptr p = { asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, impl.state_, peer,
        impl.protocol_, peer_endpoint, handler, io_ex);

    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
          &impl, impl.socket_, "async_accept"));

    start_accept_op(impl, p.p, is_continuation, peer.is_open());
    p.v = p.p = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7120
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7140
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %r8
movl (%r8), %esi
movzbl 0x4(%r8), %edx
movq -0x18(%rbp), %rcx
addq $0x10, %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x30(%rbp), %r11
movq %rsp, %rax
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x7190
jmp 0x706d
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x40(%rbp)
addq $0x28, %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x72(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12c30
movb %al, -0x71(%rbp)
jmp 0x70ab
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdi
movb -0x71(%rbp), %al
movb -0x72(%rbp), %cl
movzbl %cl, %ecx
andl $0x1, %ecx
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x12ba0
jmp 0x70d8
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7230
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7230
movq -0x58(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/io_object_executor.hpp
// Function: void asio::detail::io_object_executor<asio::executor>::dispatch<asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>, std::allocator<void>>(asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>&&, std::allocator<void> const&) const
void dispatch(ASIO_MOVE_ARG(F) f, const A& a) const
  {
    if (is_same<Executor, io_context::executor_type>::value
        || has_native_impl_)
    {
      // When using a native implementation, I/O completion handlers are
      // already dispatched according to the execution context's executor's
      // rules. We can call the function directly.
#if defined(ASIO_HAS_MOVE)
      if (is_same<F, typename decay<F>::type>::value)
      {
        asio_handler_invoke_helpers::invoke(f, f);
        return;
      }
#endif // defined(ASIO_HAS_MOVE)
      typename decay<F>::type function(ASIO_MOVE_CAST(F)(f));
      asio_handler_invoke_helpers::invoke(function, function);
    }
    else
    {
      executor_.dispatch(ASIO_MOVE_CAST(F)(f), a);
    }
  }

// 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)
testb $0x1, 0x8(%rax)
je 0x7921
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7940
jmp 0x7932
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7970
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: void asio::executor::dispatch<asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>, std::allocator<void>>(asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>&&, std::allocator<void> const&) const
void executor::dispatch(ASIO_MOVE_ARG(Function) f,
    const Allocator& a) const
{
  impl_base* i = get_impl();
  if (i->fast_dispatch_)
    system_executor().dispatch(ASIO_MOVE_CAST(Function)(f), a);
  else
    i->dispatch(function(ASIO_MOVE_CAST(Function)(f), a));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16820
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x79b4
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x21(%rbp), %rdi
callq 0x7b80
jmp 0x7a35
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7be0
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7c20
jmp 0x79e0
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x30(%rbp), %rsi
callq *%rax
jmp 0x79f3
leaq -0x30(%rbp), %rdi
callq 0x112a0
leaq -0x60(%rbp), %rdi
callq 0x7720
jmp 0x7a35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7a2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x112a0
leaq -0x60(%rbp), %rdi
callq 0x7720
jmp 0x7a3e
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::function::function<asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>, std::allocator<void>>(asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>, std::allocator<void> const&)
explicit function(F f, const Alloc& a)
  {
    // Allocate and construct an operation to wrap the function.
    typedef detail::executor_function<F, Alloc> func_type;
    typename func_type::ptr p = {
      detail::addressof(a), func_type::ptr::allocate(a), 0 };
    func_ = new (p.v) func_type(ASIO_MOVE_CAST(F)(f), a);
    p.v = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7cc0
movq -0x50(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rdx
callq 0x7d00
jmp 0x7c74
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7d60
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7d60
movq -0x38(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/executor_function.hpp
// Function: asio::detail::executor_function<asio::detail::binder1<accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)::$_0, std::error_code>, std::allocator<void>>::do_complete(asio::detail::executor_function_base*, bool)
static void do_complete(executor_function_base* base, bool call)
  {
    // Take ownership of the function object.
    executor_function* o(static_cast<executor_function*>(base));
    Alloc allocator(o->allocator_);
    ptr p = { detail::addressof(allocator), o, o };

    // Make a copy of the function 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 function may be the true owner of the memory
    // associated with the function. Consequently, a local copy of the function
    // is required to ensure that any owning sub-object remains valid until
    // after we have deallocated the memory here.
    Function function(ASIO_MOVE_CAST(Function)(o->function_));
    p.reset();

    // Make the upcall if required.
    if (call)
    {
      function();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x19(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x68(%rbp), %rdi
callq 0x7be0
jmp 0x7e2a
leaq -0x38(%rbp), %rdi
callq 0x7ea0
jmp 0x7e35
testb $0x1, -0x9(%rbp)
je 0x7e6d
leaq -0x68(%rbp), %rdi
callq 0x7ad0
jmp 0x7e46
jmp 0x7e6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7e88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7720
jmp 0x7e88
leaq -0x68(%rbp), %rdi
callq 0x7720
leaq -0x38(%rbp), %rdi
callq 0x7d60
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x7d60
movq -0x70(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_accept_op.hpp
// Function: asio::detail::reactive_socket_accept_op_base<asio::basic_socket<asio::ip::tcp, asio::executor>, asio::ip::tcp>::do_assign()
void do_assign()
  {
    if (new_socket_.get() != invalid_socket)
    {
      if (peer_endpoint_)
        peer_endpoint_->resize(addrlen_);
      peer_.assign(protocol_, new_socket_.get(), ec_);
      if (!ec_)
        new_socket_.release();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x40, %rdi
callq 0x12ea0
cmpl $-0x1, %eax
je 0x12e91
movq -0x28(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x12e2e
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rdi
movq 0x60(%rax), %rsi
callq 0x12eb0
movq -0x28(%rbp), %rdi
movq 0x48(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rdi, %rax
addq $0x50, %rax
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
callq 0x12ea0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl %eax, -0xc(%rbp)
addq $0x18, %rcx
leaq -0xc(%rbp), %rdx
callq 0x12ee0
movq -0x28(%rbp), %rdi
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x18, %rdi
callq 0x9930
testb $0x1, %al
jne 0x12e8f
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x12f50
jmp 0x12e91
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: Session::read_first_line(std::shared_ptr<Session>)
static void read_first_line(std::shared_ptr<Session> ptr) {
    asio::async_read_until(ptr->socket, ptr->buf, '\r',
                           [ptr](const asio::error_code &e, std::size_t s) {
                             std::string line, _;
                             std::istream stream{&ptr->buf};
                             std::getline(stream, line, '\r');
                             std::getline(stream, _, '\n');
                             ptr->headers.read_request_line(line);
                             ptr->read_next_line(ptr);
                           });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x8100
movq -0x48(%rbp), %rdi
addq $0xf0, %rax
movq %rax, -0x40(%rbp)
callq 0x8100
movq -0x48(%rbp), %rsi
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl $0xd, %edx
callq 0x13c20
jmp 0x13be5
leaq -0x18(%rbp), %rdi
callq 0x13c70
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13c70
movq -0x20(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/read_until.hpp
// Function: void asio::detail::initiate_async_read_until_delim_v1<asio::basic_stream_socket<asio::ip::tcp, asio::executor>>::operator()<Session::read_first_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long), asio::basic_streambuf_ref<std::allocator<char>>>(Session::read_first_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)&&, asio::basic_streambuf_ref<std::allocator<char>>&&, char) const
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
        ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
        char delim) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a ReadHandler.
      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

      non_const_lvalue<ReadHandler> handler2(handler);
      read_until_delim_op_v1<AsyncReadStream,
        typename decay<DynamicBuffer_v1>::type,
          typename decay<ReadHandler>::type>(
            stream_, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
            delim, handler2.value)(asio::error_code(), 0, 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x13e60
movq -0x90(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movsbl -0x19(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x13e80
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xadf0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x13ef0
jmp 0x13e22
leaq -0x58(%rbp), %rdi
callq 0x142e0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x142e0
movq -0x70(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/basic_stream_socket.hpp
// Function: void asio::basic_stream_socket<asio::ip::tcp, asio::executor>::initiate_async_receive::operator()<asio::detail::read_until_delim_op_v1<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::basic_streambuf_ref<std::allocator<char>>, Session::read_first_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)>, asio::mutable_buffers_1>(asio::detail::read_until_delim_op_v1<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::basic_streambuf_ref<std::allocator<char>>, Session::read_first_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)>&&, asio::mutable_buffers_1 const&, int) const
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
        const MutableBufferSequence& buffers,
        socket_base::message_flags flags) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a ReadHandler.
      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

      detail::non_const_lvalue<ReadHandler> handler2(handler);
      self_->impl_.get_service().async_receive(
          self_->impl_.get_implementation(), buffers, flags,
          handler2.value, self_->impl_.get_implementation_executor());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x15890
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x12b40
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq $0x28, %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
callq 0x12b60
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x12b80
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %r8
movq %rax, %r9
callq 0x158b0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/executor.hpp
// Function: asio::executor::get_impl() const
impl_base* get_impl() const
  {
    if (!impl_)
    {
      bad_executor ex;
      asio::detail::throw_exception(ex);
    }
    return impl_;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x16874
leaq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x169f0
movq -0x30(%rbp), %rdi
callq 0x16a30
jmp 0x16852
leaq -0x10(%rbp), %rdi
callq 0x16a70
jmp 0x16874
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x16a70
jmp 0x16881
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_recv_op.hpp
// Function: asio::detail::reactive_socket_recv_op_base<asio::mutable_buffers_1>::do_perform(asio::detail::reactor_op*)
static status do_perform(reactor_op* base)
  {
    reactive_socket_recv_op_base* o(
        static_cast<reactive_socket_recv_op_base*>(base));

    buffer_sequence_adapter<asio::mutable_buffer,
        MutableBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_recv(o->socket_,
        bufs.buffers(), bufs.count(), o->flags_,
        (o->state_ & socket_ops::stream_oriented) != 0,
        o->ec_, o->bytes_transferred_) ? done : not_done;

    if (result == done)
      if ((o->state_ & socket_ops::stream_oriented) != 0)
        if (o->bytes_transferred_ == 0)
          result = done_and_exhausted;

    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recv",
          o->ec_, o->bytes_transferred_));

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
leaq -0x28(%rbp), %rdi
callq 0x17180
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x17320
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x17330
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x3c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
movq -0x10(%rbp), %r9
addq $0x18, %r9
movq -0x10(%rbp), %r10
addq $0x28, %r10
movq %rsp, %r8
movq %r10, (%r8)
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x171d0
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x17118
movq -0x10(%rbp), %rax
movzbl 0x3c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x17116
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x17114
movl $0x2, -0x2c(%rbp)
jmp 0x17116
jmp 0x17118
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: Headers::read_request_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void read_request_line(std::string line) {
    std::stringstream request_stream(line);
    request_stream >> method;
    request_stream >> url;
    request_stream >> version;

    std::cout << "🙈 Requested: " << url << std::endl;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x17e80
movq -0x1c0(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x6680
movq -0x1b8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
callq 0x64f0
jmp 0x17d25
movq -0x1b0(%rbp), %rsi
addq $0x20, %rsi
leaq -0x198(%rbp), %rdi
callq 0x64f0
jmp 0x17d3e
movq -0x1b0(%rbp), %rsi
addq $0x40, %rsi
leaq -0x198(%rbp), %rdi
callq 0x64f0
jmp 0x17d57
movq 0x1d26a(%rip), %rdi     # 0x34fc8
leaq 0xb9c4(%rip), %rsi      # 0x23729
callq 0x6400
movq %rax, -0x1c8(%rbp)
jmp 0x17d73
movq -0x1c8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
addq $0x20, %rsi
callq 0x63c0
movq %rax, -0x1d0(%rbp)
jmp 0x17d93
movq -0x1d0(%rbp), %rdi
movq 0x1d1ef(%rip), %rsi     # 0x34f90
callq 0x6440
jmp 0x17da8
leaq -0x198(%rbp), %rdi
callq 0x6350
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x6350
movq -0x1a0(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: Session::read_next_line(std::shared_ptr<Session>)
static void read_next_line(std::shared_ptr<Session> ptr) {
    asio::async_read_until(
        ptr->socket, ptr->buf, '\r',
        [ptr](const asio::error_code &e, std::size_t s) {
          std::string line, _;
          std::istream stream{&ptr->buf};
          std::getline(stream, line, '\r');
          std::getline(stream, _, '\n');
          ptr->headers.read_header(line);

          if (line.length() == 0) {
            if (ptr->headers.content_length() == 0) {
              std::shared_ptr<std::string> str =
                  std::make_shared<std::string>(ptr->headers.get_response());
              asio::async_write(
                  ptr->socket, asio::buffer(str->c_str(), str->length()),
                  [ptr, str](const asio::error_code &e, std::size_t s) {
                    std::cout << "👌 done" << std::endl;
                  });
            } else {
              ptr->read_body(ptr);
            }
          } else {
            ptr->read_next_line(ptr);
          }
        });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x8100
movq -0x48(%rbp), %rdi
addq $0xf0, %rax
movq %rax, -0x40(%rbp)
callq 0x8100
movq -0x48(%rbp), %rsi
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl $0xd, %edx
callq 0x17ea0
jmp 0x17e45
leaq -0x18(%rbp), %rdi
callq 0x17ef0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x17ef0
movq -0x20(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: Headers::read_header(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void read_header(std::string line) {
    std::stringstream header_stream(line);
    std::string header_name;
    std::getline(header_stream, header_name, ':');

    std::string header_value;
    std::getline(header_stream, header_value);
    headers_map[header_name] = header_value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rsi, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x208(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x17e80
movq -0x200(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x6680
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x6570
movq -0x1f8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
movl $0x3a, %edx
callq 0x6780
jmp 0x19d2d
leaq -0x1e8(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x6570
movq -0x210(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x60e0
jmp 0x19d55
movq -0x208(%rbp), %rdi
addq $0x60, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1a770
movq %rax, -0x218(%rbp)
jmp 0x19d75
movq -0x218(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x6050
jmp 0x19d8a
leaq -0x1e8(%rbp), %rdi
callq 0x62e0
leaq -0x1b8(%rbp), %rdi
callq 0x62e0
leaq -0x198(%rbp), %rdi
callq 0x6350
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x19de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x62e0
leaq -0x1b8(%rbp), %rdi
callq 0x62e0
leaq -0x198(%rbp), %rdi
callq 0x6350
movq -0x1c0(%rbp), %rdi
callq 0x6700
nopl (%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: Headers::content_length()
int content_length() {
    if (headers_map.count("content-length")) {
      std::stringstream content_length_stream(headers_map["content-length"]);
      int content_length;
      content_length_stream >> content_length;
      return content_length;
    }
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
addq $0x60, %rax
movq %rax, -0x208(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x6730
movq -0x200(%rbp), %rdx
leaq 0x98e7(%rip), %rsi      # 0x2373a
leaq -0x30(%rbp), %rdi
callq 0x6550
jmp 0x19e5e
movq -0x208(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1b820
movq %rax, -0x218(%rbp)
jmp 0x19e77
leaq -0x30(%rbp), %rdi
callq 0x62e0
leaq -0x31(%rbp), %rdi
callq 0x6450
movq -0x218(%rbp), %rax
cmpq $0x0, %rax
je 0x19fe0
movq -0x210(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x228(%rbp)
leaq -0x1f1(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x6730
movq -0x220(%rbp), %rdx
leaq 0x986d(%rip), %rsi      # 0x2373a
leaq -0x1f0(%rbp), %rdi
callq 0x6550
jmp 0x19edb
movq -0x228(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x1b880
movq %rax, -0x230(%rbp)
jmp 0x19ef7
movl $0x10, %edi
movl $0x8, %esi
callq 0x17e80
movq -0x230(%rbp), %rsi
movl %eax, %edx
leaq -0x1d0(%rbp), %rdi
callq 0x6680
jmp 0x19f1d
leaq -0x1f0(%rbp), %rdi
callq 0x62e0
leaq -0x1f1(%rbp), %rdi
callq 0x6450
leaq -0x1d0(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x62d0
jmp 0x19f4a
movl -0x1f8(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x6350
jmp 0x19fe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x19f87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x62e0
leaq -0x31(%rbp), %rdi
callq 0x6450
jmp 0x19ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x19fb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x62e0
leaq -0x1f1(%rbp), %rdi
callq 0x6450
jmp 0x19ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x6350
jmp 0x19ff3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6700
nopl (%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: Session::read_body(std::shared_ptr<Session>)
static void read_body(std::shared_ptr<Session> ptr) {
    int nbuffer = 6969;
    std::shared_ptr<std::vector<char>> bufptr =
        std::make_shared<std::vector<char>>(nbuffer);
    asio::async_read(ptr->socket, asio::buffer(*bufptr, nbuffer),
                     [ptr](const asio::error_code &e, std::size_t s) {});
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1b39, -0xc(%rbp)     # imm = 0x1B39
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x1eb70
movq -0x68(%rbp), %rdi
callq 0x8100
movq -0x70(%rbp), %rdi
addq $0xf0, %rax
movq %rax, -0x60(%rbp)
callq 0x1ecd0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x1ec40
movq -0x68(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8120
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x30(%rbp), %rsi
callq 0x1ebe0
jmp 0x1a730
leaq -0x40(%rbp), %rdi
callq 0x1ed00
leaq -0x20(%rbp), %rdi
callq 0x1ed20
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1ed00
leaq -0x20(%rbp), %rdi
callq 0x1ed20
movq -0x48(%rbp), %rdi
callq 0x6700
nop
// File: nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: void asio::detail::initiate_async_write_buffer_sequence<asio::basic_stream_socket<asio::ip::tcp, asio::executor>>::operator()<Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long), asio::const_buffers_1, asio::detail::transfer_all_t>(Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)&&, asio::const_buffers_1 const&, asio::detail::transfer_all_t&&) const
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
        const ConstBufferSequence& buffers,
        ASIO_MOVE_ARG(CompletionCondition) completion_cond) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a WriteHandler.
      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;

      non_const_lvalue<WriteHandler> handler2(handler);
      non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);
      start_write_buffer_sequence_op(stream_, buffers,
          asio::buffer_sequence_begin(buffers),
          completion_cond2.value, handler2.value);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1cc90
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1ccb0
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14bc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdx
callq 0x1ccd0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: void asio::detail::start_write_buffer_sequence_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>(asio::basic_stream_socket<asio::ip::tcp, asio::executor>&, asio::const_buffers_1 const&, asio::const_buffer const* const&, asio::detail::transfer_all_t&, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)&)
inline void start_write_buffer_sequence_op(AsyncWriteStream& stream,
      const ConstBufferSequence& buffers, const ConstBufferIterator&,
      CompletionCondition& completion_condition, WriteHandler& handler)
  {
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>(
        stream, buffers, completion_condition, handler)(
          asio::error_code(), 0, 1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1cd80
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xadf0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x1cde0
jmp 0x1cd3d
leaq -0x70(%rbp), %rdi
callq 0x1cf10
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1cf10
movq -0x88(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>::operator()(std::error_code const&, unsigned long, int)
void operator()(const asio::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, buffers_.total_consumed());
        do
        {
          stream_.async_write_some(buffers_.prepare(max_size),
              ASIO_MOVE_CAST(write_op)(*this));
          return; default:
          buffers_.consume(bytes_transferred);
          if ((!ec && bytes_transferred == 0) || buffers_.empty())
            break;
          max_size = this->check_for_completion(ec, buffers_.total_consumed());
        } while (max_size > 0);

        handler_(ec, buffers_.total_consumed());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, 0x20(%rcx)
subl $0x1, %eax
jne 0x1ce6d
jmp 0x1ce0c
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x1d0a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1d070
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x50(%rbp)
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x1d110
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x1d0c0
jmp 0x1cf07
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x1d160
movq -0x10(%rbp), %rdi
callq 0x9930
testb $0x1, %al
jne 0x1ce92
cmpq $0x0, -0x18(%rbp)
je 0x1cea5
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d180
testb $0x1, %al
jne 0x1cea5
jmp 0x1cea7
jmp 0x1ced7
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x1d0a0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x1d070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
ja 0x1ce31
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x1d0a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x1d1c0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/basic_stream_socket.hpp
// Function: void asio::basic_stream_socket<asio::ip::tcp, asio::executor>::initiate_async_send::operator()<asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>, asio::const_buffers_1>(asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>&&, asio::const_buffers_1 const&, int) const
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
        const ConstBufferSequence& buffers,
        socket_base::message_flags flags) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a WriteHandler.
      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;

      detail::non_const_lvalue<WriteHandler> handler2(handler);
      self_->impl_.get_service().async_send(
          self_->impl_.get_implementation(), buffers, flags,
          handler2.value, self_->impl_.get_implementation_executor());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1d380
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x12b40
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq $0x28, %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
callq 0x12b60
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x12b80
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %r8
movq %rax, %r9
callq 0x1d3a0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_send_op.hpp
// Function: asio::detail::reactive_socket_send_op_base<asio::const_buffers_1>::do_perform(asio::detail::reactor_op*)
static status do_perform(reactor_op* base)
  {
    reactive_socket_send_op_base* o(
        static_cast<reactive_socket_send_op_base*>(base));

    buffer_sequence_adapter<asio::const_buffer,
        ConstBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_send(o->socket_,
          bufs.buffers(), bufs.count(), o->flags_,
          o->ec_, o->bytes_transferred_) ? done : not_done;

    if (result == done)
      if ((o->state_ & socket_ops::stream_oriented) != 0)
        if (o->bytes_transferred_ < bufs.total_size())
          result = done_and_exhausted;

    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_send",
          o->ec_, o->bytes_transferred_));

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e6e0
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1e860
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1e870
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x10(%rbp), %r8
addq $0x18, %r8
movq -0x10(%rbp), %r9
addq $0x28, %r9
callq 0x1e730
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x1e6cf
movq -0x10(%rbp), %rax
movzbl 0x3c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1e6cd
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1e880
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e6cb
movl $0x2, -0x2c(%rbp)
jmp 0x1e6cd
jmp 0x1e6cf
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/buffer.hpp
// Function: asio::mutable_buffers_1 asio::buffer<char, std::allocator<char>>(std::vector<char, std::allocator<char>>&, unsigned long)
inline ASIO_MUTABLE_BUFFER buffer(std::vector<PodType, Allocator>& data,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , detail::buffer_debug_check<
          typename std::vector<PodType, Allocator>::iterator
        >(data.begin())
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xde50
cmpq $0x0, %rax
je 0x1ec72
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdb60
movq %rax, -0x28(%rbp)
jmp 0x1ec7a
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x1ec7a
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xde50
shlq $0x0, %rax
cmpq -0x20(%rbp), %rax
jae 0x1eca8
movq -0x18(%rbp), %rdi
callq 0xde50
shlq $0x0, %rax
movq %rax, -0x38(%rbp)
jmp 0x1ecb0
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x21280
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nop
// File: nurseiit[P]cpp-server/./include/asio/impl/read.hpp
// Function: void asio::detail::initiate_async_read_buffer_sequence<asio::basic_stream_socket<asio::ip::tcp, asio::executor>>::operator()<Session::read_body(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long), asio::mutable_buffers_1, asio::detail::transfer_all_t>(Session::read_body(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)&&, asio::mutable_buffers_1 const&, asio::detail::transfer_all_t&&) const
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
        const MutableBufferSequence& buffers,
        ASIO_MOVE_ARG(CompletionCondition) completion_cond) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a ReadHandler.
      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

      non_const_lvalue<ReadHandler> handler2(handler);
      non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);
      start_read_buffer_sequence_op(stream_, buffers,
          asio::buffer_sequence_begin(buffers),
          completion_cond2.value, handler2.value);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1f9e0
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1ccb0
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1faa0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdx
callq 0x1fa00
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/read.hpp
// Function: void asio::detail::start_read_buffer_sequence_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::mutable_buffers_1, asio::mutable_buffer const*, asio::detail::transfer_all_t, Session::read_body(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)>(asio::basic_stream_socket<asio::ip::tcp, asio::executor>&, asio::mutable_buffers_1 const&, asio::mutable_buffer const* const&, asio::detail::transfer_all_t&, Session::read_body(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)&)
inline void start_read_buffer_sequence_op(AsyncReadStream& stream,
      const MutableBufferSequence& buffers, const MutableBufferIterator&,
      CompletionCondition& completion_condition, ReadHandler& handler)
  {
    detail::read_op<AsyncReadStream, MutableBufferSequence,
      MutableBufferIterator, CompletionCondition, ReadHandler>(
        stream, buffers, completion_condition, handler)(
          asio::error_code(), 0, 1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1fac0
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xadf0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x1fb20
jmp 0x1fa6d
leaq -0x60(%rbp), %rdi
callq 0x1fc50
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1fc50
movq -0x78(%rbp), %rdi
callq 0x6700
nopl (%rax)