Boost::asio - асинхронный сервер не работает

Помогите разобраться, в асинхронном сервере с использованием библиотеки boost.

Имеем:

1. win 10 x64;
2. boost 1.88;
3. компилятор MSYS2 MINGW64;

Что непонятно: Не выполняется функция "processTheClientMessage" в коде ниже.

Код:

    #include <iostream>
#include <string>
#include <vector>
#include <memory> // Для std::shared_ptr
#include <array> // Для std::array
#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>

#include <thread>


class Session : public std::enable_shared_from_this <Session> {
    public:
        boost::asio::ip::tcp::socket m_socket;
        unsigned int m_sizeMessages = 1024;
        char m_cString [1024];

    public:
        explicit Session (boost::asio::ip::tcp::socket aSocket)
                    : m_socket (std::move (aSocket) ) {}

        ~Session () {
            std::cout << "~Session" << std::endl;
        }

    public:
        void processTheClientMessage (std::shared_ptr <Session> aSharedPtrToSession,
                                    Session* aSessionObject,
                                    const boost::system::error_code& aErrorCode) {

            if (aErrorCode.value() != 0) {
                // ...
            }
            else {
std::cout << "client message = " << std::string (m_cString, m_sizeMessages) << std::endl;
            }

            this->readFromSocket();
        }

        void readFromSocket () {
            auto self (shared_from_this());
            boost::system::error_code errorCode1;
            auto bindedProcessTheClientMessage = std::bind (&Session::processTheClientMessage,
                                            this,
                                            self,
                                            this,
                                            errorCode1);

            m_socket.async_read_some (boost::asio::buffer (m_cString, m_sizeMessages),
                                                    bindedProcessTheClientMessage);
        }
};






class Server {
    public:
        boost::asio::ip::tcp::endpoint m_endpoint;
        boost::asio::ip::tcp::acceptor m_acceptor;
        std::vector <std::shared_ptr <Session>> m_sharedPtrSessions;
        int m_sessionCounter;

    public:
        Server (boost::asio::io_context& aIoContext,
                    boost::asio::ip::address_v4 aIpAddressV4,
                    unsigned short aPort)
                : m_endpoint (aIpAddressV4, aPort),
                m_acceptor (aIoContext, m_endpoint) {
            // ...
            m_sessionCounter = 0;
        }

        ~Server () {
std::cout << "~Server" << std::endl;
        }

    public:
        void processTheConnection (std::shared_ptr <Server> aSharedPtrToServer,
                                    std::shared_ptr <boost::asio::ip::tcp::socket> aSharedPtrSocket,
                                    const boost::system::error_code& aErrorCode) {

            if (aErrorCode.value() != 0) {
                // ...
            }
            else {
                m_sharedPtrSessions.push_back (std::make_shared <Session> (std::move (*aSharedPtrSocket)) );
                m_sharedPtrSessions [m_sessionCounter] ->readFromSocket();
                ++m_sessionCounter;
            }

            this->startAccept ();
        }




        void startAccept() {
            std::shared_ptr <boost::asio::ip::tcp::socket> sharedPtrSocket1 (new boost::asio::ip::tcp::socket (m_acceptor.get_executor()) );
            std::shared_ptr <Server> sharedPtrToThisObject (this);
            boost::system::error_code errorCode1;
            auto bindedProcessTheConnection = std::bind (&Server::processTheConnection, this,
                                            sharedPtrToThisObject,
                                            sharedPtrSocket1,
                                            errorCode1);

            m_acceptor.async_accept (*sharedPtrSocket1, bindedProcessTheConnection);
        }
};







int main() {
    boost::asio::ip::address_v4 ipAddressV4;
    unsigned short port = 3333;

        try {
            boost::asio::io_context ioContext1;

            Server Server1 (ioContext1, ipAddressV4, port);
            Server1.startAccept ();

            ioContext1.run();
        }
        catch (std::exception& e) {
std::cerr << "Exception: " << e.what() << std::endl;
        }

    system ("pause");
    return 0;
}

Где я допустил ошибку ?