LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/4shadoww[P]xwinter/xwinter.cpp
// Function: print_copyright()
void print_copyright(){
    std::cout << "xwinter " << version << std::endl;
    std::cout << R"(Copyright (C) 2019 Noa-Emil Nissinen
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.)" << std::endl;
}

// Assembly:
pushq %rbx
movq 0x463d(%rip), %rbx      # 0x6fd0
leaq 0x169e(%rip), %rsi      # 0x4038
movq %rbx, %rdi
callq 0x21a0
leaq 0x482f(%rip), %rsi      # 0x71d8
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x1681(%rip), %rsi      # 0x4041
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
popq %rbx
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/4shadoww[P]xwinter/xwinter.cpp
// Function: print_usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_usage(std::string path){
    std::cout << "usage: " + path + " [options]" << std::endl;
    std::cout << R"(Options:
  -h, --help                                  Print this message
  -v, --version                               Print version info
  -c, --count <int>                           Set particle count
  -sx, --speed-x <float>                      Set speed on X-axis
  -sy, --speed-y <float>                      Set speed on Y-axis
  -cl, --color {white|blue|red|green}         Set particle color
  -rx, --random-x <float>                     Set randomness on speed on X-axis
  -ry, --random-y <float>                     Set randomness on speed on Y-axis
  -ys, --y-spawn <int>                        Set particle spawn intensity on X-axis
  -s, --size <int>                            Set particle size
  -rs, --random-size <int>                    Set randomness to size
  -fps, --frame-rate <int>                    Set target framerate)" << std::endl;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rdx
leaq 0x1721(%rip), %rsi      # 0x412d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3481
leaq 0x1715(%rip), %rdx      # 0x4135
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3462
movq 0x459e(%rip), %rdi      # 0x6fd0
movq %rsp, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq %rsp, %rdi
callq 0x2368
leaq 0x20(%rsp), %rdi
callq 0x2368
movq 0x4575(%rip), %rdi      # 0x6fd0
leaq 0x16de(%rip), %rsi      # 0x4140
callq 0x21a0
movq %rax, %rdi
callq 0x20d0
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x2a85
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2368
leaq 0x20(%rsp), %rdi
callq 0x2368
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/server.cpp
// Function: accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)
void accept_and_run(tcp::acceptor &acceptor, asio::io_service &io_service) {
  std::shared_ptr<Session> sesh = std::make_shared<Session>(io_service);
  acceptor.async_accept(
      sesh->socket,
      [sesh, &acceptor, &io_service](const asio::error_code &accept_error) {
        accept_and_run(acceptor, io_service);
        if (!accept_error) {
          Session::start(sesh);
        }
      });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x60ca
movq (%r15), %rbp
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6594
movq %rbx, 0x10(%r12)
movq %r14, 0x18(%r12)
movq (%rbx), %r14
movq %r12, 0x8(%rsp)
movl $0x98, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x99c4
movq %rax, %r15
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0xf0(%rbp), %rcx
movl 0x8(%rbx), %esi
movzbl 0xc(%rbx), %edx
leaq 0x18(%rbx), %r8
leaq 0x268(%rip), %rax       # 0x5b90
movq %rax, (%rsp)
movq %r15, %rdi
xorl %r9d, %r9d
callq 0x99e6
leaq 0x40(%rsp), %rax
leaq 0x20(%rbx), %rsi
movaps -0x10(%rax), %xmm0
andq $0x0, -0x8(%rax)
movups %xmm0, 0x68(%r15)
andq $0x0, -0x10(%rax)
movups (%rax), %xmm0
movups %xmm0, 0x78(%r15)
movq %r15, %r12
addq $0x88, %r12
movq %r12, %rdi
callq 0x9a4c
movq 0x88(%r15), %rdi
testq %rdi, %rdi
je 0x5980
movq (%rdi), %rax
callq *(%rax)
jmp 0x5982
xorl %eax, %eax
addq $0x8, %rbx
leaq 0x58(%rsp), %r13
movq %rax, (%r13)
movb 0x90(%r15), %al
movb %al, 0x8(%r13)
movq %r13, %rdi
callq 0xb310
movq %r12, %rdi
callq 0xb310
movq (%r13), %rdi
testq %rdi, %rdi
je 0x59b9
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, 0x18(%rsp)
xorl %r8d, %r8d
cmpl $-0x1, 0xf8(%rbp)
setne %r8b
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x996a
leaq 0x10(%rsp), %rax
leaq 0x38(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x5b80
movq %rbx, %rdi
callq 0x65c8
leaq 0x28(%rsp), %rdi
callq 0x65c8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5a2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b80
leaq 0x38(%rsp), %rdi
callq 0x65c8
leaq 0x28(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/server.cpp
// Function: main
int main(int argc, const char *argv[]) {
  if (argc != 2) {
    std::cout << "Usage: " << argv[0] << " <port>\n";
    std::cout << "Examples:\n";
    std::cout << "  " << argv[0] << " 8080\n";
    return EXIT_FAILURE;
  }

  int PORT = std::atoi(argv[1]);

  asio::io_service io_service;
  tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), PORT));

  acceptor.listen();
  accept_and_run(acceptor, io_service);

  io_service.run();
  return EXIT_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x5ae8
movq 0x8(%rbx), %rdi
callq 0x5520
movl %eax, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x60e8
xorps %xmm0, %xmm0
leaq 0x4c(%rsp), %rdx
andl $0x0, 0x18(%rdx)
movups %xmm0, 0x8(%rdx)
rolw $0x8, %bx
movw $0x2, (%rdx)
movw %bx, 0x2(%rdx)
andl $0x0, 0x4(%rdx)
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x6148
leaq 0x18(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x6254
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x58ac
leaq 0x8(%rsp), %rdi
callq 0x62a4
leaq 0x18(%rsp), %rdi
callq 0x943a
leaq 0x8(%rsp), %rdi
callq 0x62e2
xorl %eax, %eax
jmp 0x5b53
movq 0x134c1(%rip), %r14     # 0x18fb0
leaq 0x952e(%rip), %rsi      # 0xf024
movq %r14, %rdi
callq 0x5360
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5360
leaq 0x951c(%rip), %rsi      # 0xf02c
movq %rax, %rdi
callq 0x5360
leaq 0x9516(%rip), %rsi      # 0xf035
movq %r14, %rdi
callq 0x5360
leaq 0x9512(%rip), %rsi      # 0xf040
movq %r14, %rdi
callq 0x5360
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5360
leaq 0x94fb(%rip), %rsi      # 0xf043
movq %rax, %rdi
callq 0x5360
pushq $0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x5b6d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x943a
leaq 0x8(%rsp), %rdi
callq 0x62e2
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
leaq 0x7(%rsp), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq %rdi, 0x8(%rax)
movq %rdi, 0x10(%rax)
leaq 0x28(%rsp), %rbx
movups 0x8(%rdi), %xmm0
andq $0x0, 0x10(%rdi)
movaps %xmm0, -0x8(%rbx)
andq $0x0, 0x8(%rdi)
movups 0x18(%rdi), %xmm0
movaps %xmm0, 0x8(%rbx)
movups 0x28(%rdi), %xmm0
movaps %xmm0, 0x18(%rbx)
movq %rax, %rdi
callq 0x5f94
testl %ebp, %ebp
je 0x5f5c
leaq 0x20(%rsp), %rdi
callq 0x5ea4
movq %rbx, %rdi
callq 0x65c8
leaq 0x8(%rsp), %rdi
callq 0x5f94
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x65c8
leaq 0x8(%rsp), %rdi
callq 0x5f94
movq %r14, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/basic_socket_acceptor.hpp
// Function: asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>::basic_socket_acceptor<asio::io_context>(asio::io_context&, asio::ip::basic_endpoint<asio::ip::tcp> const&, bool, std::enable_if<is_convertible<asio::io_context&, asio::execution_context&>::value, void>::type*)
basic_socket_acceptor(ExecutionContext& context,
      const endpoint_type& endpoint, bool reuse_addr = true,
      typename enable_if<
        is_convertible<ExecutionContext&, execution_context&>::value
      >::type* = 0)
    : impl_(context)
  {
    asio::error_code ec;
    const protocol_type protocol = endpoint.protocol();
    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
    asio::detail::throw_error(ec, "open");
    if (reuse_addr)
    {
      impl_.get_service().set_option(impl_.get_implementation(),
          socket_base::reuse_address(true), ec);
      asio::detail::throw_error(ec, "set_option");
    }
    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
    asio::detail::throw_error(ec, "bind");
    impl_.get_service().listen(impl_.get_implementation(),
        socket_base::max_listen_connections, ec);
    asio::detail::throw_error(ec, "listen");
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x81d4
leaq 0x8(%rsp), %r12
andl $0x0, (%r12)
callq 0x5240
movq %rax, 0x8(%r12)
xorl %eax, %eax
cmpw $0x2, (%r14)
setne %al
leal 0x2(,%rax,8), %eax
leaq 0x1c(%rsp), %rdx
movl %eax, (%rdx)
movq (%rbx), %rdi
leaq 0x8(%rbx), %r15
movq %r15, %rsi
movq %r12, %rcx
callq 0xe74c
leaq 0x9001(%rip), %rsi      # 0xf1a9
leaq 0x8(%rsp), %rdi
callq 0x684c
testb %bpl, %bpl
je 0x61e3
movq (%rbx), %rdi
leaq 0x18(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x8(%rsp), %rcx
movq %r15, %rsi
callq 0xe786
leaq 0x9620(%rip), %rsi      # 0xf7f9
leaq 0x8(%rsp), %rdi
callq 0x684c
movq (%rbx), %rdi
leaq 0x8(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0xe7b6
leaq 0x9607(%rip), %rsi      # 0xf804
leaq 0x8(%rsp), %rdi
callq 0x684c
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x8(%rsp), %rcx
movq %r15, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0xe7e0
leaq 0x95e2(%rip), %rsi      # 0xf809
leaq 0x8(%rsp), %rdi
callq 0x684c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6240
movq %rax, %r14
movq %rbx, %rdi
callq 0x943a
movq %r14, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
leaq 0xf0(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x6594
pushq $0xd
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0xa0b5
leaq 0x8(%rsp), %rdi
callq 0x65c8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
leaq 0x40(%rsp), %rbx
movq %rax, -0x28(%rbx)
movq (%rdx), %rax
movq %rax, -0x20(%rbx)
movb %cl, -0x18(%rbx)
andl $0x0, -0x14(%rbx)
andq $0x0, -0x10(%rbx)
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movups %xmm0, -0x8(%rbx)
andq $0x0, (%rsi)
leaq 0x8(%rsp), %r14
andl $0x0, (%r14)
callq 0x5240
movq %rax, 0x8(%r14)
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xa162
movq %rbx, %rdi
callq 0x65c8
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x65c8
movq %r14, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service_base.hpp
// Function: void asio::detail::reactive_socket_service_base::async_receive<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::detail::io_object_executor<asio::executor>>(asio::detail::reactive_socket_service_base::base_implementation_type&, asio::mutable_buffers_1 const&, int, 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::detail::io_object_executor<asio::executor> const&)
void async_receive(base_implementation_type& impl,
      const MutableBufferSequence& buffers, socket_base::message_flags flags,
      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_recv_op<
        MutableBufferSequence, 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_,
        buffers, flags, handler, io_ex);

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

    start_op(impl,
        (flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation,
        (flags & socket_base::message_out_of_band) == 0,
        ((impl.state_ & socket_ops::stream_oriented)
          && buffer_sequence_adapter<asio::mutable_buffer,
            MutableBufferSequence>::all_empty(buffers)));
    p.v = p.p = 0;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbp
movq %r8, %r14
movl %ecx, %r12d
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, 0x30(%rsp)
movl 0x14(%r8), %eax
movl %eax, 0x14(%rsp)
movq %r8, 0x18(%rsp)
movq %r8, %rdi
callq 0xa94e
movq %rax, %r15
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movl (%rbx), %esi
movzbl 0x4(%rbx), %edx
movq %rbp, (%rsp)
movq %rax, %rdi
movq %r13, %rcx
movl %r12d, %r8d
movq %r14, %r9
callq 0xa95e
xorl %r8d, %r8d
cmpl $0x0, 0x14(%rsp)
sete %r8b
movq %r15, 0x28(%rsp)
andl $0x1, %r12d
xorl %r9d, %r9d
testl %r12d, %r12d
sete %r9b
movb 0x4(%rbx), %al
shrb $0x4, %al
cmpq $0x0, 0x8(%r13)
leal (%r12,%r12), %edx
sete %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, (%rsp)
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0xa9b4
leaq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x18(%rsp), %rdi
callq 0xaa46
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xaa46
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_recv_op.hpp
// Function: asio::detail::reactive_socket_recv_op<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::detail::io_object_executor<asio::executor>>::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.
    reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
    ptr p = { asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);

    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.
    detail::binder2<Handler, asio::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = asio::detail::addressof(handler.handler_);
    p.reset();

    // Make the upcall if required.
    if (owner)
    {
      fenced_block b(fenced_block::half);
      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
      w.complete(handler, handler.handler_);
      ASIO_HANDLER_INVOCATION_END;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsi), %r12
movq %r12, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x88(%rsi), %rdx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0xac02
leaq 0x18(%r15), %rdx
addq $0x28, %r15
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0xac1c
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
callq 0xac46
testq %rbx, %rbx
je 0xaad0
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %rdx, %rsi
callq 0xac80
leaq 0x68(%rsp), %rdi
callq 0x65c8
leaq 0x20(%rsp), %rdi
callq 0xac92
leaq 0x8(%rsp), %rdi
callq 0xaa46
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xab05
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x65c8
jmp 0xab14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xac92
leaq 0x8(%rsp), %rdi
callq 0xaa46
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: void asio::executor::dispatch<asio::detail::binder2<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)>, std::error_code, unsigned long>, std::allocator<void>>(asio::detail::binder2<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)>, std::error_code, unsigned long>&&, 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r15
callq 0xadae
cmpb $0x1, 0x8(%rax)
jne 0xad28
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xadfa
jmp 0xad6d
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xae3a
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xae62
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x28(%rax)
leaq 0x8(%rsp), %rdi
callq 0x8ff0
leaq 0x38(%rsp), %rdi
callq 0x65c8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8ff0
jmp 0xad8b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::function::function<asio::detail::binder2<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)>, std::error_code, unsigned long>, std::allocator<void>>(asio::detail::binder2<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)>, std::error_code, unsigned long>, 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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movq %rdx, %rdi
callq 0xaf16
movq %rax, %r14
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x121(%rip), %rax       # 0xafb4
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xae3a
movq %r14, (%rbx)
leaq 0x8(%rsp), %rdi
andq $0x0, 0x8(%rdi)
callq 0xaf26
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xaf26
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movl 0x38(%rdi), %edi
movl 0x50(%rbx), %ecx
movb 0x3c(%rbx), %al
andb $0x10, %al
shrb $0x4, %al
leaq 0x18(%rbx), %r9
leaq 0x28(%rbx), %r14
movq %r14, (%rsp)
movzbl %al, %r8d
pushq $0x1
popq %rdx
callq 0xb186
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xb14e
testb $0x10, 0x3c(%rbx)
jne 0xb141
pushq $0x1
popq %rax
jmp 0xb14e
cmpq $0x0, (%r14)
movzbl %cl, %ecx
pushq $0x2
popq %rax
cmovnel %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %r14
movq %rsp, %rbx
pushq $0x18
popq %rdx
movq %rbx, %rdi
callq 0x5550
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5430
leaq 0x20(%r14), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5430
addq $0x40, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x5430
movq 0xd92f(%rip), %rdi      # 0x18fb0
leaq 0x4072(%rip), %rsi      # 0xf6fa
callq 0x5360
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5330
movq %rax, %rdi
callq 0x51e0
movq %rsp, %rdi
callq 0x52d0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x5550
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rsi
pushq $0x3a
popq %rdx
movq %r14, %rdi
callq 0x5600
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x50b0
addq $0x60, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xc8b8
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5220
movq %rsp, %rdi
callq 0x51c0
leaq 0x20(%rsp), %rdi
callq 0x51c0
leaq 0x40(%rsp), %rdi
callq 0x52d0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0xc3bf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51c0
leaq 0x20(%rsp), %rdi
callq 0x51c0
leaq 0x40(%rsp), %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x331b(%rip), %rsi      # 0xf70b
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5190
addq $0x60, %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xcce2
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x51c0
testq %r14, %r14
je 0xc47e
leaq 0x32e2(%rip), %rsi      # 0xf70b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5190
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xccfc
leaq 0x30(%rsp), %rdi
pushq $0x18
popq %rdx
movq %rax, %rsi
callq 0x5550
leaq 0x10(%rsp), %rdi
callq 0x51c0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5260
movl 0x10(%rsp), %ebx
leaq 0x30(%rsp), %rdi
callq 0x52d0
jmp 0xc480
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x52d0
jmp 0xc4ba
jmp 0xc4a8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0xc4b5
movq %rax, %rbx
jmp 0xc4ba
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x51c0
movq %rbx, %rdi
callq 0x55b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1b39, (%r14)         # imm = 0x1B39
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdaef
movl $0xf0, %r12d
addq (%rbx), %r12
movq (%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorl %edx, %edx
subq %rcx, %rax
cmoveq %rdx, %rcx
movslq (%r14), %rdx
cmpq %rdx, %rax
cmovaeq %rdx, %rax
leaq 0x28(%rsp), %r14
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6594
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xdb0d
leaq 0x10(%rsp), %rdi
callq 0x65c8
leaq 0x20(%rsp), %rdi
callq 0x65c8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x65c8
leaq 0x20(%rsp), %rdi
callq 0x65c8
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xd172
movq %rsp, %r14
andl $0x0, (%r14)
callq 0x5240
movq %rax, 0x8(%r14)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd192
leaq 0x38(%rsp), %rdi
callq 0xc7e2
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xc7e2
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movl %ecx, 0x20(%rdi)
cmpl $0x1, %ecx
jne 0xd1b2
xorl %ecx, %ecx
cmpl $0x0, (%rsi)
sete %cl
shll $0x10, %ecx
movq 0x10(%rax), %r8
movq 0x18(%rax), %rdx
jmp 0xd1e8
movq %rdx, %r8
movq 0x18(%rax), %rdx
addq %r8, %rdx
movq %rdx, 0x18(%rax)
movl (%rsi), %r9d
testl %r9d, %r9d
setne %cl
testq %r8, %r8
setne %dil
testl %r9d, %r9d
jne 0xd21d
orb %cl, %dil
je 0xd21d
movq 0x10(%rax), %r8
movl $0x10000, %ecx          # imm = 0x10000
cmpq %r8, %rdx
jae 0xd21d
subq $0x18, %rsp
cmpq %rdx, %r8
cmovbq %r8, %rdx
subq %rdx, %r8
addq 0x8(%rax), %rdx
cmpq %rcx, %r8
cmovaeq %rcx, %r8
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movq %r8, 0x8(%rsi)
movq %rax, %rdx
callq 0xd256
addq $0x18, %rsp
retq
addq $0x28, %rax
movq %rax, %rdi
jmp 0xd272
nop
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service_base.hpp
// Function: void asio::detail::reactive_socket_service_base::async_send<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::detail::io_object_executor<asio::executor>>(asio::detail::reactive_socket_service_base::base_implementation_type&, asio::const_buffers_1 const&, int, 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::detail::io_object_executor<asio::executor> const&)
void async_send(base_implementation_type& impl,
      const ConstBufferSequence& buffers, socket_base::message_flags flags,
      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_send_op<
        ConstBufferSequence, 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_,
        buffers, flags, handler, io_ex);

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

    start_op(impl, reactor::write_op, p.p, is_continuation, true,
        ((impl.state_ & socket_ops::stream_oriented)
          && buffer_sequence_adapter<asio::const_buffer,
            ConstBufferSequence>::all_empty(buffers)));
    p.v = p.p = 0;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r13
movq %r8, %rbp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x30(%rsp)
movl 0x20(%r8), %eax
movl %eax, 0x14(%rsp)
movq %r8, 0x18(%rsp)
movq %r8, %rdi
callq 0xd382
movq %rax, %r15
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movl (%rbx), %esi
movzbl 0x4(%rbx), %edx
movq %r13, (%rsp)
movq %rax, %rdi
movq %r12, %rcx
movl %r14d, %r8d
movq %rbp, %r9
callq 0xd392
xorl %r8d, %r8d
cmpl $0x0, 0x14(%rsp)
sete %r8b
movq %r15, 0x28(%rsp)
movb 0x4(%rbx), %al
shrb $0x4, %al
cmpq $0x0, 0x8(%r12)
sete %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, (%rsp)
pushq $0x1
popq %rdx
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
movl %edx, %r9d
callq 0xa9b4
leaq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x18(%rsp), %rdi
callq 0xd3e8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd3e8
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_send_op.hpp
// Function: asio::detail::reactive_socket_send_op<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::detail::io_object_executor<asio::executor>>::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.
    reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
    ptr p = { asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler, IoExecutor> w(o->handler_, o->io_executor_);

    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.
    detail::binder2<Handler, asio::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = asio::detail::addressof(handler.handler_);
    p.reset();

    // Make the upcall if required.
    if (owner)
    {
      fenced_block b(fenced_block::half);
      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
      w.complete(handler, handler.handler_);
      ASIO_HANDLER_INVOCATION_END;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsi), %r12
movq %r12, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xa0(%rsi), %rdx
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xd58e
leaq 0x18(%r15), %rdx
addq $0x28, %r15
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0xd5a8
movq %rsp, %rdi
movq %r14, (%rdi)
callq 0xd5d2
testq %rbx, %rbx
je 0xd46f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rdx, %rsi
callq 0xd60c
leaq 0x60(%rsp), %rdi
callq 0xc7e2
leaq 0x18(%rsp), %rdi
callq 0xd61e
movq %rsp, %rdi
callq 0xd3e8
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xd4a2
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xc7e2
jmp 0xd4b1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd61e
movq %rsp, %rdi
callq 0xd3e8
movq %rbx, %rdi
callq 0x55b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movl 0x38(%rdi), %edi
movl 0x50(%rbx), %ecx
leaq 0x18(%rbx), %r8
leaq 0x28(%rbx), %r14
pushq $0x1
popq %rdx
movq %r14, %r9
callq 0xd993
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xd98b
testb $0x10, 0x3c(%rbx)
jne 0xd97a
pushq $0x1
popq %rax
jmp 0xd98b
movq (%r14), %rax
cmpq 0x10(%rsp), %rax
movzbl %cl, %ecx
pushq $0x2
popq %rax
cmovael %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/impl/read.hpp
// Function: asio::detail::read_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)>::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_read_some(buffers_.prepare(max_size),
              ASIO_MOVE_CAST(read_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:
movq %rdi, %rax
movl %ecx, 0x20(%rdi)
cmpl $0x1, %ecx
jne 0xde30
xorl %edx, %edx
cmpl $0x0, (%rsi)
sete %dl
shll $0x10, %edx
movq 0x10(%rax), %r8
movq 0x18(%rax), %rcx
jmp 0xde60
movq 0x18(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl (%rsi), %edi
testl %edi, %edi
setne %sil
testq %rdx, %rdx
setne %dl
testl %edi, %edi
jne 0xde94
orb %sil, %dl
je 0xde94
movq 0x10(%rax), %r8
movl $0x10000, %edx          # imm = 0x10000
cmpq %r8, %rcx
jae 0xde94
subq $0x18, %rsp
cmpq %rcx, %r8
cmovbq %r8, %rcx
subq %rcx, %r8
addq 0x8(%rax), %rcx
cmpq %rdx, %r8
cmovaeq %rdx, %r8
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %r8, 0x8(%rsi)
movq %rax, %rdx
callq 0xde96
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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_perform(asio::detail::reactor_op*)
static status do_perform(reactor_op* base)
  {
    reactive_socket_accept_op_base* o(
        static_cast<reactive_socket_accept_op_base*>(base));

    socket_type new_socket = invalid_socket;
    status result = socket_ops::non_blocking_accept(o->socket_,
        o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
        o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket)
    ? done : not_done;
    o->new_socket_.reset(new_socket);

    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_accept", o->ec_));

    return result;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
orl $-0x1, (%r14)
movl 0x38(%rdi), %edi
movzbl 0x3c(%rbx), %esi
movq 0x58(%rbx), %rdx
leaq 0x60(%rbx), %rcx
testq %rdx, %rdx
cmoveq %rdx, %rcx
leaq 0x18(%rbx), %r8
movq %r14, %r9
callq 0xe56c
movzbl %al, %ebp
leaq 0x40(%rbx), %rdi
movl (%r14), %r14d
callq 0xe706
movl %r14d, 0x40(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/detail/socket_holder.hpp
// Function: asio::detail::socket_holder::reset()
void reset()
  {
    if (socket_ != invalid_socket)
    {
      asio::error_code ec;
      socket_ops::state_type state = 0;
      socket_ops::close(socket_, state, true, ec);
      socket_ = invalid_socket;
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl (%rdi), %ebp
cmpl $-0x1, %ebp
je 0xe742
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
andl $0x0, (%r14)
callq 0x5240
movq %rax, 0x8(%r14)
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
pushq $0x1
popq %rdx
movl %ebp, %edi
movq %r14, %rcx
callq 0x9617
orl $-0x1, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jahzielv[P]stingray/main.cpp
// Function: main
int main(void)
{
    std::cout << "Hello world!\n";
    DomNode *d = new DomNode(4);
    std::cout << d->getId() << std::endl;
    TextNode *tn = new TextNode("my data");
    tn->setId(5);
    std::cout << tn->getData() << "\n";
    DomNode *kid = new TextNode("child data");
    tn->addChild(kid);
    TextNode *gotChild = dynamic_cast<TextNode *>(tn->getChildren()[0]);
    std::cout << gotChild->getData() << "\n";
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0x2ca8(%rip), %rdi      # 0x4fd8
leaq 0xccd(%rip), %rsi       # 0x3004
callq 0x2100
pushq $0x28
popq %rdi
callq 0x2110
movq %rax, %rbx
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0x2634
movq %rbx, %rdi
callq 0x264e
movq 0x2c77(%rip), %rdi      # 0x4fd8
movl %eax, %esi
callq 0x2190
movq %rax, %rdi
callq 0x2080
pushq $0x48
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0xc90(%rip), %rsi       # 0x3012
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x24f2
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x2766
leaq -0x78(%rbp), %rdi
callq 0x2070
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x2652
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27ac
movq 0x2c13(%rip), %rdi      # 0x4fd8
movq %r14, %rsi
callq 0x20f0
leaq 0xc3c(%rip), %rsi       # 0x3010
movq %rax, %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2070
pushq $0x48
popq %rdi
callq 0x2110
movq %rax, %r15
leaq 0xc23(%rip), %rsi       # 0x301a
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x24f2
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x2766
leaq -0x58(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2656
movq %r14, %rdi
movq %rbx, %rsi
callq 0x266c
movq (%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2454
leaq 0x290f(%rip), %rsi      # 0x4d50
leaq 0x28d0(%rip), %rdx      # 0x4d18
xorl %ecx, %ecx
callq 0x2130
movq %rax, %rbx
jmp 0x2456
xorl %ebx, %ebx
leaq -0x38(%rbp), %rdi
callq 0x25da
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27ac
movq 0x2b67(%rip), %rdi      # 0x4fd8
movq %r14, %rsi
callq 0x20f0
leaq 0xb90(%rip), %rsi       # 0x3010
movq %rax, %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x2070
jmp 0x24af
movq %rax, %r14
pushq $0x48
popq %rsi
movq %r15, %rdi
jmp 0x24d5
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2070
jmp 0x24c8
movq %rax, %r14
pushq $0x48
jmp 0x24d1
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x2120
jmp 0x24ea
jmp 0x24de
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2070
movq %r14, %rdi
callq 0x21a0