LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nurseiit[P]cpp-server/./include/asio/detail/executor_function.hpp
// Function: asio::detail::executor_function<asio::detail::binder2<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)>, std::error_code, unsigned long>, 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 %rbx
subq $0x80, %rsp
movl %esi, %ebx
movq %rdi, %rax
leaq 0x7(%rsp), %rcx
leaq 0x68(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x28(%rax), %ecx
movl %ecx, 0x28(%rsp)
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x38(%rsp)
movq 0x38(%rax), %rdx
movq %rcx, 0x38(%rax)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rax)
movq 0x40(%rax), %rdx
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x48(%rax), %rdx
movq %rcx, 0x48(%rax)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rax)
movups 0x50(%rax), %xmm0
movups %xmm0, 0x50(%rsp)
movq 0x60(%rax), %rax
movq %rax, 0x60(%rsp)
callq 0xf592
testb %bl, %bl
je 0xf538
leaq 0x50(%rsp), %rsi
movq 0x10(%rsi), %rdx
leaq 0x8(%rsp), %rdi
xorl %ecx, %ecx
callq 0xeb8c
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xf547
callq 0x7026
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xf556
callq 0x7026
leaq 0x68(%rsp), %rdi
callq 0xf592
addq $0x80, %rsp
popq %rbx
retq
jmp 0xf58a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf108
leaq 0x68(%rsp), %rdi
callq 0xf592
movq %rbx, %rdi
callq 0x55d0
movq %rax, %rdi
callq 0x6e80
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $-0x1, 0x40(%rdi)
je 0xac02
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0xabce
movq 0x60(%rbx), %rsi
callq 0xac04
movq 0x48(%rbx), %rsi
leaq 0x50(%rbx), %rdx
movl 0x40(%rbx), %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x18(%rbx), %r8
movq (%rsi), %rdi
addq $0x8, %rsi
callq 0xac68
cmpl $0x0, 0x18(%rbx)
jne 0xabfd
movl $0xffffffff, 0x40(%rbx) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rsp), %rbx
movq %rax, (%rbx)
movq (%rdx), %rax
movq %rax, 0x8(%rbx)
movb %cl, 0x10(%rbx)
xorl %eax, %eax
movl %eax, 0x14(%rbx)
movq %rax, 0x18(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq 0x8(%rsi), %rcx
movq %rax, 0x8(%rsi)
movq %rcx, 0x28(%rbx)
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movl %eax, (%r14)
callq 0x5220
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xb2e4
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xb2c1
callq 0x7026
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xb2db
callq 0x7026
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: void asio::executor::dispatch<asio::detail::binder2<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)>, std::error_code, unsigned long>, std::allocator<void>>(asio::detail::binder2<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)>, 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 %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %r15
callq 0xc17c
cmpb $0x1, 0x8(%rax)
jne 0xf20f
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xf304
jmp 0xf2c7
movq %rax, %r14
movq (%r15), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsi)
movl 0x20(%r15), %eax
movl %eax, 0x20(%rsi)
movq 0x28(%r15), %rax
movq %rax, 0x28(%rsi)
xorl %eax, %eax
movq %rax, 0x30(%rsi)
movq 0x30(%r15), %rcx
movq %rax, 0x30(%r15)
movq %rcx, 0x30(%rsi)
movq %rax, 0x28(%r15)
movq 0x38(%r15), %rcx
movq %rcx, 0x38(%rsi)
movq %rax, 0x40(%rsi)
movq 0x40(%r15), %rcx
movq %rax, 0x40(%r15)
movq %rcx, 0x40(%rsi)
movq %rax, 0x38(%r15)
movups 0x48(%r15), %xmm0
movups %xmm0, 0x48(%rsi)
movq 0x58(%r15), %rax
movq %rax, 0x58(%rsi)
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xf3b8
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf2a9
xorl %esi, %esi
callq *(%rdi)
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xf2b8
callq 0x7026
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xf2c7
callq 0x7026
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf2e6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf2f1
xorl %esi, %esi
callq *(%rdi)
jmp 0xf2f1
movq %rax, %rdi
callq 0x6e80
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf108
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc18f
addq $0x10, %rsp
popq %rbx
retq
leaq 0xcaea(%rip), %rbx      # 0x18c80
movq %rbx, 0x8(%rsp)
movl $0x8, %edi
callq 0x51d0
movq %rbx, (%rax)
leaq 0xcae9(%rip), %rsi      # 0x18c98
movq 0xce2a(%rip), %rdx      # 0x18fe0
movq %rax, %rdi
callq 0x55b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56b8
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::function::function<asio::detail::binder2<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)>, std::error_code, unsigned long>, std::allocator<void>>(asio::detail::binder2<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)>, 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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, (%rsp)
movq %fs:-0x8, %rax
testq %rax, %rax
je 0xf3dd
movq 0x8(%rax), %rdi
jmp 0xf3df
xorl %edi, %edi
movl $0x70, %esi
callq 0xc33c
movq %rsp, %rdi
movq %rax, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
leaq 0x87(%rip), %rdx        # 0xf484
movq %rdx, (%rax)
movq (%r14), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%r14), %rdx
movq %rdx, 0x20(%rax)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x10(%rax)
movl 0x20(%r14), %edx
movl %edx, 0x28(%rax)
movq 0x28(%r14), %rdx
movq %rdx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movq 0x30(%r14), %rdx
movq %rcx, 0x30(%r14)
movq %rdx, 0x38(%rax)
movq %rcx, 0x28(%r14)
movq 0x38(%r14), %rdx
movq %rdx, 0x40(%rax)
movq %rcx, 0x48(%rax)
movq 0x40(%r14), %rdx
movq %rcx, 0x40(%r14)
movq %rdx, 0x48(%rax)
movq %rcx, 0x38(%r14)
movups 0x48(%r14), %xmm0
movups %xmm0, 0x50(%rax)
movq 0x58(%r14), %rdx
movq %rdx, 0x60(%rax)
movq %rax, (%rbx)
movq %rcx, 0x8(%rdi)
callq 0xf592
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x6e80
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edx
callq 0xc5b1
movzbl %al, %eax
testb %al, %al
je 0xc5a9
testb $0x10, 0x3c(%rbx)
je 0xc5a9
cmpq $0x0, (%r14)
movl $0x2, %ecx
cmovel %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x5560
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5440
leaq 0x20(%rbx), %rsi
movq %rsp, %rdi
callq 0x5440
leaq 0x40(%rbx), %rsi
movq %rsp, %rdi
callq 0x5440
movq 0xc521(%rip), %rdi      # 0x18fa8
leaq 0x4cb2(%rip), %rsi      # 0x11740
movl $0x10, %edx
callq 0x53b0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0xc501(%rip), %rdi      # 0x18fa8
callq 0x53b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5280
movq 0xc48b(%rip), %rsi      # 0x18f68
movq %rsp, %rdi
callq 0x52d0
leaq 0x80(%rsp), %rdi
callq 0x5150
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0xc461(%rip), %rsi      # 0x18f68
movq %rsp, %rdi
callq 0x52d0
leaq 0x80(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x5560
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movl $0x3a, %edx
callq 0x5630
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x40(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %edx
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x5630
addq $0x60, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xe3f0
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5200
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xdc36
callq 0x5340
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdc45
callq 0x5340
movq 0xb31c(%rip), %rsi      # 0x18f68
leaq 0x40(%rsp), %rdi
callq 0x52d0
leaq 0xc0(%rsp), %rdi
callq 0x5150
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xdc88
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xdc88
callq 0x5340
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdc97
callq 0x5340
movq 0xb2ca(%rip), %rsi      # 0x18f68
leaq 0x40(%rsp), %rdi
callq 0x52d0
leaq 0xc0(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3a71(%rip), %rsi      # 0x11751
leaq 0x3a78(%rip), %rdx      # 0x1175f
leaq 0x20(%rsp), %rdi
callq 0x6df0
leaq 0x60(%r14), %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xe858
movq %rax, %r15
addq $0x68, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xdd18
callq 0x5340
cmpq %r14, %r15
je 0xdd97
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3a24(%rip), %rsi      # 0x11751
leaq 0x3a2b(%rip), %rdx      # 0x1175f
movq %rsp, %rdi
callq 0x6df0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe7dc
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x18, %edx
callq 0x5560
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xdd67
callq 0x5340
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5240
movl (%rsp), %ebx
movq 0xb1ea(%rip), %rsi      # 0x18f68
leaq 0x20(%rsp), %rdi
callq 0x52d0
leaq 0xa0(%rsp), %rdi
callq 0x5150
jmp 0xdd99
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xb1b4(%rip), %rsi      # 0x18f68
leaq 0x20(%rsp), %rdi
callq 0x52d0
leaq 0xa0(%rsp), %rdi
callq 0x5150
jmp 0xddf4
jmp 0xddde
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
jne 0xddef
jmp 0xddf4
movq %rax, %rbx
jmp 0xddf4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xddf4
callq 0x5340
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x34(%rsp), %r14
movl $0x1b39, (%r14)         # imm = 0x1B39
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
movq %r13, -0x8(%rdi)
leaq 0x20(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xf816
movq (%rbx), %rcx
leaq 0xf0(%rcx), %rax
movq (%r15), %rdx
movslq (%r14), %rsi
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
subq %rdi, %rdx
cmoveq %r13, %rdi
cmpq %rsi, %rdx
cmovaeq %rsi, %rdx
movq %rdi, (%r12)
movq %rdx, 0x8(%r12)
movq %rcx, 0x10(%rsp)
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0xe37e
movq 0xac30(%rip), %rdx      # 0x18fa0
cmpb $0x0, (%rdx)
je 0xe37a
incl 0x8(%rcx)
jmp 0xe37e
lock
incl 0x8(%rcx)
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0xf98a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe3a9
callq 0x7026
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xe3b8
callq 0x7026
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe3d8
callq 0x7026
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xe3e7
callq 0x7026
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x58, %rsp
movq (%rdi), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movups (%rdx), %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movl %eax, 0x20(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq 0x8(%rsi), %rcx
movq %rax, 0x8(%rsi)
movq %rcx, 0x30(%rbx)
movq %rax, (%rsi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movq 0x18(%rsi), %rcx
movq %rax, 0x18(%rsi)
movq %rcx, 0x40(%rbx)
movq %rax, 0x10(%rsi)
movq %rsp, %r14
movl %eax, (%r14)
callq 0x5220
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xeb8c
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xeb60
callq 0x7026
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xeb6f
callq 0x7026
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xec68
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %r8
movl %ecx, 0x20(%rdi)
cmpl $0x1, %ecx
jne 0xebed
xorl %eax, %eax
cmpl $0x0, (%rsi)
sete %al
shll $0x10, %eax
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rsi
cmpq %rsi, %rcx
cmovbq %rcx, %rsi
subq %rsi, %rcx
addq 0x8(%r8), %rsi
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq (%r8), %r9
movq %rsp, %rdx
movq %rsi, (%rdx)
movq %rcx, 0x8(%rdx)
movq (%r9), %rdi
addq $0x28, %rdi
leaq 0x8(%r9), %rsi
addq $0x20, %r9
xorl %ecx, %ecx
callq 0xec8c
addq $0x10, %rsp
popq %rbx
retq
movq 0x18(%r8), %rax
addq %rdx, %rax
movq %rax, 0x18(%r8)
movl (%rsi), %ecx
testl %ecx, %ecx
sete %sil
testq %rdx, %rdx
sete %dl
testb %sil, %dl
jne 0xec1a
cmpq 0x10(%r8), %rax
jae 0xec1a
xorl %eax, %eax
testl %ecx, %ecx
sete %cl
je 0xec61
movq 0xa387(%rip), %rbx      # 0x18fa8
leaq 0x2bdc(%rip), %rsi      # 0x11804
movl $0x9, %edx
movq %rbx, %rdi
callq 0x53b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5280
movb %cl, %al
jmp 0xeba4
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edx
movq %r14, %r9
callq 0xf690
movzbl %al, %eax
testb %al, %al
je 0xf688
testb $0x10, 0x3c(%rbx)
je 0xf688
movq (%r14), %rcx
cmpq 0x10(%rsp), %rcx
movl $0x2, %ecx
cmovbl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movups (%rdx), %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movl %eax, 0x20(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq 0x8(%rsi), %rcx
movq %rax, 0x8(%rsi)
movq %rcx, 0x30(%rbx)
movq %rax, (%rsi)
movq %rsp, %r14
movl %eax, (%r14)
callq 0x5220
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xfa18
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xf9f6
callq 0x7026
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xfa10
callq 0x7026
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r8
movl %ecx, 0x20(%rdi)
cmpl $0x1, %ecx
jne 0xfa79
xorl %eax, %eax
cmpl $0x0, (%rsi)
sete %al
shll $0x10, %eax
subq $0x18, %rsp
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rsi
cmpq %rsi, %rcx
cmovbq %rcx, %rsi
subq %rsi, %rcx
addq 0x8(%r8), %rsi
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq (%r8), %r9
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq %rcx, 0x8(%rdx)
movq (%r9), %rdi
addq $0x28, %rdi
leaq 0x8(%r9), %rsi
addq $0x20, %r9
xorl %ecx, %ecx
callq 0xfaac
addq $0x18, %rsp
retq
movq 0x18(%r8), %rax
addq %rdx, %rax
movq %rax, 0x18(%r8)
movl (%rsi), %ecx
testl %ecx, %ecx
sete %sil
testq %rdx, %rdx
sete %dl
testb %sil, %dl
jne 0xfaa6
cmpq 0x10(%r8), %rax
jae 0xfaa6
xorl %eax, %eax
testl %ecx, %ecx
sete %cl
je 0xfaa7
retq
movb %cl, %al
jmp 0xfa2b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
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 0x10381
movzbl %al, %ebp
leaq 0x40(%rbx), %rdi
movl (%r14), %r14d
callq 0x10532
movl %r14d, 0x40(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10576
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x0, (%r14)
callq 0x5220
movq %rax, 0x8(%r14)
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
movl %ebp, %edi
movl $0x1, %edx
movq %r14, %rcx
callq 0xa848
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service.hpp
// Function: std::error_code asio::detail::reactive_socket_service<asio::ip::tcp>::set_option<asio::detail::socket_option::boolean<1, 2>>(asio::detail::reactive_socket_service<asio::ip::tcp>::implementation_type&, asio::detail::socket_option::boolean<1, 2> const&, std::error_code&)
asio::error_code set_option(implementation_type& impl,
      const Option& option, asio::error_code& ec)
  {
    socket_ops::setsockopt(impl.socket_, impl.state_,
        option.level(impl.protocol_), option.name(impl.protocol_),
        option.data(impl.protocol_), option.size(impl.protocol_), ec);
    return ec;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl (%rsi), %ebp
cmpl $-0x1, %ebp
je 0x105ee
movq %rdx, %r14
callq 0x5060
movq %rax, %r15
movl $0x0, (%rax)
movl %ebp, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x55f0
movl %eax, %ebp
movl (%r15), %r14d
movb 0x8e39(%rip), %al       # 0x19400
testb %al, %al
je 0x1060c
movl %r14d, (%rbx)
leaq 0x8d83(%rip), %rax      # 0x19358
movq %rax, 0x8(%rbx)
testl %ebp, %ebp
jne 0x105fb
callq 0x5220
movl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x105fb
movq %rbx, %rdi
movl $0x9, %esi
callq 0xa9cc
movl (%rbx), %eax
movq 0x8(%rbx), %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x5b0c
jmp 0x105cb
nop
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransR/Test_TransR.cpp
// Function: Test::calc_sum(int, int, int)
double calc_sum(int e1,int e2,int rel)
    {
        vector<double> e1_vec;
        e1_vec.resize(m);
        vector<double> e2_vec;
        e2_vec.resize(m);
        for (int ii=0; ii<m; ii++)
            for (int jj=0; jj<n; jj++)
            {
                e1_vec[ii]+=A[rel][jj][ii]*entity_vec[e1][jj];
                e2_vec[ii]+=A[rel][jj][ii]*entity_vec[e2][jj];
            }
        double sum=0;
        for (int ii=0; ii<m; ii++)
            sum+=-fabs(e2_vec[ii]-e1_vec[ii]-relation_vec[rel][ii]);
        return sum;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorpd %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movslq 0x6a91(%rip), %rsi      # 0xc158
callq 0x55e4
leaq 0x10(%rsp), %rdi
xorpd %xmm0, %xmm0
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movslq 0x6a70(%rip), %rsi      # 0xc158
callq 0x55e4
movslq 0x6a64(%rip), %rax      # 0xc158
movslq %r15d, %rcx
testq %rax, %rax
jle 0x5795
movl 0x6a56(%rip), %edx      # 0xc15c
leaq (%rcx,%rcx,2), %rsi
shlq $0x3, %rsi
addq 0xd8(%rbx), %rsi
movslq %r14d, %rdi
movq 0x18(%rbx), %r9
leaq (%rdi,%rdi,2), %rdi
leaq (%r9,%rdi,8), %rdi
movq 0x30(%rsp), %r8
movslq %ebp, %r10
leaq (%r10,%r10,2), %r10
leaq (%r9,%r10,8), %r9
movq 0x10(%rsp), %r10
xorl %r11d, %r11d
testl %edx, %edx
jle 0x578d
movq (%rsi), %r14
movq (%rdi), %r15
movq (%r9), %r12
xorl %r13d, %r13d
movq (%r14), %rbp
movsd (%rbp,%r11,8), %xmm0
mulsd (%r15,%r13,8), %xmm0
addsd (%r8,%r11,8), %xmm0
movsd %xmm0, (%r8,%r11,8)
movsd (%rbp,%r11,8), %xmm0
mulsd (%r12,%r13,8), %xmm0
addsd (%r10,%r11,8), %xmm0
movsd %xmm0, (%r10,%r11,8)
incq %r13
addq $0x18, %r14
cmpq %r13, %rdx
jne 0x574c
incq %r11
cmpq %rax, %r11
jne 0x573c
testl %eax, %eax
jle 0x57dd
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq (%rbx), %rdi
leaq (%rcx,%rcx,2), %rcx
movq (%rdi,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x2894(%rip), %xmm2     # 0x8050
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
subsd (%rcx,%rdi,8), %xmm1
andpd %xmm2, %xmm1
subsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x57bc
jmp 0x57e1
xorpd %xmm0, %xmm0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movsd %xmm0, 0x8(%rsp)
je 0x5804
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
movsd 0x8(%rsp), %xmm0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x5821
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
movsd 0x8(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x584f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
jmp 0x584f
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x5866
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/lunasorcery[P]succ/main.cpp
// Function: replaceTabsWithSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string replaceTabsWithSpaces(const std::string& str)
{
	const std::string tabAsSpaces = repeatChar(' ', kTabWidth);

	std::string result;
	for (const auto& c : str) {
		if (c == '\t') {
			result += tabAsSpaces;
		} else {
			result += c;
		}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
movl $0x4, %edx
movl $0x20, %esi
callq 0x571f
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x56cd
movq (%r14), %r14
xorl %r13d, %r13d
movb (%r14,%r13), %al
cmpb $0x9, %al
jne 0x56ba
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x13ecc
jmp 0x56c5
movsbl %al, %esi
movq %rbx, %rdi
callq 0x76ac
incq %r13
cmpq %r13, %r12
jne 0x56a0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56e6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x570e
movq (%r15), %rsi
incq %rsi
callq 0x4210
leaq -0x48(%rbp), %rdi
callq 0x48b2
movq %r14, %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O1/lunasorcery[P]succ/main.cpp
// Function: repeatChar[abi:cxx11](char, unsigned long)
static std::string repeatChar(char c, size_t count)
{
	std::string buffer;
	buffer.resize(count);
	memset(buffer.data(), c ? c : ' ', count);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rdx, %rsi
xorl %edx, %edx
callq 0x13f3e
movq (%rbx), %rdi
movzbl %r15b, %esi
movq %r14, %rdx
callq 0x4130
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5782
movq (%r12), %rsi
incq %rsi
callq 0x4210
movq %r14, %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/match.cpp
// Function: path_tree(array2d&, tree const&, tree const&, int, int, int)
int path_tree(array2d& dp, const tree& t1, const tree& t2, const int lx, int x, int y)
{
    // trivial case: empty path
    if (x == lx)
        return 0;

    // memoization
    int& sol = dp(x, y);
    if (sol != NINF)
        return sol;

    // TODO: select the correct child
    // x's only child
    int w = t1.adj[x].front();

    // delete path node
    sol = max(sol, path_tree(dp, t1, t2, lx, w, y));
    for (int z : t2.adj[y])
    {
        // match x and y
        sol = max(sol, 1 + path_tree(dp, t1, t2, lx, w, z));
        // delete tree node
        sol = max(sol, path_tree(dp, t1, t2, lx, x, z));
    }
    return sol;
}

// Assembly:
xorl %eax, %eax
cmpl %ecx, %r8d
je 0x37f5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %r12
movl 0x4(%rdi), %eax
imull %r8d, %eax
addl %r9d, %eax
movslq %eax, %r15
movq 0x8(%rdi), %rbx
movl (%rbx,%r15,4), %eax
movl %eax, %ecx
negl %ecx
jno 0x37e7
movq %rdx, %r13
movq %rsi, %r14
movslq %r8d, %rax
leaq (%rax,%rax,2), %rax
movq 0x48(%rsi,%rax,8), %rax
movl (%rax), %eax
movq %r12, %rdi
movl %ebp, %ecx
movl %r8d, 0x10(%rsp)
movl %eax, 0x14(%rsp)
movl %eax, %r8d
movl %r9d, 0xc(%rsp)
callq 0x36bc
movl (%rbx,%r15,4), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, (%rbx,%r15,4)
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq %r14, %rdx
movq 0x48(%r13,%rax,8), %r14
movq 0x50(%r13,%rax,8), %rax
cmpq %rax, %r14
movq %rbx, %rcx
je 0x37e3
movq %r12, %rsi
movl %ebp, %ebx
movq %rax, 0x20(%rsp)
movq %r13, 0x18(%rsp)
movl (%r14), %r9d
movl %r9d, 0xc(%rsp)
movq %rsi, %rbp
movq %rsi, %rdi
movq %rdx, %r12
movq %rdx, %rsi
movq %r13, %rdx
movq %rcx, %r13
movl %ebx, %ecx
movl 0x14(%rsp), %r8d
callq 0x36bc
incl %eax
movl (%r13,%r15,4), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, (%r13,%r15,4)
movq %rbp, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl 0x10(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq 0x36bc
movq %rbp, %rsi
movq %r12, %rdx
movl (%r13,%r15,4), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movq %r13, %rcx
movq 0x18(%rsp), %r13
movl %eax, (%rcx,%r15,4)
movq 0x20(%rsp), %rax
addq $0x4, %r14
cmpq %rax, %r14
jne 0x3766
movl (%rcx,%r15,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/match.cpp
// Function: path_path(array2d&, array2d&, array2d const&, tree const&, tree const&, int, int, int, int)
int path_path(array2d& dp, array2d& pdp, const array2d& matrix, const tree& t1, const tree& t2, const int lx, const int ly, int x, int y)
{
    // trivial case: empty path
    if (x == lx || y == ly)
        return 0;

    // memoization
    int& sol = dp(x, y);
    if (sol != NINF)
        return sol;

    // delete t1 node
    int nsol = path_path(dp, pdp, matrix, t1, t2, lx, ly, t1.par[x], y);
    if (nsol > sol)
        sol = nsol, pdp(x, y) = DEL_1;

    // match x and y
    nsol = matrix(x, y) + path_path(dp, pdp, matrix, t1, t2, lx, ly, t1.par[x], t2.par[y]);
    if (nsol > sol)
        sol = nsol, pdp(x, y) = MATCH;

    // delete t2 node
    nsol = path_path(dp, pdp, matrix, t1, t2, lx, ly, x, t2.par[y]);
    if (nsol > sol)
        sol = nsol, pdp(x, y) = DEL_2;

    return sol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rdi, %r13
movl 0x70(%rsp), %r10d
movl 0x68(%rsp), %ebx
movl 0x60(%rsp), %r11d
cmpl %r9d, %ebx
sete %dil
cmpl %r11d, %r10d
sete %dl
xorl %eax, %eax
orb %dil, %dl
jne 0x39a6
movl 0x4(%r13), %eax
imull %ebx, %eax
addl %r10d, %eax
movslq %eax, %r14
movq 0x8(%r13), %r15
movl (%r15,%r14,4), %eax
movl %eax, %edx
negl %edx
jno 0x39a6
movl %r9d, %ebp
movslq %ebx, %rax
movq %rax, 0x8(%rsp)
movl 0x5f14(%rcx,%rax,4), %eax
subq $0x8, %rsp
movq %r13, %rdi
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %rcx, 0x20(%rsp)
movq %r8, 0x28(%rsp)
pushq %r10
pushq %rax
pushq %r11
callq 0x37f6
movl 0x90(%rsp), %edx
movq 0x20(%rsp), %rcx
addq $0x20, %rsp
cmpl (%r15,%r14,4), %eax
jle 0x38b8
movl %eax, (%r15,%r14,4)
movl 0x4(%rcx), %eax
imull %ebx, %eax
addl %edx, %eax
cltq
movq 0x8(%rcx), %rcx
movl $0x0, (%rcx,%rax,4)
movl 0x4(%r12), %eax
imull %ebx, %eax
addl %edx, %eax
cltq
movq 0x8(%r12), %rcx
movl (%rcx,%rax,4), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movl 0x5f14(%rcx,%rax,4), %eax
movslq %edx, %rdx
movq 0x20(%rsp), %r8
movq %rdx, 0x8(%rsp)
movl 0x5f14(%r8,%rdx,4), %r10d
subq $0x8, %rsp
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movl %ebp, %r9d
pushq %r10
pushq %rax
movl 0x78(%rsp), %eax
pushq %rax
callq 0x37f6
movq 0x20(%rsp), %rdx
addq $0x20, %rsp
addl 0x14(%rsp), %eax
cmpl (%r15,%r14,4), %eax
jle 0x3945
movl %eax, (%r15,%r14,4)
movl 0x4(%rdx), %eax
imull %ebx, %eax
movl 0x70(%rsp), %ecx
addl %ecx, %eax
cltq
movq 0x8(%rdx), %rcx
movl $0x2, (%rcx,%rax,4)
movq 0x20(%rsp), %r8
movq 0x8(%rsp), %rax
movl 0x5f14(%r8,%rax,4), %eax
subq $0x8, %rsp
movq %r13, %rdi
movq %rdx, %r13
movq %rdx, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %rcx
movl %ebp, %r9d
pushq %rax
pushq %rbx
movl 0x78(%rsp), %eax
pushq %rax
callq 0x37f6
addq $0x20, %rsp
cmpl (%r15,%r14,4), %eax
jle 0x39a2
movl %eax, (%r15,%r14,4)
imull 0x4(%r13), %ebx
movl 0x70(%rsp), %eax
addl %eax, %ebx
movslq %ebx, %rax
movq 0x8(%r13), %rcx
movl $0x1, (%rcx,%rax,4)
movl (%r15,%r14,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/match.cpp
// Function: bipartite(array2d const&, array2d&, array2d&, int, unsigned long long)
int bipartite(const array2d& D, array2d& dp, array2d& pdp, int k, mask m)
{
    // nothing left to match
    if (k == D.n || m == 0)
        return 0;

    // memoization
    int& sol = dp(k, m);
    if (sol != NINF)
        return sol;

    // don't match kth tree with anyone
    sol = bipartite(D, dp, pdp, k + 1, m);

    // try to match kth tree in t1 with any avaliable tree in t2
    for (mask mi = m; mi != 0; mi -= ls(mi))
    {
        int nsol = D(k, tz(mi)) + bipartite(D, dp, pdp, k + 1, m ^ ls(mi));
        if (nsol > sol)
            sol = nsol, pdp(k, m) = tz(mi);
    }
    return sol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
movq %r8, 0x8(%rsp)
testq %r8, %r8
je 0x3af0
movl %ecx, %r12d
cmpl %ecx, (%rdi)
je 0x3af0
movq 0x10(%rsp), %rcx
movl 0x4(%rcx), %eax
imull %r12d, %eax
addl 0x8(%rsp), %eax
movslq %eax, %r15
movq 0x8(%rcx), %rbp
movl (%rbp,%r15,4), %eax
movl %eax, %ecx
negl %ecx
jno 0x3af0
leal 0x1(%r12), %ecx
movq %rdi, 0x28(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %ecx, 0x24(%rsp)
movq 0x8(%rsp), %rbx
movq %rbx, %r8
callq 0x39d3
movl %eax, (%rbp,%r15,4)
testq %rbx, %rbx
je 0x3aeb
movq 0x8(%rsp), %r14
bsfq %r14, %rcx
movq 0x28(%rsp), %rdi
movl 0x4(%rdi), %eax
imull %r12d, %eax
movq %rcx, 0x30(%rsp)
addl %ecx, %eax
cltq
movq 0x8(%rdi), %rcx
movq %r15, %r13
movq %r12, %r15
movl (%rcx,%rax,4), %r12d
movq %r14, %rbx
negq %rbx
andq %r14, %rbx
movq %rbx, %r8
xorq 0x8(%rsp), %r8
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x39d3
addl %r12d, %eax
movq %r15, %r12
movq %r13, %r15
cmpl (%rbp,%r13,4), %eax
jle 0x3ae2
movl %eax, (%rbp,%r15,4)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %eax
imull %r12d, %eax
addl 0x8(%rsp), %eax
cltq
movq 0x8(%rcx), %rcx
movq 0x30(%rsp), %rdx
movl %edx, (%rcx,%rax,4)
subq %rbx, %r14
jne 0x3a64
movl (%rbp,%r15,4), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/match.cpp
// Function: recover_matching_aux(tree const&, tree const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, array2d const&, int, int, int, int)
void recover_matching_aux(const tree& t1, const tree& t2, vector<pair<int, int>>& matching, const array2d& tdp, const int lx, const int ly, int x, int y)
{
    if (x == lx || y == ly)
        return;

    switch (tdp(x, y))
    {
        case DEL_1:
            recover_matching_aux(t1, t2, matching, tdp, lx, ly, t1.par[x], y);
            break;
        case DEL_2:
            recover_matching_aux(t1, t2, matching, tdp, lx, ly, x, t2.par[y]);
            break;
        case MATCH:
            matching.emplace_back(x, y);
            recover_matching_aux(t1, t2, matching, tdp, lx, ly, t1.par[x], t2.par[y]);
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movl %eax, (%rsp)
cmpl %ebp, %ecx
je 0x4937
cmpl %ebx, %eax
je 0x4937
movl 0x4(%r14), %edx
imull %ecx, %edx
addl %eax, %edx
movslq %edx, %rdx
movq 0x8(%r14), %rsi
movl (%rsi,%rdx,4), %edx
cmpl $0x1, %edx
jne 0x48d5
cltq
movl 0x5f14(%r12,%rax,4), %eax
jmp 0x489a
cmpl $0x2, %edx
je 0x48eb
testl %edx, %edx
jne 0x4937
movslq %ecx, %rcx
movl 0x5f14(%r13,%rcx,4), %ecx
jmp 0x489a
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq 0x5ad2
leaq 0x4(%rsp), %rax
movslq (%rax), %rax
movl 0x5f14(%r13,%rax,4), %eax
movq %rsp, %rcx
movslq (%rcx), %rcx
movl 0x5f14(%r12,%rcx,4), %r10d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movl %ebx, %r9d
pushq %r10
pushq %rax
callq 0x4875
addq $0x10, %rsp
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq