LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nurseiit[P]cpp-server/./include/asio/ip/basic_resolver_query.hpp
// Function: asio::ip::basic_resolver_query<asio::ip::tcp>::basic_resolver_query(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, asio::ip::resolver_base::flags)
basic_resolver_query(const std::string& host, const std::string& service,
      resolver_query_base::flags resolve_flags = address_configured)
    : hints_(),
      host_name_(host),
      service_name_(service)
  {
    typename InternetProtocol::endpoint endpoint;
    hints_.ai_flags = static_cast<int>(resolve_flags);
    hints_.ai_family = ASIO_OS_DEF(AF_UNSPEC);
    hints_.ai_socktype = endpoint.protocol().type();
    hints_.ai_protocol = endpoint.protocol().protocol();
    hints_.ai_addrlen = 0;
    hints_.ai_canonname = 0;
    hints_.ai_addr = 0;
    hints_.ai_next = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x30, %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x51c0
jmp 0xf390
movq -0x60(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x51c0
jmp 0xf3a3
leaq -0x48(%rbp), %rdi
callq 0xf760
movq -0x60(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
leaq -0x48(%rbp), %rdi
callq 0xf780
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rdi
callq 0xf7c0
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq -0x48(%rbp), %rdi
callq 0xf780
movl %eax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xf7d0
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x28(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xf440
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5270
movq -0x60(%rbp), %rdi
callq 0xf7e0
movq -0x28(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/object_pool.hpp
// Function: asio::detail::object_pool<asio::detail::epoll_reactor::descriptor_state>::destroy_list(asio::detail::epoll_reactor::descriptor_state*)
void destroy_list(Object* list)
  {
    while (list)
    {
      Object* o = list;
      list = object_pool_access::next(o);
      object_pool_access::destroy(o);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x122aa
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122d0
jmp 0x12280
addq $0x20, %rsp
popq %rbp
retq
// File: nurseiit[P]cpp-server/./include/asio/detail/object_pool.hpp
// Function: asio::detail::object_pool<asio::detail::epoll_reactor::descriptor_state>::free(asio::detail::epoll_reactor::descriptor_state*)
void free(Object* o)
  {
    if (live_list_ == o)
      live_list_ = object_pool_access::next(o);

    if (object_pool_access::prev(o))
    {
      object_pool_access::next(object_pool_access::prev(o))
        = object_pool_access::next(o);
    }

    if (object_pool_access::next(o))
    {
      object_pool_access::prev(object_pool_access::next(o))
        = object_pool_access::prev(o);
    }

    object_pool_access::next(o) = free_list_;
    object_pool_access::prev(o) = 0;
    free_list_ = o;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x125e7
movq -0x10(%rbp), %rdi
callq 0x122b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12780
cmpq $0x0, (%rax)
je 0x1261e
movq -0x10(%rbp), %rdi
callq 0x122b0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12780
movq (%rax), %rdi
callq 0x122b0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x122b0
cmpq $0x0, (%rax)
je 0x12655
movq -0x10(%rbp), %rdi
callq 0x12780
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x122b0
movq (%rax), %rdi
callq 0x12780
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x122b0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12780
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq $0x0, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/connect.hpp
// Function: asio::ip::basic_resolver_iterator<asio::ip::tcp> asio::detail::call_connect_condition<asio::detail::default_connect_condition, asio::ip::basic_resolver_iterator<asio::ip::tcp>>(asio::detail::default_connect_condition&, std::error_code const&, asio::ip::basic_resolver_iterator<asio::ip::tcp>, asio::ip::basic_resolver_iterator<asio::ip::tcp>, std::enable_if<!is_legacy_connect_condition<asio::detail::default_connect_condition, asio::ip::basic_resolver_iterator<asio::ip::tcp>>::value, void>::type*)
inline Iterator call_connect_condition(ConnectCondition& connect_condition,
      const asio::error_code& ec, Iterator next, Iterator end,
      typename enable_if<!is_legacy_connect_condition<
        ConnectCondition, Iterator>::value>::type* = 0)
  {
    for (;next != end; ++next)
      if (connect_condition(ec, *next))
        return next;
    return end;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x13800
testb $0x1, %al
jne 0x13876
jmp 0x138c1
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x136f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x13d60
testb $0x1, %al
jne 0x138a5
jmp 0x138b4
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x13b10
jmp 0x138ce
jmp 0x138b6
movq -0x48(%rbp), %rdi
callq 0x13a80
jmp 0x13863
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x13b10
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/ip/basic_resolver_iterator.hpp
// Function: asio::ip::basic_resolver_iterator<asio::ip::tcp>::operator=(asio::ip::basic_resolver_iterator<asio::ip::tcp>&&)
basic_resolver_iterator& operator=(basic_resolver_iterator&& other)
  {
    if (this != &other)
    {
      values_ = ASIO_MOVE_CAST(values_ptr_type)(other.values_);
      index_ = other.index_;
      other.index_ = 0;
    }

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x13927
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13d80
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/basic_socket.hpp
// Function: asio::basic_socket<asio::ip::tcp, asio::executor>::connect(asio::ip::basic_endpoint<asio::ip::tcp> const&, std::error_code&)
ASIO_SYNC_OP_VOID connect(const endpoint_type& peer_endpoint,
      asio::error_code& ec)
  {
    if (!is_open())
    {
      impl_.get_service().open(impl_.get_implementation(),
            peer_endpoint.protocol(), ec);
      if (ec)
      {
        ASIO_SYNC_OP_VOID_RETURN(ec);
      }
    }

    impl_.get_service().connect(impl_.get_implementation(), peer_endpoint, ec);
    ASIO_SYNC_OP_VOID_RETURN(ec);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x13f90
testb $0x1, %al
jne 0x13a2d
movq -0x58(%rbp), %rdi
callq 0x13e60
movq -0x58(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x13f50
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf780
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %rdx
callq 0x13fd0
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8260
testb $0x1, %al
jne 0x13a16
jmp 0x13a2b
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13a71
jmp 0x13a2d
movq -0x58(%rbp), %rdi
callq 0x13e60
movq -0x58(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x13f50
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x14080
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nop
// File: nurseiit[P]cpp-server/./include/asio/ip/basic_resolver_iterator.hpp
// Function: asio::ip::basic_resolver_iterator<asio::ip::tcp>::equal(asio::ip::basic_resolver_iterator<asio::ip::tcp> const&) const
bool equal(const basic_resolver_iterator& other) const
  {
    if (!values_ && !other.values_)
      return true;
    if (values_ != other.values_)
      return false;
    return index_ == other.index_;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x13d00
testb $0x1, %al
jne 0x13cc4
movq -0x18(%rbp), %rdi
callq 0x13d00
testb $0x1, %al
jne 0x13cc4
movb $0x1, -0x1(%rbp)
jmp 0x13cf5
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d20
testb $0x1, %al
jne 0x13cd7
jmp 0x13cdd
movb $0x0, -0x1(%rbp)
jmp 0x13cf5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service.hpp
// Function: asio::detail::reactive_socket_service<asio::ip::tcp>::open(asio::detail::reactive_socket_service<asio::ip::tcp>::implementation_type&, asio::ip::tcp const&, std::error_code&)
asio::error_code open(implementation_type& impl,
      const protocol_type& protocol, asio::error_code& ec)
  {
    if (!do_open(impl, protocol.family(),
          protocol.type(), protocol.protocol(), ec))
      impl.protocol_ = protocol;
    return ec;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x14370
movl %eax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf7c0
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf7d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x48(%rbp), %edx
movl -0x44(%rbp), %ecx
movl %eax, %r8d
movq -0x30(%rbp), %r9
callq 0x14130
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8260
xorb $-0x1, %al
testb $0x1, %al
jne 0x1404f
jmp 0x1405c
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/socket_holder.hpp
// Function: asio::detail::socket_holder::~socket_holder()
~socket_holder()
  {
    if (socket_ != invalid_socket)
    {
      asio::error_code ec;
      socket_ops::state_type state = 0;
      socket_ops::close(socket_, state, true, ec);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, (%rax)
je 0x145c6
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6f10
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, -0x19(%rbp)
movl (%rax), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x12c00
jmp 0x145c4
jmp 0x145c6
movq -0x28(%rbp), %rdi
callq 0x8150
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x71c0
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/object_pool.hpp
// Function: asio::detail::epoll_reactor::descriptor_state* asio::detail::object_pool<asio::detail::epoll_reactor::descriptor_state>::alloc<bool>(bool)
Object* alloc(Arg arg)
  {
    Object* o = free_list_;
    if (o)
      free_list_ = object_pool_access::next(free_list_);
    else
      o = object_pool_access::create<Object>(arg);

    object_pool_access::next(o) = live_list_;
    object_pool_access::prev(o) = 0;
    if (live_list_)
      object_pool_access::prev(live_list_) = o;
    live_list_ = o;

    return o;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x146b8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x122b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x146c9
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x14740
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x122b0
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x12780
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq $0x0, (%rcx)
cmpq $0x0, (%rax)
je 0x1471c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x12780
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: unsigned long asio::write<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::basic_streambuf_ref<std::allocator<char>>>(asio::basic_stream_socket<asio::ip::tcp, asio::executor>&, asio::basic_streambuf_ref<std::allocator<char>>&&, std::enable_if<is_dynamic_buffer_v1<std::decay<asio::basic_streambuf_ref<std::allocator<char>>>::type>::value && !is_dynamic_buffer_v2<std::decay<asio::basic_streambuf_ref<std::allocator<char>>>::type>::value, void>::type*)
inline std::size_t write(SyncWriteStream& s,
    ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
    typename enable_if<
      is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
        && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
    >::type*)
{
  asio::error_code ec;
  std::size_t bytes_transferred = write(s,
      ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
      transfer_all(), ec);
  asio::detail::throw_error(ec, "write");
  return bytes_transferred;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6f10
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x15500
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15490
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0x31de(%rip), %rsi      # 0x18634
callq 0x8220
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: unsigned long asio::write<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::basic_streambuf_ref<std::allocator<char>>, asio::detail::transfer_all_t>(asio::basic_stream_socket<asio::ip::tcp, asio::executor>&, asio::basic_streambuf_ref<std::allocator<char>>&&, asio::detail::transfer_all_t, std::error_code&, std::enable_if<is_dynamic_buffer_v1<std::decay<asio::basic_streambuf_ref<std::allocator<char>>>::type>::value && !is_dynamic_buffer_v2<std::decay<asio::basic_streambuf_ref<std::allocator<char>>>::type>::value, void>::type*)
std::size_t write(SyncWriteStream& s,
    ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
    CompletionCondition completion_condition, asio::error_code& ec,
    typename enable_if<
      is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
        && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
    >::type*)
{
  typename decay<DynamicBuffer_v1>::type b(
      ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers));

  std::size_t bytes_transferred = write(s, b.data(),
      ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);
  b.consume(bytes_transferred);
  return bytes_transferred;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x15510
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15590
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
callq 0x15530
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x155c0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: unsigned long asio::detail::write_buffer_sequence<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t>(asio::basic_stream_socket<asio::ip::tcp, asio::executor>&, asio::const_buffers_1 const&, asio::const_buffer const* const&, asio::detail::transfer_all_t, std::error_code&)
std::size_t write_buffer_sequence(SyncWriteStream& s,
      const ConstBufferSequence& buffers, const ConstBufferIterator&,
      CompletionCondition completion_condition, asio::error_code& ec)
  {
    ec = asio::error_code();
    asio::detail::consuming_buffers<const_buffer,
        ConstBufferSequence, ConstBufferIterator> tmp(buffers);
    while (!tmp.empty())
    {
      if (std::size_t max_size = detail::adapt_completion_condition_result(
            completion_condition(ec, tmp.total_consumed())))
        tmp.consume(s.write_some(tmp.prepare(max_size), ec));
      else
        break;
    }
    return tmp.total_consumed();;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6f10
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x156f0
leaq -0x50(%rbp), %rdi
callq 0x15720
xorb $-0x1, %al
testb $0x1, %al
jne 0x15645
jmp 0x156bc
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x157b0
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq -0x1(%rbp), %rdi
callq 0x15770
movq %rax, %rdi
callq 0x15760
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x156b5
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x15840
movq -0x78(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x28(%rbp), %rdx
leaq -0x68(%rbp), %rsi
callq 0x157f0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x157d0
jmp 0x156b7
jmp 0x156bc
jmp 0x15634
leaq -0x50(%rbp), %rdi
callq 0x157b0
addq $0x80, %rsp
popq %rbp
retq
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service_base.hpp
// Function: unsigned long asio::detail::reactive_socket_service_base::send<asio::const_buffers_1>(asio::detail::reactive_socket_service_base::base_implementation_type&, asio::const_buffers_1 const&, int, std::error_code&)
size_t send(base_implementation_type& impl,
      const ConstBufferSequence& buffers,
      socket_base::message_flags flags, asio::error_code& ec)
  {
    buffer_sequence_adapter<asio::const_buffer,
        ConstBufferSequence> bufs(buffers);

    return socket_ops::sync_send(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x15980
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0x5d(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15b40
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15b50
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15b60
movb -0x5d(%rbp), %sil
movl -0x5c(%rbp), %edi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %r8d
movq -0x28(%rbp), %r10
movq %rsp, %r9
movq %r10, (%r9)
movzbl %sil, %esi
movzbl %al, %r9d
andl $0x1, %r9d
callq 0x159d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/buffer.hpp
// Function: asio::buffer(asio::const_buffer const&, unsigned long)
inline ASIO_CONST_BUFFER buffer(const const_buffer& b,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_CONST_BUFFER(b.data(),
      b.size() < max_size_in_bytes
      ? b.size() : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15bf0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x158c0
cmpq -0x20(%rbp), %rax
jae 0x15e3b
movq -0x18(%rbp), %rdi
callq 0x158c0
movq %rax, -0x30(%rbp)
jmp 0x15e43
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x15f10
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/buffer.hpp
// Function: asio::operator+(asio::const_buffer const&, unsigned long)
inline const_buffer operator+(const const_buffer& b,
    std::size_t n) ASIO_NOEXCEPT
{
  std::size_t offset = n < b.size() ? n : b.size();
  const char* new_data = static_cast<const char*>(b.data()) + offset;
  std::size_t new_size = b.size() - offset;
  return const_buffer(new_data, new_size
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x158c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x15ea7
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x15eb4
movq -0x18(%rbp), %rdi
callq 0x158c0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15bf0
movq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x158c0
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x15f40
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/basic_streambuf.hpp
// Function: asio::basic_streambuf<std::allocator<char>>::consume(unsigned long)
void consume(std::size_t n)
  {
    if (egptr() < pptr())
      setg(&buffer_[0], gptr(), pptr());
    if (gptr() + n > pptr())
      n = pptr() - gptr();
    gbump(static_cast<int>(n));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x55f0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x5120
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x160c5
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb7c0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x5130
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x5120
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
callq 0x5550
movq -0x20(%rbp), %rdi
callq 0x5130
movq -0x20(%rbp), %rdi
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x5120
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0x1610f
movq -0x20(%rbp), %rdi
callq 0x5120
movq -0x20(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x5130
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
callq 0x56d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nurseiit[P]cpp-server/./include/asio/impl/read_until.hpp
// Function: unsigned long asio::read_until<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::basic_streambuf_ref<std::allocator<char>>>(asio::basic_stream_socket<asio::ip::tcp, asio::executor>&, asio::basic_streambuf_ref<std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::enable_if<is_dynamic_buffer_v1<std::decay<asio::basic_streambuf_ref<std::allocator<char>>>::type>::value && !is_dynamic_buffer_v2<std::decay<asio::basic_streambuf_ref<std::allocator<char>>>::type>::value, void>::type*)
inline std::size_t read_until(SyncReadStream& s,
    ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
    ASIO_STRING_VIEW_PARAM delim,
    typename enable_if<
      is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
        && !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
    >::type*)
{
  asio::error_code ec;
  std::size_t bytes_transferred = read_until(s,
      ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers), delim, ec);
  asio::detail::throw_error(ec, "read_until");
  return bytes_transferred;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6f10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x16190
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x24c0(%rip), %rsi      # 0x1863a
callq 0x8220
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/impl/read_until.hpp
// Function: std::pair<asio::buffers_iterator<asio::const_buffers_1, char>, bool> asio::detail::partial_search<asio::buffers_iterator<asio::const_buffers_1, char>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(asio::buffers_iterator<asio::const_buffers_1, char>, asio::buffers_iterator<asio::const_buffers_1, char>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
std::pair<Iterator1, bool> partial_search(
      Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
  {
    for (Iterator1 iter1 = first1; iter1 != last1; ++iter1)
    {
      Iterator1 test_iter1 = iter1;
      Iterator2 test_iter2 = first2;
      for (;; ++test_iter1, ++test_iter2)
      {
        if (test_iter2 == last2)
          return std::make_pair(iter1, true);
        if (test_iter1 == last1)
        {
          if (test_iter2 != first2)
            return std::make_pair(iter1, false);
          else
            break;
        }
        if (*test_iter1 != *test_iter2)
          break;
      }
    }
    return std::make_pair(last1, false);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, %rax
movq %rdi, -0xa8(%rbp)
movq %rdi, -0xa0(%rbp)
leaq 0x48(%rbp), %rcx
movq %rcx, -0x98(%rbp)
leaq 0x10(%rbp), %rsi
movq %rax, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x38, %edx
callq 0x5310
movq -0x98(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x16830
testb $0x1, %al
jne 0x166fa
jmp 0x167fa
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x38, %edx
callq 0x5310
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x16d30
testb $0x1, %al
jne 0x1672d
jmp 0x16750
movq -0xa8(%rbp), %rdi
movb $0x1, -0x89(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x89(%rbp), %rdx
callq 0x16d70
jmp 0x1681b
movq -0x98(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x16da0
testb $0x1, %al
jne 0x16766
jmp 0x1679e
leaq -0x88(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x16dd0
testb $0x1, %al
jne 0x1677c
jmp 0x1679c
movq -0xa8(%rbp), %rdi
movb $0x0, -0x8a(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x8a(%rbp), %rdx
callq 0x16d70
jmp 0x1681b
jmp 0x167ea
leaq -0x80(%rbp), %rdi
callq 0x16e10
movsbl (%rax), %eax
movl %eax, -0xac(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x16e30
movq %rax, %rcx
movl -0xac(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x167ce
jmp 0x167ea
jmp 0x167d0
leaq -0x80(%rbp), %rdi
callq 0x16e50
leaq -0x88(%rbp), %rdi
callq 0x16e80
jmp 0x16717
jmp 0x167ec
leaq -0x48(%rbp), %rdi
callq 0x16e50
jmp 0x166e1
movq -0x98(%rbp), %rsi
movq -0xa8(%rbp), %rdi
movb $0x0, -0x8b(%rbp)
leaq -0x8b(%rbp), %rdx
callq 0x16d70
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/buffers_iterator.hpp
// Function: asio::buffers_iterator<asio::const_buffers_1, char>::increment()
void increment()
  {
    ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
    ++position_;

    // Check if the increment can be satisfied by the current buffer.
    ++current_buffer_position_;
    if (current_buffer_position_ != current_buffer_.size())
      return;

    // Find the next non-empty buffer.
    ++current_;
    current_buffer_position_ = 0;
    while (current_ != end_)
    {
      current_buffer_ = *current_;
      if (current_buffer_.size() > 0)
        return;
      ++current_;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x18(%rbp)
movq 0x20(%rdx), %rcx
xorl %eax, %eax
cmpq 0x28(%rdx), %rcx
movb %al, -0x9(%rbp)
je 0x16f7a
movb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x16f7a
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x16f83
jmp 0x16f85
jmp 0x16fa4
leaq 0x16d0(%rip), %rdi      # 0x1865c
leaq 0x16f6(%rip), %rsi      # 0x18689
movl $0x164, %edx            # imm = 0x164
leaq 0x17ea(%rip), %rcx      # 0x18789
callq 0x5290
movq -0x18(%rbp), %rdi
movq 0x30(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x30(%rdi)
movq 0x10(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x10(%rdi)
movq 0x10(%rdi), %rax
movq %rax, -0x20(%rbp)
callq 0x158c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x16fdb
jmp 0x17036
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x17036
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rax
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
callq 0x158c0
cmpq $0x0, %rax
jbe 0x17024
jmp 0x17036
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x20(%rax)
jmp 0x16ff3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service_base.hpp
// Function: unsigned long asio::detail::reactive_socket_service_base::receive<asio::mutable_buffers_1>(asio::detail::reactive_socket_service_base::base_implementation_type&, asio::mutable_buffers_1 const&, int, std::error_code&)
size_t receive(base_implementation_type& impl,
      const MutableBufferSequence& buffers,
      socket_base::message_flags flags, asio::error_code& ec)
  {
    buffer_sequence_adapter<asio::mutable_buffer,
        MutableBufferSequence> bufs(buffers);

    return socket_ops::sync_recv(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x17200
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0x5d(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x173f0
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x17400
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x17410
movb -0x5d(%rbp), %sil
movl -0x5c(%rbp), %edi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %r8d
movq -0x28(%rbp), %r10
movq %rsp, %r9
movq %r10, (%r9)
movzbl %sil, %esi
movzbl %al, %r9d
andl $0x1, %r9d
callq 0x17250
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::AccessOutOfBound[abi:cxx11](cmatrix::Size, long, long)
static std::basic_string<char> AccessOutOfBound(Size bounds, long int row, long int column)
        {
            std::stringstream message;
            message << "Invalid attempt to access (" << row << ", " << column << ") which lies "
                    <<  "outside bounds [" << bounds.getRows() << ", " << bounds.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x1a0(%rbp), %rdi
leaq 0x54d47(%rip), %rsi     # 0x65a01
callq 0x6410
movq %rax, -0x1c8(%rbp)
jmp 0x10cc8
movq -0x1c8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6810
movq %rax, -0x1e0(%rbp)
jmp 0x10ce1
movq -0x1e0(%rbp), %rdi
leaq 0x58f48(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x1e8(%rbp)
jmp 0x10cfd
movq -0x1e8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6810
movq %rax, -0x1f0(%rbp)
jmp 0x10d16
movq -0x1f0(%rbp), %rdi
leaq 0x54cf9(%rip), %rsi     # 0x65a1d
callq 0x6410
movq %rax, -0x1f8(%rbp)
jmp 0x10d32
movq -0x1f8(%rbp), %rdi
leaq 0x54ceb(%rip), %rsi     # 0x65a2b
callq 0x6410
movq %rax, -0x200(%rbp)
jmp 0x10d4e
leaq -0x18(%rbp), %rdi
callq 0x10990
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x208(%rbp)
jmp 0x10d6f
movq -0x208(%rbp), %rdi
leaq 0x58eba(%rip), %rsi     # 0x69c37
callq 0x6410
movq %rax, -0x210(%rbp)
jmp 0x10d8b
leaq -0x18(%rbp), %rdi
callq 0x10b80
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0x6810
movq %rax, -0x218(%rbp)
jmp 0x10dac
movq -0x218(%rbp), %rdi
leaq 0x56da5(%rip), %rsi     # 0x67b5f
callq 0x6410
jmp 0x10dc1
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x63f0
jmp 0x10dd6
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1d0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
movq -0x1b8(%rbp), %rdi
callq 0x67c0
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/assignment.cpp
// Function: cmatrix::Matrix<double>::operator=(cmatrix::Matrix<double> const&)
Matrix<Type>& Matrix<Type>::operator = (const Matrix& otherMatrix)
{
    setSize(otherMatrix.rows(), otherMatrix.columns());

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            access(i, j) = otherMatrix.access(i, j);
        }
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10160
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10330
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x10660
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jge 0x11fd9
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jge 0x11fc6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x122e0
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10e80
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11f6b
jmp 0x11fc8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11f46
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/equality.cpp
// Function: cmatrix::Matrix<cmatrix::Matrix<double>>::equal(cmatrix::Matrix<cmatrix::Matrix<double>> const&) const
bool Matrix<Type>::equal(const Matrix& otherMatrix) const
{
    if (size != otherMatrix.size) {
        return false;
    }

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            if (access(i, j) != otherMatrix.access(i, j)) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq -0x18(%rbp), %rsi
callq 0x12600
testb $0x1, %al
jne 0x188cd
jmp 0x188d6
movb $0x0, -0x1(%rbp)
jmp 0x18a00
movq $0x0, -0x20(%rbp)
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x14450
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jge 0x189fc
movq $0x0, -0x28(%rbp)
movq -0x90(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x14470
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jge 0x189e9
movq -0x90(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x18a20
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x78(%rbp), %rdi
callq 0x18a20
jmp 0x18969
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x12d40
movb %al, -0xa1(%rbp)
jmp 0x1897e
leaq -0x78(%rbp), %rdi
callq 0x105f0
leaq -0x50(%rbp), %rdi
callq 0x105f0
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1899c
jmp 0x189d6
movb $0x0, -0x1(%rbp)
jmp 0x18a00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x189cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x105f0
leaq -0x50(%rbp), %rdi
callq 0x105f0
jmp 0x18a0e
jmp 0x189d8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x18910
jmp 0x189eb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x188de
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x67c0
nopw (%rax,%rax)
// File: chiku[P]cmatrix/src/impl/matrix/base.cpp
// Function: cmatrix::Matrix<cmatrix::Matrix<double>>::Matrix(cmatrix::Matrix<cmatrix::Matrix<double>> const&)
Matrix<Type>::Matrix(const Matrix& otherMatrix)
{
    setMatrixAsUnassigned();
    setSize(otherMatrix.rows(), otherMatrix.columns());

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            access(i, j) = otherMatrix.access(i, j);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10890
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
callq 0x141a0
movq -0x68(%rbp), %rdi
callq 0x141c0
movq -0x10(%rbp), %rdi
callq 0x14450
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14470
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x14200
movq $0x0, -0x18(%rbp)
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x14450
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jge 0x30a46
movq $0x0, -0x20(%rbp)
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x14470
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jge 0x30a33
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x18a20
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14dc0
movq %rax, -0x80(%rbp)
jmp 0x309f6
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11f00
jmp 0x30a05
leaq -0x48(%rbp), %rdi
callq 0x105f0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x309ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x105f0
jmp 0x30a4f
jmp 0x30a35
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x30984
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x67c0
nopl (%rax,%rax)
// File: chiku[P]cmatrix/src/impl/matrix/equality_with_tolerance.cpp
// Function: cmatrix::Matrix<double>::equalWithTolerance(cmatrix::Matrix<double> const&, double) const
bool Matrix<Type>::equalWithTolerance(const Matrix& otherMatrix, const Type tolerance) const
{
    if (size != otherMatrix.size) {
        return false;
    }

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            Type first = access(i, j), second = otherMatrix.access(i, j);
            if (((first - second) > tolerance) || (second - first) > tolerance) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x12600
testb $0x1, %al
jne 0x1a83c
jmp 0x1a845
movb $0x0, -0x1(%rbp)
jmp 0x1a911
movq $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x1a90d
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jge 0x1a8fa
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x122e0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x122e0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
ja 0x1a8e1
movsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x1a8e7
movb $0x0, -0x1(%rbp)
jmp 0x1a911
jmp 0x1a8e9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1a876
jmp 0x1a8fc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1a84d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/functionoid.cpp
// Function: cmatrix::Matrix<double> cmatrix::Matrix<double>::map<cmatrix::FunctionoidWithOneParameter*>(cmatrix::FunctionoidWithOneParameter*)
Matrix<Type> Matrix<Type>::map(FunctObj function)
{
    Matrix<Type> result(rows(), columns());
    for(int i = 0; i < rows(); i++) {
        for(int j = 0; j < columns(); j++) {
            result.access(i, j) = (*function)(access(i, j));
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x10160
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x10330
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x100e0
movl $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x10160
movq %rax, -0x58(%rbp)
jmp 0x1cdee
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1ceca
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x10330
movq %rax, -0x68(%rbp)
jmp 0x1ce1d
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1ceba
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq -0x20(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x10e80
movq %rax, -0x78(%rbp)
jmp 0x1ce4d
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movsd (%rax), %xmm0
callq 0x1cf00
movsd %xmm0, -0x88(%rbp)
jmp 0x1ce68
movq -0x40(%rbp), %rdi
movslq -0x20(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x10e80
movq %rax, -0x90(%rbp)
jmp 0x1ce82
movq -0x90(%rbp), %rax
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1ce06
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x105f0
jmp 0x1ceea
jmp 0x1cebc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1cdd7
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1cedd
movq -0x40(%rbp), %rdi
callq 0x105f0
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/functionoid.cpp
// Function: cmatrix::Matrix<double>& cmatrix::Matrix<double>::fillByPosition<cmatrix::FunctionoidWithTwoParameters*>(cmatrix::FunctionoidWithTwoParameters*, long, long)
Matrix<Type>& Matrix<Type>::fillByPosition(FunctObj function, long int xShift, long int yShift)
{
    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = (*function)(i - xShift, j - yShift);
        }
    }

    return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x10160
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jge 0x1cfe9
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10330
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jge 0x1cfd9
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movslq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm1
callq 0x1d0f0
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
movslq -0x24(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x10e80
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1cf6f
jmp 0x1cfdb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1cf47
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)